summaryrefslogtreecommitdiff
path: root/packages/qte/qte-2.3.12
diff options
context:
space:
mode:
authorMarcin Juszkiewicz <hrw@openembedded.org>2006-04-21 10:30:08 +0000
committerOpenEmbedded Project <openembedded-devel@lists.openembedded.org>2006-04-21 10:30:08 +0000
commit28f02967abbf61c832bd5713ee7c055e2c73eb19 (patch)
treefab6a9dab642c1e0ea3f78a5d0394c34a60397d2 /packages/qte/qte-2.3.12
parent2ae892dc300673b51fb9eb2515a3b0e4f14ae587 (diff)
added qt/e 2.3.12 as non-default, WIP
Diffstat (limited to 'packages/qte/qte-2.3.12')
-rw-r--r--packages/qte/qte-2.3.12/.mtn2git_empty0
-rw-r--r--packages/qte/qte-2.3.12/bidimetrics.patch2389
-rw-r--r--packages/qte/qte-2.3.12/c700-hardware.patch114
-rw-r--r--packages/qte/qte-2.3.12/c7x0-w100-accel.patch3414
-rw-r--r--packages/qte/qte-2.3.12/daemonize.patch115
-rw-r--r--packages/qte/qte-2.3.12/devfs.patch161
-rw-r--r--packages/qte/qte-2.3.12/encoding.patch36
-rw-r--r--packages/qte/qte-2.3.12/fix-linuxfb-offscreenoverflow.patch24
-rw-r--r--packages/qte/qte-2.3.12/fix-linuxfb-setmode.patch36
-rw-r--r--packages/qte/qte-2.3.12/fix-native-build.patch11
-rw-r--r--packages/qte/qte-2.3.12/fix-qgfxraster.patch30
-rw-r--r--packages/qte/qte-2.3.12/fix-qscreen-sync.patch17
-rw-r--r--packages/qte/qte-2.3.12/gcc3.patch27
-rw-r--r--packages/qte/qte-2.3.12/handhelds.patch66
-rw-r--r--packages/qte/qte-2.3.12/improve-calibration-r0.patch159
-rw-r--r--packages/qte/qte-2.3.12/increase-qxml-robustness.patch17
-rw-r--r--packages/qte/qte-2.3.12/ipaq-keyboard.patch27
-rw-r--r--packages/qte/qte-2.3.12/ipaq_sound_fix.patch60
-rw-r--r--packages/qte/qte-2.3.12/kernel-keymap-CXK.patch19
-rw-r--r--packages/qte/qte-2.3.12/kernel-keymap-corgi.patch25
-rw-r--r--packages/qte/qte-2.3.12/kernel-keymap-tosa.patch81
-rw-r--r--packages/qte/qte-2.3.12/kernel-keymap.patch1042
-rw-r--r--packages/qte/qte-2.3.12/key.patch90
-rw-r--r--packages/qte/qte-2.3.12/mnci-touchscreen.patch1987
-rw-r--r--packages/qte/qte-2.3.12/mnci.patch125
-rw-r--r--packages/qte/qte-2.3.12/no-moc.patch39
-rw-r--r--packages/qte/qte-2.3.12/qiconview-speed.patch122
-rw-r--r--packages/qte/qte-2.3.12/qpe.patch105
-rw-r--r--packages/qte/qte-2.3.12/qt-visibility.patch499
-rw-r--r--packages/qte/qte-2.3.12/qtabbar.patch41
-rw-r--r--packages/qte/qte-2.3.12/qte-fix-iconsize.patch105
-rw-r--r--packages/qte/qte-2.3.12/sharp_char.h309
-rw-r--r--packages/qte/qte-2.3.12/simpad-defaultkbd.patch13
-rw-r--r--packages/qte/qte-2.3.12/simpad.patch392
-rw-r--r--packages/qte/qte-2.3.12/suspend-resume-hooks.patch64
-rw-r--r--packages/qte/qte-2.3.12/switches.h74
-rw-r--r--packages/qte/qte-2.3.12/tslib.patch53
-rw-r--r--packages/qte/qte-2.3.12/vt-switch.patch184
38 files changed, 12072 insertions, 0 deletions
diff --git a/packages/qte/qte-2.3.12/.mtn2git_empty b/packages/qte/qte-2.3.12/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/qte/qte-2.3.12/.mtn2git_empty
diff --git a/packages/qte/qte-2.3.12/bidimetrics.patch b/packages/qte/qte-2.3.12/bidimetrics.patch
new file mode 100644
index 0000000000..ea4765c601
--- /dev/null
+++ b/packages/qte/qte-2.3.12/bidimetrics.patch
@@ -0,0 +1,2389 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxraster_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfxraster_qws.cpp 2006-01-20 20:50:26.577740040 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxraster_qws.cpp 2006-01-20 21:09:56.399900040 +0100
+@@ -51,6 +51,11 @@
+ #include <fcntl.h>
+ #include <errno.h>
+
++//HAQ bidi patch
++#ifdef USE_BIDI
++#include "qbidi.h"
++#endif
++// end HAQ patch
+
+ extern bool qws_sw_cursor;
+
+@@ -1408,6 +1413,53 @@
+ setAlphaType(BigEndianMask);
+ }
+
++#ifdef USE_BIDI
++ // HAQ do bidi
++ QString n;
++ qApplyBidi(s, n);
++
++ for( loopc=0; loopc < int(n.length()); loopc++ ) {
++ QGlyph glyph = memorymanager->lockGlyph(myfont, n[loopc]);
++ int myw=glyph.metrics->width;
++ srcwidth = myw;
++ srcheight = glyph.metrics->height;
++ setAlphaSource(glyph.data,glyph.metrics->linestep);
++ int myx=x;
++ int myy=y;
++ myx+=glyph.metrics->bearingx;
++ myy-=glyph.metrics->bearingy;
++
++ // HAQ hack to show arabic tashkeel (diacriticals) above
++ // the previous character (which in reversed arabic, as it is here, is the next character)
++
++ QChar c = n[loopc];
++ if (ISTASHKEEL(c.unicode())) {
++ //printf("glyph %d bearingx %d width %d advance %d\n",
++ // c.unicode(),glyph.metrics->bearingx, glyph.metrics->width, glyph.metrics->advance);
++
++ if (loopc < int(n.length()-1)) // if there is a following character then place this glyph over it
++ {
++ QGlyph nextGlyph = memorymanager->lockGlyph(myfont, n[loopc+1]);
++ int nextCharWidth = nextGlyph.metrics->width;
++ myx += nextCharWidth/2 - glyph.metrics->width;
++ // pre-undo the advance in x so that the next glyph is placed over this one
++ x -= glyph.metrics->advance;
++ }
++ }
++
++ if(glyph.metrics->width<1 || glyph.metrics->height<1
++ || glyph.metrics->linestep==0)
++ {
++ // non-printing characters
++ } else {
++ blt(myx,myy,myw,glyph.metrics->height,0,0);
++ }
++ x+=glyph.metrics->advance;
++ // ... unlock glyph
++ }
++
++#else
++
+ for( loopc=0; loopc < int(s.length()); loopc++ ) {
+ QGlyph glyph = memorymanager->lockGlyph(myfont, s[loopc]);
+ int myw=glyph.metrics->width;
+@@ -1428,6 +1480,9 @@
+ x+=glyph.metrics->advance;
+ // ... unlock glyph
+ }
++
++#endif
++
+ #ifdef DEBUG_LOCKS
+ qDebug("unaccelerated drawText unlock");
+ #endif
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qfont_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qfont_qws.cpp 2006-01-20 20:57:33.115896384 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qfont_qws.cpp 2006-01-20 21:09:56.400899888 +0100
+@@ -49,6 +49,12 @@
+ #include "qfontmanager_qws.h"
+ #include "qmemorymanager_qws.h"
+
++//HAQ
++#ifdef USE_BIDI
++#include "qbidi.h"
++#endif
++// end HAQ
++
+ // QFont_Private accesses QFont protected functions
+
+ class QFont_Private : public QFont
+@@ -388,17 +394,46 @@
+
+ int QFontMetrics::width( QChar ch ) const
+ {
++#ifdef USE_BIDI
++
++ int advance;
++ if (ISTASHKEEL(ch.unicode())) {
++ advance = 0;
++ }
++ else
++ advance = memorymanager->lockGlyphMetrics(((QFontMetrics*)this)->internal()->handle(),ch)->advance;
++ return advance;
++
++#else
++
+ return memorymanager->lockGlyphMetrics(((QFontMetrics*)this)->internal()->handle(),ch)->advance;
++
++#endif
+ }
+
+ int QFontMetrics::width( const QString &str, int len ) const
+ {
++#ifdef USE_BIDI
++
++ QString n;
++ qApplyBidi(str, n);
++ if (len < 0) len = n.length();
++ int ret=0;
++ for (int i=0; i<len; i++)
++ ret += width(n[i]);
++ return ret;
++
++#else
++
+ if ( len < 0 )
+ len = str.length();
+ int ret=0;
+ for (int i=0; i<len; i++)
+ ret += width(str[i]);
+ return ret;
++
++#endif
++
+ }
+
+ QRect QFontMetrics::boundingRect( const QString &str, int len ) const
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qbidi.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10-snapshot-20060120/src/kernel/qbidi.h 2006-01-20 21:09:56.400899888 +0100
+@@ -0,0 +1,6 @@
++#include "stdio.h"
++#include <qstring.h>
++
++#define ISTASHKEEL(x) ((x >= 0x64B && x<=0x658) || (x>=0x6d6 && x <= 0x6dc) || (x>=0x6df && x <= 0x6e4) || x==0x6e7 || x == 0x6e8 || (x>=0x6ea && x <= 0x6ed) || (x>=0xfe70 && x <= 0xfe7f))
++
++void qApplyBidi(const QString& s, QString& news);
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qbidi.cpp
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10-snapshot-20060120/src/kernel/qbidi.cpp 2006-01-20 21:09:56.401899736 +0100
+@@ -0,0 +1,45 @@
++#include <malloc.h>
++#include "qbidi.h"
++
++
++#define BLOCKTYPE unsigned short*
++#define CHARTYPE unsigned short
++
++extern "C" {
++
++int doShape(BLOCKTYPE line, CHARTYPE* to, int from, int count);
++int doBidi(BLOCKTYPE line, int count, int applyShape, int reorderCombining, int removeMarks);
++
++}
++
++void qApplyBidi(const QString& s, QString& news) {
++ //convert to utf16 zero-terminated
++ //printf(": qs length is %d\n",s.length());
++ int loopc;
++ int slength = sizeof(unsigned short) * (s.length());
++ //printf(": slength is %d\n",slength);
++ unsigned short* sutf16 = (unsigned short*)malloc(slength);
++ for( loopc=0; loopc < int(s.length()); loopc++ ) {
++ sutf16[loopc] = s[loopc].unicode();
++ //printf(": char %d is %x\n",loopc,sutf16[loopc]);
++ }
++ //printf(": mark 0\n");
++ ///sutf16[s.length()] = 0;
++
++ unsigned short* sutf16s = (unsigned short*)malloc(slength);
++ doShape(sutf16,sutf16s,0,s.length());
++ //printf(": do bidi\n");
++ doBidi(sutf16s, s.length(),0,0,0);
++ //sutf16s[s.length()] = 0;
++
++ //printf(": back to QString\n");
++ news = "";
++ for( loopc=0; loopc < s.length(); loopc++ ) {
++ QChar newChar((short) sutf16s[loopc]);
++ news = news + newChar;
++ //printf(": add char %x\n",newChar.unicode());
++ }
++
++ free(sutf16);
++ free(sutf16s);
++}
+Index: qt-2.3.10-snapshot-20060120/src/kernel/minibidi.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10-snapshot-20060120/src/kernel/minibidi.c 2006-01-20 21:09:56.403899432 +0100
+@@ -0,0 +1,2127 @@
++/************************************************************************
++ * $Id: minibidi.c,v 1.2 2005/04/08 18:01:45 lynch Exp $
++ *
++ * ------------
++ * Description:
++ * ------------
++ * This is an implemention of Unicode's Bidirectional Algorithm
++ * (known as UAX #9).
++ *
++ * http://www.unicode.org/reports/tr9/
++ *
++ * Author: Ahmad Khalifa
++ *
++ * -----------------
++ * Revision Details: (Updated by Revision Control System)
++ * -----------------
++ * $Date: 2005/04/08 18:01:45 $
++ * $Author: lynch $
++ * $Revision: 1.2 $
++ * $Source: /home/arabeyes/cvs/projects/external/qt_e/minibidi.c,v $
++ *
++ * (www.arabeyes.org - under MIT license)
++ *
++ ************************************************************************/
++
++#include <malloc.h> /* malloc() and free() definition */
++
++/*
++ * Datatype Extension Macros
++ */
++#define BLOCKTYPE unsigned short*
++#define CHARTYPE unsigned short
++#define GETCHAR(from,i) from[i]
++
++#define GetType(x) getType(x)
++/*=====TESTING mode===========*/
++//#define GetType(x) getCAPRtl(x)
++
++#define lenof(x) sizeof(x) / sizeof(x[0])
++
++/* character types */
++enum
++{
++ /* Strong Char Types */
++ L, /* Left-to-Right char */
++ LRE, /* Left-to-Right Embedding */
++ LRO, /* Left-to-Right Override */
++ R, /* Right-to-Left char */
++ AL, /* Right-to-Left Arabic char */
++ RLE, /* Right-to-Left Embedding */
++ RLO, /* Right-to-Left Override */
++ /* Weak Char Types */
++ PDF, /* Pop Directional Format */
++ EN, /* European Number */
++ ES, /* European Number Separator */
++ ET, /* European Number Terminator */
++ AN, /* Arabic Number */
++ CS, /* Common Number Separator */
++ NSM, /* Non Spacing Mark */
++ BN, /* Boundary Neutral */
++ /* Neutral Char Types */
++ B, /* Paragraph Separator */
++ S, /* Segment Separator */
++ WS, /* Whitespace */
++ ON, /* Other Neutrals */
++};
++
++/* Shaping Types */
++enum
++{
++ SL, /* Left-Joining, doesnt exist in U+0600 - U+06FF */
++ SR, /* Right-Joining, ie has Isolated, Final */
++ SD, /* Dual-Joining, ie has Isolated, Final, Initial, Medial */
++ SU, /* Non-Joining */
++ SC /* Join-Causing, like U+0640 (TATWEEL) */
++};
++
++#define odd(x) (x%2)
++/* Returns the first odd/even value greater than x */
++#define leastGreaterOdd(x) odd(x) ? (x+2) : (x+1)
++#define leastGreaterEven(x) odd(x) ? (x+1) : (x+2)
++
++/* Shaping Helpers */
++#define STYPE(xh) ((xh >= SHAPE_FIRST) && (xh <= SHAPE_LAST)) ? \
++ shapetypes[xh-SHAPE_FIRST].type : SU
++#define SISOLATED(xh) shapetypes[xh-SHAPE_FIRST].form_b
++#define SFINAL(xh) xh+1
++#define SINITIAL(xh) xh+2
++#define SMEDIAL(xh) xh+3
++
++
++/* function declarations */
++int findIndexOfRun(unsigned char* level , int start, int count, int tlevel);
++unsigned char getType(CHARTYPE ch);
++unsigned char getCAPRtl(CHARTYPE ch);
++void doMirror(BLOCKTYPE ch);
++
++typedef struct{
++ unsigned char type;
++ unsigned short form_b;
++} shape_node;
++
++/* Kept near the actual table, for verification. */
++#define SHAPE_FIRST 0x621
++#define SHAPE_LAST 0x668
++/* very bad Memory alignment for 32-bit machines
++ * could split it to 2 arrays or promote type to 2 bytes type
++ */
++shape_node shapetypes[] = {
++/* index, Typ, Iso */
++/* 621 */ {SU, 0xFE80},
++/* 622 */ {SR, 0xFE81},
++/* 623 */ {SR, 0xFE83},
++/* 624 */ {SR, 0xFE85},
++/* 625 */ {SR, 0xFE87},
++/* 626 */ {SD, 0xFE89},
++/* 627 */ {SR, 0xFE8D},
++/* 628 */ {SD, 0xFE8F},
++/* 629 */ {SR, 0xFE93},
++/* 62A */ {SD, 0xFE95},
++/* 62B */ {SD, 0xFE99},
++/* 62C */ {SD, 0xFE9D},
++/* 62D */ {SD, 0xFEA1},
++/* 62E */ {SD, 0xFEA5},
++/* 62F */ {SR, 0xFEA9},
++/* 630 */ {SR, 0xFEAB},
++/* 631 */ {SR, 0xFEAD},
++/* 632 */ {SR, 0xFEAF},
++/* 633 */ {SD, 0xFEB1},
++/* 634 */ {SD, 0xFEB5},
++/* 635 */ {SD, 0xFEB9},
++/* 636 */ {SD, 0xFEBD},
++/* 637 */ {SD, 0xFEC1},
++/* 638 */ {SD, 0xFEC5},
++/* 639 */ {SD, 0xFEC9},
++/* 63A */ {SD, 0xFECD},
++/* 63B */ {SU, 0x0},
++/* 63C */ {SU, 0x0},
++/* 63D */ {SU, 0x0},
++/* 63E */ {SU, 0x0},
++/* 63F */ {SU, 0x0},
++/* 640 */ {SC, 0x0},
++/* 641 */ {SD, 0xFED1},
++/* 642 */ {SD, 0xFED5},
++/* 643 */ {SD, 0xFED9},
++/* 644 */ {SD, 0xFEDD},
++/* 645 */ {SD, 0xFEE1},
++/* 646 */ {SD, 0xFEE5},
++/* 647 */ {SD, 0xFEE9},
++/* 648 */ {SR, 0xFEED},
++/* 649 */ {SR, 0xFEEF}, /* SD */
++/* 64A */ {SD, 0xFEF1},
++/* 64B */ {SU, 0xFEF1},
++/* 64C */ {SU, 0xFEF1},
++/* 64D */ {SU, 0xFEF1},
++/* 64E */ {SU, 0xFEF1},
++/* 64F */ {SU, 0xFEF1},
++/* 650 */ {SU,0xFEF1},
++/* 651 */ {SU,0xFEF1},
++/* 652 */ {SU,0xFEF1},
++/* 653 */ {SU, 0xFEF1},
++/* 654 */ {SU, 0xFEF1},
++/* 655 */ {SU, 0xFEF1},
++/* 656 */ {SU, 0xFEF1},
++/* 657 */ {SU, 0xFEF1},
++/* 658 */ {SU, 0xFEF1},
++/* 659 */ {SU, 0xFEF1},
++/* 65a */ {SU, 0xFEF1},
++/* 65b */ {SU, 0xFEF1},
++/* 65c */ {SU, 0xFEF1},
++/* 65d */ {SU, 0xFEF1},
++/* 65e */ {SU, 0xFEF1},
++/* 65f */ {SU, 0xFEF1},
++/* 660 */ {SU, 0xFEF1},
++/* 661 */ {SU, 0xFEF1},
++/* 662 */ {SU, 0xFEF1},
++/* 663 */ {SU, 0xFEF1},
++/* 664 */ {SU, 0xFEF1},
++/* 665 */ {SU, 0xFEF1},
++/* 666 */ {SU, 0xFEF1},
++/* 667 */ {SU, 0xFEF1},
++/* 668 */ {SU, 0xFEF1}
++};
++
++/*
++ * Flips the text buffer, according to max level, and
++ * all higher levels
++ *
++ * Input:
++ * from: text buffer, on which to apply flipping
++ * level: resolved levels buffer
++ * max: the maximum level found in this line (should be unsigned char)
++ * count: line size in wchar_t
++ */
++void flipThisRun(BLOCKTYPE from, unsigned char* level, int max, int count)
++{
++ int i, j, rcount, tlevel;
++ CHARTYPE temp;
++
++
++ j = i = 0;
++ while(i<count && j<count)
++ {
++
++ /* find the start of the run of level=max */
++ tlevel = max;
++ i = j = findIndexOfRun(level, i, count, max);
++ /* find the end of the run */
++ while((tlevel <= level[i]) && (i < count))
++ {
++ i++;
++ }
++ rcount = i-j;
++ for(; rcount>((i-j)/2); rcount--)
++ {
++ temp = GETCHAR(from, j+rcount-1);
++ GETCHAR(from, j+rcount-1) = GETCHAR(from, i-rcount);
++ GETCHAR(from, i-rcount) = temp;
++ }
++ }
++}
++
++/*
++ * Finds the index of a run with level equals tlevel
++ */
++int findIndexOfRun(unsigned char* level , int start, int count, int tlevel)
++{
++ int i;
++ for(i=start; i<count; i++)
++ {
++ if(tlevel <= level[i])
++ {
++ return i;
++ }
++ }
++ return count;
++}
++
++unsigned char GetParagraphLevel(BLOCKTYPE line, int count)
++{
++ int i;
++ for( i=0; i<count ; i++)
++ {
++ if(GetType(GETCHAR(line, i)) == R || GetType(/*line[i]*/ GETCHAR(line, i)) == AL)
++ return 1;
++ else if(GetType(GETCHAR(line, i)) == L)
++ return 0;
++ }
++ return 0; /* Compiler Nag-Stopper */
++}
++
++/*
++ * Returns character type of ch, by calling RLE table lookup
++ * function
++ */
++unsigned char getCAPRtl(CHARTYPE ch)
++{
++/* CAPRtl Charset */
++int TypesFromChar[] =
++{
++//0 1 2 3 4 5 6 7 8 9 a b c d e f
++ ON, ON, ON, ON, L, R, ON, ON, ON, ON, ON, ON, ON, B, RLO,RLE, /*00-0f*/
++ LRO,LRE,PDF,WS, ON, ON, ON, ON, ON, ON, ON, ON, ON, ON, ON, ON, /*10-1f*/
++
++ WS, ON, ON, ON, ET, ON, ON, ON, ON, ON, ON, ET, CS, ON, ES, ES, /*20-2f*/
++ EN, EN, EN, EN, EN, EN, AN, AN, AN, AN, LRE, RLE, RLO, PDF, LRO, ON, /*30-3f*/
++ R, AL, AL, AL, AL, AL, AL, R, R, R, R, R, R, R, R, R, /*40-4f*/
++ R, R, R, R, R, R, R, R, R, R, R, ON, B, ON, ON, ON, /*50-5f*/
++ NSM, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, /*60-6f*/
++ L, L, L, L, L, L, L, L, L, L, L, ON, S, ON, ON, ON, /*70-7f*/
++};
++
++//0 1 2 3 4 5 6 7 8 9 a b c d e f
++// ON, ON, ON, ON, L, R, ON, ON, ON, ON, ON, ON, ON, B, RLO,RLE, /*00-0f*/
++//LRO,LRE,PDF,WS, ON, ON, ON, ON, ON, ON, ON, ON, ON, ON, ON, ON, /*10-1f*/
++
++// WS, ON, ON, ON, ET, ON, ON, ON, ON, ON, ON, ET, CS, ON, ES, ES, /*20-2f*/
++// EN, EN, EN, EN, EN, EN, AN, AN, AN, AN, CS, ON, ON, ON, ON, ON, /*30-3f*/
++// R, AL, AL, AL, AL, AL, AL, R, R, R, R, R, R, R, R, R, /*40-4f*/
++// R, R, R, R, R, R, R, R, R, R, R, ON, B, ON, ON, ON, /*50-5f*/
++// NSM, L, L, L, L, L, L, L, L, L, L, L, L, L, L, L, /*60-6f*/
++// L, L, L, L, L, L, L, L, L, L, L, ON, S, ON, ON, ON, /*70-7f*/
++//};
++ if(ch <0x7f)
++ return TypesFromChar[ch];
++ else
++ return R;
++}
++
++unsigned char getType(CHARTYPE ch)
++{
++ static const struct {
++ CHARTYPE first, last, type;
++ } lookup[] = {
++ {0x0000, 0x0008, BN},
++ {0x0009, 0x0009, S},
++ {0x000a, 0x000a, B},
++ {0x000b, 0x000b, S},
++ {0x000c, 0x000c, WS},
++ {0x000d, 0x000d, B},
++ {0x000e, 0x001b, BN},
++ {0x001c, 0x001e, B},
++ {0x001f, 0x001f, S},
++ {0x0020, 0x0020, WS},
++ {0x0023, 0x0025, ET},
++ {0x002b, 0x002b, ES},
++ {0x002c, 0x002c, CS},
++ {0x002d, 0x002d, ES},
++ {0x002e, 0x002f, CS},
++ {0x0030, 0x0039, EN},
++ {0x003a, 0x003a, CS},
++ {0x0041, 0x005a, L},
++ {0x0061, 0x007a, L},
++ {0x007f, 0x0084, BN},
++ {0x0085, 0x0085, B},
++ {0x0086, 0x009f, BN},
++ {0x00a0, 0x00a0, CS},
++ {0x00a2, 0x00a5, ET},
++ {0x00aa, 0x00aa, L},
++ {0x00ad, 0x00ad, BN},
++ {0x00b0, 0x00b1, ET},
++ {0x00b2, 0x00b3, EN},
++ {0x00b5, 0x00b5, L},
++ {0x00b9, 0x00b9, EN},
++ {0x00ba, 0x00ba, L},
++ {0x00c0, 0x00d6, L},
++ {0x00d8, 0x00f6, L},
++ {0x00f8, 0x0236, L},
++ {0x0250, 0x02b8, L},
++ {0x02bb, 0x02c1, L},
++ {0x02d0, 0x02d1, L},
++ {0x02e0, 0x02e4, L},
++ {0x02ee, 0x02ee, L},
++ {0x0300, 0x0357, NSM},
++ {0x035d, 0x036f, NSM},
++ {0x037a, 0x037a, L},
++ {0x0386, 0x0386, L},
++ {0x0388, 0x038a, L},
++ {0x038c, 0x038c, L},
++ {0x038e, 0x03a1, L},
++ {0x03a3, 0x03ce, L},
++ {0x03d0, 0x03f5, L},
++ {0x03f7, 0x03fb, L},
++ {0x0400, 0x0482, L},
++ {0x0483, 0x0486, NSM},
++ {0x0488, 0x0489, NSM},
++ {0x048a, 0x04ce, L},
++ {0x04d0, 0x04f5, L},
++ {0x04f8, 0x04f9, L},
++ {0x0500, 0x050f, L},
++ {0x0531, 0x0556, L},
++ {0x0559, 0x055f, L},
++ {0x0561, 0x0587, L},
++ {0x0589, 0x0589, L},
++ {0x0591, 0x05a1, NSM},
++ {0x05a3, 0x05b9, NSM},
++ {0x05bb, 0x05bd, NSM},
++ {0x05be, 0x05be, R},
++ {0x05bf, 0x05bf, NSM},
++ {0x05c0, 0x05c0, R},
++ {0x05c1, 0x05c2, NSM},
++ {0x05c3, 0x05c3, R},
++ {0x05c4, 0x05c4, NSM},
++ {0x05d0, 0x05ea, R},
++ {0x05f0, 0x05f4, R},
++ {0x0600, 0x0603, AL},
++ {0x060c, 0x060c, CS},
++ {0x060d, 0x060d, AL},
++ {0x0610, 0x0615, NSM},
++ {0x061b, 0x061b, AL},
++ {0x061f, 0x061f, AL},
++ {0x0621, 0x063a, AL},
++ {0x0640, 0x064a, AL},
++ {0x064b, 0x0658, NSM},
++ {0x0660, 0x0669, AN},
++ {0x066a, 0x066a, ET},
++ {0x066b, 0x066c, AN},
++ {0x066d, 0x066f, AL},
++ {0x0670, 0x0670, NSM},
++ {0x0671, 0x06d5, AL},
++ {0x06d6, 0x06dc, NSM},
++ {0x06dd, 0x06dd, AL},
++ {0x06de, 0x06e4, NSM},
++ {0x06e5, 0x06e6, AL},
++ {0x06e7, 0x06e8, NSM},
++ {0x06ea, 0x06ed, NSM},
++ {0x06ee, 0x06ef, AL},
++ {0x06f0, 0x06f9, EN},
++ {0x06fa, 0x070d, AL},
++ {0x070f, 0x070f, BN},
++ {0x0710, 0x0710, AL},
++ {0x0711, 0x0711, NSM},
++ {0x0712, 0x072f, AL},
++ {0x0730, 0x074a, NSM},
++ {0x074d, 0x074f, AL},
++ {0x0780, 0x07a5, AL},
++ {0x07a6, 0x07b0, NSM},
++ {0x07b1, 0x07b1, AL},
++ {0x0901, 0x0902, NSM},
++ {0x0903, 0x0939, L},
++ {0x093c, 0x093c, NSM},
++ {0x093d, 0x0940, L},
++ {0x0941, 0x0948, NSM},
++ {0x0949, 0x094c, L},
++ {0x094d, 0x094d, NSM},
++ {0x0950, 0x0950, L},
++ {0x0951, 0x0954, NSM},
++ {0x0958, 0x0961, L},
++ {0x0962, 0x0963, NSM},
++ {0x0964, 0x0970, L},
++ {0x0981, 0x0981, NSM},
++ {0x0982, 0x0983, L},
++ {0x0985, 0x098c, L},
++ {0x098f, 0x0990, L},
++ {0x0993, 0x09a8, L},
++ {0x09aa, 0x09b0, L},
++ {0x09b2, 0x09b2, L},
++ {0x09b6, 0x09b9, L},
++ {0x09bc, 0x09bc, NSM},
++ {0x09bd, 0x09c0, L},
++ {0x09c1, 0x09c4, NSM},
++ {0x09c7, 0x09c8, L},
++ {0x09cb, 0x09cc, L},
++ {0x09cd, 0x09cd, NSM},
++ {0x09d7, 0x09d7, L},
++ {0x09dc, 0x09dd, L},
++ {0x09df, 0x09e1, L},
++ {0x09e2, 0x09e3, NSM},
++ {0x09e6, 0x09f1, L},
++ {0x09f2, 0x09f3, ET},
++ {0x09f4, 0x09fa, L},
++ {0x0a01, 0x0a02, NSM},
++ {0x0a03, 0x0a03, L},
++ {0x0a05, 0x0a0a, L},
++ {0x0a0f, 0x0a10, L},
++ {0x0a13, 0x0a28, L},
++ {0x0a2a, 0x0a30, L},
++ {0x0a32, 0x0a33, L},
++ {0x0a35, 0x0a36, L},
++ {0x0a38, 0x0a39, L},
++ {0x0a3c, 0x0a3c, NSM},
++ {0x0a3e, 0x0a40, L},
++ {0x0a41, 0x0a42, NSM},
++ {0x0a47, 0x0a48, NSM},
++ {0x0a4b, 0x0a4d, NSM},
++ {0x0a59, 0x0a5c, L},
++ {0x0a5e, 0x0a5e, L},
++ {0x0a66, 0x0a6f, L},
++ {0x0a70, 0x0a71, NSM},
++ {0x0a72, 0x0a74, L},
++ {0x0a81, 0x0a82, NSM},
++ {0x0a83, 0x0a83, L},
++ {0x0a85, 0x0a8d, L},
++ {0x0a8f, 0x0a91, L},
++ {0x0a93, 0x0aa8, L},
++ {0x0aaa, 0x0ab0, L},
++ {0x0ab2, 0x0ab3, L},
++ {0x0ab5, 0x0ab9, L},
++ {0x0abc, 0x0abc, NSM},
++ {0x0abd, 0x0ac0, L},
++ {0x0ac1, 0x0ac5, NSM},
++ {0x0ac7, 0x0ac8, NSM},
++ {0x0ac9, 0x0ac9, L},
++ {0x0acb, 0x0acc, L},
++ {0x0acd, 0x0acd, NSM},
++ {0x0ad0, 0x0ad0, L},
++ {0x0ae0, 0x0ae1, L},
++ {0x0ae2, 0x0ae3, NSM},
++ {0x0ae6, 0x0aef, L},
++ {0x0af1, 0x0af1, ET},
++ {0x0b01, 0x0b01, NSM},
++ {0x0b02, 0x0b03, L},
++ {0x0b05, 0x0b0c, L},
++ {0x0b0f, 0x0b10, L},
++ {0x0b13, 0x0b28, L},
++ {0x0b2a, 0x0b30, L},
++ {0x0b32, 0x0b33, L},
++ {0x0b35, 0x0b39, L},
++ {0x0b3c, 0x0b3c, NSM},
++ {0x0b3d, 0x0b3e, L},
++ {0x0b3f, 0x0b3f, NSM},
++ {0x0b40, 0x0b40, L},
++ {0x0b41, 0x0b43, NSM},
++ {0x0b47, 0x0b48, L},
++ {0x0b4b, 0x0b4c, L},
++ {0x0b4d, 0x0b4d, NSM},
++ {0x0b56, 0x0b56, NSM},
++ {0x0b57, 0x0b57, L},
++ {0x0b5c, 0x0b5d, L},
++ {0x0b5f, 0x0b61, L},
++ {0x0b66, 0x0b71, L},
++ {0x0b82, 0x0b82, NSM},
++ {0x0b83, 0x0b83, L},
++ {0x0b85, 0x0b8a, L},
++ {0x0b8e, 0x0b90, L},
++ {0x0b92, 0x0b95, L},
++ {0x0b99, 0x0b9a, L},
++ {0x0b9c, 0x0b9c, L},
++ {0x0b9e, 0x0b9f, L},
++ {0x0ba3, 0x0ba4, L},
++ {0x0ba8, 0x0baa, L},
++ {0x0bae, 0x0bb5, L},
++ {0x0bb7, 0x0bb9, L},
++ {0x0bbe, 0x0bbf, L},
++ {0x0bc0, 0x0bc0, NSM},
++ {0x0bc1, 0x0bc2, L},
++ {0x0bc6, 0x0bc8, L},
++ {0x0bca, 0x0bcc, L},
++ {0x0bcd, 0x0bcd, NSM},
++ {0x0bd7, 0x0bd7, L},
++ {0x0be7, 0x0bf2, L},
++ {0x0bf9, 0x0bf9, ET},
++ {0x0c01, 0x0c03, L},
++ {0x0c05, 0x0c0c, L},
++ {0x0c0e, 0x0c10, L},
++ {0x0c12, 0x0c28, L},
++ {0x0c2a, 0x0c33, L},
++ {0x0c35, 0x0c39, L},
++ {0x0c3e, 0x0c40, NSM},
++ {0x0c41, 0x0c44, L},
++ {0x0c46, 0x0c48, NSM},
++ {0x0c4a, 0x0c4d, NSM},
++ {0x0c55, 0x0c56, NSM},
++ {0x0c60, 0x0c61, L},
++ {0x0c66, 0x0c6f, L},
++ {0x0c82, 0x0c83, L},
++ {0x0c85, 0x0c8c, L},
++ {0x0c8e, 0x0c90, L},
++ {0x0c92, 0x0ca8, L},
++ {0x0caa, 0x0cb3, L},
++ {0x0cb5, 0x0cb9, L},
++ {0x0cbc, 0x0cbc, NSM},
++ {0x0cbd, 0x0cc4, L},
++ {0x0cc6, 0x0cc8, L},
++ {0x0cca, 0x0ccb, L},
++ {0x0ccc, 0x0ccd, NSM},
++ {0x0cd5, 0x0cd6, L},
++ {0x0cde, 0x0cde, L},
++ {0x0ce0, 0x0ce1, L},
++ {0x0ce6, 0x0cef, L},
++ {0x0d02, 0x0d03, L},
++ {0x0d05, 0x0d0c, L},
++ {0x0d0e, 0x0d10, L},
++ {0x0d12, 0x0d28, L},
++ {0x0d2a, 0x0d39, L},
++ {0x0d3e, 0x0d40, L},
++ {0x0d41, 0x0d43, NSM},
++ {0x0d46, 0x0d48, L},
++ {0x0d4a, 0x0d4c, L},
++ {0x0d4d, 0x0d4d, NSM},
++ {0x0d57, 0x0d57, L},
++ {0x0d60, 0x0d61, L},
++ {0x0d66, 0x0d6f, L},
++ {0x0d82, 0x0d83, L},
++ {0x0d85, 0x0d96, L},
++ {0x0d9a, 0x0db1, L},
++ {0x0db3, 0x0dbb, L},
++ {0x0dbd, 0x0dbd, L},
++ {0x0dc0, 0x0dc6, L},
++ {0x0dca, 0x0dca, NSM},
++ {0x0dcf, 0x0dd1, L},
++ {0x0dd2, 0x0dd4, NSM},
++ {0x0dd6, 0x0dd6, NSM},
++ {0x0dd8, 0x0ddf, L},
++ {0x0df2, 0x0df4, L},
++ {0x0e01, 0x0e30, L},
++ {0x0e31, 0x0e31, NSM},
++ {0x0e32, 0x0e33, L},
++ {0x0e34, 0x0e3a, NSM},
++ {0x0e3f, 0x0e3f, ET},
++ {0x0e40, 0x0e46, L},
++ {0x0e47, 0x0e4e, NSM},
++ {0x0e4f, 0x0e5b, L},
++ {0x0e81, 0x0e82, L},
++ {0x0e84, 0x0e84, L},
++ {0x0e87, 0x0e88, L},
++ {0x0e8a, 0x0e8a, L},
++ {0x0e8d, 0x0e8d, L},
++ {0x0e94, 0x0e97, L},
++ {0x0e99, 0x0e9f, L},
++ {0x0ea1, 0x0ea3, L},
++ {0x0ea5, 0x0ea5, L},
++ {0x0ea7, 0x0ea7, L},
++ {0x0eaa, 0x0eab, L},
++ {0x0ead, 0x0eb0, L},
++ {0x0eb1, 0x0eb1, NSM},
++ {0x0eb2, 0x0eb3, L},
++ {0x0eb4, 0x0eb9, NSM},
++ {0x0ebb, 0x0ebc, NSM},
++ {0x0ebd, 0x0ebd, L},
++ {0x0ec0, 0x0ec4, L},
++ {0x0ec6, 0x0ec6, L},
++ {0x0ec8, 0x0ecd, NSM},
++ {0x0ed0, 0x0ed9, L},
++ {0x0edc, 0x0edd, L},
++ {0x0f00, 0x0f17, L},
++ {0x0f18, 0x0f19, NSM},
++ {0x0f1a, 0x0f34, L},
++ {0x0f35, 0x0f35, NSM},
++ {0x0f36, 0x0f36, L},
++ {0x0f37, 0x0f37, NSM},
++ {0x0f38, 0x0f38, L},
++ {0x0f39, 0x0f39, NSM},
++ {0x0f3e, 0x0f47, L},
++ {0x0f49, 0x0f6a, L},
++ {0x0f71, 0x0f7e, NSM},
++ {0x0f7f, 0x0f7f, L},
++ {0x0f80, 0x0f84, NSM},
++ {0x0f85, 0x0f85, L},
++ {0x0f86, 0x0f87, NSM},
++ {0x0f88, 0x0f8b, L},
++ {0x0f90, 0x0f97, NSM},
++ {0x0f99, 0x0fbc, NSM},
++ {0x0fbe, 0x0fc5, L},
++ {0x0fc6, 0x0fc6, NSM},
++ {0x0fc7, 0x0fcc, L},
++ {0x0fcf, 0x0fcf, L},
++ {0x1000, 0x1021, L},
++ {0x1023, 0x1027, L},
++ {0x1029, 0x102a, L},
++ {0x102c, 0x102c, L},
++ {0x102d, 0x1030, NSM},
++ {0x1031, 0x1031, L},
++ {0x1032, 0x1032, NSM},
++ {0x1036, 0x1037, NSM},
++ {0x1038, 0x1038, L},
++ {0x1039, 0x1039, NSM},
++ {0x1040, 0x1057, L},
++ {0x1058, 0x1059, NSM},
++ {0x10a0, 0x10c5, L},
++ {0x10d0, 0x10f8, L},
++ {0x10fb, 0x10fb, L},
++ {0x1100, 0x1159, L},
++ {0x115f, 0x11a2, L},
++ {0x11a8, 0x11f9, L},
++ {0x1200, 0x1206, L},
++ {0x1208, 0x1246, L},
++ {0x1248, 0x1248, L},
++ {0x124a, 0x124d, L},
++ {0x1250, 0x1256, L},
++ {0x1258, 0x1258, L},
++ {0x125a, 0x125d, L},
++ {0x1260, 0x1286, L},
++ {0x1288, 0x1288, L},
++ {0x128a, 0x128d, L},
++ {0x1290, 0x12ae, L},
++ {0x12b0, 0x12b0, L},
++ {0x12b2, 0x12b5, L},
++ {0x12b8, 0x12be, L},
++ {0x12c0, 0x12c0, L},
++ {0x12c2, 0x12c5, L},
++ {0x12c8, 0x12ce, L},
++ {0x12d0, 0x12d6, L},
++ {0x12d8, 0x12ee, L},
++ {0x12f0, 0x130e, L},
++ {0x1310, 0x1310, L},
++ {0x1312, 0x1315, L},
++ {0x1318, 0x131e, L},
++ {0x1320, 0x1346, L},
++ {0x1348, 0x135a, L},
++ {0x1361, 0x137c, L},
++ {0x13a0, 0x13f4, L},
++ {0x1401, 0x1676, L},
++ {0x1680, 0x1680, WS},
++ {0x1681, 0x169a, L},
++ {0x16a0, 0x16f0, L},
++ {0x1700, 0x170c, L},
++ {0x170e, 0x1711, L},
++ {0x1712, 0x1714, NSM},
++ {0x1720, 0x1731, L},
++ {0x1732, 0x1734, NSM},
++ {0x1735, 0x1736, L},
++ {0x1740, 0x1751, L},
++ {0x1752, 0x1753, NSM},
++ {0x1760, 0x176c, L},
++ {0x176e, 0x1770, L},
++ {0x1772, 0x1773, NSM},
++ {0x1780, 0x17b6, L},
++ {0x17b7, 0x17bd, NSM},
++ {0x17be, 0x17c5, L},
++ {0x17c6, 0x17c6, NSM},
++ {0x17c7, 0x17c8, L},
++ {0x17c9, 0x17d3, NSM},
++ {0x17d4, 0x17da, L},
++ {0x17db, 0x17db, ET},
++ {0x17dc, 0x17dc, L},
++ {0x17dd, 0x17dd, NSM},
++ {0x17e0, 0x17e9, L},
++ {0x180b, 0x180d, NSM},
++ {0x180e, 0x180e, WS},
++ {0x1810, 0x1819, L},
++ {0x1820, 0x1877, L},
++ {0x1880, 0x18a8, L},
++ {0x18a9, 0x18a9, NSM},
++ {0x1900, 0x191c, L},
++ {0x1920, 0x1922, NSM},
++ {0x1923, 0x1926, L},
++ {0x1927, 0x192b, NSM},
++ {0x1930, 0x1931, L},
++ {0x1932, 0x1932, NSM},
++ {0x1933, 0x1938, L},
++ {0x1939, 0x193b, NSM},
++ {0x1946, 0x196d, L},
++ {0x1970, 0x1974, L},
++ {0x1d00, 0x1d6b, L},
++ {0x1e00, 0x1e9b, L},
++ {0x1ea0, 0x1ef9, L},
++ {0x1f00, 0x1f15, L},
++ {0x1f18, 0x1f1d, L},
++ {0x1f20, 0x1f45, L},
++ {0x1f48, 0x1f4d, L},
++ {0x1f50, 0x1f57, L},
++ {0x1f59, 0x1f59, L},
++ {0x1f5b, 0x1f5b, L},
++ {0x1f5d, 0x1f5d, L},
++ {0x1f5f, 0x1f7d, L},
++ {0x1f80, 0x1fb4, L},
++ {0x1fb6, 0x1fbc, L},
++ {0x1fbe, 0x1fbe, L},
++ {0x1fc2, 0x1fc4, L},
++ {0x1fc6, 0x1fcc, L},
++ {0x1fd0, 0x1fd3, L},
++ {0x1fd6, 0x1fdb, L},
++ {0x1fe0, 0x1fec, L},
++ {0x1ff2, 0x1ff4, L},
++ {0x1ff6, 0x1ffc, L},
++ {0x2000, 0x200a, WS},
++ {0x200b, 0x200d, BN},
++ {0x200e, 0x200e, L},
++ {0x200f, 0x200f, R},
++ {0x2028, 0x2028, WS},
++ {0x2029, 0x2029, B},
++ {0x202a, 0x202a, LRE},
++ {0x202b, 0x202b, RLE},
++ {0x202c, 0x202c, PDF},
++ {0x202d, 0x202d, LRO},
++ {0x202e, 0x202e, RLO},
++ {0x202f, 0x202f, WS},
++ {0x2030, 0x2034, ET},
++ {0x2044, 0x2044, CS},
++ {0x205f, 0x205f, WS},
++ {0x2060, 0x2063, BN},
++ {0x206a, 0x206f, BN},
++ {0x2070, 0x2070, EN},
++ {0x2071, 0x2071, L},
++ {0x2074, 0x2079, EN},
++ {0x207a, 0x207b, ET},
++ {0x207f, 0x207f, L},
++ {0x2080, 0x2089, EN},
++ {0x208a, 0x208b, ET},
++ {0x20a0, 0x20b1, ET},
++ {0x20d0, 0x20ea, NSM},
++ {0x2102, 0x2102, L},
++ {0x2107, 0x2107, L},
++ {0x210a, 0x2113, L},
++ {0x2115, 0x2115, L},
++ {0x2119, 0x211d, L},
++ {0x2124, 0x2124, L},
++ {0x2126, 0x2126, L},
++ {0x2128, 0x2128, L},
++ {0x212a, 0x212d, L},
++ {0x212e, 0x212e, ET},
++ {0x212f, 0x2131, L},
++ {0x2133, 0x2139, L},
++ {0x213d, 0x213f, L},
++ {0x2145, 0x2149, L},
++ {0x2160, 0x2183, L},
++ {0x2212, 0x2213, ET},
++ {0x2336, 0x237a, L},
++ {0x2395, 0x2395, L},
++ {0x2488, 0x249b, EN},
++ {0x249c, 0x24e9, L},
++ {0x2800, 0x28ff, L},
++ {0x3000, 0x3000, WS},
++ {0x3005, 0x3007, L},
++ {0x3021, 0x3029, L},
++ {0x302a, 0x302f, NSM},
++ {0x3031, 0x3035, L},
++ {0x3038, 0x303c, L},
++ {0x3041, 0x3096, L},
++ {0x3099, 0x309a, NSM},
++ {0x309d, 0x309f, L},
++ {0x30a1, 0x30fa, L},
++ {0x30fc, 0x30ff, L},
++ {0x3105, 0x312c, L},
++ {0x3131, 0x318e, L},
++ {0x3190, 0x31b7, L},
++ {0x31f0, 0x321c, L},
++ {0x3220, 0x3243, L},
++ {0x3260, 0x327b, L},
++ {0x327f, 0x32b0, L},
++ {0x32c0, 0x32cb, L},
++ {0x32d0, 0x32fe, L},
++ {0x3300, 0x3376, L},
++ {0x337b, 0x33dd, L},
++ {0x33e0, 0x33fe, L},
++ {0x3400, 0x4db5, L},
++ {0x4e00, 0x9fa5, L},
++ {0xa000, 0xa48c, L},
++ {0xac00, 0xd7a3, L},
++ {0xd800, 0xfa2d, L},
++ {0xfa30, 0xfa6a, L},
++ {0xfb00, 0xfb06, L},
++ {0xfb13, 0xfb17, L},
++ {0xfb1d, 0xfb1d, R},
++ {0xfb1e, 0xfb1e, NSM},
++ {0xfb1f, 0xfb28, R},
++ {0xfb29, 0xfb29, ET},
++ {0xfb2a, 0xfb36, R},
++ {0xfb38, 0xfb3c, R},
++ {0xfb3e, 0xfb3e, R},
++ {0xfb40, 0xfb41, R},
++ {0xfb43, 0xfb44, R},
++ {0xfb46, 0xfb4f, R},
++ {0xfb50, 0xfbb1, AL},
++ {0xfbd3, 0xfd3d, AL},
++ {0xfd50, 0xfd8f, AL},
++ {0xfd92, 0xfdc7, AL},
++ {0xfdf0, 0xfdfc, AL},
++ {0xfe00, 0xfe0f, NSM},
++ {0xfe20, 0xfe23, NSM},
++ {0xfe50, 0xfe50, CS},
++ {0xfe52, 0xfe52, CS},
++ {0xfe55, 0xfe55, CS},
++ {0xfe5f, 0xfe5f, ET},
++ {0xfe62, 0xfe63, ET},
++ {0xfe69, 0xfe6a, ET},
++ {0xfe70, 0xfe74, AL},
++ {0xfe76, 0xfefc, AL},
++ {0xfeff, 0xfeff, BN},
++ {0xff03, 0xff05, ET},
++ {0xff0b, 0xff0b, ET},
++ {0xff0c, 0xff0c, CS},
++ {0xff0d, 0xff0d, ET},
++ {0xff0e, 0xff0e, CS},
++ {0xff0f, 0xff0f, ES},
++ {0xff10, 0xff19, EN},
++ {0xff1a, 0xff1a, CS},
++ {0xff21, 0xff3a, L},
++ {0xff41, 0xff5a, L},
++ {0xff66, 0xffbe, L},
++ {0xffc2, 0xffc7, L},
++ {0xffca, 0xffcf, L},
++ {0xffd2, 0xffd7, L},
++ {0xffda, 0xffdc, L},
++ {0xffe0, 0xffe1, ET},
++ {0xffe5, 0xffe6, ET},
++ };
++
++ int i, j, k;
++
++ i = -1;
++ j = lenof(lookup);
++
++ while (j - i > 1) {
++ k = (i + j) / 2;
++ if (ch < lookup[k].first)
++ j = k;
++ else if (ch > lookup[k].last)
++ i = k;
++ else
++ return (unsigned char)lookup[k].type;
++ }
++
++ /*
++ * If we reach here, the character was not in any of the
++ * intervals listed in the lookup table. This means we return
++ * ON (`Other Neutrals'). This is the appropriate code for any
++ * character genuinely not listed in the Unicode table, and
++ * also the table above has deliberately left out any
++ * characters _explicitly_ listed as ON (to save space!).
++ */
++ return ON;
++}
++
++unsigned char getPreviousLevel(unsigned char* types, unsigned char* level, int from)
++{
++ int skip = 0;
++
++ while(--from > 0)
++ {
++
++ switch(types[from])
++ {
++ case LRE:
++ case LRO:
++ case RLE:
++ case RLO:
++ if(skip>0)
++ {
++ skip--;
++ break;
++ }else
++ return level[from-1];
++ case PDF:
++ skip++;
++ break;
++ }
++ }
++ return 0; /* Compiler Nag-Stopper */
++}
++
++unsigned char getPreviousOverride(unsigned char* types, unsigned char* level, int from)
++{
++ int skip = 1;
++
++ from--;
++ while(from-- > 0)
++ {
++ switch(types[from])
++ {
++ case LRE:
++ case RLE:
++ skip++;
++ break;
++
++ case LRO:
++ if(skip>0)
++ {
++ skip--;
++ break;
++ }else
++ return L;
++ case RLO:
++ if(skip>0)
++ {
++ skip--;
++ break;
++ }else
++ return R;
++ case PDF:
++ skip++;
++ break;
++ }
++ }
++ return ON;
++}
++
++
++
++/* The Main shaping function, and the only one to be used
++ * by the outside world.
++ *
++ * line: buffer to apply shaping to. this must be passed by doBidi() first
++ * to: output buffer for the shaped data
++ * from: start bidi at this index
++ * count: number of characters in line
++ */
++int doShape(BLOCKTYPE line, CHARTYPE* to, int from, int count)
++{
++ int i, j, ligFlag;
++ unsigned char prevTemp, nextTemp;
++ CHARTYPE tempChar;
++
++ ligFlag = 0;
++ prevTemp = SU;
++ nextTemp = SU;
++ for(i=from; i<count; i++)
++ {
++ /* Get Previous and next Characters type */
++ j=i;
++ while(--j >= 0)
++ {
++ //assert(j<count);
++ //assert(i<count);
++ if(GetType(GETCHAR(line, j)) != NSM)
++ {
++ prevTemp = STYPE(GETCHAR(line, j));
++ break;
++ }
++ }
++ j=i;
++ while(++j < count)
++ {
++ //assert(j<count);
++ //assert(i<count);
++ if(GetType(GETCHAR(line, j)) != NSM)
++ {
++ nextTemp = STYPE(GETCHAR(line, j));
++ break;
++ //HAQ
++ } else if(j == count-1) {
++ nextTemp = SU;
++ break;
++ }
++ }
++
++ switch(STYPE(GETCHAR(line, i)))
++ {
++ case SC:
++ case SU:
++ to[i] = GETCHAR(line, i);
++ break;
++
++ case SR:
++ if(prevTemp == SD || prevTemp == SC)
++ to[i] = SFINAL(SISOLATED(GETCHAR(line, i)));
++ else
++ to[i] = SISOLATED(GETCHAR(line, i));
++ break;
++
++ case SD:
++ /* Make Ligatures */
++ if(GETCHAR(line, i) == 0x644)
++ {
++ j=i;
++ while(j++<count)
++ {
++ if(GetType(GETCHAR(line, j)) != NSM)
++ {
++ tempChar = GETCHAR(line, j);
++ break;
++ }
++ }
++ switch(tempChar)
++ {
++ case 0x622:
++ ligFlag = 1;
++ if(prevTemp == SD || prevTemp == SC)
++ to[i] = 0xFEF6;
++ else
++ to[i] = 0xFEF5;
++ break;
++ case 0x623:
++ ligFlag = 1;
++ if(prevTemp == SD || prevTemp == SC)
++ to[i] = 0xFEF8;
++ else
++ to[i] = 0xFEF7;
++ break;
++ case 0x625:
++ ligFlag = 1;
++ if(prevTemp == SD || prevTemp == SC)
++ to[i] = 0xFEFA;
++ else
++ to[i] = 0xFEF9;
++ break;
++ case 0x627:
++ ligFlag = 1;
++ if(prevTemp == SD || prevTemp == SC)
++ to[i] = 0xFEFC;
++ else
++ to[i] = 0xFEFB;
++ break;
++ }
++ if(ligFlag)
++ {
++ to[j] = 0x20;
++ i = j;
++ ligFlag = 0;
++ break;
++ }
++ }
++ //assert(j<count);
++ //assert(i<count);
++ if((prevTemp == SD) || (prevTemp == SC))
++ {
++ if(nextTemp == SR || nextTemp == SD || nextTemp == SC)
++ to[i] = SMEDIAL(SISOLATED(GETCHAR(line, i)));
++ else
++ to[i] = SFINAL(SISOLATED(GETCHAR(line, i)));
++ break;
++ }else
++ {
++ if(nextTemp == SR || nextTemp == SD || nextTemp == SC)
++ to[i] = SINITIAL(SISOLATED(GETCHAR(line, i)));
++ else
++ to[i] = SISOLATED(GETCHAR(line, i));
++ break;
++ }
++
++ }
++ nextTemp = SU;
++ }
++ return 1;
++}
++
++/* Rule (X1), (X2), (X3), (X4), (X5), (X6), (X7), (X8), (X9) */
++void doTypes(BLOCKTYPE line, unsigned char paragraphLevel, unsigned char* types,
++ unsigned char* levels, int count, int fX)
++{
++
++ unsigned char tempType;
++ unsigned char currentEmbedding = paragraphLevel;
++ unsigned char currentOverride = ON;
++ int i;
++
++ if(fX)
++ {
++ for( i=0; i<count; i++)
++ {
++ tempType = GetType(GETCHAR(line, i));
++ switch(tempType)
++ {
++ case RLE:
++ currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
++ currentOverride = ON;
++ types[i] = BN;
++ break;
++
++ case LRE:
++ currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
++ currentOverride = ON;
++ types[i] = BN;
++ break;
++
++ case RLO:
++ currentEmbedding = levels[i] = leastGreaterOdd(currentEmbedding);
++ currentOverride = R;
++ types[i] = BN;
++ break;
++
++ case LRO:
++ currentEmbedding = levels[i] = leastGreaterEven(currentEmbedding);
++ currentOverride = L;
++ types[i] = BN;
++ break;
++
++ case PDF:
++ levels[i] = currentEmbedding;
++ currentEmbedding = getPreviousLevel(types, levels, i);
++ currentOverride = getPreviousOverride(types, levels, i);
++ types[i] = BN;
++ break;
++
++ /* Whitespace is treated as neutral for now */
++ case WS:
++ case B:
++ case S:
++ levels[i] = currentEmbedding;
++ tempType = ON;
++ if(currentOverride != ON)
++ tempType = currentOverride;
++ break;
++
++ default:
++ levels[i] = currentEmbedding;
++ if(currentOverride != ON)
++ tempType = currentOverride;
++ break;
++
++ }
++ types[i] = tempType;
++ }
++ }else
++ {
++ for( i=0; i<count; i++)
++ {
++ tempType = GetType(GETCHAR(line, i));
++ switch(tempType)
++ {
++ case WS:
++ case B:
++ case S:
++ levels[i] = currentEmbedding;
++ tempType = ON;
++ if(currentOverride != ON)
++ tempType = currentOverride;
++ break;
++
++ default:
++ levels[i] = currentEmbedding;
++ if(currentOverride != ON)
++ tempType = currentOverride;
++ break;
++
++ }
++ types[i] = tempType;
++ }
++
++ }
++
++}
++
++/* Rule (W3) */
++void doALtoR(unsigned char* types, int count)
++{
++ int i=0;
++ for(; i<count; i++)
++ {
++ if(types[i] == AL)
++ types[i] = R;
++ }
++
++}
++/*
++ * The Main Bidi Function, and the only function that should
++ * be used by the outside world.
++ *
++ * line: a buffer of size count containing text to apply
++ * the Bidirectional algorithm to.
++ */
++int doBidi(BLOCKTYPE line, int count, int applyShape, int reorderCombining, int removeMarks)
++{
++ unsigned char* types;
++ unsigned char* levels;
++ unsigned char paragraphLevel;
++ unsigned char tempType, tempTypeSec;
++ int i, j, imax, fX, fAL, fET, fNSM;
++ CHARTYPE* shapeTo;
++
++
++ fX = fAL = fET = fNSM = 0;
++ for(i=0; i<count; i++)
++ {
++ switch(GetType(line[i]))
++ {
++ case AL:
++ case R:
++ fAL = 1;
++ break;
++ case LRE:
++ case LRO:
++ case RLE:
++ case RLO:
++ case PDF:
++ case BN:
++ fX = 1;
++ break;
++ case ET:
++ fET = 1;
++ break;
++ case NSM:
++ fNSM = 1;
++ break;
++ }
++ }
++
++ if(!fAL && !fX)
++ return 0;
++
++ /* Initialize types, levels */
++ types = (unsigned char*)malloc(sizeof(unsigned char) * count);
++ levels = (unsigned char*)malloc(sizeof(unsigned char) * count);
++ if(applyShape)
++ shapeTo = (CHARTYPE*)malloc(sizeof(CHARTYPE) * count);
++
++ /* Rule (P1) NOT IMPLEMENTED
++ * P1. Split the text into separate paragraphs. A paragraph separator is
++ * kept with the previous paragraph. Within each paragraph, apply all the
++ * other rules of this algorithm.
++ */
++
++ /* Rule (P2), (P3)
++ * P2. In each paragraph, find the first character of type L, AL, or R.
++ * P3. If a character is found in P2 and it is of type AL or R, then set
++ * the paragraph embedding level to one; otherwise, set it to zero.
++ */
++ paragraphLevel = GetParagraphLevel(line, count);
++
++ /* Rule (X1), (X2), (X3), (X4), (X5), (X6), (X7), (X8), (X9)
++ * X1. Begin by setting the current embedding level to the paragraph
++ * embedding level. Set the directional override status to neutral.
++ * X2. With each RLE, compute the least greater odd embedding level.
++ * X3. With each LRE, compute the least greater even embedding level.
++ * X4. With each RLO, compute the least greater odd embedding level.
++ * X5. With each LRO, compute the least greater even embedding level.
++ * X6. For all types besides RLE, LRE, RLO, LRO, and PDF:
++ * a. Set the level of the current character to the current
++ * embedding level.
++ * b. Whenever the directional override status is not neutral,
++ * reset the current character type to the directional
++ * override status.
++ * X7. With each PDF, determine the matching embedding or override code.
++ * If there was a valid matching code, restore (pop) the last
++ * remembered (pushed) embedding level and directional override.
++ * X8. All explicit directional embeddings and overrides are completely
++ * terminated at the end of each paragraph. Paragraph separators are not
++ * included in the embedding. (Useless here) NOT IMPLEMENTED
++ * X9. Remove all RLE, LRE, RLO, LRO, PDF, and BN codes.
++ * Here, they're converted to BN.
++ */
++
++ doTypes(line, paragraphLevel, types, levels, count, fX);
++
++
++ /* Rule (W1)
++ * W1. Examine each non-spacing mark (NSM) in the level run, and change
++ * the type of the NSM to the type of the previous character. If the NSM
++ * is at the start of the level run, it will get the type of sor.
++ */
++
++ /*
++ * Clear BNs first
++ */
++ if(fX)
++ {
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == BN)
++ {
++ j=i;
++ while(types[--j] == ON);
++ levels[i] = levels[j];
++
++ j=i;
++ while(types[++j] == BN);
++
++ if(levels[j] > levels[i])
++ levels[i] = levels[j];
++
++
++
++ if((levels[i] % 2) == 0)
++ {
++ types[i] = L;
++ }
++ else
++ {
++ types[i] = R;
++ }
++
++ }
++ }
++ }
++
++
++ if(fNSM)
++ {
++ if(types[0] == NSM)
++ types[0] = paragraphLevel;
++
++ for(i=1; i<count; i++)
++ {
++ if(types[i] == NSM)
++ types[i] = types[i-1];
++ /* Is this a safe assumption?
++ * I assumed the previous, IS a character.
++ */
++ }
++ }
++
++ /* BN TYPES !!!! */
++
++ if(fX)
++ {
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == BN)
++ {
++ j=i;
++ while(--j>=0 && types[j] == ON);
++ tempType = types[j];
++ j=i;
++ while(++j<count && types[j] == BN || types[j] == ON);
++ if(tempType != types[j])
++ types[i] = tempType;
++
++ }
++ }
++ }
++
++
++ /* Rule (W2)
++ * W2. Search backwards from each instance of a European number until the
++ * first strong type (R, L, AL, or sor) is found. If an AL is found,
++ * change the type of the European number to Arabic number.
++ */
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == EN)
++ {
++ j=i;
++ while(--j >= 0)
++ {
++ if(types[j] == AL)
++ {
++ types[i] = AN;
++ break;
++ }
++ else if(types[j] == R || types[j] == L)
++ {
++ break;
++ }
++ }
++ }
++ }
++
++ /* Rule (W3)
++ * W3. Change all ALs to R.
++ *
++ * Optimization: on Rule Xn, we might set a flag on AL type
++ * to prevent this loop in L R lines only...
++ */
++ doALtoR(types, count);
++
++ /* Rule (W4)
++ * W4. A single European separator between two European numbers changes
++ * to a European number. A single common separator between two numbers
++ * of the same type changes to that type.
++ */
++ for( i=0; i<(count-1); i++)
++ {
++ if(types[i] == ES)
++ {
++ if(types[i-1] == EN && types[i+1] == EN)
++ types[i] = EN;
++ }else if(types[i] == CS)
++ {
++ if(types[i-1] == EN && types[i+1] == EN)
++ types[i] = EN;
++ else if(types[i-1] == AN && types[i+1] == AN)
++ types[i] = AN;
++ }
++ }
++
++ /* Rule (W5)
++ * W5. A sequence of European terminators adjacent to European numbers
++ * changes to all European numbers.
++ *
++ * Optimization: lots here... else ifs need rearrangement
++ */
++ if(fET)
++ {
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == ET)
++ {
++ if(types[i-1] == EN)
++ {
++ types[i] = EN;
++ continue;
++ }else if(types[i+1] == EN)
++ {
++ types[i] = EN;
++ continue;
++ }else if(types[i+1] == ET)
++ {
++ j=i;
++ while(j <count && types[j] == ET)
++ {
++ j++;
++ }
++ if(types[j] == EN)
++ types[i] = EN;
++ }
++ }
++ }
++ }
++
++ /* Rule (W6)
++ * W6. Otherwise, separators and terminators change to Other Neutral:
++ */
++ for(i=0; i<count; i++)
++ {
++ switch(types[i])
++ {
++ case ES:
++ case ET:
++ case CS:
++ types[i] = ON;
++ break;
++ }
++ }
++
++ /* Rule (W7)
++ * W7. Search backwards from each instance of a European number until
++ * the first strong type (R, L, or sor) is found. If an L is found,
++ * then change the type of the European number to L.
++ */
++
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == EN)
++ {
++ j=i;
++ while(--j >= 0)
++ {
++ if(types[j] == L)
++ {
++ types[i] = L;
++ break;
++ }
++ else if(types[j] == R || types[j] == AL)
++ {
++ break;
++ }
++
++ }
++ }
++ }
++
++
++ /* Rule (N1)
++ * N1. A sequence of neutrals takes the direction of the surrounding
++ * strong text if the text on both sides has the same direction. European
++ * and Arabic numbers are treated as though they were R.
++ */
++ tempType = paragraphLevel;
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == ON)
++ {
++ if(types[i-1] == R || types[i-1] == EN || types[i-1] == AN)
++ tempType = R;
++ else
++ tempType = L;
++ j=i;
++
++ while(j < count)
++ {
++ tempTypeSec = types[j];
++ if(tempTypeSec == ON || tempTypeSec == BN)
++ j++;
++ else
++ break;
++ }
++
++ if(((types[j] == L || types[j] == LRE) && (tempType == L)) ||
++ (((types[j] == R) || (types[j] == EN) || (types[j] == AN)) && (tempType == R)))
++ {
++ while(i<j)
++ {
++ types[i++] = tempType;
++ }
++ }
++ }
++ }
++
++
++ /* Rule (N2)
++ * N2. Any remaining neutrals take the embedding direction.
++ */
++ for(i=0; i<count; i++)
++ {
++ if(types[i] == ON || types[i] == BN)
++ {
++ if((levels[i] % 2) == 0)
++ types[i] = L;
++ else
++ types[i] = R;
++ }
++ }
++
++ /* Rule (I1)
++ * I1. For all characters with an even (left-to-right) embedding
++ * direction, those of type R go up one level and those of type AN or
++ * EN go up two levels.
++ */
++ for(i=0; i<count; i++)
++ {
++ if((levels[i] % 2) == 0)
++ {
++ if(types[i] == R)
++ levels[i] += 1;
++ else if((types[i] == AN) || (types[i] == EN))
++ levels[i] += 2;
++ }else
++ {
++ if((types[i] == L) ||
++ (types[i] == EN) ||
++ (types[i] == AN))
++ levels[i] += 1;
++ }
++ }
++
++ /* Rule (I2)
++ * I2. For all characters with an odd (right-to-left) embedding direction,
++ * those of type L, EN or AN go up one level.
++ */
++/*
++ for(i=0; i<count; i++)
++ {
++ if((levels[i] % 2) == 1)
++ {
++ if(types[i] == L || types[i] == EN || types[i] == AN)
++ levels[i] += 1;
++ }
++ }
++*/
++ /* Rule (L1)
++ * L1. On each line, reset the embedding level of the following characters
++ * to the paragraph embedding level:
++ * (1)segment separators, (2)paragraph separators,
++ * (3)any sequence of whitespace characters preceding
++ * a segment separator or paragraph separator,
++ * (4)and any sequence of white space characters
++ * at the end of the line.
++ * The types of characters used here are the original types, not those
++ * modified by the previous phase.
++ */
++
++
++
++ j=count-1;
++ while(j>0 && (GetType(GETCHAR(line, j)) == WS))
++ {
++ j--;
++ }
++ if(j < (count-1))
++ {
++ for(j++; j<count; j++)
++ levels[j] = paragraphLevel;
++ }
++
++ for(i=0; i<count; i++)
++ {
++ tempType = GetType(GETCHAR(line, i));
++ if(tempType == WS)
++ {
++ j=i;
++ while((++j < count) && ((tempType == WS) || (tempType == RLE)) )
++ {
++ tempType = GetType(line[j]);
++ }
++
++ if(GetType(GETCHAR(line, j)) == B || GetType(GETCHAR(line, j)) == S)
++ {
++ for(j--; j>=i ; j--)
++ {
++ levels[j] = paragraphLevel;
++ }
++ }
++ }else if(tempType == B || tempType == S)
++ levels[i] = paragraphLevel;
++ }
++
++ /* Rule (L4)
++ * L4. A character that possesses the mirrored property as specified by
++ * Section 4.7, Mirrored, must be depicted by a mirrored glyph if the
++ * resolved directionality of that character is R.
++ */
++ /* Note: this is implemented before L2 for efficiency */
++ for(i=0; i<count; i++)
++ {
++ if((levels[i] % 2) == 1)
++ doMirror(&line[i]);
++ }
++
++
++
++ /* Rule (L3)
++ * L3. Combining marks applied to a right-to-left base character will at
++ * this point precede their base character. If the rendering engine
++ * expects them to follow the base characters in the final display
++ * process, then the ordering of the marks and the base character must
++ * be reversed.
++ * Combining marks are reordered to the right of each character on an
++ * odd level.
++ */
++
++ if(fNSM && reorderCombining)
++ {
++ CHARTYPE temp;
++ int it;
++ for(i=0; i<count; i++)
++ {
++ if(GetType(GETCHAR(line, i)) == NSM && odd(levels[i]))
++ {
++ j=i;
++ while((++j < count) && (GetType(GETCHAR(line, j)) == NSM));
++ j--; i--;
++ for(it=j; j>i; i++, j--)
++ {
++ temp = GETCHAR(line, i);
++ GETCHAR(line, i) = GETCHAR(line, j);
++ GETCHAR(line, j) = temp;
++ }
++ i=it+1;
++ }
++ }
++ }
++
++ /* Shaping
++ * Shaping is Applied to each run of levels separately....
++ */
++
++ if(applyShape)
++ {
++
++ for(i=0; i<count; i++)
++ {
++ shapeTo[i] = GETCHAR(line, i);
++ }
++
++ j=i=0;
++ while(j < count)
++ {
++ if(GetType(GETCHAR(line, j)) == AL)
++ {
++ if(j<count && j >= i )
++ {
++ tempType = levels[j];
++ i=j;
++ while((i++ < count) && (levels[i] == tempType));
++ doShape(line, shapeTo, j, i);
++ j=i;
++ tempType = levels[j];
++
++ }
++ }
++ j++;
++ }
++ for(i=0; i<count; i++)
++ {
++ GETCHAR(line, i) = shapeTo[i];
++ }
++ free(shapeTo);
++ }
++
++
++
++ /* Rule (L2)
++ * L2. From the highest level found in the text to the lowest odd level on
++ * each line, including intermediate levels not actually present in the
++ * text, reverse any contiguous sequence of characters that are at that
++ * level or higher
++ */
++ /* we flip the character string and leave the level array */
++ imax = 0;
++ i=0;
++ tempType = levels[0];
++ while(i < count)
++ {
++ if(levels[i] > tempType)
++ {
++ tempType = levels[i];
++ imax=i;
++ }
++ i++;
++ }
++ /* maximum level in tempType, its index in imax. */
++ while(tempType > 0) /* loop from highest level to the least odd, */
++ { /* which i assume is 1 */
++ flipThisRun(line, levels, tempType, count);
++ tempType--;
++ }
++
++ /* The line should be reordered correctly, check for Explicits marks
++ * and remove them if removeMarks
++ */
++ if(fX && removeMarks)
++ {
++ if(!GetParagraphLevel(line, count))
++ {
++ for(i=0, j=0; i<count; i++)
++ {
++ tempType = GetType(GETCHAR(line, i));
++ if(tempType != RLE &&
++ tempType != LRE &&
++ tempType != RLO &&
++ tempType != LRO &&
++ tempType != PDF)
++ GETCHAR(line, j++) = GETCHAR(line, i);
++ }
++ for(i=j; j<count; j++)
++ GETCHAR(line, j) = 0x20;
++ }else
++ {
++ for(j=i=count-1; i>=0; i--)
++ {
++ tempType = GetType(GETCHAR(line, i));
++ if(tempType != RLE &&
++ tempType != LRE &&
++ tempType != RLO &&
++ tempType != LRO &&
++ tempType != PDF)
++ GETCHAR(line, j--) = GETCHAR(line, i);
++ }
++ for(i=j; j>=0; j--)
++ GETCHAR(line, j) = 0x20;
++ }
++ }
++
++
++ free(types);
++ free(levels);
++ /* if removeMarks is 1 and there were actual marks then return the new size */
++ if(fX && removeMarks) return i;
++ return count;
++}
++
++
++/*
++ * Bad, Horrible function
++ * takes a pointer to a character that is checked for
++ * having a mirror glyph.
++ */
++void doMirror(CHARTYPE* ch)
++{
++ if ((*ch & 0xFF00) == 0) {
++ switch (*ch) {
++ case 0x0028: *ch = 0x0029; break;
++ case 0x0029: *ch = 0x0028; break;
++ case 0x003C: *ch = 0x003E; break;
++ case 0x003E: *ch = 0x003C; break;
++ case 0x005B: *ch = 0x005D; break;
++ case 0x005D: *ch = 0x005B; break;
++ case 0x007B: *ch = 0x007D; break;
++ case 0x007D: *ch = 0x007B; break;
++ case 0x00AB: *ch = 0x00BB; break;
++ case 0x00BB: *ch = 0x00AB; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x2000) {
++ switch (*ch) {
++ case 0x2039: *ch = 0x203A; break;
++ case 0x203A: *ch = 0x2039; break;
++ case 0x2045: *ch = 0x2046; break;
++ case 0x2046: *ch = 0x2045; break;
++ case 0x207D: *ch = 0x207E; break;
++ case 0x207E: *ch = 0x207D; break;
++ case 0x208D: *ch = 0x208E; break;
++ case 0x208E: *ch = 0x208D; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x2200) {
++ switch (*ch) {
++ case 0x2208: *ch = 0x220B; break;
++ case 0x2209: *ch = 0x220C; break;
++ case 0x220A: *ch = 0x220D; break;
++ case 0x220B: *ch = 0x2208; break;
++ case 0x220C: *ch = 0x2209; break;
++ case 0x220D: *ch = 0x220A; break;
++ case 0x2215: *ch = 0x29F5; break;
++ case 0x223C: *ch = 0x223D; break;
++ case 0x223D: *ch = 0x223C; break;
++ case 0x2243: *ch = 0x22CD; break;
++ case 0x2252: *ch = 0x2253; break;
++ case 0x2253: *ch = 0x2252; break;
++ case 0x2254: *ch = 0x2255; break;
++ case 0x2255: *ch = 0x2254; break;
++ case 0x2264: *ch = 0x2265; break;
++ case 0x2265: *ch = 0x2264; break;
++ case 0x2266: *ch = 0x2267; break;
++ case 0x2267: *ch = 0x2266; break;
++ case 0x2268: *ch = 0x2269; break;
++ case 0x2269: *ch = 0x2268; break;
++ case 0x226A: *ch = 0x226B; break;
++ case 0x226B: *ch = 0x226A; break;
++ case 0x226E: *ch = 0x226F; break;
++ case 0x226F: *ch = 0x226E; break;
++ case 0x2270: *ch = 0x2271; break;
++ case 0x2271: *ch = 0x2270; break;
++ case 0x2272: *ch = 0x2273; break;
++ case 0x2273: *ch = 0x2272; break;
++ case 0x2274: *ch = 0x2275; break;
++ case 0x2275: *ch = 0x2274; break;
++ case 0x2276: *ch = 0x2277; break;
++ case 0x2277: *ch = 0x2276; break;
++ case 0x2278: *ch = 0x2279; break;
++ case 0x2279: *ch = 0x2278; break;
++ case 0x227A: *ch = 0x227B; break;
++ case 0x227B: *ch = 0x227A; break;
++ case 0x227C: *ch = 0x227D; break;
++ case 0x227D: *ch = 0x227C; break;
++ case 0x227E: *ch = 0x227F; break;
++ case 0x227F: *ch = 0x227E; break;
++ case 0x2280: *ch = 0x2281; break;
++ case 0x2281: *ch = 0x2280; break;
++ case 0x2282: *ch = 0x2283; break;
++ case 0x2283: *ch = 0x2282; break;
++ case 0x2284: *ch = 0x2285; break;
++ case 0x2285: *ch = 0x2284; break;
++ case 0x2286: *ch = 0x2287; break;
++ case 0x2287: *ch = 0x2286; break;
++ case 0x2288: *ch = 0x2289; break;
++ case 0x2289: *ch = 0x2288; break;
++ case 0x228A: *ch = 0x228B; break;
++ case 0x228B: *ch = 0x228A; break;
++ case 0x228F: *ch = 0x2290; break;
++ case 0x2290: *ch = 0x228F; break;
++ case 0x2291: *ch = 0x2292; break;
++ case 0x2292: *ch = 0x2291; break;
++ case 0x2298: *ch = 0x29B8; break;
++ case 0x22A2: *ch = 0x22A3; break;
++ case 0x22A3: *ch = 0x22A2; break;
++ case 0x22A6: *ch = 0x2ADE; break;
++ case 0x22A8: *ch = 0x2AE4; break;
++ case 0x22A9: *ch = 0x2AE3; break;
++ case 0x22AB: *ch = 0x2AE5; break;
++ case 0x22B0: *ch = 0x22B1; break;
++ case 0x22B1: *ch = 0x22B0; break;
++ case 0x22B2: *ch = 0x22B3; break;
++ case 0x22B3: *ch = 0x22B2; break;
++ case 0x22B4: *ch = 0x22B5; break;
++ case 0x22B5: *ch = 0x22B4; break;
++ case 0x22B6: *ch = 0x22B7; break;
++ case 0x22B7: *ch = 0x22B6; break;
++ case 0x22C9: *ch = 0x22CA; break;
++ case 0x22CA: *ch = 0x22C9; break;
++ case 0x22CB: *ch = 0x22CC; break;
++ case 0x22CC: *ch = 0x22CB; break;
++ case 0x22CD: *ch = 0x2243; break;
++ case 0x22D0: *ch = 0x22D1; break;
++ case 0x22D1: *ch = 0x22D0; break;
++ case 0x22D6: *ch = 0x22D7; break;
++ case 0x22D7: *ch = 0x22D6; break;
++ case 0x22D8: *ch = 0x22D9; break;
++ case 0x22D9: *ch = 0x22D8; break;
++ case 0x22DA: *ch = 0x22DB; break;
++ case 0x22DB: *ch = 0x22DA; break;
++ case 0x22DC: *ch = 0x22DD; break;
++ case 0x22DD: *ch = 0x22DC; break;
++ case 0x22DE: *ch = 0x22DF; break;
++ case 0x22DF: *ch = 0x22DE; break;
++ case 0x22E0: *ch = 0x22E1; break;
++ case 0x22E1: *ch = 0x22E0; break;
++ case 0x22E2: *ch = 0x22E3; break;
++ case 0x22E3: *ch = 0x22E2; break;
++ case 0x22E4: *ch = 0x22E5; break;
++ case 0x22E5: *ch = 0x22E4; break;
++ case 0x22E6: *ch = 0x22E7; break;
++ case 0x22E7: *ch = 0x22E6; break;
++ case 0x22E8: *ch = 0x22E9; break;
++ case 0x22E9: *ch = 0x22E8; break;
++ case 0x22EA: *ch = 0x22EB; break;
++ case 0x22EB: *ch = 0x22EA; break;
++ case 0x22EC: *ch = 0x22ED; break;
++ case 0x22ED: *ch = 0x22EC; break;
++ case 0x22F0: *ch = 0x22F1; break;
++ case 0x22F1: *ch = 0x22F0; break;
++ case 0x22F2: *ch = 0x22FA; break;
++ case 0x22F3: *ch = 0x22FB; break;
++ case 0x22F4: *ch = 0x22FC; break;
++ case 0x22F6: *ch = 0x22FD; break;
++ case 0x22F7: *ch = 0x22FE; break;
++ case 0x22FA: *ch = 0x22F2; break;
++ case 0x22FB: *ch = 0x22F3; break;
++ case 0x22FC: *ch = 0x22F4; break;
++ case 0x22FD: *ch = 0x22F6; break;
++ case 0x22FE: *ch = 0x22F7; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x2300) {
++ switch (*ch) {
++ case 0x2308: *ch = 0x2309; break;
++ case 0x2309: *ch = 0x2308; break;
++ case 0x230A: *ch = 0x230B; break;
++ case 0x230B: *ch = 0x230A; break;
++ case 0x2329: *ch = 0x232A; break;
++ case 0x232A: *ch = 0x2329; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x2700) {
++ switch (*ch) {
++ case 0x2768: *ch = 0x2769; break;
++ case 0x2769: *ch = 0x2768; break;
++ case 0x276A: *ch = 0x276B; break;
++ case 0x276B: *ch = 0x276A; break;
++ case 0x276C: *ch = 0x276D; break;
++ case 0x276D: *ch = 0x276C; break;
++ case 0x276E: *ch = 0x276F; break;
++ case 0x276F: *ch = 0x276E; break;
++ case 0x2770: *ch = 0x2771; break;
++ case 0x2771: *ch = 0x2770; break;
++ case 0x2772: *ch = 0x2773; break;
++ case 0x2773: *ch = 0x2772; break;
++ case 0x2774: *ch = 0x2775; break;
++ case 0x2775: *ch = 0x2774; break;
++ case 0x27D5: *ch = 0x27D6; break;
++ case 0x27D6: *ch = 0x27D5; break;
++ case 0x27DD: *ch = 0x27DE; break;
++ case 0x27DE: *ch = 0x27DD; break;
++ case 0x27E2: *ch = 0x27E3; break;
++ case 0x27E3: *ch = 0x27E2; break;
++ case 0x27E4: *ch = 0x27E5; break;
++ case 0x27E5: *ch = 0x27E4; break;
++ case 0x27E6: *ch = 0x27E7; break;
++ case 0x27E7: *ch = 0x27E6; break;
++ case 0x27E8: *ch = 0x27E9; break;
++ case 0x27E9: *ch = 0x27E8; break;
++ case 0x27EA: *ch = 0x27EB; break;
++ case 0x27EB: *ch = 0x27EA; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x2900) {
++ switch (*ch) {
++ case 0x2983: *ch = 0x2984; break;
++ case 0x2984: *ch = 0x2983; break;
++ case 0x2985: *ch = 0x2986; break;
++ case 0x2986: *ch = 0x2985; break;
++ case 0x2987: *ch = 0x2988; break;
++ case 0x2988: *ch = 0x2987; break;
++ case 0x2989: *ch = 0x298A; break;
++ case 0x298A: *ch = 0x2989; break;
++ case 0x298B: *ch = 0x298C; break;
++ case 0x298C: *ch = 0x298B; break;
++ case 0x298D: *ch = 0x2990; break;
++ case 0x298E: *ch = 0x298F; break;
++ case 0x298F: *ch = 0x298E; break;
++ case 0x2990: *ch = 0x298D; break;
++ case 0x2991: *ch = 0x2992; break;
++ case 0x2992: *ch = 0x2991; break;
++ case 0x2993: *ch = 0x2994; break;
++ case 0x2994: *ch = 0x2993; break;
++ case 0x2995: *ch = 0x2996; break;
++ case 0x2996: *ch = 0x2995; break;
++ case 0x2997: *ch = 0x2998; break;
++ case 0x2998: *ch = 0x2997; break;
++ case 0x29B8: *ch = 0x2298; break;
++ case 0x29C0: *ch = 0x29C1; break;
++ case 0x29C1: *ch = 0x29C0; break;
++ case 0x29C4: *ch = 0x29C5; break;
++ case 0x29C5: *ch = 0x29C4; break;
++ case 0x29CF: *ch = 0x29D0; break;
++ case 0x29D0: *ch = 0x29CF; break;
++ case 0x29D1: *ch = 0x29D2; break;
++ case 0x29D2: *ch = 0x29D1; break;
++ case 0x29D4: *ch = 0x29D5; break;
++ case 0x29D5: *ch = 0x29D4; break;
++ case 0x29D8: *ch = 0x29D9; break;
++ case 0x29D9: *ch = 0x29D8; break;
++ case 0x29DA: *ch = 0x29DB; break;
++ case 0x29DB: *ch = 0x29DA; break;
++ case 0x29F5: *ch = 0x2215; break;
++ case 0x29F8: *ch = 0x29F9; break;
++ case 0x29F9: *ch = 0x29F8; break;
++ case 0x29FC: *ch = 0x29FD; break;
++ case 0x29FD: *ch = 0x29FC; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x2A00) {
++ switch (*ch) {
++ case 0x2A2B: *ch = 0x2A2C; break;
++ case 0x2A2C: *ch = 0x2A2B; break;
++ case 0x2A2D: *ch = 0x2A2C; break;
++ case 0x2A2E: *ch = 0x2A2D; break;
++ case 0x2A34: *ch = 0x2A35; break;
++ case 0x2A35: *ch = 0x2A34; break;
++ case 0x2A3C: *ch = 0x2A3D; break;
++ case 0x2A3D: *ch = 0x2A3C; break;
++ case 0x2A64: *ch = 0x2A65; break;
++ case 0x2A65: *ch = 0x2A64; break;
++ case 0x2A79: *ch = 0x2A7A; break;
++ case 0x2A7A: *ch = 0x2A79; break;
++ case 0x2A7D: *ch = 0x2A7E; break;
++ case 0x2A7E: *ch = 0x2A7D; break;
++ case 0x2A7F: *ch = 0x2A80; break;
++ case 0x2A80: *ch = 0x2A7F; break;
++ case 0x2A81: *ch = 0x2A82; break;
++ case 0x2A82: *ch = 0x2A81; break;
++ case 0x2A83: *ch = 0x2A84; break;
++ case 0x2A84: *ch = 0x2A83; break;
++ case 0x2A8B: *ch = 0x2A8C; break;
++ case 0x2A8C: *ch = 0x2A8B; break;
++ case 0x2A91: *ch = 0x2A92; break;
++ case 0x2A92: *ch = 0x2A91; break;
++ case 0x2A93: *ch = 0x2A94; break;
++ case 0x2A94: *ch = 0x2A93; break;
++ case 0x2A95: *ch = 0x2A96; break;
++ case 0x2A96: *ch = 0x2A95; break;
++ case 0x2A97: *ch = 0x2A98; break;
++ case 0x2A98: *ch = 0x2A97; break;
++ case 0x2A99: *ch = 0x2A9A; break;
++ case 0x2A9A: *ch = 0x2A99; break;
++ case 0x2A9B: *ch = 0x2A9C; break;
++ case 0x2A9C: *ch = 0x2A9B; break;
++ case 0x2AA1: *ch = 0x2AA2; break;
++ case 0x2AA2: *ch = 0x2AA1; break;
++ case 0x2AA6: *ch = 0x2AA7; break;
++ case 0x2AA7: *ch = 0x2AA6; break;
++ case 0x2AA8: *ch = 0x2AA9; break;
++ case 0x2AA9: *ch = 0x2AA8; break;
++ case 0x2AAA: *ch = 0x2AAB; break;
++ case 0x2AAB: *ch = 0x2AAA; break;
++ case 0x2AAC: *ch = 0x2AAD; break;
++ case 0x2AAD: *ch = 0x2AAC; break;
++ case 0x2AAF: *ch = 0x2AB0; break;
++ case 0x2AB0: *ch = 0x2AAF; break;
++ case 0x2AB3: *ch = 0x2AB4; break;
++ case 0x2AB4: *ch = 0x2AB3; break;
++ case 0x2ABB: *ch = 0x2ABC; break;
++ case 0x2ABC: *ch = 0x2ABB; break;
++ case 0x2ABD: *ch = 0x2ABE; break;
++ case 0x2ABE: *ch = 0x2ABD; break;
++ case 0x2ABF: *ch = 0x2AC0; break;
++ case 0x2AC0: *ch = 0x2ABF; break;
++ case 0x2AC1: *ch = 0x2AC2; break;
++ case 0x2AC2: *ch = 0x2AC1; break;
++ case 0x2AC3: *ch = 0x2AC4; break;
++ case 0x2AC4: *ch = 0x2AC3; break;
++ case 0x2AC5: *ch = 0x2AC6; break;
++ case 0x2AC6: *ch = 0x2AC5; break;
++ case 0x2ACD: *ch = 0x2ACE; break;
++ case 0x2ACE: *ch = 0x2ACD; break;
++ case 0x2ACF: *ch = 0x2AD0; break;
++ case 0x2AD0: *ch = 0x2ACF; break;
++ case 0x2AD1: *ch = 0x2AD2; break;
++ case 0x2AD2: *ch = 0x2AD1; break;
++ case 0x2AD3: *ch = 0x2AD4; break;
++ case 0x2AD4: *ch = 0x2AD3; break;
++ case 0x2AD5: *ch = 0x2AD6; break;
++ case 0x2AD6: *ch = 0x2AD5; break;
++ case 0x2ADE: *ch = 0x22A6; break;
++ case 0x2AE3: *ch = 0x22A9; break;
++ case 0x2AE4: *ch = 0x22A8; break;
++ case 0x2AE5: *ch = 0x22AB; break;
++ case 0x2AEC: *ch = 0x2AED; break;
++ case 0x2AED: *ch = 0x2AEC; break;
++ case 0x2AF7: *ch = 0x2AF8; break;
++ case 0x2AF8: *ch = 0x2AF7; break;
++ case 0x2AF9: *ch = 0x2AFA; break;
++ case 0x2AFA: *ch = 0x2AF9; break;
++ }
++ } else if ((*ch & 0xFF00) == 0x3000) {
++ switch (*ch) {
++ case 0x3008: *ch = 0x3009; break;
++ case 0x3009: *ch = 0x3008; break;
++ case 0x300A: *ch = 0x300B; break;
++ case 0x300B: *ch = 0x300A; break;
++ case 0x300C: *ch = 0x300D; break;
++ case 0x300D: *ch = 0x300C; break;
++ case 0x300E: *ch = 0x300F; break;
++ case 0x300F: *ch = 0x300E; break;
++ case 0x3010: *ch = 0x3011; break;
++ case 0x3011: *ch = 0x3010; break;
++ case 0x3014: *ch = 0x3015; break;
++ case 0x3015: *ch = 0x3014; break;
++ case 0x3016: *ch = 0x3017; break;
++ case 0x3017: *ch = 0x3016; break;
++ case 0x3018: *ch = 0x3019; break;
++ case 0x3019: *ch = 0x3018; break;
++ case 0x301A: *ch = 0x301B; break;
++ case 0x301B: *ch = 0x301A; break;
++ }
++ } else if ((*ch & 0xFF00) == 0xFF00) {
++ switch (*ch) {
++ case 0xFF08: *ch = 0xFF09; break;
++ case 0xFF09: *ch = 0xFF08; break;
++ case 0xFF1C: *ch = 0xFF1E; break;
++ case 0xFF1E: *ch = 0xFF1C; break;
++ case 0xFF3B: *ch = 0xFF3D; break;
++ case 0xFF3D: *ch = 0xFF3B; break;
++ case 0xFF5B: *ch = 0xFF5D; break;
++ case 0xFF5D: *ch = 0xFF5B; break;
++ case 0xFF5F: *ch = 0xFF60; break;
++ case 0xFF60: *ch = 0xFF5F; break;
++ case 0xFF62: *ch = 0xFF63; break;
++ case 0xFF63: *ch = 0xFF62; break;
++ }
++ }
++}
+Index: qt-2.3.10-snapshot-20060120/src/qt.pro
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/qt.pro 2005-12-15 00:03:32.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/qt.pro 2006-01-20 21:09:56.404899280 +0100
+@@ -178,6 +178,7 @@
+ $$KERNEL_H/qasyncimageio.h \
+ $$KERNEL_H/qasyncio.h \
+ $$KERNEL_H/qbitmap.h \
++ $$KERNEL_H/qbidi.h \
+ $$KERNEL_H/qbrush.h \
+ $$KERNEL_H/qclipboard.h \
+ $$KERNEL_H/qcolor.h \
+@@ -524,6 +525,8 @@
+ kernel/qapplication.cpp \
+ kernel/qasyncimageio.cpp \
+ kernel/qasyncio.cpp \
++ kernel/qbidi.cpp \
++ kernel/minibidi.cpp \
+ kernel/qbitmap.cpp \
+ kernel/qclipboard.cpp \
+ kernel/qcolor.cpp \
+Index: qt-2.3.10-snapshot-20060120/src/Makefile.in
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/Makefile.in 2006-01-20 20:57:33.109897296 +0100
++++ qt-2.3.10-snapshot-20060120/src/Makefile.in 2006-01-20 21:09:56.409898520 +0100
+@@ -176,6 +176,8 @@
+ kernel/qabstractlayout.o \
+ kernel/qaccel.o \
+ kernel/qapplication.o \
++ kernel/qbidi.o \
++ kernel/minibidi.o \
+ kernel/qasyncimageio.o \
+ kernel/qasyncio.o \
+ kernel/qbitmap.o \
+@@ -4235,6 +4237,12 @@
+ kernel/qthread.h \
+ tools/qvaluestack.h
+
++kernel/qbidi.o: kernel/qbidi.cpp \
++ kernel/qbidi.h \
++ tools/qstring.h
++
++kernel/minibidi.o: kernel/minibidi.c
++
+ kernel/qasyncimageio.o: kernel/qasyncimageio.cpp \
+ kernel/qasyncimageio.h \
+ kernel/qimage.h \
diff --git a/packages/qte/qte-2.3.12/c700-hardware.patch b/packages/qte/qte-2.3.12/c700-hardware.patch
new file mode 100644
index 0000000000..a4ba2654dc
--- /dev/null
+++ b/packages/qte/qte-2.3.12/c700-hardware.patch
@@ -0,0 +1,114 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwindowsystem_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp 2006-01-20 21:27:28.283989352 +0100
+@@ -178,7 +178,7 @@
+ static QRect maxwindow_rect;
+ extern Q_EXPORT QRect qt_maxWindowRect;
+ static const char *defaultMouse =
+-#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_YOPY) || defined(QWS_CUSTOMTOUCHPANEL)
++#if defined(QT_QWS_CASSIOPEIA) || defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_SLC700) || defined(QT_QWS_YOPY) || defined(QWS_CUSTOMTOUCHPANEL)
+ "TPanel"
+ #elif defined(QT_KEYPAD_MODE)
+ "None"
+@@ -3324,7 +3324,7 @@
+ void QWSServer::screenSaverSleep()
+ {
+ qt_screen->blank(TRUE);
+-#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX)
++#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX) && !defined(QT_QWS_SLC700)
+ d->screensavertimer->stop();
+ #else
+ if ( screensaverinterval ) {
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsmouse_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.cpp 2006-01-20 21:28:39.035233528 +0100
+@@ -87,6 +87,19 @@
+ #define QT_QWS_TP_PRESSURE_THRESHOLD 500
+ #define QT_QWS_TP_MOVE_LIMIT 50
+ #define QT_QWS_TP_JITTER_LIMIT 2
++#elif defined(QT_QWS_SLC700)
++#define QT_QWS_SLC700_RAW
++typedef struct {
++ unsigned short pressure;
++ unsigned short x;
++ unsigned short y;
++ unsigned short millisecs;
++} TS_EVENT;
++#define QT_QWS_TP_SAMPLE_SIZE 10
++#define QT_QWS_TP_MINIMUM_SAMPLES 4
++#define QT_QWS_TP_PRESSURE_THRESHOLD 500
++#define QT_QWS_TP_MOVE_LIMIT 50
++#define QT_QWS_TP_JITTER_LIMIT 2
+ #endif
+
+ #ifndef QT_QWS_TP_SAMPLE_SIZE
+@@ -592,7 +605,7 @@
+ sub[nsub++] = new QAutoMouseSubHandler_intellimouse(fd);
+ notify(fd);
+ }
+-#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX) && !defined(QT_QWS_K2)
++#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX) && !defined(QT_QWS_K2) && !defined(QT_QWS_SLC700)
+ char fn[] = "/dev/ttyS?";
+ for (int ch='0'; ch<='3'; ch++) {
+ fn[9] = ch;
+@@ -1274,7 +1287,7 @@
+ numSamples(0), skipCount(0)
+ {
+ mouseFD = -1;
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2)
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+ if ( dev.isEmpty() )
+ #if defined(QT_QWS_IPAQ)
+ #ifdef QT_QWS_IPAQ_RAW
+@@ -1283,7 +1296,7 @@
+ dev = "/dev/h3600_ts";
+ #endif
+
+-#elif defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2)
++#elif defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+ //# ifdef QT_QWS_SL5XXX_TSRAW
+ # if 0
+ dev = "/dev/tsraw";
+@@ -1309,7 +1322,7 @@
+
+ QTPanelHandlerPrivate::~QTPanelHandlerPrivate()
+ {
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2)
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+ if (mouseFD >= 0)
+ close(mouseFD);
+ #endif
+@@ -1317,7 +1330,7 @@
+
+ void QTPanelHandlerPrivate::readMouseData()
+ {
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2)
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+ if(!qt_screen)
+ return;
+
+@@ -1336,7 +1349,7 @@
+ uchar *mb = mouseBuf+idx;
+ data = (TS_EVENT *) mb;
+ if(data->pressure >= QT_QWS_TP_PRESSURE_THRESHOLD) {
+-#ifdef QT_QWS_SL5XXX
++#if defined(QT_QWS_SL5XXX) || defined(QT_QWS_SLC700)
+ samples[currSample] = QPoint( 1000 - data->x, data->y );
+ #else
+ samples[currSample] = QPoint( data->x, data->y );
+@@ -2017,7 +2030,7 @@
+ handler = new QTSLibHandlerPrivate(mouseProtocol,mouseDev);
+ #elif defined(QT_QWS_YOPY)
+ handler = new QYopyTPanelHandlerPrivate(mouseProtocol,mouseDev);
+-#elif defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2)
++#elif defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+ handler = new QTPanelHandlerPrivate(mouseProtocol,mouseDev);
+ #elif defined(QT_QWS_CASSIOPEIA)
+ handler = new QVrTPanelHandlerPrivate( mouseProtocol, mouseDev );
diff --git a/packages/qte/qte-2.3.12/c7x0-w100-accel.patch b/packages/qte/qte-2.3.12/c7x0-w100-accel.patch
new file mode 100644
index 0000000000..06a723447c
--- /dev/null
+++ b/packages/qte/qte-2.3.12/c7x0-w100-accel.patch
@@ -0,0 +1,3414 @@
+ATI IMAGEON (W100) Accelerated support
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/configure
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/configure 2006-01-20 21:15:58.395868288 +0100
++++ qt-2.3.10-snapshot-20060120/configure 2006-01-20 21:17:39.451505496 +0100
+@@ -366,6 +366,9 @@
+ -accel-matrox)
+ QWS_ACCEL_MATROX=y
+ ;;
++ -accel-w100)
++ QWS_ACCEL_W100=y
++ ;;
+ -qvfb)
+ QWS_QVFB=y
+ ;;
+@@ -767,6 +770,10 @@
+ then
+ QT_CXX="$QT_CXX -DQT_NO_QWS_MATROX"
+ fi
++if [ -z "$QWS_ACCEL_W100" -a -n "$EMB" ]
++then
++ QT_CXX="$QT_CXX -DQT_NO_QWS_W100"
++fi
+ if [ -z "$QWS_VNC" -a -n "$EMB" ]
+ then
+ QT_CXX="$QT_CXX -DQT_NO_QWS_VNC"
+@@ -1398,6 +1405,7 @@
+ -accel-voodoo3 ..... Enable Voodoo3 acceleration.
+ -accel-mach64 ...... Enable Mach64 acceleration.
+ -accel-matrox ...... Enable Matrox MGA acceleration.
++ -accel-w100 ........ Enable ATI Imageon w100 acceleration (experimental).
+ -qvfb .............. Enable X11-based Qt Virtual Frame Buffer.
+ -vnc ............... Enable VNC server (requires network module).
+
+@@ -1522,6 +1530,7 @@
+ [ "x$JPEG" = "xyes" ] && QT_LIBS="${QT_LIBS} -ljpeg"
+ [ "x$MNG" = "xyes" ] && QT_LIBS="${QT_LIBS} -lmng -ljpeg" # assume JNG support
+ [ "x$NAS_SOUND" = "xyes" ] && QT_LIBS="${QT_LIBS} -laudio -lXt" # Xt junk in audio library
++[ "x$QWS_ACCEL_W100" = "xy" ] && QT_LIBS="${QT_LIBS} -laticore" # Aticore W100 support
+ QT_LIBS="$L_FLAGS $R_FLAGS $QT_LIBS $l_FLAGS"
+
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxraster_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfxraster_qws.cpp 2006-01-20 21:09:56.399900040 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxraster_qws.cpp 2006-01-20 21:17:39.454505040 +0100
+@@ -2699,7 +2699,6 @@
+ }
+ #endif
+ // Bresenham algorithm from Graphics Gems
+-
+ int ax=QABS(dx)*2;
+ int ay=QABS(dy)*2;
+ int sy=dy>0 ? 1 : -1;
+@@ -5984,6 +5983,10 @@
+ # include "qgfxmatrox_qws.cpp"
+ #endif
+
++#if !defined(QT_NO_QWS_W100)
++# include "qgfxw100_qws.cpp"
++#endif
++
+ #if !defined(QT_NO_QWS_VFB)
+ # include "qgfxvfb_qws.cpp"
+ #endif
+@@ -6038,6 +6041,9 @@
+ #if !defined(QT_NO_QWS_MATROX)
+ { "Matrox", qt_get_screen_matrox, 1 },
+ #endif
++#if !defined(QT_NO_QWS_W100)
++ { "W100", qt_get_screen_w100, 1 },
++#endif
+ #if !defined(QT_NO_QWS_TRANSFORMED)
+ { "Transformed", qt_get_screen_transformed, 0 },
+ #endif
+@@ -6078,6 +6084,8 @@
+ qt_screen = driverTable[i].qt_get_screen( display_id );
+ if ( qt_screen ) {
+ if ( qt_screen->connect( spec ) ) {
++ printf( "[%d]:Connected to screen '%s'\n",
++ getpid(), driverTable[i].name );
+ return qt_screen;
+ } else {
+ delete qt_screen;
+Index: qt-2.3.10-snapshot-20060120/src/3rdparty/kernel/aticore/aticore.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10-snapshot-20060120/src/3rdparty/kernel/aticore/aticore.h 2006-01-20 21:17:39.455504888 +0100
+@@ -0,0 +1,574 @@
++/*
++ * AtiCore 2D acceleration API
++ *
++ */
++
++#include <inttypes.h>
++#include <sys/types.h>
++
++#ifndef __W100API_H__
++#define __W100API_H__
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#define SolidRop_GXclear 0x00 /* 0 */
++#define SolidRop_GXand 0xa0 /* src AND dst */
++#define SolidRop_GXandReverse 0x50 /* src AND NOT dst */
++#define SolidRop_GXcopy 0xf0 /* src */
++#define SolidRop_GXandInverted 0x0a /* NOT src AND dst */
++#define SolidRop_GXnoop 0xaa /* dst */
++#define SolidRop_GXxor 0x5a /* src XOR dst */
++#define SolidRop_GXor 0xfa /* src OR dst */
++#define SolidRop_GXnor 0x05 /* NOT src AND NOT dst */
++#define SolidRop_GXequiv 0xa5 /* NOT src XOR dst */
++#define SolidRop_GXinvert 0x55 /* NOT dst */
++#define SolidRop_GXorReverse 0xf5 /* src OR NOT dst */
++#define SolidRop_GXcopyInverted 0x0f /* NOT src */
++#define SolidRop_GXorInverted 0xaf /* NOT src OR dst */
++#define SolidRop_GXnand 0x5f /* NOT src OR NOT dst */
++#define SolidRop_GXset 0xff /* 1 */
++
++#define BltRop_GXclear 0x00 /* 0 */
++#define BltRop_GXand 0x88 /* src AND dst */
++#define BltRop_GXandReverse 0x44 /* src AND NOT dst */
++#define BltRop_GXcopy 0xcc /* src */
++#define BltRop_GXandInverted 0x22 /* NOT src AND dst */
++#define BltRop_GXnoop 0xaa /* dst */
++#define BltRop_GXxor 0x66 /* src XOR dst */
++#define BltRop_GXor 0xee /* src OR dst */
++#define BltRop_GXnor 0x11 /* NOT src AND NOT dst */
++#define BltRop_GXequiv 0x99 /* NOT src XOR dst */
++#define BltRop_GXinvert 0x55 /* NOT dst */
++#define BltRop_GXorReverse 0xdd /* src OR NOT dst */
++#define BltRop_GXcopyInverted 0x33 /* NOT src */
++#define BltRop_GXorInverted 0xbb /* NOT src OR dst */
++#define BltRop_GXnand 0x77 /* NOT src OR NOT dst */
++#define BltRop_GXset 0xff /* 1 */
++
++#define DSTTYPE_8BPP 2 //8bpp
++#define DSTTYPE_16BPP_1555 3 //16 bpp aRGB 1555
++#define DSTTYPE_16BPP_444 5 //16 bpp aRGB 4444
++
++#define SRCTYPE_1BPP_OPA 0 //mono (expanded to frgd, bkgd)
++#define SRCTYPE_1BPP_TRA 1 //mono (expanded to frgd, leave_alone)
++#define SRCTYPE_EQU_DST 3 //color (same as DST)
++#define SRCTYPE_SOLID_COLOR_BLT 4 //solid color for Blt (use frgd)
++#define SRCTYPE_4BPP 5 //4 bpp
++#define SRCTYPE_12BPP_PACKED 6 //12 bpp packed
++
++#define ROP3_SRCCOPY 0xcc
++#define ROP3_PATCOPY 0xf0
++
++#define OVLTYPE_YUV420 7
++#define OVLTYPE_RGB565 8
++
++#define DP_BRUSH_8x8MONOOPA 0 //8x8 mono pattern (expanded to frgd, bkgd )
++#define DP_BRUSH_8x8MONOTRA 1 //8x8 mono pattern (expanded to frgd, leave alone )
++#define DP_PEN_32x1MONOOPA 6 //32x1 mono pattern (expanded to frgd, bkgd)
++#define DP_PEN_32x1MONOTRA 7 //32x1 mono pattern (expanded to frgd, leave alone)
++#define DP_BRUSH_8x8COLOR 10 //8x8 color pattern
++#define DP_BRUSH_SOLIDCOLOR 13 //solid color pattern (frgd)
++#define DB_BRUSH_NONE 15 //No brush used
++
++ typedef struct {
++ int16_t XCoord;
++ int16_t YCoord;
++ } ATI_POINT;
++
++ typedef struct {
++ int16_t XCoord;
++ int16_t YCoord;
++ int16_t Width;
++ int16_t Height;
++ } ATI_RECT;
++
++ typedef struct {
++ int16_t X_Top_Left; // x coordinate of top left corner
++ int16_t Y_Top_Left; // y coordinate of top left corner
++ int16_t X_Bottom_Right; // x coordinate of bottom right corner
++ int16_t Y_Bottom_Right; // y coordinate of bottom right corner
++ } ATI_CLIPRECT;
++
++ typedef struct {
++ uint32_t Count;
++ uint8_t ScaleXFactor;
++ uint8_t ScaleYFactor;
++ uint8_t BlendOn;
++ uint8_t dummy1;
++ } ATI_STRETCH;
++
++ typedef struct {
++ uint32_t *lpSrcBitmap; /* ¥µ¡¼¥Õ¥§¥¹¤Î¥ª¥Õ¥»¥Ã¥È */
++ uint16_t XCoord; /* +4 ³ÎÄê:¥µ¡¼¥Õ¥§¥¹Æâ¤ÎxºÂɸ */
++ uint16_t YCoord; /* +6 ³ÎÄê:¥µ¡¼¥Õ¥§¥¹Æâ¤ÎyºÂɸ */
++ uint16_t SrcPitch; /* +8 ³ÎÄê: */
++ uint16_t SrcHeight; /* +10 ³ÎÄê: */
++ uint16_t OverlayWidth; /* ¥ª¡¼¥Ð¥ì¥¤¤ÎÉý(Src¤È°ã¤¦Ãͤˤ·¤Æ¤â¡¢Æ°Åª¤Ë³ÈÂç½Ì¾®¤µ¤ì¤¿¤ê¤Ï¤·¤Ê¤¤¡¢°ÕÌ£¤¢¤ó¤Î¡©) */
++ uint16_t OverlayHeight;
++ uint32_t lpOverlayKey; /* +16 ³ÎÄê:Ææ(¥«¥é¡¼¥­¡¼¡©) */
++ uint8_t OverlayFormat; /* +20 ³ÎÄê */
++ uint8_t dummy1;
++ uint16_t dummy2;
++ } ATI_OVERLAYPROP; /* 24bytes? */
++
++ typedef struct {
++ int HInvert;
++ int VInvert;
++ } ATI_EXTVIDEOPROP;
++
++ typedef struct {
++ ATI_EXTVIDEOPROP ExtVideoProp;
++ } ATI_UNKNOWN1;
++
++ typedef struct {
++ unsigned long clr_cmp_fcn_src :3;
++ unsigned long :5;
++ unsigned long clr_cmp_fcn_dst :3;
++ unsigned long :13;
++ unsigned long clr_cmp_src :2;
++ unsigned long :6;
++ } clr_cmp_cntl_t;
++
++ typedef struct {
++ uint16_t x;
++ uint16_t y;
++ uint16_t w;
++ uint16_t h;
++ clr_cmp_cntl_t cmp_cntl;
++ unsigned long tcolour;
++ } transbitblt_t;
++
++ typedef struct {
++ uint32_t dummy1;
++ uint32_t dummy2;
++ uint8_t HExpansion; /* +8 ³ÎÄê */
++ uint8_t VExpansion; /* +9 ³ÎÄê */
++ uint8_t dummy3;
++ uint8_t dummy4;
++ uint8_t RConversion; /* +12 ³ÎÄê */
++ uint8_t dummy5;
++ uint8_t dummy6;
++ uint8_t dummy7;
++ ATI_UNKNOWN1 x;
++ } ATI_EXTENDEDOVERLAYPROP; /* 16byte? */
++
++ /**
++ * AtiCore initialization.
++ * Sets up the shared memory area
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_ProcessAttach( void );
++
++ /**
++ * AtiCore finish.
++ *
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_ProcessDetach( void );
++
++
++ /**
++ * Allocates a surface on the internal RAM.
++ * Perhaps there's a way to indicate to allocate on the
++ * internal RAM?
++ * @arg handle Reference to the returned surface handle
++ * @arg offset Returned offset of this surface on the video memory
++ * @arg size Size (bytes) to be reserved (16 multiple)
++ * @arg direction
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_AllocateSurface( uint16_t *handle, uint32_t *offset,
++ uint32_t size, uint32_t direction );
++
++ /**
++ * Deallocates a given surface.
++ * @arg handle Handle to the allocated surface
++ * (As returned by AllocateSurface)
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_DestroySurface( uint16_t handle );
++
++ /**
++ * Sets the kind of Raster Operation.
++ * @param rop Raster operation to be performed
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetRopOperation( uint32_t rop );
++
++ /**
++ * Sets the destination type for raster operation.
++ * @param dsttype
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetDstType( uint32_t dsttype );
++
++ /**
++ * Sets the source type for raster operation.
++ * @param srctype
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetSrcType( uint32_t srctype );
++
++ /**
++ * Sets Source clipping rectangle.
++ * @param cliprect Rectangle to perform clipping.
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetSrcClippingRect( ATI_CLIPRECT *cliprect );
++
++ /**
++ * Sets Destination clipping rectangle.
++ * @param cliprect Rectangle to perform clipping.
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetDstClippingRect(ATI_CLIPRECT *cliprect);
++
++ /**
++ * Sets pitch and offset for source in a raster operation.
++ * @param pitch Pitch (line width) of source
++ * @param offset Offset of source
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetSrcPitchOffset( int pitch, int offset );
++
++ /**
++ * Sets pitch and offset destination source in a raster operation.
++ * @param pitch Pitch (line width) of destination
++ * @param offset Offset of destination (memory offset)
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetDstPitchOffset( int pitch, int offset );
++
++ /**
++ * Performs a BitBlt with source rotation.
++ * @param flags Rotation degree
++ * @param dstRect Rectangle for destination Bitblitting
++ * @param srcRect Rectangle for origin bitblitting
++ * @test Tested with specified flags parameter
++ */
++ int AtiCore_BitBltFilpRotate( int flags,
++ ATI_RECT *dstRect,
++ ATI_RECT *srcRect);
++
++ /**
++ * Performs a BitBlt with source stretching.
++ * @param option Unknown
++ * @param point Unknown
++ * @param srcRect Source blitting surface
++ * @test Untested
++ */
++ int AtiCore_StretchBlt( ATI_STRETCH *option,
++ ATI_POINT *point,
++ ATI_RECT *srcRect);
++
++ /**
++ * Waits for the FIFO to be idle at least msecs.
++ * @param msecs Maximum time to wait for FIFO to idle
++ * @return 1:success, 0:fail
++ * @test Untested
++ */
++ int AtiCore_WaitComplete( int msec );
++
++ /**
++ * Allocates a new overlay handle.
++ * @param handle overlay
++ * @return 1:success, 0:fail
++ * @test Yes
++ */
++ int AtiCore_AllocOverlay( uint16_t *handle );
++
++ /**
++ * Deallocates a overlay handle.
++ * @param handle overlay
++ * @return 1:success, 0:fail
++ * @test Yes
++ */
++ int AtiCore_ReleaseOverlay( uint16_t handle );
++
++ /**
++ * Sets up an overlay given a handle an a set of properties.
++ * @param handle Allocated handle to setup the overlay.
++ * @param props Overlay properties struct
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetupOverlay( uint16_t handle, ATI_OVERLAYPROP *props );
++
++ /**
++ * Sets up extended overlay features.
++ * @param handle Allocated handle to an overlay
++ * @param props Extended overlay properties
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetupOverlayExtended( uint16_t handle,
++ ATI_EXTENDEDOVERLAYPROP *props );
++
++ /**
++ * Enable/Disable an overlayed surface.
++ * @param handle Overlay to be enabled/disabled
++ * @param enable 1: Enable, 0: Disable
++ * @return 1:success, 0:fail
++ * @test Tested
++ */
++ int AtiCore_SetOverlayOnOff( uint16_t handle, int enable );
++
++ /**
++ * Sets up the overlay position for a given handle.
++ * @param handle Overlay Handle
++ * @param x X Coordinate (Seems to be a bug with x < 4 )
++ * @param y Y Coordinate
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetOverlayPos( uint16_t handle,
++ uint16_t x,
++ uint16_t y );
++
++ /**
++ * Translates between physical/virtual addresses.
++ * @param offset VRAM offset to be translated
++ * @param viraddr Virtual address for VRAM
++ * @return 1:success,0:fail
++ */
++ int AtiCore_SetupMemoryTransfer( uint32_t offset,
++ uint32_t *viraddr );
++
++ /**
++ * Related with the previous one. It seems to be necesary to be called
++ * but I'm not sure of its function.
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_TerminateMemoryTransfer( void );
++
++ /**
++ * Returns the frontbuffer pitch and offset.
++ * @param pitch Return value for the frontbuffer pitch (width)
++ * @param offset Return value for the frontbuffer offset
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_GetFrontBufferPitchOffset( uint32_t *pitch,
++ uint32_t *offset );
++
++ /**
++ * Changes display brighness ?
++ * @param brightness -64...63
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetDisplayBrightness( int brightness );
++
++ /**
++ * Returns the amount of available internal/external memory.
++ * @param internal Pointer to return internal memory size
++ * @param external Pointer to return external memory size
++ * @return 1:success, 0:fail
++ */
++ int GetAvailableVideoMem( uint32_t *internal,
++ uint32_t *external );
++
++/**
++ *
++ *
++ *
++
++ {
++ (uint32_t) 0
++ (uint32_t) 0
++ (uint16_t) 480
++ (uint16_t) 640
++ (uint16_t) 480
++ (uint16_t) 640
++ (uint32_t) 5
++ */
++
++ typedef struct {
++ uint32_t dummy1;
++ ATI_RECT Size;
++ uint16_t Width;
++ uint16_t Height;
++ uint32_t Flag;
++ } ATI_GRAPHICWINDOW;
++
++ int AtiCore_SetupGraphicWindow(void* );
++
++ /**
++ * It seems to be necessary after AtiCore_ProcessAttach
++ * @param mode: 0xaaab for portrait, 0xaaaa for landscape
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_ProcessAttachSpecialMode( int mode );
++
++ /**
++ * Detach from the special mode. Whatever it means.
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_ProcessDetachSpecialMode( void );
++
++ /**
++ * Sets up the position of the Graphic viewport ?
++ * @param x X coordinate
++ * @param y Y coordinate
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetGraphicWindowPos( int x, int y );
++
++ /**
++ * Get the graphic viewport position.
++ * @param x Pointer to xcoord placeholder
++ * @param y Pointer to ycoord placeholder
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_GetGraphicWindowPos( int *x, int *y );
++
++ /**
++ * Sets up the frontbuffer position.
++ * @param offset VRAM offset to be used.
++ * @param x X Coordinate?
++ * @param y Y Coordinate?
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetFrontBuffer( int offset, int x, int y );
++
++ /**
++ * Enable/Disable the frontbuffer?
++ * @param enable 1 enables/ 0 disables
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetGraphicWindowOnOff( int enable );
++
++ /*
++ * Sets the foreground color.
++ * @param colour Color in 565 format (perhaps depends on the source format)
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetFrgColour( int colour );
++
++ /*
++ * Sets the background colour.
++ * @param colour Colour in 565 format (perhaps depends on the source format)
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_SetBkgColour( int colour );
++
++ /**
++ * Changes the painting brush
++ * @param btype Type of brush to use
++ * 4: Uses the pattern
++ * 6: SolidLine
++ * @param pattern Pointer to a 32 bit pattern
++ * @return 1:success, 0:fail
++ * @test Some values for btype produces a kind of antialiasing line
++ */
++ int AtiCore_BrushType( int btype, unsigned int *pattern );
++
++ /**
++ * Performs a rectangle paint.
++ * @param nrects Number of rectangles to be painted
++ * @param rects Array of rectangles to be painted
++ * @return 1:success, 0:fail
++ * @test Tested with nrects==1
++ */
++ int AtiCore_PaintRect( int nrects ,
++ ATI_RECT rects[] );
++
++ /**
++ * Draws a set of lines.
++ * @param npoints Number of points in the polyline set
++ * @param points Pointer to an array of ATI_POINT
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_Polyline( int npoints, ATI_POINT points[] );
++
++ int AtiCore_GetPitchOffsetProperty( void *, void *);
++
++ int AtiCore_CursorOnOff( int, int );
++
++ /**
++ * Performs a BitBlt ROP operation.
++ * @param unk Unknown (Always set to 1)
++ * @param dstrect Bounding destination rect
++ * @param srcrect Bounding source rect
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_BitBlt( int unk,
++ ATI_RECT *dstrect,
++ ATI_RECT *srcrect );
++
++ /**
++ * Performs a Transparent BitBlt ROP operation.
++ * @param dstrect Transparent DstRect bitblt argument
++ * @param srcrect Transparent SrcRect bitblt argument
++ * @return 1:success, 0:fail
++ * @test Doesn't work. It sets to zero CLR_CMP_CNTL and CLR_CMP_MSK
++ */
++ int AtiCore_TransBitBlt( transbitblt_t *dstrect,
++ transbitblt_t *srcrect );
++
++ int AtiCore_WakeUpCall( void );
++
++ /**
++ * Draws a set of pixels
++ * @param npoints Number of points to draw
++ * @param points Pointer to an array of ATI_POINT
++ * @return 1:success, 0:fail
++ */
++ int AtiCore_DrawPixel( int npoints, ATI_POINT *points );
++
++ int AtiCore_SetSysClk( unsigned short in0 );
++ int AtiCore_SetFastSysClk( unsigned short in0 );
++ int AtiCore_SetSlowSysClk( unsigned short in0 );
++
++ int AtiCore_GetCursorPos( unsigned long in0,
++ unsigned short *x,
++ unsigned short *y );
++
++
++
++/* ================================================================ */
++/* from libqte.so.2.3.2 */
++/*
++AtiCore_AlphaBlend
++
++AtiCore_Flush
++AtiCore_GammaCorrection
++AtiCore_GetCRC
++AtiCore_GetCursorPos
++AtiCore_GetDeviceInfo
++AtiCore_GetGPIO_Data
++AtiCore_GetGraphicExtended
++AtiCore_GetGraphicWindowPos
++AtiCore_GetLargestVideoMemBlock
++AtiCore_GetLastError
++AtiCore_GetMultiCRC
++AtiCore_GetOverlayPos
++AtiCore_Host
++AtiCore_LoadCursorBitMap
++AtiCore_PolyScanline
++AtiCore_ProcessAttachMinimal(void)?
++AtiCore_ProcessDetachMinimal(void)?
++AtiCore_ProcessDetachSpecialMode
++AtiCore_ReadCfgReg
++AtiCore_ReadMem(int, int)?
++AtiCore_ReadReg(int, int)?
++AtiCore_ScanlineShading
++AtiCore_SetApertures
++AtiCore_SetBytePixelOrder
++AtiCore_SetCursorPos
++AtiCore_SetDisplayParameters
++AtiCore_SetDriverBehaviour
++AtiCore_SetGPIO_Data
++AtiCore_SetOverlayPosUsingGraphicWindowXY
++AtiCore_SetPartialCursor
++AtiCore_SetupGraphicExtended
++AtiCore_SetupPM4
++AtiCore_SmallText
++AtiCore_SubmitPM4Packet
++AtiCore_WriteCfgReg
++AtiCore_WriteMem
++AtiCore_WriteReg
++ */
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxw100_qws.cpp
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxw100_qws.cpp 2006-01-20 21:17:39.459504280 +0100
+@@ -0,0 +1,2709 @@
++ /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil -*- */
++/***************************************************************************
++
++** Imageon driver for qte using libAticore
++** Manuel Teira( 2005 )
++** BUGS
++* - Enable again internal memory surfaces.
++****************************************************************************/
++#include <unistd.h>
++#include <stdio.h>
++#include <stdlib.h>
++#include <errno.h>
++#include <string.h>
++#include <dirent.h>
++#include <fcntl.h>
++#include <sys/types.h>
++#include <sys/mman.h>
++#include <sys/time.h>
++#include <time.h>
++
++#include <sys/ipc.h>
++#include <sys/shm.h>
++
++#include <qapplication.h>
++
++#ifndef __sparc__
++#include <sys/io.h>
++#endif
++
++#include "qgfxraster_qws.h"
++#include "qgfxlinuxfb_qws.h"
++#include <aticore/aticore.h>
++
++#include <stdarg.h>
++
++class W100Driver {
++public:
++
++ typedef enum Loglevel {
++ ERROR = 0,
++ WARNING,
++ INFO
++ };
++
++ typedef enum Opcodes {
++ DRAWLINE = 0,
++ DRAWPOINT,
++ DRAWPOINTS,
++ FILLRECT,
++ SCROLL,
++ BITBLT,
++ POLYLINE,
++ EOO
++ };
++
++ typedef enum Retcodes {
++ codOK,
++ codError
++ };
++
++
++ typedef struct Opcode {
++ QString str;
++ int index;
++ bool accelerated;
++ int hits;
++ int misses;
++ };
++
++ static Opcode lOpcodes[];
++
++ static QString level2str( int level )
++ {
++ switch( level ) {
++ case ERROR:
++ return QString( "ERROR" );
++ break;
++ case WARNING:
++ return QString( "WARNING" );
++ break;
++ case INFO:
++ return QString( "INFO" );
++ break;
++ default:
++ return QString( "UNKNOWN" );
++ break;
++ }
++ }
++
++ W100Driver():
++ m_loglevel( 0 ),
++ m_logenabled( 0 ),
++ m_logcount( 0 ),
++ m_attached( false )
++ {
++ m_pid = getpid();
++ m_loglevel = 0;
++ char *var;
++ if ( var = getenv( "W100_DEBUG" ) ) {
++ if ( strtol( var, 0, 0 ) == 1 ) {
++ m_logenabled = 1;
++ }
++ }
++
++ if ( m_logenabled ) {
++ if ( var = getenv( "W100_DEBUGLEVEL" ) ) {
++ if ( ( m_loglevel = strtol( var, 0, 0 ) ) < 0 ) {
++ m_loglevel = 0;
++ }
++ }
++
++ QString path( "/mnt/card/w100/w100debug.log" );
++ if ( var = getenv( "W100_DEBUGPATH" ) ) {
++ path = QString( var ) + "/w100debug.log";
++ }
++ m_logfile = fopen( path.latin1(), "a" );
++ if ( m_logfile == NULL ) m_logenabled = 0;
++ }
++
++ Opcode *opcodePtr = lOpcodes;
++ while ( opcodePtr->index != EOO ) {
++ QString varName = "W100_ACCEL_" + opcodePtr->str;
++ char *varPtr;
++ if ( ( varPtr = getenv( varName.latin1() ) ) ) {
++ if ( ( strtol( varPtr, NULL, 0 ) == 0 ) ||
++ ( strcmp( varPtr, "false" ) == 0 ) ) {
++ opcodePtr->accelerated = false;
++ }
++ }
++ opcodePtr++;
++ }
++ }
++
++ ~W100Driver()
++ {
++ //Dump statistics about any opcode
++ Opcode *opcodePtr = lOpcodes;
++ while ( opcodePtr->index != EOO ) {
++ log( WARNING, "Opcode %s. Accelerated=%s. Hits=%d. Misses=%d",
++ opcodePtr->str.latin1(),
++ opcodePtr->accelerated ? "true" : "false",
++ opcodePtr->hits,
++ opcodePtr->misses );
++ opcodePtr++;
++ }
++ if ( m_logenabled && m_logfile ) {
++ fclose( m_logfile );
++ }
++ }
++
++ bool accelerated( int opcode )
++ {
++ if ( !m_attached ) {
++ log( WARNING, "Asking for accelerated '%s' when not attached",
++ lOpcodes[opcode].str.latin1() );
++ return false;
++ }
++ if ( opcode < EOO ) {
++ if ( lOpcodes[opcode].accelerated ) {
++ return true;
++ } else {
++ log( WARNING, "Not accelerated '%s'",
++ lOpcodes[opcode].str.latin1() );
++ return false;
++ }
++ }
++ return false;
++ }
++
++ void addHit( int opcode )
++ {
++ lOpcodes[opcode].hits++;
++ }
++
++ void addMiss( int opcode )
++ {
++ lOpcodes[opcode].misses++;
++ }
++
++ void log( int level, const char *fmt, ... )
++ {
++ if ( m_logenabled && ( level <= m_loglevel ) ) {
++ timeval tv;
++ char buffer[1024];
++ va_list ap;
++ va_start( ap, fmt );
++ vsnprintf( buffer, 1023, fmt, ap );
++ va_end( ap );
++ gettimeofday( &tv, NULL );
++ fprintf( m_logfile, "(%010u.%06u)%d:%d:%s:%s\n",
++ tv.tv_sec, tv.tv_usec,
++ m_logcount++,
++ m_pid,
++ level2str( level ).latin1(),
++ buffer );
++ fflush( m_logfile );
++ }
++ }
++
++ bool attached( void ) const
++ {
++ return m_attached;
++ }
++
++ int processAttach( void )
++ {
++ if ( !m_attached ) {
++ if ( AtiCore_ProcessAttach() ) {
++ log( WARNING, "Process attached succesfully" );
++ m_attached = true;
++ return codOK;
++ } else {
++ log( WARNING, "Error attaching process" );
++ }
++ } else {
++ log( WARNING, "Process already attached" );
++ }
++ return codError;
++ }
++
++ int processDetach( void )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_ProcessDetach() ) {
++ log( WARNING, "Process detached succesfully" );
++ m_attached = false;
++ return codOK;
++ } else {
++ log( WARNING, "Error detaching process" );
++ }
++ } else {
++ log( WARNING, "Trying to detach while not attached" );
++ }
++ return codError;
++ }
++
++ int allocateSurface( uint16_t *handle, uint32_t *offset,
++ uint32_t size, uint32_t direction )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_AllocateSurface( handle, offset,
++ size, direction ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in allocateSurface" );
++ }
++ } else {
++ log( WARNING, "Trying to allocateSurface while not attached" );
++ }
++ return codError;
++ }
++
++ int destroySurface( uint16_t handle )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_DestroySurface( handle ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in destroySurface" );
++ }
++ } else {
++ log( WARNING, "Trying to destroySurface while not attached" );
++ }
++ return codError;
++ }
++
++ int drawPixel( int npoints, ATI_POINT *points )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_DrawPixel( npoints, points ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in drawPixel" );
++ }
++ } else {
++ log( WARNING, "Trying to drawPixel while not attached" );
++ }
++ return codError;
++ }
++
++ int setRopOperation( uint32_t rop )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetRopOperation( rop ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setRopOperation" );
++ }
++ } else {
++ log( WARNING, "Trying to setRopOperation while not attached" );
++ }
++ return codError;
++ }
++
++ int setDstType( uint32_t dtype )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetDstType( dtype ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setDstType" );
++ }
++ } else {
++ log( WARNING, "Trying to setDstType while not attached" );
++ }
++ return codError;
++ }
++
++ int setSrcType( uint32_t stype )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetSrcType( stype ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setSrcType" );
++ }
++ } else {
++ log( WARNING, "Trying to setSrcType while not attached" );
++ }
++ return codError;
++ }
++
++ int setSrcClippingRect( ATI_CLIPRECT *cliprect )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetSrcClippingRect( cliprect ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setSrcClippingRect" );
++ }
++ } else {
++ log( WARNING, "Trying to setSrcClippingRect while not attached" );
++ }
++ return codError;
++ }
++
++ int setDstClippingRect( ATI_CLIPRECT *cliprect )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetDstClippingRect( cliprect ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setDstClippingRect" );
++ }
++ } else {
++ log( WARNING, "Trying to setDstClippingRect while not attached" );
++ }
++ return codError;
++ }
++
++ int setSrcPitchOffset( int pitch, int offset )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetSrcPitchOffset( pitch, offset ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setSrcPitchOffset" );
++ }
++ } else {
++ log( WARNING, "Trying to setSrcPitchOffset while not attached" );
++ }
++ return codError;
++ }
++
++ int setDstPitchOffset( int pitch, int offset )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetDstPitchOffset( pitch, offset ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setDstPitchOffset" );
++ }
++ } else {
++ log( WARNING, "Trying to setDstPitchOffset while not attached" );
++ }
++ return codError;
++ }
++
++ int bitBltFlipRotate( int rot,
++ ATI_RECT *dstRect,
++ ATI_RECT *srcRect )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_BitBltFilpRotate( rot, dstRect, srcRect ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in bitBltFlipRotate" );
++ }
++ } else {
++ log( WARNING, "Trying to bitBltFlipRotate while not attached" );
++ }
++ return codError;
++ }
++
++ int stretchBlt( ATI_STRETCH *option,
++ ATI_POINT *point,
++ ATI_RECT *srcRect )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_StretchBlt( option, point, srcRect ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in stretchBlt" );
++ }
++ } else {
++ log( WARNING, "Trying to stretchBlt while not attached" );
++ }
++ return codError;
++ }
++
++ int waitComplete( int msec )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_WaitComplete( msec ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in waitComplete" );
++ }
++ } else {
++ log( WARNING, "Trying to waitComplete while not attached" );
++ }
++ return codError;
++ }
++
++ int allocOverlay( uint16_t *handle )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_AllocOverlay( handle ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in allocOverlay" );
++ }
++ } else {
++ log( WARNING, "Trying to allocOverlay while not attached" );
++ }
++ return codError;
++ }
++
++ int releaseOverlay( uint16_t handle )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_ReleaseOverlay( handle ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in releaseOverlay" );
++ }
++ } else {
++ log( WARNING, "Trying to releaseOverlay while not attached" );
++ }
++ return codError;
++ }
++
++ int setupOverlay( uint16_t handle, ATI_OVERLAYPROP *prop )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetupOverlay( handle, prop ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setupOverlay" );
++ }
++ } else {
++ log( WARNING, "Trying to setupOverlay while not attached" );
++ }
++ return codError;
++ }
++
++ int setupOverlayExtended( uint16_t handle,
++ ATI_EXTENDEDOVERLAYPROP *prop )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetupOverlayExtended( handle, prop ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setupOverlayExtended" );
++ }
++ } else {
++ log( WARNING, "Trying to setupOverlayExtended while not attached" );
++ }
++ return codError;
++ }
++
++ int setOverlayOnOff( uint16_t handle, int isShow )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetOverlayOnOff( handle, isShow ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setOverlayOnOff" );
++ }
++ } else {
++ log( WARNING, "Trying to setOverlayOnOff while not attached" );
++ }
++ return codError;
++ }
++
++ int setOverlayPos( uint16_t handle, uint16_t x, uint16_t y )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetOverlayPos( handle, x, y ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setOverlayPos" );
++ }
++ } else {
++ log( WARNING, "Trying to setOverlayPos while not attached" );
++ }
++ return codError;
++ }
++
++ int setupMemoryTransfer( uint32_t offset, uint32_t *regdata )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetupMemoryTransfer( offset, regdata ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setupMemoryTransfer" );
++ }
++ } else {
++ log( WARNING, "Trying to setupMemoryTransfer while not attached" );
++ }
++ return codError;
++ }
++
++ int terminateMemoryTransfer( void )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_TerminateMemoryTransfer() ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in terminateMemoryTransfer" );
++ }
++ } else {
++ log( WARNING, "Trying to terminateMemoryTransfer while not attached" );
++ }
++ return codError;
++ }
++
++ int getFrontBufferPitchOffset( uint32_t *pitch, uint32_t *offset )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_GetFrontBufferPitchOffset( pitch, offset ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in getFrontBufferPitchOffset" );
++ }
++ } else {
++ log( WARNING, "Trying to getFrontBufferPitchOffset while not attached" );
++ }
++ return codError;
++ }
++
++ int setDisplayBrightness( int bri )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetDisplayBrightness( bri ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setDisplayBrightness" );
++ }
++ } else {
++ log( WARNING, "Trying to setDisplayBrighness while not attached" );
++ }
++ return codError;
++ }
++
++ int getAvailableVideoMem( uint32_t *internal, uint32_t *external )
++ {
++ if ( m_attached ) {
++ if ( GetAvailableVideoMem( internal, external ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in getAvailableVideoMem" );
++ }
++ } else {
++ log( WARNING, "Trying to getAvailableVideoMem while not attached" );
++ }
++ return codError;
++ }
++
++ int setupGraphicWindow( ATI_GRAPHICWINDOW *win )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetupGraphicWindow( ( void * ) win ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setupGraphicWindow" );
++ }
++ } else {
++ log( WARNING, "Trying to setupGraphicWindow while not attached" );
++ }
++ return codError;
++ }
++
++ int processAttachSpecialMode( int mode )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_ProcessAttachSpecialMode( mode ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in processAttachSpecialMode" );
++ }
++ } else {
++ log( WARNING, "Trying to processAttachSpecialMode while not attached" );
++ }
++ return codError;
++ }
++
++ int processDetachSpecialMode( void )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_ProcessDetachSpecialMode() ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in processDetachSpecialMode" );
++ }
++ } else {
++ log( WARNING, "Trying to processDetachSpecialMode while not attached" );
++ }
++ return codError;
++ }
++
++ int setGraphicWindowPos( int x, int y )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetGraphicWindowPos( x, y ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setGraphicWindowPos" );
++ }
++ } else {
++ log( WARNING, "Trying to setGraphicWindow while not attached" );
++ }
++ return codError;
++ }
++
++ int setFrontBuffer( int offset, int a, int b )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetFrontBuffer( offset, a, b ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setFrontBuffer" );
++ }
++ } else {
++ log( WARNING, "Trying to setFrontBuffer while not attached" );
++ }
++ return codError;
++ }
++
++ int setGraphicWindowOnOff( int val )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetGraphicWindowOnOff( val ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setGraphicWindowOnOff" );
++ }
++ } else {
++ log( WARNING, "Trying to setGraphicWindowOnOff while not attached" );
++ }
++ }
++
++ static unsigned long ccolor( unsigned int rgb )
++ {
++ unsigned char r = ( rgb & 0xff0000 ) >> 19;
++ unsigned char g = ( rgb & 0xff00 ) >> 10;
++ unsigned char b = ( rgb & 0xff ) >> 3;
++ return ( ( ( ( unsigned short )0x1f & r ) << 11 ) |
++ ( ( ( unsigned short )0x3f & g ) << 5 ) |
++ ( ( ( unsigned short )0x1f & b ) ) );
++ }
++
++ int setFrgColour( int val )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_SetFrgColour( ccolor( val ) ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in setFrgColour" );
++ }
++ } else {
++ log( WARNING, "Trying to setFrgColour while not attached" );
++ }
++ return codError;
++ }
++
++ int brushType( int type, unsigned int pattern )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_BrushType( type, &pattern ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in brushType" );
++ }
++ } else {
++ log( WARNING, "Trying to brushType while not attached" );
++ }
++ return codError;
++ }
++
++ int paintRect( int flags, ATI_RECT *rect )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_PaintRect( flags, rect ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in paintRect" );
++ }
++ } else {
++ log( WARNING, "Trying to paintRect while not attached" );
++ }
++ return codError;
++ }
++
++ int polyline( int npoints, ATI_POINT *points )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_Polyline( npoints, points ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in polyline" );
++ }
++ } else {
++ log( WARNING, "Trying to polyline while not attached" );
++ }
++ return codError;
++ }
++
++ int getPitchOffsetProperty( void *pitch, void *offset )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_GetPitchOffsetProperty( pitch, offset ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in getPitchOffsetProperty" );
++ }
++ } else {
++ log( WARNING, "Trying to getPitchOffsetProperty while not attached" );
++ }
++ return codError;
++ }
++
++ int cursorOnOff( int a, int b )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_CursorOnOff( a, b ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in cursorOnOff" );
++ }
++ } else {
++ log( WARNING, "Trying to cursorOnOff while not attached" );
++ }
++ return codError;
++ }
++
++ int bitBlt( int flags, ATI_RECT *dst, ATI_RECT *src )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_BitBlt( flags, dst, src ) ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in bitBlt" );
++ }
++ } else {
++ log( WARNING, "Trying to bitBlt while not attached" );
++ }
++ return codError;
++ }
++
++ int wakeUpCall( void )
++ {
++ if ( m_attached ) {
++ if ( AtiCore_WakeUpCall() ) {
++ return codOK;
++ } else {
++ log( ERROR, "Error in wakeUpCall" );
++ }
++ } else {
++ log( WARNING, "Trying to wakeupCall while not attached" );
++ }
++ return codError;
++ }
++
++private:
++ FILE *m_logfile;
++ int m_loglevel;
++ bool m_logenabled;
++ bool m_attached;
++ int m_pid;
++ int m_logcount;
++};
++
++W100Driver::Opcode W100Driver::lOpcodes[] = {
++ { "DRAWLINE", W100Driver::DRAWLINE, true, 0, 0 },
++ { "DRAWPOINT", W100Driver::DRAWPOINT, true, 0, 0 },
++ { "DRAWPOINTS", W100Driver::DRAWPOINTS, true, 0, 0 },
++ { "FILLRECT", W100Driver::FILLRECT, true, 0, 0 },
++ { "SCROLL", W100Driver::SCROLL, true, 0, 0 },
++ { "BITBLT", W100Driver::BITBLT, true, 0, 0 },
++ { "POLYLINE", W100Driver::POLYLINE, true, 0, 0 },
++ { "" , W100Driver::EOO, false, 0, 0 }
++};
++
++W100Driver driver;
++
++class QW100Screen;
++static QW100Screen *qt_w100_screen = 0;
++
++class QW100Screen : public QLinuxFbScreen {
++public:
++ class HWSurface {
++ public:
++ HWSurface( void ):
++ m_handle( 0 ),
++ m_offset( 0 ),
++ m_addr( 0 ),
++ m_size( 0 ),
++ m_internal( false ),
++ m_clientid( -1 ) {};
++ HWSurface( unsigned short handle,
++ uint32_t sOffset,
++ unsigned char *localAddr,
++ int amount,
++ bool internal,
++ int clientid ):
++ m_handle( handle ),
++ m_offset( sOffset ),
++ m_addr( localAddr ),
++ m_size( amount ),
++ m_internal( internal ),
++ m_clientid( clientid ) {};
++ HWSurface( uint32_t sOffset,
++ unsigned char *localAddr,
++ bool internal,
++ int amount ):
++ m_handle( 0 ),
++ m_offset( sOffset ),
++ m_addr( localAddr ),
++ m_size( amount ),
++ m_internal( internal ),
++ m_clientid( -1 ) {};
++ bool operator!=( HWSurface &other ) {
++ return( m_offset == other.getSOffset() );
++ };
++ HWSurface &operator=( const HWSurface &c ) {
++ m_handle = c.getHandle();
++ m_offset = c.getSOffset();
++ m_addr = c.getAddr();
++ m_size = c.getSize();
++ m_clientid= c.getCId();
++ m_internal = c.internal();
++ return( *this );
++ };
++ unsigned short getHandle( void ) const { return m_handle; };
++ uint32_t getSOffset( void ) const { return m_offset; };
++ unsigned char *getAddr( void ) const { return m_addr; };
++ unsigned int getSize( void ) const { return m_size; };
++ int getCId( void ) const { return m_clientid; };
++ bool internal( void ) const { return m_internal; };
++
++ private:
++ unsigned short m_handle;
++ uint32_t m_offset;
++ unsigned char *m_addr;
++ int m_size;
++ bool m_internal;
++ int m_clientid;
++ };
++
++ QW100Screen( int display_id );
++ virtual ~QW100Screen();
++ virtual bool connect( const QString &spec );
++ virtual void disconnect( void );
++ virtual bool initDevice();
++ virtual void shutdownDevice();
++ virtual void restore();
++ virtual bool useOffscreen() { return true; }
++ virtual QGfx * createGfx( unsigned char *, int, int, int, int);
++ virtual uchar *cache( int amount, int optim );
++ virtual void uncache( uchar *c );
++ virtual bool onCard( unsigned char *p ) const;
++ virtual bool onCard( unsigned char *p, ulong& offset ) const;
++ QMap< uchar*, HWSurface > *getPSurfaceMap( void ) const;
++ void clearCache( int clientId );
++
++ // Suspend/resume hooks
++ virtual void prepareToSuspend();
++ virtual void prepareToResume();
++ // Rotation stuff
++ enum Transformation { None, Rot90, Rot180, Rot270 };
++ void setTransformation( Transformation t );
++ Transformation transformation() const;
++ virtual bool isTransformed() const { return trans != None; };
++ virtual QSize mapToDevice( const QSize & ) const;
++ virtual QSize mapFromDevice( const QSize & ) const;
++ virtual QPoint mapToDevice( const QPoint &, const QSize & ) const;
++ virtual QPoint mapFromDevice( const QPoint &, const QSize & ) const;
++ virtual QRect mapToDevice( const QRect &, const QSize & ) const;
++ virtual QRect mapFromDevice( const QRect &, const QSize & ) const;
++ virtual QImage mapToDevice( const QImage & ) const;
++ virtual QImage mapFromDevice( const QImage & ) const;
++ virtual QRegion mapToDevice( const QRegion &, const QSize & ) const;
++ virtual QRegion mapFromDevice( const QRegion &, const QSize & ) const;
++ virtual int transformOrientation() const;
++
++protected:
++ bool w100init();
++ void w100shutdown();
++ Transformation trans;
++ static Transformation getTransSpec( const QString &dspec );
++ static void clearCache( QScreen *instance, int clientId );
++ QMap< uchar*, HWSurface > surfaceMap;
++ int vramoffset;
++ bool m_isServer;
++ virtual int pixmapLinestepAlignment() { return 128; }
++};
++
++template <const int depth, const int type>
++class QGfxW100 : public QGfxRaster<depth,type> {
++
++public:
++ QGfxW100( unsigned char *b, int w, int h );
++ virtual void drawLine( int, int, int, int);
++ virtual void fillRect( int, int, int, int);
++ virtual void blt( int, int, int, int, int, int );
++ virtual void sync();
++ virtual void setOffset( int x, int y );
++ virtual void setPen( const QPen & p );
++
++ virtual void drawPolyline( const QPointArray &, int, int );
++ virtual void drawPolygon( const QPointArray &, bool, int, int );
++ virtual void drawPoint( int, int );
++ virtual void drawPoints( const QPointArray &, int, int );
++ virtual void scroll( int, int, int, int, int, int );
++ virtual void tiledBlt( int rx, int ry, int w, int h );
++
++ inline int tx( int x, int y ) {
++ switch ( qt_w100_screen->transformation() ) {
++ case QW100Screen::Rot90:
++ return y - this->xoffs + this->yoffs;
++ case QW100Screen::Rot180:
++ return ( this->width - x - 1) - this->xoffs - this->xoffs;
++ case QW100Screen::Rot270:
++ return ( this->height - y - 1) - this->xoffs - this->yoffs;
++ default:
++ return x;
++ }
++ }
++ inline int ty( int x, int y ) {
++ switch ( qt_w100_screen->transformation() ) {
++ case QW100Screen::Rot90:
++ return (this->width - x - 1) - this->yoffs - this->xoffs;
++ case QW100Screen::Rot180:
++ return (this->height - y - 1) - this->yoffs - this->yoffs;
++ case QW100Screen::Rot270:
++ return x - this->yoffs + this->xoffs;
++ default:
++ return y;
++ }
++ }
++
++protected:
++ bool checkDest( bool setsrc = false );
++ bool checkSourceDest();
++ virtual void setSourceWidgetOffset( int x, int y );
++ void processSpans( int n, QPoint* point, int* width );
++ bool inDraw;
++
++ virtual void dDrawLine( int, int, int, int);
++ virtual void dFillRect( int, int, int, int);
++ virtual void dBlt( int, int, int, int, int, int );
++ void dDrawPolyline( const QPointArray &, int, int );
++ void dDrawPolygon( const QPointArray &, bool, int, int );
++ void dDrawPoint( int, int );
++ void dDrawPoints( const QPointArray &, int, int );
++ void dScroll( int, int, int, int, int, int );
++ void dTiledBlt( int rx, int ry, int w, int h );
++};
++
++template<const int depth,const int type>
++QGfxW100<depth,type>::QGfxW100( unsigned char * b, int w, int h )
++ : QGfxRaster<depth,type>(b, w, h),
++ inDraw( false )
++{
++}
++
++template<const int depth,const int type>
++inline void QGfxW100<depth,type>::setOffset( int x, int y )
++{
++ QGfxRaster<depth,type>::setOffset( x, y );
++}
++
++namespace {
++ QString penStyleStr( const QPen &pen )
++ {
++ QString res;
++ switch( pen.style() ) {
++ case Qt::NoPen:
++ res = "NoPen";
++ break;
++ case Qt::SolidLine:
++ res = "SolidLine";
++ break;
++ case Qt::DashLine:
++ res = "DashLine";
++ break;
++ case Qt::DotLine:
++ res = "DotLine";
++ break;
++ case Qt::DashDotLine:
++ res = "DashDotLine";
++ break;
++ case Qt::DashDotDotLine:
++ res = "DashDotDotLine";
++ break;
++ default:
++ res = "Unknown";
++ }
++ return res;
++ }
++}
++
++template<const int depth, const int type>
++inline void QGfxW100<depth,type>::setPen( const QPen &p )
++{
++ QGfxRaster<depth,type>::setPen( p );
++}
++
++template<const int depth,const int type>
++inline bool QGfxW100<depth,type>::checkSourceDest()
++{
++ if ( !checkDest() ) {
++ return FALSE;
++ }
++
++ int sourcepixelpitch;
++ ulong src_buffer_offset;
++ if ( this->srctype == this->SourcePen ) {
++ src_buffer_offset = -1;
++ return FALSE;
++ } else {
++ if ( !qt_screen->onCard( this->srcbits, src_buffer_offset ) ) {
++ return FALSE;
++ }
++ sourcepixelpitch = ( this->srclinestep * 8 ) / this->srcdepth;
++ driver.setSrcPitchOffset( sourcepixelpitch,
++ src_buffer_offset );
++ }
++ return TRUE;
++}
++
++template< const int depth, const int type>
++inline bool QGfxW100<depth, type>::checkDest( bool setsrc )
++{
++ //Main framebuffer should be registered as a hardware surface
++ ulong buffer_offset;
++ if ( !qt_screen->onCard( this->buffer, buffer_offset ) ) {
++ return FALSE;
++ }
++ int pixelstep = ( this->linestep() * 8 ) / depth;
++ driver.setDstPitchOffset( pixelstep, buffer_offset );
++ if ( setsrc ) {
++ driver.setSrcPitchOffset( pixelstep, buffer_offset );
++ }
++ return TRUE;
++}
++
++template<const int depth,const int type>
++void QGfxW100<depth,type>::drawLine( int x1, int y1, int x2, int y2 )
++{
++ if ( inDraw ) {
++ dDrawLine( x1, y1, x2, y2 );
++ } else {
++ inDraw = true;
++ dDrawLine( tx(x1,y1), ty(x1,y1),
++ tx(x2,y2), ty(x2,y2) );
++ inDraw = false;
++ }
++}
++
++template<const int depth,const int type>
++void QGfxW100<depth,type>::dDrawLine( int x1, int y1, int x2, int y2 )
++{
++ if ( ( this->ncliprect < 1) ||
++ ( this->cpen.style() == this->NoPen ) ) {
++ return;
++ }
++
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::DRAWLINE ) ) {
++ driver.addMiss( W100Driver::DRAWLINE );
++ QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2 );
++ return;
++ }
++
++ // Only handle 'normal' lines
++ if ( ( this->cpen.style() != this->SolidLine ) ||
++ ( this->myrop != this->CopyROP ) ||
++ ( this->cpen.width() > 1 ) ||
++ ( this->dashedLines ) ) {
++ driver.addMiss( W100Driver::DRAWLINE );
++ QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2);
++ return;
++ }
++
++ // Stop anyone else trying to access optype/lastop/the graphics engine
++ // to avoid synchronization problems with other processes
++ QWSDisplay::grab( true );
++ if ( !checkDest() ) {
++ QWSDisplay::ungrab();
++ driver.addMiss( W100Driver::DRAWLINE );
++ QGfxRaster<depth,type>::drawLine( x1, y1, x2, y2 );
++ return;
++ }
++
++
++ // Note that the last operation used the 2d engine
++ ( *optype ) = 1;
++
++ // Add the offset of the gfx - used to make the origin the right
++ // place for windows
++ x1 += this->xoffs;
++ y1 += this->yoffs;
++ x2 += this->xoffs;
++ y2 += this->yoffs;
++
++ QRect boundRect( x1 < x2 ? x1: x2,
++ y1 < y2 ? y1 : y2,
++ QABS( x2 - x1 ) + 1,
++ QABS( y2 - y1 ) + 1 );
++
++ GFX_START( boundRect );
++
++ // The clip region is defined as a series of rectangles
++ // We repeatedly set up the hardware clip rectangle to one of
++ // these rectangles and re-draw the line - an alternative approach
++ // would be to clip to the rectangle in software
++
++ driver.setDstType( DSTTYPE_16BPP_1555 );
++ driver.setSrcType( SRCTYPE_EQU_DST );
++ driver.setRopOperation( ROP3_PATCOPY );
++ driver.brushType( 6, 0 );
++ driver.setFrgColour( this->cpen.color().rgb() );
++ driver.addHit( W100Driver::DRAWLINE );
++
++ //The imageon seems not to write on the edge of the clip
++ //for the polyline op.
++ //We are using a three points array repeating the last point
++ //to get the last single point painted.
++ ATI_POINT points[3];
++ points[0].XCoord = x1;
++ points[0].YCoord = y1;
++ points[1].XCoord = x2;
++ points[1].YCoord = y2;
++ points[2].XCoord = x2;
++ points[2].YCoord = y2;
++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ if ( boundRect.intersects( this->cliprect[loopc] ) ) {
++ ATI_CLIPRECT clip;
++ clip.X_Top_Left = this->cliprect[loopc].x();
++ clip.Y_Top_Left = this->cliprect[loopc].y();
++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++ driver.setDstClippingRect( &clip );
++ driver.polyline( 3, points );
++ }
++ }
++
++ // Software mouse cursor stuff
++ GFX_END;
++
++ // Release display again - not doing so will cause Qt/Embedded applications
++ // to deadlock
++ QWSDisplay::ungrab();
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPolyline( const QPointArray &a,
++ int index,
++ int npoints )
++{
++ if ( inDraw ) {
++ dDrawPolyline( a, index, npoints );
++ } else {
++ inDraw = true;
++ QPointArray na( npoints );
++
++ for ( int i = 0; i < npoints; i++ ) {
++ int x, y;
++ a.point( i+index, &x, &y );
++ na.setPoint( i, tx(x,y), ty(x,y) );
++ }
++
++ dDrawPolyline( na, 0, npoints );
++ inDraw = false;
++ }
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::dDrawPolyline( const QPointArray &a,
++ int index,
++ int npoints )
++{
++ if ( ( this->ncliprect < 1 ) ||
++ ( npoints < 1 ) ||
++ ( this->cpen.style() == this->NoPen ) ) {
++ return;
++ }
++
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::POLYLINE ) ) {
++ driver.addMiss( W100Driver::POLYLINE );
++ QGfxRaster<depth,type>::drawPolyline( a, index, npoints );
++ return;
++ }
++
++ if ( this->cpen.style() != this->SolidLine ||
++ this->myrop != this->CopyROP ) {
++ driver.addMiss( W100Driver::POLYLINE );
++ QGfxRaster<depth,type>::drawPolyline( a, index, npoints );
++ return;
++ }
++
++ QWSDisplay::grab( TRUE );
++ if ( !checkDest() ) {
++ QWSDisplay::ungrab();
++ driver.addMiss( W100Driver::POLYLINE );
++ QGfxRaster<depth,type>::drawPolyline( a, index, npoints );
++ return;
++ }
++
++ ( *optype ) = 1;
++
++ driver.setDstType( DSTTYPE_16BPP_1555 );
++ driver.setSrcType( SRCTYPE_EQU_DST );
++ driver.setRopOperation( ROP3_PATCOPY );
++ driver.brushType( 6, 0 );
++ driver.setFrgColour( this->cpen.color().rgb() );
++
++ driver.addHit( W100Driver::POLYLINE );
++
++ ATI_POINT *points = new ATI_POINT[ npoints + 1 ];
++
++ for ( int i = 0; i < npoints; i++ ) {
++ points[i].XCoord = a[i+index].x() + this->xoffs;
++ points[i].YCoord = a[i+index].y() + this->yoffs;
++ }
++ //Hack to get the last point of the last line painted
++ points[ npoints ] = points[ npoints - 1 ];
++
++
++ GFX_START( clipbounds );
++ driver.setFrgColour( this->cpen.color().rgb() );
++ driver.setRopOperation( ROP3_PATCOPY );
++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ ATI_CLIPRECT clip;
++ clip.X_Top_Left = this->cliprect[loopc].x();
++ clip.Y_Top_Left = this->cliprect[loopc].y();
++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++ driver.setDstClippingRect( &clip );
++ driver.polyline( npoints + 1, points );
++ }
++ GFX_END;
++
++ delete [] points;
++
++ QWSDisplay::ungrab();
++}
++
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPolygon( const QPointArray &a,
++ bool w, int index,
++ int npoints )
++{
++ if ( inDraw || this->cpen.style()==this->NoPen || this->patternedbrush ) {
++ //slowpath
++ dDrawPolygon( a, w, index, npoints );
++ } else {
++ inDraw = TRUE;
++ QPointArray na( npoints );
++
++ for ( int i = 0; i < npoints; i++ ) {
++ int x,y;
++ a.point( i+index, &x, &y );
++ na.setPoint( i, tx(x,y), ty(x,y) );
++ }
++ dDrawPolygon( na, w, 0, npoints );
++ inDraw = FALSE;
++ }
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::dDrawPolygon( const QPointArray &a, bool w, int index, int npoints )
++{
++ QGfxRaster<depth,type>::drawPolygon( a, w, index, npoints );
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPoint( int x, int y )
++{
++ dDrawPoint( tx( x, y ), ty( x, y ) );
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::dDrawPoint( int x, int y )
++{
++
++ if ( this->ncliprect < 1 ) {
++ return;
++ }
++
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::DRAWPOINT) ) {
++ driver.addMiss( W100Driver::DRAWPOINT );
++ QGfxRaster<depth,type>::drawPoint( x, y );
++ return;
++ }
++
++ if ( this->cpen.style() != this->SolidLine ||
++ this->myrop != this->CopyROP ) {
++ driver.addMiss( W100Driver::DRAWPOINT );
++ QGfxRaster<depth,type>::drawPoint( x, y );
++ return;
++ }
++
++ QWSDisplay::grab( TRUE );
++ if ( !checkDest() ) {
++ QWSDisplay::ungrab();
++ driver.addMiss( W100Driver::DRAWPOINT );
++ QGfxRaster<depth,type>::drawPoint( x, y );
++ return;
++ }
++
++ driver.addHit( W100Driver::DRAWPOINT );
++ ( *optype ) = 1;
++
++ ATI_POINT point;
++ point.XCoord = x + this->xoffs;
++ point.YCoord = y + this->yoffs;
++
++ GFX_START( clipbounds );
++ driver.setFrgColour( this->cpen.color().rgb() );
++ driver.setRopOperation( ROP3_PATCOPY );
++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ ATI_CLIPRECT clip;
++ clip.X_Top_Left = this->cliprect[loopc].x();
++ clip.Y_Top_Left = this->cliprect[loopc].y();
++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++ driver.setDstClippingRect( &clip );
++ driver.drawPixel( 1, &point );
++ }
++ GFX_END;
++ QWSDisplay::ungrab();
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::drawPoints( const QPointArray &a,
++ int index,
++ int npoints )
++{
++ QPointArray na( npoints );
++
++ for ( int i = 0; i < npoints; i++ ) {
++ int x, y;
++ a.point( i+index, &x, &y );
++ na.setPoint( i, tx( x, y ), ty( x, y ) );
++ }
++
++ dDrawPoints( na, 0, npoints );
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::dDrawPoints( const QPointArray &a,
++ int index,
++ int npoints )
++{
++ if ( ( this->ncliprect < 1 ) || ( npoints < 1 ) ) {
++ return;
++ }
++
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::DRAWPOINTS ) ) {
++ driver.addMiss( W100Driver::DRAWPOINTS );
++ QGfxRaster<depth,type>::drawPoints( a, index, npoints );
++ return;
++ }
++
++ if ( this->cpen.style() != this->SolidLine ||
++ this->myrop != this->CopyROP ) {
++ driver.addMiss( W100Driver::DRAWPOINTS );
++ QGfxRaster<depth,type>::drawPoints( a, index, npoints );
++ return;
++ }
++
++ QWSDisplay::grab( TRUE );
++ if ( !checkDest() ) {
++ QWSDisplay::ungrab();
++ driver.addMiss( W100Driver::DRAWPOINTS );
++ QGfxRaster<depth,type>::drawPoints( a, index, npoints );
++ return;
++ }
++
++ driver.addHit( W100Driver::DRAWPOINTS );
++ ( *optype ) = 1;
++
++ ATI_POINT *points = new ATI_POINT[ npoints ];
++ for ( int i = 0; i < npoints; i++ ) {
++ points[i].XCoord = a[i+index].x() + this->xoffs;
++ points[i].YCoord = a[i+index].y() + this->yoffs;
++ }
++
++ GFX_START( clipbounds );
++ driver.setFrgColour( this->cpen.color().rgb() );
++ driver.setRopOperation( ROP3_PATCOPY );
++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ ATI_CLIPRECT clip;
++ clip.X_Top_Left = this->cliprect[loopc].x();
++ clip.Y_Top_Left = this->cliprect[loopc].y();
++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1;
++ driver.setDstClippingRect( &clip );
++ driver.drawPixel( npoints, points );
++ }
++ GFX_END;
++
++ delete [] points;
++ QWSDisplay::ungrab();
++}
++
++template <const int depth, const int type>
++void QGfxW100<depth,type>::scroll( int x, int y, int w, int h, int sx, int sy )
++{
++ if ( w == 0 || h == 0 )
++ return;
++ QRect r;
++ QRect s;
++ if ( inDraw ) {
++ r = QRect( x, y, w, h );
++ s = QRect( sx, sy, w, h );
++ } else {
++ r.setCoords( tx(x,y), ty(x,y), tx(x+w-1,y+h-1), ty(x+w-1,y+h-1) );
++ s.setCoords( tx(sx,sy), ty(sx,sy), tx(sx+w-1,sy+h-1), ty(sx+w-1,sy+h-1) );
++ r = r.normalize();
++ s = s.normalize();
++ }
++ dScroll( r.x(), r.y(), r.width(), r.height(), s.x(), s.y() );
++}
++
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::dScroll( int rx, int ry,
++ int w, int h,
++ int sx, int sy )
++{
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::SCROLL ) ) {
++ driver.addMiss( W100Driver::SCROLL );
++ QGfxRaster<depth,type>::scroll( rx, ry, w, h, sx, sy );
++ return;
++ }
++
++ if ( this->ncliprect < 1 ) return;
++
++ if ( ( w < 1 ) || ( h < 1 ) ) return;
++
++ int dy = sy - ry;
++ int dx = sx - rx;
++
++ if ( dx == 0 && dy == 0 ) return;
++
++
++ QWSDisplay::grab( TRUE );
++
++ if ( checkDest( true ) ) {
++
++ rx += this->xoffs;
++ sx += this->xoffs;
++ ry += this->yoffs;
++ sy += this->yoffs;
++
++ QRect boundRect( QMIN( rx , sx ),
++ QMIN( ry , sy ),
++ w + QABS( dx ) + 1,
++ h + QABS( dy ) + 1 );
++ GFX_START( boundRect );
++ ( *optype ) = 1;
++
++
++ //if ( driver.lastOp() != W100Driver::SCROLL ) {
++ driver.setRopOperation( ROP3_SRCCOPY );
++ driver.setDstType( DSTTYPE_16BPP_1555 );
++ driver.setSrcType( SRCTYPE_EQU_DST );
++ //}
++
++ driver.addHit( W100Driver::SCROLL );
++
++ ATI_RECT srcrect, dstrect;
++
++ srcrect.XCoord = sx;
++ srcrect.YCoord = sy;
++ srcrect.Width = w;
++ srcrect.Height = h;
++ dstrect.XCoord = rx;
++ dstrect.YCoord = ry;
++ dstrect.Width = w;
++ dstrect.Height = h;
++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ if ( boundRect.intersects( this->cliprect[loopc] ) ) {
++ ATI_CLIPRECT clip;
++ clip.X_Top_Left = this->cliprect[ loopc ].x();
++ clip.Y_Top_Left = this->cliprect[ loopc ].y();
++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1;
++ driver.setDstClippingRect( &clip );
++ driver.bitBlt( 1, &dstrect, &srcrect );
++ }
++ }
++ GFX_END;
++ QWSDisplay::ungrab();
++
++ } else {
++ QWSDisplay::ungrab();
++ // software fallback
++ driver.addMiss( W100Driver::SCROLL );
++ QGfxRaster<depth,type>::scroll( rx, ry, w, h, sx, sy );
++ }
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::fillRect( int x, int y, int w, int h )
++{
++ if ( w == 0 || h == 0 )
++ return;
++ QRect r( x, y, w, h );
++ r.setCoords( tx( x, y ), ty( x, y ),
++ tx( x + w - 1, y + h - 1 ), ty( x + w - 1, y + h - 1 ) );
++ r = r.normalize();
++ inDraw = TRUE;
++ dFillRect( r.x(), r.y(), r.width(), r.height() );
++ inDraw = FALSE;
++}
++
++template< const int depth, const int type >
++void QGfxW100< depth, type>::dFillRect( int rx, int ry, int w, int h )
++{
++ if ( w <= 0 || h <= 0 || this->ncliprect < 1 ) return;
++
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::FILLRECT ) ) {
++ driver.addMiss( W100Driver::FILLRECT );
++ QGfxRaster<depth,type>::fillRect( rx, ry, w, h );
++ return;
++ }
++
++ if ( ( this->cbrush.style() != this->NoBrush ) &&
++ ( this->cbrush.style() != this->SolidPattern ) ) {
++ driver.addMiss( W100Driver::FILLRECT );
++ QGfxRaster<depth,type>::fillRect( rx, ry, w, h );
++ return;
++ }
++
++ if ( !checkDest() || ( this->myrop != this->CopyROP ) ) {
++ driver.addMiss( W100Driver::FILLRECT );
++ QGfxRaster<depth,type>::fillRect( rx, ry, w, h );
++ return;
++ }
++
++ QWSDisplay::grab( TRUE );
++ rx += this->xoffs;
++ ry += this->yoffs;
++
++ QRect boundRect( rx, ry, w + 1, h + 1 );
++ GFX_START( boundRect );
++
++ ( *optype ) = 1;
++
++ driver.setDstType( DSTTYPE_16BPP_1555 );
++ driver.setSrcType( SRCTYPE_EQU_DST );
++ driver.setRopOperation( ROP3_PATCOPY );
++ driver.brushType( 6, 0 );
++ driver.setFrgColour( this->cbrush.color().rgb() );
++
++ driver.addHit( W100Driver::FILLRECT );
++
++ if ( this->cbrush.style() != this->NoBrush ) {
++ //Using all the cliprects
++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ if ( boundRect.intersects( this->cliprect[loopc] ) ) {
++ ATI_CLIPRECT clip;
++ ATI_RECT rect;
++
++ clip.X_Top_Left = this->cliprect[ loopc ].x();
++ clip.Y_Top_Left = this->cliprect[ loopc ].y();
++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1;
++
++ driver.setDstClippingRect( &clip );
++ rect.XCoord = rx;
++ rect.YCoord = ry;
++ rect.Width = w;
++ rect.Height = h;
++ driver.paintRect( 1, &rect );
++ }
++ }
++ }
++ GFX_END;
++
++ QWSDisplay::ungrab();
++}
++
++template <const int depth, const int type>
++void QGfxW100<depth,type>::blt( int x, int y, int w, int h, int sx, int sy )
++{
++ if ( w == 0 || h == 0 )
++ return;
++ QRect r;
++ int rsx;
++ int rsy;
++ if ( inDraw ) {
++ r = QRect( x, y, w, h );
++ rsx = sx;
++ rsy = sy;
++ } else {
++ r.setCoords( tx(x,y), ty(x,y), tx(x+w-1,y+h-1), ty(x+w-1,y+h-1) );
++ r = r.normalize();
++ switch ( qt_w100_screen->transformation() ) {
++ case QW100Screen::Rot90:
++ rsx = sy;
++ rsy = this->srcwidth - sx - w;
++ break;
++ case QW100Screen::Rot180:
++ rsx = this->srcwidth - sx - w;
++ rsy = this->srcheight - sy - h;
++ break;
++ case QW100Screen::Rot270:
++ rsx = this->srcheight - sy - h;
++ rsy = sx;
++ break;
++ default:
++ rsx = sx;
++ rsy = sy;
++ break;
++ }
++ }
++ dBlt( r.x(), r.y(), r.width(), r.height(), rsx, rsy );
++}
++
++template< const int depth, const int type >
++inline void QGfxW100< depth, type>::dBlt( int rx, int ry,
++ int w, int h,
++ int sx, int sy )
++{
++ if ( !w || !h || this->ncliprect < 1 ) {
++ return;
++ }
++
++ if ( depth != 16 ||
++ !driver.accelerated( W100Driver::BITBLT ) ) {
++ driver.addMiss( W100Driver::BITBLT );
++ QGfxRaster<depth,type>::blt( rx, ry, w, h, sx, sy );
++ return;
++ }
++
++ if ( this->alphatype == this->BigEndianMask ||
++ this->alphatype == this->LittleEndianMask ||
++ this->alphatype == this->SeparateAlpha ||
++ this->srctype == this->SourcePen ||
++ ( this->myrop != this->CopyROP ) ) {
++ driver.addMiss( W100Driver::BITBLT );
++ QGfxRaster<depth,type>::blt( rx, ry, w, h, sx, sy );
++ return;
++ }
++
++ if ( ( this->srcdepth != 16 ) || this->alphatype != this->IgnoreAlpha ) {
++ driver.addMiss( W100Driver::BITBLT );
++ QGfxRaster<depth,type>::blt( rx, ry, w, h, sx, sy );
++ return;
++ }
++
++ QWSDisplay::grab( TRUE );
++
++ if ( checkSourceDest() ) {
++ QRect boundRect( rx + this->xoffs, ry + this->yoffs,
++ w + 1, h + 1 );
++ GFX_START( boundRect );
++ ( *optype ) = 1;
++
++ driver.setRopOperation( ROP3_SRCCOPY );
++ driver.setDstType( DSTTYPE_16BPP_1555 );
++ driver.setSrcType( SRCTYPE_EQU_DST );
++
++ driver.addHit( W100Driver::BITBLT );
++
++ ATI_RECT rect1;
++ ATI_RECT rect2;
++
++ rx += this->xoffs;
++ ry += this->yoffs;
++
++ rect1.XCoord = this->srcwidgetoffs.x() + sx;
++ rect1.YCoord = this->srcwidgetoffs.y() + sy;
++ rect1.Width = w;
++ rect1.Height = h;
++ rect2.XCoord = rx;
++ rect2.YCoord = ry;
++ rect2.Width = w;
++ rect2.Height = h;
++ for(int loopc = 0; loopc < this->ncliprect; loopc++ ) {
++ if ( boundRect.intersects( this->cliprect[loopc] ) ) {
++ ATI_CLIPRECT clip;
++ clip.X_Top_Left = this->cliprect[ loopc ].x();
++ clip.Y_Top_Left = this->cliprect[ loopc ].y();
++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1;
++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1;
++ driver.setDstClippingRect( &clip );
++ driver.bitBlt( 1, &rect2, &rect1 );
++ }
++ }
++ GFX_END;
++
++ QWSDisplay::ungrab();
++ return;
++ } else {
++ QWSDisplay::ungrab();
++ driver.addMiss( W100Driver::BITBLT );
++ QGfxRaster<depth,type>::blt( rx, ry,
++ w, h, sx, sy );
++ }
++}
++
++
++template <const int depth, const int type>
++void QGfxW100<depth,type>::tiledBlt( int rx,int ry,int w,int h )
++{
++ if ( w <= 0 || h <= 0 )
++ return;
++ QRect r;
++ if ( inDraw ) {
++ r = QRect(rx,ry,w,h);
++ } else {
++ r.setCoords( tx(rx,ry), ty(rx,ry), tx(rx+w-1,ry+h-1), ty(rx+w-1,ry+h-1) );
++ r = r.normalize();
++ }
++
++ inDraw = TRUE;
++
++ QPoint oldBrushOffs = this->brushoffs;
++ int brx, bry;
++ switch ( qt_w100_screen->transformation() ) {
++ case QW100Screen::Rot90:
++ brx = this->brushoffs.y();
++ bry = this->srcwidth - this->brushoffs.x() - w;
++ break;
++ case QW100Screen::Rot180:
++ brx = this->srcwidth - this->brushoffs.x() - w;
++ bry = this->srcheight - this->brushoffs.y() - h;
++ break;
++ case QW100Screen::Rot270:
++ brx = this->srcheight - this->brushoffs.y() - h;
++ bry = this->brushoffs.x();
++ break;
++ default:
++ brx = this->brushoffs.x();
++ bry = this->brushoffs.y();
++ break;
++ }
++ this->brushoffs = QPoint( brx, bry );
++
++ int oldsw = this->srcwidth;
++ int oldsh = this->srcheight;
++ QSize s = qt_screen->mapToDevice( QSize(this->srcwidth,this->srcheight) );
++ this->srcwidth = s.width();
++ this->srcheight = s.height();
++
++ dTiledBlt( r.x(), r.y(), r.width(), r.height() );
++
++ this->srcwidth = oldsw;
++ this->srcheight = oldsh;
++ this->brushoffs = oldBrushOffs;
++ inDraw = FALSE;
++}
++
++
++template <const int depth, const int type>
++void QGfxW100<depth,type>::dTiledBlt( int rx,int ry, int w,int h )
++{
++ if ( this->srcwidth == 0 || this->srcheight == 0 )
++ return;
++ QGfxRaster<depth,type>::tiledBlt( rx, ry, w, h );
++}
++
++template<const int depth,const int type>
++void QGfxW100<depth,type>::sync()
++{
++ driver.waitComplete( -1 );
++}
++
++template <const int depth, const int type>
++void QGfxW100<depth,type>::setSourceWidgetOffset(int x, int y)
++{
++ if ( this->srcbits == this->buffer ) {
++ switch ( qt_w100_screen->transformation() ) {
++ case QW100Screen::Rot90:
++ this->srcwidgetoffs = QPoint( y, this->width - x - this->srcwidth );
++ break;
++ case QW100Screen::Rot180:
++ this->srcwidgetoffs = QPoint( this->width - x - this->srcwidth, this->height - y - this->srcheight );
++ break;
++ case QW100Screen::Rot270:
++ this->srcwidgetoffs = QPoint( this->height - y - this->srcheight, x );
++ break;
++ default:
++ this->srcwidgetoffs = QPoint( x, y );
++ break;
++ }
++ } else {
++ this->srcwidgetoffs = QPoint( x, y );
++ }
++}
++
++template <const int depth, const int type>
++void QGfxW100<depth,type>::processSpans( int n, QPoint* point, int* width )
++{
++ if ( inDraw ||
++ this->patternedbrush &&
++ this->srcwidth != 0 &&
++ this->srcheight != 0 ) {
++ //in the patternedbrush case, we let blt do the transformation
++ // so we leave inDraw false.
++ QGfxRaster<depth,type>::processSpans( n, point, width );
++ } else {
++ inDraw = true;
++ while (n--) {
++ if ( *width > 0 ) {
++ int x=tx(point->x(),point->y())+this->xoffs;
++ int y=ty(point->x(),point->y())+this->yoffs;
++
++ switch( qt_w100_screen->transformation() ) {
++ case QW100Screen::Rot90:
++ this->vline( x, y-(*width-1), y );
++ break;
++ case QW100Screen::Rot180:
++ this->hline( x - (*width-1), x, y );
++ break;
++ case QW100Screen::Rot270:
++ this->vline( x, y, y+*width-1 );
++ break;
++ default:
++ this->hline( x, x+*width-1, y );
++ break;
++ }
++ }
++ point++;
++ width++;
++ }
++ inDraw = false;
++ }
++}
++
++QW100Screen::QW100Screen( int display_id )
++ :QLinuxFbScreen( display_id ),
++ vramoffset( 0 ),
++ m_isServer( false )
++{
++ qt_w100_screen = this;
++ vramoffset = 0;
++ clearCacheFunc = &clearCache;
++ trans = None;
++}
++
++static const char *trans2str( QW100Screen::Transformation t )
++{
++ switch( t ) {
++ case QW100Screen::None:
++ return "None";
++ break;
++ case QW100Screen::Rot90:
++ return "Rot90";
++ break;
++ case QW100Screen::Rot180:
++ return "Rot180";
++ break;
++ case QW100Screen::Rot270:
++ return "Rot270";
++ break;
++ default:
++ return "Unknown";
++ break;
++ }
++}
++
++QW100Screen::Transformation QW100Screen::getTransSpec( const QString &dspec )
++{
++ Transformation mytrans = None;
++ if ( dspec.find( ":Rot270" ) >= 0 ) {
++ mytrans = Rot270;
++ } else if ( dspec.find( ":Rot180" ) >= 0 ) {
++ mytrans = Rot180;
++ } else if ( dspec.find( ":Rot90" ) >= 0 ) {
++ mytrans = Rot90;
++ }
++ return mytrans;
++}
++
++bool QW100Screen::connect( const QString &displaySpec )
++{
++ driver.log( W100Driver::WARNING, "QW100Screen::connect('%s')",
++ displaySpec.latin1() );
++ trans = getTransSpec( displaySpec );
++
++ if ( QLinuxFbScreen::connect( displaySpec ) ) {
++ vramoffset = ( w == 320 ) ? 0 : 0x0f000000;
++ if ( driver.processAttach() == W100Driver::codOK ) {
++ driver.processAttachSpecialMode( ( w == 480 ) ? 0xaaab : 0xaaaa );
++ surfaceMap.clear();
++ surfaceMap.insert( 0, HWSurface( vramoffset,
++ data , false,
++ w*h*d/8 ) );
++ canaccel = true;
++ QSize s = mapFromDevice( QSize( w, h ) );
++ w = s.width();
++ h = s.height();
++ return true;
++ }
++ }
++ return false;
++}
++
++void QW100Screen::disconnect( void )
++{
++ driver.log( W100Driver::WARNING, "QW100Screen::disconnect()" );
++ driver.processDetachSpecialMode();
++ driver.processDetach();
++ QLinuxFbScreen::disconnect();
++ printf( "[%d]QW100Screen disconnected with %d surfaces\n",
++ getpid(), surfaceMap.count() );
++ surfaceMap.clear();
++}
++
++void QW100Screen::prepareToSuspend( void )
++{
++
++ driver.log( W100Driver::WARNING,
++ "QW100Screen::prepareToSuspend. Server = %s",
++ m_isServer ? "true" : "false" );
++
++ QWSDisplay::grab( true );
++ driver.waitComplete( -1 );
++
++ if ( !driver.attached() ) {
++ driver.log( W100Driver::ERROR, "Driver was not attached. " );
++ } else {
++ driver.processDetachSpecialMode();
++ driver.processDetach();
++ }
++ QWSDisplay::ungrab();
++
++ driver.log( W100Driver::WARNING, "prepareToSuspend done" );
++
++}
++
++void QW100Screen::prepareToResume( void )
++{
++
++ driver.log( W100Driver::WARNING,
++ "QW100Screen::prepareToResume. Server = %s",
++ m_isServer ? "true": "false" );
++
++ driver.processAttach();
++ driver.processAttachSpecialMode( ( w == 480 ) ? 0xaaab : 0xaaaa );
++ if ( m_isServer ) {
++ QWSDisplay::grab( true );
++ w100init();
++ QWSDisplay::ungrab();
++ driver.log( W100Driver::WARNING, "W100 restarted" );
++ }
++ driver.log( W100Driver::WARNING, "prepareToResume done" );
++
++}
++
++QW100Screen::~QW100Screen()
++{
++}
++
++bool QW100Screen::w100init()
++{
++ driver.log( W100Driver::WARNING,
++ "QW100Screen::w100init(%dx%d)", dw, dh );
++ ATI_GRAPHICWINDOW win;
++ ATI_CLIPRECT clip;
++ uint16_t overlay;
++
++ win.dummy1 = 0;
++ win.Size.XCoord = 0;
++ win.Size.YCoord = 0;
++ win.Size.Width = dw;
++ win.Size.Height = dh;
++ win.Width = dw > dh ? dh : dw;
++ win.Height = dw > dh ? dw : dh;
++ win.Flag = DSTTYPE_16BPP_444;
++
++ driver.waitComplete( -1 );
++ driver.setGraphicWindowOnOff( 0 );
++
++ driver.setupGraphicWindow( &win );
++ driver.setGraphicWindowPos( 0, 0 );
++
++ driver.setFrontBuffer( vramoffset, 0, 0 );
++ driver.setDstPitchOffset( dw, vramoffset );
++ driver.setDstType( DSTTYPE_16BPP_444 );
++ driver.setSrcPitchOffset( dw, vramoffset );
++ driver.setSrcType( SRCTYPE_SOLID_COLOR_BLT );
++ clip.X_Top_Left = 0;
++ clip.Y_Top_Left = 0;
++ clip.X_Bottom_Right = dw;
++ clip.Y_Bottom_Right = dh;
++ driver.setDstClippingRect( &clip );
++
++ clip.X_Top_Left = 0xE000;
++ clip.Y_Top_Left = 0xE000;
++ clip.X_Bottom_Right = 0x1FFF;
++ clip.Y_Bottom_Right = 0x1FFF;
++
++ driver.setSrcClippingRect( &clip );
++
++ driver.setRopOperation( ROP3_SRCCOPY );
++ driver.setGraphicWindowOnOff( 1 );
++ driver.allocOverlay( &overlay );
++ driver.setOverlayOnOff( overlay, 0 );
++ driver.releaseOverlay( overlay );
++ driver.setDstPitchOffset( dw, vramoffset );
++ driver.setDstClippingRect( NULL );
++ for ( int i = 0; i < dw * dh ; i++ ) {
++ *( data + i ) = 0;
++ }
++ driver.waitComplete( -1 );
++ return true;
++}
++
++void QW100Screen::w100shutdown()
++{
++}
++
++bool QW100Screen::initDevice()
++{
++ QWSDisplay::grab( true );
++ driver.log( W100Driver::WARNING, "initDevice( dw=%d, dh=%d )",
++ dw, dh );
++ m_isServer = true;
++
++ if ( !w100init() ) {
++ QWSDisplay::ungrab();
++ return false;
++ }
++
++ if ( QLinuxFbScreen::initDevice() ) {
++ //HACK
++ //Some sprite corruption seems to be avoided
++ //reserving some upper memory on the offscreen framebuffer memory
++ QLinuxFbScreen::cache( 65535 * 2, 0 );
++ QWSDisplay::ungrab();
++ return true;
++ }
++ QWSDisplay::ungrab();
++ return false;
++}
++
++void QW100Screen::shutdownDevice()
++{
++ driver.log( W100Driver::WARNING, "Shutting down device" );
++ QLinuxFbScreen::shutdownDevice();
++}
++
++void QW100Screen::restore()
++{
++ driver.log( W100Driver::WARNING, "Restoring W100..." );
++ QLinuxFbScreen::restore();
++ driver.log( W100Driver::WARNING, "Restoring done" );
++}
++
++
++QGfx *QW100Screen::createGfx( unsigned char *b,
++ int w, int h, int d, int linestep )
++{
++ //We need ALL the gfx created to be QGfxW100 to allow software
++ //drawing syncing after hardware operations
++ QGfx * ret=0;
++ if ( false ) {
++#ifndef QT_NO_QWS_DEPTH_1
++ } else if ( d == 1 ) {
++ ret = new QGfxW100<1,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_4
++ } else if ( d == 4 ) {
++ ret = new QGfxW100<4,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_8
++ } else if ( d == 8 ) {
++ ret = new QGfxW100<8,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_16
++ } else if ( d == 16 ) {
++ ret = new QGfxW100<16,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_24
++ } else if ( d == 24 ) {
++ ret = new QGfxW100<24,0>( b, w, h );
++#endif
++#ifndef QT_NO_QWS_DEPTH_32
++ } else if ( d == 32 ) {
++ ret = new QGfxW100<32,0>( b, w, h );
++#endif
++ } else {
++ qFatal( "Unsupported depth %d\n", d );
++ ret = 0;
++ }
++
++ ret->setLineStep( linestep );
++ return ret;
++}
++
++
++uchar *QW100Screen::cache( int amount, int optim )
++{
++ unsigned short hSurface = 0;
++ uint32_t surfaceOffset = 0;
++ uchar* localAddr = 0;
++ bool internal = false;
++
++ /* The size must have 0xF bit zeroed (16 multiple)*/
++ /* Perhaps this is not needed anymore, after setting
++ * QW100Screen::pixmapLinestepAlignment to 128
++ */
++ amount = ( amount & 0x0F ) ? ( amount | 0x10 ) & ~0x0F : amount;
++
++ /* Experimenting memory corruption with the
++ * internal AtiCore memory allocation routines
++ * disabled for now
++ */
++#if 1
++ if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) {
++ return( 0 );
++ }
++ surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t )data;
++
++#else
++ int retcode = 0;
++ qt_fbdpy->grab( true );
++ retcode = driver.allocateSurface( &hSurface,
++ &surfaceOffset,
++ amount, 1 );
++ qt_fbdpy->ungrab();
++ if ( retcode ) {
++ internal = true;
++ driver.setupMemoryTransfer( surfaceOffset,
++ (uint32_t*) &localAddr );
++ driver.terminateMemoryTransfer();
++ } else {
++ // Try to use the offscreen framebuffer memory
++ // to allocate the surface. Use the qgfxlinuxfb routines
++ if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) {
++ return( 0 );
++ }
++ //Distance between physical vram start and surface should be
++ //the same than distance between logical addresses
++ surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t ) data;
++ }
++#endif
++
++ HWSurface surface( hSurface, surfaceOffset,
++ localAddr, amount,
++ internal,
++ qws_client_id );
++ surfaceMap.insert( surface.getAddr(), surface );
++ return( ( uchar* ) localAddr );
++}
++
++void QW100Screen::uncache( uchar *c )
++{
++ QMap< uchar*, HWSurface >::Iterator itr;
++ if ( ( itr = surfaceMap.find( c ) ) != surfaceMap.end() ) {
++ driver.waitComplete( -1 );
++ if ( itr.data().internal() ) {
++ qt_fbdpy->grab( true );
++ driver.destroySurface( itr.data().getHandle() );
++ qt_fbdpy->ungrab();
++ } else {
++ QLinuxFbScreen::uncache( c );
++ }
++ surfaceMap.remove( itr );
++ }
++}
++
++bool QW100Screen::onCard( uchar *p ) const
++{
++ QMap< uchar*, HWSurface >::ConstIterator itr = surfaceMap.begin();
++ for ( ; itr != surfaceMap.end(); itr++ ) {
++ uchar *begin;
++ if ( ( begin = itr.data().getAddr() ) <= p ) {
++ if ( ( itr.data().getSize() + begin ) >= p ) {
++ return TRUE;
++ }
++ }
++ }
++ return FALSE;
++}
++
++bool QW100Screen::onCard( unsigned char *p, ulong& offset ) const
++{
++ QMap< uchar*, HWSurface >::ConstIterator itr;
++ for ( itr = surfaceMap.begin(); itr != surfaceMap.end(); itr++ ) {
++ uchar *begin;
++ if ( ( begin = itr.data().getAddr() ) <= p ) {
++ if ( ( itr.data().getSize() + begin ) >= p ) {
++ offset = itr.data().getSOffset() + ( p - begin );
++ return TRUE;
++ }
++ }
++ }
++ return FALSE;
++}
++
++QMap< uchar*, QW100Screen::HWSurface >
++*QW100Screen::getPSurfaceMap( void ) const
++{
++ return ( QMap<uchar*,HWSurface> *) &surfaceMap;
++}
++
++void QW100Screen::clearCache( int clientId )
++{
++ printf( "[%d] CLEARING CACHE FOR %d\n", getpid(), clientId );
++ driver.log( W100Driver::WARNING, "Cleaning cache for '%d'", clientId );
++ QMap< uchar*, HWSurface >::Iterator itr = surfaceMap.begin();
++ while ( itr != surfaceMap.end() ) {
++ if ( itr.data().getCId() == clientId ) {
++ if ( itr.data().internal() ) {
++ qt_fbdpy->grab();
++ driver.destroySurface( itr.data().getHandle() );
++ qt_fbdpy->ungrab();
++ }
++ surfaceMap.remove( itr );
++ }
++ itr++;
++ }
++ QLinuxFbScreen::clearCache( this, clientId );
++}
++
++void QW100Screen::clearCache( QScreen *instance, int clientId )
++{
++ QW100Screen *screen = reinterpret_cast<QW100Screen *> ( instance );
++ screen->clearCache( clientId );
++}
++
++void QW100Screen::setTransformation( Transformation t )
++{
++ qt_fbdpy->grab( true );
++ trans = t;
++
++ QSize s = mapFromDevice( QSize( dw,dh ) );
++ w = s.width();
++ h = s.height();
++ qt_fbdpy->ungrab();
++}
++
++QW100Screen::Transformation QW100Screen::transformation( void ) const
++{
++ return trans;
++}
++
++QSize QW100Screen::mapToDevice( const QSize &s ) const
++{
++ if ( trans == Rot90 || trans == Rot270 ) {
++ return QSize( s.height(), s.width() );
++ }
++
++ return s;
++}
++
++QSize QW100Screen::mapFromDevice( const QSize &s ) const
++{
++ if ( trans == Rot90 || trans == Rot270 ) {
++ return QSize( s.height(), s.width() );
++ }
++
++ return s;
++}
++
++QPoint QW100Screen::mapToDevice( const QPoint &p, const QSize &s ) const
++{
++ QPoint rp( p );
++
++ switch ( trans ) {
++ case Rot90:
++ rp.setX( p.y() );
++ rp.setY( s.width() - p.x() - 1 );
++ break;
++ case Rot180:
++ rp.setX( s.width() - p.x() - 1 );
++ rp.setY( s.height() - p.y() - 1 );
++ break;
++ case Rot270:
++ rp.setX( s.height() - p.y() - 1 );
++ rp.setY( p.x() );
++ break;
++ default:
++ break;
++ }
++
++ return rp;
++}
++
++QPoint QW100Screen::mapFromDevice( const QPoint &p, const QSize &s ) const
++{
++ QPoint rp( p );
++
++ switch ( trans ) {
++ case Rot90:
++ rp.setX( s.height() - p.y() - 1 );
++ rp.setY( p.x() );
++ break;
++ case Rot180:
++ rp.setX( s.width() - p.x() - 1 );
++ rp.setY( s.height() - p.y() - 1 );
++ break;
++ case Rot270:
++ rp.setX( p.y() );
++ rp.setY( s.width() - p.x() - 1 );
++ break;
++ default:
++ break;
++ }
++
++ return rp;
++}
++
++QRect QW100Screen::mapToDevice( const QRect &r, const QSize &s ) const
++{
++ QRect tr;
++ switch ( trans ) {
++ case Rot90:
++ tr.setCoords( r.y(), s.width() - r.x() - 1,
++ r.bottom(), s.width() - r.right() - 1 );
++ break;
++ case Rot180:
++ tr.setCoords( s.width() - r.x() - 1, s.height() - r.y() - 1,
++ s.width() - r.right() - 1, s.height() - r.bottom() - 1 );
++ break;
++ case Rot270:
++ tr.setCoords( s.height() - r.y() - 1, r.x(),
++ s.height() - r.bottom() - 1, r.right() );
++ break;
++ default:
++ tr = r;
++ break;
++ }
++
++ return tr.normalize();
++}
++
++QRect QW100Screen::mapFromDevice( const QRect &r, const QSize &s ) const
++{
++ QRect tr;
++ switch ( trans ) {
++ case Rot90:
++ tr.setCoords( s.height() - r.y() - 1, r.x(),
++ s.height() - r.bottom() - 1, r.right() );
++ break;
++ case Rot180:
++ tr.setCoords( s.width() - r.x() - 1, s.height() - r.y() - 1,
++ s.width() - r.right() - 1, s.height() - r.bottom() - 1 );
++ break;
++ case Rot270:
++ tr.setCoords( r.y(), s.width() - r.x() - 1,
++ r.bottom(), s.width() - r.right() - 1 );
++ break;
++ default:
++ tr = r;
++ break;
++ }
++
++ return tr.normalize();
++}
++
++template<class T>
++static inline void rotateLoopTemplate( uchar *src, int srcBytesPerLine,
++ uchar *dst, int dstBytesPerLine,
++ int width, int height,
++ QW100Screen::Transformation trans,
++ bool mapToDevice )
++{
++ int dstXAdd = 0;
++ int dstYAdd = 0;
++ int dstXOfs = 0;
++ int dstYOfs = 0;
++ int srcYAdd = srcBytesPerLine - width * sizeof(T);
++
++ if ( !mapToDevice ) {
++ if ( trans == QW100Screen::Rot90 )
++ trans = QW100Screen::Rot270;
++ else if ( trans == QW100Screen::Rot270 )
++ trans = QW100Screen::Rot90;
++ }
++
++ switch ( trans ) {
++ case QW100Screen::Rot90:
++ dstXOfs = 0;
++ dstYOfs = width - 1;
++ dstXAdd = -dstBytesPerLine;
++ dstYAdd = 1 * sizeof(T) + width * dstBytesPerLine;
++ break;
++ case QW100Screen::Rot270:
++ dstXOfs = height - 1;
++ dstYOfs = 0;
++ dstXAdd = dstBytesPerLine;
++ dstYAdd = -1 * sizeof(T) - width * dstBytesPerLine;
++ break;
++ default:
++ dstXOfs = width - 1;
++ dstYOfs = height - 1;
++ dstXAdd = -1 * sizeof(T);
++ dstYAdd = -dstBytesPerLine + width * sizeof(T);
++ break;
++ };
++
++ T *dstPtr = (T *)(dst + dstYOfs * dstBytesPerLine) + dstXOfs;
++ T *srcPtr = (T *)src;
++ for ( int y = 0; y < height; y++ ) {
++ for ( int x = 0; x < width; x++ ) {
++ *dstPtr = *srcPtr++;
++ dstPtr = (T *)((uchar*)dstPtr + dstXAdd); // add dstXAdd number of bytes
++ }
++ srcPtr = (T *)((uchar*)srcPtr + srcYAdd); // add srcYAdd number of bytes
++ dstPtr = (T *)((uchar*)dstPtr + dstYAdd); // add dstYAdd number of bytes
++ }
++}
++
++QImage QW100Screen::mapToDevice( const QImage &img ) const
++{
++ if ( img.isNull() || trans == None )
++ return img;
++
++ int iw = img.width();
++ int ih = img.height();
++ int w = iw;
++ int h = ih;
++ if ( trans == Rot90 || trans == Rot270 ) {
++ w = ih;
++ h = iw;
++ }
++
++ QImage rimg( w, h, img.depth(), img.numColors(), img.bitOrder() );
++
++ for ( int i = 0; i < img.numColors(); i++ ) {
++ rimg.colorTable()[i] = img.colorTable()[i];
++ }
++
++ // Optimized image rotation code for nice bit depths
++ int d = img.depth();
++ if ( d == 8 || d == 16 || d == 32 ) {
++ int srcBytesPerLine = img.bytesPerLine();
++ int dstBytesPerLine = rimg.bytesPerLine();
++ uchar *srcBits = img.bits();
++ uchar *dstBits = rimg.bits();
++ switch ( d ) {
++ case 8:
++ rotateLoopTemplate<uchar>( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, TRUE );
++ break;
++ case 16:
++ rotateLoopTemplate<ushort>( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, TRUE );
++ break;
++ case 32:
++ rotateLoopTemplate<uint>( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, TRUE );
++ break;
++ }
++ rimg.setAlphaBuffer( img.hasAlphaBuffer() );
++ rimg.setOffset( img.offset() );
++ return rimg;
++ }
++
++ // Slower fall back code for image rotation for 1-bit and other depths
++#define ROTATE_LOOP( X, Y, VAL ) \
++ for ( int y = 0; y < ih; y++ ) { \
++ for ( int x = 0; x < iw; x++ ) { \
++ rimg.setPixel( X, Y, VAL ); \
++ } \
++ } \
++ break;
++
++ if ( img.depth() > 8 ) {
++ switch ( trans ) {
++ case Rot90:
++ ROTATE_LOOP( y, iw - x - 1, img.pixel(x, y) )
++ case Rot270:
++ ROTATE_LOOP( ih - y - 1, x, img.pixel(x, y) );
++ default:
++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixel(x, y) );
++ }
++ } else {
++ switch ( trans ) {
++ case Rot90:
++ ROTATE_LOOP( y, iw - x - 1, img.pixelIndex(x, y) );
++ case Rot270:
++ ROTATE_LOOP( ih - y - 1, x, img.pixelIndex(x, y) );
++ default:
++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixelIndex(x, y) );
++ }
++ }
++
++#undef ROTATE_LOOP
++
++ rimg.setAlphaBuffer( img.hasAlphaBuffer() );
++ rimg.setOffset( img.offset() );
++
++ return rimg;
++}
++
++QImage QW100Screen::mapFromDevice( const QImage &img ) const
++{
++ if ( img.isNull() || trans == None )
++ return img;
++
++ int iw = img.width();
++ int ih = img.height();
++ int w = iw;
++ int h = ih;
++ if ( trans == Rot90 || trans == Rot270 ) {
++ w = ih;
++ h = iw;
++ }
++
++ QImage rimg( w, h, img.depth(), img.numColors(), img.bitOrder() );
++
++ for ( int i = 0; i < img.numColors(); i++ ) {
++ rimg.colorTable()[i] = img.colorTable()[i];
++ }
++
++ // Optimized image rotation code for nice bit depths
++ int d = img.depth();
++ if ( d == 8 || d == 16 || d == 32 ) {
++ int srcBytesPerLine = img.bytesPerLine();
++ int dstBytesPerLine = rimg.bytesPerLine();
++ uchar *srcBits = img.bits();
++ uchar *dstBits = rimg.bits();
++ switch ( d ) {
++ case 8:
++ rotateLoopTemplate<uchar>( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, FALSE );
++ break;
++ case 16:
++ rotateLoopTemplate<ushort>( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, FALSE );
++ break;
++ case 32:
++ rotateLoopTemplate<uint>( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, FALSE );
++ break;
++ }
++ rimg.setAlphaBuffer( img.hasAlphaBuffer() );
++ rimg.setOffset( img.offset() );
++ return rimg;
++ }
++
++ // Slower fall back code for image rotation for 1-bit and other depths
++#define ROTATE_LOOP( X, Y, VAL ) \
++ for ( int y = 0; y < ih; y++ ) { \
++ for ( int x = 0; x < iw; x++ ) { \
++ rimg.setPixel( X, Y, VAL ); \
++ } \
++ } \
++ break;
++
++ if ( img.depth() > 8 ) {
++ switch ( trans ) {
++ case Rot90:
++ ROTATE_LOOP( ih - y - 1, x, img.pixel(x, y) );
++ case Rot270:
++ ROTATE_LOOP( y, iw - x - 1, img.pixel(x, y) )
++ default:
++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixel(x, y) );
++ }
++ } else {
++ switch ( trans ) {
++ case Rot90:
++ ROTATE_LOOP( ih - y - 1, x, img.pixelIndex(x, y) );
++ case Rot270:
++ ROTATE_LOOP( y, iw - x - 1, img.pixelIndex(x, y) );
++ default:
++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixelIndex(x, y) );
++ }
++ }
++
++#undef ROTATE_LOOP
++
++ rimg.setAlphaBuffer( img.hasAlphaBuffer() );
++ rimg.setOffset( img.offset() );
++
++ return rimg;
++}
++
++QRegion QW100Screen::mapToDevice( const QRegion &rgn, const QSize &s ) const
++{
++ if ( trans == None )
++ return rgn;
++
++ QRegion trgn;
++ QArray<QRect> a = rgn.rects();
++ QRect tr;
++ const QRect *r = a.data();
++
++ int w = s.width();
++ int h = s.height();
++ int size = a.size();
++
++ switch ( trans ) {
++ case Rot270:
++ for ( int i = 0; i < size; i++, r++ ) {
++ tr.setCoords( h - r->y() - 1, r->x(),
++ h - r->bottom() - 1, r->right() );
++ trgn |= tr.normalize();
++ }
++ break;
++ case Rot90:
++ for ( int i = 0; i < size; i++, r++ ) {
++ tr.setCoords( r->y(), w - r->x() - 1,
++ r->bottom(), w - r->right() - 1 );
++ trgn |= tr.normalize();
++ }
++ break;
++ case Rot180:
++ for ( int i = 0; i < size; i++, r++ ) {
++ tr.setCoords( w - r->x() - 1, h - r->y() - 1,
++ w - r->right() - 1, h - r->bottom() - 1 );
++ trgn |= tr.normalize();
++ }
++ break;
++ default:
++ break;
++ }
++ return trgn;
++}
++
++QRegion QW100Screen::mapFromDevice( const QRegion &rgn, const QSize &s ) const
++{
++ if ( trans == None )
++ return rgn;
++
++ QRegion trgn;
++ QArray<QRect> a = rgn.rects();
++ const QRect *r = a.data();
++ QRect tr;
++
++ int w = s.width();
++ int h = s.height();
++ int size = a.size();
++
++ switch ( trans ) {
++ case Rot270:
++ for ( int i = 0; i < size; i++, r++ ) {
++ tr.setCoords( r->y(), w - r->x() - 1,
++ r->bottom(), w - r->right() - 1 );
++ trgn |= tr.normalize();
++ }
++ break;
++ case Rot90:
++ for ( int i = 0; i < size; i++, r++ ) {
++ tr.setCoords( h - r->y() - 1, r->x(),
++ h - r->bottom() - 1, r->right() );
++ trgn |= tr.normalize();
++ }
++ break;
++ case Rot180:
++ for ( int i = 0; i < size; i++, r++ ) {
++ tr.setCoords( w - r->x() - 1, h - r->y() - 1,
++ w - r->right() - 1, h - r->bottom() - 1 );
++ trgn |= tr.normalize();
++ }
++ break;
++ default:
++ break;
++ }
++
++ return trgn;
++}
++
++/*!
++ 0 = none
++ 1..3 = rotates 90..270
++ 4..7 = mirrored 0..3
++*/
++int QW100Screen::transformOrientation() const
++{
++ return (int)trans;
++}
++
++
++void qws_w100Transformation( int t )
++{
++ if ( qt_w100_screen ) {
++ qt_w100_screen->setTransformation( static_cast<QW100Screen::Transformation>( t ) );
++ }
++}
++
++extern bool qws_accel;
++
++extern "C" QScreen * qt_get_screen_w100( int display_id )
++{
++ return( new QW100Screen( display_id ) );
++}
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qapplication_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qapplication_qws.cpp 2006-01-20 20:48:07.131939024 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qapplication_qws.cpp 2006-01-20 21:17:39.461503976 +0100
+@@ -1450,16 +1450,25 @@
+ extern void qws_clearLoadedFonts();
+ #endif
+
++#ifndef QT_NO_QWS_W100
++extern void qws_w100Transformation( int t );
++#endif
++
+ void QWSDisplay::setTransformation( int t )
+ {
+-#ifndef QT_NO_QWS_TRANSFORMED
++#if !defined(QT_NO_QWS_TRANSFORMED) || !defined(QT_NO_QWS_W100)
+ QRect mwr = qt_screen->mapToDevice(qt_maxWindowRect,
+ QSize(qt_screen->width(), qt_screen->height()) );
+
+ QPixmapCache::clear();
+ qws_clearLoadedFonts();
+ qws_mapPixmaps( TRUE );
++#ifndef QT_NO_QWS_TRANSFORMED
+ qws_setScreenTransformation( t );
++#endif
++#ifndef QT_NO_QWS_W100
++ qws_w100Transformation( t );
++#endif
+ qws_mapPixmaps( FALSE );
+
+ if ( qt_fbdpy->d->directServerConnection() ) {
diff --git a/packages/qte/qte-2.3.12/daemonize.patch b/packages/qte/qte-2.3.12/daemonize.patch
new file mode 100644
index 0000000000..49124b5dbc
--- /dev/null
+++ b/packages/qte/qte-2.3.12/daemonize.patch
@@ -0,0 +1,115 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qapplication_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qapplication_qws.cpp 2006-01-20 20:46:52.639263632 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qapplication_qws.cpp 2006-01-20 20:48:07.131939024 +0100
+@@ -105,6 +105,7 @@
+
+ #include <sys/time.h>
+ #include <sys/times.h>
++#include <syslog.h>
+
+ #if defined(_OS_AIX_) && defined(_CC_GNU_)
+ #include <sys/select.h>
+@@ -164,6 +165,7 @@
+ //these used to be environment variables, they are initialized from
+ //environment variables in
+
++bool qws_daemon = TRUE;
+ bool qws_savefonts = FALSE;
+ bool qws_screen_is_interlaced=FALSE; //### should be detected
+ bool qws_shared_memory = FALSE;
+@@ -1688,6 +1690,10 @@
+ mwGeometry = argv[i];
+ } else if ( arg == "-shared" ) {
+ qws_shared_memory = TRUE;
++ } else if ( arg == "-daemon" ) {
++ qws_daemon = TRUE;
++ } else if ( arg == "-nodaemon" ) {
++ qws_daemon = FALSE;
+ } else if ( arg == "-noshared" ) {
+ qws_shared_memory = FALSE;
+ } else if ( arg == "-savefonts" ) {
+@@ -1745,6 +1751,78 @@
+ qt_appType = type;
+ qws_single_process = TRUE;
+
++ /* Daemonize the server process -- (C) Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
++ * Added a new command line option which only is relevant if the application is created as a GuiServer.
++ * The option is -daemon respectively -nodaemon. If in daemon mode (which is the default now), the
++ * server will detach from the controlling terminal and continue as a daemon. This is done via the standard
++ * UNIX double fork magic.
++ */
++ if ( qws_daemon )
++ {
++ qWarning( "qt_init() - starting in daemon mode..." );
++
++ int pid1 = fork();
++ if ( pid1 == -1 )
++ {
++ qWarning( "qt_init() - can't perform initial fork: %s", strerror( errno ) );
++ exit( -1 );
++ }
++ if ( pid1 ) _exit( 0 ); // ok, first fork performed
++
++ chdir( "/" );
++ setsid();
++ umask(0);
++ close(0);
++ close(1);
++ close(2);
++
++ int fdnull = ::open( "/dev/null", O_RDWR );
++ if ( fdnull == -1 )
++ {
++ syslog( 3, "qt_init() - can't open /dev/null to redirect std{in|out|err}: %s", strerror( errno ) );
++ exit( -1 );
++ }
++ dup2( fdnull, 0 ); // stdin
++ dup2( fdnull, 1 ); // stdout
++ dup2( fdnull, 2 ); // stderr
++
++ int pid2 = fork();
++ if ( pid2 == -1 )
++ {
++ syslog( 3, "qt_init() - can't perform initial fork: %s", strerror( errno ) );
++ exit( -1 );
++ }
++ if ( pid2 )
++ {
++ syslog( 4, "qt_init() [%d] - successfully entered daemon mode", pid2 );
++ _exit( 0 ); // ok, second fork performed
++ }
++ }
++
++ /*
++ * , ,
++ * /( )`
++ * \ \___ / | B E W A R E !
++ * /- _ `-/ ' We are a DAEMON now!
++ * (/\/ \ \ /\
++ * / / | ` \
++ * O O ) / |
++ * `-^--'`< '
++ * (_.) _ ) /
++ * `.___/` /
++ * `-----' /
++ * <----. __ / __ \
++ * <----|====O)))==) \) /====
++ * <----' `--' `.__,' \
++ * | |
++ * \ /
++ * ______( (_ / \______
++ * (FL) ,' ,-----' | \
++ * `--{__________) \/
++ *
++ */
++
++
+ /* Allocate a dedicated virtual terminal -- (C) Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
+ * Added a new command line option which only is relevant if the application is created as a GuiServer.
+ * The option is -terminal <num>, where <num> specifies the virtual terminal to be occupied by the server.
diff --git a/packages/qte/qte-2.3.12/devfs.patch b/packages/qte/qte-2.3.12/devfs.patch
new file mode 100644
index 0000000000..dd46d516ff
--- /dev/null
+++ b/packages/qte/qte-2.3.12/devfs.patch
@@ -0,0 +1,161 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10/configure
+===================================================================
+--- qt-2.3.10.orig/configure 2005-07-03 12:26:10.000000000 +0200
++++ qt-2.3.10/configure 2005-07-03 12:30:36.000000000 +0200
+@@ -412,6 +412,9 @@
+ -visibility-hidden)
+ VISIBILITY=YES
+ ;;
++ -devfs)
++ DEVFS=yes
++ ;;
+ -no-g++-exceptions)
+ GPLUSPLUS_EXCEPTIONS=no
+ ;;
+@@ -1302,6 +1305,8 @@
+ -visibility-hidden . Use -fvisibility=hidden as default. This requires GCC 4.0
+ or a special patched GCC to support the visibility attribute
+
++ -devfs ............. Use devfs /dev paths.
++
+ -no-g++-exceptions . Disable exceptions on platforms using the GNU C++
+ compiler by using the -fno-exceptions flag.
+
+@@ -1374,6 +1379,10 @@
+ then
+ QT_CXX="${QT_CXX} -DGCC_SUPPORTS_VISIBILITY -fvisibility=hidden"
+ fi
++if [ "x$DEVFS" = "xyes" ]
++then
++ QT_CXX="${QT_CXX} -DQT_QWS_DEVFS"
++fi
+ if [ "x$THREAD" = "xyes" ]
+ then
+ cat >src-mt.mk <<EOF
+Index: qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qgfxlinuxfb_qws.cpp 2005-07-03 12:26:13.000000000 +0200
++++ qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp 2005-07-03 12:30:36.000000000 +0200
+@@ -101,11 +101,19 @@
+ bool QLinuxFbScreen::connect( const QString &displaySpec )
+ {
+ // Check for explicitly specified device
++#ifdef QT_QWS_DEVFS
++ QRegExp r( "/dev/fb/[0-9]+" );
++#else
+ QRegExp r( "/dev/fb[0-9]+" );
++#endif
+ int len;
+ int m = r.match( displaySpec, 0, &len );
+
++#ifdef QT_QWS_DEVFS
++ QString dev = (m>=0) ? displaySpec.mid( m, len ) : QString("/dev/fb/0");
++#else
+ QString dev = (m>=0) ? displaySpec.mid( m, len ) : QString("/dev/fb0");
++#endif
+
+ fd=open( dev.latin1(), O_RDWR );
+ if (fd<0) {
+@@ -121,14 +129,22 @@
+
+ /* Get fixed screen information */
+ if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo)) {
++#ifdef QT_QWS_DEVFS
++ perror("reading /dev/fb/0");
++#else
+ perror("reading /dev/fb0");
++#endif
+ qWarning("Error reading fixed information");
+ return FALSE;
+ }
+
+ /* Get variable screen information */
+ if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo)) {
++#ifdef QT_QWS_DEVFS
++ perror("reading /dev/fb/0");
++#else
+ perror("reading /dev/fb0");
++#endif
+ qWarning("Error reading variable information");
+ return FALSE;
+ }
+@@ -165,7 +181,11 @@
+ data += dataoffset;
+
+ if ((int)data == -1) {
+- perror("mapping /dev/fb0");
++#ifdef QT_QWS_DEVFS
++ perror("reading /dev/fb/0");
++#else
++ perror("reading /dev/fb0");
++#endif
+ qWarning("Error: failed to map framebuffer device to memory.");
+ return FALSE;
+ }
+@@ -229,7 +249,11 @@
+
+ static void writeTerm(const char* termctl, int sizeof_termctl)
+ {
++#ifdef QT_QWS_DEVFS
++ const char* tt[]={"/dev/vc/1","/dev/console","/dev/tty",0};
++#else
+ const char* tt[]={"/dev/console","/dev/tty","/dev/tty0",0};
++#endif
+ const char** dev=tt;
+ while (*dev) {
+ int tty=::open(*dev,O_WRONLY);
+Index: qt-2.3.10/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qkeyboard_qws.cpp 2005-07-03 12:26:13.000000000 +0200
++++ qt-2.3.10/src/kernel/qkeyboard_qws.cpp 2005-07-03 12:30:36.000000000 +0200
+@@ -1253,7 +1253,11 @@
+
+ QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString& device)
+ {
++#ifdef QT_QWS_DEVFS
++ kbdFD=open(device.isEmpty() ? "/dev/vc/1" : device.latin1(), O_RDWR | O_NDELAY, 0);
++#else
+ kbdFD=open(device.isEmpty() ? "/dev/tty0" : device.latin1(), O_RDWR | O_NDELAY, 0);
++#endif
+
+ if ( kbdFD >= 0 ) {
+ QSocketNotifier *notifier;
+Index: qt-2.3.10/src/kernel/qwindowsystem_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qwindowsystem_qws.cpp 2005-07-03 12:26:11.000000000 +0200
++++ qt-2.3.10/src/kernel/qwindowsystem_qws.cpp 2005-07-03 12:30:36.000000000 +0200
+@@ -836,7 +836,11 @@
+ void openDevice()
+ {
+ if ( !sn ) {
++#ifdef QT_QWS_DEVFS
++ int fd = ::open("/dev/sound/dsp",O_RDWR);
++#else
+ int fd = ::open("/dev/dsp",O_RDWR);
++#endif
+ if ( fd < 0 ) {
+ // For debugging purposes - defined QT_NO_SOUND if you
+ // don't have sound hardware!
+Index: qt-2.3.10/src/kernel/qsoundqss_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qsoundqss_qws.cpp 2005-01-23 15:00:46.000000000 +0100
++++ qt-2.3.10/src/kernel/qsoundqss_qws.cpp 2005-07-03 12:30:36.000000000 +0200
+@@ -1088,7 +1088,12 @@
+ // Don't block open right away.
+ //
+ bool openOkay = false;
+- if ((fd = ::open("/dev/dsp", O_WRONLY|O_NONBLOCK)) != -1) {
++#ifdef QT_QWS_DEVFS
++ if ((fd = ::open("/dev/sound/dsp", O_WRONLY|O_NONBLOCK)) != -1)
++#else
++ if ((fd = ::open("/dev/dsp", O_WRONLY|O_NONBLOCK)) != -1)
++#endif
++ {
+ int flags = fcntl(fd, F_GETFL);
+ flags &= ~O_NONBLOCK;
+ openOkay = (fcntl(fd, F_SETFL, flags) == 0);
diff --git a/packages/qte/qte-2.3.12/encoding.patch b/packages/qte/qte-2.3.12/encoding.patch
new file mode 100644
index 0000000000..77626c48bf
--- /dev/null
+++ b/packages/qte/qte-2.3.12/encoding.patch
@@ -0,0 +1,36 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/tools/qstring.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/tools/qstring.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/tools/qstring.cpp 2006-01-20 20:49:57.610143784 +0100
+@@ -14468,7 +14468,11 @@
+ return qt_winQString2MB( *this );
+ #endif
+ #ifdef _WS_QWS_
+- return utf8(); // ##### if there is ANY 8 bit format supported?
++ QTextCodec* codec = QTextCodec::codecForLocale();
++ return codec
++ ? codec->fromUnicode(*this)
++ : utf8();
++ //return latin1(); // ##### if there is ANY 8 bit format supported?
+ #endif
+ #endif
+ }
+@@ -14514,7 +14518,12 @@
+ return qt_winMB2QString( local8Bit );
+ #endif
+ #ifdef _WS_QWS_
+- return fromUtf8(local8Bit,len);
++ QTextCodec* codec = QTextCodec::codecForLocale();
++ if( len < 0) len = qstrlen(local8Bit);
++ return codec
++ ? codec->toUnicode(local8Bit, len)
++ : QString::fromUtf8(local8Bit,len);
++// return fromLatin1(local8Bit,len);
+ #endif
+ #endif // QT_NO_TEXTCODEC
+ }
diff --git a/packages/qte/qte-2.3.12/fix-linuxfb-offscreenoverflow.patch b/packages/qte/qte-2.3.12/fix-linuxfb-offscreenoverflow.patch
new file mode 100644
index 0000000000..a0bb12940c
--- /dev/null
+++ b/packages/qte/qte-2.3.12/fix-linuxfb-offscreenoverflow.patch
@@ -0,0 +1,24 @@
+Fix an overflow when the amount of requested cache memory
+is greater than the *lowest value
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxlinuxfb_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfxlinuxfb_qws.cpp 2006-01-20 21:07:51.803841520 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxlinuxfb_qws.cpp 2006-01-20 21:08:13.655519560 +0100
+@@ -616,6 +616,11 @@
+
+ // No free blocks in already-taken memory; get some more
+ // if we can
++ if ( amount >= (*lowest ) ) {
++ //Avoid this overflow
++ qt_fbdpy->ungrab();
++ return 0;
++ }
+ unsigned int newlowest = (*lowest)-amount;
+ if (newlowest % align) {
+ newlowest -= align;
diff --git a/packages/qte/qte-2.3.12/fix-linuxfb-setmode.patch b/packages/qte/qte-2.3.12/fix-linuxfb-setmode.patch
new file mode 100644
index 0000000000..e6cb25c385
--- /dev/null
+++ b/packages/qte/qte-2.3.12/fix-linuxfb-setmode.patch
@@ -0,0 +1,36 @@
+Set lstep properly on a mode change
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxlinuxfb_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfxlinuxfb_qws.cpp 2006-01-20 20:46:52.641263328 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxlinuxfb_qws.cpp 2006-01-20 21:07:51.803841520 +0100
+@@ -119,13 +119,6 @@
+ memset( &finfo, 0, sizeof(fb_fix_screeninfo) ); // keep valgrind happy
+ memset( &vinfo, 0, sizeof(fb_var_screeninfo) ); // keep valgrind happy
+
+- /* Get fixed screen information */
+- if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo)) {
+- perror("reading /dev/fb0");
+- qWarning("Error reading fixed information");
+- return FALSE;
+- }
+-
+ /* Get variable screen information */
+ if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo)) {
+ perror("reading /dev/fb0");
+@@ -826,6 +819,10 @@
+ qFatal("Error reading fixed information");
+ }
+
++ if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo)) {
++ qFatal("Error reading changed fixed information in mode change");
++ }
++
+ w=vinfo.xres;
+ h=vinfo.yres;
+ d=vinfo.bits_per_pixel;
diff --git a/packages/qte/qte-2.3.12/fix-native-build.patch b/packages/qte/qte-2.3.12/fix-native-build.patch
new file mode 100644
index 0000000000..7670d44f27
--- /dev/null
+++ b/packages/qte/qte-2.3.12/fix-native-build.patch
@@ -0,0 +1,11 @@
+--- qt-2.3.10/src/kernel/qwindowsystem_qws.h.orig 2005-09-19 17:50:39.000000000 +0200
++++ qt-2.3.10/src/kernel/qwindowsystem_qws.h 2005-09-19 17:50:45.000000000 +0200
+@@ -53,6 +53,8 @@
+ class QWSRegionManager;
+ class QGfx;
+ class QWSServerData;
++class QWSInputMethod;
++class QWSGestureMethod;
+
+ class QWSInternalWindowInfo
+ {
diff --git a/packages/qte/qte-2.3.12/fix-qgfxraster.patch b/packages/qte/qte-2.3.12/fix-qgfxraster.patch
new file mode 100644
index 0000000000..26bbe1e957
--- /dev/null
+++ b/packages/qte/qte-2.3.12/fix-qgfxraster.patch
@@ -0,0 +1,30 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxraster_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfxraster_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxraster_qws.cpp 2006-01-20 20:50:26.577740040 +0100
+@@ -4076,13 +4076,14 @@
+ for( loopc2=0;loopc2<frontadd;loopc2++ )
+ *(alphaptr++)=get_value_32(16,(unsigned char **)&temppos);
+
+- PackType temp2;
+- unsigned char * cp;
++ volatile PackType temp2;
++ volatile unsigned short int * cp;
+ for( loopc2=0;loopc2<count;loopc2++ ) {
+- temp2=*((PackType *)temppos);
+- cp=(unsigned char *)&temp2;
+- *(alphaptr++)=get_value_32(16,&cp);
+- *(alphaptr++)=get_value_32(16,&cp);
++ temp2=*reinterpret_cast<PackType *>(temppos);
++ cp=reinterpret_cast<volatile unsigned short int *>(&temp2);
++ *(alphaptr++)=qt_conv16ToRgb(*cp);
++ cp++;
++ *(alphaptr++)=qt_conv16ToRgb(*cp);
+ temppos += 2;
+ }
+
diff --git a/packages/qte/qte-2.3.12/fix-qscreen-sync.patch b/packages/qte/qte-2.3.12/fix-qscreen-sync.patch
new file mode 100644
index 0000000000..47929ee1f2
--- /dev/null
+++ b/packages/qte/qte-2.3.12/fix-qscreen-sync.patch
@@ -0,0 +1,17 @@
+Add a sync member to QScreen class
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/kernel/qgfx_qws.h~fix-qscreen-sync
++++ qt-2.3.10/src/kernel/qgfx_qws.h
+@@ -191,6 +191,7 @@
+ virtual int pixmapOffsetAlignment() { return 64; }
+ virtual int pixmapLinestepAlignment() { return 64; }
+
++ virtual void sync() {}
+ virtual bool onCard(unsigned char *) const;
+ virtual bool onCard(unsigned char *, ulong& out_offset) const;
+
diff --git a/packages/qte/qte-2.3.12/gcc3.patch b/packages/qte/qte-2.3.12/gcc3.patch
new file mode 100644
index 0000000000..fc1656aa24
--- /dev/null
+++ b/packages/qte/qte-2.3.12/gcc3.patch
@@ -0,0 +1,27 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20041211/src/tools/qcstring.h~gcc3
++++ qt-2.3.9-snapshot-20041211/src/tools/qcstring.h
+@@ -119,7 +119,7 @@
+ // We want to keep source compatibility for 2.x
+ // ### TODO for 4.0: completely remove these and the cstr* functions
+
+-#if !defined(QT_GENUINE_STR)
++#if 0
+
+ #undef strlen
+ #define strlen qstrlen
+--- qt-2.3.9-snapshot-20041211/src/kernel/qwsdecoration_qws.h~gcc3
++++ qt-2.3.9-snapshot-20041211/src/kernel/qwsdecoration_qws.h
+@@ -50,7 +50,7 @@
+ enum Region { None=0, All=1, Title=2, Top=3, Bottom=4, Left=5, Right=6,
+ TopLeft=7, TopRight=8, BottomLeft=9, BottomRight=10,
+ Close=11, Minimize=12, Maximize=13, Normalize=14,
+- Menu=15, LastRegion=Menu };
++ Menu=15, LastRegion=Menu, UserDefined = 100 };
+
+ virtual QRegion region(const QWidget *, const QRect &rect, Region r=All) = 0;
+ virtual void close( QWidget * );
diff --git a/packages/qte/qte-2.3.12/handhelds.patch b/packages/qte/qte-2.3.12/handhelds.patch
new file mode 100644
index 0000000000..c4e3c8ce59
--- /dev/null
+++ b/packages/qte/qte-2.3.12/handhelds.patch
@@ -0,0 +1,66 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qcommonstyle.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qcommonstyle.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qcommonstyle.cpp 2006-01-20 21:03:08.477913608 +0100
+@@ -572,7 +572,7 @@
+ bool enabled, bool active )
+ {
+ #ifndef QT_NO_MENUBAR
+-#ifndef QT_NO_STYLE_SGI
++#if 1 // #ifndef QT_NO_STYLE_SGI
+ if (draw_menu_bar_impl != 0) {
+ QDrawMenuBarItemImpl impl = draw_menu_bar_impl;
+ (this->*impl)(p, x, y, w, h, mi, g, enabled, active);
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qlistview.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qlistview.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qlistview.cpp 2006-01-20 21:03:08.480913152 +0100
+@@ -5053,9 +5053,9 @@
+ l = l->childItem ? l->childItem : l->siblingItem;
+
+ if ( l && l->height() )
+- s.setHeight( s.height() + 10 * l->height() );
+- else
+- s.setHeight( s.height() + 140 );
++ s.setHeight( s.height() + 4 /*10*/ * l->height() );
++ else // ^v much too big for handhelds
++ s.setHeight( s.height() + 30 /*140*/ );
+
+ if ( s.width() > s.height() * 3 )
+ s.setHeight( s.width() / 3 );
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwindowsystem_qws.cpp 2006-01-20 20:57:33.113896688 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp 2006-01-20 21:03:08.482912848 +0100
+@@ -918,6 +918,18 @@
+ {
+ }
+
++static void catchSegvSignal( int )
++{
++#ifndef QT_NO_QWS_KEYBOARD
++ if ( qwsServer )
++ qwsServer->closeKeyboard();
++#endif
++ QWSServer::closedown();
++ fprintf(stderr, "Segmentation fault.\n");
++ exit(1);
++}
++
++
+ /*!
+ \class QWSServer qwindowsystem_qws.h
+ \brief Server-specific functionality in Qt/Embedded
+@@ -1043,6 +1055,7 @@
+ }
+
+ signal(SIGPIPE, ignoreSignal); //we get it when we read
++ signal(SIGSEGV, catchSegvSignal); //recover the keyboard on crash
+ #endif
+ focusw = 0;
+ mouseGrabber = 0;
diff --git a/packages/qte/qte-2.3.12/improve-calibration-r0.patch b/packages/qte/qte-2.3.12/improve-calibration-r0.patch
new file mode 100644
index 0000000000..9b11f52d83
--- /dev/null
+++ b/packages/qte/qte-2.3.12/improve-calibration-r0.patch
@@ -0,0 +1,159 @@
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsmouse_qws.cpp 2006-01-20 21:02:45.087469496 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.cpp 2006-01-20 21:08:58.697672112 +0100
+@@ -14,10 +14,6 @@
+ ** Foundation and appearing in the file LICENSE.GPL included in the
+ ** packaging of this file.
+ **
+-** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition
+-** licenses for Qt/Embedded may use this file in accordance with the
+-** Qt Embedded Commercial License Agreement provided with the Software.
+-**
+ ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ **
+@@ -30,6 +26,12 @@
+ **
+ **********************************************************************/
+
++/*
++ * The 5 point algorithim in QTSLibHandlerPrivate::calibrate() is
++ * GPL only code and Copyright (C) 2001 Russel King.
++ *
++ * Taken from ts_calibrate.c from tslib
++ */
+ #include "qwindowsystem_qws.h"
+ #include "qsocketnotifier.h"
+ #include "qwsevent_qws.h"
+@@ -1810,6 +1812,7 @@
+
+ void QTSLibHandlerPrivate::calibrate( QWSPointerCalibrationData * cd)
+ {
++#ifdef ORIG_CALIBRATE
+ QPoint dev_tl = cd->devPoints[ QWSPointerCalibrationData::TopLeft ];
+ QPoint dev_br = cd->devPoints[ QWSPointerCalibrationData::BottomRight ];
+ QPoint screen_tl = cd->screenPoints[ QWSPointerCalibrationData::TopLeft ];
+@@ -1840,6 +1843,122 @@
+ {
+ qDebug( "Could not save calibration: %s", calFile.latin1() );
+ }
++
++#else
++ int j;
++ float n, x, y, x2, y2, xy, z, zx, zy;
++ float det, cal_a, cal_b, cal_c, cal_d, cal_e, cal_f, cal_i;
++ float scaling = 65536.0;
++ int cal_x[5], cal_xfb[5], cal_y[5], cal_yfb[5], cal_o[7];
++
++ cal_x[0]=cd->devPoints[ QWSPointerCalibrationData::TopLeft ].x();
++ cal_y[0]=cd->devPoints[ QWSPointerCalibrationData::TopLeft ].y();
++ cal_x[1]=cd->devPoints[ QWSPointerCalibrationData::TopRight ].x();
++ cal_y[1]=cd->devPoints[ QWSPointerCalibrationData::TopRight ].y();
++ cal_x[2]=cd->devPoints[ QWSPointerCalibrationData::BottomLeft ].x();
++ cal_y[2]=cd->devPoints[ QWSPointerCalibrationData::BottomLeft ].y();
++ cal_x[3]=cd->devPoints[ QWSPointerCalibrationData::BottomRight ].x();
++ cal_y[3]=cd->devPoints[ QWSPointerCalibrationData::BottomRight ].y();
++ cal_x[4]=cd->devPoints[ QWSPointerCalibrationData::Center ].x();
++ cal_y[4]=cd->devPoints[ QWSPointerCalibrationData::Center ].y();
++
++ cal_xfb[0]=cd->screenPoints[ QWSPointerCalibrationData::TopLeft ].x();
++ cal_yfb[0]=cd->screenPoints[ QWSPointerCalibrationData::TopLeft ].y();
++ cal_xfb[1]=cd->screenPoints[ QWSPointerCalibrationData::TopRight ].x();
++ cal_yfb[1]=cd->screenPoints[ QWSPointerCalibrationData::TopRight ].y();
++ cal_xfb[2]=cd->screenPoints[ QWSPointerCalibrationData::BottomLeft ].x();
++ cal_yfb[2]=cd->screenPoints[ QWSPointerCalibrationData::BottomLeft ].y();
++ cal_xfb[3]=cd->screenPoints[ QWSPointerCalibrationData::BottomRight ].x();
++ cal_yfb[3]=cd->screenPoints[ QWSPointerCalibrationData::BottomRight ].y();
++ cal_xfb[4]=cd->screenPoints[ QWSPointerCalibrationData::Center ].x();
++ cal_yfb[4]=cd->screenPoints[ QWSPointerCalibrationData::Center ].y();
++
++ //qDebug("Top left : X = %4d Y = %4d", cal_x[0], cal_y[0]);
++ //qDebug("Top right: X = %4d Y = %4d", cal_x[1], cal_y[1]);
++ //qDebug("Bot left : X = %4d Y = %4d", cal_x[2], cal_y[2]);
++ //qDebug("Bot right: X = %4d Y = %4d", cal_x[3], cal_y[3]);
++ //qDebug("Middle: X = %4d Y = %4d", cal_x[4], cal_y[4]);
++
++ // Get sums for matrix
++ n = x = y = x2 = y2 = xy = 0;
++ for(j=0;j<5;j++) {
++ n += 1.0;
++ x += (float)cal_x[j];
++ y += (float)cal_y[j];
++ x2 += (float)(cal_x[j]*cal_x[j]);
++ y2 += (float)(cal_y[j]*cal_y[j]);
++ xy += (float)(cal_x[j]*cal_y[j]);
++ }
++
++ // Get determinant of matrix -- check if determinant is too small
++ det = n*(x2*y2 - xy*xy) + x*(xy*y - x*y2) + y*(x*xy - y*x2);
++ if(det < 0.1 && det > -0.1) {
++ qDebug("determinant is too small -- %f",det);
++ return;// false;
++ }
++
++ // Get elements of inverse matrix
++ cal_a = (x2*y2 - xy*xy)/det;
++ cal_b = (xy*y - x*y2)/det;
++ cal_c = (x*xy - y*x2)/det;
++ cal_e = (n*y2 - y*y)/det;
++ cal_f = (x*y - n*xy)/det;
++ cal_i = (n*x2 - x*x)/det;
++
++ // Get sums for x calibration
++ z = zx = zy = 0;
++ for(j=0;j<5;j++) {
++ z += (float)cal_xfb[j];
++ zx += (float)(cal_xfb[j]*cal_x[j]);
++ zy += (float)(cal_xfb[j]*cal_y[j]);
++ }
++
++ // Now multiply out to get the calibration for framebuffer x coord
++ cal_o[0] = (int)((cal_a*z + cal_b*zx + cal_c*zy)*(scaling));
++ cal_o[1] = (int)((cal_b*z + cal_e*zx + cal_f*zy)*(scaling));
++ cal_o[2] = (int)((cal_c*z + cal_f*zx + cal_i*zy)*(scaling));
++
++ qDebug("%f %f %f",(cal_a*z + cal_b*zx + cal_c*zy), (cal_b*z + cal_e*zx + cal_f*zy), (cal_c*z + cal_f*zx + cal_i*zy));
++
++ // Get sums for y calibration
++ z = zx = zy = 0;
++ for (j=0;j<5;j++) {
++ z += (float)cal_yfb[j];
++ zx += (float)(cal_yfb[j]*cal_x[j]);
++ zy += (float)(cal_yfb[j]*cal_y[j]);
++ }
++
++ // Now multiply out to get the calibration for framebuffer y coord
++ cal_o[3] = (int)((cal_a*z + cal_b*zx + cal_c*zy)*(scaling));
++ cal_o[4] = (int)((cal_b*z + cal_e*zx + cal_f*zy)*(scaling));
++ cal_o[5] = (int)((cal_c*z + cal_f*zx + cal_i*zy)*(scaling));
++
++ qDebug("%f %f %f",(cal_a*z + cal_b*zx + cal_c*zy), (cal_b*z + cal_e*zx + cal_f*zy), (cal_c*z + cal_f*zx + cal_i*zy));
++
++
++ // If we got here, we're OK, so assign scaling to a[6] and return
++ cal_o[6] = (int) scaling;
++
++ qDebug("Calibration constants: %d %d %d %d %d %d %d",
++ cal_o[0], cal_o[1], cal_o[2],
++ cal_o[3], cal_o[4], cal_o[5],
++ cal_o[6]);
++
++ QString calFile = "/etc/pointercal";
++#ifndef QT_NO_TEXTSTREAM
++ QFile file( calFile );
++ if ( file.open( IO_WriteOnly ) ) {
++ QTextStream t( &file );
++ t << cal_o[1] << " " << cal_o[2] << " " << cal_o[0] << " ";
++ t << cal_o[4] << " " << cal_o[5] << " " << cal_o[3] << " " << cal_o[6];
++ file.flush(); closeTs();
++ openTs();
++ } else
++#endif
++ {
++ qDebug( "Could not save calibration: %s", calFile.latin1() );
++ }
++#endif
+ }
+
+ void QTSLibHandlerPrivate::readMouseData()
diff --git a/packages/qte/qte-2.3.12/increase-qxml-robustness.patch b/packages/qte/qte-2.3.12/increase-qxml-robustness.patch
new file mode 100644
index 0000000000..3a29b4ab03
--- /dev/null
+++ b/packages/qte/qte-2.3.12/increase-qxml-robustness.patch
@@ -0,0 +1,17 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/xml/qxml.cpp~xml
++++ qt-2.3.10/src/xml/qxml.cpp
+@@ -809,6 +809,9 @@
+ // ### The input source should not do the encoding detection!
+ void QXmlInputSource::readInput( QByteArray& rawData )
+ {
++ // avoid crash if the array has less than 5 characters (skyhusker@handhelds.org)
++ if ( rawData.size() < 6 )
++ return;
+ QBuffer buf( rawData );
+ buf.open( IO_ReadOnly );
+ QTextStream *stream = new QTextStream( &buf );
diff --git a/packages/qte/qte-2.3.12/ipaq-keyboard.patch b/packages/qte/qte-2.3.12/ipaq-keyboard.patch
new file mode 100644
index 0000000000..6aa33242f5
--- /dev/null
+++ b/packages/qte/qte-2.3.12/ipaq-keyboard.patch
@@ -0,0 +1,27 @@
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:22:10.391316384 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:25:41.190270072 +0100
+@@ -571,17 +571,17 @@
+ { Qt::Key_Plus, '+' , '-' , 0xffff },
+ { Qt::Key_Pause, 0xffff , 0xffff , 0xffff }, // 120
+ { Qt::Key_F31, 0xffff , 0xffff , 0xffff }, // IM toggle
+- { Qt::Key_F32, 0xffff , 0xffff , 0xffff }, // Sync
+- { Qt::Key_F34, 0xffff , 0xffff , 0xffff }, // Power
+- { Qt::Key_F35, 0xffff , 0xffff , 0xffff }, // Backlight
++ { Qt::Key_SysReq, 0xffff , 0xffff , 0xffff }, // iPAQ
++ { Qt::Key_F9, 0xffff , 0xffff , 0xffff }, // iPAQ
++ { Qt::Key_F10, 0xffff , 0xffff , 0xffff }, // iPAQ
+ #if defined(QT_KEYPAD_MODE)
+ { Qt::Key_Context1, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_Context2, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_Context3, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_Context4, 0xffff , 0xffff , 0xffff },
+ #else
+- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
++ { Qt::Key_F13, 0xffff , 0xffff , 0xffff }, // iPAQ
++ { Qt::Key_F12, 0xffff , 0xffff , 0xffff }, // iPAQ
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ #endif
diff --git a/packages/qte/qte-2.3.12/ipaq_sound_fix.patch b/packages/qte/qte-2.3.12/ipaq_sound_fix.patch
new file mode 100644
index 0000000000..a5874b4d6c
--- /dev/null
+++ b/packages/qte/qte-2.3.12/ipaq_sound_fix.patch
@@ -0,0 +1,60 @@
+Attention HACK ahead:
+ The OpenSoundSystem is just scary this is a special hack
+ for supporting iPAQ(s) at least h3870.
+
+ Features:
+ -It does not crash when playing a 'null' file
+ -Change sound fragment size to 12
+ -Force stereo on!!! (hardcoded at least uda1341 needs it)
+
+
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qsoundqss_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qsoundqss_qws.cpp 2006-01-20 21:15:58.396868136 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qsoundqss_qws.cpp 2006-01-20 21:22:27.674688912 +0100
+@@ -73,7 +73,7 @@
+ };
+
+ #if defined(QT_QWS_IPAQ)
+-static const int sound_fragment_size = 12;
++static const int sound_fragment_size = 14;
+ #else
+ static const int sound_fragment_size = 12;
+ #endif
+@@ -520,8 +520,14 @@
+
+ int devSamples()
+ {
+- int possible = (((max1+max2-out) / ((chunkdata.wBitsPerSample>>3)*chunkdata.channels))
+- *sound_speed)/chunkdata.samplesPerSec;
++ if ( !(chunkdata.wBitsPerSample>>3) ||
++ !chunkdata.channels ||
++ !sound_speed ||
++ !chunkdata.samplesPerSec )
++ return 0;
++
++ int possible = (((max1+max2-out) / ((chunkdata.wBitsPerSample>>3 )*chunkdata.channels))
++ *sound_speed)/chunkdata.samplesPerSec;
+
+ return possible;
+ }
+@@ -1510,12 +1516,14 @@
+ if ( AFMT_U8 != v )
+ qDebug("Want format %d got %d", AFMT_U8, v);
+ #endif
+- v=sound_stereo; if ( ioctl(fd, SNDCTL_DSP_STEREO, &v) )
++ v=1; if ( ioctl(fd, SNDCTL_DSP_STEREO, &v) )
+ qWarning("Could not set stereo %d",v);
+ if ( sound_stereo != v )
+- qDebug("Want stereo %d got %d", sound_stereo, v);
+-#ifdef QT_QWS_SOUND_STEREO
+- sound_stereo=v;
++ qDebug("Want stereo %d got %d", sound_stereo, v);
++#if defined(QT_QWS_IPAQ)
++ sound_stereo=1;
++#elif QT_QWS_SOUND_STEREO
++ sound_stereo=v;
+ #endif
+ v=sound_speed; if ( ioctl(fd, SNDCTL_DSP_SPEED, &sound_speed) )
+ qWarning("Could not set speed %d",v);
diff --git a/packages/qte/qte-2.3.12/kernel-keymap-CXK.patch b/packages/qte/qte-2.3.12/kernel-keymap-CXK.patch
new file mode 100644
index 0000000000..6aca81e97d
--- /dev/null
+++ b/packages/qte/qte-2.3.12/kernel-keymap-CXK.patch
@@ -0,0 +1,19 @@
+
+#
+# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher
+#
+
+--- qt-2.3.10/src/kernel/qkeyboard_qws.cpp~kernel-keymap-CXK.patch 2005-05-05 19:34:05.000000000 +0200
++++ qt-2.3.10/src/kernel/qkeyboard_qws.cpp 2005-05-05 19:35:47.000000000 +0200
+@@ -1809,7 +1809,11 @@
+ case Qt::Key_Up:
+ case Qt::Key_Down:
+ mod_key = false;
++#if QT_QWS_SLCXK
++ if (qt_screen->transformOrientation() != 3)
++#else
+ if (qt_screen->isTransformed())
++#endif
+ qtKeyCode = static_cast<Qt::Key>( xform_dirkey(static_cast<int>( qtKeyCode ) ) );
+ break;
+ /*
diff --git a/packages/qte/qte-2.3.12/kernel-keymap-corgi.patch b/packages/qte/qte-2.3.12/kernel-keymap-corgi.patch
new file mode 100644
index 0000000000..7611590322
--- /dev/null
+++ b/packages/qte/qte-2.3.12/kernel-keymap-corgi.patch
@@ -0,0 +1,25 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:16:25.412761096 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:16:49.508098048 +0100
+@@ -420,6 +420,15 @@
+ { 0x20ac, 0xffff , 0x20ac , 0x20ac }, // 73 Euro sign
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 74
+ { Qt::Key_F32, 0xffff , 0xffff , 0xffff }, // 75 Sync
++ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 76
++ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 77
++ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 78
++ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 79
++ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 7a
++ { Qt::Key_Return, 0xffff , 0xffff , 0xffff }, // 7b
++ { Qt::Key_Escape, 0xffff , 0xffff , 0xffff }, // 7c
++ { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 7d
++ { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 7e
+ { 0, 0xffff , 0xffff , 0xffff }
+ };
+ #else
diff --git a/packages/qte/qte-2.3.12/kernel-keymap-tosa.patch b/packages/qte/qte-2.3.12/kernel-keymap-tosa.patch
new file mode 100644
index 0000000000..ca445f4d1d
--- /dev/null
+++ b/packages/qte/qte-2.3.12/kernel-keymap-tosa.patch
@@ -0,0 +1,81 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp~kernel-keymap-tosa
++++ qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp
+@@ -355,14 +355,24 @@
+ { Qt::Key_CapsLock, 0xffff , 0xffff , 0xffff }, // 3c 60
+ { Qt::Key_At, '@' , 's' , 'S'-64 }, // 3d
+ { Qt::Key_Question, '?' , '?' , 0xffff }, // 3e
++#ifdef QT_QWS_SL6000
++ { Qt::Key_Comma, ',' , ';' , 0xffff }, // 3f
++ { Qt::Key_Period, '.' , ':' , 0xffff }, // 40
++#else
+ { Qt::Key_Comma, ',' , ',' , 0xffff }, // 3f
+ { Qt::Key_Period, '.' , '.' , 0xffff }, // 40
++#endif
+ { Qt::Key_Tab, 9 , '\\' , 0xffff }, // 41
+ { Qt::Key_X, 0xffff , 'x' , 'X'-64 }, // 42
+ { Qt::Key_C, 0xffff , 'c' , 'C'-64 }, // 43
+ { Qt::Key_V, 0xffff , 'v' , 'V'-64 }, // 44
++#ifdef QT_QWS_SL6000
++ { Qt::Key_Slash, '/' , '?' , 0xffff }, // 45
++ { Qt::Key_Apostrophe, '\'' , '"' , 0xffff }, // 46 70
++#else
+ { Qt::Key_Slash, '/' , '/' , 0xffff }, // 45
+ { Qt::Key_Apostrophe, '\'' , '\'' , 0xffff }, // 46 70
++#endif
+ { Qt::Key_Semicolon, ';' , ';' , 0xffff }, // 47
+ { Qt::Key_QuoteDbl, '\"' , '\"' , 0xffff }, // 48
+ { Qt::Key_Colon, ':' , ':' , 0xffff }, // 49
+@@ -572,6 +582,32 @@
+ static const int keyMSize = sizeof(keyM)/sizeof(QWSServer::KeyMap)-1;
+ static QIntDict<QWSServer::KeyMap> *overrideMap = 0;
+
++#if defined(QT_QWS_SL6000)
++/* Translation table to obtain a 'legacy' keycode corresponding to
++ Fn+key on tosa
++ Other devices obviously send different keycodes while Fn is down, tosa sends
++ the same keys as usual bracketed by Fn-down/Fn-up.
++ This table is used while Fn is down to obtain the key-code the SL-5xxx would
++ send, so the rest of keyboard processing does not need to be adjusted. */
++static const uchar sl6kFnTrans[] = { 0x00,
++ 0x5e, 0x3a, 0x43, 0x4a, 0x2b, 0x4b, 0x4c, 0x4d, 0x30, 0x4e, 0x4f, 0x50,
++ // !, -, cpy, #, 3, $, %, _, 8, &, *, (,
++ 0x53, 0x3b, 0x31, 0x32, 0x29, 0x2c, 0x3d, 0x2d, 0x2f, 0x44, 0x2a, 0x42,
++ // =, +, 9, 0, 1, 4, @, 5, 7, pste, 2, cut,
++ // padding for keycodes which don't ever get directly sent on tosa
++ // except for y->6, ret->'>', BS->DEL
++ 0x2e, 0x00, 0x00, 0x57, 0x00, 0x00, 0x51, 0x00, 0x00, 0x00, 0x00, 0x00,
++ // 6, _Z, shft, ret, F11, fn, BS?, F31, lght, cncl, lft, up,
++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
++ // dn, rght, OK, home, 1, 2, 3, 4, 5, 6, 7, 8,
++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
++ // 9, 0, UNK, UNK, UNK, UNK, UNK, UNK, UNK, -, +, caps,
++ // here are a few translatable codes again...
++ 0x00, 0x00, 0x54, 0x56, 0x3c, 0x00, 0x00, 0x00, 0x70, 0x55 };
++ // @, ?, ,, ., tab, cut, cpy, pste, /, '
++static const int sl6kFnSize = sizeof(sl6kFnTrans);
++#endif
++
+ /*!
+ Changes the mapping of the keyboard; adding the scancode to Unicode
+ mappings from \a map. The server takes over ownership of \a map
+@@ -882,6 +918,15 @@
+ int keypad = 0;
+
+ #ifndef QT_QWS_USE_KEYCODES
++#if defined(QT_QWS_SL6000)
++ qDebug("Key pressed: %x", code);
++ if (fn)
++ if (code < sl6kFnSize) {
++ code = sl6kFnTrans[code];
++ qDebug("Translated Fn: %x", code);
++ } else
++ qDebug("Untranslatable Fn: %x", code);
++#endif
+ #if defined(QT_QWS_IPAQ)
+ // map ipaq 'action' key (0x60, 0xe0)
+ if ((code & 0x7f) == 0x60) {
diff --git a/packages/qte/qte-2.3.12/kernel-keymap.patch b/packages/qte/qte-2.3.12/kernel-keymap.patch
new file mode 100644
index 0000000000..52771b0398
--- /dev/null
+++ b/packages/qte/qte-2.3.12/kernel-keymap.patch
@@ -0,0 +1,1042 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:15:58.396868136 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:16:25.412761096 +0100
+@@ -30,6 +30,42 @@
+ **
+ **********************************************************************/
+
++/****************************************************************************
++**
++** Keyboard Handling Redesign
++** Copyright 2003, Chris Larson <kergoth@handhelds.org>
++** Copyright 2004,2005 Holger Hans Peter Frether <freyther@handhelds.org>
++**
++** TODO: (key: . = in progress, x = completed)
++**
++** [.] Tty driver should load its initial keymap from the kernel,
++** thereby ensuring keymap consistency between X, console, and qt/e
++** [x] Read kernel keymappings.
++** [x] Read kernel keycode -> unicode map.
++** [x] Use them, along with the existing keyM, to push events up.
++** [x] Create a new table, from transformed keycode -> qt keycode, rather
++** than the existing raw keycode -> qt keycode.
++** [ ] Adapt handleKey to deal with keys that have no unicode value, such as
++** keypresses that are mapped to strings in the string table. (e.g. F keys)
++** [x] Cursor orientation change based on display rotation should not
++** be bound to Ipaq or 5xxx, but instead as a runtime choice based
++** on whether or not we're using a Transformed display driver.
++** [.] Double check that VT handling, particularly with regard to switching,
++** is handled properly.
++** [ ] Add a generic means of dealing with additional (outside the realm of
++** ctrl, alt, shift, altgr) modifiers. Also ensure a means of binding
++** a keypress/combination to a 'lock' of said additional modifiers.
++**
++** Holgers Todo
++**
++** [ ] Fix NumLock handling
++** [ ] Fix Keypad handling
++** [ ] Fix LED handling (LED_NUM and LED_CAP) don't seem to work
++** [ ] Fix CTRL+ALT+H (somehow takes the function of CTRL+ALT+BACKSPACE)
++**
++**********************************************************************/
++
++
+ #include "qwindowsystem_qws.h"
+ #include "qwsutils_qws.h"
+ #include "qgfx_qws.h"
+@@ -45,15 +81,18 @@
+ #include <ctype.h>
+
+ #include <unistd.h>
+-#ifdef _OS_LINUX_
+-#include <linux/kd.h>
+-#endif
++#include <sys/wait.h>
+ #include <sys/ioctl.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <errno.h>
+ #include <signal.h>
++#include <termios.h>
++#ifdef _OS_LINUX_
++#include <linux/kd.h>
++#include <linux/keyboard.h>
++#endif
+
+ #ifdef QT_QWS_TIP2
+ #include <qcopchannel_qws.h>
+@@ -135,17 +174,6 @@
+ };
+
+
+-#ifdef QT_QWS_SL5XXX
+-#include <asm/sharp_char.h>
+-#endif
+-
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
+-#define QT_QWS_AUTOREPEAT_MANUALLY
+-#endif
+-
+-
+-
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
+ static int dir_keyrot = -1;
+
+ static int xform_dirkey(int key)
+@@ -169,7 +197,6 @@
+ int xf = qt_screen->transformOrientation() + dir_keyrot;
+ return (key-Qt::Key_Left+xf)%4+Qt::Key_Left;
+ }
+-#endif
+
+ #define VTSWITCHSIG SIGUSR2
+
+@@ -300,11 +327,19 @@
+ { Qt::Key_F35, 0xffff , 0xffff , 0xffff }, // 21 light
+ { Qt::Key_Escape, 0xffff , 0xffff , 0xffff }, // 22
+
++#ifdef QT_QWS_SL6000
++ // Direction key code are for *UNROTATED* display.
++ { Qt::Key_Left, 0xffff , 0xffff , 0xffff }, // 23
++ { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 24
++ { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 25
++ { Qt::Key_Right, 0xffff , 0xffff , 0xffff }, // 26
++#else
+ // Direction key code are for *UNROTATED* display.
+- { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 23
+- { Qt::Key_Right, 0xffff , 0xffff , 0xffff }, // 24
+- { Qt::Key_Left, 0xffff , 0xffff , 0xffff }, // 25
+- { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 26
++ { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 23
++ { Qt::Key_Right, 0xffff , 0xffff , 0xffff }, // 24
++ { Qt::Key_Left, 0xffff , 0xffff , 0xffff }, // 25
++ { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 26
++#endif
+
+ { Qt::Key_F33, 0xffff , 0xffff , 0xffff }, // 27 OK
+ { Qt::Key_F12, 0xffff , 0xffff , 0xffff }, // 28 40 home
+@@ -369,7 +404,7 @@
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 63
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 64
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 65
+- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 66
++ { Qt::Key_F14, 0xffff , 0xffff , 0xffff }, // 66
+ { Qt::Key_Meta, 0xffff , 0xffff , 0xffff }, // 67
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 68
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 69
+@@ -649,12 +684,61 @@
+ public:
+ QWSTtyKeyboardHandler(const QString&);
+ virtual ~QWSTtyKeyboardHandler();
++ void readKeyboardMap();
++ void readUnicodeMap();
++ void handleKey(unsigned char code);
+
+ private slots:
+ void readKeyboardData();
+
+ private:
++ void modifyModifier( int map, int modify, bool release );
++ void modifyLock( unsigned int lock, bool release );
++ void handleExtra( unsigned int key, bool release );
++ static void restoreLeds();
++ static void toggleLed(unsigned int);
++ int map_to_modif ();
++
++private:
+ struct termios origTermData;
++ unsigned short acm[E_TABSZ];
++ struct KeyMap {
++ enum ExtraKey{
++ Key_AltGr = 0x01ffff,
++ Key_Console1 = 0x02ffff,
++ Key_Console2 = 0x03ffff,
++ Key_Console3 = 0x04ffff,
++ Key_Console4 = 0x05ffff,
++ Key_Console5 = 0x06ffff,
++ Key_Console6 = 0x07ffff,
++ Key_Console7 = 0x08ffff,
++ Key_Console8 = 0x09ffff,
++ Key_Console9 = 0x0affff,
++ Key_Console10 = 0x0bffff,
++ Key_Console11 = 0x0cffff,
++ Key_Console12 = 0x0dffff,
++ Key_NumLock = 0x0effff,
++ Key_ShiftLock = 0x0fffff,
++ Key_CtrlLock = 0x10ffff,
++ Key_AltLock = 0x11ffff,
++ Key_AltGrLock = 0x12ffff
++ };
++
++ KeyMap( Qt::Key _key = Qt::Key_unknown, unsigned short _code = 0 )
++ : key( _key ), code( _code )
++ {}
++ KeyMap( ExtraKey _key, unsigned short _code )
++ : key( _key ), code( _code )
++ {}
++ unsigned int key; // 16 Bit
++ unsigned short code;
++ };
++
++ KeyMap kernel_map[(1<<KG_CAPSSHIFT)][NR_KEYS];
++ int current_map;
++ int modifier;
++ bool numlock : 1;
++ bool capslock : 1;
+ };
+
+
+@@ -814,6 +898,7 @@
+ fn = FALSE;
+
+ numLock = FALSE;
++#if 0
+ sharp_kbdctl_modifstat st;
+ int dev = ::open("/dev/sharp_kbdctl", O_RDWR);
+ if( dev >= 0 ) {
+@@ -825,6 +910,7 @@
+ ::close(dev);
+ }
+ #endif
++#endif
+ #if defined(QT_QWS_IPAQ)
+ // iPAQ Action Key has ScanCode 0x60: 0x60|0x80 = 0xe0 == extended mode 1 !
+ ipaq_return_pressed = FALSE;
+@@ -957,7 +1043,7 @@
+ }
+ } else if ( extended == 2 ) {
+ switch (code) {
+- case 0x1d:
++ case 0x1d:
+ return;
+ case 0x45:
+ keyCode = Qt::Key_Pause;
+@@ -1197,7 +1283,7 @@
+ unicode = '`';
+ } else
+ #endif
+-
++
+ if (bCtrl)
+ unicode = currentKey->ctrl_unicode;
+ else if (bCaps)
+@@ -1250,9 +1336,12 @@
+ //
+ // Tty keyboard
+ //
++#include "keyboard_linux_to_qt.h"
+
+ QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString& device)
++ : current_map(0), modifier( 0 ), numlock( false ), capslock( false )
+ {
++ restoreLeds();
+ kbdFD=open(device.isEmpty() ? "/dev/tty0" : device.latin1(), O_RDWR | O_NDELAY, 0);
+
+ if ( kbdFD >= 0 ) {
+@@ -1268,11 +1357,7 @@
+ tcgetattr( kbdFD, &termdata );
+
+ #if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
+-# ifdef QT_QWS_USE_KEYCODES
+- ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW);
+-# else
+- ioctl(kbdFD, KDSKBMODE, K_RAW);
+-# endif
++ ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW);
+ #endif
+
+ termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
+@@ -1285,6 +1370,9 @@
+ cfsetospeed(&termdata, 9600);
+ tcsetattr(kbdFD, TCSANOW, &termdata);
+
++ readUnicodeMap();
++ readKeyboardMap();
++
+ signal(VTSWITCHSIG, vtSwitchHandler);
+
+ #if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
+@@ -1306,6 +1394,7 @@
+
+ QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler()
+ {
++ restoreLeds();
+ if (kbdFD >= 0)
+ {
+
+@@ -1334,13 +1423,451 @@
+ kbdFD = -1;
+ }
+ }
++void QWSTtyKeyboardHandler::readUnicodeMap()
++{
++ if (kbdFD < 0)
++ return;
++ if (ioctl(kbdFD,GIO_UNISCRNMAP,acm) != 0)
++ return;
++}
++
++
++void QWSTtyKeyboardHandler::readKeyboardMap()
++{
++ struct kbentry kbe;
++ if (kbdFD < 0)
++ return;
++
++ for (int map = 0; map < (1<<KG_CAPSSHIFT); ++map) {
++ unsigned short kval;
++ kbe.kb_table = map;
++
++ for (int key = 0; key < NR_KEYS; ++key) {
++ kbe.kb_index = key;
++
++ if (ioctl(kbdFD, KDGKBENT, &kbe) != 0)
++ continue;
++
++ if ((kbe.kb_value == K_HOLE) || (kbe.kb_value == K_NOSUCHMAP))
++ continue;
++
++ kval = KVAL(kbe.kb_value);
++ switch (KTYP(kbe.kb_value)) {
++ /*
++ * Map asciis and letters to Qt KeyCodes
++ * via the map (0-255)
++ */
++ case KT_LETTER:
++ case KT_LATIN:
++ kernel_map[map][key] = KeyMap( linux_to_qt[kval], kval );
++ break;
++
++ /*
++ * Handle the F Keys and map them
++ * to Qt
++ */
++ case KT_FN:
++ if ( kval <= 19 )
++ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F1 + kval ), kval );
++ else if ( kval >= 31 && kval <= 33)
++ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F21 + kval ), kval );
++ else if ( kval >= 34 && kval <= 45 ) {
++ int off = kval-34;
++ kernel_map[map][key] = KeyMap(static_cast<KeyMap::ExtraKey>( KeyMap::Key_Console1+off ), kval );
++ }else
++ switch(kbe.kb_value ) {
++ case K_INSERT:
++ kernel_map[map][key] = KeyMap( Qt::Key_Insert, kval );
++ break;
++ case K_REMOVE:
++ kernel_map[map][key] = KeyMap( Qt::Key_Delete, kval ); // right?
++ break;
++ case K_SELECT:
++ kernel_map[map][key] = KeyMap( Qt::Key_End , kval );
++ break;
++ case K_PGUP:
++ kernel_map[map][key] = KeyMap( Qt::Key_Prior, kval );
++ break;
++ case K_PGDN:
++ kernel_map[map][key] = KeyMap( Qt::Key_Next, kval );
++ break;
++ case K_MACRO:
++ kernel_map[map][key] = KeyMap( Qt::Key_Menu, kval );
++ break;
++ case K_HELP:
++ kernel_map[map][key] = KeyMap( Qt::Key_Help, kval );
++ break;
++ case K_PAUSE:
++ kernel_map[map][key] = KeyMap( Qt::Key_Pause, kval );
++ break;
++ case K_FIND:
++ case K_DO:
++ default:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ break;
++ }
++ break;
++
++ case KT_SPEC:
++ switch ( kbe.kb_value ) {
++ case K_ENTER:
++ kernel_map[map][key] = KeyMap( Qt::Key_Enter, kval );
++ break;
++ case K_CAPS:
++ kernel_map[map][key] = KeyMap( Qt::Key_CapsLock, kval );
++ break;
++ case K_NUM:
++ kernel_map[map][key] = KeyMap( Qt::Key_NumLock, kval );
++ break;
++ case K_HOLD:
++ kernel_map[map][key] = KeyMap( Qt::Key_ScrollLock, kval );
++ break;
++ case K_HOLE:
++ case K_SH_REGS:
++ case K_SH_MEM:
++ case K_SH_STAT:
++ case K_BREAK:
++ case K_CONS:
++ case K_SCROLLFORW:
++ case K_SCROLLBACK:
++ case K_BOOT:
++ case K_CAPSON:
++ case K_COMPOSE:
++ case K_SAK:
++ case K_DECRCONSOLE:
++ case K_INCRCONSOLE:
++ case K_SPAWNCONSOLE:
++ case K_BARENUMLOCK:
++ default:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ break;
++ }
++ break;
++ case KT_PAD:
++ /*
++ * Number Values might be wrong
++ */
++ switch(kbe.kb_value ) {
++ case K_P0:
++ kernel_map[map][key] = KeyMap( Qt::Key_0, kval );
++ break;
++ case K_P1:
++ kernel_map[map][key] = KeyMap( Qt::Key_1, kval );
++ break;
++ case K_P2:
++ kernel_map[map][key] = KeyMap( Qt::Key_2, kval );
++ break;
++ case K_P3:
++ kernel_map[map][key] = KeyMap( Qt::Key_3, kval );
++ break;
++ case K_P4:
++ kernel_map[map][key] = KeyMap( Qt::Key_4, kval );
++ break;
++ case K_P5:
++ kernel_map[map][key] = KeyMap( Qt::Key_5, kval );
++ break;
++ case K_P6:
++ kernel_map[map][key] = KeyMap( Qt::Key_6, kval );
++ break;
++ case K_P7:
++ kernel_map[map][key] = KeyMap( Qt::Key_7, kval );
++ break;
++ case K_P8:
++ kernel_map[map][key] = KeyMap( Qt::Key_8, kval );
++ break;
++ case K_P9:
++ kernel_map[map][key] = KeyMap( Qt::Key_9, kval );
++ break;
++ case K_PPLUS:
++ kernel_map[map][key] = KeyMap( Qt::Key_Plus, kval );
++ break;
++ case K_PMINUS:
++ kernel_map[map][key] = KeyMap( Qt::Key_Minus, kval );
++ break;
++ case K_PSTAR:
++ kernel_map[map][key] = KeyMap( Qt::Key_multiply, kval );
++ break;
++ case K_PSLASH:
++ kernel_map[map][key] = KeyMap( Qt::Key_division, kval );
++ break;
++ case K_PENTER:
++ kernel_map[map][key] = KeyMap( Qt::Key_Enter, kval );
++ break;
++ case K_PCOMMA:
++ kernel_map[map][key] = KeyMap( Qt::Key_Comma, kval ) ;
++ break;
++ case K_PPLUSMINUS:
++ kernel_map[map][key] = KeyMap( Qt::Key_plusminus, kval );
++ case K_PDOT:
++ break;
++ case K_PPARENL:
++ kernel_map[map][key] = KeyMap( Qt::Key_ParenLeft, kval );
++ break;
++ case K_PPARENR:
++ kernel_map[map][key] = KeyMap( Qt::Key_ParenRight, kval );
++ break;
++ default:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ break;
++ }
++ break;
++ case KT_DEAD:
++ switch(kbe.kb_value ) {
++ case K_DGRAVE:
++ case K_DACUTE:
++ case K_DCIRCM:
++ case K_DTILDE:
++ case K_DDIERE:
++ case K_DCEDIL:
++ default:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ break;
++ }
++ break;
++
++ case KT_CONS:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ break;
++
++ case KT_CUR:
++ switch(kbe.kb_value ) {
++ case K_DOWN:
++ kernel_map[map][key] = KeyMap( Qt::Key_Down, kval );
++ break;
++ case K_LEFT:
++ kernel_map[map][key] = KeyMap( Qt::Key_Left, kval );
++ break;
++ case K_RIGHT:
++ kernel_map[map][key] = KeyMap( Qt::Key_Right, kval );
++ break;
++ case K_UP:
++ kernel_map[map][key] = KeyMap( Qt::Key_Up, kval );
++ break;
++ }
++ break;
++
++ case KT_SHIFT:
++ switch( kbe.kb_value ) {
++ case K_SHIFT:
++ kernel_map[map][key] = KeyMap( Qt::Key_Shift, kval );
++ break;
++ case K_ALT:
++ kernel_map[map][key] = KeyMap( Qt::Key_Alt, kval );
++ break;
++ case K_CTRL:
++ kernel_map[map][key] = KeyMap( Qt::Key_Control, kval );
++ break;
++ case K_ALTGR:
++ kernel_map[map][key] = KeyMap( KeyMap::Key_AltGr, kval );
++ break;
++ case K_SHIFTL:
++ case K_SHIFTR:
++ case K_CTRLL:
++ case K_CTRLR:
++ case K_CAPSSHIFT:
++ default:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ break;
++ }
++ break;
++ /*
++ * What is this for?
++ */
++ case KT_ASCII:
++ case KT_LOCK:
++ case KT_SLOCK:
++ default:
++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ //qWarning("keycode %d, map %d, type %d, val %d, acm %c\n", key, map, KTYP(kbe.kb_value), kval, acm[kval]);
++ break;
++ }
++ }
++ }
++}
++int QWSTtyKeyboardHandler::map_to_modif()
++{
++ int modifiers = 0;
++
++ if (current_map & (1<<KG_ALT))
++ modifiers |= Qt::AltButton;
++ else if (current_map & (1<<KG_CTRL))
++ modifiers |= Qt::ControlButton;
++ else if (current_map & (1<<KG_SHIFT))
++ modifiers |= Qt::ShiftButton;
++
++ return modifiers;
++}
++
++/*
++ * Handle Extra Keys for VT switching and Quitting
++ */
++void QWSTtyKeyboardHandler::handleExtra( unsigned int key, bool release ) {
++ if ( !release ) {
++ int term = 0;
++ if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL)) ) {
++ if ( key == Qt::Key_Left )
++ term = QMAX(vtQws -1, 1 );
++ else if ( key == Qt::Key_Right )
++ term = QMIN(vtQws +1, 12 );
++ }
++
++ if ( key >= KeyMap::Key_Console1 && key <= KeyMap::Key_Console12 )
++ term = key - KeyMap::Key_Console1 + 1;
++
++ if ( term != 0 ) {
++ current_map = modifier = 0;
++ numlock = capslock = false;
++ ioctl(kbdFD, VT_ACTIVATE, term );
++ return;
++ }
++ }
++
++ if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL) ) )
++ if ( key == Qt::Key_Delete || key == Qt::Key_Backspace ) {
++ qWarning( "Instructed to quit on %d", key );
++ qApp->quit();
++ }
++}
++
++/*
++ * apply modifier
++ */
++void QWSTtyKeyboardHandler::modifyModifier( int map, int modify, bool release ) {
++ if (map != -1) {
++ if (release)
++ current_map &= ~map;
++ else
++ current_map |= map;
++ }
++
++ if ( modify != -1 ) {
++ if (release)
++ modifier &= ~modify;
++ else
++ modifier |= modify;
++ }
++}
++
++void QWSTtyKeyboardHandler::handleKey(unsigned char code)
++{
++ int old_modifier = modifier;
++ bool release = false;
++ bool mod_key = true;
++
++ if (code & 0x80)
++ {
++ release = true;
++ code &= 0x7f;
++ }
++
++ KeyMap key_map = kernel_map[current_map][code];
++ unsigned short unicode = acm[key_map.code];
++ unsigned int qtKeyCode = key_map.key;
++
++ if ( !release )
++ qWarning( "KeyCode: %d KVAL: %d", qtKeyCode, key_map.code );
++// qWarning( "Alt:%d Ctrl:%d Shift:%d Key = %d", modifier & (1<<KG_ALT),
++// modifier & (1<<KG_CTRL),
++// modifier & (1<<KG_SHIFT), key_map.key );
++// qDebug("code %d, mCode %d, uni '%c', qtKeyCode %d", code, map.code,
++// QChar(unicode ).isPrint() ?
++// unicode : '?' , qtKeyCode);
++
++ // Handle map changes based on press/release of modifiers
++ // hardcoded for now
++ int modif = -1;
++ int map = -1;
++ bool lock = false;
++ switch (qtKeyCode)
++ {
++ case Qt::Key_Alt:
++ case Qt::Key_F22:
++ modif = (1<<KG_ALT);
++ break;
++ case Qt::Key_Control:
++ modif = (1<<KG_CTRL);
++ map = modif;
++ break;
++ case Qt::Key_Shift:
++ modif = (1<<KG_SHIFT);
++ map = modif;
++ break;
++ case KeyMap::Key_AltGr:
++ map = (1<<KG_ALTGR );
++ break;
++ case Qt::Key_Left:
++ case Qt::Key_Right:
++ case Qt::Key_Up:
++ case Qt::Key_Down:
++ mod_key = false;
++ if (qt_screen->isTransformed())
++ qtKeyCode = static_cast<Qt::Key>( xform_dirkey(static_cast<int>( qtKeyCode ) ) );
++ break;
++ /*
++ * handle lock, we don't handle scroll lock!
++ */
++ case Qt::Key_CapsLock:
++ case Qt::Key_NumLock:
++ lock = true;
++ default:
++ mod_key = false;
++ break;
++ }
++
++
++ /*
++ * Change the Map. We handle locks a bit different
++ */
++ if ( lock )
++ modifyLock( qtKeyCode, release );
++ else
++ modifyModifier( map, modif, release );
++
++ handleExtra( qtKeyCode, release );
++
++ /*
++ * do not repeat modifier keys
++ */
++ if ( modifier == old_modifier && mod_key )
++ return;
++
++ processKeyEvent(unicode & 0xff, qtKeyCode, map_to_modif(), !release, 0);
++}
+
+ void QWSTtyKeyboardHandler::readKeyboardData()
+ {
+ unsigned char buf[81];
+ int n = ::read(kbdFD, buf, 80 );
+ for ( int loop = 0; loop < n; loop++ )
+- doKey(buf[loop]);
++ handleKey(buf[loop]);
++}
++
++void QWSTtyKeyboardHandler::modifyLock( unsigned int lock, bool release ) {
++ if ( !release )
++ return;
++
++ if ( lock == Qt::Key_CapsLock ) {
++ toggleLed( LED_CAP );
++ capslock = !capslock;
++ }else if ( lock == Qt::Key_NumLock ) {
++ toggleLed( LED_NUM );
++ numlock = !numlock;
++ }
++}
++
++void QWSTtyKeyboardHandler::restoreLeds() {
++ unsigned int leds;
++ ioctl(kbdFD, KDGETLED, &leds );
++ leds &= ~LED_CAP;
++ leds &= ~LED_NUM;
++ ioctl(kbdFD, KDSETLED, &leds );
++}
++
++void QWSTtyKeyboardHandler::toggleLed(unsigned int led) {
++ unsigned int leds;
++ int ret = ioctl(kbdFD, KDGETLED, &leds );
++ leds = leds & led ? (leds & ~led) : (leds | led);
++ ret = ioctl(kbdFD, KDSETLED, &leds );
+ }
+
+ typedef struct {
+@@ -1445,13 +1972,13 @@
+ return;
+ #ifdef QT_QWS_TIP2
+ // custom scan codes - translate them and create a key event immediately
+- if( overrideMap && event.value == 0 || overrideMap->find( event.value ) )
++ if( overrideMap && event.value == 0 || overrideMap->find( event.value ) )
+ {
+ if( event.value )
+ {
+ int modifiers = 0;
+ QWSServer::KeyMap *km = overrideMap->find( event.value );
+- switch( km->unicode )
++ switch( km->unicode )
+ {
+ case Key_Menu:
+ case Key_Back:
+@@ -1479,14 +2006,14 @@
+ TRUE, FALSE );
+ }
+ lastPress = km;
+- }
+- else if( lastPress )
++ }
++ else if( lastPress )
+ {
+- processKeyEvent( lastPress->unicode, lastPress->key_code, 0,
++ processKeyEvent( lastPress->unicode, lastPress->key_code, 0,
+ FALSE, FALSE );
+ lastPress = 0;
+ }
+- }
++ }
+ else
+ #endif
+ {
+@@ -1854,10 +2381,10 @@
+ handler = new QWSUsbKeyboardHandler(device);
+ } else if ( type == "TTY" ) {
+ handler = new QWSTtyKeyboardHandler(device);
+- }
++ }
+ else if( type == "Samsung" ) {
+ handler = new QWSSamsungKeypadHandler(device);
+- }
++ }
+ else {
+ qWarning( "Keyboard type %s:%s unsupported", spec.latin1(), device.latin1() );
+ }
+Index: qt-2.3.10-snapshot-20060120/src/kernel/keyboard_linux_to_qt.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10-snapshot-20060120/src/kernel/keyboard_linux_to_qt.h 2006-01-20 21:16:25.413760944 +0100
+@@ -0,0 +1,263 @@
++/*
++ * Generated with a small python utility found at
++ * http://handhelds.org/~zecke/downloads/python_keytable_creator.py
++ */
++
++static const Qt::Key linux_to_qt[] = {
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_Backspace,
++Qt::Key_Tab,
++Qt::Key_unknown, // LineFeed
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown, // No Symbol
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown, // No Symbol
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_Escape,
++Qt::Key_unknown,
++Qt::Key_unknown, // No symbol
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_Space,
++Qt::Key_Exclam,
++Qt::Key_QuoteDbl,
++Qt::Key_NumberSign,
++Qt::Key_Dollar,
++Qt::Key_Percent,
++Qt::Key_Ampersand,
++Qt::Key_Apostrophe,
++Qt::Key_ParenLeft,
++Qt::Key_ParenRight,
++Qt::Key_Asterisk,
++Qt::Key_Plus,
++Qt::Key_Comma,
++Qt::Key_Minus,
++Qt::Key_Period,
++Qt::Key_Slash,
++Qt::Key_0,
++Qt::Key_1,
++Qt::Key_2,
++Qt::Key_3,
++Qt::Key_4,
++Qt::Key_5,
++Qt::Key_6,
++Qt::Key_7,
++Qt::Key_8,
++Qt::Key_9,
++Qt::Key_Colon,
++Qt::Key_Semicolon,
++Qt::Key_Less,
++Qt::Key_Equal,
++Qt::Key_Greater,
++Qt::Key_Question,
++Qt::Key_At,
++Qt::Key_A,
++Qt::Key_B,
++Qt::Key_C,
++Qt::Key_D,
++Qt::Key_E,
++Qt::Key_F,
++Qt::Key_G,
++Qt::Key_H,
++Qt::Key_I,
++Qt::Key_J,
++Qt::Key_K,
++Qt::Key_L,
++Qt::Key_M,
++Qt::Key_N,
++Qt::Key_O,
++Qt::Key_P,
++Qt::Key_Q,
++Qt::Key_R,
++Qt::Key_S,
++Qt::Key_T,
++Qt::Key_U,
++Qt::Key_V,
++Qt::Key_W,
++Qt::Key_X,
++Qt::Key_Y,
++Qt::Key_Z,
++Qt::Key_BracketLeft,
++Qt::Key_Backslash,
++Qt::Key_BracketRight,
++Qt::Key_AsciiCircum,
++Qt::Key_Underscore,
++Qt::Key_QuoteLeft, // grave
++Qt::Key_A,
++Qt::Key_B,
++Qt::Key_C,
++Qt::Key_D,
++Qt::Key_E,
++Qt::Key_F,
++Qt::Key_G,
++Qt::Key_H,
++Qt::Key_I,
++Qt::Key_J,
++Qt::Key_K,
++Qt::Key_L,
++Qt::Key_M,
++Qt::Key_N,
++Qt::Key_O,
++Qt::Key_P,
++Qt::Key_Q,
++Qt::Key_R,
++Qt::Key_S,
++Qt::Key_T,
++Qt::Key_U,
++Qt::Key_V,
++Qt::Key_W,
++Qt::Key_X,
++Qt::Key_Y,
++Qt::Key_Z,
++Qt::Key_BraceLeft,
++Qt::Key_Bar,
++Qt::Key_BraceRight,
++Qt::Key_AsciiTilde,
++Qt::Key_BackSpace,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_unknown,
++Qt::Key_nobreakspace,
++Qt::Key_exclamdown,
++Qt::Key_cent,
++Qt::Key_sterling,
++Qt::Key_currency,
++Qt::Key_yen,
++Qt::Key_brokenbar,
++Qt::Key_section,
++Qt::Key_diaeresis,
++Qt::Key_copyright,
++Qt::Key_ordfeminine,
++Qt::Key_guillemotleft,
++Qt::Key_notsign,
++Qt::Key_hyphen,
++Qt::Key_registered,
++Qt::Key_macron,
++Qt::Key_degree,
++Qt::Key_plusminus,
++Qt::Key_twosuperior,
++Qt::Key_threesuperior,
++Qt::Key_acute,
++Qt::Key_mu,
++Qt::Key_paragraph,
++Qt::Key_periodcentered,
++Qt::Key_cedilla,
++Qt::Key_onesuperior,
++Qt::Key_masculine,
++Qt::Key_guillemotright,
++Qt::Key_onequarter,
++Qt::Key_onehalf,
++Qt::Key_threequarters,
++Qt::Key_questiondown,
++Qt::Key_Agrave,
++Qt::Key_Aacute,
++Qt::Key_Acircumflex,
++Qt::Key_Atilde,
++Qt::Key_Adiaeresis,
++Qt::Key_Aring,
++Qt::Key_AE,
++Qt::Key_Ccedilla,
++Qt::Key_Egrave,
++Qt::Key_Eacute,
++Qt::Key_Ecircumflex,
++Qt::Key_Ediaeresis,
++Qt::Key_Igrave,
++Qt::Key_Iacute,
++Qt::Key_Icircumflex,
++Qt::Key_Idiaeresis,
++Qt::Key_ETH,
++Qt::Key_Ntilde,
++Qt::Key_Ograve,
++Qt::Key_Oacute,
++Qt::Key_Ocircumflex,
++Qt::Key_Otilde,
++Qt::Key_Odiaeresis,
++Qt::Key_multiply,
++Qt::Key_Ooblique,
++Qt::Key_Ugrave,
++Qt::Key_Uacute,
++Qt::Key_Ucircumflex,
++Qt::Key_Udiaeresis,
++Qt::Key_Yacute,
++Qt::Key_THORN,
++Qt::Key_ssharp,
++Qt::Key_agrave,
++Qt::Key_aacute,
++Qt::Key_acircumflex,
++Qt::Key_atilde,
++Qt::Key_adiaeresis,
++Qt::Key_aring,
++Qt::Key_ae,
++Qt::Key_ccedilla,
++Qt::Key_egrave,
++Qt::Key_eacute,
++Qt::Key_ecircumflex,
++Qt::Key_ediaeresis,
++Qt::Key_igrave,
++Qt::Key_iacute,
++Qt::Key_icircumflex,
++Qt::Key_idiaeresis,
++Qt::Key_eth,
++Qt::Key_ntilde,
++Qt::Key_ograve,
++Qt::Key_oacute,
++Qt::Key_ocircumflex,
++Qt::Key_otilde,
++Qt::Key_odiaeresis,
++Qt::Key_division,
++Qt::Key_oslash,
++Qt::Key_ugrave,
++Qt::Key_uacute,
++Qt::Key_ucircumflex,
++Qt::Key_udiaeresis,
++Qt::Key_yacute,
++Qt::Key_thorn,
++Qt::Key_ydiaeresis
++};
diff --git a/packages/qte/qte-2.3.12/key.patch b/packages/qte/qte-2.3.12/key.patch
new file mode 100644
index 0000000000..590ae9a7c6
--- /dev/null
+++ b/packages/qte/qte-2.3.12/key.patch
@@ -0,0 +1,90 @@
+
+#
+# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qkeyboard_qws.cpp 2006-01-20 20:57:47.547702416 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:09:23.001977296 +0100
+@@ -848,6 +848,9 @@
+ bool release = false;
+ int keypad = 0;
+
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) // need autorepeat implemented here?
++ bool repeatable = TRUE;
++
+ #ifndef QT_QWS_USE_KEYCODES
+ #if defined(QT_QWS_IPAQ)
+ // map ipaq 'action' key (0x60, 0xe0)
+@@ -984,9 +987,6 @@
+ if ( currentKey )
+ keyCode = currentKey->key_code;
+
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) // need autorepeat implemented here?
+- bool repeatable = TRUE;
+-
+ #if defined(QT_QWS_IPAQ)
+ switch (code) {
+ #if defined(QT_QWS_SL5XXX)
+@@ -1061,25 +1061,23 @@
+ repeatable = FALSE;
+ #endif
+
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
+ if ( qt_screen->isTransformed()
+ && keyCode >= Qt::Key_Left && keyCode <= Qt::Key_Down )
+ {
+ keyCode = xform_dirkey(keyCode);
+ }
+-
+-#ifdef QT_QWS_AUTOREPEAT_MANUALLY
+- if ( repeatable && !release )
+- rep->start(prevuni,prevkey,modifiers);
+- else
+- rep->stop();
+ #endif
++
+ #endif
+ /*
+ Translate shift+Key_Tab to Key_Backtab
+ */
+ if (( keyCode == Key_Tab ) && shift )
+ keyCode = Key_Backtab;
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
+ }
++#endif
+
+ #ifndef QT_QWS_USE_KEYCODES
+ /*
+@@ -1234,6 +1232,14 @@
+ } else {
+ prevkey = prevuni = 0;
+ }
++
++#ifdef QT_QWS_AUTOREPEAT_MANUALLY
++ if ( repeatable && !release )
++ rep->start(prevuni,prevkey,modifiers);
++ else
++ rep->stop();
++#endif
++
+ }
+ #ifndef QT_QWS_USE_KEYCODES
+ extended = 0;
+@@ -2059,6 +2065,7 @@
+ press ? "press" : "release",
+ repeatable ? "true":"false" );
+
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
+ if ( qt_screen->isTransformed() && k >= Qt::Key_Left && k <= Qt::Key_Down )
+ {
+ qDebug( "SimpadButtonsHandler() - We are transformed! Correcting..." );
+@@ -2066,6 +2073,7 @@
+ k = xform_dirkey( k );
+ qDebug( "SimpadButtonsHandler() - Old Key: %d - New Key %d", oldK, k );
+ }
++#endif
+
+ if ( repeatable && press )
+ repeater->start( repeatdelay, true );
diff --git a/packages/qte/qte-2.3.12/mnci-touchscreen.patch b/packages/qte/qte-2.3.12/mnci-touchscreen.patch
new file mode 100644
index 0000000000..570c2ff290
--- /dev/null
+++ b/packages/qte/qte-2.3.12/mnci-touchscreen.patch
@@ -0,0 +1,1987 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/kernel/qwsmouse_qws.cpp~ramses-touchscreen
++++ qt-2.3.10/src/kernel/qwsmouse_qws.cpp
+@@ -1,5 +1,5 @@
+ /****************************************************************************
+-** $Id: qt/src/kernel/qwsmouse_qws.cpp 2.3.10 edited 2005-01-24 $
++** $Id: qt/src/kernel/qwsmouse_qws.cpp 2.3.7 edited 2003-02-04 $
+ **
+ ** Implementation of Qt/Embedded mouse drivers
+ **
+@@ -47,85 +47,32 @@
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <sys/ioctl.h>
+-#include <sys/time.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <errno.h>
+ #include <termios.h>
+
++
+ #include <qgfx_qws.h>
+ #if !defined(_OS_QNX6_)
+
+-#ifdef QT_QWS_CASSIOPEIA
+-#include <linux/tpanel.h>
+-#endif
+-#ifdef QT_QWS_TSLIB
+-#include <tslib.h>
+-#endif
+-
+-
+-//#define QT_QWS_K2
+-
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_K2)
+-#define QT_QWS_IPAQ_RAW
+-typedef struct {
+- unsigned short pressure;
+- unsigned short x;
+- unsigned short y;
+- unsigned short pad;
+- struct timeval stamp;
+-} TS_EVENT;
+-#elif defined(QT_QWS_SL5XXX)
+-#define QT_QWS_SL5XXX_RAW
+-typedef struct {
+- long y;
+- long x;
+- long pressure;
+- long long millisecs;
+-} TS_EVENT;
+-#define QT_QWS_TP_SAMPLE_SIZE 10
+-#define QT_QWS_TP_MINIMUM_SAMPLES 4
+-#define QT_QWS_TP_PRESSURE_THRESHOLD 500
+-#define QT_QWS_TP_MOVE_LIMIT 50
+-#define QT_QWS_TP_JITTER_LIMIT 2
+-#elif defined(QT_QWS_SLC700)
+-#define QT_QWS_SLC700_RAW
+-typedef struct {
+- unsigned short pressure;
+- unsigned short x;
+- unsigned short y;
+- unsigned short millisecs;
+-} TS_EVENT;
+-#define QT_QWS_TP_SAMPLE_SIZE 10
+-#define QT_QWS_TP_MINIMUM_SAMPLES 4
+-#define QT_QWS_TP_PRESSURE_THRESHOLD 500
+-#define QT_QWS_TP_MOVE_LIMIT 50
+-#define QT_QWS_TP_JITTER_LIMIT 2
+-#endif
+-
+-#ifndef QT_QWS_TP_SAMPLE_SIZE
+-#define QT_QWS_TP_SAMPLE_SIZE 5
+-#endif
+-
+-#ifndef QT_QWS_TP_MINIMUM_SAMPLES
+-#define QT_QWS_TP_MINIMUM_SAMPLES 5
++#ifndef QT_QWS_TP_PRESSURE_DOWN_THRESHOLD
++#define QT_QWS_TP_PRESSURE_DOWN_THRESHOLD 500
+ #endif
+
+-#ifndef QT_QWS_TP_PRESSURE_THRESHOLD
+-#define QT_QWS_TP_PRESSURE_THRESHOLD 1
++#ifndef QT_QWS_TP_PRESSURE_UP_THRESHOLD
++#define QT_QWS_TP_PRESSURE_UP_THRESHOLD 450
+ #endif
+
+-#ifndef QT_QWS_TP_MOVE_LIMIT
+-#define QT_QWS_TP_MOVE_LIMIT 100
++#ifndef QT_QWS_TP_TABLE_SIZE
++#define QT_QWS_TP_TABLE_SIZE 2
+ #endif
+
+-#ifndef QT_QWS_TP_JITTER_LIMIT
+-#define QT_QWS_TP_JITTER_LIMIT 2
++#ifndef QT_QWS_TP_MOVE_MAX
++#define QT_QWS_TP_MOVE_MAX 100
+ #endif
+
+-//#define QWS_CUSTOMTOUCHPANEL
+-
+ /*!
+ \class QWSMouseHandler qwsmouse_qws.h
+ \brief Mouse driver/handler for Qt/Embedded
+@@ -168,8 +115,7 @@
+ enum MouseProtocol { Unknown = -1, Auto = 0,
+ MouseMan, IntelliMouse, Microsoft,
+ QVFBMouse, TPanel, BusMouse,
+- FirstAuto = MouseMan,
+- LastAuto = Microsoft };
++ };
+
+ static void limitToScreen( QPoint &pt )
+ {
+@@ -186,810 +132,14 @@
+ } MouseConfig;
+
+ static const MouseConfig mouseConfig[] = {
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+ { "Auto", Auto },
+-#endif
+-#ifndef QT_NO_QWS_MOUSE_PC
+- { "MouseMan", MouseMan },
+- { "IntelliMouse", IntelliMouse },
+- { "USB", IntelliMouse },
+- { "Microsoft", Microsoft },
+-#endif
+-#ifndef QT_NO_QWS_VFB
+ { "QVFbMouse", QVFBMouse },
+-#endif
+ { "TPanel", TPanel },
+- { "BusMouse", BusMouse },
+ { 0, Unknown }
+ };
+
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+-/*
+- * Automatic-detection mouse driver
+- */
+-
+-class QAutoMouseSubHandler {
+-protected:
+- enum { max_buf=32 };
+-
+- int fd;
+-
+- uchar buffer[max_buf];
+- int nbuf;
+-
+- QPoint motion;
+- int bstate;
+-
+- int goodness;
+- int badness;
+-
+- virtual int tryData()=0;
+-
+-public:
+- QAutoMouseSubHandler(int f) : fd(f)
+- {
+- nbuf = bstate = goodness = badness = 0;
+- }
+-
+- int file() const { return fd; }
+-
+- void closeIfNot(int& f)
+- {
+- if ( fd != f ) {
+- f = fd;
+- close(fd);
+- }
+- }
+-
+- void worse(int by=1) { badness+=by; }
+- bool reliable() const { return goodness >= 5 && badness < 50; }
+- int buttonState() const { return bstate; }
+- bool motionPending() const { return motion!=QPoint(0,0); }
+- QPoint takeMotion() { QPoint r=motion; motion=QPoint(0,0); return r; }
+-
+- void appendData(uchar* data, int length)
+- {
+- memcpy(buffer+nbuf, data, length);
+- nbuf += length;
+- }
+-
+- enum UsageResult { Insufficient, Motion, Button };
+-
+- UsageResult useData()
+- {
+- int pbstate = bstate;
+- int n = tryData();
+- if ( n > 0 ) {
+- if ( n<nbuf )
+- memmove( buffer, buffer+n, nbuf-n );
+- nbuf -= n;
+- return pbstate == bstate ? Motion : Button;
+- }
+- return Insufficient;
+- }
+-};
+-
+-class QAutoMouseSubHandler_intellimouse : public QAutoMouseSubHandler {
+- int packetsize;
+-public:
+- QAutoMouseSubHandler_intellimouse(int f) : QAutoMouseSubHandler(f)
+- {
+- init();
+- }
+-
+- void init()
+- {
+- int n;
+- uchar reply[20];
+-
+- tcflush(fd,TCIOFLUSH);
+- static const uchar initseq[] = { 243, 200, 243, 100, 243, 80 };
+- static const uchar query[] = { 0xf2 };
+- if (write(fd, initseq, sizeof(initseq))!=sizeof(initseq)) {
+- badness = 100;
+- return;
+- }
+- usleep(10000);
+- tcflush(fd,TCIOFLUSH);
+- if (write(fd, query, sizeof(query))!=sizeof(query)) {
+- badness = 100;
+- return;
+- }
+- usleep(10000);
+- n = read(fd, reply, 20);
+- if ( n > 0 ) {
+- goodness = 10;
+- switch ( reply[n-1] ) {
+- case 3:
+- case 4:
+- packetsize = 4;
+- break;
+- default:
+- packetsize = 3;
+- }
+- } else {
+- badness = 100;
+- }
+- }
+-
+- int tryData()
+- {
+- if ( nbuf >= packetsize ) {
+- //int overflow = (buffer[0]>>6 )& 0x03;
+-
+- if ( /*overflow ||*/ !(buffer[0] & 8) ) {
+- badness++;
+- return 1;
+- } else {
+- motion +=
+- QPoint((buffer[0] & 0x10) ? buffer[1]-256 : buffer[1],
+- (buffer[0] & 0x20) ? 256-buffer[2] : -buffer[2]);
+- int nbstate = buffer[0] & 0x7;
+- if ( motion.x() || motion.y() || bstate != nbstate ) {
+- bstate = nbstate;
+- goodness++;
+- } else {
+- badness++;
+- return 1;
+- }
+- }
+- return packetsize;
+- }
+- return 0;
+- }
+-};
+-
+-class QAutoMouseSubHandler_serial : public QAutoMouseSubHandler {
+-public:
+- QAutoMouseSubHandler_serial(int f) : QAutoMouseSubHandler(f)
+- {
+- initSerial();
+- }
+-
+-protected:
+- void setflags(int f)
+- {
+- termios tty;
+- tcgetattr(fd, &tty);
+- tty.c_iflag = IGNBRK | IGNPAR;
+- tty.c_oflag = 0;
+- tty.c_lflag = 0;
+- tty.c_cflag = f | CREAD | CLOCAL | HUPCL;
+-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
+- tty.c_line = 0;
+-#endif
+- tty.c_cc[VTIME] = 0;
+- tty.c_cc[VMIN] = 1;
+- tcsetattr(fd, TCSANOW, &tty);
+- }
+-
+-private:
+- void initSerial()
+- {
+- int speed[4] = { B9600, B4800, B2400, B1200 };
+-
+- for (int n = 0; n < 4; n++) {
+- setflags(CSTOPB | speed[n]);
+- write(fd, "*q", 2);
+- usleep(10000);
+- }
+- }
+-};
+-
+-class QAutoMouseSubHandler_mousesystems : public QAutoMouseSubHandler_serial {
+-public:
+- // ##### This driver has not been tested
+-
+- QAutoMouseSubHandler_mousesystems(int f) : QAutoMouseSubHandler_serial(f)
+- {
+- init();
+- }
+-
+- void init()
+- {
+- setflags(B1200|CS8|CSTOPB);
+- // 60Hz
+- if (write(fd, "R", 1)!=1) {
+- badness = 100;
+- return;
+- }
+- tcflush(fd,TCIOFLUSH);
+- }
+-
+- int tryData()
+- {
+- if ( nbuf >= 5 ) {
+- if ( (buffer[0] & 0xf8) != 0x80 ) {
+- badness++;
+- return 1;
+- }
+- motion +=
+- QPoint((signed char)buffer[1] + (signed char)buffer[3],
+- -(signed char)buffer[2] + (signed char)buffer[4]);
+- int t = ~buffer[0];
+- int nbstate = ((t&3) << 1) | ((t&4) >> 2);
+- if ( motion.x() || motion.y() || bstate != nbstate ) {
+- bstate = nbstate;
+- goodness++;
+- } else {
+- badness++;
+- return 1;
+- }
+- return 5;
+- }
+- return 0;
+- }
+-};
+-
+-class QAutoMouseSubHandler_ms : public QAutoMouseSubHandler_serial {
+- int mman;
+-public:
+- QAutoMouseSubHandler_ms(int f) : QAutoMouseSubHandler_serial(f)
+- {
+- mman=0;
+- init();
+- }
+-
+- void init()
+- {
+- setflags(B1200|CS7);
+- // 60Hz
+- if (write(fd, "R", 1)!=1) {
+- badness = 100;
+- return;
+- }
+- tcflush(fd,TCIOFLUSH);
+- }
+-
+- int tryData()
+- {
+- if ( !(buffer[0] & 0x40) ) {
+- if ( buffer[0] == 0x20 && (bstate & Qt::MidButton) ) {
+- mman=1; // mouseman extension
+- }
+- return 1;
+- }
+- int extra = mman&&(bstate & Qt::MidButton);
+- if ( nbuf >= 3+extra ) {
+- int nbstate = 0;
+- if ( buffer[0] == 0x40 && !bstate && !buffer[1] && !buffer[2] ) {
+- nbstate = Qt::MidButton;
+- } else {
+- nbstate = ((buffer[0] & 0x20) >> 5)
+- | ((buffer[0] & 0x10) >> 3);
+- if ( extra && buffer[3] == 0x20 )
+- nbstate = Qt::MidButton;
+- }
+-
+- if ( buffer[1] & 0x40 ) {
+- badness++;
+- return 1;
+- } else {
+- motion +=
+- QPoint((signed char)((buffer[0]&0x3)<<6)
+- |(signed char)(buffer[1]&0x3f),
+- (signed char)((buffer[0]&0xc)<<4)
+- |(signed char)(buffer[2]&0x3f));
+- if ( motion.x() || motion.y() || bstate != nbstate ) {
+- bstate = nbstate;
+- goodness++;
+- } else {
+- badness++;
+- return 1;
+- }
+- return 3+extra;
+- }
+- }
+- return 0;
+- }
+-};
+-
+-/*
+-QAutoMouseHandler::UsageResult QAutoMouseHandler::useDev(Dev& d)
+-{
+- if ( d.nbuf >= mouseData[d.protocol].bytesPerPacket ) {
+- uchar *mb = d.buf;
+- int bstate = 0;
+- int dx = 0;
+- int dy = 0;
+-
+- switch (mouseProtocol) {
+- case MouseMan:
+- case IntelliMouse:
+- {
+- bstate = mb[0] & 0x7; // assuming Qt::*Button order
+-
+- int overflow = (mb[0]>>6 )& 0x03;
+- if (mouseProtocol == MouseMan && overflow) {
+- //### wheel events signalled with overflow bit, ignore for now
+- }
+- else {
+- bool xs = mb[0] & 0x10;
+- bool ys = mb[0] & 0x20;
+- dx = xs ? mb[1]-256 : mb[1];
+- dy = ys ? mb[2]-256 : mb[2];
+- }
+- break;
+- }
+- case Microsoft:
+- if ( ((mb[0] & 0x20) >> 3) ) {
+- bstate |= Qt::LeftButton;
+- }
+- if ( ((mb[0] & 0x10) >> 4) ) {
+- bstate |= Qt::RightButton;
+- }
+-
+- dx=(signed char)(((mb[0] & 0x03) << 6) | (mb[1] & 0x3f));
+- dy=-(signed char)(((mb[0] & 0x0c) << 4) | (mb[2] & 0x3f));
+-
+- break;
+- }
+- }
+- }
+-*/
+-
+-#endif
+-
+-class QAutoMouseHandler : public QWSMouseHandler {
+- Q_OBJECT
+-
+-public:
+- QAutoMouseHandler();
+- ~QAutoMouseHandler();
+-
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+-private:
+- enum { max_dev=32 };
+- QAutoMouseSubHandler *sub[max_dev];
+- QList<QSocketNotifier> notifiers;
+- int nsub;
+- int retries;
+-#endif
+-
+-private slots:
+- void readMouseData(int);
+-
+-private:
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+- void openDevices();
+- void closeDevices();
+- void notify(int fd);
+- bool sendEvent(QAutoMouseSubHandler& h)
+- {
+- if ( h.reliable() ) {
+- mousePos += h.takeMotion();
+- limitToScreen( mousePos );
+-/*
+-qDebug("%d,%d %c%c%c",
+-mousePos.x(),mousePos.y(),
+-(h.buttonState()&Qt::LeftButton)?'L':'.',
+-(h.buttonState()&Qt::MidButton)?'M':'.',
+-(h.buttonState()&Qt::RightButton)?'R':'.');
+-*/
+- emit mouseChanged(mousePos,h.buttonState());
+- return TRUE;
+- } else {
+- h.takeMotion();
+- if ( h.buttonState() & (Qt::RightButton|Qt::MidButton) ) {
+- // Strange for the user to press right or middle without
+- // a moving mouse!
+- h.worse();
+- }
+- return FALSE;
+- }
+- }
+-#endif
+-};
+-
+-QAutoMouseHandler::QAutoMouseHandler()
+-{
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+- notifiers.setAutoDelete( TRUE );
+- retries = 0;
+- openDevices();
+-#endif
+-}
+-
+-QAutoMouseHandler::~QAutoMouseHandler()
+-{
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+- closeDevices();
+-#endif
+-}
+-
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+-void QAutoMouseHandler::openDevices()
+-{
+- nsub=0;
+- int fd;
+- fd = open( "/dev/psaux", O_RDWR | O_NDELAY );
+- if ( fd >= 0 ) {
+- sub[nsub++] = new QAutoMouseSubHandler_intellimouse(fd);
+- notify(fd);
+- }
+-#if !defined(QT_QWS_IPAQ) && !defined(QT_QWS_SL5XXX) && !defined(QT_QWS_K2) && !defined(QT_QWS_SLC700)
+- char fn[] = "/dev/ttyS?";
+- for (int ch='0'; ch<='3'; ch++) {
+- fn[9] = ch;
+- fd = open( fn, O_RDWR | O_NDELAY );
+- if ( fd >= 0 ) {
+- //sub[nsub++] = new QAutoMouseSubHandler_intellimouse(fd);
+- sub[nsub++] = new QAutoMouseSubHandler_mousesystems(fd);
+- sub[nsub++] = new QAutoMouseSubHandler_ms(fd);
+- notify(fd);
+- }
+- }
+-#endif
+- // ...
+-}
+-
+-void QAutoMouseHandler::closeDevices()
+-{
+- int pfd=-1;
+- for (int i=0; i<nsub; i++) {
+- sub[i]->closeIfNot(pfd);
+- delete sub[i];
+- }
+- notifiers.clear();
+-}
+-
+-void QAutoMouseHandler::notify(int fd)
+-{
+- QSocketNotifier *mouseNotifier
+- = new QSocketNotifier( fd, QSocketNotifier::Read, this );
+- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData(int)));
+- notifiers.append( mouseNotifier );
+-}
+-#endif
+-
+-void QAutoMouseHandler::readMouseData(int fd)
+-{
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+- for (;;) {
+- uchar buf[8];
+- int n = read(fd, buf, 8);
+- if ( n<=0 )
+- break;
+- for (int i=0; i<nsub; i++) {
+- QAutoMouseSubHandler& h = *sub[i];
+- if ( h.file() == fd ) {
+- h.appendData(buf,n);
+- for (;;) {
+- switch ( h.useData() ) {
+- case QAutoMouseSubHandler::Button:
+- sendEvent(h);
+- break;
+- case QAutoMouseSubHandler::Insufficient:
+- goto breakbreak;
+- case QAutoMouseSubHandler::Motion:
+- break;
+- }
+- }
+- breakbreak:
+- ;
+- }
+- }
+- }
+- bool any_reliable=FALSE;
+- for (int i=0; i<nsub; i++) {
+- QAutoMouseSubHandler& h = *sub[i];
+- if ( h.motionPending() )
+- sendEvent(h);
+- any_reliable = any_reliable || h.reliable();
+- }
+- if ( any_reliable ) {
+- // ... get rid of all unreliable ones? All bad ones?
+- } else if ( retries < 2 ) {
+- // Try again - maybe the mouse was being moved when we tried to init.
+- closeDevices();
+- openDevices();
+- retries++;
+- }
+-#else
+- Q_UNUSED( fd );
+-#endif
+-}
+-
+-
+-
+-
+-/*
+- * Standard mouse driver
+- */
+-
+-typedef struct {
+- int bytesPerPacket;
+-} MouseData;
+-
+-static const MouseData mouseData[] = {
+- { 3 }, // dummy for auto protocal, correction made by add by YYD
+- { 3 }, // MouseMan
+- { 4 }, // intelliMouse
+- { 3 }, // Microsoft
+- { 0 }, // QVFBMouse,
+- { 0 }, // TPanel,
+- { 3 }, // BusMouse,
+-};
+-
+-
+-class QWSMouseHandlerPrivate : public QWSMouseHandler {
+- Q_OBJECT
+-public:
+- QWSMouseHandlerPrivate( MouseProtocol protocol, QString mouseDev );
+- ~QWSMouseHandlerPrivate();
+-
+-#ifndef QT_NO_QWS_MOUSE_PC
+-private:
+- static const int mouseBufSize = 128;
+- int mouseFD;
+- int mouseIdx;
+- uchar mouseBuf[mouseBufSize];
+- MouseProtocol mouseProtocol;
+- void handleMouseData();
+-#endif
+-
+-private slots:
+- void readMouseData();
+-
+-private:
+- int obstate;
+-};
+-
+-
+-void QWSMouseHandlerPrivate::readMouseData()
+-{
+-#ifndef QT_NO_QWS_MOUSE_PC
+- int n;
+- if ( BusMouse == mouseProtocol ) {
+- // a workaround of linux busmouse driver interface.
+- // It'll only read 3 bytes a time and return all other buffer zeroed, thus cause protocol errors
+- for (;;) {
+- if ( mouseBufSize - mouseIdx < 3 )
+- break;
+- n = read( mouseFD, mouseBuf+mouseIdx, 3 );
+- if ( n != 3 )
+- break;
+- mouseIdx += 3;
+- }
+- } else {
+- do {
+- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx );
+- if ( n > 0 )
+- mouseIdx += n;
+- } while ( n > 0 );
+- }
+- handleMouseData();
+-#endif
+-}
+-
+-
+-#ifndef QT_NO_QWS_MOUSE_PC
+-/*
+-*/
+-
+-void QWSMouseHandlerPrivate::handleMouseData()
+-{
+- static const int accel_limit = 5;
+- static const int accel = 2;
+-
+- int idx = 0;
+- int bstate = 0;
+- int dx = 0, dy = 0;
+- bool sendEvent = false;
+- int tdx = 0, tdy = 0;
+-
+- while ( mouseIdx-idx >= mouseData[mouseProtocol].bytesPerPacket ) {
+- //qDebug( "Got mouse data" );
+- uchar *mb = mouseBuf+idx;
+- bstate = 0;
+- dx = 0;
+- dy = 0;
+- sendEvent = false;
+- switch (mouseProtocol) {
+- case MouseMan:
+- case IntelliMouse:
+- {
+- if (mb[0] & 0x01)
+- bstate |= Qt::LeftButton;
+- if (mb[0] & 0x02)
+- bstate |= Qt::RightButton;
+- if (mb[0] & 0x04)
+- bstate |= Qt::MidButton;
+-
+- int overflow = (mb[0]>>6 )& 0x03;
+- if (mouseProtocol == MouseMan && overflow) {
+- //### wheel events signalled with overflow bit, ignore for now
+- }
+- else {
+- bool xs = mb[0] & 0x10;
+- bool ys = mb[0] & 0x20;
+- dx = xs ? mb[1]-256 : mb[1];
+- dy = ys ? mb[2]-256 : mb[2];
+
+- sendEvent = true;
+- }
+-#if 0 //debug
+- if (mouseProtocol == MouseMan)
+- printf("(%2d) %02x %02x %02x ", idx, mb[0], mb[1], mb[2]);
+- else
+- printf("(%2d) %02x %02x %02x %02x ",idx,mb[0],mb[1],mb[2],mb[3]);
+- const char *b1 = (mb[0] & 0x01) ? "b1":" ";//left
+- const char *b2 = (mb[0] & 0x02) ? "b2":" ";//right
+- const char *b3 = (mb[0] & 0x04) ? "b3":" ";//mid
+
+- if ( overflow )
+- printf( "Overflow%d %s %s %s (%4d,%4d)\n", overflow,
+- b1, b2, b3, mousePos.x(), mousePos.y() );
+- else
+- printf( "%s %s %s (%+3d,%+3d) (%4d,%4d)\n",
+- b1, b2, b3, dx, dy, mousePos.x(), mousePos.y() );
+-#endif
+- break;
+- }
+- case Microsoft:
+- if ( (mb[0] & 0x20) )
+- bstate |= Qt::LeftButton;
+- if ( (mb[0] & 0x10) )
+- bstate |= Qt::RightButton;
+-
+- dx=(signed char)(((mb[0] & 0x03) << 6) | (mb[1] & 0x3f));
+- dy=-(signed char)(((mb[0] & 0x0c) << 4) | (mb[2] & 0x3f));
+- sendEvent=true;
+-
+- break;
+- case BusMouse:
+- if ( !(mb[0] & 0x04) )
+- bstate |= Qt::LeftButton;
+- if ( !(mb[0] & 0x01) )
+- bstate |= Qt::RightButton;
+-
+- dx=(signed char)mb[1];
+- dy=(signed char)mb[2];
+- sendEvent=true;
+- break;
+-
+- default:
+- qWarning( "Unknown mouse protocol in QWSMouseHandlerPrivate" );
+- break;
+- }
+- if (sendEvent) {
+- if ( QABS(dx) > accel_limit || QABS(dy) > accel_limit ) {
+- dx *= accel;
+- dy *= accel;
+- }
+- tdx += dx;
+- tdy += dy;
+- if ( bstate != obstate ) {
+- mousePos += QPoint(tdx,-tdy);
+- limitToScreen( mousePos );
+- emit mouseChanged(mousePos,bstate);
+- sendEvent = FALSE;
+- tdx = 0;
+- tdy = 0;
+- obstate = bstate;
+- }
+- }
+- idx += mouseData[mouseProtocol].bytesPerPacket;
+- }
+- if ( sendEvent ) {
+- mousePos += QPoint(tdx,-tdy);
+- limitToScreen( mousePos );
+- emit mouseChanged(mousePos,bstate);
+- }
+-
+- int surplus = mouseIdx - idx;
+- for ( int i = 0; i < surplus; i++ )
+- mouseBuf[i] = mouseBuf[idx+i];
+- mouseIdx = surplus;
+-}
+-#endif
+-
+-
+-QWSMouseHandlerPrivate::QWSMouseHandlerPrivate( MouseProtocol protocol,
+- QString mouseDev )
+-{
+-#ifndef QT_NO_QWS_MOUSE_PC
+- mouseProtocol = protocol;
+-
+- if ( mouseDev.isEmpty() )
+- mouseDev = "/dev/mouse";
+- obstate = -1;
+- mouseFD = -1;
+- mouseFD = open( mouseDev.local8Bit().data(), O_RDWR | O_NDELAY);
+- if ( mouseFD < 0 ) {
+- mouseFD = open( mouseDev.local8Bit().data(), O_RDONLY | O_NDELAY);
+- if ( mouseFD < 0 )
+- qDebug( "Cannot open %s (%s)", mouseDev.ascii(),
+- strerror(errno));
+- } else {
+- // Clear pending input
+- tcflush(mouseFD,TCIFLUSH);
+-
+- bool ps2 = false;
+-
+- switch (mouseProtocol) {
+- case MouseMan:
+- ps2 = true;
+- write(mouseFD,"",1);
+- usleep(50000);
+- write(mouseFD,"@EeI!",5);
+- break;
+-
+- case IntelliMouse: {
+-// ps2 = true;
+- const unsigned char init1[] = { 243, 200, 243, 100, 243, 80 };
+- const unsigned char init2[] = { 246, 230, 244, 243, 100, 232, 3 };
+- write(mouseFD,init1,sizeof(init1));
+- usleep(50000);
+- write(mouseFD,init2,sizeof(init2));
+- }
+- break;
+-
+- case Microsoft:
+- struct termios tty;
+-
+- tcgetattr(mouseFD, &tty);
+-
+- tty.c_iflag = IGNBRK | IGNPAR;
+- tty.c_oflag = 0;
+- tty.c_lflag = 0;
+-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
+- tty.c_line = 0;
+-#endif // _OS_FREEBSD_
+- tty.c_cc[VTIME] = 0;
+- tty.c_cc[VMIN] = 1;
+- tty.c_cflag = B1200 | CS7 | CREAD | CLOCAL | HUPCL;
+- tcsetattr(mouseFD, TCSAFLUSH, &tty); /* set parameters */
+- break;
+-
+- case BusMouse:
+- usleep(50000);
+- break;
+-
+- default:
+- qDebug("Unknown mouse protocol");
+- exit(1);
+- }
+-
+- if (ps2) {
+- char buf[] = { 246, 244 };
+- write(mouseFD,buf,1);
+- write(mouseFD,buf+1,1);
+- }
+-
+- usleep(50000);
+- tcflush(mouseFD,TCIFLUSH); // ### doesn't seem to work.
+- usleep(50000);
+- tcflush(mouseFD,TCIFLUSH); // ### doesn't seem to work.
+-
+- char buf[100]; // busmouse driver will not read if bufsize < 3, YYD
+- while (read(mouseFD, buf, 100) > 0) { } // eat unwanted replies
+-
+- mouseIdx = 0;
+-
+- QSocketNotifier *mouseNotifier;
+- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, this );
+- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+- }
+-#else
+- Q_UNUSED(protocol);
+- Q_UNUSED(mouseDev);
+-#endif
+-}
+-
+-QWSMouseHandlerPrivate::~QWSMouseHandlerPrivate()
+-{
+-#ifndef QT_NO_QWS_MOUSE_PC
+- if (mouseFD >= 0) {
+- tcflush(mouseFD,TCIFLUSH); // yyd.
+- close(mouseFD);
+- }
+-#endif
+-}
+-
+-/*
+- *
+- */
+
+ QCalibratedMouseHandler::QCalibratedMouseHandler()
+ : samples(5), currSample(0), numSamples(0)
+@@ -1030,7 +180,8 @@
+ if ( file.open( IO_WriteOnly ) ) {
+ QTextStream t( &file );
+ t << a << " " << b << " " << c << " ";
+- t << d << " " << e << " " << f << " " << s;
++ t << d << " " << e << " " << f << " " << s << endl;
++ file.close();
+ } else
+ #endif
+ {
+@@ -1046,6 +197,7 @@
+ if ( file.open( IO_ReadOnly ) ) {
+ QTextStream t( &file );
+ t >> a >> b >> c >> d >> e >> f >> s;
++ file.close();
+ } else
+ #endif
+ {
+@@ -1073,12 +225,24 @@
+ writeCalibration();
+ }
+
++void QCalibratedMouseHandler::setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss)
++{
++ a = aa;
++ b = bb;
++ c = cc;
++ d = dd;
++ e = ee;
++ f = ff;
++ s = ss;
++}
++
+ QPoint QCalibratedMouseHandler::transform( const QPoint &p )
+ {
+ QPoint tp;
+
+ tp.setX( (a * p.x() + b * p.y() + c) / s );
+ tp.setY( (d * p.x() + e * p.y() + f) / s );
++//qDebug("QCalibratedMouseHandler::transform(%d,%d) -> %d,%d)", p.x(), p.y(), tp.x(), tp.y() );
+
+ return tp;
+ }
+@@ -1143,814 +307,192 @@
+ return sent;
+ }
+
+-/*
+- * Handler for /dev/tpanel Linux kernel driver
+- */
+
+-class QVrTPanelHandlerPrivate : public QCalibratedMouseHandler {
+- Q_OBJECT
+-public:
+- QVrTPanelHandlerPrivate(MouseProtocol, QString dev);
+- ~QVrTPanelHandlerPrivate();
+
+-private:
+- int mouseFD;
+- MouseProtocol mouseProtocol;
+-private slots:
+- void sendRelease();
+- void readMouseData();
+-private:
+- static const int mouseBufSize = 1280;
+- QTimer *rtimer;
+- int mouseIdx;
+- uchar mouseBuf[mouseBufSize];
+-};
+
+-#ifndef QT_QWS_CASSIOPEIA
+-QVrTPanelHandlerPrivate::QVrTPanelHandlerPrivate( MouseProtocol, QString ) :
+- QCalibratedMouseHandler()
+-{
+-}
+-#else
+-QVrTPanelHandlerPrivate::QVrTPanelHandlerPrivate( MouseProtocol, QString dev ) :
+- QCalibratedMouseHandler()
+-{
+- if ( dev.isEmpty() )
+- dev = "/dev/tpanel";
+-
+- if ((mouseFD = open( dev, O_RDONLY)) < 0) {
+- qFatal( "Cannot open %s (%s)", dev.latin1(), strerror(errno));
+- } else {
+- sleep(1);
+- }
+-
+- struct scanparam s;
+- s.interval = 20000;
+- s.settletime = 480;
+- if ( ioctl(mouseFD, TPSETSCANPARM, &s) < 0
+- || fcntl(mouseFD, F_SETFL, O_NONBLOCK) < 0 )
+- qWarning("Error initializing touch panel.");
+-
+- QSocketNotifier *mouseNotifier;
+- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read,
+- this );
+- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+-
+- rtimer = new QTimer( this );
+- connect( rtimer, SIGNAL(timeout()), this, SLOT(sendRelease()));
+- mouseIdx = 0;
+- setFilterSize( 3 );
+-
+- printf("\033[?25l"); fflush(stdout); // VT100 cursor off
+-}
+-#endif
+-
+-QVrTPanelHandlerPrivate::~QVrTPanelHandlerPrivate()
+-{
+- if (mouseFD >= 0)
+- close(mouseFD);
+-}
+-
+-void QVrTPanelHandlerPrivate::sendRelease()
+-{
+- sendFiltered( mousePos, 0 );
+-}
+
+-void QVrTPanelHandlerPrivate::readMouseData()
+-{
+-#ifdef QT_QWS_CASSIOPEIA
+- if(!qt_screen)
+- return;
+- static bool pressed = FALSE;
+-
+- int n;
+- do {
+- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx );
+- if ( n > 0 )
+- mouseIdx += n;
+- } while ( n > 0 && mouseIdx < mouseBufSize );
+-
+- int idx = 0;
+- while ( mouseIdx-idx >= (int)sizeof( short ) * 6 ) {
+- uchar *mb = mouseBuf+idx;
+- ushort *data = (ushort *) mb;
+- if ( data[0] & 0x8000 ) {
+- if ( data[5] > 750 ) {
+- QPoint t(data[3]-data[4],data[2]-data[1]);
+- if ( sendFiltered( t, Qt::LeftButton ) )
+- pressed = TRUE;
+- if ( pressed )
+- rtimer->start( 200, TRUE ); // release unreliable
+- }
+- } else if ( pressed ) {
+- rtimer->start( 50, TRUE );
+- pressed = FALSE;
+- }
+- idx += sizeof( ushort ) * 6;
+- }
++struct input_event {
++ struct timeval time;
++ unsigned short type;
++ unsigned short code;
++ unsigned int value;
++};
+
+- int surplus = mouseIdx - idx;
+- for ( int i = 0; i < surplus; i++ )
+- mouseBuf[i] = mouseBuf[idx+i];
+- mouseIdx = surplus;
+
+-#endif
+-}
++#define EV_ABS 0x03
++#define ABS_X 0x00
++#define ABS_Y 0x01
++#define ABS_PRESSURE 0x18
+
+
+-class QTPanelHandlerPrivate : public QCalibratedMouseHandler
++class QInputEventHandler : public QCalibratedMouseHandler
+ {
+ Q_OBJECT
+ public:
+- QTPanelHandlerPrivate(MouseProtocol, QString dev);
+- ~QTPanelHandlerPrivate();
++ QInputEventHandler(MouseProtocol, QString dev);
++ ~QInputEventHandler();
++
++ virtual void calibrate( QWSPointerCalibrationData * );
++ virtual void setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss);
+
+ private:
+- static const int mouseBufSize = 2048;
++ void init();
++ void fini();
++
+ int mouseFD;
+- QPoint oldmouse;
+- QPoint oldTotalMousePos;
+- bool waspressed;
+- QPointArray samples;
+- unsigned int currSample;
+- unsigned int lastSample;
+- unsigned int numSamples;
+- int skipCount;
+- int mouseIdx;
+- uchar mouseBuf[mouseBufSize];
++ struct input_event sample;
++ int myX, myY, myP, oldX, oldY, oldP;
++ int xtable[QT_QWS_TP_TABLE_SIZE];
++ int ytable[QT_QWS_TP_TABLE_SIZE];
++ int ptr;
+
+ private slots:
+ void readMouseData();
+ };
+
+
+-QTPanelHandlerPrivate::QTPanelHandlerPrivate( MouseProtocol, QString dev )
+- : samples(QT_QWS_TP_SAMPLE_SIZE), currSample(0), lastSample(0),
+- numSamples(0), skipCount(0)
+-{
+- Q_UNUSED(dev);
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+-#if defined(QT_QWS_IPAQ)
+-# ifdef QT_QWS_IPAQ_RAW
+- if ((mouseFD = open( "/dev/h3600_tsraw", O_RDONLY | O_NDELAY)) < 0) {
+-# else
+- if ((mouseFD = open( "/dev/h3600_ts", O_RDONLY | O_NDELAY)) < 0) {
+-# endif
+- qWarning( "Cannot open /dev/h3600_ts (%s)", strerror(errno));
+- return;
+- }
+-#elif defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
+-//# ifdef QT_QWS_SL5XXX_TSRAW
+-# if 0
+- if ((mouseFD = open( "/dev/tsraw", O_RDONLY | O_NDELAY)) < 0) {
+- qWarning( "Cannot open /dev/tsraw (%s)", strerror(errno));
+- return;
+- }
+-# else
+- if ((mouseFD = open( "/dev/ts", O_RDONLY | O_NDELAY)) < 0) {
+- qWarning( "Cannot open /dev/ts (%s)", strerror(errno));
+- return;
+- }
+-# endif
+-#elif defined(QT_QWS_SIMPAD )
+- if ((mouseFD = open( "/dev/touchscreen/ucb1x00", O_RDONLY | O_NONBLOCK )) < 0) {
+- qWarning( "Cannot open /dev/touchscreen/ucb1x00 (%s)", strerror(errno));
+- return;
+- }
+-#endif
+-
+- QSocketNotifier *mouseNotifier;
+- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read,
+- this );
+- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+- waspressed=FALSE;
+- mouseIdx = 0;
+-#endif
+-}
+-
+-QTPanelHandlerPrivate::~QTPanelHandlerPrivate()
++QInputEventHandler::QInputEventHandler( MouseProtocol, QString )
++ : myP(-1)
+ {
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD)
+- if (mouseFD >= 0)
+- close(mouseFD);
+-#endif
++ init();
+ }
+
+-void QTPanelHandlerPrivate::readMouseData()
++QInputEventHandler::~QInputEventHandler()
+ {
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD)
+- if(!qt_screen)
+- return;
+-
+- int n;
+- do {
+- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx );
+- if ( n > 0 )
+- mouseIdx += n;
+- } while ( n > 0 && mouseIdx < mouseBufSize );
+-
+- TS_EVENT *data;
+- int idx = 0;
+-
+- // perhaps we shouldn't be reading EVERY SAMPLE.
+- while ( mouseIdx-idx >= (int)sizeof( TS_EVENT ) ) {
+- uchar *mb = mouseBuf+idx;
+- data = (TS_EVENT *) mb;
+- if(data->pressure >= QT_QWS_TP_PRESSURE_THRESHOLD) {
+-#if defined(QT_QWS_SL5XXX) || defined(QT_QWS_SLC700)
+- samples[currSample] = QPoint( 1000 - data->x, data->y );
+-#else
+- samples[currSample] = QPoint( data->x, data->y );
+-#endif
+-
+- numSamples++;
+- if ( numSamples >= QT_QWS_TP_MINIMUM_SAMPLES ) {
+- int sampleCount = QMIN(numSamples + 1,samples.count());
+-
+- // average the rest
+- mousePos = QPoint( 0, 0 );
+- QPoint totalMousePos = oldTotalMousePos;
+- totalMousePos += samples[currSample];
+- if(numSamples >= samples.count())
+- totalMousePos -= samples[lastSample];
+-
+- mousePos = totalMousePos / (sampleCount - 1);
+-
+-# if defined(QT_QWS_IPAQ_RAW) || defined(QT_QWS_SL5XXX_RAW)
+- mousePos = transform( mousePos );
+-# endif
+- if(!waspressed)
+- oldmouse = mousePos;
+- QPoint dp = mousePos - oldmouse;
+- int dxSqr = dp.x() * dp.x();
+- int dySqr = dp.y() * dp.y();
+- if ( dxSqr + dySqr < (QT_QWS_TP_MOVE_LIMIT * QT_QWS_TP_MOVE_LIMIT) ) {
+- if ( waspressed ) {
+- if ( (dxSqr + dySqr > (QT_QWS_TP_JITTER_LIMIT * QT_QWS_TP_JITTER_LIMIT) ) || skipCount > 2) {
+- emit mouseChanged(mousePos,Qt::LeftButton);
+- oldmouse = mousePos;
+- skipCount = 0;
+- } else {
+- skipCount++;
+- }
+- } else {
+- emit mouseChanged(mousePos,Qt::LeftButton);
+- oldmouse=mousePos;
+- waspressed=true;
+- }
+-
+- // save recuring information
+- currSample++;
+- if (numSamples >= samples.count())
+- lastSample++;
+- oldTotalMousePos = totalMousePos;
+- } else {
+- numSamples--; // don't use this sample, it was bad.
+- }
+- } else {
+- // build up the average
+- oldTotalMousePos += samples[currSample];
+- currSample++;
+- }
+- if ( currSample >= samples.count() )
+- currSample = 0;
+- if ( lastSample >= samples.count() )
+- lastSample = 0;
+- } else {
+- currSample = 0;
+- lastSample = 0;
+- numSamples = 0;
+- skipCount = 0;
+- oldTotalMousePos = QPoint(0,0);
+- if ( waspressed ) {
+- emit mouseChanged(oldmouse,0);
+- oldmouse = QPoint( -100, -100 );
+- waspressed=false;
+- }
+- }
+- idx += sizeof( TS_EVENT );
+- }
++ fini();
+
+- int surplus = mouseIdx - idx;
+- for ( int i = 0; i < surplus; i++ )
+- mouseBuf[i] = mouseBuf[idx+i];
+- mouseIdx = surplus;
+-#endif
+ }
+
+-// YOPY touch panel support based on changes contributed by Ron Victorelli
+-// (victorrj at icubed.com) to Custom TP driver.
+-//
+-class QYopyTPanelHandlerPrivate : public QWSMouseHandler {
+- Q_OBJECT
+-public:
+- QYopyTPanelHandlerPrivate(MouseProtocol, QString dev);
+- ~QYopyTPanelHandlerPrivate();
+-
+-private:
+- int mouseFD;
+- int prevstate;
+-private slots:
+- void readMouseData();
+-
+-};
+-
+-QYopyTPanelHandlerPrivate::QYopyTPanelHandlerPrivate( MouseProtocol, QString )
++void QInputEventHandler::setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss)
+ {
+-#ifdef QT_QWS_YOPY
+- if ((mouseFD = open( "/dev/ts", O_RDONLY)) < 0) {
+- qWarning( "Cannot open /dev/ts (%s)", strerror(errno));
+- return;
+- } else {
+- sleep(1);
+- }
+- prevstate=0;
+- QSocketNotifier *mouseNotifier;
+- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read,
+- this );
+- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+-#endif
+-}
++ QCalibratedMouseHandler::setCalibration(aa, bb, cc, dd, ee, ff, ss);
+
+-QYopyTPanelHandlerPrivate::~QYopyTPanelHandlerPrivate()
+-{
+- if (mouseFD >= 0)
+- close(mouseFD);
++ writeCalibration();
++ fini();
++ init();
+ }
+
+-#define YOPY_XPOS(d) (d[1]&0x3FF)
+-#define YOPY_YPOS(d) (d[2]&0x3FF)
+-#define YOPY_PRES(d) (d[0]&0xFF)
+-#define YOPY_STAT(d) (d[3]&0x01 )
+-
+-struct YopyTPdata {
+-
+- unsigned char status;
+- unsigned short xpos;
+- unsigned short ypos;
+-
+-};
+-
+-void QYopyTPanelHandlerPrivate::readMouseData()
++void QInputEventHandler::calibrate( QWSPointerCalibrationData *cd )
+ {
+-#ifdef QT_QWS_YOPY
+- if(!qt_screen)
+- return;
+- YopyTPdata data;
+-
+- unsigned int yopDat[4];
+-
+- int ret;
+-
+- ret=read(mouseFD,&yopDat,sizeof(yopDat));
++ QCalibratedMouseHandler::calibrate( cd );
+
+- if(ret) {
+- data.status= ( YOPY_PRES(yopDat) ) ? 1 : 0;
+- data.xpos=YOPY_XPOS(yopDat);
+- data.ypos=YOPY_YPOS(yopDat);
+- QPoint q;
+- q.setX(data.xpos);
+- q.setY(data.ypos);
+- mousePos=q;
+- if(data.status && !prevstate) {
+- emit mouseChanged(mousePos,Qt::LeftButton);
+- } else if( !data.status && prevstate ) {
+- emit mouseChanged(mousePos,0);
+- }
+- prevstate = data.status;
+- }
+- if(ret<0) {
+- qDebug("Error %s",strerror(errno));
+- }
+-#endif
++ // write calibration data, and close and reopen
++ // tslib, in order to ensure it uses the new values
++ writeCalibration();
++ fini();
++ init();
+ }
+
+-class QCustomTPanelHandlerPrivate : public QWSMouseHandler {
+- Q_OBJECT
+-public:
+- QCustomTPanelHandlerPrivate(MouseProtocol, QString dev);
+- ~QCustomTPanelHandlerPrivate();
+-
+-private:
+- int mouseFD;
+-private slots:
+- void readMouseData();
+-
+-};
+-
+-QCustomTPanelHandlerPrivate::QCustomTPanelHandlerPrivate( MouseProtocol, QString )
++void QInputEventHandler::init()
+ {
+-#ifdef QWS_CUSTOMTOUCHPANEL
+- if ((mouseFD = open( "/dev/ts", O_RDONLY)) < 0) {
+- qWarning( "Cannot open /dev/ts (%s)", strerror(errno));
++ if ((mouseFD = open( "/dev/input/event1", O_RDONLY)) < 0) {
++ qWarning( "Cannot open /dev/input/event1 (%s)", strerror(errno));
+ return;
+- } else {
+- sleep(1);
+ }
+
+ QSocketNotifier *mouseNotifier;
+- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read,
+- this );
++ mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, this );
++ setFilterSize(2);
+ connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+-#endif
+ }
+
+-QCustomTPanelHandlerPrivate::~QCustomTPanelHandlerPrivate()
++void QInputEventHandler::fini()
+ {
+ if (mouseFD >= 0)
+ close(mouseFD);
+ }
+
+-struct CustomTPdata {
+-
+- unsigned char status;
+- unsigned short xpos;
+- unsigned short ypos;
+-
+-};
+-
+-void QCustomTPanelHandlerPrivate::readMouseData()
++void QInputEventHandler::readMouseData()
+ {
+-#ifdef QWS_CUSTOMTOUCHPANEL
+- if(!qt_screen)
+- return;
+- CustomTPdata data;
+-
+- unsigned char data2[5];
+-
+- int ret;
+-
+- ret=read(mouseFD,data2,5);
++ if (!qt_screen)
++ return;
+
+- if(ret==5) {
+- data.status=data2[0];
+- data.xpos=(data2[1] << 8) | data2[2];
+- data.ypos=(data2[3] << 8) | data2[4];
+- QPoint q;
+- q.setX(data.xpos);
+- q.setY(data.ypos);
+- mousePos=q;
+- if(data.status & 0x40) {
+- emit mouseChanged(mousePos,Qt::LeftButton);
+- } else {
+- emit mouseChanged(mousePos,0);
++ unsigned int size = read(mouseFD, &sample, sizeof(sample));
++ if (size < sizeof(sample)) {
++ qDebug("no input");
++ return;
++ }
++ //qDebug("type,code,val: %d,%d,%d", sample.type, sample.code, sample.value);
++ if (sample.type == EV_ABS) {
++ if (sample.code == ABS_Y) {
++ myY = sample.value;
++ return;
++ } else
++ if (sample.code == ABS_X) {
++ myX = sample.value;
++ return;
++ } else
++ if (sample.code == ABS_PRESSURE) {
++ myP = sample.value;
++ }
+ }
+- }
+- if(ret<0) {
+- qDebug("Error %s",strerror(errno));
+- }
+-#endif
+-}
+-
+-/*
+- * Virtual framebuffer mouse driver
+- */
+-
+-#ifndef QT_NO_QWS_VFB
+-#include "qvfbhdr.h"
+-extern int qws_display_id;
+-#endif
+-
+-class QVFbMouseHandlerPrivate : public QWSMouseHandler {
+- Q_OBJECT
+-public:
+- QVFbMouseHandlerPrivate(MouseProtocol, QString dev);
+- ~QVFbMouseHandlerPrivate();
+-
+-#ifndef QT_NO_QWS_VFB
+- bool isOpen() const { return mouseFD > 0; }
+-
+-private:
+- static const int mouseBufSize = 128;
+- int mouseFD;
+- int mouseIdx;
+- uchar mouseBuf[mouseBufSize];
+-#endif
+-
+-private slots:
+- void readMouseData();
+-};
+-
+-QVFbMouseHandlerPrivate::QVFbMouseHandlerPrivate( MouseProtocol, QString mouseDev )
+-{
+-#ifndef QT_NO_QWS_VFB
+- mouseFD = -1;
+- if ( mouseDev.isEmpty() )
+- mouseDev = QString(QT_VFB_MOUSE_PIPE).arg(qws_display_id);
+-
+- if ((mouseFD = open( mouseDev.local8Bit().data(), O_RDWR | O_NDELAY)) < 0) {
+- qDebug( "Cannot open %s (%s)", mouseDev.ascii(),
+- strerror(errno));
+- } else {
+- // Clear pending input
+- char buf[2];
+- while (read(mouseFD, buf, 1) > 0) { }
+-
+- mouseIdx = 0;
+-
+- QSocketNotifier *mouseNotifier;
+- mouseNotifier = new QSocketNotifier( mouseFD, QSocketNotifier::Read, this );
+- connect(mouseNotifier, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+- }
+-#endif
+-}
+-
+-QVFbMouseHandlerPrivate::~QVFbMouseHandlerPrivate()
+-{
+-#ifndef QT_NO_QWS_VFB
+- if (mouseFD >= 0)
+- close(mouseFD);
+-#endif
+-}
+-
+-void QVFbMouseHandlerPrivate::readMouseData()
+-{
+-#ifndef QT_NO_QWS_VFB
+- int n;
+- do {
+- n = read(mouseFD, mouseBuf+mouseIdx, mouseBufSize-mouseIdx );
+- if ( n > 0 )
+- mouseIdx += n;
+- } while ( n > 0 );
+-
+- int idx = 0;
+- while ( mouseIdx-idx >= int(sizeof( QPoint ) + sizeof( int )) ) {
+- uchar *mb = mouseBuf+idx;
+- QPoint *p = (QPoint *) mb;
+- mb += sizeof( QPoint );
+- int *bstate = (int *)mb;
+- mousePos = *p;
+- limitToScreen( mousePos );
+- emit mouseChanged(mousePos, *bstate);
+- idx += sizeof( QPoint ) + sizeof( int );
+- }
+-
+- int surplus = mouseIdx - idx;
+- for ( int i = 0; i < surplus; i++ )
+- mouseBuf[i] = mouseBuf[idx+i];
+- mouseIdx = surplus;
+-#endif
+-}
+-
+-/*
+- mouse handler for tslib
+- see http://cvs.arm.linux.org.uk/
+- */
+-/*
+-
+- Copyright (C) 2003, 2004, 2005 Texas Instruments, Inc.
+- Copyright (C) 2004, 2005 Holger Hans Peter Freyther
+- All rights reserved.
+-
+- Redistribution and use in source and binary forms, with or without
+- modification, are permitted provided that the following conditions are met:
+-
+- Redistributions of source code must retain the above copyright notice,
+- this list of conditions and the following disclaimer.
+-
+- Redistributions in binary form must reproduce the above copyright
+- notice, this list of conditions and the following disclaimer in the
+- documentation and/or other materials provided with the distribution.
+-
+- Neither the name Texas Instruments, Inc nor the names of its
+- contributors may be used to endorse or promote products derived
+- from this software without specific prior written permission.
+-
+- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+- FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+- COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+- (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+- SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+- HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+- STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+- IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+- POSSIBILITY OF SUCH DAMAGE.
+-
+-*/
+-class QTSLibHandlerPrivate : public QCalibratedMouseHandler
+-{
+- Q_OBJECT
+-public:
+- QTSLibHandlerPrivate();
+- ~QTSLibHandlerPrivate();
+-
+- virtual void clearCalibration();
+- virtual void calibrate( QWSPointerCalibrationData * );
+- static int sortByX( const void*, const void* );
+- static int sortByY( const void*, const void* );
+-
+-private:
+- bool m_raw : 1;
+- QSocketNotifier *m_notify;
+-
+-#ifdef QT_QWS_TSLIB
+- struct tsdev *m_ts;
+-#endif
+- void openTs();
+- void closeTs();
+- void interpolateSample();
+-
+-private slots:
+- void readMouseData();
+-
+-};
+-
+-QTSLibHandlerPrivate::QTSLibHandlerPrivate()
+- : m_raw(false), m_notify(0 )
+-{
+- openTs();
+-}
+-
+-QTSLibHandlerPrivate::~QTSLibHandlerPrivate()
+-{
+- closeTs();
+-}
+-
+-void QTSLibHandlerPrivate::openTs()
+-{
+-#ifdef QT_QWS_TSLIB
+- char *tsdevice;
+- if((tsdevice = getenv("TSLIB_TSDEVICE")) != NULL) {
+- m_ts = ts_open( tsdevice, 1 ); //1 = nonblocking, 0 = blocking mode
+- } else {
+- m_ts = ts_open( "/dev/ts", 1 );
+- }
+-
+- if (!m_ts) {
+- qWarning( "Cannot open touchscreen (%s)", strerror( errno));
+- return;
+- }
+-
+- if (ts_config( m_ts)) {
+- qWarning( "Cannot configure touchscreen (%s)", strerror( errno));
+- return;
+- }
+- m_notify = new QSocketNotifier( ts_fd(m_ts), QSocketNotifier::Read, this );
+- connect( m_notify, SIGNAL(activated(int)),this, SLOT(readMouseData()));
+-#endif
+-}
+-
+-void QTSLibHandlerPrivate::closeTs()
+-{
+-#ifdef QT_QWS_TSLIB
+- if (m_ts)
+- ts_close(m_ts);
+- m_ts = 0;
+-#endif
+-
+- delete m_notify;
+- m_notify = 0;
+- m_raw = false;
+-}
+-
+-void QTSLibHandlerPrivate::clearCalibration()
+-{
+- m_raw = true;
+-}
+-
+-void QTSLibHandlerPrivate::calibrate( QWSPointerCalibrationData * cd)
+-{
+- QPoint dev_tl = cd->devPoints[ QWSPointerCalibrationData::TopLeft ];
+- QPoint dev_br = cd->devPoints[ QWSPointerCalibrationData::BottomRight ];
+- QPoint screen_tl = cd->screenPoints[ QWSPointerCalibrationData::TopLeft ];
+- QPoint screen_br = cd->screenPoints[ QWSPointerCalibrationData::BottomRight ];
+- int a, b, c, d, e, f, s;
+-
+- s = 1 << 16;
+
+- a = s * (screen_tl.x() - screen_br.x() ) / (dev_tl.x() - dev_br.x());
+- b = 0;
+- c = s * screen_tl.x() - a * dev_tl.x();
++ // up->up
++ if (oldP==0 && myP==0) {
++ //qDebug("uu %d,%d,%d", myX,myY,myP);
++ return;
++ }
+
+- d = 0;
+- e = s * (screen_tl.y() - screen_br.y() ) / (dev_tl.y() - dev_br.y());
+- f = s * screen_tl.y() - e * dev_tl.y();
++ // up->down
++ if (oldP==0 && myP>QT_QWS_TP_PRESSURE_DOWN_THRESHOLD) {
++ //qDebug("ud %d,%d,%d", myX,myY,myP);
+
+- QString calFile = "/etc/pointercal";
+-#ifndef QT_NO_TEXTSTREAM
+- QFile file( calFile );
+- if ( file.open( IO_WriteOnly ) ) {
+- QTextStream t( &file );
+- t << a << " " << b << " " << c << " ";
+- t << d << " " << e << " " << f << " " << s;
+- file.flush(); closeTs();
+- openTs();
+- } else
+-#endif
+- {
+- qDebug( "Could not save calibration: %s", calFile.latin1() );
+- }
+-}
++ xtable[0] = myX;
++ ytable[0] = myY;
++ ptr = 1;
++ oldX = myX;
++ oldY = myY;
++ oldP = myP;
++ return;
++ }
+
+-void QTSLibHandlerPrivate::readMouseData()
+-{
+-#ifdef QT_QWS_TSLIB
+- if(!qt_screen)
+- return;
++ // down->down
++ if (oldP>QT_QWS_TP_PRESSURE_DOWN_THRESHOLD && myP>QT_QWS_TP_PRESSURE_UP_THRESHOLD) {
++ //qDebug("dd %d,%d,%d (%d,%d)", myX,myY,myP, oldX,oldY);
+
+- /*
+- * After clear Calibration
+- * we're in raw mode and do some easy median
+- * search.
+- */
+- if ( m_raw )
+- return interpolateSample();
++ int dxSqr = myX-oldX; dxSqr *= dxSqr;
++ int dySqr = myY-oldY; dySqr *= dySqr;
++ oldX = myX;
++ oldY = myY;
++ if (dxSqr+dySqr > QT_QWS_TP_MOVE_MAX*QT_QWS_TP_MOVE_MAX) {
++ //qWarning("distance too wide %d", dxSqr+dySqr);
++ return;
++ }
+
+- static struct ts_sample sample;
+- static int ret;
++ if (ptr < QT_QWS_TP_TABLE_SIZE) {
++ xtable[ptr] = myX;
++ ytable[ptr++] = myY;
++ }
+
+- /*
+- * Ok. We need to see if we can read more than one event
+- * We do this not to lose an update.
+- */
+- while ( true ) {
+- if ((ret = ts_read(m_ts, &sample, 1)) != 1 )
+- return;
++ if (ptr == QT_QWS_TP_TABLE_SIZE) {
++ int i;
++ int mx = 0;
++ int my = 0;
++ for (i=0; i<QT_QWS_TP_TABLE_SIZE; i++) {
++ mx += xtable[i];
++ my += ytable[i];
++ if (i>0) {
++ xtable[i-1] = xtable[i];
++ ytable[i-1] = ytable[i];
++ }
++ }
++ ptr--;
++ mousePos = transform(QPoint(mx/QT_QWS_TP_TABLE_SIZE, my/QT_QWS_TP_TABLE_SIZE));
+
++ emit mouseChanged(mousePos, Qt::LeftButton);
++ }
++ return;
++ }
+
+- QPoint pos( sample.x, sample.y );
+- mouseChanged( pos, sample.pressure != 0 ? 1 : 0 );
+- }
+-#endif
++ // down->up
++ //qDebug("du %d,%d,%d", myX,myY,myP);
++ emit mouseChanged(mousePos, 0);
++ oldP = 0;
+ }
+
+-/*
+- * Lets take all down events and then sort them
+- * and take the event in the middle.
+- *
+- * inspired by testutils.c
+- */
+-void QTSLibHandlerPrivate::interpolateSample() {
+-#ifdef QT_QWS_TSLIB
+-#define TSLIB_MAX_SAMPLES 25
+- static struct ts_sample samples[TSLIB_MAX_SAMPLES];
+- int index = 0;
+- int read_samples = 0;
+- int ret;
+-
+- do {
+- /* do not access negative arrays */
+- if ( index < 0 )
+- index = 0;
+-
+- /* we're opened non-blocking */
+- if((ret= ts_read_raw(m_ts, &samples[index], 1 ) ) != 1 )
+- /* no event yet, so try again */
+- if (ret==-1 )
+- continue;
+-
+- read_samples++;
+- index = (index+1)%TSLIB_MAX_SAMPLES;
+- }while (samples[index == 0 ? (TSLIB_MAX_SAMPLES-1) : index-1].pressure != 0);
+-
+- /*
+- * If we've wrapped around each sample is used otherwise
+- * we will use the index
+- */
+- index = read_samples >= TSLIB_MAX_SAMPLES ?
+- (TSLIB_MAX_SAMPLES-1 ) : index;
+- int x, y;
+-
+- /*
+- * now let us use the median value
+- * even index does not have an item in the middle
+- * so let us take the average of n/2 and (n/2)-1 as the middle
+- */
+- int m = index/2;
+- ::qsort(samples, index, sizeof(ts_sample), QTSLibHandlerPrivate::sortByX);
+- x = (index % 2 ) ? samples[m].x :
+- ( samples[m-1].x + samples[m].x )/2;
+-
+- ::qsort(samples, index, sizeof(ts_sample), QTSLibHandlerPrivate::sortByY);
+- y = (index % 2 ) ? samples[m].y :
+- ( samples[m-1].y + samples[m].y )/2;
+
+- emit mouseChanged( QPoint(x, y), 1 );
+- emit mouseChanged( QPoint(0, 0), 0 );
+-#endif
+-}
+
+-int QTSLibHandlerPrivate::sortByX( const void* one, const void* two) {
+-#ifdef QT_QWS_TSLIB
+- return reinterpret_cast<const struct ts_sample*>(one)->x -
+- reinterpret_cast<const struct ts_sample*>(two)->x;
+-#else
+- return 0;
+-#endif
+-}
+
+-int QTSLibHandlerPrivate::sortByY( const void* one, const void* two) {
+-#ifdef QT_QWS_TSLIB
+- return reinterpret_cast<const struct ts_sample*>(one)->y -
+- reinterpret_cast<const struct ts_sample*>(two)->y;
+-#else
+- return 0;
+-#endif
+-}
+-//////
+
+ /*
+ * return a QWSMouseHandler that supports /a spec.
+@@ -1977,7 +519,7 @@
+
+ if ( mouseProto == "USB" && mouseDev.isEmpty() )
+ mouseDev = "/dev/input/mice";
+-
++
+ MouseProtocol mouseProtocol = Unknown;
+
+ int idx = 0;
+@@ -1988,50 +530,7 @@
+ idx++;
+ }
+
+-
+- QWSMouseHandler *handler = 0;
+-
+- switch ( mouseProtocol ) {
+-#ifndef QT_NO_QWS_MOUSE_AUTO
+- case Auto:
+- handler = new QAutoMouseHandler();
+- break;
+-#endif
+-
+-#ifndef QT_NO_QWS_MOUSE_PC
+- case MouseMan:
+- case IntelliMouse:
+- case Microsoft:
+- case BusMouse:
+- handler = new QWSMouseHandlerPrivate( mouseProtocol, mouseDev );
+- break;
+-#endif
+-
+-#ifndef QT_NO_QWS_VFB
+- case QVFBMouse:
+- handler = new QVFbMouseHandlerPrivate( mouseProtocol, mouseDev );
+- break;
+-#endif
+-
+- case TPanel:
+-#if defined(QWS_CUSTOMTOUCHPANEL)
+- handler = new QCustomTPanelHandlerPrivate(mouseProtocol,mouseDev);
+-#elif defined(QT_QWS_TSLIB)
+- handler = new QTSLibHandlerPrivate();
+-#elif defined(QT_QWS_YOPY)
+- handler = new QYopyTPanelHandlerPrivate(mouseProtocol,mouseDev);
+-#elif defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD)
+- handler = new QTPanelHandlerPrivate(mouseProtocol,mouseDev);
+-#elif defined(QT_QWS_CASSIOPEIA)
+- handler = new QVrTPanelHandlerPrivate( mouseProtocol, mouseDev );
+-#endif
+- break;
+-
+- default:
+- qDebug( "Mouse type %s unsupported", spec.latin1() );
+- }
+-
+- return handler;
++ return new QInputEventHandler( mouseProtocol, mouseDev );
+ }
+
+ #include "qwsmouse_qws.moc"
+--- qt-2.3.10/src/kernel/qwsmouse_qws.h~ramses-touchscreen
++++ qt-2.3.10/src/kernel/qwsmouse_qws.h
+@@ -1,5 +1,5 @@
+ /****************************************************************************
+-** $Id: qt/src/kernel/qwsmouse_qws.h 2.3.10 edited 2005-01-24 $
++** $Id: qt/src/kernel/qwsmouse_qws.h 2.3.7 edited 2001-10-03 $
+ **
+ ** Definition of Qt/FB central server classes
+ **
+@@ -70,6 +70,7 @@
+ virtual void clearCalibration();
+ virtual void calibrate( QWSPointerCalibrationData * );
+ virtual void getCalibration( QWSPointerCalibrationData * );
++ virtual void setCalibration(int aa, int bb, int cc, int dd, int ee, int ff, int ss);
+
+ protected:
+ void readCalibration();
diff --git a/packages/qte/qte-2.3.12/mnci.patch b/packages/qte/qte-2.3.12/mnci.patch
new file mode 100644
index 0000000000..c2e0e079d9
--- /dev/null
+++ b/packages/qte/qte-2.3.12/mnci.patch
@@ -0,0 +1,125 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp~ramses.patch
++++ qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp
+@@ -249,20 +249,12 @@
+
+ static void writeTerm(const char* termctl, int sizeof_termctl)
+ {
+-#ifdef QT_QWS_DEVFS
+- const char* tt[]={"/dev/vc/1","/dev/console","/dev/tty",0};
+-#else
+- const char* tt[]={"/dev/console","/dev/tty","/dev/tty0",0};
+-#endif
+- const char** dev=tt;
+- while (*dev) {
+- int tty=::open(*dev,O_WRONLY);
++qWarning("writeTerm");
++ int tty=::open("/dev/vc/2", O_WRONLY);
+ if ( tty>=0 ) {
+ ::write(tty,termctl,sizeof_termctl);
+ ::close(tty);
+ }
+- dev++;
+- }
+ }
+
+ /*!
+@@ -275,6 +267,7 @@
+
+ bool QLinuxFbScreen::initDevice()
+ {
++qWarning("QLinuxFbScreen::initDevice");
+ /* Setting up the VT parameters is done in qapplication_qws.cpp
+ const char termctl[]="\033[9;0]\033[?33l\033[?25l";
+ writeTerm(termctl,sizeof(termctl)); */
+@@ -765,9 +758,12 @@
+ }
+ */
+
++qWarning("QLinuxFbScreen::shutdownDevice");
++/*
+ // Blankin' screen, blinkin' cursor!
+ const char termctl[] = "\033[9;15]\033[?33h\033[?25h\033[?0c";
+ writeTerm(termctl,sizeof(termctl));
++*/
+ }
+
+ /*!
+--- qt-2.3.10/src/kernel/qapplication_qws.cpp~ramses.patch
++++ qt-2.3.10/src/kernel/qapplication_qws.cpp
+@@ -1756,8 +1756,6 @@
+ */
+ if ( qws_daemon )
+ {
+- qWarning( "qt_init() - starting in daemon mode..." );
+-
+ int pid1 = fork();
+ if ( pid1 == -1 )
+ {
+@@ -1791,7 +1789,6 @@
+ }
+ if ( pid2 )
+ {
+- syslog( 4, "qt_init() [%d] - successfully entered daemon mode", pid2 );
+ _exit( 0 ); // ok, second fork performed
+ }
+ }
+@@ -1828,9 +1825,12 @@
+ #if defined(_OS_LINUX_)
+ if ( qws_terminal_id )
+ {
+- qDebug( "qt_init() - terminal specification is '%d'.", qws_terminal_id );
+ struct vt_stat console_stat;
++#ifdef QT_QWS_DEVFS
++ int console_fd = ::open( QString().sprintf( "/dev/vc/%d", qws_terminal_id ).latin1(), O_RDWR );
++#else
+ int console_fd = ::open( QString().sprintf( "/dev/tty%d", qws_terminal_id ).latin1(), O_RDWR );
++#endif
+ if ( console_fd == -1)
+ {
+ qWarning( "qt_init() - can't open tty: %s", strerror( errno ) );
+@@ -1927,7 +1927,11 @@
+ {
+ qDebug( "qt_cleanup() - switching back to virtual terminal #%d", qws_terminal_old );
+
++#ifdef QT_QWS_DEVFS
++ int console_fd = ::open( "/dev/vc/0", O_RDWR );
++#else
+ int console_fd = ::open( "/dev/tty0", O_RDWR );
++#endif
+ if ( console_fd == -1)
+ {
+ qWarning( "qt_init() - can't open tty: %s", strerror( errno ) );
+--- qt-2.3.10/src/kernel/qwindowsystem_qws.cpp~ramses.patch
++++ qt-2.3.10/src/kernel/qwindowsystem_qws.cpp
+@@ -1791,6 +1791,7 @@
+ }
+
+ #ifndef QT_NO_QWS_KEYBOARD
++#ifndef QT_QWS_RAMSES
+ static int keyUnicode(int keycode)
+ {
+ const QWSServer::KeyMap *km = QWSServer::keyMap();
+@@ -1803,6 +1804,7 @@
+ return 0xffff;
+ }
+ #endif
++#endif
+ /*!
+ Send a key event. You can use this to send key events generated by
+ "virtual keyboards".
+@@ -1845,8 +1847,10 @@
+
+ event.simpleData.unicode =
+ #ifndef QT_NO_QWS_KEYBOARD
++#ifndef QT_QWS_RAMSES
+ unicode < 0 ? keyUnicode(keycode) :
+ #endif
++#endif
+ unicode;
+ event.simpleData.keycode = keycode;
+ event.simpleData.modifiers = modifiers;
diff --git a/packages/qte/qte-2.3.12/no-moc.patch b/packages/qte/qte-2.3.12/no-moc.patch
new file mode 100644
index 0000000000..0b2cdea6df
--- /dev/null
+++ b/packages/qte/qte-2.3.12/no-moc.patch
@@ -0,0 +1,39 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/Makefile
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/Makefile 2006-01-20 01:09:29.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/Makefile 2006-01-20 20:49:03.232410456 +0100
+@@ -8,7 +8,7 @@
+ init: FORCE
+ @$(MAKE) QTDIR=`pwd` all
+
+-all: symlinks src-moc src-mt sub-src sub-tools sub-tutorial sub-examples
++all: symlinks src-mt sub-src sub-tools sub-tutorial sub-examples
+ @echo
+ @echo "The Qt library is now built in ./lib"
+ @echo "The Qt examples are built in the directories in ./examples"
+@@ -31,10 +31,10 @@
+ symlinks: .buildopts
+ @cd include; rm -f q*.h; for i in ../src/*/q*.h ../src/3rdparty/*/q*.h ../extensions/*/src/q*.h; do ln -s $$i .; done; rm -f q*_p.h
+
+-sub-src: src-moc src-mt .buildopts FORCE
++sub-src: src-mt .buildopts FORCE
+ cd src; $(MAKE)
+
+-src-mt: src-moc .buildopts FORCE
++src-mt: .buildopts FORCE
+ $(MAKE) -f src-mt.mk
+
+ sub-tutorial: sub-src FORCE
+@@ -44,7 +44,6 @@
+ cd examples; $(MAKE)
+
+ clean:
+- cd src/moc; $(MAKE) clean
+ cd src; $(MAKE) clean
+ -rm src/tmp/*.o src/tmp/*.a src/allmoc.cpp
+ -find src/3rdparty -name '*.o' | xargs rm
diff --git a/packages/qte/qte-2.3.12/qiconview-speed.patch b/packages/qte/qte-2.3.12/qiconview-speed.patch
new file mode 100644
index 0000000000..bac9b9705f
--- /dev/null
+++ b/packages/qte/qte-2.3.12/qiconview-speed.patch
@@ -0,0 +1,122 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10-snapshot-20050131/src/iconview/qiconview.cpp~qiconview-speed
++++ qt-2.3.10-snapshot-20050131/src/iconview/qiconview.cpp
+@@ -225,6 +225,7 @@
+ QIconView::SelectionMode selectionMode;
+ QIconViewItem *currentItem, *tmpCurrentItem, *highlightedItem, *startDragItem, *pressedItem, *selectAnchor;
+ QRect *rubber;
++ QPixmap *backBuffer;
+ QTimer *scrollTimer, *adjustTimer, *updateTimer, *inputTimer,
+ *fullRedrawTimer;
+ int rastX, rastY, spacing;
+@@ -2268,6 +2269,7 @@
+ d->currentItem = 0;
+ d->highlightedItem = 0;
+ d->rubber = 0;
++ d->backBuffer = 0;
+ d->scrollTimer = 0;
+ d->startDragItem = 0;
+ d->tmpCurrentItem = 0;
+@@ -2416,6 +2418,8 @@
+ delete item;
+ item = tmp;
+ }
++ delete d->backBuffer;
++ d->backBuffer = 0;
+ delete d->fm;
+ d->fm = 0;
+ #ifndef QT_NO_TOOLTIP
+@@ -2882,6 +2886,48 @@
+ }
+
+ /*!
++ This function grabs all paintevents that otherwise would have been
++ processed by the QScrollView::viewportPaintEvent(). Here we use a
++ doublebuffer to reduce 'on-paint' flickering on QIconView
++ (and of course its childs).
++
++ \sa QScrollView::viewportPaintEvent(), QIconView::drawContents()
++*/
++
++void QIconView::bufferedPaintEvent( QPaintEvent* pe )
++{
++ QWidget* vp = viewport();
++ QRect r = pe->rect() & vp->rect();
++ int ex = r.x() + contentsX();
++ int ey = r.y() + contentsY();
++ int ew = r.width();
++ int eh = r.height();
++
++ if ( !d->backBuffer )
++ d->backBuffer = new QPixmap(vp->size());
++ if ( d->backBuffer->size() != vp->size() ) {
++ //Resize function (with hysteesis). Uses a good compromise between memory
++ //consumption and speed (number) of resizes.
++ float newWidth = (float)vp->width();
++ float newHeight = (float)vp->height();
++ if ( newWidth > d->backBuffer->width() || newHeight > d->backBuffer->height() )
++ {
++ newWidth *= 1.1892;
++ newHeight *= 1.1892;
++ d->backBuffer->resize( (int)newWidth, (int)newHeight );
++ } else if ( 1.5*newWidth < d->backBuffer->width() || 1.5*newHeight < d->backBuffer->height() )
++ d->backBuffer->resize( (int)newWidth, (int)newHeight );
++ }
++
++ QPainter p;
++ p.begin(d->backBuffer, vp);
++ drawContentsOffset(&p, contentsX(), contentsY(), ex, ey, ew, eh);
++ p.end();
++ bitBlt(vp, r.x(), r.y(), d->backBuffer, r.x(), r.y(), ew, eh);
++}
++
++/*!
++
+ \reimp
+ */
+
+@@ -4939,7 +4985,7 @@
+ if ( !d->rubber )
+ drawDragShapes( d->oldDragPos );
+ }
+- viewportPaintEvent( (QPaintEvent*)e );
++ bufferedPaintEvent ((QPaintEvent*)e );
+ if ( d->dragging ) {
+ if ( !d->rubber )
+ drawDragShapes( d->oldDragPos );
+@@ -5377,11 +5423,19 @@
+ return;
+
+ if ( item->d->container1 && d->firstContainer ) {
+- item->d->container1->items.removeRef( item );
++ //Special-case checking of the last item, since this may be
++ //called a few times for the same item.
++ if (item->d->container1->items.last() == item)
++ item->d->container1->items.removeLast();
++ else
++ item->d->container1->items.removeRef( item );
+ }
+ item->d->container1 = 0;
+ if ( item->d->container2 && d->firstContainer ) {
+- item->d->container2->items.removeRef( item );
++ if (item->d->container2->items.last() == item)
++ item->d->container2->items.removeLast();
++ else
++ item->d->container2->items.removeRef( item );
+ }
+ item->d->container2 = 0;
+
+--- qt-2.3.10-snapshot-20050131/src/iconview/qiconview.h~qiconview-speed
++++ qt-2.3.10-snapshot-20050131/src/iconview/qiconview.h
+@@ -444,6 +444,7 @@
+ virtual void contentsDropEvent( QDropEvent *e );
+ #endif
+
++ void bufferedPaintEvent( QPaintEvent* );
+ virtual void resizeEvent( QResizeEvent* e );
+ virtual void keyPressEvent( QKeyEvent *e );
+ virtual void focusInEvent( QFocusEvent *e );
diff --git a/packages/qte/qte-2.3.12/qpe.patch b/packages/qte/qte-2.3.12/qpe.patch
new file mode 100644
index 0000000000..af2e31664a
--- /dev/null
+++ b/packages/qte/qte-2.3.12/qpe.patch
@@ -0,0 +1,105 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- /dev/null
++++ qt-2.3.9-snapshot-20041211/src/tools/qconfig-qpe.h
+@@ -0,0 +1,97 @@
++/**********************************************************************
++** Copyright (C) 2000 Trolltech AS. All rights reserved.
++**
++** This file is part of Qtopia Environment.
++**
++** This file may be distributed and/or modified under the terms of the
++** GNU General Public License version 2 as published by the Free Software
++** Foundation and appearing in the file LICENSE.GPL included in the
++** packaging of this file.
++**
++** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
++** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
++**
++** See http://www.trolltech.com/gpl/ for GPL licensing information.
++**
++** Contact info@trolltech.com if any conditions of this licensing are
++** not clear to you.
++**
++**********************************************************************/
++#ifndef QT_H
++#endif // QT_H
++
++// Empty leaves all features enabled. See doc/html/features.html for choices.
++
++// Note that disabling some features will produce a libqt that is not
++// compatible with other libqt builds. Such modifications are only
++// supported on Qt/Embedded where reducing the library size is important
++// and where the application-suite is often a fixed set.
++
++#ifndef QT_DLL
++#define QT_DLL // Internal
++#endif
++
++#define QT_NO_QWS_CURSOR
++#define QT_NO_QWS_MOUSE_AUTO
++#ifndef QT_NO_CODECS
++#define QT_NO_CODECS
++#endif
++#define QT_NO_UNICODETABLES
++//#define QT_NO_IMAGEIO_BMP
++#define QT_NO_IMAGEIO_PPM
++//#define QT_NO_ASYNC_IO
++//#define QT_NO_ASYNC_IMAGE_IO
++#define QT_NO_FREETYPE
++#define QT_NO_BDF
++//#define QT_NO_FONTDATABASE
++#define QT_NO_DRAGANDDROP
++//#define QT_NO_CLIPBOARD
++#define QT_NO_PROPERTIES
++#define QT_NO_NETWORKPROTOCOL
++
++#define QT_NO_IMAGE_TEXT
++
++//#define QT_NO_TOOLTIP
++#define QT_NO_COLORNAMES
++#define QT_NO_TRANSFORMATIONS
++#define QT_NO_TRANSLATION_BUILDER
++#define QT_NO_COMPLEXTEXT
++#define QT_NO_PRINTER
++#define QT_NO_PICTURE
++//#define QT_NO_ICONVIEW
++#define QT_NO_DIAL
++#define QT_NO_SIZEGRIP
++#define QT_NO_WORKSPACE
++//#define QT_NO_TABLE
++//#define QT_NO_ACTION
++//#define QT_NO_SETTINGS
++#define QT_NO_STYLE_POCKETPC
++#ifndef QT_NO_STYLE_AQUA
++# define QT_NO_STYLE_AQUA
++#endif
++#define QT_NO_STYLE_MOTIF
++#define QT_NO_STYLE_PLATINUM
++#define QT_NO_FILEDIALOG
++#define QT_NO_FONTDIALOG
++#define QT_NO_PRINTDIALOG
++#define QT_NO_COLORDIALOG
++#define QT_NO_INPUTDIALOG
++//#define QT_NO_MESSAGEBOX
++#define QT_NO_PROGRESSDIALOG
++//#define QT_NO_TABDIALOG
++#define QT_NO_WIZARD
++#define QT_NO_EFFECTS
++//#define QT_NO_COMPONENT
++#define QT_NO_DOM
++#define QT_NO_SEMIMODAL
++//#define QT_NO_PROGRESSBAR
++#define QT_NO_SPLITTER
++
++//#define QT_NO_QWS_SAVEFONTS
++//#define QT_NO_QWS_PROPERTIES
++
++#define QT_NO_QWS_BEOS_WM_STYLE
++#define QT_NO_QWS_KDE2_WM_STYLE
++#define QT_NO_QWS_KDE_WM_STYLE
++#define QT_NO_QWS_WINDOWS_WM_STYLE
++
diff --git a/packages/qte/qte-2.3.12/qt-visibility.patch b/packages/qte/qte-2.3.12/qt-visibility.patch
new file mode 100644
index 0000000000..2b552b293f
--- /dev/null
+++ b/packages/qte/qte-2.3.12/qt-visibility.patch
@@ -0,0 +1,499 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/configure
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/configure 2005-09-21 05:48:39.000000000 +0200
++++ qt-2.3.10-snapshot-20060120/configure 2006-01-20 20:50:52.536793664 +0100
+@@ -450,6 +450,9 @@
+ -tslib)
+ TSLIB=yes
+ ;;
++ -visibility-hidden)
++ VISIBILITY=YES
++ ;;
+ -no-g++-exceptions)
+ GPLUSPLUS_EXCEPTIONS=no
+ ;;
+@@ -1356,6 +1359,9 @@
+ -tslib ............. Enable TSlib (touchscreen library) mouse handler.
+ See http://arm.linux.org.uk
+
++ -visibility-hidden . Use -fvisibility=hidden as default. This requires GCC 4.0
++ or a special patched GCC to support the visibility attribute
++
+ -no-g++-exceptions . Disable exceptions on platforms using the GNU C++
+ compiler by using the -fno-exceptions flag.
+
+@@ -1424,6 +1430,10 @@
+ QT_CXX="${QT_CXX} -DQT_QWS_TSLIB"
+ QT_LIBS="${QT_LIBS} -lts"
+ fi
++if [ "x$VISIBILITY=" = "xyes" ]
++then
++ QT_CXX="${QT_CXX} -DGCC_SUPPORTS_VISIBILITY -fvisibility=hidden"
++fi
+ if [ "x$THREAD" = "xyes" ]
+ then
+ cat >src-mt.mk <<EOF
+Index: qt-2.3.10-snapshot-20060120/src/tools/qglobal.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/tools/qglobal.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/tools/qglobal.h 2006-01-20 20:50:52.537793512 +0100
+@@ -503,6 +503,12 @@
+ #undef QT_DLL
+ #endif
+
++#ifdef GCC_SUPPORTS_VISIBILITY
++#ifndef Q_EXPORT
++ #define Q_EXPORT __attribute__((visibility("default")))
++#endif
++#endif
++
+ #ifndef Q_EXPORT
+ #define Q_EXPORT
+ #endif
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qscrollview.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qscrollview.cpp 2006-01-20 01:08:04.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qscrollview.cpp 2006-01-20 20:50:52.553791080 +0100
+@@ -703,7 +703,7 @@
+ The surrounding environment (or application, if there is no
+ environment, may set this. Requires Qt >= 2.3.8.
+ */
+-bool qt_left_hand_scrollbars = FALSE;
++bool Q_EXPORT qt_left_hand_scrollbars = FALSE;
+
+ /*!
+ Updates scrollbars - all possibilities considered. You should never
+Index: qt-2.3.10-snapshot-20060120/src/Makefile.in
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/Makefile.in 2006-01-20 01:09:33.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/Makefile.in 2006-01-20 20:50:52.558790320 +0100
+@@ -652,7 +652,7 @@
+ network/qsocket.h \
+ network/qsocketdevice.h
+ echo '#include "kernel/qt.h"' >allmoc.cpp
+- $(CXX) -E -DQT_MOC_CPP $(CXXFLAGS) $(INCPATH) >allmoc.h allmoc.cpp
++ $(CXX) -E -DQT_MOC_CPP -DQ_EXPORT="" $(CXXFLAGS) $(INCPATH) >allmoc.h allmoc.cpp
+ $(MOC) -o allmoc.cpp allmoc.h
+ perl -pi -e 's{"allmoc.h"}{"kernel/qt.h"}' allmoc.cpp
+ rm allmoc.h
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qcopchannel_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qcopchannel_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qcopchannel_qws.h 2006-01-20 20:50:52.559790168 +0100
+@@ -42,7 +42,7 @@
+ class QCopChannelPrivate;
+ class QWSClient;
+
+-class QCopChannel : public QObject
++class Q_EXPORT QCopChannel : public QObject
+ {
+ Q_OBJECT
+ public:
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qfontmanager_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qfontmanager_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qfontmanager_qws.cpp 2006-01-20 20:50:52.559790168 +0100
+@@ -68,7 +68,7 @@
+ return r;
+ }
+
+-QFontManager * qt_fontmanager=0;
++QFontManager Q_EXPORT *qt_fontmanager=0;
+
+ /*!
+ \class QFontManager qfontmanager_qws.h
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfx_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfx_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfx_qws.cpp 2006-01-20 20:50:52.560790016 +0100
+@@ -38,10 +38,10 @@
+ #include <stdlib.h>
+
+ #ifndef QT_NO_QWS_CURSOR
+-bool qt_sw_cursor=false;
+-QScreenCursor * qt_screencursor=0;
++bool Q_EXPORT qt_sw_cursor=false;
++QScreenCursor Q_EXPORT * qt_screencursor=0;
+ #endif
+-QScreen * qt_screen=0;
++QScreen Q_EXPORT * qt_screen=0;
+
+ extern bool qws_screen_is_interlaced; //### hack, from qapplication_qws.cpp
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwindowsystem_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp 2006-01-20 20:50:52.562789712 +0100
+@@ -89,7 +89,7 @@
+
+ extern void qt_setMaxWindowRect(const QRect& r);
+
+-QWSServer *qwsServer=0;
++QWSServer Q_EXPORT *qwsServer=0;
+
+ #define MOUSE 0
+ #define KEY 1
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsdecoration_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsdecoration_qws.h 2006-01-20 20:49:30.348288216 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsdecoration_qws.h 2006-01-20 20:50:52.562789712 +0100
+@@ -41,7 +41,7 @@
+ /*
+ Implements decoration styles
+ */
+-class QWSDecoration
++class Q_EXPORT QWSDecoration
+ {
+ public:
+ QWSDecoration() {}
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwindowsystem_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.h 2006-01-20 20:50:52.563789560 +0100
+@@ -69,7 +69,7 @@
+
+ struct QWSWindowData;
+
+-class QWSScreenSaver
++class Q_EXPORT QWSScreenSaver
+ {
+ public:
+ virtual ~QWSScreenSaver();
+@@ -77,7 +77,7 @@
+ virtual bool save(int level)=0;
+ };
+
+-class QWSWindow
++class Q_EXPORT QWSWindow
+ {
+ friend class QWSServer;
+ public:
+@@ -171,9 +171,9 @@
+ struct QWSCommandStruct;
+
+ #ifndef QT_NO_QWS_MULTIPROCESS
+-class QWSServer : public QWSServerSocket
++class Q_EXPORT QWSServer : public QWSServerSocket
+ #else
+-class QWSServer : public QObject
++class Q_EXPORT QWSServer : public QObject
+ #endif
+ {
+ friend class QCopChannel;
+@@ -503,7 +503,7 @@
+
+
+ #ifndef QT_NO_QWS_IM
+-class QWSInputMethod : public QObject
++class Q_EXPORT QWSInputMethod : public QObject
+ {
+ public:
+ QWSInputMethod();
+@@ -527,7 +527,7 @@
+ #endif
+
+ #ifndef QT_NO_QWS_FSIM
+-class QWSGestureMethod : public QObject
++class Q_EXPORT QWSGestureMethod : public QObject
+ {
+ public:
+ QWSGestureMethod();
+@@ -575,7 +575,7 @@
+
+ typedef QMap<int, QWSCursor*> QWSCursorMap;
+
+-class QWSClient : public QObject
++class Q_EXPORT QWSClient : public QObject
+ {
+ Q_OBJECT
+ public:
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsdefaultdecoration_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsdefaultdecoration_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsdefaultdecoration_qws.h 2006-01-20 20:50:52.563789560 +0100
+@@ -44,7 +44,7 @@
+
+
+
+-class QWSDefaultDecoration : public QWSDecoration
++class Q_EXPORT QWSDefaultDecoration : public QWSDecoration
+ {
+ public:
+ QWSDefaultDecoration();
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwscommand_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwscommand_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwscommand_qws.h 2006-01-20 20:50:52.564789408 +0100
+@@ -47,8 +47,8 @@
+ *
+ *********************************************************************/
+ #ifndef QT_NO_QWS_MULTIPROCESS
+-void qws_write_command( QWSSocket *socket, int type, char *simpleData, int simpleLen, char *rawData, int rawLen );
+-bool qws_read_command( QWSSocket *socket, char *&simpleData, int &simpleLen, char *&rawData, int &rawLen, int &bytesRead );
++void Q_EXPORT qws_write_command( QWSSocket *socket, int type, char *simpleData, int simpleLen, char *rawData, int rawLen );
++bool Q_EXPORT qws_read_command( QWSSocket *socket, char *&simpleData, int &simpleLen, char *&rawData, int &rawLen, int &bytesRead );
+ #endif
+ /*********************************************************************
+ *
+@@ -57,7 +57,7 @@
+ *********************************************************************/
+
+
+-struct QWSProtocolItem
++struct Q_EXPORT QWSProtocolItem
+ {
+ // ctor - dtor
+ QWSProtocolItem( int t, int len, char *ptr ) : type( t ),
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qfont_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qfont_qws.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qfont_qws.cpp 2006-01-20 20:50:52.565789256 +0100
+@@ -152,7 +152,7 @@
+ static QFontCache *fontCache = 0; // cache of loaded fonts
+ static QFontDict *fontDict = 0; // dict of all loaded fonts
+
+-void qws_clearLoadedFonts()
++void Q_EXPORT qws_clearLoadedFonts()
+ {
+ if (!fontDict)
+ return;
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwscursor_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwscursor_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwscursor_qws.h 2006-01-20 20:50:52.565789256 +0100
+@@ -37,7 +37,7 @@
+ #include <qimage.h>
+ #endif // QT_H
+
+-class QWSCursor : public Qt
++class Q_EXPORT QWSCursor : public Qt
+ {
+ public:
+ QWSCursor() {}
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsevent_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsevent_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsevent_qws.h 2006-01-20 20:50:52.566789104 +0100
+@@ -40,7 +40,7 @@
+
+ struct QWSMouseEvent;
+
+-struct QWSEvent : QWSProtocolItem {
++struct Q_EXPORT QWSEvent : QWSProtocolItem {
+
+ QWSEvent( int t, int len, char *ptr ) : QWSProtocolItem(t,len,ptr) {}
+
+@@ -71,7 +71,7 @@
+
+ //All events must start with windowID
+
+-struct QWSConnectedEvent : QWSEvent {
++struct Q_EXPORT QWSConnectedEvent : QWSEvent {
+ QWSConnectedEvent()
+ : QWSEvent( QWSEvent::Connected, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -90,7 +90,7 @@
+ char *display;
+ };
+
+-struct QWSMaxWindowRectEvent : QWSEvent {
++struct Q_EXPORT QWSMaxWindowRectEvent : QWSEvent {
+ QWSMaxWindowRectEvent()
+ : QWSEvent( MaxWindowRect, sizeof( simpleData ), (char*)&simpleData ) { }
+ struct SimpleData {
+@@ -99,7 +99,7 @@
+ } simpleData;
+ };
+
+-struct QWSMouseEvent : QWSEvent {
++struct Q_EXPORT QWSMouseEvent : QWSEvent {
+ QWSMouseEvent()
+ : QWSEvent( QWSEvent::Mouse, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -110,7 +110,7 @@
+ } simpleData;
+ };
+
+-struct QWSFocusEvent : QWSEvent {
++struct Q_EXPORT QWSFocusEvent : QWSEvent {
+ QWSFocusEvent()
+ : QWSEvent( QWSEvent::Focus, sizeof( simpleData ), (char*)&simpleData )
+ { memset((char*)&simpleData,0,sizeof(simpleData)); }
+@@ -120,7 +120,7 @@
+ } simpleData;
+ };
+
+-struct QWSKeyEvent: QWSEvent {
++struct Q_EXPORT QWSKeyEvent: QWSEvent {
+ QWSKeyEvent()
+ : QWSEvent( QWSEvent::Key, sizeof( simpleData ),
+ (char*)&simpleData )
+@@ -136,7 +136,7 @@
+ };
+
+
+-struct QWSCreationEvent : QWSEvent {
++struct Q_EXPORT QWSCreationEvent : QWSEvent {
+ QWSCreationEvent()
+ : QWSEvent( QWSEvent::Creation, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -146,7 +146,7 @@
+ };
+
+ #ifndef QT_NO_QWS_PROPERTIES
+-struct QWSPropertyNotifyEvent : QWSEvent {
++struct Q_EXPORT QWSPropertyNotifyEvent : QWSEvent {
+ QWSPropertyNotifyEvent()
+ : QWSEvent( QWSEvent::PropertyNotify, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -162,7 +162,7 @@
+ };
+ #endif
+
+-struct QWSSelectionClearEvent : QWSEvent {
++struct Q_EXPORT QWSSelectionClearEvent : QWSEvent {
+ QWSSelectionClearEvent()
+ : QWSEvent( QWSEvent::SelectionClear, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -171,7 +171,7 @@
+ } simpleData;
+ };
+
+-struct QWSSelectionRequestEvent : QWSEvent {
++struct Q_EXPORT QWSSelectionRequestEvent : QWSEvent {
+ QWSSelectionRequestEvent()
+ : QWSEvent( QWSEvent::SelectionRequest, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -184,7 +184,7 @@
+ } simpleData;
+ };
+
+-struct QWSSelectionNotifyEvent : QWSEvent {
++struct Q_EXPORT QWSSelectionNotifyEvent : QWSEvent {
+ QWSSelectionNotifyEvent()
+ : QWSEvent( QWSEvent::SelectionNotify, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -198,7 +198,7 @@
+
+ //complex events:
+
+-struct QWSRegionModifiedEvent : QWSEvent {
++struct Q_EXPORT QWSRegionModifiedEvent : QWSEvent {
+ QWSRegionModifiedEvent()
+ : QWSEvent( QWSEvent::RegionModified, sizeof( simpleData ),
+ (char*)&simpleData )
+@@ -218,7 +218,7 @@
+ QRect *rectangles;
+ };
+ #ifndef QT_NO_QWS_PROPERTIES
+-struct QWSPropertyReplyEvent : QWSEvent {
++struct Q_EXPORT QWSPropertyReplyEvent : QWSEvent {
+ QWSPropertyReplyEvent()
+ : QWSEvent( QWSEvent::PropertyReply, sizeof( simpleData ),
+ (char*)&simpleData ) {}
+@@ -238,7 +238,7 @@
+ #endif //QT_NO_QWS_PROPERTIES
+
+ #ifndef QT_NO_COP
+-struct QWSQCopMessageEvent : QWSEvent {
++struct Q_EXPORT QWSQCopMessageEvent : QWSEvent {
+ QWSQCopMessageEvent()
+ : QWSEvent( QWSEvent::QCopMessage, sizeof( simpleData ),
+ (char*)&simpleData )
+@@ -268,7 +268,7 @@
+
+ #endif
+
+-struct QWSWindowOperationEvent : QWSEvent {
++struct Q_EXPORT QWSWindowOperationEvent : QWSEvent {
+ QWSWindowOperationEvent()
+ : QWSEvent( WindowOperation, sizeof( simpleData ), (char*)&simpleData ) { }
+
+@@ -280,7 +280,7 @@
+ };
+
+ #ifndef QT_NO_QWS_IM
+-struct QWSIMEvent : QWSEvent {
++struct Q_EXPORT QWSIMEvent : QWSEvent {
+ QWSIMEvent()
+ : QWSEvent( IMEvent, sizeof( simpleData ), (char*)&simpleData ) { }
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsmanager_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsmanager_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsmanager_qws.h 2006-01-20 20:50:52.566789104 +0100
+@@ -48,7 +48,7 @@
+ class QWSButton;
+ class QWSManager;
+
+-class QWSManager : public QObject
++class Q_EXPORT QWSManager : public QObject
+ {
+ Q_OBJECT
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsmouse_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.h 2006-01-20 20:50:52.566789104 +0100
+@@ -38,7 +38,7 @@
+ #include <qpointarray.h>
+ #endif // QT_H
+
+-class QWSPointerCalibrationData
++class Q_EXPORT QWSPointerCalibrationData
+ {
+ public:
+ enum Location { TopLeft = 0, BottomLeft = 1, BottomRight = 2, TopRight = 3,
+@@ -47,7 +47,7 @@
+ QPoint screenPoints[5];
+ };
+
+-class QWSMouseHandler : public QObject {
++class Q_EXPORT QWSMouseHandler : public QObject {
+ Q_OBJECT
+ public:
+ QWSMouseHandler();
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsproperty_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsproperty_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsproperty_qws.h 2006-01-20 20:50:52.598784240 +0100
+@@ -47,7 +47,7 @@
+
+ class QWSPropertyManagerData;
+
+-class QWSPropertyManager
++class Q_EXPORT QWSPropertyManager
+ {
+ public:
+ enum Mode {
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qlayoutengine.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qlayoutengine.cpp 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qlayoutengine.cpp 2006-01-20 20:50:52.598784240 +0100
+@@ -70,7 +70,7 @@
+ pos and space give the interval (relative to parentWidget topLeft.)
+ */
+
+-void qGeomCalc( QArray<QLayoutStruct> &chain, int start, int count, int pos,
++void Q_EXPORT qGeomCalc( QArray<QLayoutStruct> &chain, int start, int count, int pos,
+ int space, int spacer )
+ {
+ typedef int fixed;
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qfontmanager_qws.h
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qfontmanager_qws.h 2006-01-20 01:08:03.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qfontmanager_qws.h 2006-01-20 20:50:52.610782416 +0100
+@@ -84,7 +84,7 @@
+ // e.g. Truetype Times, 10 point. There's only one of these though;
+ // we want to share generated glyphs
+
+-class QRenderedFont {
++class Q_EXPORT QRenderedFont {
+
+ public:
+
diff --git a/packages/qte/qte-2.3.12/qtabbar.patch b/packages/qte/qte-2.3.12/qtabbar.patch
new file mode 100644
index 0000000000..f1697421f5
--- /dev/null
+++ b/packages/qte/qte-2.3.12/qtabbar.patch
@@ -0,0 +1,41 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qtabbar.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qtabbar.cpp 2006-01-20 01:08:04.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qtabbar.cpp 2006-01-20 21:03:47.293012816 +0100
+@@ -260,7 +260,6 @@
+ lstatic->insert( index, newTab );
+
+ layoutTabs();
+- updateArrowButtons();
+ makeVisible( tab( currentTab() ) );
+
+ #ifndef QT_NO_ACCEL
+@@ -282,7 +281,6 @@
+ l->remove( t );
+ lstatic->remove( t );
+ layoutTabs();
+- updateArrowButtons();
+ makeVisible( tab( currentTab() ) );
+ update();
+ }
+@@ -887,6 +885,7 @@
+ }
+ for ( t = lstatic->first(); t; t = lstatic->next() )
+ t->r.setHeight( r.height() );
++ updateArrowButtons();
+ }
+
+ /*!
+@@ -978,7 +977,6 @@
+ d->leftB->setGeometry( width() - 2*arrowWidth, 0, arrowWidth, height() );
+ #endif
+ layoutTabs();
+- updateArrowButtons();
+ makeVisible( tab( currentTab() ));
+ }
+
diff --git a/packages/qte/qte-2.3.12/qte-fix-iconsize.patch b/packages/qte/qte-2.3.12/qte-fix-iconsize.patch
new file mode 100644
index 0000000000..2b44ea69c0
--- /dev/null
+++ b/packages/qte/qte-2.3.12/qte-fix-iconsize.patch
@@ -0,0 +1,105 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qpopupmenu.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qpopupmenu.cpp 2006-01-20 01:08:04.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qpopupmenu.cpp 2006-01-20 21:06:03.060373040 +0100
+@@ -820,7 +820,7 @@
+ mi->custom()->setFont( font() );
+ if ( mi->iconSet() != 0)
+ maxPMWidth = QMAX( maxPMWidth,
+- mi->iconSet()->pixmap( QIconSet::Small, QIconSet::Normal ).width() + 4 );
++ mi->iconSet()->pixmap().width() + 4 );
+ }
+
+ int dh = QApplication::desktop()->height();
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qtabbar.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qtabbar.cpp 2006-01-20 21:03:47.293012816 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qtabbar.cpp 2006-01-20 21:06:03.061372888 +0100
+@@ -412,8 +412,8 @@
+ int iw = 0;
+ int ih = 0;
+ if ( t->iconset != 0 ) {
+- iw = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).width();
+- ih = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).height();
++ iw = t->iconset->pixmap().width();
++ ih = t->iconset->pixmap().height();
+ if (!t->label.isEmpty())
+ iw +=2;
+ }
+@@ -440,7 +440,11 @@
+ ? QIconSet::Normal : QIconSet::Disabled;
+ if ( mode == QIconSet::Normal && has_focus )
+ mode = QIconSet::Active;
+- QPixmap pixmap = t->iconset->pixmap( QIconSet::Small, mode );
++ QPixmap pixmap;
++ if ( mode == QIconSet::Disabled )
++ pixmap = t->iconset->pixmap( QIconSet::Automatic, QIconSet::Disabled );
++ else
++ pixmap = t->iconset->pixmap();
+ int pixw = pixmap.width();
+ int pixh = pixmap.height();
+ r.setLeft( r.left() + pixw + 2 );
+@@ -869,8 +873,8 @@
+ int iw = 0;
+ int ih = 0;
+ if ( t->iconset != 0 ) {
+- iw = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).width();
+- ih = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).height();
++ iw = t->iconset->pixmap().width();
++ ih = t->iconset->pixmap().height();
+ if (!t->label.isNull())
+ iw +=2;
+ }
+@@ -914,8 +918,8 @@
+ int iw = 0;
+ int ih = 0;
+ if ( t->iconset != 0 ) {
+- iw = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).width();
+- ih = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).height();
++ iw = t->iconset->pixmap().width();
++ ih = t->iconset->pixmap().height();
+ if (!t->label.isEmpty())
+ iw +=2;
+ }
+@@ -947,8 +951,8 @@
+ int iw = 0;
+ int ih = 0;
+ if ( t->iconset != 0 ) {
+- iw = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).width();
+- ih = t->iconset->pixmap( QIconSet::Small, QIconSet::Normal ).height();
++ iw = t->iconset->pixmap().width();
++ ih = t->iconset->pixmap().height();
+ if (!t->label.isEmpty())
+ iw +=2;
+ }
+Index: qt-2.3.10-snapshot-20060120/src/widgets/qwindowsstyle.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/widgets/qwindowsstyle.cpp 2006-01-20 01:08:04.000000000 +0100
++++ qt-2.3.10-snapshot-20060120/src/widgets/qwindowsstyle.cpp 2006-01-20 21:06:03.062372736 +0100
+@@ -1182,7 +1182,7 @@
+ h = fm.height() + 2*motifItemVMargin + 2*motifItemFrame;
+
+ if ( !mi->isSeparator() && mi->iconSet() != 0 ) {
+- h = QMAX( h, mi->iconSet()->pixmap( QIconSet::Small, QIconSet::Normal ).height() + 2*motifItemFrame );
++ h = QMAX( h, mi->iconSet()->pixmap().height() + 2*motifItemFrame );
+ }
+ if ( mi->custom() )
+ h = QMAX( h, mi->custom()->sizeHint().height() + 2*motifItemVMargin + 2*motifItemFrame );
+@@ -1246,7 +1246,11 @@
+ QIconSet::Mode mode = dis ? QIconSet::Disabled : QIconSet::Normal;
+ if (act && !dis )
+ mode = QIconSet::Active;
+- QPixmap pixmap = mi->iconSet()->pixmap( QIconSet::Small, mode );
++ QPixmap pixmap;
++ if ( mode == QIconSet::Disabled )
++ pixmap = mi->iconSet()->pixmap( QIconSet::Automatic, QIconSet::Disabled );
++ else
++ pixmap = mi->iconSet()->pixmap();
+ int pixw = pixmap.width();
+ int pixh = pixmap.height();
+ if ( act && !dis ) {
diff --git a/packages/qte/qte-2.3.12/sharp_char.h b/packages/qte/qte-2.3.12/sharp_char.h
new file mode 100644
index 0000000000..a70f5f690e
--- /dev/null
+++ b/packages/qte/qte-2.3.12/sharp_char.h
@@ -0,0 +1,309 @@
+/*
+ * linux/include/asm/sharp_char.h
+ *
+ * sharp drivers definitions (SHARP)
+ *
+ * Copyright (C) 2001 SHARP
+ *
+ * This program 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 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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.
+ *
+ * Change Log
+ * 12-Dec-2002 Sharp Corporation for Poodle and Corgi
+ */
+
+#ifndef __ASM_SHARP_CHAR_H_INCLUDED
+#define __ASM_SHARP_CHAR_H_INCLUDED
+
+/*
+ * If SHARPCHAR_USE_MISCDEV defined , misc driver architecture used instead of sharp_char
+ */
+
+#define SHARPCHAR_USE_MISCDEV
+
+/*
+ * devices defines...
+ */
+
+#ifndef SHARP_DEV_MAJOR
+#define SHARP_DEV_MAJOR 11
+#endif
+
+#ifndef SHARP_DEV_MINOR_START
+#define SHARP_DEV_MINOR_START 210
+#endif
+
+#define SHARP_DEV_MINOR_MAX 4 /* defines last minor number of SHARP device */
+
+#define SHARP_LED_MINOR (SHARP_DEV_MINOR_START+0)
+#define SHARP_BUZZER_MINOR (SHARP_DEV_MINOR_START+1)
+#define SHARP_GSM_MINOR (SHARP_DEV_MINOR_START+2)
+#define SHARP_AUDIOCTL_MINOR (SHARP_DEV_MINOR_START+3)
+#define SHARP_KBDCTL_MINOR (SHARP_DEV_MINOR_START+4)
+
+/*
+ * ioctl defines...
+ */
+
+#define SHARP_DEV_IOCTL_COMMAND_START 0x5680
+
+/* --- for SHARP_LED device --- */
+#define SHARP_LED_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_LED_GETSTATUS (SHARP_LED_IOCTL_START)
+#define SHARP_LED_SETSTATUS (SHARP_LED_IOCTL_START+1)
+#define SHARP_LED_ISUPPORTED (SHARP_LED_IOCTL_START+2)
+
+typedef struct sharp_led_status {
+ int which; /* select which LED status is wanted. */
+ int status; /* set new led status if you call SHARP_LED_SETSTATUS */
+} sharp_led_status;
+
+#define SHARP_LED_WHICH_MAX 15 /* last number of LED */
+
+/* parameters for 'which' member */
+#define SHARP_LED_PDA 0 /* PDA status */
+#define SHARP_LED_DALARM 1 /* daily alarm */
+#define SHARP_LED_SALARM 2 /* schedule alarm */
+#define SHARP_LED_BATTERY 3 /* main battery status */
+#define SHARP_LED_ACSTATUS 4 /* AC line status */
+#define SHARP_LED_CHARGER 5 /* charger status */
+#define SHARP_LED_PHONE_RSSI 6 /* phone status (RSSI...) */
+#define SHARP_LED_PHONE_DIAL 7 /* phone status (dialing...) */
+#define SHARP_LED_PHONE_IN 8 /* phone status (incoming..) */
+#define SHARP_LED_MAIL_EXISTS 9 /* mail status (exists or not) */
+#define SHARP_LED_MAIL_SEND 10 /* mail status (sending...) */
+#define SHARP_LED_MAIL_QUEUE 11 /* mail to send is in queue */
+#define SHARP_LED_COLLIE_0 12 /* 1st pri. battery LED control */
+#define SHARP_LED_COLLIE_1 13 /* 1st pri. mail LED control */
+#define SHARP_LED_COMM 14 /* communication status */
+#define SHARP_LED_BROWSER 15 /* WWW browser status */
+
+/* parameters for 'status' member */
+#define LED_PDA_RUNNING 0 /* for SHARP_LED_RUN */
+#define LED_PDA_SUSPENDED 1 /* for SHARP_LED_RUN */
+#define LED_PDA_OFF 2 /* for SHARP_LED_RUN */
+#define LED_PDA_ERROR 3 /* for SHARP_LED_RUN */
+
+#define LED_DALARM_OFF 0 /* for SHARP_LED_DALARM */
+#define LED_DALARM_ON 1 /* for SHARP_LED_DALARM */
+
+#define LED_SALARM_OFF 0 /* for SHARP_LED_SALARM */
+#define LED_SALARM_ON 1 /* for SHARP_LED_SALARM */
+
+#define LED_BATTERY_GOOD 0 /* for SHARP_LED_BATTERY */
+#define LED_BATTERY_LOW 1 /* for SHARP_LED_BATTERY */
+#define LED_BATTERY_VERY_LOW 2 /* for SHARP_LED_BATTERY */
+#define LED_BATTERY_CRITICAL 3 /* for SHARP_LED_BATTERY */
+
+#define LED_CHARGER_OFF 0 /* for SHARP_LED_CHARGER */
+#define LED_CHARGER_CHARGING 1 /* for SHARP_LED_CHARGER */
+#define LED_CHARGER_ERROR 2 /* for SHARP_LED_CHARGER */
+#define LED_CHARGER_FLASH 3
+
+#define LED_AC_NOT_CONNECTED 0 /* for SHARP_LED_ACSTATUS */
+#define LED_AC_CONNECTED 1 /* for SHARP_LED_ACSTATUS */
+
+#define LED_RSSI_OUT 0 /* for SHARP_LED_PHONE_RSSI */
+#define LED_RSSI_IN 1 /* for SHARP_LED_PHONE_RSSI */
+
+#define LED_DIAL_OFF 0 /* for SHARP_LED_PHONE_DIAL */
+#define LED_DIAL_DIALING 1 /* for SHARP_LED_PHONE_DIAL */
+#define LED_DIAL_HOLDING 2 /* for SHARP_LED_PHONE_DIAL */
+
+#define LED_PHONE_WAITING 0 /* for SHARP_LED_PHONE_IN */
+#define LED_PHONE_INCOMING 1 /* for SHARP_LED_PHONE_IN */
+
+#define LED_MAIL_NO_UNREAD_MAIL 0 /* for SHARP_LED_MAIL_EXISTS */
+#define LED_MAIL_NEWMAIL_EXISTS 1 /* for SHARP_LED_MAIL_EXISTS */
+#define LED_MAIL_UNREAD_MAIL_EX 2 /* for SHARP_LED_MAIL_EXISTS */
+
+#define LED_SENDMAIL_OFF 0 /* for SHARP_LED_MAIL_SEND */
+#define LED_SENDMAIL_SENDING 1 /* for SHARP_LED_MAIL_SEND */
+#define LED_SENDMAIL_ERROR 2 /* for SHARP_LED_MAIL_SEND */
+
+#define LED_MAILQUEUE_NOUNREAD 0 /* for SHARP_LED_MAIL_QUEUE */
+#define LED_MAILQUEUE_NEWMAIL 1 /* for SHARP_LED_MAIL_QUEUE */
+#define LED_MAILQUEUE_UNREAD 2 /* for SHARP_LED_MAIL_QUEUE */
+
+#define LED_COLLIE_0_DEFAULT 0 /* for SHARP_LED_COLLIE_0 */
+#define LED_COLLIE_0_OFF 1 /* for SHARP_LED_COLLIE_0 */
+#define LED_COLLIE_0_ON 2 /* for SHARP_LED_COLLIE_0 */
+#define LED_COLLIE_0_FASTBLINK 3 /* for SHARP_LED_COLLIE_0 */
+#define LED_COLLIE_0_SLOWBLINK 4 /* for SHARP_LED_COLLIE_0 */
+
+#define LED_COLLIE_1_DEFAULT 0 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_OFF 1 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_ON 2 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_FLASHON 3 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_FLASHOFF 4 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_VFSTBLINK 5 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_FASTBLINK 6 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_NORMBLINK 7 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_SLOWBLINK 8 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_SOFTBLINK 9 /* for SHARP_LED_COLLIE_1 */
+#define LED_COLLIE_1_SOFTFLASH 10 /* for SHARP_LED_COLLIE_1 */
+
+#define LED_COMM_OFFLINE 0 /* for SHARP_LED_COMM */
+#define LED_COMM_ONLINE 1 /* for SHARP_LED_COMM */
+#define LED_COMM_ERROR 2 /* for SHARP_LED_COMM */
+
+#define LED_BROWSER_OFFLINE 0 /* for SHARP_LED_BROWSER */
+#define LED_BROWSER_ONLINE 1 /* for SHARP_LED_BROWSER */
+#define LED_BROWSER_ERROR 2 /* for SHARP_LED_BROWSER */
+
+
+/* --- for SHARP_BUZZER device --- */
+#define SHARP_BUZZER_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_BUZZER_MAKESOUND (SHARP_BUZZER_IOCTL_START)
+#define SHARP_BUZZER_SETVOLUME (SHARP_BUZZER_IOCTL_START+1)
+#define SHARP_BUZZER_GETVOLUME (SHARP_BUZZER_IOCTL_START+2)
+#define SHARP_BUZZER_ISSUPPORTED (SHARP_BUZZER_IOCTL_START+3)
+#define SHARP_BUZZER_SETMUTE (SHARP_BUZZER_IOCTL_START+4)
+#define SHARP_BUZZER_STOPSOUND (SHARP_BUZZER_IOCTL_START+5)
+#define SHARP_BUZZER_SET_BUFFER (SHARP_BUZZER_IOCTL_START+6)
+
+typedef struct sharp_buzzer_status { /* this struct is used for setvolume/getvolume */
+ int which; /* select which LED status is wanted. */
+ int volume; /* set new buzzer volume if you call SHARP_BUZZER_SETVOLUME */
+ int mute; /* set 1 to MUTE if you call SHARP_BUZZER_SETMUTE */
+} sharp_buzzer_status;
+
+#define SHARP_BUZ_WHICH_MAX 14 /* last number of buzzer */
+
+#define SHARP_BUZ_ALL_SOUNDS -1 /* for setting volumes of ALL sounds at a time */
+
+#define SHARP_BUZ_WRITESOUND 0 /* for sound datas through 'write' calls */
+#define SHARP_BUZ_TOUCHSOUND 1 /* touch panel sound */
+#define SHARP_BUZ_KEYSOUND 2 /* key sound */
+#define SHARP_PDA_ILLCLICKSOUND 3 /* illegal click */
+#define SHARP_PDA_WARNSOUND 4 /* warning occurred */
+#define SHARP_PDA_ERRORSOUND 5 /* error occurred */
+#define SHARP_PDA_CRITICALSOUND 6 /* critical error occurred */
+#define SHARP_PDA_SYSSTARTSOUND 7 /* system start */
+#define SHARP_PDA_SYSTEMENDSOUND 8 /* system shutdown */
+#define SHARP_PDA_APPSTART 9 /* application start */
+#define SHARP_PDA_APPQUIT 10 /* application ends */
+#define SHARP_BUZ_SCHEDULE_ALARM 11 /* schedule alarm */
+#define SHARP_BUZ_DAILY_ALARM 12 /* daily alarm */
+#define SHARP_BUZ_GOT_PHONE_CALL 13 /* phone call sound */
+#define SHARP_BUZ_GOT_MAIL 14 /* mail sound */
+
+#define SHARP_BUZ_VOLUME_OFF 0
+#define SHARP_BUZ_VOLUME_LOW 33
+#define SHARP_BUZ_VOLUME_MEDIUM 67
+#define SHARP_BUZ_VOLUME_HIGH 100 /* currentry , this is the maximum ... */
+#define SHARP_BUZ_VOLUME_MAX (SHARP_BUZ_VOLUME_HIGH)
+
+/* --- for SHARP_GSM device --- */
+#define SHARP_GSM_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_GSM_GETEXTSTATUS (SHARP_GSM_IOCTL_START+16)
+#define SHARP_GSM_INFO_TELL_MODE (SHARP_GSM_IOCTL_START+17)
+#define SHARP_IRIS_GETSYNCSTATUS (SHARP_GSM_IOCTL_START+18)
+#define SHARP_IRIS_RECHECKDEVICE (SHARP_GSM_IOCTL_START+19)
+
+
+#define GSM_PHONE_NO_POWER 0 /* for SHARP_GSM_INFO_TELL_MODE */
+#define GSM_PHONE_NO_CONNECTION 1 /* for SHARP_GSM_INFO_TELL_MODE */
+#define GSM_PHONE_IN_ANALOG_MODE 2 /* for SHARP_GSM_INFO_TELL_MODE */
+#define GSM_PHONE_IN_DATA_MODE 3 /* for SHARP_GSM_INFO_TELL_MODE */
+
+#define IRIS_AUDIO_EXT_IS_NONE 0
+#define IRIS_AUDIO_EXT_IS_HEADPHONEMIC 1
+#define IRIS_AUDIO_EXT_IS_EXTSPEAKER 2
+
+typedef struct sharp_gsmext_status {
+ int carkit; /* be set as 1 , if car-kit is connected */
+ int headphone_mic; /* be set as 1 , if head-phone-microphone is inserted */
+ int external_sp; /* be set as 1 , if external-speaker is inserted */
+} sharp_gsmext_status;
+
+typedef struct sharp_irisext_status { /* for SHARP_IRIS_GETSYNCSTATUS */
+ int usb;
+ int uart;
+ int carkit;
+} sharp_irisext_status;
+
+/* --- for SHARP_AUDIOCTL device --- */
+#define SHARP_AUDIOCTL_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_AUDIOCTL_ARCH_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START+0x10)
+#define SHARP_IRIS_AUFIL_GETVAL (SHARP_AUDIOCTL_ARCH_IOCTL_START+0)
+#define SHARP_IRIS_AUFIL_SETVAL (SHARP_AUDIOCTL_ARCH_IOCTL_START+1)
+#define SHARP_IRIS_AMP_EXT_ON (SHARP_AUDIOCTL_ARCH_IOCTL_START+2)
+#define SHARP_IRIS_AMP_EXT_OFF (SHARP_AUDIOCTL_ARCH_IOCTL_START+3)
+
+
+#define SHARP_IRIS_AUFIL_FILTERON 0x01 /* Iris AudioCtl Specific. Enable Audio Filter */
+
+/* --- for SHARP_AUDIOCTL device --- */
+#define SHARP_KBDCTL_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START)
+#define SHARP_KBDCTL_GETMODIFSTAT (SHARP_KBDCTL_IOCTL_START+0)
+#define SHARP_KBDCTL_TOGGLEMODIFSTAT (SHARP_KBDCTL_IOCTL_START+1)
+#define SHARP_KBDCTL_SETHOLDTH (SHARP_KBDCTL_IOCTL_START+2)
+#define SHARP_KBDCTL_SETHOLDTH_GR (SHARP_KBDCTL_IOCTL_START+3)
+#define SHARP_KBDCTL_HOLDINFO_SETHD (SHARP_KBDCTL_IOCTL_START+4)
+#define SHARP_KBDCTL_HOLDINFO_SETSL (SHARP_KBDCTL_IOCTL_START+5)
+#define SHARP_KBDCTL_HOLDINFO_DELHD (SHARP_KBDCTL_IOCTL_START+6)
+#define SHARP_KBDCTL_HOLDINFO_DELSL (SHARP_KBDCTL_IOCTL_START+7)
+#define SHARP_KBDCTL_HOLDINFO_RESTHD (SHARP_KBDCTL_IOCTL_START+8)
+#define SHARP_KBDCTL_HOLDINFO_RESTSL (SHARP_KBDCTL_IOCTL_START+9)
+#define SHARP_KBDCTL_HOLDINFO_RESTFULL (SHARP_KBDCTL_IOCTL_START+10)
+#define IRIS_KBDCTL_ENABLEKEYBOARD (SHARP_KBDCTL_IOCTL_START+16)
+#define IRIS_KBDCTL_DISABLEKEYBOARD (SHARP_KBDCTL_IOCTL_START+17)
+#define SHARP_KBDCTL_SENDKEY (SHARP_KBDCTL_IOCTL_START+18)
+
+typedef struct sharp_kbdctl_modifstat {
+ int which;
+ int stat;
+} sharp_kbdctl_modifstat;
+
+typedef struct sharp_kbdctl_holdstat {
+ int group;
+ int timeout;
+} sharp_kbdctl_holdstat;
+
+typedef struct sharp_kbdctl_holdcustom {
+ int normal_hardcode;
+ int normal_slcode;
+ int hold_slcode;
+} sharp_kbdctl_holdcustom;
+
+#define SHARP_EXTMODIF_2ND 0x01
+#define SHARP_EXTMODIF_CAPS 0x02
+#define SHARP_EXTMODIF_NUMLOCK 0x03
+
+#define HOLDKEY_GROUP_NORMAL 0
+#define HOLDKEY_GROUP_POWER 1
+
+
+/* --- for AUDIO & REMOCON device --- */
+#define HPJACK_STATE_UNDETECT (-1)
+#define HPJACK_STATE_NONE (0)
+#define HPJACK_STATE_HEADPHONE (1)
+#define HPJACK_STATE_REMOCON (2)
+
+
+#endif /* __ASM_SHARP_CHAR_H_INCLUDED */
+
+
+//#define EXTERNAL_IO_BASE01 0xF8000000
+//#define EXTEND_GPIO_RED_LED (1<<4)
+//#define EXTEND_GPIO_GREEN_LED (1<<5)
+//unsigned short * pwEGPIO1 ;
+//unsigned short gwExtendGpio1;
+// pwEGPIO1 = (unsigned short *) EXTERNAL_IO_BASE01;
+
+
+
+
+
+
+
+
+
diff --git a/packages/qte/qte-2.3.12/simpad-defaultkbd.patch b/packages/qte/qte-2.3.12/simpad-defaultkbd.patch
new file mode 100644
index 0000000000..0bfff37ec4
--- /dev/null
+++ b/packages/qte/qte-2.3.12/simpad-defaultkbd.patch
@@ -0,0 +1,13 @@
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwindowsystem_qws.cpp 2006-01-20 21:03:08.482912848 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwindowsystem_qws.cpp 2006-01-20 21:11:59.410199632 +0100
+@@ -2922,7 +2922,7 @@
+ {
+ QString keyboards = getenv("QWS_KEYBOARD");
+ if ( keyboards.isEmpty() ) {
+-#if defined( QT_QWS_CASSIOPEIA )
++#if defined( QT_QWS_CASSIOPEIA ) || defined( QT_QWS_SIMPAD )
+ keyboards = "Buttons";
+ #elif !defined(QT_NO_QWS_VFB)
+ extern bool qvfbEnabled;
diff --git a/packages/qte/qte-2.3.12/simpad.patch b/packages/qte/qte-2.3.12/simpad.patch
new file mode 100644
index 0000000000..bf4367c319
--- /dev/null
+++ b/packages/qte/qte-2.3.12/simpad.patch
@@ -0,0 +1,392 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:30:31.073201168 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp 2006-01-20 21:36:45.024351952 +0100
+@@ -37,6 +37,7 @@
+ #include <qapplication.h>
+ #include <qsocketnotifier.h>
+ #include <qnamespace.h>
++#include <qdatetime.h>
+ #include <qtimer.h>
+
+ #include <stdlib.h>
+@@ -80,6 +81,60 @@
+ #include <sys/vt.h>
+ #endif
+
++/*
++ * SIMpad switches handler
++ * (C) 2003-2005 Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
++ */
++
++
++
++#include <linux/switches.h>
++#define SIMPAD_SWITCHES_DEVICE "/dev/misc/switches"
++
++// switches from left top to right down over the SIMpad surface
++
++#define SIMPAD_SWITCH_POWER 0x02
++#define SIMPAD_SWITCH_UPPER 0x10
++#define SIMPAD_SWITCH_UP 0x20
++#define SIMPAD_SWITCH_DOWN 0x40
++#define SIMPAD_SWITCH_LEFT 0x80
++#define SIMPAD_SWITCH_RIGHT 0x100
++#define SIMPAD_SWITCH_LOWER 0x8
++
++class QWSsimpadButtonsHandler : public QWSKeyboardHandler
++{
++ Q_OBJECT
++
++ public:
++ QWSsimpadButtonsHandler();
++ virtual ~QWSsimpadButtonsHandler();
++
++ bool isOpen() { return fd > 0; }
++
++ private slots:
++ void readSwitchesData();
++ void autoRepeat();
++
++ private:
++ switches_mask_t switches;
++
++ int fd;
++ int repeatdelay;
++ int repeatperiod;
++
++ int lastCode; // last native code
++ int lastPress; // last press/release state
++
++ int k; // last emitted Qt key code
++ int shiftKeyPressed; // true if one of the SHIFT keys has been pressed and not yet released
++ bool shiftUsed; // true if SHIFT has been used
++
++ QTime eventTimer; // tracks time between raw events
++ QTimer* repeater;
++ QSocketNotifier *notifier;
++};
++
++
+ #ifdef QT_QWS_SL5XXX
+ #include <asm/sharp_char.h>
+ #endif
+@@ -165,9 +220,9 @@
+ current = 0;
+ }
+
+- void setAutoRepeat(int d, int p) { if ( d > 0 ) repeatdelay=d;
++ void setAutoRepeat(int d, int p) { if ( d > 0 ) repeatdelay=d;
+ if ( p > 0 ) repeatperiod=p;}
+- void getAutoRepeat(int *d ,int *p ) { if (d) *d=repeatdelay;
++ void getAutoRepeat(int *d ,int *p ) { if (d) *d=repeatdelay;
+ if (p) *p=repeatperiod; }
+
+ void stop()
+@@ -551,9 +606,9 @@
+
+ void doKey(uchar scancode);
+
+-
++
+ void restoreLeds();
+-
++
+ private:
+ bool shift;
+ bool alt;
+@@ -809,7 +864,7 @@
+
+ #if !defined(QT_QWS_SL5XXX)
+ if (code == 224
+-#if defined(QT_QWS_IPAQ)
++#if defined(QT_QWS_IPAQ)
+ && !ipaq_return_pressed
+ #endif
+ ) {
+@@ -1778,9 +1833,11 @@
+ } else {
+ type = spec;
+ }
+-
+ if ( type == "Buttons" ) {
+-#if defined(QT_QWS_YOPY)
++#if defined(QT_QWS_SIMPAD)
++ qDebug( "QWSKeyboardHandler: using SIMpad switches handler..." );
++ handler = new QWSsimpadButtonsHandler();
++#elif defined(QT_QWS_YOPY)
+ handler = new QWSyopyButtonsHandler();
+ #elif defined(QT_QWS_CASSIOPEIA)
+ handler = new QWSVr41xxButtonsHandler();
+@@ -1815,6 +1872,218 @@
+ return keyM;
+ }
+
+-#endif // QT_NO_QWS_KEYBOARD
+
++/*
++ * SIMpad switches handler
++ * (C) 2003 Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
++ */
++
++
++QWSsimpadButtonsHandler::QWSsimpadButtonsHandler()
++ :QWSKeyboardHandler(), fd( -1 ),
++ repeatdelay( 700 ), repeatperiod( 80 ),
++ lastCode( 0 ), lastPress( 0 ),
++ k( -1 ), shiftKeyPressed( 0 ), shiftUsed( false )
++{
++ qDebug( "SimpadButtonsHandler() - V4.1" );
++ fd = ::open( SIMPAD_SWITCHES_DEVICE, O_RDWR | O_NDELAY, 0 );
++ if ( fd < 0 )
++ {
++ qWarning( "SimpadButtonsHandler(): can't open %s", SIMPAD_SWITCHES_DEVICE );
++ return;
++ }
++
++ notifier = new QSocketNotifier( fd, QSocketNotifier::Read, this );
++ connect( notifier, SIGNAL( activated(int) ),this, SLOT( readSwitchesData() ) );
++
++ repeater = new QTimer(this);
++ connect(repeater, SIGNAL(timeout()), this, SLOT(autoRepeat()));
++
++}
++
++
++QWSsimpadButtonsHandler::~QWSsimpadButtonsHandler()
++{
++ qDebug( "~SimpadButtonsHandler()" );
++ if ( fd > 0 )
++ {
++ ::close( fd );
++ fd = -1;
++ }
++}
++
++
++void QWSsimpadButtonsHandler::readSwitchesData()
++{
++ qDebug( "SimpadButtonsHandler() - detected switches action" );
+
++ if ( ::read( fd, &switches, sizeof switches ) < 0 )
++ {
++ qWarning( "SimpadButtonsHandler() - switches read error!" );
++ return;
++ }
++
++ qDebug( "SimpadButtonsHandler() - Shift: %0x [used: %0x] + Event = %0x | %0x",
++ shiftKeyPressed, shiftUsed, switches.events[0], switches.states[0] );
++
++ bool press = switches.states[0]; // == switches.event[0];
++ int code = switches.events[0];
++
++ //=========================================================================
++
++ /**
++ * Work around a bug in the kernel keyboard driver emitting
++ * bogus events when pressing multiple switches at once
++ **/
++
++ if ( lastCode == 0 )
++ {
++ // first press ever
++ eventTimer.start();
++ lastPress = press;
++ lastCode = code;
++ }
++ else
++ {
++ int interval = eventTimer.restart();
++ qDebug( "event interval = %d", interval );
++ if ( code == lastCode && interval < 10 )
++ {
++ qDebug( "event interval too small - ignoring bogus event" );
++ qDebug( "did I say i hate buggy kernel drivers? :-D" );
++ return;
++ }
++
++ lastPress = press;
++ lastCode = code;
++ }
++
++ /**
++ * Actually it may also be a hardware problem, but I really don't like
++ * to review kernel code for further inquiry. So just being lazy and
++ * do the workaround in user space :-D
++ **/
++
++ //=====================================================================
++
++ if ( shiftKeyPressed )
++ {
++ // a shift key obviously is being held
++ qDebug( "while shift key is being held..." );
++
++ if ( code != shiftKeyPressed )
++ {
++ // another key is being touched - that means shift mode for us!
++ qDebug( " another key is being touched -> shift use now = true" );
++
++ shiftUsed = true;
++
++ if ( shiftKeyPressed == SIMPAD_SWITCH_LOWER ) // SHIFT 1
++ {
++ qDebug( " shift mode 1" );
++ switch(code)
++ {
++ case SIMPAD_SWITCH_UP: k = Qt::Key_F9; break; // Shift1-Up = Calendar
++ case SIMPAD_SWITCH_DOWN: k = Qt::Key_F10; break; // Shift1-Down = Contacts
++ case SIMPAD_SWITCH_LEFT: k = Qt::Key_F13; break; // Shift1-Left = Mail
++ case SIMPAD_SWITCH_RIGHT: k = Qt::Key_F11; break; // Shift1-Up = Menu
++ case SIMPAD_SWITCH_UPPER: k = Qt::Key_F12; break; // Shift1-Upper = Home
++ default: k=-1; qWarning( "SimpadButtonsHandler() - unhandled event for Shift 1 !" ); break;
++ }
++ }
++ else if ( shiftKeyPressed == SIMPAD_SWITCH_UPPER ) // SHIFT 2
++ {
++ qDebug( " shift mode 2" );
++ switch(code)
++ {
++ case SIMPAD_SWITCH_UP: k = Qt::Key_F5; break; // Shift2-Up = F5
++ case SIMPAD_SWITCH_DOWN: k = Qt::Key_F6; break; // Shift2-Down = F6
++ case SIMPAD_SWITCH_LEFT: k = Qt::Key_F7; break; // Shift2-Left = F7
++ case SIMPAD_SWITCH_RIGHT: k = Qt::Key_F8; break; // Shift2-Up = F8
++ case SIMPAD_SWITCH_LOWER: k = Qt::Key_F9; break; // Shift2-Lower = F9
++ default: k=-1; qWarning( "SimpadButtonsHandler() - unhandled event for Shift 2!" ); break;
++ }
++ }
++ }
++ else
++ {
++ qDebug( " shift key has been released. checking if being used..." );
++ shiftKeyPressed = 0;
++
++ if ( !shiftUsed )
++ {
++ qDebug( " ... has _not_ being used -> really emit the key" );
++ k = ( code == SIMPAD_SWITCH_UPPER ? Qt::Key_Escape : Qt::Key_Return );
++ qDebug( "Emitting key = %d (pressed)", k );
++ processKeyEvent( 0, k, 0, true, true );
++ qDebug( "Emitting key = %d (released)", k );
++ processKeyEvent( 0, k, 0, false, true );
++ return;
++ }
++ else
++ {
++ qDebug( " ... has being used -> doing nothing" );
++ return;
++ }
++ }
++ }
++ else
++ {
++ qDebug( "standard mode - no shift yet..." );
++
++ switch(code)
++ {
++ case SIMPAD_SWITCH_UP: k = Qt::Key_Up; break;
++ case SIMPAD_SWITCH_DOWN: k = Qt::Key_Down; break;
++ case SIMPAD_SWITCH_LEFT: k = Qt::Key_Left; break;
++ case SIMPAD_SWITCH_RIGHT: k = Qt::Key_Right; break;
++ case SIMPAD_SWITCH_POWER: k = Qt::Key_F34; break; // Power Button
++
++ case SIMPAD_SWITCH_UPPER: k=-1; shiftKeyPressed = press? code:0; shiftUsed = false; qDebug( "shiftkey pressed now = %d", shiftKeyPressed ); return;
++ case SIMPAD_SWITCH_LOWER: k=-1; shiftKeyPressed = press? code:0; shiftUsed = false; qDebug( "shiftkey pressed now = %d", shiftKeyPressed ); return;
++
++ default: k=-1; qWarning( "SimpadButtonsHandler() - unhandled event!" ); break;
++ }
++ }
++
++ if ( k == -1 )
++ {
++ qDebug( "no key to emit - returning." );
++ return;
++ }
++
++ bool repeatable = ( k == Qt::Key_Up || k == Qt::Key_Down ||
++ k == Qt::Key_Right || k == Qt::Key_Left );
++
++ qDebug( "key to emit = %d [%s] [repeat=%s]", k,
++ press ? "press" : "release",
++ repeatable ? "true":"false" );
++
++ if ( qt_screen->isTransformed() && k >= Qt::Key_Left && k <= Qt::Key_Down )
++ {
++ qDebug( "SimpadButtonsHandler() - We are transformed! Correcting..." );
++ int oldK = k;
++ k = xform_dirkey( k );
++ qDebug( "SimpadButtonsHandler() - Old Key: %d - New Key %d", oldK, k );
++ }
++
++ if ( repeatable && press )
++ repeater->start( repeatdelay, true );
++ else
++ repeater->stop();
++
++ qwsServer->processKeyEvent( 0, k, 0, press, false );
++}
++
++
++void QWSsimpadButtonsHandler::autoRepeat()
++{
++ qDebug( "Emitting key = %d (released)", k );
++ processKeyEvent( 0, k, 0, false, true );
++ qDebug( "Emitting key = %d (pressed)", k );
++ processKeyEvent( 0, k, 0, true, true );
++ repeater->start(repeatperiod);
++}
++
++
++#endif // QT_NO_QWS_KEYBOARD
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qwsmouse_qws.cpp 2006-01-20 21:30:35.836477040 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qwsmouse_qws.cpp 2006-01-20 21:36:59.160202976 +0100
+@@ -47,6 +47,7 @@
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <sys/ioctl.h>
++#include <sys/time.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #include <fcntl.h>
+@@ -73,6 +74,7 @@
+ unsigned short x;
+ unsigned short y;
+ unsigned short pad;
++ struct timeval stamp;
+ } TS_EVENT;
+ #elif defined(QT_QWS_SL5XXX)
+ #define QT_QWS_SL5XXX_RAW
+@@ -1292,6 +1294,8 @@
+ #if defined(QT_QWS_IPAQ)
+ #ifdef QT_QWS_IPAQ_RAW
+ dev = "/dev/h3600_tsraw";
++#elif defined(QT_QWS_SIMPAD)
++ dev = "/dev/touchscreen/usb1x00";
+ #else
+ dev = "/dev/h3600_ts";
+ #endif
+@@ -1322,7 +1326,7 @@
+
+ QTPanelHandlerPrivate::~QTPanelHandlerPrivate()
+ {
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD)
+ if (mouseFD >= 0)
+ close(mouseFD);
+ #endif
+@@ -1330,7 +1334,7 @@
+
+ void QTPanelHandlerPrivate::readMouseData()
+ {
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700)
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_K2) || defined(QT_QWS_SLC700) || defined(QT_QWS_SIMPAD)
+ if(!qt_screen)
+ return;
+
diff --git a/packages/qte/qte-2.3.12/suspend-resume-hooks.patch b/packages/qte/qte-2.3.12/suspend-resume-hooks.patch
new file mode 100644
index 0000000000..34e6ba2133
--- /dev/null
+++ b/packages/qte/qte-2.3.12/suspend-resume-hooks.patch
@@ -0,0 +1,64 @@
+Suspend/Resume hooks for QScreen and usage from QApplication
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/kernel/qgfx_qws.h~suspend-resume-hooks
++++ qt-2.3.10/src/kernel/qgfx_qws.h
+@@ -192,6 +192,8 @@
+ virtual int pixmapLinestepAlignment() { return 64; }
+
+ virtual void sync() {}
++ virtual void prepareToSuspend() {}
++ virtual void prepareToResume() {}
+ virtual bool onCard(unsigned char *) const;
+ virtual bool onCard(unsigned char *, ulong& out_offset) const;
+
+--- qt-2.3.10/src/kernel/qapplication_qws.cpp~suspend-resume-hooks
++++ qt-2.3.10/src/kernel/qapplication_qws.cpp
+@@ -480,6 +480,7 @@
+ int region_offset_window;
+ #ifndef QT_NO_COP
+ QWSQCopMessageEvent *qcop_response;
++ bool manageAPMMessage( QWSQCopMessageEvent *e );
+ #endif
+ QWSEvent* current_event;
+ QValueList<int> unused_identifiers;
+@@ -840,7 +841,7 @@
+ QWSQCopMessageEvent *pe = (QWSQCopMessageEvent*)e;
+ if ( pe->simpleData.is_response ) {
+ qcop_response = pe;
+- } else {
++ } else if ( !manageAPMMessage( pe ) ) {
+ queue.append(e);
+ }
+ #endif
+@@ -851,6 +852,26 @@
+ }
+ }
+
++#ifndef QT_NO_COP
++bool QWSDisplayData::manageAPMMessage( QWSQCopMessageEvent *e )
++{
++ if ( e->channel.data() != QCString( "QPE/System" ) ) {
++ return FALSE;
++ }
++ if ( e->message.data() == QCString( "aboutToSuspend()" ) ) {
++ if ( qt_screen ) qt_screen->prepareToSuspend();
++ delete e;
++ return TRUE;
++ }
++ if ( e->message.data() == QCString( "returnFromSuspend()" ) ) {
++ if ( qt_screen ) qt_screen->prepareToResume();
++ delete e;
++ return TRUE;
++ }
++ return FALSE;
++}
++#endif
++
+ void QWSDisplayData::offsetPendingExpose( int window, const QPoint &offset )
+ {
+ if ( offset.isNull() )
diff --git a/packages/qte/qte-2.3.12/switches.h b/packages/qte/qte-2.3.12/switches.h
new file mode 100644
index 0000000000..37516b4c75
--- /dev/null
+++ b/packages/qte/qte-2.3.12/switches.h
@@ -0,0 +1,74 @@
+/*
+ * linux/include/linux/switches.h
+ *
+ * Copyright (C) 2000 John Dorsey
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 23 October 2000 - created.
+ */
+
+#if !defined(_LINUX_SWITCHES_H)
+#define _LINUX_SWITCHES_H
+
+#define SWITCHES_MASK_SIZE (128)
+
+typedef unsigned long switches_bitfield;
+
+#define SWITCHES_BITS (sizeof(switches_bitfield) * 8)
+#define SWITCHES_NUM_FIELDS (SWITCHES_MASK_SIZE / SWITCHES_BITS)
+#define SWITCHES_FIELD_SELECT(i) ((i) / SWITCHES_BITS)
+#define SWITCHES_FIELD_MASK(i) ((switches_bitfield)(1 << (i) % \
+ SWITCHES_BITS))
+
+typedef struct switches_mask_t {
+ unsigned int count;
+ switches_bitfield events[SWITCHES_NUM_FIELDS];
+ switches_bitfield states[SWITCHES_NUM_FIELDS];
+} switches_mask_t;
+
+#define SWITCHES_ZERO(m) \
+do { \
+ unsigned int sz_i; \
+ (m)->count = 0; \
+ for(sz_i = 0; sz_i < SWITCHES_NUM_FIELDS; ++sz_i) \
+ (m)->events[sz_i] = (m)->states[sz_i] = 0; \
+} while (0)
+
+/* `s' is the state of the switch, either 0 or non-zero: */
+#define SWITCHES_SET(m, i, s) \
+do { \
+ ((m)->events[SWITCHES_FIELD_SELECT((i))] |= \
+ SWITCHES_FIELD_MASK((i))); \
+ if(s) \
+ ((m)->states[SWITCHES_FIELD_SELECT((i))] |= \
+ SWITCHES_FIELD_MASK((i))); \
+ else \
+ ((m)->states[SWITCHES_FIELD_SELECT((i))] &= \
+ ~SWITCHES_FIELD_MASK((i))); \
+ ++((m)->count); \
+} while (0)
+
+/* Should only use to clear an event set by SWITCHES_SET(): */
+#define SWITCHES_CLEAR(m, i) \
+do { \
+ ((m)->events[SWITCHES_FIELD_SELECT((i))] &= \
+ ~SWITCHES_FIELD_MASK((i))); \
+ ((m)->states[SWITCHES_FIELD_SELECT((i))] &= \
+ ~SWITCHES_FIELD_MASK((i))); \
+ --((m)->count); \
+}
+
+#define SWITCHES_COUNT(m) ((m)->count)
+
+/* Returns 0 or non-zero: */
+#define SWITCHES_EVENT(m, i) \
+((m)->events[SWITCHES_FIELD_SELECT((i))] & SWITCHES_FIELD_MASK((i)))
+
+/* Returns 0 or non-zero: */
+#define SWITCHES_STATE(m, i) \
+((m)->states[SWITCHES_FIELD_SELECT((i))] & SWITCHES_FIELD_MASK((i)))
+
+#endif /* !defined(_LINUX_SWITCHES_H) */
diff --git a/packages/qte/qte-2.3.12/tslib.patch b/packages/qte/qte-2.3.12/tslib.patch
new file mode 100644
index 0000000000..47837d7a5d
--- /dev/null
+++ b/packages/qte/qte-2.3.12/tslib.patch
@@ -0,0 +1,53 @@
+Index: qt-2.3.10/src/kernel/qwsmouse_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qwsmouse_qws.cpp 2005-02-16 00:53:53.090339898 +0100
++++ qt-2.3.10/src/kernel/qwsmouse_qws.cpp 2005-02-16 00:54:43.059069292 +0100
+@@ -1878,30 +1878,33 @@
+ */
+ void QTSLibHandlerPrivate::interpolateSample() {
+ #ifdef QT_QWS_TSLIB
+- static struct ts_sample samples[25];
+- int index = -1;
++#define TSLIB_MAX_SAMPLES 25
++ static struct ts_sample samples[TSLIB_MAX_SAMPLES];
++ int index = 0;
++ int read_samples = 0;
+ int ret;
+
+ do {
+- /* fill only the last sample again */
+- if ( index >= 25 )
+- index = 24;
+-
++ /* do not access negative arrays */
++ if ( index < 0 )
++ index = 0;
++
+ /* we're opened non-blocking */
+- if((ret= ts_read_raw(m_ts, &samples[index], 1 ) ) != 1 ) {
++ if((ret= ts_read_raw(m_ts, &samples[index], 1 ) ) != 1 )
+ /* no event yet, so try again */
+- if (ret==-1 ) {
+- index--;
++ if (ret==-1 )
+ continue;
+- }
+- }
+- }while (samples[index++].pressure != 0);
++
++ read_samples++;
++ index = (index+1)%TSLIB_MAX_SAMPLES;
++ }while (samples[index == 0 ? (TSLIB_MAX_SAMPLES-1) : index-1].pressure != 0);
+
+ /*
+- * index is maximal 25 and we at least one sample
++ * If we've wrapped around each sample is used otherwise
++ * we will use the index
+ */
+- if( index >= 25 )
+- index = 24;
++ index = read_samples >= TSLIB_MAX_SAMPLES ?
++ (TSLIB_MAX_SAMPLES-1 ) : index;
+ int x, y;
+
+ /*
diff --git a/packages/qte/qte-2.3.12/vt-switch.patch b/packages/qte/qte-2.3.12/vt-switch.patch
new file mode 100644
index 0000000000..92b8e5436a
--- /dev/null
+++ b/packages/qte/qte-2.3.12/vt-switch.patch
@@ -0,0 +1,184 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qapplication_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qapplication_qws.cpp 2006-01-20 20:44:13.910394088 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qapplication_qws.cpp 2006-01-20 20:46:52.639263632 +0100
+@@ -125,6 +125,12 @@
+ static int qt_thread_pipe[2];
+ #endif
+
++#if defined(_OS_LINUX_)
++#include <sys/ioctl.h>
++#include <linux/vt.h>
++#include <linux/kd.h>
++#endif
++
+ const int qwsSharedRamSize = 32 * 1024; //Small amount to fit on small devices.
+
+ // These are in qapplication.cpp in qt/main
+@@ -165,6 +171,8 @@
+ bool qws_accel = TRUE; // ### never set
+ const char *qws_display_spec = ":0";
+ int qws_display_id = 0;
++int qws_terminal_id = 0;
++int qws_terminal_old = 0;
+ int qws_client_id = 0;
+ QWidget *qt_pressGrab = 0;
+ QWidget *qt_mouseGrb = 0;
+@@ -1702,6 +1710,15 @@
+ type = QApplication::GuiServer;
+ } else if ( arg == "-interlaced" ) {
+ qws_screen_is_interlaced = TRUE;
++ } else if ( arg == "-terminal" ) {
++ if ( ++i < argc )
++ {
++ if ( ( qws_terminal_id = atoi( argv[i] ) ) < 1 )
++ {
++ qWarning( "Ignoring Invalid Terminal Specification." );
++ qws_terminal_id = 0;
++ }
++ }
+ } else if ( arg == "-display" ) {
+ if ( ++i < argc )
+ qws_display_spec = argv[i];
+@@ -1727,6 +1744,53 @@
+ if ( type == QApplication::GuiServer ) {
+ qt_appType = type;
+ qws_single_process = TRUE;
++
++ /* Allocate a dedicated virtual terminal -- (C) Michael 'Mickey' Lauer <mickey@tm.informatik.uni-frankfurt.de>
++ * Added a new command line option which only is relevant if the application is created as a GuiServer.
++ * The option is -terminal <num>, where <num> specifies the virtual terminal to be occupied by the server.
++ * As default in Linux, 0 means the current virtual terminal.
++ */
++ #if defined(_OS_LINUX_)
++ if ( qws_terminal_id )
++ {
++ qDebug( "qt_init() - terminal specification is '%d'.", qws_terminal_id );
++ struct vt_stat console_stat;
++ int console_fd = ::open( QString().sprintf( "/dev/tty%d", qws_terminal_id ).latin1(), O_RDWR );
++ if ( console_fd == -1)
++ {
++ qWarning( "qt_init() - can't open tty: %s", strerror( errno ) );
++ exit( -1 );
++ }
++ if ( ioctl( console_fd, VT_GETSTATE, &console_stat ) == -1 )
++ {
++ qWarning( "qt_init() - can't ioctl(VT_GETSTATE): %s", strerror( errno ) );
++ exit( -1 );
++ }
++ qws_terminal_old = console_stat.v_active;
++ qDebug( "qt_init() - active vt is #%d, switching to #%d as requested...", qws_terminal_old, qws_terminal_id );
++
++ if ( ioctl( console_fd, VT_ACTIVATE, qws_terminal_id ) == -1 )
++ {
++ qWarning( "qt_init() - can't ioctl(VT_ACTIVATE): %s", strerror( errno ) );
++ exit( -1 );
++ }
++ if ( ioctl( console_fd, VT_WAITACTIVE, qws_terminal_id ) == -1 )
++ {
++ qWarning( "qt_init() - can't ioctl(VT_WAITACTIVE): %s", strerror( errno ) );
++ exit( -1 );
++ }
++ if ( ioctl( console_fd, KDSETMODE, KD_GRAPHICS ) == -1 )
++ {
++ qWarning( "qt_init() - can't ioctl(KDSETMODE:KD_GRAPHICS): %s", strerror( errno ) );
++ exit( -1 );
++ }
++ ::close( console_fd );
++ }
++ else
++ {
++ qDebug( "QWSApplication::qt_init() - current terminal specified." );
++ }
++ #endif
+ QWSServer::startup(flags);
+ setenv("QWS_DISPLAY", qws_display_spec, 0);
+ }
+@@ -1777,7 +1841,36 @@
+ QFontManager::cleanup();
+
+ if ( qws_single_process ) {
+- QWSServer::closedown();
++ qDebug( "qt_cleanup() - shutting down QWSServer..." );
++#ifndef QT_NO_QWS_KEYBOARD
++ if ( qwsServer )
++ qwsServer->closeKeyboard();
++#endif
++ QWSServer::closedown();
++#if defined(_OS_LINUX_)
++ if ( qws_terminal_old > 0 )
++ {
++ qDebug( "qt_cleanup() - switching back to virtual terminal #%d", qws_terminal_old );
++
++ int console_fd = ::open( "/dev/tty0", O_RDWR );
++ if ( console_fd == -1)
++ {
++ qWarning( "qt_init() - can't open tty: %s", strerror( errno ) );
++ }
++ else
++ {
++ if ( ioctl( console_fd, KDSETMODE, KD_TEXT ) == -1 )
++ {
++ qWarning( "qt_init() - can't ioctl(KDSETMODE:KD_TEXT): %s", strerror( errno ) );
++ }
++ if ( ioctl( console_fd, VT_ACTIVATE, qws_terminal_old ) == -1 )
++ {
++ qWarning( "qt_init() - can't ioctl(VT_ACTIVATE): %s", strerror( errno ) );
++ }
++ ::close( console_fd );
++ }
++ }
++#endif
+ }
+ if ( qt_is_gui_used ) {
+ delete qt_fbdpy;
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qkeyboard_qws.cpp 2006-01-20 20:44:13.911393936 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qkeyboard_qws.cpp 2006-01-20 20:46:52.640263480 +0100
+@@ -1247,6 +1247,24 @@
+ {
+ if (kbdFD >= 0)
+ {
++
++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
++ struct vt_mode vtMode;
++ ioctl(kbdFD, VT_GETMODE, &vtMode);
++
++ /* Mickey says: "Better give up control of VT switching.
++ * Hey, I really hate that OS-will-reacquire-resources on process-death
++ * kind of thinking!
++ */
++ vtMode.mode = VT_AUTO;
++ vtMode.relsig = 0;
++ vtMode.acqsig = 0;
++ ioctl(kbdFD, VT_SETMODE, &vtMode);
++
++ signal(VTSWITCHSIG, 0);
++ qDebug( "~QWSTtyKeyboardHandler() - released VT." );
++#endif
++
+ #if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
+ ioctl(kbdFD, KDSKBMODE, K_XLATE);
+ #endif
+Index: qt-2.3.10-snapshot-20060120/src/kernel/qgfxlinuxfb_qws.cpp
+===================================================================
+--- qt-2.3.10-snapshot-20060120.orig/src/kernel/qgfxlinuxfb_qws.cpp 2006-01-20 20:44:13.911393936 +0100
++++ qt-2.3.10-snapshot-20060120/src/kernel/qgfxlinuxfb_qws.cpp 2006-01-20 20:46:52.641263328 +0100
+@@ -255,9 +255,9 @@
+
+ bool QLinuxFbScreen::initDevice()
+ {
+- // No blankin' screen, no blinkin' cursor!, no cursor!
++ /* Setting up the VT parameters is done in qapplication_qws.cpp
+ const char termctl[]="\033[9;0]\033[?33l\033[?25l";
+- writeTerm(termctl,sizeof(termctl));
++ writeTerm(termctl,sizeof(termctl)); */
+
+ // Grab current mode so we can reset it
+ fb_var_screeninfo vinfo;
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-22 10:53:37 +0000