From e9b45ff67d32fdc27950a51135b6dabada8334e7 Mon Sep 17 00:00:00 2001 From: Paul Eggleton Date: Sun, 24 Jul 2011 17:57:24 +0100 Subject: initial commit of meta-opie Populate the repository with files from OpenEmbedded at revision 45edf621296daf150c72b876d720861235e5762e - no changes, only rearranged the directory structure to match the new oe-core style and added COPYING.MIT and README. Signed-off-by: Paul Eggleton --- recipes-qt/qte/qte-2.3.10/bidimetrics.patch | 2389 ++++++++++++++ recipes-qt/qte/qte-2.3.10/c7x0-w100-accel.patch | 3404 ++++++++++++++++++++ recipes-qt/qte/qte-2.3.10/c7x0-w100-gcc4.patch | 31 + recipes-qt/qte/qte-2.3.10/daemonize.patch | 113 + .../qte/qte-2.3.10/disable-dup-rotation.patch | 13 + recipes-qt/qte/qte-2.3.10/encoding.patch | 34 + .../qte/qte-2.3.10/fix-errno-exception-spec.patch | 16 + .../qte-2.3.10/fix-linuxfb-offscreenoverflow.patch | 22 + .../qte/qte-2.3.10/fix-linuxfb-setmode.patch | 32 + recipes-qt/qte/qte-2.3.10/fix-native-build.patch | 11 + recipes-qt/qte/qte-2.3.10/fix-qgfxraster.patch | 28 + recipes-qt/qte/qte-2.3.10/fix-qscreen-sync.patch | 17 + .../qte/qte-2.3.10/fix-qte-asm-include.patch | 19 + recipes-qt/qte/qte-2.3.10/gcc3.patch | 27 + recipes-qt/qte/qte-2.3.10/gcc4.patch | 16 + recipes-qt/qte/qte-2.3.10/handhelds.patch | 60 + .../qte/qte-2.3.10/improve-calibration-r0.patch | 159 + .../qte/qte-2.3.10/increase-qxml-robustness.patch | 17 + recipes-qt/qte/qte-2.3.10/ipaq_sound_fix.patch | 60 + .../qte/qte-2.3.10/kernel-keymap-corgi.patch | 23 + recipes-qt/qte/qte-2.3.10/kernel-keymap.patch | 1293 ++++++++ recipes-qt/qte/qte-2.3.10/key.patch | 74 + .../qte/qte-2.3.10/keyboardless-buttonmap.patch | 19 + recipes-qt/qte/qte-2.3.10/no-moc.patch | 37 + recipes-qt/qte/qte-2.3.10/qiconview-speed.patch | 122 + recipes-qt/qte/qte-2.3.10/qpe.patch | 105 + recipes-qt/qte/qte-2.3.10/qt-visibility.patch | 459 +++ recipes-qt/qte/qte-2.3.10/qtabbar.patch | 39 + recipes-qt/qte/qte-2.3.10/qte-fix-iconsize.patch | 99 + .../qte/qte-2.3.10/remove-unused-kbdhandler.patch | 420 +++ recipes-qt/qte/qte-2.3.10/sharp_char.h | 309 ++ .../qte/qte-2.3.10/spitz-adhoc-keypad-rotate.patch | 21 + recipes-qt/qte/qte-2.3.10/support_18bpp.patch | 275 ++ .../qte/qte-2.3.10/suspend-resume-hooks.patch | 78 + recipes-qt/qte/qte-2.3.10/switches.h | 74 + recipes-qt/qte/qte-2.3.10/tslib.patch | 53 + recipes-qt/qte/qte-2.3.10/vt-switch.patch | 178 + recipes-qt/qte/qte-common_2.3.10.inc | 149 + recipes-qt/qte/qte-functions.inc | 11 + recipes-qt/qte/qte-mt_2.3.10.bb | 9 + recipes-qt/qte/qte_2.3.10.bb | 6 + 41 files changed, 10321 insertions(+) create mode 100644 recipes-qt/qte/qte-2.3.10/bidimetrics.patch create mode 100644 recipes-qt/qte/qte-2.3.10/c7x0-w100-accel.patch create mode 100644 recipes-qt/qte/qte-2.3.10/c7x0-w100-gcc4.patch create mode 100644 recipes-qt/qte/qte-2.3.10/daemonize.patch create mode 100644 recipes-qt/qte/qte-2.3.10/disable-dup-rotation.patch create mode 100644 recipes-qt/qte/qte-2.3.10/encoding.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-errno-exception-spec.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-linuxfb-offscreenoverflow.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-linuxfb-setmode.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-native-build.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-qgfxraster.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-qscreen-sync.patch create mode 100644 recipes-qt/qte/qte-2.3.10/fix-qte-asm-include.patch create mode 100644 recipes-qt/qte/qte-2.3.10/gcc3.patch create mode 100644 recipes-qt/qte/qte-2.3.10/gcc4.patch create mode 100644 recipes-qt/qte/qte-2.3.10/handhelds.patch create mode 100644 recipes-qt/qte/qte-2.3.10/improve-calibration-r0.patch create mode 100644 recipes-qt/qte/qte-2.3.10/increase-qxml-robustness.patch create mode 100644 recipes-qt/qte/qte-2.3.10/ipaq_sound_fix.patch create mode 100644 recipes-qt/qte/qte-2.3.10/kernel-keymap-corgi.patch create mode 100644 recipes-qt/qte/qte-2.3.10/kernel-keymap.patch create mode 100644 recipes-qt/qte/qte-2.3.10/key.patch create mode 100644 recipes-qt/qte/qte-2.3.10/keyboardless-buttonmap.patch create mode 100644 recipes-qt/qte/qte-2.3.10/no-moc.patch create mode 100644 recipes-qt/qte/qte-2.3.10/qiconview-speed.patch create mode 100644 recipes-qt/qte/qte-2.3.10/qpe.patch create mode 100644 recipes-qt/qte/qte-2.3.10/qt-visibility.patch create mode 100644 recipes-qt/qte/qte-2.3.10/qtabbar.patch create mode 100644 recipes-qt/qte/qte-2.3.10/qte-fix-iconsize.patch create mode 100644 recipes-qt/qte/qte-2.3.10/remove-unused-kbdhandler.patch create mode 100644 recipes-qt/qte/qte-2.3.10/sharp_char.h create mode 100644 recipes-qt/qte/qte-2.3.10/spitz-adhoc-keypad-rotate.patch create mode 100644 recipes-qt/qte/qte-2.3.10/support_18bpp.patch create mode 100644 recipes-qt/qte/qte-2.3.10/suspend-resume-hooks.patch create mode 100644 recipes-qt/qte/qte-2.3.10/switches.h create mode 100644 recipes-qt/qte/qte-2.3.10/tslib.patch create mode 100644 recipes-qt/qte/qte-2.3.10/vt-switch.patch create mode 100644 recipes-qt/qte/qte-common_2.3.10.inc create mode 100644 recipes-qt/qte/qte-functions.inc create mode 100644 recipes-qt/qte/qte-mt_2.3.10.bb create mode 100644 recipes-qt/qte/qte_2.3.10.bb (limited to 'recipes-qt/qte') diff --git a/recipes-qt/qte/qte-2.3.10/bidimetrics.patch b/recipes-qt/qte/qte-2.3.10/bidimetrics.patch new file mode 100644 index 0000000..50990f5 --- /dev/null +++ b/recipes-qt/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 + #include + ++//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 ++ ++#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 ++#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() 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((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 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= 0) ++ { ++ //assert(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=0 && types[j] == ON); ++ tempType = types[j]; ++ 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= 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; i0 && (GetType(GETCHAR(line, j)) == WS)) ++ { ++ j--; ++ } ++ if(j < (count-1)) ++ { ++ 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; ii; 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= 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 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=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/recipes-qt/qte/qte-2.3.10/c7x0-w100-accel.patch b/recipes-qt/qte/qte-2.3.10/c7x0-w100-accel.patch new file mode 100644 index 0000000..59a6710 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/c7x0-w100-accel.patch @@ -0,0 +1,3404 @@ +ATI IMAGEON (W100) Accelerated support +Manuel Teira + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/configure~w100 ++++ qt-2.3.10/configure +@@ -325,6 +325,9 @@ + -accel-matrox) + QWS_ACCEL_MATROX=y + ;; ++ -accel-w100) ++ QWS_ACCEL_W100=y ++ ;; + -qvfb) + QWS_QVFB=y + ;; +@@ -726,6 +729,10 @@ + then + QT_CXX="$QT_CXX -DQT_NO_QWS_MATROX" + fi ++if [ -z "$QWS_ACCEL_W100" -a -n "$EMB" ] ++then ++ QT_CXX="$QT_CXX -DQT_NO_QWS_W100" ++fi + if [ -z "$QWS_VNC" -a -n "$EMB" ] + then + QT_CXX="$QT_CXX -DQT_NO_QWS_VNC" +@@ -1338,6 +1345,7 @@ + -accel-voodoo3 ..... Enable Voodoo3 acceleration. + -accel-mach64 ...... Enable Mach64 acceleration. + -accel-matrox ...... Enable Matrox MGA acceleration. ++ -accel-w100 ........ Enable ATI Imageon w100 acceleration (experimental). + -qvfb .............. Enable X11-based Qt Virtual Frame Buffer. + -vnc ............... Enable VNC server (requires network module). + +@@ -1462,6 +1470,7 @@ + [ "x$JPEG" = "xyes" ] && QT_LIBS="${QT_LIBS} -ljpeg" + [ "x$MNG" = "xyes" ] && QT_LIBS="${QT_LIBS} -lmng -ljpeg" # assume JNG support + [ "x$NAS_SOUND" = "xyes" ] && QT_LIBS="${QT_LIBS} -laudio -lXt" # Xt junk in audio library ++[ "x$QWS_ACCEL_W100" = "xy" ] && QT_LIBS="${QT_LIBS} -laticore" # Aticore W100 support + QT_LIBS="$L_FLAGS $R_FLAGS $QT_LIBS $l_FLAGS" + + +--- qt-2.3.10/src/kernel/qgfxraster_qws.cpp~w100 ++++ qt-2.3.10/src/kernel/qgfxraster_qws.cpp +@@ -2673,7 +2673,6 @@ + } + #endif + // Bresenham algorithm from Graphics Gems +- + int ax=QABS(dx)*2; + int ay=QABS(dy)*2; + int sy=dy>0 ? 1 : -1; +@@ -5945,6 +5944,10 @@ + # include "qgfxmatrox_qws.cpp" + #endif + ++#if !defined(QT_NO_QWS_W100) ++# include "qgfxw100_qws.cpp" ++#endif ++ + #if !defined(QT_NO_QWS_VFB) + # include "qgfxvfb_qws.cpp" + #endif +@@ -5999,6 +6002,9 @@ + #if !defined(QT_NO_QWS_MATROX) + { "Matrox", qt_get_screen_matrox, 1 }, + #endif ++#if !defined(QT_NO_QWS_W100) ++ { "W100", qt_get_screen_w100, 1 }, ++#endif + #if !defined(QT_NO_QWS_TRANSFORMED) + { "Transformed", qt_get_screen_transformed, 0 }, + #endif +@@ -6039,6 +6045,8 @@ + qt_screen = driverTable[i].qt_get_screen( display_id ); + if ( qt_screen ) { + if ( qt_screen->connect( spec ) ) { ++ printf( "[%d]:Connected to screen '%s'\n", ++ getpid(), driverTable[i].name ); + return qt_screen; + } else { + delete qt_screen; +--- /dev/null ++++ qt-2.3.10/src/3rdparty/kernel/aticore/aticore.h +@@ -0,0 +1,574 @@ ++/* ++ * AtiCore 2D acceleration API ++ * ++ */ ++ ++#include ++#include ++ ++#ifndef __W100API_H__ ++#define __W100API_H__ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#define SolidRop_GXclear 0x00 /* 0 */ ++#define SolidRop_GXand 0xa0 /* src AND dst */ ++#define SolidRop_GXandReverse 0x50 /* src AND NOT dst */ ++#define SolidRop_GXcopy 0xf0 /* src */ ++#define SolidRop_GXandInverted 0x0a /* NOT src AND dst */ ++#define SolidRop_GXnoop 0xaa /* dst */ ++#define SolidRop_GXxor 0x5a /* src XOR dst */ ++#define SolidRop_GXor 0xfa /* src OR dst */ ++#define SolidRop_GXnor 0x05 /* NOT src AND NOT dst */ ++#define SolidRop_GXequiv 0xa5 /* NOT src XOR dst */ ++#define SolidRop_GXinvert 0x55 /* NOT dst */ ++#define SolidRop_GXorReverse 0xf5 /* src OR NOT dst */ ++#define SolidRop_GXcopyInverted 0x0f /* NOT src */ ++#define SolidRop_GXorInverted 0xaf /* NOT src OR dst */ ++#define SolidRop_GXnand 0x5f /* NOT src OR NOT dst */ ++#define SolidRop_GXset 0xff /* 1 */ ++ ++#define BltRop_GXclear 0x00 /* 0 */ ++#define BltRop_GXand 0x88 /* src AND dst */ ++#define BltRop_GXandReverse 0x44 /* src AND NOT dst */ ++#define BltRop_GXcopy 0xcc /* src */ ++#define BltRop_GXandInverted 0x22 /* NOT src AND dst */ ++#define BltRop_GXnoop 0xaa /* dst */ ++#define BltRop_GXxor 0x66 /* src XOR dst */ ++#define BltRop_GXor 0xee /* src OR dst */ ++#define BltRop_GXnor 0x11 /* NOT src AND NOT dst */ ++#define BltRop_GXequiv 0x99 /* NOT src XOR dst */ ++#define BltRop_GXinvert 0x55 /* NOT dst */ ++#define BltRop_GXorReverse 0xdd /* src OR NOT dst */ ++#define BltRop_GXcopyInverted 0x33 /* NOT src */ ++#define BltRop_GXorInverted 0xbb /* NOT src OR dst */ ++#define BltRop_GXnand 0x77 /* NOT src OR NOT dst */ ++#define BltRop_GXset 0xff /* 1 */ ++ ++#define DSTTYPE_8BPP 2 //8bpp ++#define DSTTYPE_16BPP_1555 3 //16 bpp aRGB 1555 ++#define DSTTYPE_16BPP_444 5 //16 bpp aRGB 4444 ++ ++#define SRCTYPE_1BPP_OPA 0 //mono (expanded to frgd, bkgd) ++#define SRCTYPE_1BPP_TRA 1 //mono (expanded to frgd, leave_alone) ++#define SRCTYPE_EQU_DST 3 //color (same as DST) ++#define SRCTYPE_SOLID_COLOR_BLT 4 //solid color for Blt (use frgd) ++#define SRCTYPE_4BPP 5 //4 bpp ++#define SRCTYPE_12BPP_PACKED 6 //12 bpp packed ++ ++#define ROP3_SRCCOPY 0xcc ++#define ROP3_PATCOPY 0xf0 ++ ++#define OVLTYPE_YUV420 7 ++#define OVLTYPE_RGB565 8 ++ ++#define DP_BRUSH_8x8MONOOPA 0 //8x8 mono pattern (expanded to frgd, bkgd ) ++#define DP_BRUSH_8x8MONOTRA 1 //8x8 mono pattern (expanded to frgd, leave alone ) ++#define DP_PEN_32x1MONOOPA 6 //32x1 mono pattern (expanded to frgd, bkgd) ++#define DP_PEN_32x1MONOTRA 7 //32x1 mono pattern (expanded to frgd, leave alone) ++#define DP_BRUSH_8x8COLOR 10 //8x8 color pattern ++#define DP_BRUSH_SOLIDCOLOR 13 //solid color pattern (frgd) ++#define DB_BRUSH_NONE 15 //No brush used ++ ++ typedef struct { ++ int16_t XCoord; ++ int16_t YCoord; ++ } ATI_POINT; ++ ++ typedef struct { ++ int16_t XCoord; ++ int16_t YCoord; ++ int16_t Width; ++ int16_t Height; ++ } ATI_RECT; ++ ++ typedef struct { ++ int16_t X_Top_Left; // x coordinate of top left corner ++ int16_t Y_Top_Left; // y coordinate of top left corner ++ int16_t X_Bottom_Right; // x coordinate of bottom right corner ++ int16_t Y_Bottom_Right; // y coordinate of bottom right corner ++ } ATI_CLIPRECT; ++ ++ typedef struct { ++ uint32_t Count; ++ uint8_t ScaleXFactor; ++ uint8_t ScaleYFactor; ++ uint8_t BlendOn; ++ uint8_t dummy1; ++ } ATI_STRETCH; ++ ++ typedef struct { ++ uint32_t *lpSrcBitmap; /* ¥µ¡¼¥Õ¥§¥¹¤Î¥ª¥Õ¥»¥Ã¥È */ ++ uint16_t XCoord; /* +4 ³ÎÄê:¥µ¡¼¥Õ¥§¥¹Æâ¤ÎxºÂɸ */ ++ uint16_t YCoord; /* +6 ³ÎÄê:¥µ¡¼¥Õ¥§¥¹Æâ¤ÎyºÂɸ */ ++ uint16_t SrcPitch; /* +8 ³ÎÄê: */ ++ uint16_t SrcHeight; /* +10 ³ÎÄê: */ ++ uint16_t OverlayWidth; /* ¥ª¡¼¥Ð¥ì¥¤¤ÎÉý(Src¤È°ã¤¦Ãͤˤ·¤Æ¤â¡¢Æ°Åª¤Ë³ÈÂç½Ì¾®¤µ¤ì¤¿¤ê¤Ï¤·¤Ê¤¤¡¢°ÕÌ£¤¢¤ó¤Î¡©) */ ++ uint16_t OverlayHeight; ++ uint32_t lpOverlayKey; /* +16 ³ÎÄê:Ææ(¥«¥é¡¼¥­¡¼¡©) */ ++ uint8_t OverlayFormat; /* +20 ³ÎÄê */ ++ uint8_t dummy1; ++ uint16_t dummy2; ++ } ATI_OVERLAYPROP; /* 24bytes? */ ++ ++ typedef struct { ++ int HInvert; ++ int VInvert; ++ } ATI_EXTVIDEOPROP; ++ ++ typedef struct { ++ ATI_EXTVIDEOPROP ExtVideoProp; ++ } ATI_UNKNOWN1; ++ ++ typedef struct { ++ unsigned long clr_cmp_fcn_src :3; ++ unsigned long :5; ++ unsigned long clr_cmp_fcn_dst :3; ++ unsigned long :13; ++ unsigned long clr_cmp_src :2; ++ unsigned long :6; ++ } clr_cmp_cntl_t; ++ ++ typedef struct { ++ uint16_t x; ++ uint16_t y; ++ uint16_t w; ++ uint16_t h; ++ clr_cmp_cntl_t cmp_cntl; ++ unsigned long tcolour; ++ } transbitblt_t; ++ ++ typedef struct { ++ uint32_t dummy1; ++ uint32_t dummy2; ++ uint8_t HExpansion; /* +8 ³ÎÄê */ ++ uint8_t VExpansion; /* +9 ³ÎÄê */ ++ uint8_t dummy3; ++ uint8_t dummy4; ++ uint8_t RConversion; /* +12 ³ÎÄê */ ++ uint8_t dummy5; ++ uint8_t dummy6; ++ uint8_t dummy7; ++ ATI_UNKNOWN1 x; ++ } ATI_EXTENDEDOVERLAYPROP; /* 16byte? */ ++ ++ /** ++ * AtiCore initialization. ++ * Sets up the shared memory area ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessAttach( void ); ++ ++ /** ++ * AtiCore finish. ++ * ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessDetach( void ); ++ ++ ++ /** ++ * Allocates a surface on the internal RAM. ++ * Perhaps there's a way to indicate to allocate on the ++ * internal RAM? ++ * @arg handle Reference to the returned surface handle ++ * @arg offset Returned offset of this surface on the video memory ++ * @arg size Size (bytes) to be reserved (16 multiple) ++ * @arg direction ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_AllocateSurface( uint16_t *handle, uint32_t *offset, ++ uint32_t size, uint32_t direction ); ++ ++ /** ++ * Deallocates a given surface. ++ * @arg handle Handle to the allocated surface ++ * (As returned by AllocateSurface) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_DestroySurface( uint16_t handle ); ++ ++ /** ++ * Sets the kind of Raster Operation. ++ * @param rop Raster operation to be performed ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetRopOperation( uint32_t rop ); ++ ++ /** ++ * Sets the destination type for raster operation. ++ * @param dsttype ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDstType( uint32_t dsttype ); ++ ++ /** ++ * Sets the source type for raster operation. ++ * @param srctype ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetSrcType( uint32_t srctype ); ++ ++ /** ++ * Sets Source clipping rectangle. ++ * @param cliprect Rectangle to perform clipping. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetSrcClippingRect( ATI_CLIPRECT *cliprect ); ++ ++ /** ++ * Sets Destination clipping rectangle. ++ * @param cliprect Rectangle to perform clipping. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDstClippingRect(ATI_CLIPRECT *cliprect); ++ ++ /** ++ * Sets pitch and offset for source in a raster operation. ++ * @param pitch Pitch (line width) of source ++ * @param offset Offset of source ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetSrcPitchOffset( int pitch, int offset ); ++ ++ /** ++ * Sets pitch and offset destination source in a raster operation. ++ * @param pitch Pitch (line width) of destination ++ * @param offset Offset of destination (memory offset) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDstPitchOffset( int pitch, int offset ); ++ ++ /** ++ * Performs a BitBlt with source rotation. ++ * @param flags Rotation degree ++ * @param dstRect Rectangle for destination Bitblitting ++ * @param srcRect Rectangle for origin bitblitting ++ * @test Tested with specified flags parameter ++ */ ++ int AtiCore_BitBltFilpRotate( int flags, ++ ATI_RECT *dstRect, ++ ATI_RECT *srcRect); ++ ++ /** ++ * Performs a BitBlt with source stretching. ++ * @param option Unknown ++ * @param point Unknown ++ * @param srcRect Source blitting surface ++ * @test Untested ++ */ ++ int AtiCore_StretchBlt( ATI_STRETCH *option, ++ ATI_POINT *point, ++ ATI_RECT *srcRect); ++ ++ /** ++ * Waits for the FIFO to be idle at least msecs. ++ * @param msecs Maximum time to wait for FIFO to idle ++ * @return 1:success, 0:fail ++ * @test Untested ++ */ ++ int AtiCore_WaitComplete( int msec ); ++ ++ /** ++ * Allocates a new overlay handle. ++ * @param handle overlay ++ * @return 1:success, 0:fail ++ * @test Yes ++ */ ++ int AtiCore_AllocOverlay( uint16_t *handle ); ++ ++ /** ++ * Deallocates a overlay handle. ++ * @param handle overlay ++ * @return 1:success, 0:fail ++ * @test Yes ++ */ ++ int AtiCore_ReleaseOverlay( uint16_t handle ); ++ ++ /** ++ * Sets up an overlay given a handle an a set of properties. ++ * @param handle Allocated handle to setup the overlay. ++ * @param props Overlay properties struct ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetupOverlay( uint16_t handle, ATI_OVERLAYPROP *props ); ++ ++ /** ++ * Sets up extended overlay features. ++ * @param handle Allocated handle to an overlay ++ * @param props Extended overlay properties ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetupOverlayExtended( uint16_t handle, ++ ATI_EXTENDEDOVERLAYPROP *props ); ++ ++ /** ++ * Enable/Disable an overlayed surface. ++ * @param handle Overlay to be enabled/disabled ++ * @param enable 1: Enable, 0: Disable ++ * @return 1:success, 0:fail ++ * @test Tested ++ */ ++ int AtiCore_SetOverlayOnOff( uint16_t handle, int enable ); ++ ++ /** ++ * Sets up the overlay position for a given handle. ++ * @param handle Overlay Handle ++ * @param x X Coordinate (Seems to be a bug with x < 4 ) ++ * @param y Y Coordinate ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetOverlayPos( uint16_t handle, ++ uint16_t x, ++ uint16_t y ); ++ ++ /** ++ * Translates between physical/virtual addresses. ++ * @param offset VRAM offset to be translated ++ * @param viraddr Virtual address for VRAM ++ * @return 1:success,0:fail ++ */ ++ int AtiCore_SetupMemoryTransfer( uint32_t offset, ++ uint32_t *viraddr ); ++ ++ /** ++ * Related with the previous one. It seems to be necesary to be called ++ * but I'm not sure of its function. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_TerminateMemoryTransfer( void ); ++ ++ /** ++ * Returns the frontbuffer pitch and offset. ++ * @param pitch Return value for the frontbuffer pitch (width) ++ * @param offset Return value for the frontbuffer offset ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_GetFrontBufferPitchOffset( uint32_t *pitch, ++ uint32_t *offset ); ++ ++ /** ++ * Changes display brighness ? ++ * @param brightness -64...63 ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetDisplayBrightness( int brightness ); ++ ++ /** ++ * Returns the amount of available internal/external memory. ++ * @param internal Pointer to return internal memory size ++ * @param external Pointer to return external memory size ++ * @return 1:success, 0:fail ++ */ ++ int GetAvailableVideoMem( uint32_t *internal, ++ uint32_t *external ); ++ ++/** ++ * ++ * ++ * ++ ++ { ++ (uint32_t) 0 ++ (uint32_t) 0 ++ (uint16_t) 480 ++ (uint16_t) 640 ++ (uint16_t) 480 ++ (uint16_t) 640 ++ (uint32_t) 5 ++ */ ++ ++ typedef struct { ++ uint32_t dummy1; ++ ATI_RECT Size; ++ uint16_t Width; ++ uint16_t Height; ++ uint32_t Flag; ++ } ATI_GRAPHICWINDOW; ++ ++ int AtiCore_SetupGraphicWindow(void* ); ++ ++ /** ++ * It seems to be necessary after AtiCore_ProcessAttach ++ * @param mode: 0xaaab for portrait, 0xaaaa for landscape ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessAttachSpecialMode( int mode ); ++ ++ /** ++ * Detach from the special mode. Whatever it means. ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_ProcessDetachSpecialMode( void ); ++ ++ /** ++ * Sets up the position of the Graphic viewport ? ++ * @param x X coordinate ++ * @param y Y coordinate ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetGraphicWindowPos( int x, int y ); ++ ++ /** ++ * Get the graphic viewport position. ++ * @param x Pointer to xcoord placeholder ++ * @param y Pointer to ycoord placeholder ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_GetGraphicWindowPos( int *x, int *y ); ++ ++ /** ++ * Sets up the frontbuffer position. ++ * @param offset VRAM offset to be used. ++ * @param x X Coordinate? ++ * @param y Y Coordinate? ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetFrontBuffer( int offset, int x, int y ); ++ ++ /** ++ * Enable/Disable the frontbuffer? ++ * @param enable 1 enables/ 0 disables ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetGraphicWindowOnOff( int enable ); ++ ++ /* ++ * Sets the foreground color. ++ * @param colour Color in 565 format (perhaps depends on the source format) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetFrgColour( int colour ); ++ ++ /* ++ * Sets the background colour. ++ * @param colour Colour in 565 format (perhaps depends on the source format) ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_SetBkgColour( int colour ); ++ ++ /** ++ * Changes the painting brush ++ * @param btype Type of brush to use ++ * 4: Uses the pattern ++ * 6: SolidLine ++ * @param pattern Pointer to a 32 bit pattern ++ * @return 1:success, 0:fail ++ * @test Some values for btype produces a kind of antialiasing line ++ */ ++ int AtiCore_BrushType( int btype, unsigned int *pattern ); ++ ++ /** ++ * Performs a rectangle paint. ++ * @param nrects Number of rectangles to be painted ++ * @param rects Array of rectangles to be painted ++ * @return 1:success, 0:fail ++ * @test Tested with nrects==1 ++ */ ++ int AtiCore_PaintRect( int nrects , ++ ATI_RECT rects[] ); ++ ++ /** ++ * Draws a set of lines. ++ * @param npoints Number of points in the polyline set ++ * @param points Pointer to an array of ATI_POINT ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_Polyline( int npoints, ATI_POINT points[] ); ++ ++ int AtiCore_GetPitchOffsetProperty( void *, void *); ++ ++ int AtiCore_CursorOnOff( int, int ); ++ ++ /** ++ * Performs a BitBlt ROP operation. ++ * @param unk Unknown (Always set to 1) ++ * @param dstrect Bounding destination rect ++ * @param srcrect Bounding source rect ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_BitBlt( int unk, ++ ATI_RECT *dstrect, ++ ATI_RECT *srcrect ); ++ ++ /** ++ * Performs a Transparent BitBlt ROP operation. ++ * @param dstrect Transparent DstRect bitblt argument ++ * @param srcrect Transparent SrcRect bitblt argument ++ * @return 1:success, 0:fail ++ * @test Doesn't work. It sets to zero CLR_CMP_CNTL and CLR_CMP_MSK ++ */ ++ int AtiCore_TransBitBlt( transbitblt_t *dstrect, ++ transbitblt_t *srcrect ); ++ ++ int AtiCore_WakeUpCall( void ); ++ ++ /** ++ * Draws a set of pixels ++ * @param npoints Number of points to draw ++ * @param points Pointer to an array of ATI_POINT ++ * @return 1:success, 0:fail ++ */ ++ int AtiCore_DrawPixel( int npoints, ATI_POINT *points ); ++ ++ int AtiCore_SetSysClk( unsigned short in0 ); ++ int AtiCore_SetFastSysClk( unsigned short in0 ); ++ int AtiCore_SetSlowSysClk( unsigned short in0 ); ++ ++ int AtiCore_GetCursorPos( unsigned long in0, ++ unsigned short *x, ++ unsigned short *y ); ++ ++ ++ ++/* ================================================================ */ ++/* from libqte.so.2.3.2 */ ++/* ++AtiCore_AlphaBlend ++ ++AtiCore_Flush ++AtiCore_GammaCorrection ++AtiCore_GetCRC ++AtiCore_GetCursorPos ++AtiCore_GetDeviceInfo ++AtiCore_GetGPIO_Data ++AtiCore_GetGraphicExtended ++AtiCore_GetGraphicWindowPos ++AtiCore_GetLargestVideoMemBlock ++AtiCore_GetLastError ++AtiCore_GetMultiCRC ++AtiCore_GetOverlayPos ++AtiCore_Host ++AtiCore_LoadCursorBitMap ++AtiCore_PolyScanline ++AtiCore_ProcessAttachMinimal(void)? ++AtiCore_ProcessDetachMinimal(void)? ++AtiCore_ProcessDetachSpecialMode ++AtiCore_ReadCfgReg ++AtiCore_ReadMem(int, int)? ++AtiCore_ReadReg(int, int)? ++AtiCore_ScanlineShading ++AtiCore_SetApertures ++AtiCore_SetBytePixelOrder ++AtiCore_SetCursorPos ++AtiCore_SetDisplayParameters ++AtiCore_SetDriverBehaviour ++AtiCore_SetGPIO_Data ++AtiCore_SetOverlayPosUsingGraphicWindowXY ++AtiCore_SetPartialCursor ++AtiCore_SetupGraphicExtended ++AtiCore_SetupPM4 ++AtiCore_SmallText ++AtiCore_SubmitPM4Packet ++AtiCore_WriteCfgReg ++AtiCore_WriteMem ++AtiCore_WriteReg ++ */ ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +--- /dev/null ++++ qt-2.3.10/src/kernel/qgfxw100_qws.cpp +@@ -0,0 +1,2709 @@ ++ /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil -*- */ ++/*************************************************************************** ++ ++** Imageon driver for qte using libAticore ++** Manuel Teira( 2005 ) ++** BUGS ++* - Enable again internal memory surfaces. ++****************************************************************************/ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++#include ++ ++#include ++ ++#ifndef __sparc__ ++#include ++#endif ++ ++#include "qgfxraster_qws.h" ++#include "qgfxlinuxfb_qws.h" ++#include ++ ++#include ++ ++class W100Driver { ++public: ++ ++ typedef enum Loglevel { ++ ERROR = 0, ++ WARNING, ++ INFO ++ }; ++ ++ typedef enum Opcodes { ++ DRAWLINE = 0, ++ DRAWPOINT, ++ DRAWPOINTS, ++ FILLRECT, ++ SCROLL, ++ BITBLT, ++ POLYLINE, ++ EOO ++ }; ++ ++ typedef enum Retcodes { ++ codOK, ++ codError ++ }; ++ ++ ++ typedef struct Opcode { ++ QString str; ++ int index; ++ bool accelerated; ++ int hits; ++ int misses; ++ }; ++ ++ static Opcode lOpcodes[]; ++ ++ static QString level2str( int level ) ++ { ++ switch( level ) { ++ case ERROR: ++ return QString( "ERROR" ); ++ break; ++ case WARNING: ++ return QString( "WARNING" ); ++ break; ++ case INFO: ++ return QString( "INFO" ); ++ break; ++ default: ++ return QString( "UNKNOWN" ); ++ break; ++ } ++ } ++ ++ W100Driver(): ++ m_loglevel( 0 ), ++ m_logenabled( 0 ), ++ m_logcount( 0 ), ++ m_attached( false ) ++ { ++ m_pid = getpid(); ++ m_loglevel = 0; ++ char *var; ++ if ( var = getenv( "W100_DEBUG" ) ) { ++ if ( strtol( var, 0, 0 ) == 1 ) { ++ m_logenabled = 1; ++ } ++ } ++ ++ if ( m_logenabled ) { ++ if ( var = getenv( "W100_DEBUGLEVEL" ) ) { ++ if ( ( m_loglevel = strtol( var, 0, 0 ) ) < 0 ) { ++ m_loglevel = 0; ++ } ++ } ++ ++ QString path( "/mnt/card/w100/w100debug.log" ); ++ if ( var = getenv( "W100_DEBUGPATH" ) ) { ++ path = QString( var ) + "/w100debug.log"; ++ } ++ m_logfile = fopen( path.latin1(), "a" ); ++ if ( m_logfile == NULL ) m_logenabled = 0; ++ } ++ ++ Opcode *opcodePtr = lOpcodes; ++ while ( opcodePtr->index != EOO ) { ++ QString varName = "W100_ACCEL_" + opcodePtr->str; ++ char *varPtr; ++ if ( ( varPtr = getenv( varName.latin1() ) ) ) { ++ if ( ( strtol( varPtr, NULL, 0 ) == 0 ) || ++ ( strcmp( varPtr, "false" ) == 0 ) ) { ++ opcodePtr->accelerated = false; ++ } ++ } ++ opcodePtr++; ++ } ++ } ++ ++ ~W100Driver() ++ { ++ //Dump statistics about any opcode ++ Opcode *opcodePtr = lOpcodes; ++ while ( opcodePtr->index != EOO ) { ++ log( WARNING, "Opcode %s. Accelerated=%s. Hits=%d. Misses=%d", ++ opcodePtr->str.latin1(), ++ opcodePtr->accelerated ? "true" : "false", ++ opcodePtr->hits, ++ opcodePtr->misses ); ++ opcodePtr++; ++ } ++ if ( m_logenabled && m_logfile ) { ++ fclose( m_logfile ); ++ } ++ } ++ ++ bool accelerated( int opcode ) ++ { ++ if ( !m_attached ) { ++ log( WARNING, "Asking for accelerated '%s' when not attached", ++ lOpcodes[opcode].str.latin1() ); ++ return false; ++ } ++ if ( opcode < EOO ) { ++ if ( lOpcodes[opcode].accelerated ) { ++ return true; ++ } else { ++ log( WARNING, "Not accelerated '%s'", ++ lOpcodes[opcode].str.latin1() ); ++ return false; ++ } ++ } ++ return false; ++ } ++ ++ void addHit( int opcode ) ++ { ++ lOpcodes[opcode].hits++; ++ } ++ ++ void addMiss( int opcode ) ++ { ++ lOpcodes[opcode].misses++; ++ } ++ ++ void log( int level, const char *fmt, ... ) ++ { ++ if ( m_logenabled && ( level <= m_loglevel ) ) { ++ timeval tv; ++ char buffer[1024]; ++ va_list ap; ++ va_start( ap, fmt ); ++ vsnprintf( buffer, 1023, fmt, ap ); ++ va_end( ap ); ++ gettimeofday( &tv, NULL ); ++ fprintf( m_logfile, "(%010u.%06u)%d:%d:%s:%s\n", ++ tv.tv_sec, tv.tv_usec, ++ m_logcount++, ++ m_pid, ++ level2str( level ).latin1(), ++ buffer ); ++ fflush( m_logfile ); ++ } ++ } ++ ++ bool attached( void ) const ++ { ++ return m_attached; ++ } ++ ++ int processAttach( void ) ++ { ++ if ( !m_attached ) { ++ if ( AtiCore_ProcessAttach() ) { ++ log( WARNING, "Process attached succesfully" ); ++ m_attached = true; ++ return codOK; ++ } else { ++ log( WARNING, "Error attaching process" ); ++ } ++ } else { ++ log( WARNING, "Process already attached" ); ++ } ++ return codError; ++ } ++ ++ int processDetach( void ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_ProcessDetach() ) { ++ log( WARNING, "Process detached succesfully" ); ++ m_attached = false; ++ return codOK; ++ } else { ++ log( WARNING, "Error detaching process" ); ++ } ++ } else { ++ log( WARNING, "Trying to detach while not attached" ); ++ } ++ return codError; ++ } ++ ++ int allocateSurface( uint16_t *handle, uint32_t *offset, ++ uint32_t size, uint32_t direction ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_AllocateSurface( handle, offset, ++ size, direction ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in allocateSurface" ); ++ } ++ } else { ++ log( WARNING, "Trying to allocateSurface while not attached" ); ++ } ++ return codError; ++ } ++ ++ int destroySurface( uint16_t handle ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_DestroySurface( handle ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in destroySurface" ); ++ } ++ } else { ++ log( WARNING, "Trying to destroySurface while not attached" ); ++ } ++ return codError; ++ } ++ ++ int drawPixel( int npoints, ATI_POINT *points ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_DrawPixel( npoints, points ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in drawPixel" ); ++ } ++ } else { ++ log( WARNING, "Trying to drawPixel while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setRopOperation( uint32_t rop ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetRopOperation( rop ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setRopOperation" ); ++ } ++ } else { ++ log( WARNING, "Trying to setRopOperation while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setDstType( uint32_t dtype ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetDstType( dtype ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setDstType" ); ++ } ++ } else { ++ log( WARNING, "Trying to setDstType while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setSrcType( uint32_t stype ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetSrcType( stype ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setSrcType" ); ++ } ++ } else { ++ log( WARNING, "Trying to setSrcType while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setSrcClippingRect( ATI_CLIPRECT *cliprect ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetSrcClippingRect( cliprect ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setSrcClippingRect" ); ++ } ++ } else { ++ log( WARNING, "Trying to setSrcClippingRect while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setDstClippingRect( ATI_CLIPRECT *cliprect ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetDstClippingRect( cliprect ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setDstClippingRect" ); ++ } ++ } else { ++ log( WARNING, "Trying to setDstClippingRect while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setSrcPitchOffset( int pitch, int offset ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetSrcPitchOffset( pitch, offset ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setSrcPitchOffset" ); ++ } ++ } else { ++ log( WARNING, "Trying to setSrcPitchOffset while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setDstPitchOffset( int pitch, int offset ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetDstPitchOffset( pitch, offset ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setDstPitchOffset" ); ++ } ++ } else { ++ log( WARNING, "Trying to setDstPitchOffset while not attached" ); ++ } ++ return codError; ++ } ++ ++ int bitBltFlipRotate( int rot, ++ ATI_RECT *dstRect, ++ ATI_RECT *srcRect ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_BitBltFilpRotate( rot, dstRect, srcRect ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in bitBltFlipRotate" ); ++ } ++ } else { ++ log( WARNING, "Trying to bitBltFlipRotate while not attached" ); ++ } ++ return codError; ++ } ++ ++ int stretchBlt( ATI_STRETCH *option, ++ ATI_POINT *point, ++ ATI_RECT *srcRect ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_StretchBlt( option, point, srcRect ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in stretchBlt" ); ++ } ++ } else { ++ log( WARNING, "Trying to stretchBlt while not attached" ); ++ } ++ return codError; ++ } ++ ++ int waitComplete( int msec ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_WaitComplete( msec ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in waitComplete" ); ++ } ++ } else { ++ log( WARNING, "Trying to waitComplete while not attached" ); ++ } ++ return codError; ++ } ++ ++ int allocOverlay( uint16_t *handle ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_AllocOverlay( handle ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in allocOverlay" ); ++ } ++ } else { ++ log( WARNING, "Trying to allocOverlay while not attached" ); ++ } ++ return codError; ++ } ++ ++ int releaseOverlay( uint16_t handle ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_ReleaseOverlay( handle ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in releaseOverlay" ); ++ } ++ } else { ++ log( WARNING, "Trying to releaseOverlay while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setupOverlay( uint16_t handle, ATI_OVERLAYPROP *prop ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetupOverlay( handle, prop ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setupOverlay" ); ++ } ++ } else { ++ log( WARNING, "Trying to setupOverlay while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setupOverlayExtended( uint16_t handle, ++ ATI_EXTENDEDOVERLAYPROP *prop ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetupOverlayExtended( handle, prop ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setupOverlayExtended" ); ++ } ++ } else { ++ log( WARNING, "Trying to setupOverlayExtended while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setOverlayOnOff( uint16_t handle, int isShow ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetOverlayOnOff( handle, isShow ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setOverlayOnOff" ); ++ } ++ } else { ++ log( WARNING, "Trying to setOverlayOnOff while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setOverlayPos( uint16_t handle, uint16_t x, uint16_t y ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetOverlayPos( handle, x, y ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setOverlayPos" ); ++ } ++ } else { ++ log( WARNING, "Trying to setOverlayPos while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setupMemoryTransfer( uint32_t offset, uint32_t *regdata ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetupMemoryTransfer( offset, regdata ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setupMemoryTransfer" ); ++ } ++ } else { ++ log( WARNING, "Trying to setupMemoryTransfer while not attached" ); ++ } ++ return codError; ++ } ++ ++ int terminateMemoryTransfer( void ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_TerminateMemoryTransfer() ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in terminateMemoryTransfer" ); ++ } ++ } else { ++ log( WARNING, "Trying to terminateMemoryTransfer while not attached" ); ++ } ++ return codError; ++ } ++ ++ int getFrontBufferPitchOffset( uint32_t *pitch, uint32_t *offset ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_GetFrontBufferPitchOffset( pitch, offset ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in getFrontBufferPitchOffset" ); ++ } ++ } else { ++ log( WARNING, "Trying to getFrontBufferPitchOffset while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setDisplayBrightness( int bri ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetDisplayBrightness( bri ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setDisplayBrightness" ); ++ } ++ } else { ++ log( WARNING, "Trying to setDisplayBrighness while not attached" ); ++ } ++ return codError; ++ } ++ ++ int getAvailableVideoMem( uint32_t *internal, uint32_t *external ) ++ { ++ if ( m_attached ) { ++ if ( GetAvailableVideoMem( internal, external ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in getAvailableVideoMem" ); ++ } ++ } else { ++ log( WARNING, "Trying to getAvailableVideoMem while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setupGraphicWindow( ATI_GRAPHICWINDOW *win ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetupGraphicWindow( ( void * ) win ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setupGraphicWindow" ); ++ } ++ } else { ++ log( WARNING, "Trying to setupGraphicWindow while not attached" ); ++ } ++ return codError; ++ } ++ ++ int processAttachSpecialMode( int mode ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_ProcessAttachSpecialMode( mode ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in processAttachSpecialMode" ); ++ } ++ } else { ++ log( WARNING, "Trying to processAttachSpecialMode while not attached" ); ++ } ++ return codError; ++ } ++ ++ int processDetachSpecialMode( void ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_ProcessDetachSpecialMode() ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in processDetachSpecialMode" ); ++ } ++ } else { ++ log( WARNING, "Trying to processDetachSpecialMode while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setGraphicWindowPos( int x, int y ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetGraphicWindowPos( x, y ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setGraphicWindowPos" ); ++ } ++ } else { ++ log( WARNING, "Trying to setGraphicWindow while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setFrontBuffer( int offset, int a, int b ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetFrontBuffer( offset, a, b ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setFrontBuffer" ); ++ } ++ } else { ++ log( WARNING, "Trying to setFrontBuffer while not attached" ); ++ } ++ return codError; ++ } ++ ++ int setGraphicWindowOnOff( int val ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetGraphicWindowOnOff( val ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setGraphicWindowOnOff" ); ++ } ++ } else { ++ log( WARNING, "Trying to setGraphicWindowOnOff while not attached" ); ++ } ++ } ++ ++ static unsigned long ccolor( unsigned int rgb ) ++ { ++ unsigned char r = ( rgb & 0xff0000 ) >> 19; ++ unsigned char g = ( rgb & 0xff00 ) >> 10; ++ unsigned char b = ( rgb & 0xff ) >> 3; ++ return ( ( ( ( unsigned short )0x1f & r ) << 11 ) | ++ ( ( ( unsigned short )0x3f & g ) << 5 ) | ++ ( ( ( unsigned short )0x1f & b ) ) ); ++ } ++ ++ int setFrgColour( int val ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_SetFrgColour( ccolor( val ) ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in setFrgColour" ); ++ } ++ } else { ++ log( WARNING, "Trying to setFrgColour while not attached" ); ++ } ++ return codError; ++ } ++ ++ int brushType( int type, unsigned int pattern ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_BrushType( type, &pattern ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in brushType" ); ++ } ++ } else { ++ log( WARNING, "Trying to brushType while not attached" ); ++ } ++ return codError; ++ } ++ ++ int paintRect( int flags, ATI_RECT *rect ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_PaintRect( flags, rect ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in paintRect" ); ++ } ++ } else { ++ log( WARNING, "Trying to paintRect while not attached" ); ++ } ++ return codError; ++ } ++ ++ int polyline( int npoints, ATI_POINT *points ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_Polyline( npoints, points ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in polyline" ); ++ } ++ } else { ++ log( WARNING, "Trying to polyline while not attached" ); ++ } ++ return codError; ++ } ++ ++ int getPitchOffsetProperty( void *pitch, void *offset ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_GetPitchOffsetProperty( pitch, offset ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in getPitchOffsetProperty" ); ++ } ++ } else { ++ log( WARNING, "Trying to getPitchOffsetProperty while not attached" ); ++ } ++ return codError; ++ } ++ ++ int cursorOnOff( int a, int b ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_CursorOnOff( a, b ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in cursorOnOff" ); ++ } ++ } else { ++ log( WARNING, "Trying to cursorOnOff while not attached" ); ++ } ++ return codError; ++ } ++ ++ int bitBlt( int flags, ATI_RECT *dst, ATI_RECT *src ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_BitBlt( flags, dst, src ) ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in bitBlt" ); ++ } ++ } else { ++ log( WARNING, "Trying to bitBlt while not attached" ); ++ } ++ return codError; ++ } ++ ++ int wakeUpCall( void ) ++ { ++ if ( m_attached ) { ++ if ( AtiCore_WakeUpCall() ) { ++ return codOK; ++ } else { ++ log( ERROR, "Error in wakeUpCall" ); ++ } ++ } else { ++ log( WARNING, "Trying to wakeupCall while not attached" ); ++ } ++ return codError; ++ } ++ ++private: ++ FILE *m_logfile; ++ int m_loglevel; ++ bool m_logenabled; ++ bool m_attached; ++ int m_pid; ++ int m_logcount; ++}; ++ ++W100Driver::Opcode W100Driver::lOpcodes[] = { ++ { "DRAWLINE", W100Driver::DRAWLINE, true, 0, 0 }, ++ { "DRAWPOINT", W100Driver::DRAWPOINT, true, 0, 0 }, ++ { "DRAWPOINTS", W100Driver::DRAWPOINTS, true, 0, 0 }, ++ { "FILLRECT", W100Driver::FILLRECT, true, 0, 0 }, ++ { "SCROLL", W100Driver::SCROLL, true, 0, 0 }, ++ { "BITBLT", W100Driver::BITBLT, true, 0, 0 }, ++ { "POLYLINE", W100Driver::POLYLINE, true, 0, 0 }, ++ { "" , W100Driver::EOO, false, 0, 0 } ++}; ++ ++W100Driver driver; ++ ++class QW100Screen; ++static QW100Screen *qt_w100_screen = 0; ++ ++class QW100Screen : public QLinuxFbScreen { ++public: ++ class HWSurface { ++ public: ++ HWSurface( void ): ++ m_handle( 0 ), ++ m_offset( 0 ), ++ m_addr( 0 ), ++ m_size( 0 ), ++ m_internal( false ), ++ m_clientid( -1 ) {}; ++ HWSurface( unsigned short handle, ++ uint32_t sOffset, ++ unsigned char *localAddr, ++ int amount, ++ bool internal, ++ int clientid ): ++ m_handle( handle ), ++ m_offset( sOffset ), ++ m_addr( localAddr ), ++ m_size( amount ), ++ m_internal( internal ), ++ m_clientid( clientid ) {}; ++ HWSurface( uint32_t sOffset, ++ unsigned char *localAddr, ++ bool internal, ++ int amount ): ++ m_handle( 0 ), ++ m_offset( sOffset ), ++ m_addr( localAddr ), ++ m_size( amount ), ++ m_internal( internal ), ++ m_clientid( -1 ) {}; ++ bool operator!=( HWSurface &other ) { ++ return( m_offset == other.getSOffset() ); ++ }; ++ HWSurface &operator=( const HWSurface &c ) { ++ m_handle = c.getHandle(); ++ m_offset = c.getSOffset(); ++ m_addr = c.getAddr(); ++ m_size = c.getSize(); ++ m_clientid= c.getCId(); ++ m_internal = c.internal(); ++ return( *this ); ++ }; ++ unsigned short getHandle( void ) const { return m_handle; }; ++ uint32_t getSOffset( void ) const { return m_offset; }; ++ unsigned char *getAddr( void ) const { return m_addr; }; ++ unsigned int getSize( void ) const { return m_size; }; ++ int getCId( void ) const { return m_clientid; }; ++ bool internal( void ) const { return m_internal; }; ++ ++ private: ++ unsigned short m_handle; ++ uint32_t m_offset; ++ unsigned char *m_addr; ++ int m_size; ++ bool m_internal; ++ int m_clientid; ++ }; ++ ++ QW100Screen( int display_id ); ++ virtual ~QW100Screen(); ++ virtual bool connect( const QString &spec ); ++ virtual void disconnect( void ); ++ virtual bool initDevice(); ++ virtual void shutdownDevice(); ++ virtual void restore(); ++ virtual bool useOffscreen() { return true; } ++ virtual QGfx * createGfx( unsigned char *, int, int, int, int); ++ virtual uchar *cache( int amount, int optim ); ++ virtual void uncache( uchar *c ); ++ virtual bool onCard( unsigned char *p ) const; ++ virtual bool onCard( unsigned char *p, ulong& offset ) const; ++ QMap< uchar*, HWSurface > *getPSurfaceMap( void ) const; ++ void clearCache( int clientId ); ++ ++ // Suspend/resume hooks ++ virtual void prepareToSuspend(); ++ virtual void prepareToResume(); ++ // Rotation stuff ++ enum Transformation { None, Rot90, Rot180, Rot270 }; ++ void setTransformation( Transformation t ); ++ Transformation transformation() const; ++ virtual bool isTransformed() const { return trans != None; }; ++ virtual QSize mapToDevice( const QSize & ) const; ++ virtual QSize mapFromDevice( const QSize & ) const; ++ virtual QPoint mapToDevice( const QPoint &, const QSize & ) const; ++ virtual QPoint mapFromDevice( const QPoint &, const QSize & ) const; ++ virtual QRect mapToDevice( const QRect &, const QSize & ) const; ++ virtual QRect mapFromDevice( const QRect &, const QSize & ) const; ++ virtual QImage mapToDevice( const QImage & ) const; ++ virtual QImage mapFromDevice( const QImage & ) const; ++ virtual QRegion mapToDevice( const QRegion &, const QSize & ) const; ++ virtual QRegion mapFromDevice( const QRegion &, const QSize & ) const; ++ virtual int transformOrientation() const; ++ ++protected: ++ bool w100init(); ++ void w100shutdown(); ++ Transformation trans; ++ static Transformation getTransSpec( const QString &dspec ); ++ static void clearCache( QScreen *instance, int clientId ); ++ QMap< uchar*, HWSurface > surfaceMap; ++ int vramoffset; ++ bool m_isServer; ++ virtual int pixmapLinestepAlignment() { return 128; } ++}; ++ ++template ++class QGfxW100 : public QGfxRaster { ++ ++public: ++ QGfxW100( unsigned char *b, int w, int h ); ++ virtual void drawLine( int, int, int, int); ++ virtual void fillRect( int, int, int, int); ++ virtual void blt( int, int, int, int, int, int ); ++ virtual void sync(); ++ virtual void setOffset( int x, int y ); ++ virtual void setPen( const QPen & p ); ++ ++ virtual void drawPolyline( const QPointArray &, int, int ); ++ virtual void drawPolygon( const QPointArray &, bool, int, int ); ++ virtual void drawPoint( int, int ); ++ virtual void drawPoints( const QPointArray &, int, int ); ++ virtual void scroll( int, int, int, int, int, int ); ++ virtual void tiledBlt( int rx, int ry, int w, int h ); ++ ++ inline int tx( int x, int y ) { ++ switch ( qt_w100_screen->transformation() ) { ++ case QW100Screen::Rot90: ++ return y - this->xoffs + this->yoffs; ++ case QW100Screen::Rot180: ++ return ( this->width - x - 1) - this->xoffs - this->xoffs; ++ case QW100Screen::Rot270: ++ return ( this->height - y - 1) - this->xoffs - this->yoffs; ++ default: ++ return x; ++ } ++ } ++ inline int ty( int x, int y ) { ++ switch ( qt_w100_screen->transformation() ) { ++ case QW100Screen::Rot90: ++ return (this->width - x - 1) - this->yoffs - this->xoffs; ++ case QW100Screen::Rot180: ++ return (this->height - y - 1) - this->yoffs - this->yoffs; ++ case QW100Screen::Rot270: ++ return x - this->yoffs + this->xoffs; ++ default: ++ return y; ++ } ++ } ++ ++protected: ++ bool checkDest( bool setsrc = false ); ++ bool checkSourceDest(); ++ virtual void setSourceWidgetOffset( int x, int y ); ++ void processSpans( int n, QPoint* point, int* width ); ++ bool inDraw; ++ ++ virtual void dDrawLine( int, int, int, int); ++ virtual void dFillRect( int, int, int, int); ++ virtual void dBlt( int, int, int, int, int, int ); ++ void dDrawPolyline( const QPointArray &, int, int ); ++ void dDrawPolygon( const QPointArray &, bool, int, int ); ++ void dDrawPoint( int, int ); ++ void dDrawPoints( const QPointArray &, int, int ); ++ void dScroll( int, int, int, int, int, int ); ++ void dTiledBlt( int rx, int ry, int w, int h ); ++}; ++ ++template ++QGfxW100::QGfxW100( unsigned char * b, int w, int h ) ++ : QGfxRaster(b, w, h), ++ inDraw( false ) ++{ ++} ++ ++template ++inline void QGfxW100::setOffset( int x, int y ) ++{ ++ QGfxRaster::setOffset( x, y ); ++} ++ ++namespace { ++ QString penStyleStr( const QPen &pen ) ++ { ++ QString res; ++ switch( pen.style() ) { ++ case Qt::NoPen: ++ res = "NoPen"; ++ break; ++ case Qt::SolidLine: ++ res = "SolidLine"; ++ break; ++ case Qt::DashLine: ++ res = "DashLine"; ++ break; ++ case Qt::DotLine: ++ res = "DotLine"; ++ break; ++ case Qt::DashDotLine: ++ res = "DashDotLine"; ++ break; ++ case Qt::DashDotDotLine: ++ res = "DashDotDotLine"; ++ break; ++ default: ++ res = "Unknown"; ++ } ++ return res; ++ } ++} ++ ++template ++inline void QGfxW100::setPen( const QPen &p ) ++{ ++ QGfxRaster::setPen( p ); ++} ++ ++template ++inline bool QGfxW100::checkSourceDest() ++{ ++ if ( !checkDest() ) { ++ return FALSE; ++ } ++ ++ int sourcepixelpitch; ++ ulong src_buffer_offset; ++ if ( this->srctype == this->SourcePen ) { ++ src_buffer_offset = -1; ++ return FALSE; ++ } else { ++ if ( !qt_screen->onCard( this->srcbits, src_buffer_offset ) ) { ++ return FALSE; ++ } ++ sourcepixelpitch = ( this->srclinestep * 8 ) / this->srcdepth; ++ driver.setSrcPitchOffset( sourcepixelpitch, ++ src_buffer_offset ); ++ } ++ return TRUE; ++} ++ ++template< const int depth, const int type> ++inline bool QGfxW100::checkDest( bool setsrc ) ++{ ++ //Main framebuffer should be registered as a hardware surface ++ ulong buffer_offset; ++ if ( !qt_screen->onCard( this->buffer, buffer_offset ) ) { ++ return FALSE; ++ } ++ int pixelstep = ( this->linestep() * 8 ) / depth; ++ driver.setDstPitchOffset( pixelstep, buffer_offset ); ++ if ( setsrc ) { ++ driver.setSrcPitchOffset( pixelstep, buffer_offset ); ++ } ++ return TRUE; ++} ++ ++template ++void QGfxW100::drawLine( int x1, int y1, int x2, int y2 ) ++{ ++ if ( inDraw ) { ++ dDrawLine( x1, y1, x2, y2 ); ++ } else { ++ inDraw = true; ++ dDrawLine( tx(x1,y1), ty(x1,y1), ++ tx(x2,y2), ty(x2,y2) ); ++ inDraw = false; ++ } ++} ++ ++template ++void QGfxW100::dDrawLine( int x1, int y1, int x2, int y2 ) ++{ ++ if ( ( this->ncliprect < 1) || ++ ( this->cpen.style() == this->NoPen ) ) { ++ return; ++ } ++ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::DRAWLINE ) ) { ++ driver.addMiss( W100Driver::DRAWLINE ); ++ QGfxRaster::drawLine( x1, y1, x2, y2 ); ++ return; ++ } ++ ++ // Only handle 'normal' lines ++ if ( ( this->cpen.style() != this->SolidLine ) || ++ ( this->myrop != this->CopyROP ) || ++ ( this->cpen.width() > 1 ) || ++ ( this->dashedLines ) ) { ++ driver.addMiss( W100Driver::DRAWLINE ); ++ QGfxRaster::drawLine( x1, y1, x2, y2); ++ return; ++ } ++ ++ // Stop anyone else trying to access optype/lastop/the graphics engine ++ // to avoid synchronization problems with other processes ++ QWSDisplay::grab( true ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ driver.addMiss( W100Driver::DRAWLINE ); ++ QGfxRaster::drawLine( x1, y1, x2, y2 ); ++ return; ++ } ++ ++ ++ // Note that the last operation used the 2d engine ++ ( *optype ) = 1; ++ ++ // Add the offset of the gfx - used to make the origin the right ++ // place for windows ++ x1 += this->xoffs; ++ y1 += this->yoffs; ++ x2 += this->xoffs; ++ y2 += this->yoffs; ++ ++ QRect boundRect( x1 < x2 ? x1: x2, ++ y1 < y2 ? y1 : y2, ++ QABS( x2 - x1 ) + 1, ++ QABS( y2 - y1 ) + 1 ); ++ ++ GFX_START( boundRect ); ++ ++ // The clip region is defined as a series of rectangles ++ // We repeatedly set up the hardware clip rectangle to one of ++ // these rectangles and re-draw the line - an alternative approach ++ // would be to clip to the rectangle in software ++ ++ driver.setDstType( DSTTYPE_16BPP_1555 ); ++ driver.setSrcType( SRCTYPE_EQU_DST ); ++ driver.setRopOperation( ROP3_PATCOPY ); ++ driver.brushType( 6, 0 ); ++ driver.setFrgColour( this->cpen.color().rgb() ); ++ driver.addHit( W100Driver::DRAWLINE ); ++ ++ //The imageon seems not to write on the edge of the clip ++ //for the polyline op. ++ //We are using a three points array repeating the last point ++ //to get the last single point painted. ++ ATI_POINT points[3]; ++ points[0].XCoord = x1; ++ points[0].YCoord = y1; ++ points[1].XCoord = x2; ++ points[1].YCoord = y2; ++ points[2].XCoord = x2; ++ points[2].YCoord = y2; ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ if ( boundRect.intersects( this->cliprect[loopc] ) ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ driver.setDstClippingRect( &clip ); ++ driver.polyline( 3, points ); ++ } ++ } ++ ++ // Software mouse cursor stuff ++ GFX_END; ++ ++ // Release display again - not doing so will cause Qt/Embedded applications ++ // to deadlock ++ QWSDisplay::ungrab(); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPolyline( const QPointArray &a, ++ int index, ++ int npoints ) ++{ ++ if ( inDraw ) { ++ dDrawPolyline( a, index, npoints ); ++ } else { ++ inDraw = true; ++ QPointArray na( npoints ); ++ ++ for ( int i = 0; i < npoints; i++ ) { ++ int x, y; ++ a.point( i+index, &x, &y ); ++ na.setPoint( i, tx(x,y), ty(x,y) ); ++ } ++ ++ dDrawPolyline( na, 0, npoints ); ++ inDraw = false; ++ } ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::dDrawPolyline( const QPointArray &a, ++ int index, ++ int npoints ) ++{ ++ if ( ( this->ncliprect < 1 ) || ++ ( npoints < 1 ) || ++ ( this->cpen.style() == this->NoPen ) ) { ++ return; ++ } ++ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::POLYLINE ) ) { ++ driver.addMiss( W100Driver::POLYLINE ); ++ QGfxRaster::drawPolyline( a, index, npoints ); ++ return; ++ } ++ ++ if ( this->cpen.style() != this->SolidLine || ++ this->myrop != this->CopyROP ) { ++ driver.addMiss( W100Driver::POLYLINE ); ++ QGfxRaster::drawPolyline( a, index, npoints ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ driver.addMiss( W100Driver::POLYLINE ); ++ QGfxRaster::drawPolyline( a, index, npoints ); ++ return; ++ } ++ ++ ( *optype ) = 1; ++ ++ driver.setDstType( DSTTYPE_16BPP_1555 ); ++ driver.setSrcType( SRCTYPE_EQU_DST ); ++ driver.setRopOperation( ROP3_PATCOPY ); ++ driver.brushType( 6, 0 ); ++ driver.setFrgColour( this->cpen.color().rgb() ); ++ ++ driver.addHit( W100Driver::POLYLINE ); ++ ++ ATI_POINT *points = new ATI_POINT[ npoints + 1 ]; ++ ++ for ( int i = 0; i < npoints; i++ ) { ++ points[i].XCoord = a[i+index].x() + this->xoffs; ++ points[i].YCoord = a[i+index].y() + this->yoffs; ++ } ++ //Hack to get the last point of the last line painted ++ points[ npoints ] = points[ npoints - 1 ]; ++ ++ ++ GFX_START( clipbounds ); ++ driver.setFrgColour( this->cpen.color().rgb() ); ++ driver.setRopOperation( ROP3_PATCOPY ); ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ driver.setDstClippingRect( &clip ); ++ driver.polyline( npoints + 1, points ); ++ } ++ GFX_END; ++ ++ delete [] points; ++ ++ QWSDisplay::ungrab(); ++} ++ ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPolygon( const QPointArray &a, ++ bool w, int index, ++ int npoints ) ++{ ++ if ( inDraw || this->cpen.style()==this->NoPen || this->patternedbrush ) { ++ //slowpath ++ dDrawPolygon( a, w, index, npoints ); ++ } else { ++ inDraw = TRUE; ++ QPointArray na( npoints ); ++ ++ for ( int i = 0; i < npoints; i++ ) { ++ int x,y; ++ a.point( i+index, &x, &y ); ++ na.setPoint( i, tx(x,y), ty(x,y) ); ++ } ++ dDrawPolygon( na, w, 0, npoints ); ++ inDraw = FALSE; ++ } ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::dDrawPolygon( const QPointArray &a, bool w, int index, int npoints ) ++{ ++ QGfxRaster::drawPolygon( a, w, index, npoints ); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPoint( int x, int y ) ++{ ++ dDrawPoint( tx( x, y ), ty( x, y ) ); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::dDrawPoint( int x, int y ) ++{ ++ ++ if ( this->ncliprect < 1 ) { ++ return; ++ } ++ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::DRAWPOINT) ) { ++ driver.addMiss( W100Driver::DRAWPOINT ); ++ QGfxRaster::drawPoint( x, y ); ++ return; ++ } ++ ++ if ( this->cpen.style() != this->SolidLine || ++ this->myrop != this->CopyROP ) { ++ driver.addMiss( W100Driver::DRAWPOINT ); ++ QGfxRaster::drawPoint( x, y ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ driver.addMiss( W100Driver::DRAWPOINT ); ++ QGfxRaster::drawPoint( x, y ); ++ return; ++ } ++ ++ driver.addHit( W100Driver::DRAWPOINT ); ++ ( *optype ) = 1; ++ ++ ATI_POINT point; ++ point.XCoord = x + this->xoffs; ++ point.YCoord = y + this->yoffs; ++ ++ GFX_START( clipbounds ); ++ driver.setFrgColour( this->cpen.color().rgb() ); ++ driver.setRopOperation( ROP3_PATCOPY ); ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ driver.setDstClippingRect( &clip ); ++ driver.drawPixel( 1, &point ); ++ } ++ GFX_END; ++ QWSDisplay::ungrab(); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::drawPoints( const QPointArray &a, ++ int index, ++ int npoints ) ++{ ++ QPointArray na( npoints ); ++ ++ for ( int i = 0; i < npoints; i++ ) { ++ int x, y; ++ a.point( i+index, &x, &y ); ++ na.setPoint( i, tx( x, y ), ty( x, y ) ); ++ } ++ ++ dDrawPoints( na, 0, npoints ); ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::dDrawPoints( const QPointArray &a, ++ int index, ++ int npoints ) ++{ ++ if ( ( this->ncliprect < 1 ) || ( npoints < 1 ) ) { ++ return; ++ } ++ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::DRAWPOINTS ) ) { ++ driver.addMiss( W100Driver::DRAWPOINTS ); ++ QGfxRaster::drawPoints( a, index, npoints ); ++ return; ++ } ++ ++ if ( this->cpen.style() != this->SolidLine || ++ this->myrop != this->CopyROP ) { ++ driver.addMiss( W100Driver::DRAWPOINTS ); ++ QGfxRaster::drawPoints( a, index, npoints ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ if ( !checkDest() ) { ++ QWSDisplay::ungrab(); ++ driver.addMiss( W100Driver::DRAWPOINTS ); ++ QGfxRaster::drawPoints( a, index, npoints ); ++ return; ++ } ++ ++ driver.addHit( W100Driver::DRAWPOINTS ); ++ ( *optype ) = 1; ++ ++ ATI_POINT *points = new ATI_POINT[ npoints ]; ++ for ( int i = 0; i < npoints; i++ ) { ++ points[i].XCoord = a[i+index].x() + this->xoffs; ++ points[i].YCoord = a[i+index].y() + this->yoffs; ++ } ++ ++ GFX_START( clipbounds ); ++ driver.setFrgColour( this->cpen.color().rgb() ); ++ driver.setRopOperation( ROP3_PATCOPY ); ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[loopc].x(); ++ clip.Y_Top_Left = this->cliprect[loopc].y(); ++ clip.X_Bottom_Right = this->cliprect[loopc].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[loopc].bottom() + 1; ++ driver.setDstClippingRect( &clip ); ++ driver.drawPixel( npoints, points ); ++ } ++ GFX_END; ++ ++ delete [] points; ++ QWSDisplay::ungrab(); ++} ++ ++template ++void QGfxW100::scroll( int x, int y, int w, int h, int sx, int sy ) ++{ ++ if ( w == 0 || h == 0 ) ++ return; ++ QRect r; ++ QRect s; ++ if ( inDraw ) { ++ r = QRect( x, y, w, h ); ++ s = QRect( sx, sy, w, h ); ++ } else { ++ r.setCoords( tx(x,y), ty(x,y), tx(x+w-1,y+h-1), ty(x+w-1,y+h-1) ); ++ s.setCoords( tx(sx,sy), ty(sx,sy), tx(sx+w-1,sy+h-1), ty(sx+w-1,sy+h-1) ); ++ r = r.normalize(); ++ s = s.normalize(); ++ } ++ dScroll( r.x(), r.y(), r.width(), r.height(), s.x(), s.y() ); ++} ++ ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::dScroll( int rx, int ry, ++ int w, int h, ++ int sx, int sy ) ++{ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::SCROLL ) ) { ++ driver.addMiss( W100Driver::SCROLL ); ++ QGfxRaster::scroll( rx, ry, w, h, sx, sy ); ++ return; ++ } ++ ++ if ( this->ncliprect < 1 ) return; ++ ++ if ( ( w < 1 ) || ( h < 1 ) ) return; ++ ++ int dy = sy - ry; ++ int dx = sx - rx; ++ ++ if ( dx == 0 && dy == 0 ) return; ++ ++ ++ QWSDisplay::grab( TRUE ); ++ ++ if ( checkDest( true ) ) { ++ ++ rx += this->xoffs; ++ sx += this->xoffs; ++ ry += this->yoffs; ++ sy += this->yoffs; ++ ++ QRect boundRect( QMIN( rx , sx ), ++ QMIN( ry , sy ), ++ w + QABS( dx ) + 1, ++ h + QABS( dy ) + 1 ); ++ GFX_START( boundRect ); ++ ( *optype ) = 1; ++ ++ ++ //if ( driver.lastOp() != W100Driver::SCROLL ) { ++ driver.setRopOperation( ROP3_SRCCOPY ); ++ driver.setDstType( DSTTYPE_16BPP_1555 ); ++ driver.setSrcType( SRCTYPE_EQU_DST ); ++ //} ++ ++ driver.addHit( W100Driver::SCROLL ); ++ ++ ATI_RECT srcrect, dstrect; ++ ++ srcrect.XCoord = sx; ++ srcrect.YCoord = sy; ++ srcrect.Width = w; ++ srcrect.Height = h; ++ dstrect.XCoord = rx; ++ dstrect.YCoord = ry; ++ dstrect.Width = w; ++ dstrect.Height = h; ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ if ( boundRect.intersects( this->cliprect[loopc] ) ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[ loopc ].x(); ++ clip.Y_Top_Left = this->cliprect[ loopc ].y(); ++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1; ++ driver.setDstClippingRect( &clip ); ++ driver.bitBlt( 1, &dstrect, &srcrect ); ++ } ++ } ++ GFX_END; ++ QWSDisplay::ungrab(); ++ ++ } else { ++ QWSDisplay::ungrab(); ++ // software fallback ++ driver.addMiss( W100Driver::SCROLL ); ++ QGfxRaster::scroll( rx, ry, w, h, sx, sy ); ++ } ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::fillRect( int x, int y, int w, int h ) ++{ ++ if ( w == 0 || h == 0 ) ++ return; ++ QRect r( x, y, w, h ); ++ r.setCoords( tx( x, y ), ty( x, y ), ++ tx( x + w - 1, y + h - 1 ), ty( x + w - 1, y + h - 1 ) ); ++ r = r.normalize(); ++ inDraw = TRUE; ++ dFillRect( r.x(), r.y(), r.width(), r.height() ); ++ inDraw = FALSE; ++} ++ ++template< const int depth, const int type > ++void QGfxW100< depth, type>::dFillRect( int rx, int ry, int w, int h ) ++{ ++ if ( w <= 0 || h <= 0 || this->ncliprect < 1 ) return; ++ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::FILLRECT ) ) { ++ driver.addMiss( W100Driver::FILLRECT ); ++ QGfxRaster::fillRect( rx, ry, w, h ); ++ return; ++ } ++ ++ if ( ( this->cbrush.style() != this->NoBrush ) && ++ ( this->cbrush.style() != this->SolidPattern ) ) { ++ driver.addMiss( W100Driver::FILLRECT ); ++ QGfxRaster::fillRect( rx, ry, w, h ); ++ return; ++ } ++ ++ if ( !checkDest() || ( this->myrop != this->CopyROP ) ) { ++ driver.addMiss( W100Driver::FILLRECT ); ++ QGfxRaster::fillRect( rx, ry, w, h ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ rx += this->xoffs; ++ ry += this->yoffs; ++ ++ QRect boundRect( rx, ry, w + 1, h + 1 ); ++ GFX_START( boundRect ); ++ ++ ( *optype ) = 1; ++ ++ driver.setDstType( DSTTYPE_16BPP_1555 ); ++ driver.setSrcType( SRCTYPE_EQU_DST ); ++ driver.setRopOperation( ROP3_PATCOPY ); ++ driver.brushType( 6, 0 ); ++ driver.setFrgColour( this->cbrush.color().rgb() ); ++ ++ driver.addHit( W100Driver::FILLRECT ); ++ ++ if ( this->cbrush.style() != this->NoBrush ) { ++ //Using all the cliprects ++ for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ if ( boundRect.intersects( this->cliprect[loopc] ) ) { ++ ATI_CLIPRECT clip; ++ ATI_RECT rect; ++ ++ clip.X_Top_Left = this->cliprect[ loopc ].x(); ++ clip.Y_Top_Left = this->cliprect[ loopc ].y(); ++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1; ++ ++ driver.setDstClippingRect( &clip ); ++ rect.XCoord = rx; ++ rect.YCoord = ry; ++ rect.Width = w; ++ rect.Height = h; ++ driver.paintRect( 1, &rect ); ++ } ++ } ++ } ++ GFX_END; ++ ++ QWSDisplay::ungrab(); ++} ++ ++template ++void QGfxW100::blt( int x, int y, int w, int h, int sx, int sy ) ++{ ++ if ( w == 0 || h == 0 ) ++ return; ++ QRect r; ++ int rsx; ++ int rsy; ++ if ( inDraw ) { ++ r = QRect( x, y, w, h ); ++ rsx = sx; ++ rsy = sy; ++ } else { ++ r.setCoords( tx(x,y), ty(x,y), tx(x+w-1,y+h-1), ty(x+w-1,y+h-1) ); ++ r = r.normalize(); ++ switch ( qt_w100_screen->transformation() ) { ++ case QW100Screen::Rot90: ++ rsx = sy; ++ rsy = this->srcwidth - sx - w; ++ break; ++ case QW100Screen::Rot180: ++ rsx = this->srcwidth - sx - w; ++ rsy = this->srcheight - sy - h; ++ break; ++ case QW100Screen::Rot270: ++ rsx = this->srcheight - sy - h; ++ rsy = sx; ++ break; ++ default: ++ rsx = sx; ++ rsy = sy; ++ break; ++ } ++ } ++ dBlt( r.x(), r.y(), r.width(), r.height(), rsx, rsy ); ++} ++ ++template< const int depth, const int type > ++inline void QGfxW100< depth, type>::dBlt( int rx, int ry, ++ int w, int h, ++ int sx, int sy ) ++{ ++ if ( !w || !h || this->ncliprect < 1 ) { ++ return; ++ } ++ ++ if ( depth != 16 || ++ !driver.accelerated( W100Driver::BITBLT ) ) { ++ driver.addMiss( W100Driver::BITBLT ); ++ QGfxRaster::blt( rx, ry, w, h, sx, sy ); ++ return; ++ } ++ ++ if ( this->alphatype == this->BigEndianMask || ++ this->alphatype == this->LittleEndianMask || ++ this->alphatype == this->SeparateAlpha || ++ this->srctype == this->SourcePen || ++ ( this->myrop != this->CopyROP ) ) { ++ driver.addMiss( W100Driver::BITBLT ); ++ QGfxRaster::blt( rx, ry, w, h, sx, sy ); ++ return; ++ } ++ ++ if ( ( this->srcdepth != 16 ) || this->alphatype != this->IgnoreAlpha ) { ++ driver.addMiss( W100Driver::BITBLT ); ++ QGfxRaster::blt( rx, ry, w, h, sx, sy ); ++ return; ++ } ++ ++ QWSDisplay::grab( TRUE ); ++ ++ if ( checkSourceDest() ) { ++ QRect boundRect( rx + this->xoffs, ry + this->yoffs, ++ w + 1, h + 1 ); ++ GFX_START( boundRect ); ++ ( *optype ) = 1; ++ ++ driver.setRopOperation( ROP3_SRCCOPY ); ++ driver.setDstType( DSTTYPE_16BPP_1555 ); ++ driver.setSrcType( SRCTYPE_EQU_DST ); ++ ++ driver.addHit( W100Driver::BITBLT ); ++ ++ ATI_RECT rect1; ++ ATI_RECT rect2; ++ ++ rx += this->xoffs; ++ ry += this->yoffs; ++ ++ rect1.XCoord = this->srcwidgetoffs.x() + sx; ++ rect1.YCoord = this->srcwidgetoffs.y() + sy; ++ rect1.Width = w; ++ rect1.Height = h; ++ rect2.XCoord = rx; ++ rect2.YCoord = ry; ++ rect2.Width = w; ++ rect2.Height = h; ++ for(int loopc = 0; loopc < this->ncliprect; loopc++ ) { ++ if ( boundRect.intersects( this->cliprect[loopc] ) ) { ++ ATI_CLIPRECT clip; ++ clip.X_Top_Left = this->cliprect[ loopc ].x(); ++ clip.Y_Top_Left = this->cliprect[ loopc ].y(); ++ clip.X_Bottom_Right = this->cliprect[ loopc ].right() + 1; ++ clip.Y_Bottom_Right = this->cliprect[ loopc ].bottom() + 1; ++ driver.setDstClippingRect( &clip ); ++ driver.bitBlt( 1, &rect2, &rect1 ); ++ } ++ } ++ GFX_END; ++ ++ QWSDisplay::ungrab(); ++ return; ++ } else { ++ QWSDisplay::ungrab(); ++ driver.addMiss( W100Driver::BITBLT ); ++ QGfxRaster::blt( rx, ry, ++ w, h, sx, sy ); ++ } ++} ++ ++ ++template ++void QGfxW100::tiledBlt( int rx,int ry,int w,int h ) ++{ ++ if ( w <= 0 || h <= 0 ) ++ return; ++ QRect r; ++ if ( inDraw ) { ++ r = QRect(rx,ry,w,h); ++ } else { ++ r.setCoords( tx(rx,ry), ty(rx,ry), tx(rx+w-1,ry+h-1), ty(rx+w-1,ry+h-1) ); ++ r = r.normalize(); ++ } ++ ++ inDraw = TRUE; ++ ++ QPoint oldBrushOffs = this->brushoffs; ++ int brx, bry; ++ switch ( qt_w100_screen->transformation() ) { ++ case QW100Screen::Rot90: ++ brx = this->brushoffs.y(); ++ bry = this->srcwidth - this->brushoffs.x() - w; ++ break; ++ case QW100Screen::Rot180: ++ brx = this->srcwidth - this->brushoffs.x() - w; ++ bry = this->srcheight - this->brushoffs.y() - h; ++ break; ++ case QW100Screen::Rot270: ++ brx = this->srcheight - this->brushoffs.y() - h; ++ bry = this->brushoffs.x(); ++ break; ++ default: ++ brx = this->brushoffs.x(); ++ bry = this->brushoffs.y(); ++ break; ++ } ++ this->brushoffs = QPoint( brx, bry ); ++ ++ int oldsw = this->srcwidth; ++ int oldsh = this->srcheight; ++ QSize s = qt_screen->mapToDevice( QSize(this->srcwidth,this->srcheight) ); ++ this->srcwidth = s.width(); ++ this->srcheight = s.height(); ++ ++ dTiledBlt( r.x(), r.y(), r.width(), r.height() ); ++ ++ this->srcwidth = oldsw; ++ this->srcheight = oldsh; ++ this->brushoffs = oldBrushOffs; ++ inDraw = FALSE; ++} ++ ++ ++template ++void QGfxW100::dTiledBlt( int rx,int ry, int w,int h ) ++{ ++ if ( this->srcwidth == 0 || this->srcheight == 0 ) ++ return; ++ QGfxRaster::tiledBlt( rx, ry, w, h ); ++} ++ ++template ++void QGfxW100::sync() ++{ ++ driver.waitComplete( -1 ); ++} ++ ++template ++void QGfxW100::setSourceWidgetOffset(int x, int y) ++{ ++ if ( this->srcbits == this->buffer ) { ++ switch ( qt_w100_screen->transformation() ) { ++ case QW100Screen::Rot90: ++ this->srcwidgetoffs = QPoint( y, this->width - x - this->srcwidth ); ++ break; ++ case QW100Screen::Rot180: ++ this->srcwidgetoffs = QPoint( this->width - x - this->srcwidth, this->height - y - this->srcheight ); ++ break; ++ case QW100Screen::Rot270: ++ this->srcwidgetoffs = QPoint( this->height - y - this->srcheight, x ); ++ break; ++ default: ++ this->srcwidgetoffs = QPoint( x, y ); ++ break; ++ } ++ } else { ++ this->srcwidgetoffs = QPoint( x, y ); ++ } ++} ++ ++template ++void QGfxW100::processSpans( int n, QPoint* point, int* width ) ++{ ++ if ( inDraw || ++ this->patternedbrush && ++ this->srcwidth != 0 && ++ this->srcheight != 0 ) { ++ //in the patternedbrush case, we let blt do the transformation ++ // so we leave inDraw false. ++ QGfxRaster::processSpans( n, point, width ); ++ } else { ++ inDraw = true; ++ while (n--) { ++ if ( *width > 0 ) { ++ int x=tx(point->x(),point->y())+this->xoffs; ++ int y=ty(point->x(),point->y())+this->yoffs; ++ ++ switch( qt_w100_screen->transformation() ) { ++ case QW100Screen::Rot90: ++ this->vline( x, y-(*width-1), y ); ++ break; ++ case QW100Screen::Rot180: ++ this->hline( x - (*width-1), x, y ); ++ break; ++ case QW100Screen::Rot270: ++ this->vline( x, y, y+*width-1 ); ++ break; ++ default: ++ this->hline( x, x+*width-1, y ); ++ break; ++ } ++ } ++ point++; ++ width++; ++ } ++ inDraw = false; ++ } ++} ++ ++QW100Screen::QW100Screen( int display_id ) ++ :QLinuxFbScreen( display_id ), ++ vramoffset( 0 ), ++ m_isServer( false ) ++{ ++ qt_w100_screen = this; ++ vramoffset = 0; ++ clearCacheFunc = &clearCache; ++ trans = None; ++} ++ ++static const char *trans2str( QW100Screen::Transformation t ) ++{ ++ switch( t ) { ++ case QW100Screen::None: ++ return "None"; ++ break; ++ case QW100Screen::Rot90: ++ return "Rot90"; ++ break; ++ case QW100Screen::Rot180: ++ return "Rot180"; ++ break; ++ case QW100Screen::Rot270: ++ return "Rot270"; ++ break; ++ default: ++ return "Unknown"; ++ break; ++ } ++} ++ ++QW100Screen::Transformation QW100Screen::getTransSpec( const QString &dspec ) ++{ ++ Transformation mytrans = None; ++ if ( dspec.find( ":Rot270" ) >= 0 ) { ++ mytrans = Rot270; ++ } else if ( dspec.find( ":Rot180" ) >= 0 ) { ++ mytrans = Rot180; ++ } else if ( dspec.find( ":Rot90" ) >= 0 ) { ++ mytrans = Rot90; ++ } ++ return mytrans; ++} ++ ++bool QW100Screen::connect( const QString &displaySpec ) ++{ ++ driver.log( W100Driver::WARNING, "QW100Screen::connect('%s')", ++ displaySpec.latin1() ); ++ trans = getTransSpec( displaySpec ); ++ ++ if ( QLinuxFbScreen::connect( displaySpec ) ) { ++ vramoffset = ( w == 320 ) ? 0 : 0x0f000000; ++ if ( driver.processAttach() == W100Driver::codOK ) { ++ driver.processAttachSpecialMode( ( w == 480 ) ? 0xaaab : 0xaaaa ); ++ surfaceMap.clear(); ++ surfaceMap.insert( 0, HWSurface( vramoffset, ++ data , false, ++ w*h*d/8 ) ); ++ canaccel = true; ++ QSize s = mapFromDevice( QSize( w, h ) ); ++ w = s.width(); ++ h = s.height(); ++ return true; ++ } ++ } ++ return false; ++} ++ ++void QW100Screen::disconnect( void ) ++{ ++ driver.log( W100Driver::WARNING, "QW100Screen::disconnect()" ); ++ driver.processDetachSpecialMode(); ++ driver.processDetach(); ++ QLinuxFbScreen::disconnect(); ++ printf( "[%d]QW100Screen disconnected with %d surfaces\n", ++ getpid(), surfaceMap.count() ); ++ surfaceMap.clear(); ++} ++ ++void QW100Screen::prepareToSuspend( void ) ++{ ++ ++ driver.log( W100Driver::WARNING, ++ "QW100Screen::prepareToSuspend. Server = %s", ++ m_isServer ? "true" : "false" ); ++ ++ QWSDisplay::grab( true ); ++ driver.waitComplete( -1 ); ++ ++ if ( !driver.attached() ) { ++ driver.log( W100Driver::ERROR, "Driver was not attached. " ); ++ } else { ++ driver.processDetachSpecialMode(); ++ driver.processDetach(); ++ } ++ QWSDisplay::ungrab(); ++ ++ driver.log( W100Driver::WARNING, "prepareToSuspend done" ); ++ ++} ++ ++void QW100Screen::prepareToResume( void ) ++{ ++ ++ driver.log( W100Driver::WARNING, ++ "QW100Screen::prepareToResume. Server = %s", ++ m_isServer ? "true": "false" ); ++ ++ driver.processAttach(); ++ driver.processAttachSpecialMode( ( w == 480 ) ? 0xaaab : 0xaaaa ); ++ if ( m_isServer ) { ++ QWSDisplay::grab( true ); ++ w100init(); ++ QWSDisplay::ungrab(); ++ driver.log( W100Driver::WARNING, "W100 restarted" ); ++ } ++ driver.log( W100Driver::WARNING, "prepareToResume done" ); ++ ++} ++ ++QW100Screen::~QW100Screen() ++{ ++} ++ ++bool QW100Screen::w100init() ++{ ++ driver.log( W100Driver::WARNING, ++ "QW100Screen::w100init(%dx%d)", dw, dh ); ++ ATI_GRAPHICWINDOW win; ++ ATI_CLIPRECT clip; ++ uint16_t overlay; ++ ++ win.dummy1 = 0; ++ win.Size.XCoord = 0; ++ win.Size.YCoord = 0; ++ win.Size.Width = dw; ++ win.Size.Height = dh; ++ win.Width = dw > dh ? dh : dw; ++ win.Height = dw > dh ? dw : dh; ++ win.Flag = DSTTYPE_16BPP_444; ++ ++ driver.waitComplete( -1 ); ++ driver.setGraphicWindowOnOff( 0 ); ++ ++ driver.setupGraphicWindow( &win ); ++ driver.setGraphicWindowPos( 0, 0 ); ++ ++ driver.setFrontBuffer( vramoffset, 0, 0 ); ++ driver.setDstPitchOffset( dw, vramoffset ); ++ driver.setDstType( DSTTYPE_16BPP_444 ); ++ driver.setSrcPitchOffset( dw, vramoffset ); ++ driver.setSrcType( SRCTYPE_SOLID_COLOR_BLT ); ++ clip.X_Top_Left = 0; ++ clip.Y_Top_Left = 0; ++ clip.X_Bottom_Right = dw; ++ clip.Y_Bottom_Right = dh; ++ driver.setDstClippingRect( &clip ); ++ ++ clip.X_Top_Left = 0xE000; ++ clip.Y_Top_Left = 0xE000; ++ clip.X_Bottom_Right = 0x1FFF; ++ clip.Y_Bottom_Right = 0x1FFF; ++ ++ driver.setSrcClippingRect( &clip ); ++ ++ driver.setRopOperation( ROP3_SRCCOPY ); ++ driver.setGraphicWindowOnOff( 1 ); ++ driver.allocOverlay( &overlay ); ++ driver.setOverlayOnOff( overlay, 0 ); ++ driver.releaseOverlay( overlay ); ++ driver.setDstPitchOffset( dw, vramoffset ); ++ driver.setDstClippingRect( NULL ); ++ for ( int i = 0; i < dw * dh ; i++ ) { ++ *( data + i ) = 0; ++ } ++ driver.waitComplete( -1 ); ++ return true; ++} ++ ++void QW100Screen::w100shutdown() ++{ ++} ++ ++bool QW100Screen::initDevice() ++{ ++ QWSDisplay::grab( true ); ++ driver.log( W100Driver::WARNING, "initDevice( dw=%d, dh=%d )", ++ dw, dh ); ++ m_isServer = true; ++ ++ if ( !w100init() ) { ++ QWSDisplay::ungrab(); ++ return false; ++ } ++ ++ if ( QLinuxFbScreen::initDevice() ) { ++ //HACK ++ //Some sprite corruption seems to be avoided ++ //reserving some upper memory on the offscreen framebuffer memory ++ QLinuxFbScreen::cache( 65535 * 2, 0 ); ++ QWSDisplay::ungrab(); ++ return true; ++ } ++ QWSDisplay::ungrab(); ++ return false; ++} ++ ++void QW100Screen::shutdownDevice() ++{ ++ driver.log( W100Driver::WARNING, "Shutting down device" ); ++ QLinuxFbScreen::shutdownDevice(); ++} ++ ++void QW100Screen::restore() ++{ ++ driver.log( W100Driver::WARNING, "Restoring W100..." ); ++ QLinuxFbScreen::restore(); ++ driver.log( W100Driver::WARNING, "Restoring done" ); ++} ++ ++ ++QGfx *QW100Screen::createGfx( unsigned char *b, ++ int w, int h, int d, int linestep ) ++{ ++ //We need ALL the gfx created to be QGfxW100 to allow software ++ //drawing syncing after hardware operations ++ QGfx * ret=0; ++ if ( false ) { ++#ifndef QT_NO_QWS_DEPTH_1 ++ } else if ( d == 1 ) { ++ ret = new QGfxW100<1,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_4 ++ } else if ( d == 4 ) { ++ ret = new QGfxW100<4,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_8 ++ } else if ( d == 8 ) { ++ ret = new QGfxW100<8,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_16 ++ } else if ( d == 16 ) { ++ ret = new QGfxW100<16,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_24 ++ } else if ( d == 24 ) { ++ ret = new QGfxW100<24,0>( b, w, h ); ++#endif ++#ifndef QT_NO_QWS_DEPTH_32 ++ } else if ( d == 32 ) { ++ ret = new QGfxW100<32,0>( b, w, h ); ++#endif ++ } else { ++ qFatal( "Unsupported depth %d\n", d ); ++ ret = 0; ++ } ++ ++ ret->setLineStep( linestep ); ++ return ret; ++} ++ ++ ++uchar *QW100Screen::cache( int amount, int optim ) ++{ ++ unsigned short hSurface = 0; ++ uint32_t surfaceOffset = 0; ++ uchar* localAddr = 0; ++ bool internal = false; ++ ++ /* The size must have 0xF bit zeroed (16 multiple)*/ ++ /* Perhaps this is not needed anymore, after setting ++ * QW100Screen::pixmapLinestepAlignment to 128 ++ */ ++ amount = ( amount & 0x0F ) ? ( amount | 0x10 ) & ~0x0F : amount; ++ ++ /* Experimenting memory corruption with the ++ * internal AtiCore memory allocation routines ++ * disabled for now ++ */ ++#if 1 ++ if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) { ++ return( 0 ); ++ } ++ surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t )data; ++ ++#else ++ int retcode = 0; ++ qt_fbdpy->grab( true ); ++ retcode = driver.allocateSurface( &hSurface, ++ &surfaceOffset, ++ amount, 1 ); ++ qt_fbdpy->ungrab(); ++ if ( retcode ) { ++ internal = true; ++ driver.setupMemoryTransfer( surfaceOffset, ++ (uint32_t*) &localAddr ); ++ driver.terminateMemoryTransfer(); ++ } else { ++ // Try to use the offscreen framebuffer memory ++ // to allocate the surface. Use the qgfxlinuxfb routines ++ if ( !( localAddr = QLinuxFbScreen::cache( amount, optim ) ) ) { ++ return( 0 ); ++ } ++ //Distance between physical vram start and surface should be ++ //the same than distance between logical addresses ++ surfaceOffset = vramoffset + ( uint32_t ) localAddr - ( uint32_t ) data; ++ } ++#endif ++ ++ HWSurface surface( hSurface, surfaceOffset, ++ localAddr, amount, ++ internal, ++ qws_client_id ); ++ surfaceMap.insert( surface.getAddr(), surface ); ++ return( ( uchar* ) localAddr ); ++} ++ ++void QW100Screen::uncache( uchar *c ) ++{ ++ QMap< uchar*, HWSurface >::Iterator itr; ++ if ( ( itr = surfaceMap.find( c ) ) != surfaceMap.end() ) { ++ driver.waitComplete( -1 ); ++ if ( itr.data().internal() ) { ++ qt_fbdpy->grab( true ); ++ driver.destroySurface( itr.data().getHandle() ); ++ qt_fbdpy->ungrab(); ++ } else { ++ QLinuxFbScreen::uncache( c ); ++ } ++ surfaceMap.remove( itr ); ++ } ++} ++ ++bool QW100Screen::onCard( uchar *p ) const ++{ ++ QMap< uchar*, HWSurface >::ConstIterator itr = surfaceMap.begin(); ++ for ( ; itr != surfaceMap.end(); itr++ ) { ++ uchar *begin; ++ if ( ( begin = itr.data().getAddr() ) <= p ) { ++ if ( ( itr.data().getSize() + begin ) >= p ) { ++ return TRUE; ++ } ++ } ++ } ++ return FALSE; ++} ++ ++bool QW100Screen::onCard( unsigned char *p, ulong& offset ) const ++{ ++ QMap< uchar*, HWSurface >::ConstIterator itr; ++ for ( itr = surfaceMap.begin(); itr != surfaceMap.end(); itr++ ) { ++ uchar *begin; ++ if ( ( begin = itr.data().getAddr() ) <= p ) { ++ if ( ( itr.data().getSize() + begin ) >= p ) { ++ offset = itr.data().getSOffset() + ( p - begin ); ++ return TRUE; ++ } ++ } ++ } ++ return FALSE; ++} ++ ++QMap< uchar*, QW100Screen::HWSurface > ++*QW100Screen::getPSurfaceMap( void ) const ++{ ++ return ( QMap *) &surfaceMap; ++} ++ ++void QW100Screen::clearCache( int clientId ) ++{ ++ printf( "[%d] CLEARING CACHE FOR %d\n", getpid(), clientId ); ++ driver.log( W100Driver::WARNING, "Cleaning cache for '%d'", clientId ); ++ QMap< uchar*, HWSurface >::Iterator itr = surfaceMap.begin(); ++ while ( itr != surfaceMap.end() ) { ++ if ( itr.data().getCId() == clientId ) { ++ if ( itr.data().internal() ) { ++ qt_fbdpy->grab(); ++ driver.destroySurface( itr.data().getHandle() ); ++ qt_fbdpy->ungrab(); ++ } ++ surfaceMap.remove( itr ); ++ } ++ itr++; ++ } ++ QLinuxFbScreen::clearCache( this, clientId ); ++} ++ ++void QW100Screen::clearCache( QScreen *instance, int clientId ) ++{ ++ QW100Screen *screen = reinterpret_cast ( instance ); ++ screen->clearCache( clientId ); ++} ++ ++void QW100Screen::setTransformation( Transformation t ) ++{ ++ qt_fbdpy->grab( true ); ++ trans = t; ++ ++ QSize s = mapFromDevice( QSize( dw,dh ) ); ++ w = s.width(); ++ h = s.height(); ++ qt_fbdpy->ungrab(); ++} ++ ++QW100Screen::Transformation QW100Screen::transformation( void ) const ++{ ++ return trans; ++} ++ ++QSize QW100Screen::mapToDevice( const QSize &s ) const ++{ ++ if ( trans == Rot90 || trans == Rot270 ) { ++ return QSize( s.height(), s.width() ); ++ } ++ ++ return s; ++} ++ ++QSize QW100Screen::mapFromDevice( const QSize &s ) const ++{ ++ if ( trans == Rot90 || trans == Rot270 ) { ++ return QSize( s.height(), s.width() ); ++ } ++ ++ return s; ++} ++ ++QPoint QW100Screen::mapToDevice( const QPoint &p, const QSize &s ) const ++{ ++ QPoint rp( p ); ++ ++ switch ( trans ) { ++ case Rot90: ++ rp.setX( p.y() ); ++ rp.setY( s.width() - p.x() - 1 ); ++ break; ++ case Rot180: ++ rp.setX( s.width() - p.x() - 1 ); ++ rp.setY( s.height() - p.y() - 1 ); ++ break; ++ case Rot270: ++ rp.setX( s.height() - p.y() - 1 ); ++ rp.setY( p.x() ); ++ break; ++ default: ++ break; ++ } ++ ++ return rp; ++} ++ ++QPoint QW100Screen::mapFromDevice( const QPoint &p, const QSize &s ) const ++{ ++ QPoint rp( p ); ++ ++ switch ( trans ) { ++ case Rot90: ++ rp.setX( s.height() - p.y() - 1 ); ++ rp.setY( p.x() ); ++ break; ++ case Rot180: ++ rp.setX( s.width() - p.x() - 1 ); ++ rp.setY( s.height() - p.y() - 1 ); ++ break; ++ case Rot270: ++ rp.setX( p.y() ); ++ rp.setY( s.width() - p.x() - 1 ); ++ break; ++ default: ++ break; ++ } ++ ++ return rp; ++} ++ ++QRect QW100Screen::mapToDevice( const QRect &r, const QSize &s ) const ++{ ++ QRect tr; ++ switch ( trans ) { ++ case Rot90: ++ tr.setCoords( r.y(), s.width() - r.x() - 1, ++ r.bottom(), s.width() - r.right() - 1 ); ++ break; ++ case Rot180: ++ tr.setCoords( s.width() - r.x() - 1, s.height() - r.y() - 1, ++ s.width() - r.right() - 1, s.height() - r.bottom() - 1 ); ++ break; ++ case Rot270: ++ tr.setCoords( s.height() - r.y() - 1, r.x(), ++ s.height() - r.bottom() - 1, r.right() ); ++ break; ++ default: ++ tr = r; ++ break; ++ } ++ ++ return tr.normalize(); ++} ++ ++QRect QW100Screen::mapFromDevice( const QRect &r, const QSize &s ) const ++{ ++ QRect tr; ++ switch ( trans ) { ++ case Rot90: ++ tr.setCoords( s.height() - r.y() - 1, r.x(), ++ s.height() - r.bottom() - 1, r.right() ); ++ break; ++ case Rot180: ++ tr.setCoords( s.width() - r.x() - 1, s.height() - r.y() - 1, ++ s.width() - r.right() - 1, s.height() - r.bottom() - 1 ); ++ break; ++ case Rot270: ++ tr.setCoords( r.y(), s.width() - r.x() - 1, ++ r.bottom(), s.width() - r.right() - 1 ); ++ break; ++ default: ++ tr = r; ++ break; ++ } ++ ++ return tr.normalize(); ++} ++ ++template ++static inline void rotateLoopTemplate( uchar *src, int srcBytesPerLine, ++ uchar *dst, int dstBytesPerLine, ++ int width, int height, ++ QW100Screen::Transformation trans, ++ bool mapToDevice ) ++{ ++ int dstXAdd = 0; ++ int dstYAdd = 0; ++ int dstXOfs = 0; ++ int dstYOfs = 0; ++ int srcYAdd = srcBytesPerLine - width * sizeof(T); ++ ++ if ( !mapToDevice ) { ++ if ( trans == QW100Screen::Rot90 ) ++ trans = QW100Screen::Rot270; ++ else if ( trans == QW100Screen::Rot270 ) ++ trans = QW100Screen::Rot90; ++ } ++ ++ switch ( trans ) { ++ case QW100Screen::Rot90: ++ dstXOfs = 0; ++ dstYOfs = width - 1; ++ dstXAdd = -dstBytesPerLine; ++ dstYAdd = 1 * sizeof(T) + width * dstBytesPerLine; ++ break; ++ case QW100Screen::Rot270: ++ dstXOfs = height - 1; ++ dstYOfs = 0; ++ dstXAdd = dstBytesPerLine; ++ dstYAdd = -1 * sizeof(T) - width * dstBytesPerLine; ++ break; ++ default: ++ dstXOfs = width - 1; ++ dstYOfs = height - 1; ++ dstXAdd = -1 * sizeof(T); ++ dstYAdd = -dstBytesPerLine + width * sizeof(T); ++ break; ++ }; ++ ++ T *dstPtr = (T *)(dst + dstYOfs * dstBytesPerLine) + dstXOfs; ++ T *srcPtr = (T *)src; ++ for ( int y = 0; y < height; y++ ) { ++ for ( int x = 0; x < width; x++ ) { ++ *dstPtr = *srcPtr++; ++ dstPtr = (T *)((uchar*)dstPtr + dstXAdd); // add dstXAdd number of bytes ++ } ++ srcPtr = (T *)((uchar*)srcPtr + srcYAdd); // add srcYAdd number of bytes ++ dstPtr = (T *)((uchar*)dstPtr + dstYAdd); // add dstYAdd number of bytes ++ } ++} ++ ++QImage QW100Screen::mapToDevice( const QImage &img ) const ++{ ++ if ( img.isNull() || trans == None ) ++ return img; ++ ++ int iw = img.width(); ++ int ih = img.height(); ++ int w = iw; ++ int h = ih; ++ if ( trans == Rot90 || trans == Rot270 ) { ++ w = ih; ++ h = iw; ++ } ++ ++ QImage rimg( w, h, img.depth(), img.numColors(), img.bitOrder() ); ++ ++ for ( int i = 0; i < img.numColors(); i++ ) { ++ rimg.colorTable()[i] = img.colorTable()[i]; ++ } ++ ++ // Optimized image rotation code for nice bit depths ++ int d = img.depth(); ++ if ( d == 8 || d == 16 || d == 32 ) { ++ int srcBytesPerLine = img.bytesPerLine(); ++ int dstBytesPerLine = rimg.bytesPerLine(); ++ uchar *srcBits = img.bits(); ++ uchar *dstBits = rimg.bits(); ++ switch ( d ) { ++ case 8: ++ rotateLoopTemplate( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, TRUE ); ++ break; ++ case 16: ++ rotateLoopTemplate( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, TRUE ); ++ break; ++ case 32: ++ rotateLoopTemplate( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, TRUE ); ++ break; ++ } ++ rimg.setAlphaBuffer( img.hasAlphaBuffer() ); ++ rimg.setOffset( img.offset() ); ++ return rimg; ++ } ++ ++ // Slower fall back code for image rotation for 1-bit and other depths ++#define ROTATE_LOOP( X, Y, VAL ) \ ++ for ( int y = 0; y < ih; y++ ) { \ ++ for ( int x = 0; x < iw; x++ ) { \ ++ rimg.setPixel( X, Y, VAL ); \ ++ } \ ++ } \ ++ break; ++ ++ if ( img.depth() > 8 ) { ++ switch ( trans ) { ++ case Rot90: ++ ROTATE_LOOP( y, iw - x - 1, img.pixel(x, y) ) ++ case Rot270: ++ ROTATE_LOOP( ih - y - 1, x, img.pixel(x, y) ); ++ default: ++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixel(x, y) ); ++ } ++ } else { ++ switch ( trans ) { ++ case Rot90: ++ ROTATE_LOOP( y, iw - x - 1, img.pixelIndex(x, y) ); ++ case Rot270: ++ ROTATE_LOOP( ih - y - 1, x, img.pixelIndex(x, y) ); ++ default: ++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixelIndex(x, y) ); ++ } ++ } ++ ++#undef ROTATE_LOOP ++ ++ rimg.setAlphaBuffer( img.hasAlphaBuffer() ); ++ rimg.setOffset( img.offset() ); ++ ++ return rimg; ++} ++ ++QImage QW100Screen::mapFromDevice( const QImage &img ) const ++{ ++ if ( img.isNull() || trans == None ) ++ return img; ++ ++ int iw = img.width(); ++ int ih = img.height(); ++ int w = iw; ++ int h = ih; ++ if ( trans == Rot90 || trans == Rot270 ) { ++ w = ih; ++ h = iw; ++ } ++ ++ QImage rimg( w, h, img.depth(), img.numColors(), img.bitOrder() ); ++ ++ for ( int i = 0; i < img.numColors(); i++ ) { ++ rimg.colorTable()[i] = img.colorTable()[i]; ++ } ++ ++ // Optimized image rotation code for nice bit depths ++ int d = img.depth(); ++ if ( d == 8 || d == 16 || d == 32 ) { ++ int srcBytesPerLine = img.bytesPerLine(); ++ int dstBytesPerLine = rimg.bytesPerLine(); ++ uchar *srcBits = img.bits(); ++ uchar *dstBits = rimg.bits(); ++ switch ( d ) { ++ case 8: ++ rotateLoopTemplate( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, FALSE ); ++ break; ++ case 16: ++ rotateLoopTemplate( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, FALSE ); ++ break; ++ case 32: ++ rotateLoopTemplate( srcBits, srcBytesPerLine, dstBits, dstBytesPerLine, iw, ih, trans, FALSE ); ++ break; ++ } ++ rimg.setAlphaBuffer( img.hasAlphaBuffer() ); ++ rimg.setOffset( img.offset() ); ++ return rimg; ++ } ++ ++ // Slower fall back code for image rotation for 1-bit and other depths ++#define ROTATE_LOOP( X, Y, VAL ) \ ++ for ( int y = 0; y < ih; y++ ) { \ ++ for ( int x = 0; x < iw; x++ ) { \ ++ rimg.setPixel( X, Y, VAL ); \ ++ } \ ++ } \ ++ break; ++ ++ if ( img.depth() > 8 ) { ++ switch ( trans ) { ++ case Rot90: ++ ROTATE_LOOP( ih - y - 1, x, img.pixel(x, y) ); ++ case Rot270: ++ ROTATE_LOOP( y, iw - x - 1, img.pixel(x, y) ) ++ default: ++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixel(x, y) ); ++ } ++ } else { ++ switch ( trans ) { ++ case Rot90: ++ ROTATE_LOOP( ih - y - 1, x, img.pixelIndex(x, y) ); ++ case Rot270: ++ ROTATE_LOOP( y, iw - x - 1, img.pixelIndex(x, y) ); ++ default: ++ ROTATE_LOOP( iw - x - 1, ih - y - 1, img.pixelIndex(x, y) ); ++ } ++ } ++ ++#undef ROTATE_LOOP ++ ++ rimg.setAlphaBuffer( img.hasAlphaBuffer() ); ++ rimg.setOffset( img.offset() ); ++ ++ return rimg; ++} ++ ++QRegion QW100Screen::mapToDevice( const QRegion &rgn, const QSize &s ) const ++{ ++ if ( trans == None ) ++ return rgn; ++ ++ QRegion trgn; ++ QArray a = rgn.rects(); ++ QRect tr; ++ const QRect *r = a.data(); ++ ++ int w = s.width(); ++ int h = s.height(); ++ int size = a.size(); ++ ++ switch ( trans ) { ++ case Rot270: ++ for ( int i = 0; i < size; i++, r++ ) { ++ tr.setCoords( h - r->y() - 1, r->x(), ++ h - r->bottom() - 1, r->right() ); ++ trgn |= tr.normalize(); ++ } ++ break; ++ case Rot90: ++ for ( int i = 0; i < size; i++, r++ ) { ++ tr.setCoords( r->y(), w - r->x() - 1, ++ r->bottom(), w - r->right() - 1 ); ++ trgn |= tr.normalize(); ++ } ++ break; ++ case Rot180: ++ for ( int i = 0; i < size; i++, r++ ) { ++ tr.setCoords( w - r->x() - 1, h - r->y() - 1, ++ w - r->right() - 1, h - r->bottom() - 1 ); ++ trgn |= tr.normalize(); ++ } ++ break; ++ default: ++ break; ++ } ++ return trgn; ++} ++ ++QRegion QW100Screen::mapFromDevice( const QRegion &rgn, const QSize &s ) const ++{ ++ if ( trans == None ) ++ return rgn; ++ ++ QRegion trgn; ++ QArray a = rgn.rects(); ++ const QRect *r = a.data(); ++ QRect tr; ++ ++ int w = s.width(); ++ int h = s.height(); ++ int size = a.size(); ++ ++ switch ( trans ) { ++ case Rot270: ++ for ( int i = 0; i < size; i++, r++ ) { ++ tr.setCoords( r->y(), w - r->x() - 1, ++ r->bottom(), w - r->right() - 1 ); ++ trgn |= tr.normalize(); ++ } ++ break; ++ case Rot90: ++ for ( int i = 0; i < size; i++, r++ ) { ++ tr.setCoords( h - r->y() - 1, r->x(), ++ h - r->bottom() - 1, r->right() ); ++ trgn |= tr.normalize(); ++ } ++ break; ++ case Rot180: ++ for ( int i = 0; i < size; i++, r++ ) { ++ tr.setCoords( w - r->x() - 1, h - r->y() - 1, ++ w - r->right() - 1, h - r->bottom() - 1 ); ++ trgn |= tr.normalize(); ++ } ++ break; ++ default: ++ break; ++ } ++ ++ return trgn; ++} ++ ++/*! ++ 0 = none ++ 1..3 = rotates 90..270 ++ 4..7 = mirrored 0..3 ++*/ ++int QW100Screen::transformOrientation() const ++{ ++ return (int)trans; ++} ++ ++ ++void qws_w100Transformation( int t ) ++{ ++ if ( qt_w100_screen ) { ++ qt_w100_screen->setTransformation( static_cast( t ) ); ++ } ++} ++ ++extern bool qws_accel; ++ ++extern "C" QScreen * qt_get_screen_w100( int display_id ) ++{ ++ return( new QW100Screen( display_id ) ); ++} +--- qt-2.3.10/src/kernel/qapplication_qws.cpp~w100 ++++ qt-2.3.10/src/kernel/qapplication_qws.cpp +@@ -1450,16 +1450,25 @@ + extern void qws_clearLoadedFonts(); + #endif + ++#ifndef QT_NO_QWS_W100 ++extern void qws_w100Transformation( int t ); ++#endif ++ + void QWSDisplay::setTransformation( int t ) + { +-#ifndef QT_NO_QWS_TRANSFORMED ++#if !defined(QT_NO_QWS_TRANSFORMED) || !defined(QT_NO_QWS_W100) + QRect mwr = qt_screen->mapToDevice(qt_maxWindowRect, + QSize(qt_screen->width(), qt_screen->height()) ); + + QPixmapCache::clear(); + qws_clearLoadedFonts(); + qws_mapPixmaps( TRUE ); ++#ifndef QT_NO_QWS_TRANSFORMED + qws_setScreenTransformation( t ); ++#endif ++#ifndef QT_NO_QWS_W100 ++ qws_w100Transformation( t ); ++#endif + qws_mapPixmaps( FALSE ); + + if ( qt_fbdpy->d->directServerConnection() ) { diff --git a/recipes-qt/qte/qte-2.3.10/c7x0-w100-gcc4.patch b/recipes-qt/qte/qte-2.3.10/c7x0-w100-gcc4.patch new file mode 100644 index 0000000..101f959 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/c7x0-w100-gcc4.patch @@ -0,0 +1,31 @@ +diff --git a/src/kernel/qgfxw100_qws.cpp b/src/kernel/qgfxw100_qws.cpp +index cbc42d6..b5dfe31 100644 +--- a/src/kernel/qgfxw100_qws.cpp ++++ b/src/kernel/qgfxw100_qws.cpp +@@ -1250,7 +1250,7 @@ void QGfxW100< depth, type>::dDrawPolyline( const QPointArray &a, + points[ npoints ] = points[ npoints - 1 ]; + + +- GFX_START( clipbounds ); ++ GFX_START( this->clipbounds ); + driver.setFrgColour( this->cpen.color().rgb() ); + driver.setRopOperation( ROP3_PATCOPY ); + for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { +@@ -1341,7 +1341,7 @@ void QGfxW100< depth, type>::dDrawPoint( int x, int y ) + point.XCoord = x + this->xoffs; + point.YCoord = y + this->yoffs; + +- GFX_START( clipbounds ); ++ GFX_START( this->clipbounds ); + driver.setFrgColour( this->cpen.color().rgb() ); + driver.setRopOperation( ROP3_PATCOPY ); + for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { +@@ -1413,7 +1413,7 @@ void QGfxW100< depth, type>::dDrawPoints( const QPointArray &a, + points[i].YCoord = a[i+index].y() + this->yoffs; + } + +- GFX_START( clipbounds ); ++ GFX_START( this->clipbounds ); + driver.setFrgColour( this->cpen.color().rgb() ); + driver.setRopOperation( ROP3_PATCOPY ); + for ( int loopc = 0; loopc < this->ncliprect; loopc++ ) { diff --git a/recipes-qt/qte/qte-2.3.10/daemonize.patch b/recipes-qt/qte/qte-2.3.10/daemonize.patch new file mode 100644 index 0000000..487a18c --- /dev/null +++ b/recipes-qt/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 ++#include + + #if defined(_OS_AIX_) && defined(_CC_GNU_) + #include +@@ -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 ++ * 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 + * Added a new command line option which only is relevant if the application is created as a GuiServer. + * The option is -terminal , where specifies the virtual terminal to be occupied by the server. diff --git a/recipes-qt/qte/qte-2.3.10/disable-dup-rotation.patch b/recipes-qt/qte/qte-2.3.10/disable-dup-rotation.patch new file mode 100644 index 0000000..6874ba5 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/disable-dup-rotation.patch @@ -0,0 +1,13 @@ +--- qte/src/kernel/kernelkeyboard.cpp 2008-05-26 16:25:23.000000000 +0100 ++++ qte/src/kernel/kernelkeyboard.cpp 2008-05-26 16:27:52.000000000 +0100 +@@ -627,8 +627,10 @@ + case Qt::Key_Down: + unicode = 0xffff; + mod_key = false; ++#if 0 + if (qt_screen->isTransformed()) + qtKeyCode = static_cast( xform_dirkey(static_cast( qtKeyCode ) ) ); ++#endif + break; + /* + * handle lock, we don't handle scroll lock! diff --git a/recipes-qt/qte/qte-2.3.10/encoding.patch b/recipes-qt/qte/qte-2.3.10/encoding.patch new file mode 100644 index 0000000..13a4828 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/fix-errno-exception-spec.patch b/recipes-qt/qte/qte-2.3.10/fix-errno-exception-spec.patch new file mode 100644 index 0000000..19a5c13 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/fix-errno-exception-spec.patch @@ -0,0 +1,16 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/src/kernel/qsoundqss_qws.cpp~fix-errno-exception-spec.patch ++++ qt-2.3.10/src/kernel/qsoundqss_qws.cpp +@@ -51,8 +51,6 @@ + #include + #include + +-extern int errno; +- + #define QT_QWS_SOUND_16BIT 1 // or 0, or undefined for always 0 + #define QT_QWS_SOUND_STEREO 1 // or 0, or undefined for always 0 + diff --git a/recipes-qt/qte/qte-2.3.10/fix-linuxfb-offscreenoverflow.patch b/recipes-qt/qte/qte-2.3.10/fix-linuxfb-offscreenoverflow.patch new file mode 100644 index 0000000..a604630 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/fix-linuxfb-offscreenoverflow.patch @@ -0,0 +1,22 @@ +Fix an overflow when the amount of requested cache memory +is greater than the *lowest value +Manuel Teira + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp~fix-linuxfb-offscreenoverflow ++++ qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp +@@ -610,6 +610,11 @@ + + // No free blocks in already-taken memory; get some more + // if we can ++ if ( amount >= (*lowest ) ) { ++ //Avoid this overflow ++ qt_fbdpy->ungrab(); ++ return 0; ++ } + unsigned int newlowest = (*lowest)-amount; + if (newlowest % align) { + newlowest -= align; diff --git a/recipes-qt/qte/qte-2.3.10/fix-linuxfb-setmode.patch b/recipes-qt/qte/qte-2.3.10/fix-linuxfb-setmode.patch new file mode 100644 index 0000000..212463c --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/fix-linuxfb-setmode.patch @@ -0,0 +1,32 @@ +Set lstep properly on a mode change +Manuel Teira + +# +# 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/recipes-qt/qte/qte-2.3.10/fix-native-build.patch b/recipes-qt/qte/qte-2.3.10/fix-native-build.patch new file mode 100644 index 0000000..7670d44 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/fix-native-build.patch @@ -0,0 +1,11 @@ +--- qt-2.3.10/src/kernel/qwindowsystem_qws.h.orig 2005-09-19 17:50:39.000000000 +0200 ++++ qt-2.3.10/src/kernel/qwindowsystem_qws.h 2005-09-19 17:50:45.000000000 +0200 +@@ -53,6 +53,8 @@ + class QWSRegionManager; + class QGfx; + class QWSServerData; ++class QWSInputMethod; ++class QWSGestureMethod; + + class QWSInternalWindowInfo + { diff --git a/recipes-qt/qte/qte-2.3.10/fix-qgfxraster.patch b/recipes-qt/qte/qte-2.3.10/fix-qgfxraster.patch new file mode 100644 index 0000000..7bc1e2a --- /dev/null +++ b/recipes-qt/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(temppos); ++ cp=reinterpret_cast(&temp2); ++ *(alphaptr++)=qt_conv16ToRgb(*cp); ++ cp++; ++ *(alphaptr++)=qt_conv16ToRgb(*cp); + temppos += 2; + } + diff --git a/recipes-qt/qte/qte-2.3.10/fix-qscreen-sync.patch b/recipes-qt/qte/qte-2.3.10/fix-qscreen-sync.patch new file mode 100644 index 0000000..47929ee --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/fix-qscreen-sync.patch @@ -0,0 +1,17 @@ +Add a sync member to QScreen class +Manuel Teira + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10/src/kernel/qgfx_qws.h~fix-qscreen-sync ++++ qt-2.3.10/src/kernel/qgfx_qws.h +@@ -191,6 +191,7 @@ + virtual int pixmapOffsetAlignment() { return 64; } + virtual int pixmapLinestepAlignment() { return 64; } + ++ virtual void sync() {} + virtual bool onCard(unsigned char *) const; + virtual bool onCard(unsigned char *, ulong& out_offset) const; + diff --git a/recipes-qt/qte/qte-2.3.10/fix-qte-asm-include.patch b/recipes-qt/qte/qte-2.3.10/fix-qte-asm-include.patch new file mode 100644 index 0000000..951bd82 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/fix-qte-asm-include.patch @@ -0,0 +1,19 @@ +--- a/src/kernel/qpixmapcache.cpp 2005-01-23 14:00:46.000000000 +0000 ++++ b/src/kernel/qpixmapcache.cpp 2009-11-05 22:49:44.000000000 +0000 +@@ -119,13 +119,13 @@ + #include + #include + #include ++#include + + #ifdef THROW_AWAY_UNUSED_PAGES + # include // madvise +-# include // PAGE_SIZE,PAGE_MASK,PAGE_ALIGN +-# ifndef PAGE_ALIGN ++# define PAGE_SIZE getpagesize() ++# define PAGE_MASK (~(PAGE_SIZE-1)) + # define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK) +-# endif // PAGE_ALIGN + #endif // THROW_AWAY_UNUSED_PAGES + + diff --git a/recipes-qt/qte/qte-2.3.10/gcc3.patch b/recipes-qt/qte/qte-2.3.10/gcc3.patch new file mode 100644 index 0000000..fc1656a --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/gcc4.patch b/recipes-qt/qte/qte-2.3.10/gcc4.patch new file mode 100644 index 0000000..550effd --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/gcc4.patch @@ -0,0 +1,16 @@ + +# +# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher +# + +--- qt-2.3.10/src/tools/qvaluestack.h~gcc4 2005-01-23 15:00:47.000000000 +0100 ++++ qt-2.3.10/src/tools/qvaluestack.h 2006-03-19 02:32:56.000000000 +0100 +@@ -54,7 +54,7 @@ + { + T elem( this->last() ); + if ( !this->isEmpty() ) +- remove( this->fromLast() ); ++ this->remove( this->fromLast() ); + return elem; + } + T& top() { return this->last(); } diff --git a/recipes-qt/qte/qte-2.3.10/handhelds.patch b/recipes-qt/qte/qte-2.3.10/handhelds.patch new file mode 100644 index 0000000..f67766a --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/handhelds.patch @@ -0,0 +1,60 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10-snapshot-20050131/src/widgets/qcommonstyle.cpp~opie ++++ qt-2.3.10-snapshot-20050131/src/widgets/qcommonstyle.cpp +@@ -572,7 +572,7 @@ + bool enabled, bool active ) + { + #ifndef QT_NO_MENUBAR +-#ifndef QT_NO_STYLE_SGI ++#if 1 // #ifndef QT_NO_STYLE_SGI + if (draw_menu_bar_impl != 0) { + QDrawMenuBarItemImpl impl = draw_menu_bar_impl; + (this->*impl)(p, x, y, w, h, mi, g, enabled, active); +--- qt-2.3.10-snapshot-20050131/src/widgets/qlistview.cpp~opie ++++ qt-2.3.10-snapshot-20050131/src/widgets/qlistview.cpp +@@ -5051,9 +5051,9 @@ + l = l->childItem ? l->childItem : l->siblingItem; + + if ( l && l->height() ) +- s.setHeight( s.height() + 10 * l->height() ); +- else +- s.setHeight( s.height() + 140 ); ++ s.setHeight( s.height() + 4 /*10*/ * l->height() ); ++ else // ^v much too big for handhelds ++ s.setHeight( s.height() + 30 /*140*/ ); + + if ( s.width() > s.height() * 3 ) + s.setHeight( s.width() / 3 ); +--- qt-2.3.10-snapshot-20050131/src/kernel/qwindowsystem_qws.cpp~opie ++++ qt-2.3.10-snapshot-20050131/src/kernel/qwindowsystem_qws.cpp +@@ -918,6 +918,18 @@ + { + } + ++static void catchSegvSignal( int ) ++{ ++#ifndef QT_NO_QWS_KEYBOARD ++ if ( qwsServer ) ++ qwsServer->closeKeyboard(); ++#endif ++ QWSServer::closedown(); ++ fprintf(stderr, "Segmentation fault.\n"); ++ exit(1); ++} ++ ++ + /*! + \class QWSServer qwindowsystem_qws.h + \brief Server-specific functionality in Qt/Embedded +@@ -1043,6 +1055,7 @@ + } + + signal(SIGPIPE, ignoreSignal); //we get it when we read ++ signal(SIGSEGV, catchSegvSignal); //recover the keyboard on crash + #endif + focusw = 0; + mouseGrabber = 0; diff --git a/recipes-qt/qte/qte-2.3.10/improve-calibration-r0.patch b/recipes-qt/qte/qte-2.3.10/improve-calibration-r0.patch new file mode 100644 index 0000000..6052510 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/improve-calibration-r0.patch @@ -0,0 +1,159 @@ +Index: qt-2.3.10/src/kernel/qwsmouse_qws.cpp +=================================================================== +--- qt-2.3.10.orig/src/kernel/qwsmouse_qws.cpp 2005-08-31 13:44:12.000000000 +0000 ++++ qt-2.3.10/src/kernel/qwsmouse_qws.cpp 2005-09-01 19:38:27.000000000 +0000 +@@ -14,10 +14,6 @@ + ** Foundation and appearing in the file LICENSE.GPL included in the + ** packaging of this file. + ** +-** Licensees holding valid Qt Enterprise Edition or Qt Professional Edition +-** licenses for Qt/Embedded may use this file in accordance with the +-** Qt Embedded Commercial License Agreement provided with the Software. +-** + ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + ** +@@ -30,6 +26,12 @@ + ** + **********************************************************************/ + ++/* ++ * The 5 point algorithim in QTSLibHandlerPrivate::calibrate() is ++ * GPL only code and Copyright (C) 2001 Russel King. ++ * ++ * Taken from ts_calibrate.c from tslib ++ */ + #include "qwindowsystem_qws.h" + #include "qsocketnotifier.h" + #include "qwsevent_qws.h" +@@ -1813,6 +1815,7 @@ + + void QTSLibHandlerPrivate::calibrate( QWSPointerCalibrationData * cd) + { ++#ifdef ORIG_CALIBRATE + QPoint dev_tl = cd->devPoints[ QWSPointerCalibrationData::TopLeft ]; + QPoint dev_br = cd->devPoints[ QWSPointerCalibrationData::BottomRight ]; + QPoint screen_tl = cd->screenPoints[ QWSPointerCalibrationData::TopLeft ]; +@@ -1843,6 +1846,122 @@ + { + qDebug( "Could not save calibration: %s", calFile.latin1() ); + } ++ ++#else ++ int j; ++ float n, x, y, x2, y2, xy, z, zx, zy; ++ float det, cal_a, cal_b, cal_c, cal_d, cal_e, cal_f, cal_i; ++ float scaling = 65536.0; ++ int cal_x[5], cal_xfb[5], cal_y[5], cal_yfb[5], cal_o[7]; ++ ++ cal_x[0]=cd->devPoints[ QWSPointerCalibrationData::TopLeft ].x(); ++ cal_y[0]=cd->devPoints[ QWSPointerCalibrationData::TopLeft ].y(); ++ cal_x[1]=cd->devPoints[ QWSPointerCalibrationData::TopRight ].x(); ++ cal_y[1]=cd->devPoints[ QWSPointerCalibrationData::TopRight ].y(); ++ cal_x[2]=cd->devPoints[ QWSPointerCalibrationData::BottomLeft ].x(); ++ cal_y[2]=cd->devPoints[ QWSPointerCalibrationData::BottomLeft ].y(); ++ cal_x[3]=cd->devPoints[ QWSPointerCalibrationData::BottomRight ].x(); ++ cal_y[3]=cd->devPoints[ QWSPointerCalibrationData::BottomRight ].y(); ++ cal_x[4]=cd->devPoints[ QWSPointerCalibrationData::Center ].x(); ++ cal_y[4]=cd->devPoints[ QWSPointerCalibrationData::Center ].y(); ++ ++ cal_xfb[0]=cd->screenPoints[ QWSPointerCalibrationData::TopLeft ].x(); ++ cal_yfb[0]=cd->screenPoints[ QWSPointerCalibrationData::TopLeft ].y(); ++ cal_xfb[1]=cd->screenPoints[ QWSPointerCalibrationData::TopRight ].x(); ++ cal_yfb[1]=cd->screenPoints[ QWSPointerCalibrationData::TopRight ].y(); ++ cal_xfb[2]=cd->screenPoints[ QWSPointerCalibrationData::BottomLeft ].x(); ++ cal_yfb[2]=cd->screenPoints[ QWSPointerCalibrationData::BottomLeft ].y(); ++ cal_xfb[3]=cd->screenPoints[ QWSPointerCalibrationData::BottomRight ].x(); ++ cal_yfb[3]=cd->screenPoints[ QWSPointerCalibrationData::BottomRight ].y(); ++ cal_xfb[4]=cd->screenPoints[ QWSPointerCalibrationData::Center ].x(); ++ cal_yfb[4]=cd->screenPoints[ QWSPointerCalibrationData::Center ].y(); ++ ++ //qDebug("Top left : X = %4d Y = %4d", cal_x[0], cal_y[0]); ++ //qDebug("Top right: X = %4d Y = %4d", cal_x[1], cal_y[1]); ++ //qDebug("Bot left : X = %4d Y = %4d", cal_x[2], cal_y[2]); ++ //qDebug("Bot right: X = %4d Y = %4d", cal_x[3], cal_y[3]); ++ //qDebug("Middle: X = %4d Y = %4d", cal_x[4], cal_y[4]); ++ ++ // Get sums for matrix ++ n = x = y = x2 = y2 = xy = 0; ++ for(j=0;j<5;j++) { ++ n += 1.0; ++ x += (float)cal_x[j]; ++ y += (float)cal_y[j]; ++ x2 += (float)(cal_x[j]*cal_x[j]); ++ y2 += (float)(cal_y[j]*cal_y[j]); ++ xy += (float)(cal_x[j]*cal_y[j]); ++ } ++ ++ // Get determinant of matrix -- check if determinant is too small ++ det = n*(x2*y2 - xy*xy) + x*(xy*y - x*y2) + y*(x*xy - y*x2); ++ if(det < 0.1 && det > -0.1) { ++ qDebug("determinant is too small -- %f",det); ++ return;// false; ++ } ++ ++ // Get elements of inverse matrix ++ cal_a = (x2*y2 - xy*xy)/det; ++ cal_b = (xy*y - x*y2)/det; ++ cal_c = (x*xy - y*x2)/det; ++ cal_e = (n*y2 - y*y)/det; ++ cal_f = (x*y - n*xy)/det; ++ cal_i = (n*x2 - x*x)/det; ++ ++ // Get sums for x calibration ++ z = zx = zy = 0; ++ for(j=0;j<5;j++) { ++ z += (float)cal_xfb[j]; ++ zx += (float)(cal_xfb[j]*cal_x[j]); ++ zy += (float)(cal_xfb[j]*cal_y[j]); ++ } ++ ++ // Now multiply out to get the calibration for framebuffer x coord ++ cal_o[0] = (int)((cal_a*z + cal_b*zx + cal_c*zy)*(scaling)); ++ cal_o[1] = (int)((cal_b*z + cal_e*zx + cal_f*zy)*(scaling)); ++ cal_o[2] = (int)((cal_c*z + cal_f*zx + cal_i*zy)*(scaling)); ++ ++ qDebug("%f %f %f",(cal_a*z + cal_b*zx + cal_c*zy), (cal_b*z + cal_e*zx + cal_f*zy), (cal_c*z + cal_f*zx + cal_i*zy)); ++ ++ // Get sums for y calibration ++ z = zx = zy = 0; ++ for (j=0;j<5;j++) { ++ z += (float)cal_yfb[j]; ++ zx += (float)(cal_yfb[j]*cal_x[j]); ++ zy += (float)(cal_yfb[j]*cal_y[j]); ++ } ++ ++ // Now multiply out to get the calibration for framebuffer y coord ++ cal_o[3] = (int)((cal_a*z + cal_b*zx + cal_c*zy)*(scaling)); ++ cal_o[4] = (int)((cal_b*z + cal_e*zx + cal_f*zy)*(scaling)); ++ cal_o[5] = (int)((cal_c*z + cal_f*zx + cal_i*zy)*(scaling)); ++ ++ qDebug("%f %f %f",(cal_a*z + cal_b*zx + cal_c*zy), (cal_b*z + cal_e*zx + cal_f*zy), (cal_c*z + cal_f*zx + cal_i*zy)); ++ ++ ++ // If we got here, we're OK, so assign scaling to a[6] and return ++ cal_o[6] = (int) scaling; ++ ++ qDebug("Calibration constants: %d %d %d %d %d %d %d", ++ cal_o[0], cal_o[1], cal_o[2], ++ cal_o[3], cal_o[4], cal_o[5], ++ cal_o[6]); ++ ++ QString calFile = "/etc/pointercal"; ++#ifndef QT_NO_TEXTSTREAM ++ QFile file( calFile ); ++ if ( file.open( IO_WriteOnly ) ) { ++ QTextStream t( &file ); ++ t << cal_o[1] << " " << cal_o[2] << " " << cal_o[0] << " "; ++ t << cal_o[4] << " " << cal_o[5] << " " << cal_o[3] << " " << cal_o[6]; ++ file.flush(); closeTs(); ++ openTs(); ++ } else ++#endif ++ { ++ qDebug( "Could not save calibration: %s", calFile.latin1() ); ++ } ++#endif + } + + void QTSLibHandlerPrivate::readMouseData() diff --git a/recipes-qt/qte/qte-2.3.10/increase-qxml-robustness.patch b/recipes-qt/qte/qte-2.3.10/increase-qxml-robustness.patch new file mode 100644 index 0000000..3a29b4a --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/ipaq_sound_fix.patch b/recipes-qt/qte/qte-2.3.10/ipaq_sound_fix.patch new file mode 100644 index 0000000..af72362 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/ipaq_sound_fix.patch @@ -0,0 +1,60 @@ +Attention HACK ahead: + The OpenSoundSystem is just scary this is a special hack + for supporting iPAQ(s) at least h3870. + + Features: + -It does not crash when playing a 'null' file + -Change sound fragment size to 12 + -Force stereo on!!! (hardcoded at least uda1341 needs it) + + + +Index: qt-2.3.10/src/kernel/qsoundqss_qws.cpp +=================================================================== +--- qt-2.3.10.orig/src/kernel/qsoundqss_qws.cpp 2005-03-20 17:11:29.000000000 +0100 ++++ qt-2.3.10/src/kernel/qsoundqss_qws.cpp 2005-03-20 23:53:46.403129133 +0100 +@@ -73,7 +73,7 @@ + }; + + #if defined(QT_QWS_IPAQ) +-static const int sound_fragment_size = 12; ++static const int sound_fragment_size = 14; + #else + static const int sound_fragment_size = 12; + #endif +@@ -451,8 +451,14 @@ + + int devSamples() + { +- int possible = (((max1+max2-out) / ((chunkdata.wBitsPerSample>>3)*chunkdata.channels)) +- *sound_speed)/chunkdata.samplesPerSec; ++ if ( !(chunkdata.wBitsPerSample>>3) || ++ !chunkdata.channels || ++ !sound_speed || ++ !chunkdata.samplesPerSec ) ++ return 0; ++ ++ int possible = (((max1+max2-out) / ((chunkdata.wBitsPerSample>>3 )*chunkdata.channels)) ++ *sound_speed)/chunkdata.samplesPerSec; + + return possible; + } +@@ -1116,12 +1127,14 @@ + if ( AFMT_U8 != v ) + qDebug("Want format %d got %d", AFMT_U8, v); + #endif +- v=sound_stereo; if ( ioctl(fd, SNDCTL_DSP_STEREO, &v) ) ++ v=1; if ( ioctl(fd, SNDCTL_DSP_STEREO, &v) ) + qWarning("Could not set stereo %d",v); + if ( sound_stereo != v ) +- qDebug("Want stereo %d got %d", sound_stereo, v); +-#ifdef QT_QWS_SOUND_STEREO +- sound_stereo=v; ++ qDebug("Want stereo %d got %d", sound_stereo, v); ++#if defined(QT_QWS_IPAQ) ++ sound_stereo=1; ++#elif QT_QWS_SOUND_STEREO ++ sound_stereo=v; + #endif + v=sound_speed; if ( ioctl(fd, SNDCTL_DSP_SPEED, &sound_speed) ) + qWarning("Could not set speed %d",v); diff --git a/recipes-qt/qte/qte-2.3.10/kernel-keymap-corgi.patch b/recipes-qt/qte/qte-2.3.10/kernel-keymap-corgi.patch new file mode 100644 index 0000000..0fabd78 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/kernel-keymap.patch b/recipes-qt/qte/qte-2.3.10/kernel-keymap.patch new file mode 100644 index 0000000..0111c83 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/kernel-keymap.patch @@ -0,0 +1,1293 @@ +--- /dev/null 2004-07-13 00:58:01.000000000 +0000 ++++ qte/src/kernel/kernelkeyboard.cpp 2007-04-07 01:00:36.000000000 +0000 +@@ -0,0 +1,769 @@ ++/* ++ ++ Copyright (C) 2003 Chris Larson ++ 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 Chris Larson 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. ++ ++*/ ++ ++/* ++ Copyright (C) 2005 ROAD GmbH ++ ++ 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. ++ ++ You should have received a copy of the GNU General Public ++ License along with this program; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, ++ Boston, MA 02111-1307 USA ++ ++ ++ Changes Done: ++ -ShiftL and ShiftR modifier handling ++ -Keypad handling improved ++ -Handle unmapped keys by lookin them up in the first column ++ -Handle AutoRepeat ++ -Handle Keys >127 ++ -Handle Increment and Decrement the Console ++ -Handle the Home Key ++ -Fix handling of Function Keys ++ -Fix handling of the unicode value (to fix QPopupMenu,QAction) ++ ++ */ ++ ++/* ++ Paul Sokolovsky, 2007-04: ++ ++ 1. Added support for nicely named and extensible key bindings. ++ E.g., in loadkeys do: ++ keycode 155 = F100 ++ string F100 = "power" ++ where 155 is keycode a power button happens to have on your machine, F100 is ++ arbitrary function key (please use F100-F120), and "power" is OPIE binding. ++ Currently defined bindings are "power", "backlight", "record" ++ 2. K_DO ("Do") keycode is mapped to OPIE power button by default. Kernel uses ++ K_DO for KEY_POWER input subsystem keycode. So, if your device does the right ++ thing, it will work out of the box. ++ 3. Implemented NumLock handling for numeric keypad. ++ */ ++ ++/* ++ This is an alternative implementation of the QWSTtyKeyboardHandler ++ of Trolltech's QtE. ++ ++ Instead of using a hardcoded incomplete map, this implementation ++ imports the Keymap from a Linux Kernel. ++ ++ */ ++ ++ ++// ++// 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 ) { ++ QSocketNotifier *notifier; ++ notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this ); ++ connect( notifier, SIGNAL(activated(int)),this, ++ SLOT(readKeyboardData()) ); ++ ++ // save for restore. ++ tcgetattr( kbdFD, &origTermData ); ++ ++ struct termios termdata; ++ tcgetattr( kbdFD, &termdata ); ++ ++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) ++ ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW); ++#endif ++ ++ 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); ++ ++ readUnicodeMap(); ++ readKeyboardMap(); ++ ++ signal(VTSWITCHSIG, vtSwitchHandler); ++ ++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) ++ 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; ++#endif ++ } ++} ++ ++QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler() ++{ ++ restoreLeds(); ++ 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 ++ tcsetattr(kbdFD, TCSANOW, &origTermData); ++ ::close(kbdFD); ++ kbdFD = -1; ++ } ++} ++void QWSTtyKeyboardHandler::readUnicodeMap() ++{ ++ if (kbdFD < 0) ++ return; ++ if (ioctl(kbdFD,GIO_UNISCRNMAP,acm) != 0) ++ return; ++} ++ ++static Qt::Key getSpecialKey(int fKey) ++{ ++ struct kbsentry kbs; ++ kbs.kb_func = fKey; ++ ++ if (ioctl(kbdFD, KDGKBSENT, &kbs) != 0) ++ return Qt::Key_unknown; ++ const char *str = (const char *)kbs.kb_string; ++ ++ if (!strcmp("record", str)) ++ return Qt::Key_F24; ++ else if (!strcmp("power", str)) ++ return Qt::Key_F34; ++ else if (!strcmp("backlight", str)) ++ return Qt::Key_F35; ++ ++ return Qt::Key_unknown; ++} ++ ++void QWSTtyKeyboardHandler::readKeyboardMap() ++{ ++ struct kbentry kbe; ++ if (kbdFD < 0) ++ return; ++ ++ for (int map = 0; map < (1<( Qt::Key_F1 + kval ), kval ); ++ else if ( kval >= 30 && kval <= 44) ++ kernel_map[map][key] = KeyMap( static_cast( Qt::Key_F21 + (kval - 30) ), kval ); ++ else { ++ Qt::Key specialKey = getSpecialKey(kval); ++ if (specialKey != Qt::Key_unknown) { ++ kernel_map[map][key] = KeyMap( specialKey, 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: ++ kernel_map[map][key] = KeyMap( Qt::Key_Home, kval ); ++ break; ++ case K_DO: ++ kernel_map[map][key] = KeyMap( Qt::Key_F34, kval ); ++ break; ++ 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_DECRCONSOLE: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_DecConsole, kval ); ++ break; ++ case K_INCRCONSOLE: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_IncConsole, 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_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, kbe.kb_value ); ++ break; ++ case K_P1: ++ kernel_map[map][key] = KeyMap( Qt::Key_1, kbe.kb_value ); ++ break; ++ case K_P2: ++ kernel_map[map][key] = KeyMap( Qt::Key_2, kbe.kb_value ); ++ break; ++ case K_P3: ++ kernel_map[map][key] = KeyMap( Qt::Key_3, kbe.kb_value ); ++ break; ++ case K_P4: ++ kernel_map[map][key] = KeyMap( Qt::Key_4, kbe.kb_value ); ++ break; ++ case K_P5: ++ kernel_map[map][key] = KeyMap( Qt::Key_5, kbe.kb_value ); ++ break; ++ case K_P6: ++ kernel_map[map][key] = KeyMap( Qt::Key_6, kbe.kb_value ); ++ break; ++ case K_P7: ++ kernel_map[map][key] = KeyMap( Qt::Key_7, kbe.kb_value ); ++ break; ++ case K_P8: ++ kernel_map[map][key] = KeyMap( Qt::Key_8, kbe.kb_value ); ++ break; ++ case K_P9: ++ kernel_map[map][key] = KeyMap( Qt::Key_9, kbe.kb_value ); ++ break; ++ case K_PPLUS: ++ kernel_map[map][key] = KeyMap( Qt::Key_Plus, '+' ); ++ break; ++ case K_PMINUS: ++ kernel_map[map][key] = KeyMap( Qt::Key_Minus, '-' ); ++ break; ++ case K_PSTAR: ++ kernel_map[map][key] = KeyMap( Qt::Key_multiply, '*' ); ++ break; ++ case K_PSLASH: ++ kernel_map[map][key] = KeyMap( Qt::Key_division, '/' ); ++ 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, '.' ) ; ++ break; ++ case K_PPLUSMINUS: ++ kernel_map[map][key] = KeyMap( Qt::Key_plusminus, kval ); ++ break; ++ case K_PDOT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Comma, '.' ) ; ++ 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; ++ ++ /* ++ * Console keys ++ */ ++ case KT_CONS: ++ if ( kval < 10 ) ++ kernel_map[map][key] = KeyMap(static_cast( KeyMap::Key_Console1+kval ), kval ); ++ else ++ 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: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_ShiftL, kval ); ++ break; ++ case K_SHIFTR: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_ShiftR, kval ); ++ break; ++ 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<= 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<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; ++ } ++} ++ ++static Qt::Key numpad2cursor[NR_PAD] = { ++ Qt::Key_Insert, ++ Qt::Key_End, ++ Qt::Key_Down, ++ Qt::Key_Next, ++ Qt::Key_Left, ++ Qt::Key_5, ++ Qt::Key_Right, ++ Qt::Key_Home, ++ Qt::Key_Up, ++ Qt::Key_Prior, ++}; ++ ++void QWSTtyKeyboardHandler::handleKey(unsigned int code, bool release) ++{ ++ int old_modifier = modifier; ++ bool mod_key = true; ++ ++ KeyMap key_map = kernel_map[current_map][code]; ++ if( key_map.key == KeyMap::Key_NotMapped ) { ++ qWarning("Unmapped Key Pressed fixing up map:%d modif:%d code:%d", current_map, modifier, code); ++ key_map = kernel_map[0][code]; ++ } ++ ++ unsigned short unicode = 0xffff; ++ if (key_map.code < 0x100) ++ unicode = acm[key_map.code & 0xff] & 0xff; ++ 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<isTransformed()) ++ qtKeyCode = static_cast( xform_dirkey(static_cast( qtKeyCode ) ) ); ++ break; ++ /* ++ * handle lock, we don't handle scroll lock! ++ */ ++ case Qt::Key_CapsLock: ++ case Qt::Key_NumLock: ++ unicode = 0xffff; ++ 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 NumLock ++ if (KTYP(key_map.code) == KT_PAD) { ++ if (!numlock) { ++ qtKeyCode = numpad2cursor[KVAL(key_map.code)]; ++ } else { ++ unicode = KVAL(key_map.code) + '0'; ++ } ++ } ++ ++ /* ++ * do not repeat modifier keys ++ */ ++ if ( modifier == old_modifier && mod_key ) ++ return; ++ ++ processKeyEvent(unicode, qtKeyCode, map_to_modif(), !release, 0); ++} ++ ++ ++/* ++ * We will read the keys off the kernel. We have two cases here ++ * 1. ) keycode < 128, bit8 is the down/up bit and the rest is ++ * is the value of the key. we can simply process it ++ * 2. ) keycode > 128, the first byte is either empty or 0x80. ++ * We need to save the status ( press/release ) the following ++ * two bytes. ++ * The difficulty is we might have not read all keys into the ++ * buffer. This makes the reading of highkeys a bit harder and ++ * I've decided against rereading, or adding a special case for ++ * the 'all' buffers in loop instead we have a simple state machine. ++ */ ++void QWSTtyKeyboardHandler::readKeyboardData() ++{ ++ unsigned char buf[81]; ++ unsigned char code; ++ bool release = false; ++ bool release_bit; ++ ++ bool highKey = false; ++ unsigned int highKeyCode = 0; ++ unsigned int highNeedMoreKey = 0; ++ ++ int n = ::read(kbdFD, buf, 80 ); ++ for ( int loop = 0; loop < n; loop++ ) { ++ code = buf[loop] & 0x7f; ++ release_bit = buf[loop] & 0x80; ++ ++ if ( highKey ) { ++ if ( highNeedMoreKey == 2 ) { ++ highNeedMoreKey--; ++ highKeyCode = code << 7; ++ }else if ( highNeedMoreKey == 1 ) { ++ highNeedMoreKey = 0; ++ highKeyCode |= code; ++ highKey = false; ++ if ( highKeyCode > 127 && highKeyCode < NR_KEYS ) ++ handleKey( highKeyCode, release ); ++ } ++ }else if (code == 0) { ++ highKey = true; ++ highNeedMoreKey = 2; ++ release = release_bit; ++ }else { ++ release = release_bit; ++ handleKey(code, release); ++ } ++ } ++} ++ ++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 ); ++} ++ ++void QWSTtyKeyboardHandler::processKeyEvent(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ) { ++ static int last_unicode = -1; ++ static int last_keycode = -1; ++ ++ autoRepeat = false; ++ if( last_unicode == unicode && last_keycode == keycode && isPress ) ++ autoRepeat = true; ++ ++ QWSPC101KeyboardHandler::processKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat); ++ ++ if ( isPress ) { ++ last_unicode = unicode; ++ last_keycode = keycode; ++ } else { ++ last_unicode = last_keycode = -1; ++ } ++} +Index: src/kernel/qkeyboard_qws.cpp +=================================================================== +--- qte/src/kernel/qkeyboard_qws.cpp.orig 2006-04-01 23:36:22.499297680 +0200 ++++ qte/src/kernel/qkeyboard_qws.cpp 2006-04-01 23:38:19.913448016 +0200 +@@ -45,15 +45,18 @@ + #include + + #include +-#ifdef _OS_LINUX_ +-#include +-#endif ++#include + #include + #include + #include + #include + #include + #include ++#include ++#ifdef _OS_LINUX_ ++#include ++#include ++#endif + + #ifdef QT_QWS_TIP2 + #include +@@ -135,17 +138,6 @@ + }; + + +-#ifdef QT_QWS_SL5XXX +-#include +-#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 +161,6 @@ + int xf = qt_screen->transformOrientation() + dir_keyrot; + return (key-Qt::Key_Left+xf)%4+Qt::Key_Left; + } +-#endif + + #define VTSWITCHSIG SIGUSR2 + +@@ -643,18 +634,81 @@ + ioctl(0, KDSETLED, leds); + } + ++/* ++ * This class was extended by: ++ * ++ * Copyright 2002 Chris Larson ++ * Copyright 2004, 2005 Holger Hans Peter Freyther ++ */ + class QWSTtyKeyboardHandler : public QWSPC101KeyboardHandler + { + Q_OBJECT + public: + QWSTtyKeyboardHandler(const QString&); + virtual ~QWSTtyKeyboardHandler(); ++ void readKeyboardMap(); ++ void readUnicodeMap(); ++ void handleKey(unsigned int key, bool release); + + 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, ++ Key_ShiftL = 0x130000, ++ Key_ShiftR = 0x130001, ++ Key_IncConsole= 0x130002, ++ Key_DecConsole= 0x130003, ++ Key_NotMapped = 0x130004, ++ }; ++ ++ 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<= 0 ) { +@@ -825,6 +880,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; +@@ -1250,98 +1306,10 @@ + // + // Tty keyboard + // +- +-QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString& device) +-{ +- kbdFD=open(device.isEmpty() ? "/dev/tty0" : device.latin1(), O_RDWR | O_NDELAY, 0); +- +- if ( kbdFD >= 0 ) { +- QSocketNotifier *notifier; +- notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this ); +- connect( notifier, SIGNAL(activated(int)),this, +- SLOT(readKeyboardData()) ); +- +- // save for restore. +- tcgetattr( kbdFD, &origTermData ); +- +- struct termios termdata; +- 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 +-#endif +- +- 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); +- +- signal(VTSWITCHSIG, vtSwitchHandler); +- +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- 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; +-#endif +- } +-} +- +-QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler() +-{ +- 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 +- tcsetattr(kbdFD, TCSANOW, &origTermData); +- ::close(kbdFD); +- kbdFD = -1; +- } +-} +- +-void QWSTtyKeyboardHandler::readKeyboardData() +-{ +- unsigned char buf[81]; +- int n = ::read(kbdFD, buf, 80 ); +- for ( int loop = 0; loop < n; loop++ ) +- doKey(buf[loop]); +-} ++/* ++ * Include the alternative implementation ++ */ ++#include "kernelkeyboard.cpp" + + typedef struct { + unsigned short key; +Index: src/kernel/keyboard_linux_to_qt.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qte/src/kernel/keyboard_linux_to_qt.h 2006-04-01 23:37:03.928999408 +0200 +@@ -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_At, ++Qt::Key_A, ++Qt::Key_B, ++Qt::Key_C, ++Qt::Key_D, ++Qt::Key_E, ++Qt::Key_F, ++Qt::Key_G, ++Qt::Key_Backspace, ++Qt::Key_Tab, ++Qt::Key_J, // Linefeed ++Qt::Key_K, ++Qt::Key_L, ++Qt::Key_Enter, ++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_Escape, ++Qt::Key_Backslash, ++Qt::Key_BracketRight, ++Qt::Key_AsciiCircum, ++Qt::Key_Underscore, ++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/recipes-qt/qte/qte-2.3.10/key.patch b/recipes-qt/qte/qte-2.3.10/key.patch new file mode 100644 index 0000000..d3cf4f7 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/key.patch @@ -0,0 +1,74 @@ + +# +# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher +# + +Index: qt-2.3.10/src/kernel/qkeyboard_qws.cpp +=================================================================== +--- qt-2.3.10.orig/src/kernel/qkeyboard_qws.cpp 2005-03-31 17:51:14.978609000 -0500 ++++ qt-2.3.10/src/kernel/qkeyboard_qws.cpp 2005-03-31 17:54:28.140243968 -0500 +@@ -848,6 +848,9 @@ + bool release = false; + int keypad = 0; + ++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) // need autorepeat implemented here? ++ bool repeatable = TRUE; ++ + #ifndef QT_QWS_USE_KEYCODES + #if defined(QT_QWS_IPAQ) + // map ipaq 'action' key (0x60, 0xe0) +@@ -984,9 +987,6 @@ + if ( currentKey ) + keyCode = currentKey->key_code; + +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) // need autorepeat implemented here? +- bool repeatable = TRUE; +- + #if defined(QT_QWS_IPAQ) + switch (code) { + #if defined(QT_QWS_SL5XXX) +@@ -1061,25 +1061,23 @@ + repeatable = FALSE; + #endif + ++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) + if ( qt_screen->isTransformed() + && keyCode >= Qt::Key_Left && keyCode <= Qt::Key_Down ) + { + keyCode = xform_dirkey(keyCode); + } +- +-#ifdef QT_QWS_AUTOREPEAT_MANUALLY +- if ( repeatable && !release ) +- rep->start(prevuni,prevkey,modifiers); +- else +- rep->stop(); + #endif ++ + #endif + /* + Translate shift+Key_Tab to Key_Backtab + */ + if (( keyCode == Key_Tab ) && shift ) + keyCode = Key_Backtab; ++#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) + } ++#endif + + #ifndef QT_QWS_USE_KEYCODES + /* +@@ -1234,6 +1232,14 @@ + } else { + prevkey = prevuni = 0; + } ++ ++#ifdef QT_QWS_AUTOREPEAT_MANUALLY ++ if ( repeatable && !release ) ++ rep->start(prevuni,prevkey,modifiers); ++ else ++ rep->stop(); ++#endif ++ + } + #ifndef QT_QWS_USE_KEYCODES + extended = 0; diff --git a/recipes-qt/qte/qte-2.3.10/keyboardless-buttonmap.patch b/recipes-qt/qte/qte-2.3.10/keyboardless-buttonmap.patch new file mode 100644 index 0000000..9bea5b6 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/keyboardless-buttonmap.patch @@ -0,0 +1,19 @@ +--- qt-2.3.10/src/kernel/qkeyboard_qws.cpp.org 2006-09-16 20:54:32.000000000 +0000 ++++ qt-2.3.10/src/kernel/qkeyboard_qws.cpp 2006-10-06 13:25:29.000000000 +0000 +@@ -1018,6 +1018,16 @@ + repeatable = FALSE; + break; + #endif ++ ++ case 0x74: // kernel KEY_POWER ++ keyCode = Key_F34; ++ repeatable = FALSE; ++ break; ++ case 89: // kernel KEY_RO ++ keyCode = Key_F24; ++ repeatable = FALSE; ++ break; ++ + case 0x78: + # if defined(QT_QWS_IPAQ) + keyCode = Key_F24; // record diff --git a/recipes-qt/qte/qte-2.3.10/no-moc.patch b/recipes-qt/qte/qte-2.3.10/no-moc.patch new file mode 100644 index 0000000..128f8a6 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/qiconview-speed.patch b/recipes-qt/qte/qte-2.3.10/qiconview-speed.patch new file mode 100644 index 0000000..bac9b97 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/qpe.patch b/recipes-qt/qte/qte-2.3.10/qpe.patch new file mode 100644 index 0000000..554c42c --- /dev/null +++ b/recipes-qt/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 ++ ++#undef 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/recipes-qt/qte/qte-2.3.10/qt-visibility.patch b/recipes-qt/qte/qte-2.3.10/qt-visibility.patch new file mode 100644 index 0000000..ccdebb0 --- /dev/null +++ b/recipes-qt/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 <= 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 + + #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 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 + #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 + #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 &chain, int start, int count, int pos, ++void Q_EXPORT qGeomCalc( QArray &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/recipes-qt/qte/qte-2.3.10/qtabbar.patch b/recipes-qt/qte/qte-2.3.10/qtabbar.patch new file mode 100644 index 0000000..6940ec9 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/qte-fix-iconsize.patch b/recipes-qt/qte/qte-2.3.10/qte-fix-iconsize.patch new file mode 100644 index 0000000..cc14315 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/remove-unused-kbdhandler.patch b/recipes-qt/qte/qte-2.3.10/remove-unused-kbdhandler.patch new file mode 100644 index 0000000..2bebb02 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/remove-unused-kbdhandler.patch @@ -0,0 +1,420 @@ +--- qt-2.3.10.orig/src/kernel/qkeyboard_qws.cpp.org 2007-07-19 11:00:39.000000000 +0300 ++++ qt-2.3.10/src/kernel/qkeyboard_qws.cpp 2007-07-19 12:14:48.000000000 +0300 +@@ -853,417 +853,6 @@ + + void QWSPC101KeyboardHandler::doKey(uchar code) + { +- const QWSServer::KeyMap *currentKey = 0; +- int keyCode = Qt::Key_unknown; +- bool release = false; +- int keypad = 0; +- +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) // need autorepeat implemented here? +- bool repeatable = TRUE; +- +-#ifndef QT_QWS_USE_KEYCODES +-#if defined(QT_QWS_IPAQ) +- // map ipaq 'action' key (0x60, 0xe0) +- if ((code & 0x7f) == 0x60) { +-#if defined(QT_KEYPAD_MODE) +- // to keycode for select (keypad mode) +- code = (code & 0x80) | 116; +-#else +- // to keycode for space. (no keypad mode0 +- code = (code & 0x80) | 57; +-#endif +- } +-#endif +- +-#if !defined(QT_QWS_SL5XXX) +- if (code == 224 +-#if defined(QT_QWS_IPAQ) +- && !ipaq_return_pressed +-#endif +- ) { +- // extended +- extended = 1; +- return; +- } +- else if (code == 225) { +- // extended 2 +- extended = 2; +- return; +- } +-#endif +-#endif +- +- +- /*------------------------------------------------------------------ +- First find the Qt KeyCode +- ------------------------------------------------------------------*/ +- +- if (code & 0x80) { +- release = true; +- code &= 0x7f; +- } +- +-#ifndef QT_QWS_USE_KEYCODES +- if (extended == 1) { +- currentKey = overrideMap ? overrideMap->find( code+0xe000 ) : 0; +- if ( currentKey ) +- keyCode = currentKey->key_code; +- else +- switch (code) { +- case 72: +- keyCode = Qt::Key_Up; +- break; +- case 75: +- keyCode = Qt::Key_Left; +- break; +- case 77: +- keyCode = Qt::Key_Right; +- break; +- case 80: +- keyCode = Qt::Key_Down; +- break; +- case 82: +- keyCode = Qt::Key_Insert; +- break; +- case 71: +- keyCode = Qt::Key_Home; +- break; +- case 73: +- keyCode = Qt::Key_Prior; +- break; +- case 83: +- keyCode = Qt::Key_Delete; +- break; +- case 79: +- keyCode = Qt::Key_End; +- break; +- case 81: +- keyCode = Qt::Key_Next; +- break; +- case 28: +- keyCode = Qt::Key_Enter; +- break; +- case 53: +- keyCode = Qt::Key_Slash; +- break; +- case 0x1d: +- keyCode = Qt::Key_Control; +- break; +- case 0x2a: +- keyCode = Qt::Key_SysReq; +- break; +- case 0x38: +- keyCode = Qt::Key_Alt; +- break; +- case 0x5b: +- keyCode = Qt::Key_Super_L; +- break; +- case 0x5c: +- keyCode = Qt::Key_Super_R; +- break; +- case 0x5d: +- keyCode = Qt::Key_Menu; +- break; +- } +- } else if ( extended == 2 ) { +- switch (code) { +- case 0x1d: +- return; +- case 0x45: +- keyCode = Qt::Key_Pause; +- break; +- } +- } else +-#endif +- { +-#if defined(QT_QWS_SL5XXX) +- if ( fn && !meta && (code >= 0x42 && code <= 0x52) ) { +- ushort unicode=0xffff; +- int scan=0; +- if ( code == 0x42 ) { unicode='X'-'@'; scan=Key_X; } // Cut +- else if ( code == 0x43 ) { unicode='C'-'@'; scan=Key_C; } // Copy +- else if ( code == 0x44 ) { unicode='V'-'@'; scan=Key_V; } // Paste +- else if ( code == 0x52 ) { unicode='Z'-'@'; scan=Key_Z; } // Undo +- if ( scan ) { +- processKeyEvent( unicode, scan, ControlButton, !release, FALSE ); +- return; +- } +- } +-#endif +- currentKey = overrideMap ? overrideMap->find( code ) : 0; +- if ( !currentKey && code < keyMSize ) { +- currentKey = &QWSServer::keyMap()[code]; +- } +- if ( currentKey ) +- keyCode = currentKey->key_code; +- +-#if defined(QT_QWS_IPAQ) +- switch (code) { +-#if defined(QT_QWS_SL5XXX) +-#if defined(QT_KEYPAD_MODE) +- case 0x7a: +- keyCode = Key_Call; +- repeatable = FALSE; +- break; +- case 0x7b: +- keyCode = Key_Context1; +- repeatable = FALSE; +- break; +- case 0x7c: +- keyCode = Key_Back; +- repeatable = FALSE; +- break; +- case 0x7d: +- keyCode = Key_Hangup; +- repeatable = FALSE; +- break; +-#else +- case 0x7a: case 0x7b: case 0x7c: case 0x7d: +- keyCode = code - 0x7a + Key_F9; +- repeatable = FALSE; +- break; +-#endif +- case 0x79: +- keyCode = Key_F34; +- repeatable = FALSE; +- break; +-#endif +- +- case 0x74: // kernel KEY_POWER +- keyCode = Key_F34; +- repeatable = FALSE; +- break; +- case 89: // kernel KEY_RO +- keyCode = Key_F24; +- repeatable = FALSE; +- break; +- +- case 0x78: +-# if defined(QT_QWS_IPAQ) +- keyCode = Key_F24; // record +-# else +- keyCode = Key_Escape; +-# endif +- repeatable = FALSE; +- break; +- case 0x60: +- keyCode = Key_Return; +-# ifdef QT_QWS_IPAQ +- ipaq_return_pressed = !release; +-# endif +- break; +- case 0x67: +- keyCode = Key_Right; +- break; +- case 0x69: +- keyCode = Key_Up; +- break; +- case 0x6a: +- keyCode = Key_Down; +- break; +- case 0x6c: +- keyCode = Key_Left; +- break; +- } +-#endif +- +- /*------------------------------------------------------------------ +- Then do special processing of magic keys +- ------------------------------------------------------------------*/ +- +- +-#if defined(QT_QWS_SL5XXX) +- if ( release && ( keyCode == Key_F34 || keyCode == Key_F35 ) ) +- return; // no release for power and light keys +- if ( keyCode >= Key_F1 && keyCode <= Key_F35 +- || keyCode == Key_Escape || keyCode == Key_Home +- || keyCode == Key_Shift || keyCode == Key_Meta ) +- repeatable = FALSE; +-#endif +- +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) +- if ( qt_screen->isTransformed() +- && keyCode >= Qt::Key_Left && keyCode <= Qt::Key_Down ) +- { +- keyCode = xform_dirkey(keyCode); +- } +-#endif +- +-#endif +- /* +- Translate shift+Key_Tab to Key_Backtab +- */ +- if (( keyCode == Key_Tab ) && shift ) +- keyCode = Key_Backtab; +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) +- } +-#endif +- +-#ifndef QT_QWS_USE_KEYCODES +- /* +- Keypad consists of extended keys 53 and 28, +- and non-extended keys 55 and 71 through 83. +- */ +- if (( extended == 1 ) ? (code == 53 || code == 28) : +- (code == 55 || ( code >= 71 && code <= 83 )) ) +- keypad = Qt::Keypad; +-#else +- if ( code == 55 || code >= 71 && code <= 83 || code == 96 +- || code == 98 || code == 118 ) +- keypad = Qt::Keypad; +-#endif +- +- // Virtual console switching +- int term = 0; +- 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 && !release) { +- ctrl = false; +- alt = false; +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- ioctl(kbdFD, VT_ACTIVATE, term); +-#endif +- return; +- } +- +-#if defined(QT_QWS_SL5XXX) +- // Ctrl-Alt-Delete exits qws +- if (ctrl && alt && keyCode == Qt::Key_Delete) { +- qApp->quit(); +- } +-#else +- // Ctrl-Alt-Backspace exits qws +- if (ctrl && alt && keyCode == Qt::Key_Backspace) { +- qApp->quit(); +- } +-#endif +- +-#if defined(QT_QWS_SL5XXX) +- if (keyCode == Qt::Key_F22) { /* Fn key */ +- fn = !release; +- } else if ( keyCode == Key_NumLock ) { +- if ( release ) +- numLock = !numLock; +- } else +-#endif +- +- if (keyCode == Qt::Key_Alt) { +- alt = !release; +- } else if (keyCode == Qt::Key_Control) { +- ctrl = !release; +- } else if (keyCode == Qt::Key_Shift) { +- shift = !release; +-#if defined(QT_QWS_SL5XXX) +- } else if (keyCode == Qt::Key_Meta) { +- meta = !release; +-#endif +- } else if ( keyCode == Qt::Key_CapsLock && release ) { +- caps = !caps; +-#if defined(_OS_LINUX_) && !defined(QT_QWS_SL5XXX) +- char leds; +- ioctl(0, KDGETLED, &leds); +- leds = leds & ~LED_CAP; +- if ( caps ) leds |= LED_CAP; +- ioctl(0, KDSETLED, leds); +-#endif +- } +- +- /*------------------------------------------------------------------ +- Then find the Unicode value and send the event +- ------------------------------------------------------------------*/ +- //If we map the keyboard to a non-latin1 layout, we may have +- //valid keys with unknown key codes. +- if ( currentKey || keyCode != Qt::Key_unknown ) { +- bool bAlt = alt; +- bool bCtrl = ctrl; +- bool bShift = shift; +- int unicode = 0xffff; +- if ( currentKey ) { +-#if !defined(QT_QWS_SL5XXX) +- bool bCaps = shift || +- (caps ? QChar(QWSServer::keyMap()[code].unicode).isLetter() : FALSE); +-#else +- bool bCaps = caps ^ shift; +- if (fn) { +- if ( shift ) { +- bCaps = bShift = FALSE; +- bCtrl = TRUE; +- } +- if ( meta ) { +- bCaps = bShift = TRUE; +- bAlt = TRUE; +- } +- } else if ( meta ) { +- bCaps = bShift = TRUE; +- } +- if ( code > 40 && caps ) { +- // fn-keys should only react to shift, not caps +- bCaps = bShift = shift; +- } +- if ( numLock ) { +- if ( keyCode != Key_Space && keyCode != Key_Tab ) +- bCaps = bShift = FALSE; +- } +- if ( keyCode == Key_Delete && (bAlt || bCtrl) ) { +- keyCode = Key_BraceLeft; +- unicode = '['; +- bCaps = bShift = bAlt = bCtrl = FALSE; +- } else if (keyCode == Qt::Key_F31 && bCtrl) { +- keyCode = Key_QuoteLeft; +- unicode = '`'; +- } else +-#endif +- +- if (bCtrl) +- unicode = currentKey->ctrl_unicode; +- else if (bCaps) +- unicode = currentKey->shift_unicode; +- else +- unicode = currentKey->unicode; +-#ifndef QT_QWS_USE_KEYCODES +- } else if ( extended == 1 ) { +- if ( keyCode == Qt::Key_Slash ) +- unicode = '/'; +- else if ( keyCode == Qt::Key_Enter ) +- unicode = 0xd; +-#endif +- } +- +- modifiers = 0; +- if ( bAlt ) modifiers |= AltButton; +- if ( bCtrl ) modifiers |= ControlButton; +- if ( bShift ) modifiers |= ShiftButton; +- if ( keypad ) modifiers |= Keypad; +- +- // looks wrong -- WWA +- bool repeat = FALSE; +- if (prevuni == unicode && prevkey == keyCode && !release) +- repeat = TRUE; +- +- processKeyEvent( unicode, keyCode, modifiers, !release, repeat ); +- +- if (!release) { +- prevuni = unicode; +- prevkey = keyCode; +- } else { +- prevkey = prevuni = 0; +- } +- +-#ifdef QT_QWS_AUTOREPEAT_MANUALLY +- if ( repeatable && !release ) +- rep->start(prevuni,prevkey,modifiers); +- else +- rep->stop(); +-#endif +- +- } +-#ifndef QT_QWS_USE_KEYCODES +- extended = 0; +-#endif + } + + diff --git a/recipes-qt/qte/qte-2.3.10/sharp_char.h b/recipes-qt/qte/qte-2.3.10/sharp_char.h new file mode 100644 index 0000000..a70f5f6 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/spitz-adhoc-keypad-rotate.patch b/recipes-qt/qte/qte-2.3.10/spitz-adhoc-keypad-rotate.patch new file mode 100644 index 0000000..a32207d --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/spitz-adhoc-keypad-rotate.patch @@ -0,0 +1,21 @@ + +# +# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher +# + +Index: qt-2.3.10/src/kernel/kernelkeyboard.cpp +=================================================================== +--- qt-2.3.10.orig/src/kernel/kernelkeyboard.cpp 2006-04-05 23:04:30.000000000 +0200 ++++ qt-2.3.10/src/kernel/kernelkeyboard.cpp 2006-04-05 23:09:40.514650408 +0200 +@@ -568,7 +568,11 @@ + case Qt::Key_Down: + unicode = 0xffff; + mod_key = false; ++#if QT_QWS_SLCXK ++ if (qt_screen->transformOrientation() != 3) ++#else + if (qt_screen->isTransformed()) ++#endif + qtKeyCode = static_cast( xform_dirkey(static_cast( qtKeyCode ) ) ); + break; + /* diff --git a/recipes-qt/qte/qte-2.3.10/support_18bpp.patch b/recipes-qt/qte/qte-2.3.10/support_18bpp.patch new file mode 100644 index 0000000..138c4ce --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/support_18bpp.patch @@ -0,0 +1,275 @@ +diff -urN qt-2.3.10/configure qt-2.3.10_mod/configure +--- qt-2.3.10/configure 2005-01-23 08:00:36.000000000 -0600 ++++ qt-2.3.10_mod/configure 2006-10-21 23:13:29.000000000 -0500 +@@ -805,7 +805,8 @@ + echo " 4. 4bpp grayscale - also enables 8bpp" + echo " 8. 8bpp" + echo " 16. 16bpp" +- echo " 24. 24bpp - also enables 32bpp" ++ echo " 18. 18bpp - packed into 24bpp, cannot be enabled with 24bpp" ++ echo " 24. 24bpp - also enables 32bpp, cannot be enabled with 18bpp" + echo " 32. 32bpp" + echo + echo "Each depth adds around 100Kb on 80386." +@@ -830,7 +831,7 @@ + + if [ -n "$DEPTHS" ] + then +- DV=;D4=;D8=;D16=;D24=;D32= ++ DV=;D4=;D8=;D16=;D18=;D24=;D32= + for D in `echo "$DEPTHS" | sed -e 's/,/ /g'` + do + case "$D" in +@@ -838,10 +839,20 @@ + ;; 4) D4=y; D8=y + ;; 8) D8=y + ;; 16) D16=y ++ ;; 18) D18=y + ;; 24) D24=y; D32=y + ;; 32) D32=y + esac + done ++ ++ if [ ! -z "$D18" -a ! -z "$D24" ] ++ then ++ echo ++ echo "WARNING: You have configured with depth 18 and 24." ++ echo " These depths are not compatible. Depth 24" ++ echo " will be disabled." ++ fi ++ + if [ -z "$DV" ] + then + QT_CXX="$QT_CXX -DQT_NO_QWS_VGA_16" +@@ -858,9 +869,19 @@ + then + QT_CXX="$QT_CXX -DQT_NO_QWS_DEPTH_16" + fi ++ if [ -z "$D18" ] ++ then ++ QT_CXX="$QT_CXX -DQT_NO_QWS_DEPTH_18" ++ fi + if [ -z "$D24" ] + then + QT_CXX="$QT_CXX -DQT_NO_QWS_DEPTH_24" ++ else ++ # Disable depth 24 if depth 18 enabled ++ if [ ! -z "$D18" ] ++ then ++ QT_CXX="$QT_CXX -DQT_NO_QWS_DEPTH_24" ++ fi + fi + if [ -z "$D32" ] + then +@@ -1326,7 +1347,7 @@ + default ($QCONFIG). + + -depths list ....... Comma-separated list of supported bit-per-pixel +- depths, from: v, 4, 8, 16, 24, and 32. 'v' is VGA16. ++ depths, from: v, 4, 8, 16, 18, 24, and 32. 'v' is VGA16. + + -accel-snap ........ Enable SciTech SNAP Graphics acceleration. + -accel-voodoo3 ..... Enable Voodoo3 acceleration. +diff -urN qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp qt-2.3.10_mod/src/kernel/qgfxlinuxfb_qws.cpp +--- qt-2.3.10/src/kernel/qgfxlinuxfb_qws.cpp 2011-04-09 18:48:17.000000000 +0100 ++++ qt-2.3.10_mod/src/kernel/qgfxlinuxfb_qws.cpp 2011-04-09 18:54:45.000000000 +0100 +@@ -134,6 +134,10 @@ + } + + d=vinfo.bits_per_pixel; ++ // 18-bpp-support ++ if ((d == 18) || (d == 19)) ++ d = 24; ++ // End of 18-bpp-support + lstep=finfo.line_length; + int xoff = vinfo.xoffset; + int yoff = vinfo.yoffset; +@@ -427,6 +431,15 @@ + gbits=6; + bbits=5; + break; ++ // 18-bpp-support ++ case 18: case 19: ++ rbits=6; ++ gbits=6; ++ bbits=6; ++ vinfo.bits_per_pixel=24; ++ startupd=24; ++ break; ++ // End of 18-bpp-support + case 24: case 32: + rbits=gbits=bbits=8; + break; +@@ -819,6 +832,10 @@ + w=vinfo.xres; + h=vinfo.yres; + d=vinfo.bits_per_pixel; ++ // 18-bpp-support ++ if ((d == 18) || (d == 19)) ++ d = 24; ++ // End of 18-bpp-support + lstep=finfo.line_length; + size=h*lstep; + } +diff -urN qt-2.3.10/src/kernel/qgfxraster_qws.cpp qt-2.3.10_mod/src/kernel/qgfxraster_qws.cpp +--- qt-2.3.10/src/kernel/qgfxraster_qws.cpp 2005-01-23 08:00:47.000000000 -0600 ++++ qt-2.3.10_mod/src/kernel/qgfxraster_qws.cpp 2006-10-22 08:38:38.000000000 -0500 +@@ -161,25 +161,51 @@ + #endif + + #define MASK4BPP(x) (0xf0 >> (x)) +- ++// 18-bpp-support + inline void gfxSetRgb24( unsigned char *d, unsigned int p ) + { +- *d = p & 0x0000ff; ++#ifdef QT_NO_QWS_DEPTH_18 ++ *d = p & 0x000ff; + *(d+1) = (p & 0x00ff00 ) >> 8; + *(d+2) = (p & 0xff0000 ) >> 16; ++#else ++ uint b = (p & 0x0000ff) >> 0; ++ uint g = (p & 0x00ff00) >> 8; ++ uint r = (p & 0xff0000) >> 16; ++ uint data = (b>>2) | ((g>>2) << 6) | ((r>>2) << 12); ++ *d = data & 0xff; ++ *(d+1) = (data >> 8) & 0xff; ++ *(d+2) = (data >> 16) & 0xff; ++#endif + } + + inline void gfxSetRgb24( unsigned char *d, int r, int g, int b ) + { ++#ifdef QT_NO_QWS_DEPTH_18 + *d = b; + *(d+1) = g; + *(d+2) = r; ++#else ++ uint data = (b>>2) | ((g>>2) << 6) | ((r>>2) << 12); ++ *d = data & 0xff; ++ *(d+1) = (data >> 8) & 0xff; ++ *(d+2) = (data >> 16) & 0xff; ++#endif + } + + inline unsigned int gfxGetRgb24( unsigned char *d ) + { ++#ifdef QT_NO_QWS_DEPTH_18 + return *d | (*(d+1)<<8) | (*(d+2)<<16); ++#else ++ uint data = *d | (*(d+1)<<8) | (*(d+2)<<16); ++ uint r = ((data >> 10) & 0xfc); ++ uint g = ((data >> 4) & 0xfc); ++ uint b = ((data << 2) & 0xfc); ++ return b | (g << 8) | (r << 16); ++#endif + } ++// End of 18-bpp-support + + static bool simple_8bpp_alloc=FALSE; + +@@ -1767,11 +1793,12 @@ + } else { + (*srcdata)+=4; + } +-#if !defined( QT_NO_QWS_DEPTH_24 ) ++// 18-bpp hack (mlk) ++//#if !defined( QT_NO_QWS_DEPTH_24 ) + } else if(sdepth==24) { + ret = gfxGetRgb24( *srcdata ); + (*srcdata) += 3; +-#endif ++//#endif + #if !defined( QT_NO_IMAGE_16_BIT ) || !defined( QT_NO_QWS_DEPTH_16 ) + } else if(sdepth==16) { + unsigned short int hold=*((unsigned short int *)(*srcdata)); +@@ -3963,9 +3990,22 @@ + unsigned char *alphaptr = (unsigned char *)alphabuf; + unsigned char *avp = alphas; + int loopc; +- ++// 18-bpp-support ++#ifdef QT_NO_QWS_DEPTH_18 + memcpy( alphabuf, myptr+x1*3, w*3 ); +- ++#else ++ { uchar *srcptr24 = myptr+x1*3; ++ uchar *dstptr24 = (uchar*)alphabuf; ++ for ( int i = 0; i < w; i++ ) { ++ uint pix = gfxGetRgb24(srcptr24); ++ dstptr24[2] = (pix >> 16) & 0xff; ++ dstptr24[1] = (pix >> 8) & 0xff; ++ dstptr24[0] = (pix >> 0) & 0xff; ++ srcptr24 += 3; ++ dstptr24 += 3; ++ } } ++#endif ++// End of 18-bpp-support + // Now blend with source data + unsigned char * srcptr=srcdata; + unsigned int srcval; +@@ -5808,10 +5848,10 @@ + } else if(d==8) { + ret = new QGfxRaster<8,0>(bytes,w,h); + #endif +-#ifndef QT_NO_QWS_DEPTH_24 ++//#ifndef QT_NO_QWS_DEPTH_24 + } else if(d==24) { + ret = new QGfxRaster<24,0>(bytes,w,h); +-#endif ++//#endif + #ifndef QT_NO_QWS_DEPTH_32 + } else if(d==32) { + ret = new QGfxRaster<32,0>(bytes,w,h); +diff -urN qt-2.3.10/src/kernel/qgfxtransformed_qws.cpp qt-2.3.10_mod/src/kernel/qgfxtransformed_qws.cpp +--- qt-2.3.10/src/kernel/qgfxtransformed_qws.cpp 2005-01-23 08:00:46.000000000 -0600 ++++ qt-2.3.10_mod/src/kernel/qgfxtransformed_qws.cpp 2006-10-22 00:57:27.000000000 -0500 +@@ -1020,10 +1020,10 @@ + } else if (d==8) { + ret = new QGfxTransformedRaster<8,0>(bytes,w,h); + #endif +-#ifndef QT_NO_QWS_DEPTH_24 ++//#ifndef QT_NO_QWS_DEPTH_24 + } else if (d==24) { + ret = new QGfxTransformedRaster<24,0>(bytes,w,h); +-#endif ++//#endif + #ifndef QT_NO_QWS_DEPTH_32 + } else if (d==32) { + ret = new QGfxTransformedRaster<32,0>(bytes,w,h); +diff -urN qt-2.3.10/src/kernel/qgfxvfb_qws.cpp qt-2.3.10_mod/src/kernel/qgfxvfb_qws.cpp +--- qt-2.3.10/src/kernel/qgfxvfb_qws.cpp 2005-01-23 08:00:47.000000000 -0600 ++++ qt-2.3.10_mod/src/kernel/qgfxvfb_qws.cpp 2006-10-22 00:19:30.000000000 -0500 +@@ -288,10 +288,14 @@ + d = hdr->depth; + lstep = hdr->linestep; + +-#ifdef DEBUG ++//#ifdef DEBUG + qDebug( "Connected to VFB server: %d x %d x %d", w, h, d ); +-#endif ++//#endif + ++// 18-bpp-support ++ if ( (d == 18) || (d == 19) ) ++ d = 24; ++// End of 18-bpp-support + size = lstep * h; + mapsize = size; + screencols = hdr->numcols; +@@ -434,6 +438,15 @@ + else + ret = new QGfxRaster<32,0>(bytes,w,h); + #endif ++// 18-bpp-support ++//#ifndef QT_NO_QWS_DEPTH_24 ++ } else if (d==24) { ++ if ( bytes == qt_screen->base() ) ++ ret = new QGfxVFb<24,0>(bytes,w,h); ++ else ++ ret = new QGfxRaster<24,0>(bytes,w,h); ++//#endif ++// 18-bpp-support + } else { + qFatal("Can't drive depth %d",d); + } diff --git a/recipes-qt/qte/qte-2.3.10/suspend-resume-hooks.patch b/recipes-qt/qte/qte-2.3.10/suspend-resume-hooks.patch new file mode 100644 index 0000000..c6e9f16 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/suspend-resume-hooks.patch @@ -0,0 +1,78 @@ + +# +# Patch managed by http://www.holgerschurig.de/patcher.html +# + +--- qt-2.3.10.foo/src/kernel/qgfx_qws.h~suspend-resume-hooks ++++ qt-2.3.10.foo/src/kernel/qgfx_qws.h +@@ -192,6 +192,8 @@ + virtual int pixmapLinestepAlignment() { return 64; } + + virtual void sync() {} ++ virtual void prepareToSuspend() {} ++ virtual void prepareToResume() {} + virtual bool onCard(unsigned char *) const; + virtual bool onCard(unsigned char *, ulong& out_offset) const; + +--- qt-2.3.10.foo/src/kernel/qapplication_qws.cpp~suspend-resume-hooks ++++ qt-2.3.10.foo/src/kernel/qapplication_qws.cpp +@@ -480,6 +480,7 @@ + int region_offset_window; + #ifndef QT_NO_COP + QWSQCopMessageEvent *qcop_response; ++ bool manageAPMMessage( QWSQCopMessageEvent *e ); + #endif + QWSEvent* current_event; + QValueList unused_identifiers; +@@ -840,7 +841,7 @@ + QWSQCopMessageEvent *pe = (QWSQCopMessageEvent*)e; + if ( pe->simpleData.is_response ) { + qcop_response = pe; +- } else { ++ } else if ( !manageAPMMessage( pe ) ) { + queue.append(e); + } + #endif +@@ -851,6 +852,42 @@ + } + } + ++#ifndef QT_NO_COP ++bool QWSDisplayData::manageAPMMessage( QWSQCopMessageEvent *e ) ++{ ++ if ( e->channel.data() != QCString( "QPE/System" ) ) { ++ return FALSE; ++ } ++ if ( e->message.data() == QCString( "aboutToSuspend()" ) ) { ++ if ( qt_screen ) qt_screen->prepareToSuspend(); ++ delete e; ++ return TRUE; ++ } ++ if ( e->message.data() == QCString( "returnFromSuspend()" ) ) { ++ if ( qt_screen ) qt_screen->prepareToResume(); ++ delete e; ++ QWidgetList *list = QApplication::topLevelWidgets(); ++ if ( list ) { ++ QWidgetListIt it( *list ); ++ QWidget * w; ++ while ( (w=it.current()) != 0 ) { ++ ++it; ++ if ( !w->testWFlags(Qt::WType_Desktop) ) { ++ QETWidget *etw = (QETWidget*)w; ++ if ( etw->isVisible() ) { ++ etw->repaintHierarchy( etw->geometry(), TRUE ); ++ etw->repaintDecoration( qApp->desktop()->rect(), TRUE ); ++ } ++ } ++ } ++ delete list; ++ } ++ return TRUE; ++ } ++ return FALSE; ++} ++#endif ++ + void QWSDisplayData::offsetPendingExpose( int window, const QPoint &offset ) + { + if ( offset.isNull() ) diff --git a/recipes-qt/qte/qte-2.3.10/switches.h b/recipes-qt/qte/qte-2.3.10/switches.h new file mode 100644 index 0000000..37516b4 --- /dev/null +++ b/recipes-qt/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/recipes-qt/qte/qte-2.3.10/tslib.patch b/recipes-qt/qte/qte-2.3.10/tslib.patch new file mode 100644 index 0000000..47837d7 --- /dev/null +++ b/recipes-qt/qte/qte-2.3.10/tslib.patch @@ -0,0 +1,53 @@ +Index: qt-2.3.10/src/kernel/qwsmouse_qws.cpp +=================================================================== +--- qt-2.3.10.orig/src/kernel/qwsmouse_qws.cpp 2005-02-16 00:53:53.090339898 +0100 ++++ qt-2.3.10/src/kernel/qwsmouse_qws.cpp 2005-02-16 00:54:43.059069292 +0100 +@@ -1878,30 +1878,33 @@ + */ + void QTSLibHandlerPrivate::interpolateSample() { + #ifdef QT_QWS_TSLIB +- static struct ts_sample samples[25]; +- int index = -1; ++#define TSLIB_MAX_SAMPLES 25 ++ static struct ts_sample samples[TSLIB_MAX_SAMPLES]; ++ int index = 0; ++ int read_samples = 0; + int ret; + + do { +- /* fill only the last sample again */ +- if ( index >= 25 ) +- index = 24; +- ++ /* do not access negative arrays */ ++ if ( index < 0 ) ++ index = 0; ++ + /* we're opened non-blocking */ +- if((ret= ts_read_raw(m_ts, &samples[index], 1 ) ) != 1 ) { ++ if((ret= ts_read_raw(m_ts, &samples[index], 1 ) ) != 1 ) + /* no event yet, so try again */ +- if (ret==-1 ) { +- index--; ++ if (ret==-1 ) + continue; +- } +- } +- }while (samples[index++].pressure != 0); ++ ++ read_samples++; ++ index = (index+1)%TSLIB_MAX_SAMPLES; ++ }while (samples[index == 0 ? (TSLIB_MAX_SAMPLES-1) : index-1].pressure != 0); + + /* +- * index is maximal 25 and we at least one sample ++ * If we've wrapped around each sample is used otherwise ++ * we will use the index + */ +- if( index >= 25 ) +- index = 24; ++ index = read_samples >= TSLIB_MAX_SAMPLES ? ++ (TSLIB_MAX_SAMPLES-1 ) : index; + int x, y; + + /* diff --git a/recipes-qt/qte/qte-2.3.10/vt-switch.patch b/recipes-qt/qte/qte-2.3.10/vt-switch.patch new file mode 100644 index 0000000..4007a5d --- /dev/null +++ b/recipes-qt/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 ++#include ++#include ++#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 ++ * Added a new command line option which only is relevant if the application is created as a GuiServer. ++ * The option is -terminal , where 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/recipes-qt/qte/qte-common_2.3.10.inc b/recipes-qt/qte/qte-common_2.3.10.inc new file mode 100644 index 0000000..75419ac --- /dev/null +++ b/recipes-qt/qte/qte-common_2.3.10.inc @@ -0,0 +1,149 @@ +DESCRIPTION = "Qt/Embedded Version ${PV}" +SECTION = "libs" +PRIORITY = "optional" +HOMEPAGE = "http://www.trolltech.com" +LICENSE = "GPL" +DEPENDS = "zlib libpng jpeg tslib uicmoc-native" +#DEPENDS_append_c7x0 = " sharp-aticore-oss" +PROVIDES = "virtual/libqte2" + +FILESDIR = "${@os.path.dirname(bb.data.getVar('FILE',d,1))}/qte-${PV}" + +# Workaround GCC 4.1 issues with -fvisibility-inlines-hidden (see #1521) +# by disabling it for qpe only. TODO: pinpoint actual issue causing GCC +# misbehavior. +# +# Laibsch: Remove -fno-visibility-inlines-hidden instead of negating it +# Laibsch: Fixes bug 1631 +#CXXFLAGS += "-fno-visibility-inlines-hidden" +CXXFLAGS := "${@oe_filter_out('-fvisibility-inlines-hidden', '${CXXFLAGS}', d)}" + +SRC_URI = "ftp://ftp.trolltech.com/pub/qt/source/qt-embedded-${PV}-free.tar.gz;md5sum=1f7ad30113afc500cab7f5b2f4dec0d7 \ + file://qpe.patch \ + file://vt-switch.patch \ + file://daemonize.patch \ + file://no-moc.patch \ + file://gcc3.patch \ + file://gcc4.patch \ + file://encoding.patch \ + file://fix-qgfxraster.patch \ + file://qt-visibility.patch \ + file://tslib.patch \ + file://handhelds.patch \ + file://qiconview-speed.patch \ + file://qtabbar.patch \ + file://increase-qxml-robustness.patch \ + file://qte-fix-iconsize.patch \ + file://fix-linuxfb-setmode.patch \ + file://fix-linuxfb-offscreenoverflow.patch \ + file://fix-qscreen-sync.patch \ + file://improve-calibration-r0.patch \ + file://key.patch \ + file://bidimetrics.patch \ + file://fix-native-build.patch \ + file://fix-errno-exception-spec.patch \ + file://keyboardless-buttonmap.patch \ + file://kernel-keymap.patch \ + file://kernel-keymap-corgi.patch \ + file://remove-unused-kbdhandler.patch \ + file://disable-dup-rotation.patch \ + file://fix-qte-asm-include.patch \ + file://support_18bpp.patch \ + file://sharp_char.h \ + file://switches.h " + +# +# add device specific patches here +# + +W100_ACCEL_PATCHES = "file://c7x0-w100-accel.patch \ + file://c7x0-w100-gcc4.patch \ + file://suspend-resume-hooks.patch" + +#SRC_URI_append_c7x0 = "${W100_ACCEL_PATCHES} " +#SRC_URI_append_spitz = "file://spitz-adhoc-keypad-rotate.patch " +#SRC_URI_append_akita = "file://spitz-adhoc-keypad-rotate.patch " + +# "ipaqs" used to have this, but later were proven to at least work +# without it. Review again and see if has interesting bits to be applied +# universally. +#SRC_URI_append = "file://ipaq_sound_fix.patch " + + +S = "${WORKDIR}/qt-${PV}" +export QTDIR = "${S}" + +require qte-functions.inc +QTE_ARCH := "${@qte_arch(d)}" + +# +# add device configuration here +# +EXTRA_OECONF_CONFIG = "-qconfig qpe" +#EXTRA_OECONF_CONFIG_c7x0 = "-qconfig qpe -accel-w100" +EXTRA_OECONF_CONFIG_native = "-qconfig qpe -qvfb" + +EXTRA_OECONF = "-system-jpeg -system-libpng -system-zlib -no-qvfb -no-xft -no-vnc -gif \ + -xplatform ${TARGET_OS}-${QTE_ARCH}-g++ ${EXTRA_OECONF_CONFIG} -depths 8,16,18,32" +EXTRA_OEMAKE = "-e" + +# +# add device flags here +# +EXTRA_DEFINES = "-DQT_QWS_TSLIB -DQT_QWS_CUSTOM -DQT_QWS_IPAQ" +#EXTRA_DEFINES_spitz = "-DQT_QWS_TSLIB -DQT_QWS_CUSTOM -DQT_QWS_IPAQ -DQT_QWS_SLCXK" +#EXTRA_DEFINES_akita = "-DQT_QWS_TSLIB -DQT_QWS_CUSTOM -DQT_QWS_IPAQ -DQT_QWS_SLCXK" + +# +# don't touch anything below here +# +export SYSCONF_CC = "${CC}" +export SYSCONF_CXX = "${CXX}" +export SYSCONF_LINK = "${CCLD}" +export SYSCONF_SHLIB = "${CCLD}" +export SYSCONF_CFLAGS = "${CFLAGS}" +export SYSCONF_LINK_SHLIB = "${CCLD}" +export SYSCONF_CXXFLAGS = "${CXXFLAGS} -pipe -DQWS -fno-exceptions -frtti -DNO_DEBUG ${EXTRA_DEFINES} -DUSE_BIDI" +# enable if gcc supports visibility +#export SYSCONF_CXXFLAGS = "${CXXFLAGS} -pipe -DQWS -fno-exceptions -frtti -fvisibility=hidden -DGCC_SUPPORTS_VISIBILITY -DNO_DEBUG ${EXTRA_DEFINES} -DUSE_BIDI" +export SYSCONF_LFLAGS = "${LDFLAGS} -lts" +export SYSCONF_MOC = "${STAGING_BINDIR_NATIVE}/moc" +export SYSCONF_UIC = "${STAGING_BINDIR_NATIVE}/uic" + +# generate uclibc, eabi and powerpc configurations +do_configure() { + for f in ${S}/configs/linux-*-g++-shared; do + sed -e 's,-linux-,-linux-uclibc-,g' < $f \ + > `dirname $f`/`basename $f | sed -e 's,linux-,linux-uclibc-,'` + sed -e 's,-linux-,-linux-gnueabi-,g' < $f \ + > `dirname $f`/`basename $f | sed -e 's,linux-,linux-gnueabi-,'` + sed -e 's,-linux-,-linux-uclibceabi-,g' < $f \ + > `dirname $f`/`basename $f | sed -e 's,linux-,linux-uclibceabi-,'` + done + sed -e 's/arm/powerpc/' ${S}/configs/linux-arm-g++-shared > ${S}/configs/linux-powerpc-g++-shared + echo yes | ./configure ${EXTRA_OECONF} || die "Configuring qte failed. EXTRA_OECONF was ${EXTRA_OECONF}" +} + +do_compile() { + unset CC LD CCLD CXX RANLIB AR STRIP CFLAGS LDFLAGS CXXFLAGS CPPFLAGS + install -d include/asm/ + install -m 0644 ${WORKDIR}/sharp_char.h include/asm/ + install -d include/linux/ + install -m 0644 ${WORKDIR}/switches.h include/linux/ + + # Create symlinks first and then compile the library + oe_runmake symlinks + oe_runmake src-mt sub-src +} + +do_install() { + oe_libinstall -so -C lib lib${PN} ${D}${libdir} + + install -d ${D}/${includedir}/qte + rm -f include/qxt.h + install -m 0644 include/*.h ${D}/${includedir}/qte/ +} + +FILES_${PN} = "${libdir}/lib${PN}.so.*" +FILES_${PN}-dev = "${includedir}/* ${libdir}/lib${PN}.so" +FILES_${PN}-dbg += "${libdir}/.debug/" diff --git a/recipes-qt/qte/qte-functions.inc b/recipes-qt/qte/qte-functions.inc new file mode 100644 index 0000000..f0ffb0e --- /dev/null +++ b/recipes-qt/qte/qte-functions.inc @@ -0,0 +1,11 @@ +def qte_arch(d): + import bb, re + arch = bb.data.getVar('TARGET_ARCH', d, 1) + if re.match("^i.86$", arch): + arch = "x86" + elif arch == "x86_64": + arch = "x86" + elif arch == "mipsel": + arch = "mips" + return arch + diff --git a/recipes-qt/qte/qte-mt_2.3.10.bb b/recipes-qt/qte/qte-mt_2.3.10.bb new file mode 100644 index 0000000..84467f5 --- /dev/null +++ b/recipes-qt/qte/qte-mt_2.3.10.bb @@ -0,0 +1,9 @@ +require qte-common_${PV}.inc +PR = "r31" + +EXTRA_OECONF += "-thread" + +DEFAULT_PREFERENCE = "1" + +SRC_URI[md5sum] = "1f7ad30113afc500cab7f5b2f4dec0d7" +SRC_URI[sha256sum] = "883363eb0c94de3d1e36f3ab9e09a8f127418d497213cc1a0ed1a1588ecd66b8" diff --git a/recipes-qt/qte/qte_2.3.10.bb b/recipes-qt/qte/qte_2.3.10.bb new file mode 100644 index 0000000..7a4376d --- /dev/null +++ b/recipes-qt/qte/qte_2.3.10.bb @@ -0,0 +1,6 @@ +require qte-common_${PV}.inc +PR = "r56" + + +SRC_URI[md5sum] = "1f7ad30113afc500cab7f5b2f4dec0d7" +SRC_URI[sha256sum] = "883363eb0c94de3d1e36f3ab9e09a8f127418d497213cc1a0ed1a1588ecd66b8" -- cgit 1.2.3-korg