aboutsummaryrefslogtreecommitdiffstats
path: root/packages/qte
diff options
context:
space:
mode:
authorKoen Kooi <koen@openembedded.org>2005-06-30 08:19:37 +0000
committerOpenEmbedded Project <openembedded-devel@lists.openembedded.org>2005-06-30 08:19:37 +0000
commitc8e5702127e507e82e6f68a4b8c546803accea9d (patch)
tree00583491f40ecc640f2b28452af995e3a63a09d7 /packages/qte
parent87ec8ca4d2e2eb4d1c1e1e1a6b46a395d56805b9 (diff)
downloadopenembedded-c8e5702127e507e82e6f68a4b8c546803accea9d.tar.gz
import clean BK tree at cset 1.3670
Diffstat (limited to 'packages/qte')
-rw-r--r--packages/qte/.mtn2git_empty0
-rw-r--r--packages/qte/qte-2.3.10/.mtn2git_empty0
-rw-r--r--packages/qte/qte-2.3.10/beagle.patch32
-rw-r--r--packages/qte/qte-2.3.10/bidimetrics.patch2389
-rw-r--r--packages/qte/qte-2.3.10/c700-hardware.patch110
-rw-r--r--packages/qte/qte-2.3.10/daemonize.patch113
-rw-r--r--packages/qte/qte-2.3.10/devfs.patch163
-rw-r--r--packages/qte/qte-2.3.10/encoding.patch34
-rw-r--r--packages/qte/qte-2.3.10/fix-linuxfb-setmode.patch32
-rw-r--r--packages/qte/qte-2.3.10/fix-qgfxraster.patch28
-rw-r--r--packages/qte/qte-2.3.10/gcc3.patch27
-rw-r--r--packages/qte/qte-2.3.10/increase-qxml-robustness.patch17
-rw-r--r--packages/qte/qte-2.3.10/ipaq-keyboard.patch27
-rw-r--r--packages/qte/qte-2.3.10/kernel-keymap-CXK.patch19
-rw-r--r--packages/qte/qte-2.3.10/kernel-keymap-corgi.patch23
-rw-r--r--packages/qte/qte-2.3.10/kernel-keymap-tosa.patch81
-rw-r--r--packages/qte/qte-2.3.10/kernel-keymap.patch1038
-rw-r--r--packages/qte/qte-2.3.10/mnci-touchscreen.patch1987
-rw-r--r--packages/qte/qte-2.3.10/mnci.patch125
-rw-r--r--packages/qte/qte-2.3.10/no-moc.patch37
-rw-r--r--packages/qte/qte-2.3.10/openmn/.mtn2git_empty0
-rw-r--r--packages/qte/qte-2.3.10/openmn/qkeyboard_qws.cpp584
-rw-r--r--packages/qte/qte-2.3.10/openmn/qkeyboard_qws.h56
-rw-r--r--packages/qte/qte-2.3.10/qiconview-speed.patch122
-rw-r--r--packages/qte/qte-2.3.10/qpe.patch105
-rw-r--r--packages/qte/qte-2.3.10/qt-visibility.patch459
-rw-r--r--packages/qte/qte-2.3.10/qtabbar.patch39
-rw-r--r--packages/qte/qte-2.3.10/qte-fix-iconsize.patch99
-rw-r--r--packages/qte/qte-2.3.10/sharp_char.h309
-rw-r--r--packages/qte/qte-2.3.10/switches.h74
-rw-r--r--packages/qte/qte-2.3.10/vt-switch.patch178
-rw-r--r--packages/qte/qte-4.0.0-snapshot/.mtn2git_empty0
-rw-r--r--packages/qte/qte-4.0.0-snapshot/add-qatomic.patch72
-rw-r--r--packages/qte/qte-4.0.0-snapshot/fix-qwidget.patch17
-rw-r--r--packages/qte/qte-4.0.0-snapshot/fix-qwsmanager.patch18
-rw-r--r--packages/qte/qte-4.0.0-snapshot/fix-sl5000driver.patch29
-rw-r--r--packages/qte/qte-4.0.0-snapshot/fix-vncdriver.patch16
-rw-r--r--packages/qte/qte-4.0.0-snapshot/gcc34.patch26
-rw-r--r--packages/qte/qte-4.0.0-snapshot/no-moc-no-uic-no-rcc.patch25
-rw-r--r--packages/qte/qte-4.0.0-snapshot/sharp_char.h309
-rw-r--r--packages/qte/qte-4.0.0-snapshot/switches.h74
-rwxr-xr-x[-rw-r--r--]packages/qte/qte-4.0.0-snapshot/update-qtfontdir62
42 files changed, 8955 insertions, 0 deletions
diff --git a/packages/qte/.mtn2git_empty b/packages/qte/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/qte/.mtn2git_empty
diff --git a/packages/qte/qte-2.3.10/.mtn2git_empty b/packages/qte/qte-2.3.10/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/qte/qte-2.3.10/.mtn2git_empty
diff --git a/packages/qte/qte-2.3.10/beagle.patch b/packages/qte/qte-2.3.10/beagle.patch
index e69de29bb2..eeb31c3b98 100644
--- a/packages/qte/qte-2.3.10/beagle.patch
+++ b/packages/qte/qte-2.3.10/beagle.patch
@@ -0,0 +1,32 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp~beagle
++++ qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp
+@@ -138,7 +138,7 @@
+ #include <asm/sharp_char.h>
+ #endif
+
+-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) || defined(QT_QWS_BEAGLE)
+ #define QT_QWS_AUTOREPEAT_MANUALLY
+ #endif
+
+@@ -492,9 +492,15 @@
+ #endif
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 90
++#ifdef QT_QWS_BEAGLE
++ { Qt::Key_F13, 0xffff , 0xffff , 0xffff }, // lightning
++ { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // Wheel Up
++ { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // Wheel Down
++#else
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
++#endif
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_unknown, 0xffff , 0xffff , 0xffff },
+ { Qt::Key_Enter, 13 , 13 , 0xffff },
diff --git a/packages/qte/qte-2.3.10/bidimetrics.patch b/packages/qte/qte-2.3.10/bidimetrics.patch
index e69de29bb2..50990f5d19 100644
--- a/packages/qte/qte-2.3.10/bidimetrics.patch
+++ b/packages/qte/qte-2.3.10/bidimetrics.patch
@@ -0,0 +1,2389 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+Index: qt-2.3.10/src/kernel/qgfxraster_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qgfxraster_qws.cpp 2005-05-13 22:22:11.000000000 +0200
++++ qt-2.3.10/src/kernel/qgfxraster_qws.cpp 2005-05-13 22:22:13.000000000 +0200
+@@ -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;
+
+@@ -1382,6 +1387,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;
+@@ -1402,6 +1454,9 @@
+ x+=glyph.metrics->advance;
+ // ... unlock glyph
+ }
++
++#endif
++
+ #ifdef DEBUG_LOCKS
+ qDebug("unaccelerated drawText unlock");
+ #endif
+Index: qt-2.3.10/src/kernel/qfont_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qfont_qws.cpp 2005-05-13 22:22:11.000000000 +0200
++++ qt-2.3.10/src/kernel/qfont_qws.cpp 2005-05-13 22:22:13.000000000 +0200
+@@ -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
+@@ -385,17 +391,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/src/kernel/qbidi.h
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10/src/kernel/qbidi.h 2005-05-13 22:22:13.000000000 +0200
+@@ -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/src/kernel/qbidi.cpp
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10/src/kernel/qbidi.cpp 2005-05-13 22:22:13.000000000 +0200
+@@ -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/src/kernel/minibidi.c
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ qt-2.3.10/src/kernel/minibidi.c 2005-05-13 22:22:13.000000000 +0200
+@@ -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/src/qt.pro
+===================================================================
+--- qt-2.3.10.orig/src/qt.pro 2005-01-23 15:00:39.000000000 +0100
++++ qt-2.3.10/src/qt.pro 2005-05-13 22:22:13.000000000 +0200
+@@ -182,6 +182,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 \
+@@ -527,6 +528,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/src/Makefile.in
+===================================================================
+--- qt-2.3.10.orig/src/Makefile.in 2005-05-13 22:22:11.000000000 +0200
++++ qt-2.3.10/src/Makefile.in 2005-05-13 22:29:52.000000000 +0200
+@@ -168,6 +168,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 \
+@@ -4107,6 +4109,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.10/c700-hardware.patch b/packages/qte/qte-2.3.10/c700-hardware.patch
index e69de29bb2..5527ab4a88 100644
--- a/packages/qte/qte-2.3.10/c700-hardware.patch
+++ b/packages/qte/qte-2.3.10/c700-hardware.patch
@@ -0,0 +1,110 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.cpp~c700-hardware
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.cpp
+@@ -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"
+@@ -3308,7 +3308,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 ) {
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsmouse_qws.cpp~c700-hardware
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsmouse_qws.cpp
+@@ -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)
+ {
+ Q_UNUSED(dev);
+-#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 defined(QT_QWS_IPAQ)
+ # ifdef QT_QWS_IPAQ_RAW
+ if ((mouseFD = open( "/dev/h3600_tsraw", O_RDONLY | O_NDELAY)) < 0) {
+@@ -1284,7 +1297,7 @@
+ qWarning( "Cannot open /dev/h3600_ts (%s)", strerror(errno));
+ return;
+ }
+-#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
+ if ((mouseFD = open( "/dev/tsraw", O_RDONLY | O_NDELAY)) < 0) {
+@@ -1310,7 +1323,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
+@@ -1318,7 +1331,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;
+
+@@ -1337,7 +1350,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 );
+@@ -1997,7 +2010,7 @@
+ 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)
++#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.10/daemonize.patch b/packages/qte/qte-2.3.10/daemonize.patch
index e69de29bb2..487a18c32a 100644
--- a/packages/qte/qte-2.3.10/daemonize.patch
+++ b/packages/qte/qte-2.3.10/daemonize.patch
@@ -0,0 +1,113 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20041211/src/kernel/qapplication_qws.cpp~daemonize
++++ qt-2.3.9-snapshot-20041211/src/kernel/qapplication_qws.cpp
+@@ -104,6 +104,7 @@
+ #endif
+
+ #include <sys/time.h>
++#include <syslog.h>
+
+ #if defined(_OS_AIX_) && defined(_CC_GNU_)
+ #include <sys/select.h>
+@@ -163,6 +164,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;
+@@ -1686,6 +1688,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" ) {
+@@ -1742,6 +1748,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.10/devfs.patch b/packages/qte/qte-2.3.10/devfs.patch
index e69de29bb2..27ea4239c7 100644
--- a/packages/qte/qte-2.3.10/devfs.patch
+++ b/packages/qte/qte-2.3.10/devfs.patch
@@ -0,0 +1,163 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20050114/configure~devfs
++++ qt-2.3.9-snapshot-20050114/configure
+@@ -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
+--- qt-2.3.9-snapshot-20050114/src/kernel/qgfxlinuxfb_qws.cpp~devfs
++++ qt-2.3.9-snapshot-20050114/src/kernel/qgfxlinuxfb_qws.cpp
+@@ -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);
+@@ -792,7 +816,11 @@
+ fb_var_screeninfo vinfo;
+
+ if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo)) {
++#ifdef QT_QWS_DEVFS
++ perror("reading /dev/fb/0");
++#else
+ perror("reading /dev/fb0");
++#endif
+ qFatal("Error reading fixed information");
+ }
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp~devfs
++++ qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp
+@@ -1192,7 +1192,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;
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.cpp~devfs
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.cpp
+@@ -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!
+--- qt-2.3.9-snapshot-20050114/src/kernel/qsoundqss_qws.cpp~devfs
++++ qt-2.3.9-snapshot-20050114/src/kernel/qsoundqss_qws.cpp
+@@ -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.10/encoding.patch b/packages/qte/qte-2.3.10/encoding.patch
index e69de29bb2..13a48282d1 100644
--- a/packages/qte/qte-2.3.10/encoding.patch
+++ b/packages/qte/qte-2.3.10/encoding.patch
@@ -0,0 +1,34 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20041211/src/tools/qstring.cpp~encoding
++++ qt-2.3.9-snapshot-20041211/src/tools/qstring.cpp
+@@ -14469,7 +14469,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
+ }
+@@ -14515,7 +14519,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.10/fix-linuxfb-setmode.patch b/packages/qte/qte-2.3.10/fix-linuxfb-setmode.patch
index e69de29bb2..212463cb03 100644
--- a/packages/qte/qte-2.3.10/fix-linuxfb-setmode.patch
+++ b/packages/qte/qte-2.3.10/fix-linuxfb-setmode.patch
@@ -0,0 +1,32 @@
+Set lstep properly on a mode change
+Manuel Teira <manuel.teira@telefonica.net>
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp~fix-linuxfb-setmode
++++ qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp
+@@ -791,11 +791,6 @@
+ fb_fix_screeninfo finfo;
+ fb_var_screeninfo vinfo;
+
+- if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo)) {
+- perror("reading /dev/fb0");
+- qFatal("Error reading fixed information");
+- }
+-
+ if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo)) {
+ qFatal("Error reading variable information in mode change");
+ }
+@@ -812,6 +807,10 @@
+ qFatal("Error reading changed variable information in mode change");
+ }
+
++ 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.10/fix-qgfxraster.patch b/packages/qte/qte-2.3.10/fix-qgfxraster.patch
index e69de29bb2..7bc1e2af56 100644
--- a/packages/qte/qte-2.3.10/fix-qgfxraster.patch
+++ b/packages/qte/qte-2.3.10/fix-qgfxraster.patch
@@ -0,0 +1,28 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20041211/src/kernel/qgfxraster_qws.cpp~fix-qgfxraster
++++ qt-2.3.9-snapshot-20041211/src/kernel/qgfxraster_qws.cpp
+@@ -4037,13 +4037,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.10/gcc3.patch b/packages/qte/qte-2.3.10/gcc3.patch
index e69de29bb2..fc1656aa24 100644
--- a/packages/qte/qte-2.3.10/gcc3.patch
+++ b/packages/qte/qte-2.3.10/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.10/increase-qxml-robustness.patch b/packages/qte/qte-2.3.10/increase-qxml-robustness.patch
index e69de29bb2..3a29b4ab03 100644
--- a/packages/qte/qte-2.3.10/increase-qxml-robustness.patch
+++ b/packages/qte/qte-2.3.10/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.10/ipaq-keyboard.patch b/packages/qte/qte-2.3.10/ipaq-keyboard.patch
index e69de29bb2..47474f698e 100644
--- a/packages/qte/qte-2.3.10/ipaq-keyboard.patch
+++ b/packages/qte/qte-2.3.10/ipaq-keyboard.patch
@@ -0,0 +1,27 @@
+Index: qt-2.3.10/src/kernel/qkeyboard_qws.cpp
+===================================================================
+--- qt-2.3.10.orig/src/kernel/qkeyboard_qws.cpp 2005-02-20 13:20:03.285091763 +0100
++++ qt-2.3.10/src/kernel/qkeyboard_qws.cpp 2005-02-20 13:21:49.668213425 +0100
+@@ -527,17 +527,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.10/kernel-keymap-CXK.patch b/packages/qte/qte-2.3.10/kernel-keymap-CXK.patch
index e69de29bb2..6aca81e97d 100644
--- a/packages/qte/qte-2.3.10/kernel-keymap-CXK.patch
+++ b/packages/qte/qte-2.3.10/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.10/kernel-keymap-corgi.patch b/packages/qte/qte-2.3.10/kernel-keymap-corgi.patch
index e69de29bb2..0fabd78fac 100644
--- a/packages/qte/qte-2.3.10/kernel-keymap-corgi.patch
+++ b/packages/qte/qte-2.3.10/kernel-keymap-corgi.patch
@@ -0,0 +1,23 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp~kernel-keymap-corgi
++++ qt-2.3.9-snapshot-20050114/src/kernel/qkeyboard_qws.cpp
+@@ -410,6 +410,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.10/kernel-keymap-tosa.patch b/packages/qte/qte-2.3.10/kernel-keymap-tosa.patch
index e69de29bb2..ca445f4d1d 100644
--- a/packages/qte/qte-2.3.10/kernel-keymap-tosa.patch
+++ b/packages/qte/qte-2.3.10/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.10/kernel-keymap.patch b/packages/qte/qte-2.3.10/kernel-keymap.patch
index e69de29bb2..7b786eb294 100644
--- a/packages/qte/qte-2.3.10/kernel-keymap.patch
+++ b/packages/qte/qte-2.3.10/kernel-keymap.patch
@@ -0,0 +1,1038 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10-snapshot-20050131/src/kernel/qkeyboard_qws.cpp~kernel-keymap
++++ qt-2.3.10-snapshot-20050131/src/kernel/qkeyboard_qws.cpp
+@@ -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 @@
+ };
+ #endif
+
+-#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_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_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
++#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;
+@@ -954,7 +1040,7 @@
+ }
+ } else if ( extended == 2 ) {
+ switch (code) {
+- case 0x1d:
++ case 0x1d:
+ return;
+ case 0x45:
+ keyCode = Qt::Key_Pause;
+@@ -1199,7 +1285,7 @@
+ unicode = '`';
+ } else
+ #endif
+-
++
+ if (bCtrl)
+ unicode = currentKey->ctrl_unicode;
+ else if (bCaps)
+@@ -1244,9 +1330,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 ) {
+@@ -1262,11 +1351,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);
+@@ -1279,6 +1364,9 @@
+ cfsetospeed(&termdata, 9600);
+ tcsetattr(kbdFD, TCSANOW, &termdata);
+
++ readUnicodeMap();
++ readKeyboardMap();
++
+ signal(VTSWITCHSIG, vtSwitchHandler);
+
+ #if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
+@@ -1300,6 +1388,7 @@
+
+ QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler()
+ {
++ restoreLeds();
+ if (kbdFD >= 0)
+ {
+
+@@ -1328,13 +1417,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 {
+@@ -1439,13 +1966,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:
+@@ -1473,14 +2000,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
+ {
+@@ -1845,10 +2372,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() );
+ }
+--- /dev/null
++++ qt-2.3.10-snapshot-20050131/src/kernel/keyboard_linux_to_qt.h
+@@ -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.10/mnci-touchscreen.patch b/packages/qte/qte-2.3.10/mnci-touchscreen.patch
index e69de29bb2..570c2ff290 100644
--- a/packages/qte/qte-2.3.10/mnci-touchscreen.patch
+++ b/packages/qte/qte-2.3.10/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.10/mnci.patch b/packages/qte/qte-2.3.10/mnci.patch
index e69de29bb2..c2e0e079d9 100644
--- a/packages/qte/qte-2.3.10/mnci.patch
+++ b/packages/qte/qte-2.3.10/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.10/no-moc.patch b/packages/qte/qte-2.3.10/no-moc.patch
index e69de29bb2..128f8a6f98 100644
--- a/packages/qte/qte-2.3.10/no-moc.patch
+++ b/packages/qte/qte-2.3.10/no-moc.patch
@@ -0,0 +1,37 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20041211/Makefile~no-moc
++++ qt-2.3.9-snapshot-20041211/Makefile
+@@ -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
+@@ -45,7 +45,6 @@
+
+ clean:
+ -rm .buildopts
+- 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.10/openmn/.mtn2git_empty b/packages/qte/qte-2.3.10/openmn/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/qte/qte-2.3.10/openmn/.mtn2git_empty
diff --git a/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.cpp b/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.cpp
index e69de29bb2..9917675a43 100644
--- a/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.cpp
+++ b/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.cpp
@@ -0,0 +1,584 @@
+/****************************************************************************
+** $Id: qt/src/kernel/qkeyboard_qws.cpp 2.3.7 edited 2003-05-30 $
+**
+** Implementation of Qt/Embedded keyboard drivers
+**
+** Created : 991025
+**
+** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.
+**
+** This file is part of the kernel module of the Qt GUI Toolkit.
+**
+** 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.
+**
+** 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.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+** information about Qt Commercial License Agreements.
+** 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.
+**
+**********************************************************************/
+
+#include "qwindowsystem_qws.h"
+#include "qwsutils_qws.h"
+#include "qgfx_qws.h"
+
+#include <qapplication.h>
+#include <qsocketnotifier.h>
+#include <qnamespace.h>
+#include <qtimer.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+
+#include <unistd.h>
+#include <linux/kd.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <signal.h>
+
+#ifndef QT_NO_QWS_KEYBOARD
+
+#include <termios.h>
+#include <sys/kd.h>
+#include <sys/vt.h>
+#include <sys/wait.h>
+#include <linux/keyboard.h>
+
+#define VTSWITCHSIG SIGUSR2
+
+static bool vtActive = true;
+static int vtQws = 0;
+static int kbdFD = -1;
+
+static QIntDict<QWSServer::KeyMap> *overrideMap = 0;
+
+/*!
+ Changes the mapping of the keyboard; adding the scancode to Unicode
+ mappings from \a map. The server takes over ownership of \a map
+ and will delete it. Use QCollection::setAutoDelete() to control
+ whether the contents of \a map should be deleted.
+
+ Passing a null pointer for \a map will revert to the default keymap.
+*/
+
+void QWSServer::setOverrideKeys( QIntDict<QWSServer::KeyMap> *map )
+{
+ delete overrideMap;
+ overrideMap = map;
+}
+
+/*!
+ \class QWSKeyboardHandler qkeyboard_qws.h
+ \brief Keyboard driver/handler for Qt/Embedded
+
+ The keyboard driver/handler handles events from system devices and
+ generates key events.
+
+ A QWSKeyboardHandler will usually open some system device in its
+ constructor, create a QSocketNotifier on that opened device and when
+ it receives data, it will call processKeyEvent() to send the event
+ to Qt/Embedded for relaying to clients.
+*/
+
+/*!
+ Subclasses call this to send a key event. The server may additionally
+ filter it before sending it on to applications.
+
+ <ul>
+ <li>\a unicode is the Unicode value for the key, or 0xffff if none is appropriate.
+ <li>\a keycode is the Qt keycode for the key (see Qt::Key).
+ for the list of codes).
+ <li>\a modifiers is the set of modifier keys (see Qt::Modifier).
+ <li>\a isPress says whether this is a press or a release.
+ <li>\a autoRepeat says whether this event was generated by an auto-repeat
+ mechanism, or an actual key press.
+ </ul>
+*/
+void QWSKeyboardHandler::processKeyEvent(int unicode, int keycode, int modifiers,
+ bool isPress, bool autoRepeat)
+{
+ qwsServer->processKeyEvent( unicode, keycode, modifiers, isPress, autoRepeat );
+}
+
+
+bool qwsSetKeyboardAutoRepeat( int /* delay */ , int /* period */ )
+{
+ return FALSE;
+}
+
+bool qwsGetKeyboardAutoRepeat( int /* delay */ , int /* period */ )
+{
+ return FALSE;
+}
+
+void qwsRestoreKeyboardLeds()
+{
+}
+
+
+
+
+
+/*
+ * Virtual framebuffer keyboard driver
+ */
+
+class QWSVFbKeyboardHandler : public QWSKeyboardHandler
+{
+ Q_OBJECT
+public:
+ QWSVFbKeyboardHandler();
+ virtual ~QWSVFbKeyboardHandler();
+
+ bool isOpen() { return fd > 0; }
+
+private slots:
+ void readKeyboardData();
+
+private:
+ QString terminalName;
+ int fd;
+ int kbdIdx;
+ int kbdBufferLen;
+ unsigned char *kbdBuffer;
+ QSocketNotifier *notifier;
+};
+
+#ifndef QT_NO_QWS_VFB
+#include "qvfbhdr.h"
+extern int qws_display_id;
+#endif
+
+QWSVFbKeyboardHandler::QWSVFbKeyboardHandler()
+{
+ kbdFD = -1;
+#ifndef QT_NO_QWS_VFB
+ kbdIdx = 0;
+ kbdBufferLen = sizeof( QVFbKeyData ) * 5;
+ kbdBuffer = new unsigned char [kbdBufferLen];
+
+ terminalName = QString(QT_VFB_KEYBOARD_PIPE).arg(qws_display_id);
+
+ if ((kbdFD = open( terminalName.local8Bit(), O_RDWR | O_NDELAY)) < 0) {
+ qDebug( "Cannot open %s (%s)", terminalName.latin1(),
+ strerror(errno));
+ } else {
+ // Clear pending input
+ char buf[2];
+ while (read(kbdFD, buf, 1) > 0) { }
+
+ notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this );
+ connect(notifier, SIGNAL(activated(int)),this, SLOT(readKeyboardData()));
+ }
+#endif
+}
+
+QWSVFbKeyboardHandler::~QWSVFbKeyboardHandler()
+{
+#ifndef QT_NO_QWS_VFB
+ if ( kbdFD >= 0 )
+ close( kbdFD );
+ delete [] kbdBuffer;
+#endif
+}
+
+
+void QWSVFbKeyboardHandler::readKeyboardData()
+{
+#ifndef QT_NO_QWS_VFB
+ int n;
+ do {
+ n = read(kbdFD, kbdBuffer+kbdIdx, kbdBufferLen - kbdIdx );
+ if ( n > 0 )
+ kbdIdx += n;
+ } while ( n > 0 );
+
+ int idx = 0;
+ while ( kbdIdx - idx >= (int)sizeof( QVFbKeyData ) ) {
+ QVFbKeyData *kd = (QVFbKeyData *)(kbdBuffer + idx);
+ if ( kd->unicode == 0 && kd->modifiers == 0 && kd->press ) {
+ // magic exit key
+ qWarning( "Instructed to quit by Virtual Keyboard" );
+ qApp->quit();
+ }
+ processKeyEvent( kd->unicode&0xffff, kd->unicode>>16,
+ kd->modifiers, kd->press, kd->repeat );
+ idx += sizeof( QVFbKeyData );
+ }
+
+ int surplus = kbdIdx - idx;
+ for ( int i = 0; i < surplus; i++ )
+ kbdBuffer[i] = kbdBuffer[idx+i];
+ kbdIdx = surplus;
+#endif
+}
+
+
+
+
+struct termios origTermData;
+
+static void init_kbd(void)
+{
+ struct termios termdata;
+
+ tcgetattr( kbdFD, &origTermData );
+ tcgetattr( kbdFD, &termdata );
+
+ ioctl(kbdFD, KDSKBMODE, K_XLATE);
+
+ termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
+ termdata.c_oflag = 0;
+ termdata.c_cflag = CREAD | CS8;
+ termdata.c_lflag = 0;
+ termdata.c_cc[VTIME]=0;
+ termdata.c_cc[VMIN]=1;
+ cfsetispeed(&termdata, 9600);
+ cfsetospeed(&termdata, 9600);
+ tcsetattr(kbdFD, TCSANOW, &termdata);
+}
+
+static void done_kbd(void)
+{
+ if (kbdFD >= 0) {
+ tcsetattr(kbdFD, TCSANOW, &origTermData);
+ }
+}
+
+static void vtSwitchHandler(int /*sig*/)
+{
+ if (vtActive) {
+ qwsServer->enablePainting(false);
+ qt_screen->save();
+ if (ioctl(kbdFD, VT_RELDISP, VT_ACKACQ) == 0) {
+ vtActive = false;
+ qwsServer->closeMouse();
+ done_kbd();
+ }
+ else {
+ qwsServer->enablePainting(true);
+ }
+ usleep(200000);
+ }
+ else {
+ if (ioctl(kbdFD, VT_RELDISP, VT_ACKACQ) == 0) {
+ init_kbd();
+ qwsServer->enablePainting(true);
+ vtActive = true;
+ qt_screen->restore();
+ qwsServer->openMouse();
+ qwsServer->refresh();
+ }
+ }
+ signal(VTSWITCHSIG, vtSwitchHandler);
+}
+
+
+
+class QWSRamsesKbPrivate;
+class QWSRamsesKeyboardHandler : public QWSKeyboardHandler
+{
+public:
+ QWSRamsesKeyboardHandler( const QString& );
+ virtual ~QWSRamsesKeyboardHandler();
+
+ virtual void processKeyEvent(int unicode, int keycode, int modifiers,
+ bool isPress, bool autoRepeat);
+
+private:
+ QWSRamsesKbPrivate *d;
+};
+
+
+class QWSRamsesKbPrivate : public QObject
+{
+ Q_OBJECT
+public:
+ QWSRamsesKbPrivate( QWSRamsesKeyboardHandler *, const QString &device );
+ ~QWSRamsesKbPrivate();
+
+private slots:
+ void readKeyboardData();
+
+private:
+ void handleKey(unsigned char code, int n);
+
+ QWSRamsesKeyboardHandler *handler;
+ char rbuf[255];
+ int rptr;
+};
+
+QWSRamsesKbPrivate::QWSRamsesKbPrivate( QWSRamsesKeyboardHandler *h, const QString &device )
+ : handler(h), rptr(0)
+{
+#ifdef QT_QWS_DEVFS
+ kbdFD = ::open(device.isEmpty()?"/dev/vc/2":device.latin1(), O_RDWR|O_NDELAY, 0);
+#else
+ kbdFD = ::open(device.isEmpty()?"/dev/tty2":device.latin1(), O_RDWR|O_NDELAY, 0);
+#endif
+
+ if ( kbdFD >= 0 ) {
+ QSocketNotifier *notifier;
+ notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this );
+ connect( notifier, SIGNAL(activated(int)),this, SLOT(readKeyboardData()) );
+ } else {
+ qDebug( "Cannot open keyboard" );
+ }
+ init_kbd();
+
+ struct vt_mode vtMode;
+ ioctl(kbdFD, VT_GETMODE, &vtMode);
+
+ // let us control VT switching
+ vtMode.mode = VT_PROCESS;
+ vtMode.relsig = VTSWITCHSIG;
+ vtMode.acqsig = VTSWITCHSIG;
+ ioctl(kbdFD, VT_SETMODE, &vtMode);
+
+ struct vt_stat vtStat;
+ ioctl(kbdFD, VT_GETSTATE, &vtStat);
+ vtQws = vtStat.v_active;
+
+ signal(VTSWITCHSIG, vtSwitchHandler);
+}
+
+QWSRamsesKbPrivate::~QWSRamsesKbPrivate()
+{
+ signal(VTSWITCHSIG, 0);
+
+ done_kbd();
+
+ 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);
+
+ ::close(kbdFD);
+ kbdFD = -1;
+}
+
+
+static inline int map_to_modif(int current_map)
+{
+ int modifiers = 0;
+
+ if (current_map & KG_ALT)
+ modifiers |= Qt::ALT;
+ else if (current_map & KG_CTRL)
+ modifiers |= Qt::CTRL;
+ else if (current_map & KG_SHIFT)
+ modifiers |= Qt::SHIFT;
+
+ return modifiers;
+}
+
+struct {
+ const char *code;
+ unsigned short qtcode;
+} qtesc_lookup[] = {
+ { "\e[A", Qt::Key_Up },
+ { "\e[B", Qt::Key_Down },
+ { "\e[C", Qt::Key_Right },
+ { "\e[D", Qt::Key_Left },
+ { "\e[1~", Qt::Key_Home },
+ { "\e[4~", Qt::Key_End },
+ { "\e[5~", Qt::Key_PageUp },
+ { "\e[6~", Qt::Key_PageDown },
+
+ { "\e[[A", Qt::Key_F1 },
+ { "\e[[B", Qt::Key_F2 },
+ { "\e[[C", Qt::Key_F3 },
+ { "\e[[D", Qt::Key_F4 },
+ { "\e[[E", Qt::Key_F5 },
+ { "\e[17~", Qt::Key_F6 },
+ { "\e[18~", Qt::Key_F7 },
+ { "\e[19~", Qt::Key_F8 },
+ { "\e[20~", Qt::Key_F9 },
+ { "\e[21~", Qt::Key_F10 },
+ { "\e[23~", Qt::Key_F11 },
+ { "\e[24~", Qt::Key_F12 },
+
+ // { "\ex", Qt::FieldExit },
+ // { "\er", Qt::FieldReset },
+
+};
+
+struct {
+ unsigned char code;
+ unsigned short qtcode;
+} qtkey_lookup[] = {
+ { 0x08, Qt::Key_Backspace },
+ { 0x09, Qt::Key_Tab },
+ { 0x0d, Qt::Key_Enter },
+ { 0x1b, Qt::Key_Escape },
+};
+
+void QWSRamsesKbPrivate::handleKey(unsigned char code, int n)
+{
+ int qtKeyCode = Qt::Key_unknown;
+ unsigned int i;
+
+ //qDebug("\nhandleKey %02x %d %c", code, n, code >= ' ' ? code : ' ');
+
+ // Single keys
+ if ((n==1) && (rptr==0)) {
+ qtKeyCode = code;
+ for (i=0; i < sizeof(qtkey_lookup)/sizeof(qtkey_lookup[0]); i++) {
+ if (qtkey_lookup[i].code == code) {
+ qtKeyCode = qtkey_lookup[i].qtcode;
+ code = 0;
+ break;
+ }
+ }
+ } else
+
+ // Alt-<KEY> sequence
+ if ((n==1) && (rptr==1) && (rbuf[0] == '\e')) {
+ //qDebug("alt-key %d", code);
+ handler->processKeyEvent(0, Qt::Key_Alt, 0, 1, 0);
+ handler->processKeyEvent(0, code-32, Qt::ALT, 1, 0);
+ handler->processKeyEvent(0, code-32, Qt::ALT, 0, 0);
+ handler->processKeyEvent(0, Qt::Key_Alt, 0, 0, 0);
+ rptr = 0;
+ return;
+ } else
+
+ // End of a function key sequence
+ if ((n==1) && (rptr!=0)) {
+ rbuf[rptr++] = code;
+ rbuf[rptr] = 0;
+ for (i=0; i < sizeof(qtesc_lookup)/sizeof(qtesc_lookup[0]); i++) {
+ if (strncmp(rbuf, qtesc_lookup[i].code, sizeof(rbuf)) == 0) {
+ qtKeyCode = qtesc_lookup[i].qtcode;
+ code = 0;
+ break;
+ }
+ }
+ if (code != 0) {
+ //qWarning("no entry in key sequence table for %s", &rbuf[1]);
+ int oldrptr = rptr;
+ rptr = 0;
+ for (i=0; i <= oldrptr; i++) {
+ handleKey(rbuf[i], 1);
+ }
+ return;
+ }
+ rptr = 0;
+ } else
+
+ // Middle of a function key sequence
+ {
+ if (rptr < sizeof(rbuf))
+ rbuf[rptr++] = code;
+ return;
+ }
+
+ //qDebug(" code 0x%2x %d -> qtKeyCode 0x%04x", code, code, qtKeyCode);
+
+ handler->processKeyEvent(code, qtKeyCode, 0, 1, 0);
+ handler->processKeyEvent(code, qtKeyCode, 0, 0, 0);
+}
+
+
+void QWSRamsesKbPrivate::readKeyboardData()
+{
+ unsigned char buf[81];
+ int n = read(kbdFD, buf, 80 );
+ for ( int loop = 0; loop < n; loop++ ) {
+ handleKey(buf[loop], n-loop);
+ }
+}
+
+
+
+
+
+QWSRamsesKeyboardHandler::QWSRamsesKeyboardHandler( const QString &device )
+{
+ d = new QWSRamsesKbPrivate( this, device );
+}
+
+QWSRamsesKeyboardHandler::~QWSRamsesKeyboardHandler()
+{
+ delete d;
+}
+
+void QWSRamsesKeyboardHandler::processKeyEvent(int unicode, int keycode,
+ int modifiers, bool isPress, bool autoRepeat)
+{
+ // Virtual console switching
+ int term = 0;
+ bool ctrl = modifiers & Qt::ControlButton;
+ bool alt = modifiers & Qt::AltButton;
+ if (ctrl && alt && keycode >= Qt::Key_F1 && keycode <= Qt::Key_F10)
+ term = keycode - Qt::Key_F1 + 1;
+ else if (ctrl && alt && keycode == Qt::Key_Left)
+ term = QMAX(vtQws - 1, 1);
+ else if (ctrl && alt && keycode == Qt::Key_Right)
+ term = QMIN(vtQws + 1, 10);
+ if (term && !isPress) {
+ ioctl(kbdFD, VT_ACTIVATE, term);
+ return;
+ }
+
+ QWSKeyboardHandler::processKeyEvent( unicode, keycode, modifiers, isPress, autoRepeat );
+}
+
+
+
+/*
+ * keyboard driver instantiation
+ */
+
+QWSKeyboardHandler *QWSServer::newKeyboardHandler( const QString &spec )
+{
+ QWSKeyboardHandler *handler = 0;
+
+ QString device;
+ QString type;
+ int colon=spec.find(':');
+ if ( colon>=0 ) {
+ type = spec.left(colon);
+ device = spec.mid(colon+1);
+ } else {
+ type = spec;
+ }
+
+ if ( type == "QVFbKeyboard" ) {
+ handler = new QWSVFbKeyboardHandler();
+ } else if ( type == "TTY" ) {
+ handler = new QWSRamsesKeyboardHandler(device);
+ } else {
+ qWarning( "Keyboard type %s:%s unsupported", spec.latin1(), device.latin1() );
+ }
+
+ return handler;
+}
+
+#include "qkeyboard_qws.moc"
+
+#endif // QT_NO_QWS_KEYBOARD
+
+
diff --git a/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.h b/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.h
index e69de29bb2..aa459d1448 100644
--- a/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.h
+++ b/packages/qte/qte-2.3.10/openmn/qkeyboard_qws.h
@@ -0,0 +1,56 @@
+/****************************************************************************
+** $Id: qt/src/kernel/qkeyboard_qws.h 2.3.10 edited 2005-01-24 $
+**
+** Definition of Qt/Embedded keyboards
+**
+** Created : 991025
+**
+** Copyright (C) 1992-2000 Trolltech AS. All rights reserved.
+**
+** This file is part of the kernel module of the Qt GUI Toolkit.
+**
+** 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.
+**
+** 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.
+**
+** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
+** information about Qt Commercial License Agreements.
+** 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 QKEYBOARD_QWS_H
+#define QKEYBOARD_QWS_H
+
+#ifndef QT_H
+#include "qobject.h"
+#endif // QT_H
+
+#ifndef QT_NO_QWS_KEYBOARD
+class Q_EXPORT QWSKeyboardHandler : public QObject {
+ Q_OBJECT
+public:
+ QWSKeyboardHandler();
+ virtual ~QWSKeyboardHandler();
+
+protected:
+ virtual void processKeyEvent(int unicode, int keycode, int modifiers,
+ bool isPress, bool autoRepeat);
+};
+#endif
+
+Q_EXPORT bool qwsSetKeyboardAutoRepeat( int delay, int period );
+Q_EXPORT bool qwsGetKeyboardAutoRepeat( int *delay, int *period );
+
+#endif
diff --git a/packages/qte/qte-2.3.10/qiconview-speed.patch b/packages/qte/qte-2.3.10/qiconview-speed.patch
index e69de29bb2..bac9b9705f 100644
--- a/packages/qte/qte-2.3.10/qiconview-speed.patch
+++ b/packages/qte/qte-2.3.10/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.10/qpe.patch b/packages/qte/qte-2.3.10/qpe.patch
index e69de29bb2..af2e31664a 100644
--- a/packages/qte/qte-2.3.10/qpe.patch
+++ b/packages/qte/qte-2.3.10/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.10/qt-visibility.patch b/packages/qte/qte-2.3.10/qt-visibility.patch
index e69de29bb2..ccdebb0c40 100644
--- a/packages/qte/qte-2.3.10/qt-visibility.patch
+++ b/packages/qte/qte-2.3.10/qt-visibility.patch
@@ -0,0 +1,459 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20050114/configure~qt-visibility
++++ qt-2.3.9-snapshot-20050114/configure
+@@ -409,6 +409,9 @@
+ -tslib)
+ TSLIB=yes
+ ;;
++ -visibility-hidden)
++ VISIBILITY=YES
++ ;;
+ -no-g++-exceptions)
+ GPLUSPLUS_EXCEPTIONS=no
+ ;;
+@@ -1296,6 +1299,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.
+
+@@ -1364,6 +1370,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
+--- qt-2.3.9-snapshot-20050114/src/tools/qglobal.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/tools/qglobal.h
+@@ -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
+--- qt-2.3.9-snapshot-20050114/src/widgets/qscrollview.cpp~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/widgets/qscrollview.cpp
+@@ -696,7 +696,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
+--- qt-2.3.9-snapshot-20050114/src/Makefile.in~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/Makefile.in
+@@ -641,7 +641,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
+--- qt-2.3.9-snapshot-20050114/src/kernel/qcopchannel_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qcopchannel_qws.h
+@@ -42,7 +42,7 @@
+ class QCopChannelPrivate;
+ class QWSClient;
+
+-class QCopChannel : public QObject
++class Q_EXPORT QCopChannel : public QObject
+ {
+ Q_OBJECT
+ public:
+--- qt-2.3.9-snapshot-20050114/src/kernel/qfontmanager_qws.cpp~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qfontmanager_qws.cpp
+@@ -68,7 +68,7 @@
+ return r;
+ }
+
+-QFontManager * qt_fontmanager=0;
++QFontManager Q_EXPORT *qt_fontmanager=0;
+
+ /*!
+ \class QFontManager qfontmanager_qws.h
+--- qt-2.3.9-snapshot-20050114/src/kernel/qgfx_qws.cpp~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qgfx_qws.cpp
+@@ -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
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.cpp~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.cpp
+@@ -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
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsdecoration_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsdecoration_qws.h
+@@ -41,7 +41,7 @@
+ /*
+ Implements decoration styles
+ */
+-class QWSDecoration
++class Q_EXPORT QWSDecoration
+ {
+ public:
+ QWSDecoration() {}
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwindowsystem_qws.h
+@@ -67,7 +67,7 @@
+
+ struct QWSWindowData;
+
+-class QWSScreenSaver
++class Q_EXPORT QWSScreenSaver
+ {
+ public:
+ virtual ~QWSScreenSaver();
+@@ -75,7 +75,7 @@
+ virtual bool save(int level)=0;
+ };
+
+-class QWSWindow
++class Q_EXPORT QWSWindow
+ {
+ friend class QWSServer;
+ public:
+@@ -169,9 +169,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;
+@@ -501,7 +501,7 @@
+
+
+ #ifndef QT_NO_QWS_IM
+-class QWSInputMethod : public QObject
++class Q_EXPORT QWSInputMethod : public QObject
+ {
+ public:
+ QWSInputMethod();
+@@ -525,7 +525,7 @@
+ #endif
+
+ #ifndef QT_NO_QWS_FSIM
+-class QWSGestureMethod : public QObject
++class Q_EXPORT QWSGestureMethod : public QObject
+ {
+ public:
+ QWSGestureMethod();
+@@ -573,7 +573,7 @@
+
+ typedef QMap<int, QWSCursor*> QWSCursorMap;
+
+-class QWSClient : public QObject
++class Q_EXPORT QWSClient : public QObject
+ {
+ Q_OBJECT
+ public:
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsdefaultdecoration_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsdefaultdecoration_qws.h
+@@ -44,7 +44,7 @@
+
+
+
+-class QWSDefaultDecoration : public QWSDecoration
++class Q_EXPORT QWSDefaultDecoration : public QWSDecoration
+ {
+ public:
+ QWSDefaultDecoration();
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwscommand_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwscommand_qws.h
+@@ -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 ),
+--- qt-2.3.9-snapshot-20050114/src/kernel/qfont_qws.cpp~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qfont_qws.cpp
+@@ -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()
+ {
+ QFontDictIt it( *fontDict );
+ while ( it.current() ) {
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwscursor_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwscursor_qws.h
+@@ -37,7 +37,7 @@
+ #include <qimage.h>
+ #endif // QT_H
+
+-class QWSCursor : public Qt
++class Q_EXPORT QWSCursor : public Qt
+ {
+ public:
+ QWSCursor() {}
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsevent_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsevent_qws.h
+@@ -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 ) { }
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsmanager_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsmanager_qws.h
+@@ -48,7 +48,7 @@
+ class QWSButton;
+ class QWSManager;
+
+-class QWSManager : public QObject
++class Q_EXPORT QWSManager : public QObject
+ {
+ Q_OBJECT
+
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsmouse_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsmouse_qws.h
+@@ -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();
+--- qt-2.3.9-snapshot-20050114/src/kernel/qwsproperty_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qwsproperty_qws.h
+@@ -47,7 +47,7 @@
+
+ class QWSPropertyManagerData;
+
+-class QWSPropertyManager
++class Q_EXPORT QWSPropertyManager
+ {
+ public:
+ enum Mode {
+--- qt-2.3.9-snapshot-20050114/src/kernel/qlayoutengine.cpp~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qlayoutengine.cpp
+@@ -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;
+--- qt-2.3.9-snapshot-20050114/src/kernel/qfontmanager_qws.h~qt-visibility
++++ qt-2.3.9-snapshot-20050114/src/kernel/qfontmanager_qws.h
+@@ -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.10/qtabbar.patch b/packages/qte/qte-2.3.10/qtabbar.patch
index e69de29bb2..6940ec9b25 100644
--- a/packages/qte/qte-2.3.10/qtabbar.patch
+++ b/packages/qte/qte-2.3.10/qtabbar.patch
@@ -0,0 +1,39 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/widgets/qtabbar.cpp~qtabbar
++++ qt-2.3.10/src/widgets/qtabbar.cpp
+@@ -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();
+ }
+
+ /*!
+@@ -977,7 +976,6 @@
+ d->leftB->setGeometry( width() - 2*arrowWidth, 0, arrowWidth, height() );
+ #endif
+ layoutTabs();
+- updateArrowButtons();
+ makeVisible( tab( currentTab() ));
+ }
+
diff --git a/packages/qte/qte-2.3.10/qte-fix-iconsize.patch b/packages/qte/qte-2.3.10/qte-fix-iconsize.patch
index e69de29bb2..cc14315bd0 100644
--- a/packages/qte/qte-2.3.10/qte-fix-iconsize.patch
+++ b/packages/qte/qte-2.3.10/qte-fix-iconsize.patch
@@ -0,0 +1,99 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.10/src/widgets/qpopupmenu.cpp~qte-iconsize
++++ qt-2.3.10/src/widgets/qpopupmenu.cpp
+@@ -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();
+--- qt-2.3.10/src/widgets/qtabbar.cpp~qte-iconsize
++++ qt-2.3.10/src/widgets/qtabbar.cpp
+@@ -414,8 +414,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;
+ }
+@@ -442,7 +442,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 );
+@@ -871,8 +875,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;
+ }
+@@ -915,8 +919,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;
+ }
+--- qt-2.3.10/src/widgets/qwindowsstyle.cpp~qte-iconsize
++++ qt-2.3.10/src/widgets/qwindowsstyle.cpp
+@@ -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.10/sharp_char.h b/packages/qte/qte-2.3.10/sharp_char.h
index e69de29bb2..a70f5f690e 100644
--- a/packages/qte/qte-2.3.10/sharp_char.h
+++ b/packages/qte/qte-2.3.10/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.10/switches.h b/packages/qte/qte-2.3.10/switches.h
index e69de29bb2..37516b4c75 100644
--- a/packages/qte/qte-2.3.10/switches.h
+++ b/packages/qte/qte-2.3.10/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.10/vt-switch.patch b/packages/qte/qte-2.3.10/vt-switch.patch
index e69de29bb2..4007a5d9f6 100644
--- a/packages/qte/qte-2.3.10/vt-switch.patch
+++ b/packages/qte/qte-2.3.10/vt-switch.patch
@@ -0,0 +1,178 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-2.3.9-snapshot-20041221/src/kernel/qapplication_qws.cpp~vt-switch.patch
++++ qt-2.3.9-snapshot-20041221/src/kernel/qapplication_qws.cpp
+@@ -124,6 +124,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
+@@ -164,6 +170,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;
+@@ -1700,6 +1708,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];
+@@ -1724,6 +1741,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);
+ }
+@@ -1774,7 +1838,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;
+--- qt-2.3.9-snapshot-20041221/src/kernel/qkeyboard_qws.cpp~vt-switch.patch
++++ qt-2.3.9-snapshot-20041221/src/kernel/qkeyboard_qws.cpp
+@@ -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
+--- qt-2.3.9-snapshot-20041221/src/kernel/qgfxlinuxfb_qws.cpp~vt-switch.patch
++++ qt-2.3.9-snapshot-20041221/src/kernel/qgfxlinuxfb_qws.cpp
+@@ -251,9 +251,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;
diff --git a/packages/qte/qte-4.0.0-snapshot/.mtn2git_empty b/packages/qte/qte-4.0.0-snapshot/.mtn2git_empty
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/packages/qte/qte-4.0.0-snapshot/.mtn2git_empty
diff --git a/packages/qte/qte-4.0.0-snapshot/add-qatomic.patch b/packages/qte/qte-4.0.0-snapshot/add-qatomic.patch
index e69de29bb2..8fea162691 100644
--- a/packages/qte/qte-4.0.0-snapshot/add-qatomic.patch
+++ b/packages/qte/qte-4.0.0-snapshot/add-qatomic.patch
@@ -0,0 +1,72 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- /dev/null
++++ qt-embedded-opensource-4.0.0-b1/src/core/arch/arm/qatomic.cpp
+@@ -0,0 +1,64 @@
++#include <qhash.h>
++
++#define UNLOCKED {-1,-1,-1,-1}
++#define UNLOCKED2 UNLOCKED,UNLOCKED
++#define UNLOCKED4 UNLOCKED2,UNLOCKED2
++#define UNLOCKED8 UNLOCKED4,UNLOCKED4
++#define UNLOCKED16 UNLOCKED8,UNLOCKED8
++#define UNLOCKED32 UNLOCKED16,UNLOCKED16
++#define UNLOCKED64 UNLOCKED32,UNLOCKED32
++#define UNLOCKED128 UNLOCKED64,UNLOCKED64
++#define UNLOCKED256 UNLOCKED128,UNLOCKED128
++
++// use a 4k page for locks
++static int locks[256][4] = { UNLOCKED256 };
++
++int *getLock(volatile void *addr)
++{ return locks[qHash(const_cast<void *>(addr)) % 256]; }
++
++static int *align16(int *lock)
++{
++ ulong off = (((ulong) lock) % 16);
++ return off ? (int *)(ulong(lock) + 16 - off) : lock;
++}
++
++extern "C" {
++
++ int q_ldcw(volatile int *addr);
++
++ void q_atomic_lock(int *lock)
++ {
++ // ldcw requires a 16-byte aligned address
++ volatile int *x = align16(lock);
++ // FIXME WHERE IS q_ldcw ??? while (q_ldcw(x) == 0)
++ ;
++ }
++
++ void q_atomic_unlock(int *lock)
++ { lock[0] = lock[1] = lock[2] = lock[3] = -1; }
++
++ int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
++ {
++ int *lock = getLock(ptr);
++ q_atomic_lock(lock);
++ if (*reinterpret_cast<void * volatile *>(ptr) == expected) {
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ q_atomic_unlock(lock);
++ return 1;
++ }
++ q_atomic_unlock(lock);
++ return 0;
++ }
++
++ void *q_atomic_set_ptr(volatile void *ptr, void *newval)
++ {
++ int *lock = getLock(ptr);
++ q_atomic_lock(lock);
++ void *oldval = *reinterpret_cast<void * volatile *>(ptr);
++ *reinterpret_cast<void * volatile *>(ptr) = newval;
++ q_atomic_unlock(lock);
++ return oldval;
++ }
++
++}
++
diff --git a/packages/qte/qte-4.0.0-snapshot/fix-qwidget.patch b/packages/qte/qte-4.0.0-snapshot/fix-qwidget.patch
index e69de29bb2..4cd174f574 100644
--- a/packages/qte/qte-4.0.0-snapshot/fix-qwidget.patch
+++ b/packages/qte/qte-4.0.0-snapshot/fix-qwidget.patch
@@ -0,0 +1,17 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-embedded-opensource-4.0.0-b1/src/gui/kernel/qwidget.cpp~fix-qwidget
++++ qt-embedded-opensource-4.0.0-b1/src/gui/kernel/qwidget.cpp
+@@ -6272,7 +6272,9 @@
+ ic->update();
+ #endif
+ // ##### is this correct
++#ifndef QT_NO_ACCESSIBILITY
+ QAccessible::updateAccessibility(this, 0, QAccessible::StateChanged);
++#endif
+ }
+
+
diff --git a/packages/qte/qte-4.0.0-snapshot/fix-qwsmanager.patch b/packages/qte/qte-4.0.0-snapshot/fix-qwsmanager.patch
index e69de29bb2..f676f0e09c 100644
--- a/packages/qte/qte-4.0.0-snapshot/fix-qwsmanager.patch
+++ b/packages/qte/qte-4.0.0-snapshot/fix-qwsmanager.patch
@@ -0,0 +1,18 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-embedded-opensource-4.0.0-b1/src/gui/kernel/qapplication_p.h~fix-qwsmanager
++++ qt-embedded-opensource-4.0.0-b1/src/gui/kernel/qapplication_p.h
+@@ -41,7 +41,9 @@
+ #include "qmutex.h"
+ #include "qtranslator.h"
+ #include "qshortcutmap_p.h"
+-
++#ifdef Q_WS_QWS
++#include "qwsmanager_qws.h"
++#endif
+ #include <private/qcoreapplication_p.h>
+ #include "qapplication.h"
+ #include "qbasictimer.h"
diff --git a/packages/qte/qte-4.0.0-snapshot/fix-sl5000driver.patch b/packages/qte/qte-4.0.0-snapshot/fix-sl5000driver.patch
index e69de29bb2..8f25031d7d 100644
--- a/packages/qte/qte-4.0.0-snapshot/fix-sl5000driver.patch
+++ b/packages/qte/qte-4.0.0-snapshot/fix-sl5000driver.patch
@@ -0,0 +1,29 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-embedded-opensource-4.0.0-b1/src/gui/embedded/qkbdsl5000_qws.cpp~fix-sl5000driver
++++ qt-embedded-opensource-4.0.0-b1/src/gui/embedded/qkbdsl5000_qws.cpp
+@@ -219,7 +219,7 @@
+ else if (code == 0x44) { unicode='V'-'@'; scan=Qt::Key_V; } // Paste
+ else if (code == 0x52) { unicode='Z'-'@'; scan=Qt::Key_Z; } // Undo
+ if (scan) {
+- processKeyEvent(unicode, scan, Qt::ControlButton, !release, false);
++ processKeyEvent(unicode, scan, Qt::ControlModifier, !release, false);
+ return;
+ }
+ }
+@@ -307,9 +307,9 @@
+ }
+
+ modifiers = 0;
+- if (bAlt) modifiers |= Qt::AltButton;
+- if (bCtrl) modifiers |= Qt::ControlButton;
+- if (bShift) modifiers |= Qt::ShiftButton;
++ if (bAlt) modifiers |= Qt::AltModifier;
++ if (bCtrl) modifiers |= Qt::ControlModifier;
++ if (bShift) modifiers |= Qt::ShiftModifier;
+
+ // looks wrong -- WWA
+ bool repeat = false;
diff --git a/packages/qte/qte-4.0.0-snapshot/fix-vncdriver.patch b/packages/qte/qte-4.0.0-snapshot/fix-vncdriver.patch
index e69de29bb2..8c48083a8b 100644
--- a/packages/qte/qte-4.0.0-snapshot/fix-vncdriver.patch
+++ b/packages/qte/qte-4.0.0-snapshot/fix-vncdriver.patch
@@ -0,0 +1,16 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-embedded-opensource-4.0.0-b1/src/gui/embedded/qgfxvnc_qws.cpp~fix-vncdriver
++++ qt-embedded-opensource-4.0.0-b1/src/gui/embedded/qgfxvnc_qws.cpp
+@@ -31,7 +31,7 @@
+ #include "qgfxvnc_qws.h"
+ #include <private/qsharedmemory_p.h>
+ #include <stdlib.h>
+-
++#include <stdio.h>
+ extern QString qws_qtePipeFilename();
+
+ #define MAP_TILE_SIZE 16
diff --git a/packages/qte/qte-4.0.0-snapshot/gcc34.patch b/packages/qte/qte-4.0.0-snapshot/gcc34.patch
index e69de29bb2..603e230dd5 100644
--- a/packages/qte/qte-4.0.0-snapshot/gcc34.patch
+++ b/packages/qte/qte-4.0.0-snapshot/gcc34.patch
@@ -0,0 +1,26 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-embedded-opensource-4.0.0-b1/src/core/tools/qchar.h~gcc34
++++ qt-embedded-opensource-4.0.0-b1/src/core/tools/qchar.h
+@@ -197,7 +197,7 @@
+ const char ascii() const;
+ const char latin1() const;
+ inline const ushort unicode() const { return ucs; }
+- inline ushort &unicode() { return ucs; }
++ inline ushort &unicode() { return *(&ucs); }
+
+ static QChar fromAscii(char c);
+ static QChar fromLatin1(char c);
+--- qt-embedded-opensource-4.0.0-b1/src/gui/embedded/qgfxlinuxfb_qws.cpp~gcc34
++++ qt-embedded-opensource-4.0.0-b1/src/gui/embedded/qgfxlinuxfb_qws.cpp
+@@ -31,6 +31,7 @@
+
+ #include <unistd.h>
+ #include <stdlib.h>
++#include <stdio.h>
+ #include <sys/ioctl.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
diff --git a/packages/qte/qte-4.0.0-snapshot/no-moc-no-uic-no-rcc.patch b/packages/qte/qte-4.0.0-snapshot/no-moc-no-uic-no-rcc.patch
index e69de29bb2..2f99979319 100644
--- a/packages/qte/qte-4.0.0-snapshot/no-moc-no-uic-no-rcc.patch
+++ b/packages/qte/qte-4.0.0-snapshot/no-moc-no-uic-no-rcc.patch
@@ -0,0 +1,25 @@
+
+#
+# Patch managed by http://www.holgerschurig.de/patcher.html
+#
+
+--- qt-embedded-opensource-4.0.0-b1/src/src.pro~no-moc-no-uic-no-rcc
++++ qt-embedded-opensource-4.0.0-b1/src/src.pro
+@@ -3,16 +3,13 @@
+
+ # this order is important
+ win32:SUBDIRS += winmain
+-SUBDIRS += moc core gui sql
++SUBDIRS += core gui sql
+ contains(QT_CONFIG, opengl): SUBDIRS += opengl
+ SUBDIRS += xml network
+ contains(QT_CONFIG, compat): SUBDIRS += compat
+
+ SUBDIRS += plugins
+
+-embedded:SUBDIRS -= opengl
+-SUBDIRS += tools
+-
+ # This gives us a top level debug/release
+ unix {
+ EXTRA_DEBUG_TARGETS =
diff --git a/packages/qte/qte-4.0.0-snapshot/sharp_char.h b/packages/qte/qte-4.0.0-snapshot/sharp_char.h
index e69de29bb2..a70f5f690e 100644
--- a/packages/qte/qte-4.0.0-snapshot/sharp_char.h
+++ b/packages/qte/qte-4.0.0-snapshot/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-4.0.0-snapshot/switches.h b/packages/qte/qte-4.0.0-snapshot/switches.h
index e69de29bb2..37516b4c75 100644
--- a/packages/qte/qte-4.0.0-snapshot/switches.h
+++ b/packages/qte/qte-4.0.0-snapshot/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-4.0.0-snapshot/update-qtfontdir b/packages/qte/qte-4.0.0-snapshot/update-qtfontdir
index e69de29bb2..6df7b503af 100644..100755
--- a/packages/qte/qte-4.0.0-snapshot/update-qtfontdir
+++ b/packages/qte/qte-4.0.0-snapshot/update-qtfontdir
@@ -0,0 +1,62 @@
+#!/bin/sh
+
+usage()
+{
+ echo "usage: $0 [font directory, defaults to QTDIR/lib/fonts]"
+ exit 1
+}
+
+setVar()
+{
+ eval "$1='$2'"
+}
+
+getVar()
+{
+ eval "echo \$$1"
+}
+
+handleQPF()
+{
+ base=`basename $1`
+ family=`echo $base|cut -d_ -f1`
+ pt=`echo $base|cut -d_ -f2`
+ weight=`echo $base|cut -d_ -f3|sed -e 's,i$,,'`
+ if (echo $base|cut -d_ -f3|grep -q 'i$'); then
+ italic="y"
+ else
+ italic="n"
+ fi
+ echo "$family $base.qpf QPF $italic $weight $pt u"
+}
+
+if [ -z "$1" ]; then
+ if [ -n "$QTDIR" ]; then
+ fontdir=$QTDIR/lib/fonts
+ else
+ fontdir=/opt/QtPalmtop/lib/fonts
+ fi
+else
+ fontdir=$1
+fi
+
+if ! [ -d $fontdir ]; then
+ echo Error: $fontdir not a directory
+ exit 1
+fi
+
+if [ -e $fontdir/fontdir ]; then
+ cat $fontdir/fontdir | grep -v '\.qpf' > $fontdir/fontdir.new
+fi
+
+(
+ for file in `ls $fontdir/*.qpf|sed -e's,\.qpf$,,; s,_t[^_]*$,,;'|sort -u`; do
+ handleQPF $file
+ done
+) >> $fontdir/fontdir.new
+
+mv $fontdir/fontdir.new $fontdir/fontdir
+
+exit 0
+
+# vim:ai:et:sts=4:sw=4:tw=0:
generated by cgit 1.2.3-korg (git 2.39.0) at 2024-04-28 02:27:37 +0000