From d3f7a9d6f1b8f6e24fb49aaa8caeaa7623ae48b5 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sat, 23 Jul 2011 17:13:36 -0500 Subject: Apply all Qt3.3.8d patches NOTE: This will *likely* break compilation of TQt4 Please wait a few days for fixes to be committed as needed! --- tqtinterface/qt4/src/__debian_export_symbols.cpp | 63 ++ tqtinterface/qt4/src/codecs/tqutfcodec.cpp | 2 +- tqtinterface/qt4/src/dialogs/tqdialog.cpp | 21 +- tqtinterface/qt4/src/iconview/tqiconview.cpp | 208 +++-- .../qt4/src/inputmethod/tqinputcontextfactory.cpp | 186 +++++ .../qt4/src/inputmethod/tqinputcontextfactory.h | 59 ++ .../src/inputmethod/tqinputcontextinterface_p.h | 87 +++ .../qt4/src/inputmethod/tqinputcontextplugin.cpp | 231 ++++++ .../qt4/src/inputmethod/tqinputcontextplugin.h | 67 ++ .../qt4/src/inputmethod/tqt_inputmethod.pri | 10 + tqtinterface/qt4/src/kernel/qt_kernel.pri | 8 +- tqtinterface/qt4/src/kernel/tqapplication.cpp | 68 +- tqtinterface/qt4/src/kernel/tqapplication.h | 26 +- tqtinterface/qt4/src/kernel/tqapplication_x11.cpp | 754 +++++++++++------- tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp | 18 + .../qt4/src/kernel/tqdesktopwidget_x11.cpp | 46 +- tqtinterface/qt4/src/kernel/tqdnd_x11.cpp | 138 +++- tqtinterface/qt4/src/kernel/tqdragobject.cpp | 10 + tqtinterface/qt4/src/kernel/tqdragobject.h | 3 +- tqtinterface/qt4/src/kernel/tqevent.cpp | 4 + tqtinterface/qt4/src/kernel/tqfontdatabase.cpp | 34 +- tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp | 8 +- tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp | 17 +- tqtinterface/qt4/src/kernel/tqinputcontext.cpp | 856 +++++++++++++++++++++ tqtinterface/qt4/src/kernel/tqinputcontext.h | 143 ++++ tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp | 504 +----------- tqtinterface/qt4/src/kernel/tqnamespace.h | 92 ++- tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp | 15 +- tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp | 593 +++++++++++--- tqtinterface/qt4/src/kernel/tqrichtext.cpp | 20 +- tqtinterface/qt4/src/kernel/tqrichtext_p.h | 3 +- tqtinterface/qt4/src/kernel/tqt_x11_p.h | 5 + tqtinterface/qt4/src/kernel/tqwidget.cpp | 33 +- tqtinterface/qt4/src/kernel/tqwidget.h | 54 +- tqtinterface/qt4/src/kernel/tqwidget_x11.cpp | 521 ++++++++++--- tqtinterface/qt4/src/opengl/tqgl_x11.cpp | 4 +- tqtinterface/qt4/src/qt.pro | 17 +- .../qt4/src/sql/drivers/ibase/tqsql_ibase.cpp | 2 +- tqtinterface/qt4/src/sql/qt_sql.pri | 2 +- tqtinterface/qt4/src/tools/tqdir_unix.cpp | 23 + tqtinterface/qt4/src/tools/tqfeatures.h | 10 + tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp | 36 +- tqtinterface/qt4/src/tools/tqglobal.h | 10 +- tqtinterface/qt4/src/tools/tqlibrary.cpp | 1 + tqtinterface/qt4/src/tools/tqlocale.cpp | 15 +- tqtinterface/qt4/src/tools/tqmap.h | 1 + tqtinterface/qt4/src/tools/tqstring.h | 2 +- tqtinterface/qt4/src/tools/tqvaluelist.h | 1 + tqtinterface/qt4/src/widgets/tqbutton.h | 4 +- tqtinterface/qt4/src/widgets/tqcombobox.cpp | 32 +- tqtinterface/qt4/src/widgets/tqlineedit.cpp | 108 ++- tqtinterface/qt4/src/widgets/tqlineedit.h | 1 + tqtinterface/qt4/src/widgets/tqlistview.cpp | 27 +- tqtinterface/qt4/src/widgets/tqmenubar.cpp | 26 +- tqtinterface/qt4/src/widgets/tqpopupmenu.cpp | 112 ++- tqtinterface/qt4/src/widgets/tqpopupmenu.h | 1 + tqtinterface/qt4/src/widgets/tqscrollview.cpp | 5 +- tqtinterface/qt4/src/widgets/tqtextedit.cpp | 124 ++- tqtinterface/qt4/src/widgets/tqtextedit.h | 5 +- tqtinterface/qt4/src/widgets/tqtooltip.cpp | 5 + 60 files changed, 4233 insertions(+), 1248 deletions(-) create mode 100644 tqtinterface/qt4/src/__debian_export_symbols.cpp create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp create mode 100644 tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h create mode 100644 tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri create mode 100644 tqtinterface/qt4/src/kernel/tqinputcontext.cpp create mode 100644 tqtinterface/qt4/src/kernel/tqinputcontext.h (limited to 'tqtinterface/qt4/src') diff --git a/tqtinterface/qt4/src/__debian_export_symbols.cpp b/tqtinterface/qt4/src/__debian_export_symbols.cpp new file mode 100644 index 0000000..71e30ad --- /dev/null +++ b/tqtinterface/qt4/src/__debian_export_symbols.cpp @@ -0,0 +1,63 @@ +// Use the __NO_INLINE__ hack below to prevent sys/stat.h from +// exporting __extern_inline definitions of the symbols [fl]?stat64 +// with g++-4.3 or later and glibc6 >= 2.7 or later. This flag has no +// impact on [fl]?stat(64)? symbol export for glibc6 << 2.7 +// +#ifndef __NO_INLINE__ +# define __NO_INLINE__ +# define INLINE_ENABLED +#endif + +#include + +#if defined(__GLIBC_PREREQ) && __GLIBC_PREREQ(2, 7) + +// We must ensure that [fl]?stat64 are exported in the dynamic symbol +// table of libqt-mt.so.3 as weak symbols to preserve ABI. +int stat64 (__const char *__path, struct stat64 *__statbuf) __attribute__((weak)); +int lstat64 (__const char *__path, struct stat64 *__statbuf) __attribute__((weak)); +int fstat64 (int __fd, struct stat64 *__statbuf) __attribute__((weak)); + +int stat64 (__const char *__path, struct stat64 *__statbuf) +{ + return __xstat64 (_STAT_VER, __path, __statbuf); +} + +int lstat64 (__const char *__path, struct stat64 *__statbuf) +{ + return __lxstat64 (_STAT_VER, __path, __statbuf); +} + +int fstat64 (int __fd, struct stat64 *__statbuf) +{ + return __fxstat64 (_STAT_VER, __fd, __statbuf); +} + +#else +# ifndef INLINE_ENABLED +/* + * Trigger export of the extern __inline [fl]?stat64 symbols + * (defined at ) by referencing them in the dummy + * hidden function below. It's very important to reference + * [fl]?stat64 via their [fl]?stat aliases (because LARGEFILE + * is enabled) for these weak symbols to get exported. + * + * This hack is compatible with libc6-dev << 2.7 headers. + * + * This source file must be compiled with -fno-inline to have + * expected effect. + **/ +void __stat_extern_inline_export_hack() + __attribute__((visibility("hidden"))); + +void __stat_extern_inline_export_hack() { + struct stat buf; + stat("", &buf); + lstat("", &buf); + fstat(0, &buf); +} +# else +# error "This file must be compiled with inline disabled for the hack to be effective." +# endif /* INLINES_ENABLED */ + +#endif diff --git a/tqtinterface/qt4/src/codecs/tqutfcodec.cpp b/tqtinterface/qt4/src/codecs/tqutfcodec.cpp index 5b263e9..3a80d31 100644 --- a/tqtinterface/qt4/src/codecs/tqutfcodec.cpp +++ b/tqtinterface/qt4/src/codecs/tqutfcodec.cpp @@ -303,7 +303,7 @@ public: TQString toUnicode(const char* chars, int len) { TQString result; - result.setLength( len ); // worst case + result.setLength( len + 1 ); // worst case TQChar *qch = (TQChar *)result.tqunicode(); TQChar ch; while ( len-- ) { diff --git a/tqtinterface/qt4/src/dialogs/tqdialog.cpp b/tqtinterface/qt4/src/dialogs/tqdialog.cpp index 43db3ca..58093f1 100644 --- a/tqtinterface/qt4/src/dialogs/tqdialog.cpp +++ b/tqtinterface/qt4/src/dialogs/tqdialog.cpp @@ -681,6 +681,11 @@ bool TQDialog::event( TQEvent *e ) #if defined(TQ_WS_X11) extern "C" { int XSetTransientForHint( Display *, unsigned long, unsigned long ); } +#include +#undef FocusIn +// defined in qapplication_x11.cpp +extern Atom qt_net_wm_full_placement; +extern bool qt_net_supports(Atom atom); #endif // TQ_WS_X11 /*! @@ -702,10 +707,12 @@ void TQDialog::show() if ( !did_resize ) adjustSize(); - if ( has_relpos && !did_move ) { - adjustPositionInternal( parentWidget(), TRUE ); - } else if ( !did_move ) { - adjustPositionInternal( parentWidget() ); + if( !qt_net_supports( qt_net_wm_full_placement )) { + if ( has_relpos && !did_move ) { + adjustPositionInternal( parentWidget(), TRUE ); + } else if ( !did_move ) { + adjustPositionInternal( parentWidget() ); + } } if (windowState() != state) @@ -716,7 +723,7 @@ void TQDialog::show() && tqApp->mainWidget() && tqApp->mainWidget()->isVisible() && !tqApp->mainWidget()->isMinimized()) { // make sure the transient for hint is set properly for modal dialogs - XSetTransientForHint( x11Display(), winId(), tqApp->mainWidget()->winId() ); + x11SetWindowTransient( tqApp->mainWidget()); } #endif // TQ_WS_X11 @@ -811,7 +818,9 @@ void TQDialog::adjustPositionInternal( TQWidget*w, bool useRelPos) w = w->tqtopLevelWidget(); TQRect desk; if ( w ) { - scrn = TQApplication::desktop()->screenNumber( w ); + // Use mapToGlobal rather than tqgeometry() in case w might + // be embedded in another application + scrn = TQApplication::desktop()->screenNumber( w->mapToGlobal( TQPoint(0,0) ) ); } else if ( TQApplication::desktop()->isVirtualDesktop() ) { scrn = TQApplication::desktop()->screenNumber( TQCursor::pos() ); } else { diff --git a/tqtinterface/qt4/src/iconview/tqiconview.cpp b/tqtinterface/qt4/src/iconview/tqiconview.cpp index e95ff47..08ab4bd 100644 --- a/tqtinterface/qt4/src/iconview/tqiconview.cpp +++ b/tqtinterface/qt4/src/iconview/tqiconview.cpp @@ -264,6 +264,7 @@ public: TQIconViewToolTip *toolTip; TQPixmapCache maskCache; + TQPixmap *backrubber; TQPtrDict selectedItems; struct ItemContainer { @@ -1998,14 +1999,27 @@ void TQIconViewItem::paintItem( TQPainter *p, const TQColorGroup &cg ) if ( picture() ) { TQPicture *pic = picture(); if ( isSelected() ) { - p->fillRect( pixmapRect( FALSE ), TQBrush( cg.highlight(), Qt::Dense4Pattern) ); + p->setBrush( TQBrush( cg.highlight(), TQBrush::Dense4Pattern ) ); + p->setPen( TQPen( cg.highlight(), TQBrush::Dense4Pattern ) ); + p->drawRoundRect( pixmapRect( FALSE ), + 1000 / pixmapRect( FALSE ).width(), + 1000 / pixmapRect( FALSE ).height() ); } p->drawPicture( x()-pic->boundingRect().x(), y()-pic->boundingRect().y(), *pic ); if ( isSelected() ) { - p->fillRect( textRect( FALSE ), cg.highlight() ); + p->setBrush( TQBrush( cg.highlight() ) ); + p->setPen( TQPen( cg.highlight() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); p->setPen( TQPen( cg.highlightedText() ) ); - } else if ( view->d->itemTextBrush != Qt::NoBrush ) - p->fillRect( textRect( FALSE ), view->d->itemTextBrush ); + } else if ( view->d->itemTextBrush != Qt::NoBrush ) { + p->setBrush( view->d->itemTextBrush ); + p->setPen( TQPen( view->d->itemTextBrush.color() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); + } int align = view->itemTextPos() == TQIconView::Bottom ? AlignHCenter : AlignAuto; if ( view->d->wordWrapIconText ) @@ -2063,10 +2077,19 @@ void TQIconViewItem::paintItem( TQPainter *p, const TQColorGroup &cg ) p->save(); if ( isSelected() ) { - p->fillRect( textRect( FALSE ), cg.highlight() ); + p->setBrush( TQBrush( cg.highlight() ) ); + p->setPen( TQPen( cg.highlight() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); p->setPen( TQPen( cg.highlightedText() ) ); - } else if ( view->d->itemTextBrush != Qt::NoBrush ) - p->fillRect( textRect( FALSE ), view->d->itemTextBrush ); + } else if ( view->d->itemTextBrush != Qt::NoBrush ) { + p->setBrush( view->d->itemTextBrush ); + p->setPen( TQPen( view->d->itemTextBrush.color() ) ); + p->drawRoundRect( textRect( FALSE ), + 1000 / textRect( FALSE ).width(), + 1000 / textRect( FALSE ).height() ); + } int align = AlignHCenter; if ( view->d->wordWrapIconText ) @@ -2082,31 +2105,14 @@ void TQIconViewItem::paintItem( TQPainter *p, const TQColorGroup &cg ) /*! Paints the focus rectangle of the item using the painter \a p and the color group \a cg. + + The default implementation does nothing; subclasses may + reimplement this function. */ -void TQIconViewItem::paintFocus( TQPainter *p, const TQColorGroup &cg ) +void TQIconViewItem::paintFocus( TQPainter *p, const TQColorGroup & ) { - if ( !view ) - return; - view->tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, p, - TQRect( textRect( FALSE ).x(), textRect( FALSE ).y(), - textRect( FALSE ).width(), - textRect( FALSE ).height() ), cg, - (isSelected() ? - TQStyle::Style_FocusAtBorder : - TQStyle::Style_Default), - TQStyleOption(isSelected() ? cg.highlight() : cg.base())); - - if ( this != view->d->currentItem ) { - view->tqstyle().tqdrawPrimitive(TQStyle::PE_FocusRect, p, - TQRect( pixmapRect( FALSE ).x(), - pixmapRect( FALSE ).y(), - pixmapRect( FALSE ).width(), - pixmapRect( FALSE ).height() ), - cg, TQStyle::Style_Default, - TQStyleOption(cg.base())); - } } /*! @@ -2804,6 +2810,7 @@ TQIconView::TQIconView( TQWidget *tqparent, const char *name, WFlags f ) d->renamingItem = 0; d->drawActiveSelection = TRUE; d->drawDragShapes = FALSE; + d->backrubber = 0; connect( d->adjustTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( adjustItems() ) ); @@ -3288,7 +3295,7 @@ uint TQIconView::count() const void TQIconView::doAutoScroll() { - TQRect oldRubber = TQRect( *d->rubber ); + TQRect oldRubber = *d->rubber; TQPoint vp = viewport()->mapFromGlobal( TQCursor::pos() ); TQPoint pos = viewportToContents( vp ); @@ -3305,7 +3312,6 @@ void TQIconView::doAutoScroll() bool block = tqsignalsBlocked(); TQRect rr; - TQRegion region( 0, 0, visibleWidth(), visibleHeight() ); blockSignals( TRUE ); viewport()->setUpdatesEnabled( FALSE ); @@ -3331,9 +3337,6 @@ void TQIconView::doAutoScroll() item->setSelected( TRUE, TRUE ); changed = TRUE; rr = rr.unite( item->rect() ); - } else { - region = region.subtract( TQRect( contentsToViewport( item->pos() ), - item->size() ) ); } minx = TQMIN( minx, item->x() - 1 ); @@ -3350,37 +3353,72 @@ void TQIconView::doAutoScroll() viewport()->setUpdatesEnabled( TRUE ); blockSignals( block ); - TQRect r = *d->rubber; - *d->rubber = oldRubber; - - TQPainter p; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); - drawRubber( &p ); - d->dragging = FALSE; - p.end(); - - *d->rubber = r; - - if ( changed ) { - d->drawAllBack = FALSE; - d->clipRegion = region; - repaintContents( rr, FALSE ); - d->drawAllBack = TRUE; + // static bool drawAll; + if ( d->backrubber == 0 ) { + d->backrubber = new TQPixmap( viewport()->rect().size() ); + d->backrubber->fill( viewport(), viewport()->rect().topLeft() ); + // drawAll = true; } + // int oldX = 0, oldY = 0; + // if ( !drawAll && d->scrollTimer ) { + // oldX = contentsX(); + // oldY = contentsY(); + // } ensureVisible( pos.x(), pos.y() ); + // if ( !drawAll && d->scrollTimer && ( oldX != contentsX() || oldY != contentsY() ) ) + // drawAll = true; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); - drawRubber( &p ); - d->dragging = TRUE; + TQRect allRect = oldRubber.normalize(); + if ( changed ) + allRect |= rr.normalize(); + allRect |= d->rubber->normalize(); + TQPoint point = contentsToViewport( allRect.topLeft() ); + allRect = TQRect( point.x(), point.y(), allRect.width(), allRect.height() ); + allRect &= viewport()->rect(); + + d->dragging = FALSE; + + TQPainter p( d->backrubber ); + p.translate( -contentsX(), -contentsY() ); +#if 0 + if ( !drawAll ) { + oldRubber = oldRubber.normalize(); + point = contentsToViewport( oldRubber.topLeft() ); + oldRubber = TQRect( point.x(), point.y(), oldRubber.width(), oldRubber.height() ); + oldRubber &= viewport()->rect(); + + point = contentsToViewport( nr.topLeft() ); + nr = TQRect( point.x(), point.y(), nr.width(), nr.height() ); + nr &= viewport()->rect(); + + TQRegion region; + if ( allRect != nr ) + region = TQRegion(allRect).subtract( TQRegion( nr ) ); + if ( allRect != oldRubber ) + region += TQRegion(allRect).subtract( TQRegion( oldRubber ) ); + + TQMemArray< TQRect > ar = region.rects(); + for ( uint i = 0; i < ar.size(); ++i ) { + ar[i].addCoords( -2, -2, 4, 4 ); + ar[i] = ar[i].normalize(); + + p.setClipRect( ar[i] ); + drawContents( &p, contentsX() + ar[i].left(), contentsY() + ar[i].top(), ar[i].width(), ar[i].height() ); + } + } + else +#endif + { + drawContents( &p, + contentsX() + allRect.left(), contentsY() + allRect.top(), + allRect.width(), allRect.height() ); + } p.end(); + // drawAll = false; + d->dragging = TRUE; + bitBlt( viewport(), allRect.topLeft(), d->backrubber, allRect ); if ( changed ) { emit selectionChanged(); @@ -3412,9 +3450,7 @@ void TQIconView::doAutoScroll() void TQIconView::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) { - if ( d->dragging && d->rubber ) - drawRubber( p ); - + p->save(); TQRect r = TQRect( cx, cy, cw, ch ); TQIconViewPrivate::ItemContainer *c = d->firstContainer; @@ -3488,8 +3524,16 @@ void TQIconView::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) d->currentItem->paintFocus( p, tqcolorGroup() ); } - if ( d->dragging && d->rubber ) - drawRubber( p ); + p->restore(); + if ( d->rubber ) { + p->save(); + p->translate( contentsX(), contentsY() ); + p->setRasterOp( NotROP ); + p->setPen( TQPen( color0, 1 ) ); + p->setBrush( NoBrush ); + drawRubber( p ); + p->restore(); + } } /*! @@ -4388,17 +4432,15 @@ void TQIconView::contentsMousePressEvent( TQMouseEvent *e ) void TQIconView::contentsMousePressEventEx( TQMouseEvent *e ) { if ( d->rubber ) { - TQPainter p; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); + TQRect r( d->rubber->normalize() ); + delete d->rubber; + d->rubber = 0; + + repaintContents( r, FALSE ); + d->dragging = FALSE; - drawRubber( &p ); - d->dragging = FALSE; - p.end(); - delete d->rubber; - d->rubber = 0; + delete d->backrubber; + d->backrubber = 0; if ( d->scrollTimer ) { disconnect( d->scrollTimer, TQT_SIGNAL( timeout() ), this, TQT_SLOT( doAutoScroll() ) ); @@ -4583,21 +4625,17 @@ void TQIconView::contentsMouseReleaseEvent( TQMouseEvent *e ) d->startDragItem = 0; if ( d->rubber ) { - TQPainter p; - p.begin( viewport() ); - p.setRasterOp( TQt::NotROP ); - p.setPen( TQPen( Qt::color0, 1 ) ); - p.setBrush( Qt::NoBrush ); - - drawRubber( &p ); - d->dragging = FALSE; - p.end(); + TQRect r(d->rubber->normalize()); if ( ( d->rubber->topLeft() - d->rubber->bottomRight() ).manhattanLength() > TQApplication::startDragDistance() ) emitClicked = FALSE; delete d->rubber; d->rubber = 0; + repaintContents(r, FALSE); + d->dragging = FALSE; + delete d->backrubber; + d->backrubber = 0; d->currentItem = d->tmpCurrentItem; d->tmpCurrentItem = 0; if ( d->currentItem ) @@ -5365,9 +5403,9 @@ void TQIconView::drawRubber( TQPainter *p ) TQPoint pnt( d->rubber->x(), d->rubber->y() ); pnt = contentsToViewport( pnt ); - tqstyle().tqdrawPrimitive(TQStyle::PE_RubberBand, p, - TQRect(pnt.x(), pnt.y(), d->rubber->width(), d->rubber->height()), - tqcolorGroup(), TQStyle::Style_Default, TQStyleOption(tqcolorGroup().base())); + tqstyle().tqdrawPrimitive( TQStyle::PE_RubberBand, p, + TQRect( pnt.x(), pnt.y(), d->rubber->width(), d->rubber->height() ).normalize(), + tqcolorGroup(), TQStyle::Style_Default, TQStyleOption(tqcolorGroup().base()) ); } /*! diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp new file mode 100644 index 0000000..276085d --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.cpp @@ -0,0 +1,186 @@ +/**************************************************************************** +** $Id: qinputcontextfactory.cpp,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** Implementation of TQInputContextFactory class +** +** Created : 001103 +** +** Copyright (C) 1992-2002 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition licenses may use this +** file in accordance with the TQt Commercial License Agreement provided +** with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "tqinputcontextinterface_p.h" // up here for GCC 2.7.* compatibility +#include "tqinputcontextfactory.h" +#include "tqinputcontext.h" + +#ifndef TQT_NO_IM + +#include "tqapplication.h" + +#ifdef TQT_THREAD_SUPPORT +#include +#endif // TQT_THREAD_SUPPORT + +#include + +#include "tqcleanuphandler.h" +#include +#ifndef TQT_NO_COMPONENT + + +static TQPluginManager *manager = 0; +static TQSingleCleanupHandler< TQPluginManager > cleanup_manager; + +static void create_manager() +{ + if( manager ) // already created + return; + +#ifdef TQT_THREAD_SUPPORT + // protect manager creation + TQMutexLocker locker( qt_global_mutexpool ? + qt_global_mutexpool->get( &manager ) : 0); + + // we check the manager pointer again to make sure that another thread + // has not created the manager before us. + + if ( manager ) // already created + return; +#endif + + manager = new TQPluginManager( IID_TQInputContextFactory, TQApplication::libraryPaths(), "/inputmethods", FALSE ); + + Q_CHECK_PTR( manager ); + cleanup_manager.set( &manager ); +} + +#endif //TQT_NO_COMPONENT + + +/*! + This function generates the input context that has the identifier + name which is in agreement with \a key. \a widget is the client + widget of TQInputContext. \a widget may be null. +*/ +TQInputContext *TQInputContextFactory::create( const TQString& key, TQWidget *widget ) +{ + TQInputContext *ret = 0; + TQString inputcontext = key; +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( inputcontext, &iface ); + + if ( iface ) { + ret = iface->create( inputcontext ); +#ifdef TQ_WS_X11 + if ( ret ) + ret->setHolderWidget( widget ); +#endif + } +#endif + return ret; +} + + +/*! + This function returns the list of the names input methods. + Only input methods included in default and placed under + $TQTDIR/plugins/inputmethods are listed. +*/ +TQStringList TQInputContextFactory::keys() +{ + TQStringList list; +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + list = manager->featureList(); +#endif //TQT_NO_COMPONENT + + return list; +} + + +TQStringList TQInputContextFactory::languages( const TQString &key ) +{ + TQStringList result; +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( key, &iface ); + + if ( iface ) + result = iface->languages( key ); +#endif //TQT_NO_COMPONENT + + return result; +} + + +TQString TQInputContextFactory::displayName( const TQString &key ) +{ + TQString result( "" ); +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( key, &iface ); + + if ( iface ) + result = iface->displayName( key ); +#endif //TQT_NO_COMPONENT + + return result; +} + + +TQString TQInputContextFactory::description( const TQString &key ) +{ + TQString result( "" ); +#ifndef TQT_NO_COMPONENT + // make sure the manager is created + create_manager(); + + TQInterfacePtr iface; + manager->queryInterface( key, &iface ); + + if ( iface ) + result = iface->description( key ); +#endif //TQT_NO_COMPONENT + + return result; +} + +#endif // TQT_NO_IM diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h new file mode 100644 index 0000000..ea97f83 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextfactory.h @@ -0,0 +1,59 @@ +/**************************************************************************** +** $Id: qinputcontextfactory.h,v 1.1.1.1 2004/05/11 11:16:49 daisuke Exp $ +** +** Definition of TQInputContextFactory class +** +** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** 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 TQINPUTCONTEXTFACTORY_H +#define TQINPUTCONTEXTFACTORY_H + +#ifndef TQT_H +#include "tqstringlist.h" +#endif // TQT_H + +#ifndef TQT_NO_IM + +class TQInputContext; +class TQWidget; + +class TQ_EXPORT TQInputContextFactory +{ +public: + static TQStringList keys(); + static TQInputContext *create( const TQString &key, TQWidget *widget ); // should be a toplevel widget + static TQStringList languages( const TQString &key ); + static TQString displayName( const TQString &key ); + static TQString description( const TQString &key ); +}; +#endif //TQT_NO_IM + +#endif //TQINPUTCONTEXTFACTORY_H diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h b/tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h new file mode 100644 index 0000000..be91171 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextinterface_p.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** $Id: qinputcontextinterface_p.h,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** ... +** +** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** 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 TQINPUTCONTEXTINTERFACE_P_H +#define TQINPUTCONTEXTINTERFACE_P_H + +// +// W A R N I N G +// ------------- +// +// This file is not part of the TQt API. This header file may +// change from version to version without notice, or even be +// removed. +// +// We mean it. +// +// + +#ifndef TQT_H +#include +#endif // TQT_H + +#ifndef TQT_NO_IM +#ifndef TQT_NO_COMPONENT + +class TQWidget; +class TQInputContext; + +// old version interface in qt-x11-immodule-bc-qt3.3.2-20040623.diff: +// {6C2B9EDE-B63C-14c9-A729-3C7643739C4C} +// +// new version interface: +// {a5f5c63d-e044-11d8-9718-000d6077a78d} +// {b0bf3e59-e526-11d8-80da-000d6077a78d} +// {9ef05c7f-0272-11d9-846c-000d6077a78d} + +#ifndef IID_TQInputContextFactory +//#define IID_TQInputContextFactory TQUuid(0x6c2b9ede, 0xb63c, 0x14c9, 0xa7, 0x29, 0x3c, 0x76, 0x43, 0x73, 0x9c, 0x4c) +//#define IID_TQInputContextFactory TQUuid(0xa5f5c63d, 0xe044, 0x11d8, 0x97, 0x18, 0x00, 0x0d, 0x60, 0x77, 0xa7, 0x8d) +//#define IID_TQInputContextFactory TQUuid(0xb0bf3e59, 0xe526, 0x11d8, 0x80, 0xda, 0x00, 0x0d, 0x60, 0x77, 0xa7, 0x8d) +#define IID_TQInputContextFactory TQUuid(0x9ef05c7f, 0x0272, 0x11d9, 0x84, 0x6c, 0x00, 0x0d, 0x60, 0x77, 0xa7, 0x8d) +#endif + +struct TQ_EXPORT TQInputContextFactoryInterface : public TQFeatureListInterface +{ + virtual TQInputContext *create( const TQString &key ) = 0; + virtual TQStringList languages( const TQString &key ) = 0; + virtual TQString displayName( const TQString &key ) = 0; + virtual TQString description( const TQString &key ) = 0; +}; + +#endif //TQT_NO_COMPONENT +#endif //TQT_NO_IM + +#endif //TQINPUTCONTEXTINTERFACE_P_H diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp new file mode 100644 index 0000000..d8a728e --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.cpp @@ -0,0 +1,231 @@ +/**************************************************************************** +** $Id: qinputcontextplugin.cpp,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** Implementation of TQInputContextPlugin class +** +** Created : 010920 +** +** Copyright (C) 2001 Trolltech AS. All rights reserved. +** +** This file is part of the widgets module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#include "tqinputcontextplugin.h" + +#ifndef TQT_NO_IM +#ifndef TQT_NO_COMPONENT + +#include "tqinputcontextinterface_p.h" + +/*! + \class TQInputContextPlugin qinputcontextplugin.h + \brief The TQInputContextPlugin class provides an abstract base for custom TQInputContext plugins. + \reentrant + \ingroup plugins + + The input context plugin is a simple plugin interface that makes it + easy to create custom input contexts that can be loaded dynamically + into applications. + + Writing a input context plugin is achieved by subclassing this + base class, reimplementing the pure virtual functions keys(), + create(), languages(), displayName() description() and exporting + the class with the \c TQ_EXPORT_PLUGIN macro. See the \link + plugins-howto.html TQt Plugins documentation \endlink for details. + + \sa TQInputContext +*/ + +/*! + \fn TQStringList TQInputContextPlugin::keys() const + + Returns the list of TQInputContext keys this plugin provides. + + These keys are usually the class names of the custom input context + that are implemented in the plugin. + + Return value is the names to identify and specify input methods + for the input method switching mechanism and so on. The names have + to be consistent with TQInputContext::identifierName(). The names + have to consist of ASCII characters only. See also + TQInputContext::identifierName() for further information. + + \sa create(), displayName(), TQInputContext::identifierName() +*/ + +/*! + \fn TQInputContext* TQInputContextPlugin::create( const TQString& key ) + + Creates and returns a TQInputContext instance for the input context key \a key. + The input context key is usually the class name of the required input method. + + \sa keys() +*/ + +/*! + \fn TQStringList languages( const TQString &key ) + + Returns what languages are supported by the TQInputContext instance + specified by \a key. + + The languages are expressed as language code (e.g. "zh_CN", + "zh_TW", "zh_HK", "ja", "ko", ...). An input context that suports + multiple languages can return all supported languages as + TQStringList. The name has to be consistent with + TQInputContextPlugin::language(). + + This information may be used to optimize user interface. + + \sa TQInputContext::language() +*/ + +/*! + \fn TQString displayName( const TQString &key ) + + Returns a user friendly i18n-ized name of the TQInputContext + instance specified by \a key. This string may be appeared in a + menu and so on for users. + + There are two different names with different responsibility in the + input method domain. This function returns one of them. Another + name is called 'identifier name' to identify and specify input + methods for the input method switching mechanism and so on. + + Although tr( identifierName ) can provide user friendly i18n-ized + name without this function, the message catalog have to be managed + by TQt in the case. However, some sophisticated input method + framework manages their own message catalogs to provide this + i18n-ized name string. So we need this function rather than just + call tr() for identifier name. + + \sa keys(), TQInputContext::identifierName() +*/ + +/*! + \fn TQString description( const TQString &key ) + + Returns a i18n-ized brief description of the TQInputContext + instance specified by \a key. This string may be appeared in some + user interfaces. +*/ + + + +class TQInputContextPluginPrivate : public TQInputContextFactoryInterface +{ +public: + TQInputContextPluginPrivate( TQInputContextPlugin *p ) + : plugin( p ) + { + } + + virtual ~TQInputContextPluginPrivate(); + + TQRESULT queryInterface( const TQUuid &iid, TQUnknownInterface **iface ); + TQ_REFCOUNT; + + TQStringList featureList() const; + TQInputContext *create( const TQString &key ); + TQStringList languages( const TQString &key ); + TQString displayName( const TQString &key ); + TQString description( const TQString &key ); + +private: + TQInputContextPlugin *plugin; +}; + +TQRESULT TQInputContextPluginPrivate::queryInterface( const TQUuid &iid, TQUnknownInterface **iface ) +{ + *iface = 0; + + if ( iid == IID_TQUnknown ) + *iface = this; + else if ( iid == IID_TQFeatureList ) + *iface = this; + else if ( iid == IID_TQInputContextFactory ) + *iface = this; + else + return TQE_NOINTERFACE; + + (*iface)->addRef(); + return TQS_OK; +} + +TQInputContextPluginPrivate::~TQInputContextPluginPrivate() +{ + delete plugin; +} + +TQStringList TQInputContextPluginPrivate::featureList() const +{ + return plugin->keys(); +} + +TQInputContext *TQInputContextPluginPrivate::create( const TQString &key ) +{ + return plugin->create( key ); +} + +TQStringList TQInputContextPluginPrivate::languages( const TQString &key ) +{ + return plugin->languages( key ); +} + +TQString TQInputContextPluginPrivate::displayName( const TQString &key ) +{ + return plugin->displayName( key ); +} + +TQString TQInputContextPluginPrivate::description( const TQString &key ) +{ + return plugin->description( key ); +} + + +/*! + Constructs a input context plugin. This is invoked automatically by the + \c TQ_EXPORT_PLUGIN macro. +*/ +TQInputContextPlugin::TQInputContextPlugin() + : TQGPlugin( d = new TQInputContextPluginPrivate( this ) ) +{ +} + +/*! + Destroys the input context plugin. + + You never have to call this explicitly. TQt destroys a plugin + automatically when it is no longer used. +*/ +TQInputContextPlugin::~TQInputContextPlugin() +{ + // don't delete d, as this is deleted by d +} + +#endif // TQT_NO_COMPONENT +#endif // TQT_NO_IM diff --git a/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h new file mode 100644 index 0000000..3c50cc2 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqinputcontextplugin.h @@ -0,0 +1,67 @@ +/**************************************************************************** +** $Id: qinputcontextplugin.h,v 1.2 2004/06/20 18:43:11 daisuke Exp $ +** +** Definition of TQInputContextPlugin class +** +** Created : 010920 +** +** Copyright (C) 2001 Trolltech AS. All rights reserved. +** +** This file is part of the tools module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** 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 TQINPUTCONTEXTPLUGIN_H +#define TQINPUTCONTEXTPLUGIN_H + +#ifndef TQT_H +#include "tqgplugin.h" +#include "tqstringlist.h" +#endif // TQT_H + +#ifndef TQT_NO_IM +class TQInputContext; +class TQInputContextPluginPrivate; + +class TQ_EXPORT TQInputContextPlugin : public TQGPlugin +{ + TQ_OBJECT +public: + TQInputContextPlugin(); + ~TQInputContextPlugin(); + + virtual TQStringList keys() const = 0; + virtual TQInputContext *create( const TQString &key ) = 0; + virtual TQStringList languages( const TQString &key ) = 0; + virtual TQString displayName( const TQString &key ) = 0; + virtual TQString description( const TQString &key ) = 0; + +private: + TQInputContextPluginPrivate *d; +}; +#endif // TQT_NO_IM +#endif // TQINPUTCONTEXTPLUGIN_H diff --git a/tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri b/tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri new file mode 100644 index 0000000..0d48026 --- /dev/null +++ b/tqtinterface/qt4/src/inputmethod/tqt_inputmethod.pri @@ -0,0 +1,10 @@ +# TQt inputmetod module + +inputmethod { + INPUTMETHOD_P = inputmethod + HEADERS +=$$INPUTMETHOD_H/qinputcontextfactory.h \ + $$INPUTMETHOD_P/qinputcontextinterface_p.h \ + $$INPUTMETHOD_H/qinputcontextplugin.h + SOURCES +=$$INPUTMETHOD_CPP/qinputcontextfactory.cpp \ + $$INPUTMETHOD_CPP/qinputcontextplugin.cpp +} diff --git a/tqtinterface/qt4/src/kernel/qt_kernel.pri b/tqtinterface/qt4/src/kernel/qt_kernel.pri index aa76de0..f10ed74 100644 --- a/tqtinterface/qt4/src/kernel/qt_kernel.pri +++ b/tqtinterface/qt4/src/kernel/qt_kernel.pri @@ -34,7 +34,6 @@ kernel { $$KERNEL_H/tqimage.h \ $$KERNEL_P/tqimageformatinterface_p.h \ $$KERNEL_H/tqimageformatplugin.h \ - $$KERNEL_P/tqinputcontext_p.h \ $$KERNEL_H/tqkeycode.h \ $$KERNEL_H/tqkeysequence.h \ $$KERNEL_H/tqlayout.h \ @@ -99,6 +98,12 @@ kernel { $$KERNEL_CPP/tqfontengine_p.h \ $$KERNEL_CPP/tqtextlayout_p.h + unix:x11 { + HEADERS += $$KERNEL_H/tqinputcontext.h + } else { + HEADERS += $$KERNEL_P/tqinputcontext_p.h + } + win32:SOURCES += $$KERNEL_CPP/tqapplication_win.cpp \ $$KERNEL_CPP/tqclipboard_win.cpp \ $$KERNEL_CPP/tqcolor_win.cpp \ @@ -130,6 +135,7 @@ kernel { $$KERNEL_CPP/tqdesktopwidget_x11.cpp \ $$KERNEL_CPP/tqeventloop_x11.cpp \ $$KERNEL_CPP/tqfont_x11.cpp \ + $$KERNEL_CPP/tqinputcontext.cpp \ $$KERNEL_CPP/tqinputcontext_x11.cpp \ $$KERNEL_CPP/tqmotifdnd_x11.cpp \ $$KERNEL_CPP/tqpixmap_x11.cpp \ diff --git a/tqtinterface/qt4/src/kernel/tqapplication.cpp b/tqtinterface/qt4/src/kernel/tqapplication.cpp index af193c9..74d2f08 100644 --- a/tqtinterface/qt4/src/kernel/tqapplication.cpp +++ b/tqtinterface/qt4/src/kernel/tqapplication.cpp @@ -4113,6 +4113,35 @@ void TQApplication::postEvent( TQObject *receiver, TQEvent *event ) }; } +#if !defined(TQT_NO_IM) + // if this is one of the compressible IM events, do compression + else if ( event->type() == TQEvent::IMCompose ) { + l->last(); + TQPostEvent * cur = 0; + for ( ;; ) { + while ( (cur=l->current()) != 0 && + ( cur->receiver != receiver || + cur->event == 0 || + cur->event->type() != event->type() || + cur->event->type() != TQEvent::IMStart ) ) + l->prev(); + if ( l->current() != 0 ) { + // IMCompose must not be compressed with another one + // beyond its IMStart boundary + if ( cur->event->type() == TQEvent::IMStart ) { + break; + } else if ( cur->event->type() == TQEvent::IMCompose ) { + TQIMComposeEvent * e = (TQIMComposeEvent *)(cur->event); + *e = *(TQIMComposeEvent *)event; + delete event; + return; + } + } + break; + }; + } +#endif + // if no compression could be done, just append something event->posted = TRUE; TQPostEvent * pe = new TQPostEvent( receiver, event ); @@ -4258,6 +4287,23 @@ void TQApplication::sendPostedEvents( TQObject *receiver, int event_type ) */ void TQApplication::removePostedEvents( TQObject *receiver ) +{ + removePostedEvents( receiver, 0 ); +} + +/*! + Removes all events that have the event type \a event_type posted + using postEvent() for \a receiver. + + The events are \e not dispatched, instead they are removed from the + queue. + + If \a event_type is 0, all the events are removed from the queue. + + \threadsafe +*/ + +void TQApplication::removePostedEvents( TQObject *receiver, int event_type ) { if ( !receiver ) return; @@ -4277,18 +4323,24 @@ void TQApplication::removePostedEvents( TQObject *receiver ) // leave the TQPostEvent objects; they'll be deleted by // sendPostedEvents(). TQPostEventList * l = receiver->postedEvents; - receiver->postedEvents = 0; l->first(); TQPostEvent * pe; while( (pe=l->current()) != 0 ) { - if ( pe->event ) { - pe->event->posted = FALSE; - delete pe->event; - pe->event = 0; + if ( !event_type || pe->event->type() == event_type ) { + if ( pe->event ) { + pe->event->posted = FALSE; + delete pe->event; + pe->event = 0; + } + l->remove(); + } else { + l->next(); } - l->remove(); } - delete l; + if ( !event_type || !l->count() ) { + receiver->postedEvents = 0; + delete l; + } } @@ -4473,6 +4525,8 @@ void TQApplication::setActiveWindow( TQWidget* act ) focus_widget = 0; #ifdef TQ_WS_WIN TQInputContext::accept( tmp ); +#elif defined(TQ_WS_X11) + tmp->unfocusInputContext(); #endif TQApplication::sendSpontaneousEvent( tmp, &out ); } else if ( active_window ) { diff --git a/tqtinterface/qt4/src/kernel/tqapplication.h b/tqtinterface/qt4/src/kernel/tqapplication.h index 2be7c02..e5e2ea9 100644 --- a/tqtinterface/qt4/src/kernel/tqapplication.h +++ b/tqtinterface/qt4/src/kernel/tqapplication.h @@ -67,6 +67,9 @@ class TQSessionManager; class TQStyle; class TQTranslator; class TQEventLoop; +#if defined(TQ_WS_X11) +class TQIMEvent; +#endif #if defined(TQ_WS_TQWS) class TQWSDecoration; #endif @@ -467,8 +470,19 @@ public: virtual void saveState( TQSessionManager& sm ); #endif #if defined(TQ_WS_X11) +#if !defined(TQT_NO_IM_EXTENSIONS) + virtual TQWidget *locateICHolderWidget( TQWidget *w ); + virtual TQWidgetList *icHolderWidgets(); + static void create_im(); + static void close_im(); +#else + TQWidget *locateICHolderWidget( TQWidget *w ); + TQWidgetList *icHolderWidgets(); static void create_xim(); static void close_xim(); +#endif + static TQString defaultInputMethod(); + void changeAllInputContext( const TQString & ); static bool x11_apply_settings(); #endif void wakeUpGuiThread(); @@ -523,6 +537,12 @@ private: friend void qt_init(int *, char **, TQApplication::Type); #endif +#if defined(TQ_WS_X11) +private slots: + void postIMEvent( TQObject *receiver, TQIMEvent *event ); +#endif + +private: #ifdef TQT_THREAD_SUPPORT static TQMutex *qt_mutex; #endif // TQT_THREAD_SUPPORT @@ -572,9 +592,12 @@ private: static TQString* session_key; bool is_session_restored; #endif -#if defined(TQ_WS_X11) && !defined (TQT_NO_STYLE ) +#if defined(TQ_WS_X11) +#if !defined (TQT_NO_STYLE) static void x11_initialize_style(); #endif + static TQString defaultIM; // default input method's name in this application. +#endif static TQSize app_strut; #ifndef TQT_NO_COMPONENT @@ -591,6 +614,7 @@ private: static bool sendSpontaneousEvent( TQObject *receiver, TQEvent *event ); static void removePostedEvent( TQEvent * ); + static void removePostedEvents( TQObject *receiver, int event_type ); friend class TQWidget; friend class TQETWidget; diff --git a/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp b/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp index 48616bf..e7cf92f 100644 --- a/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqapplication_x11.cpp @@ -92,7 +92,9 @@ #include "tqfileinfo.h" // Input method stuff - UNFINISHED -#include "tqinputcontext_p.h" +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#endif // TQT_NO_IM #include "tqinternal_p.h" // shared double buffer cleanup #if defined(TQT_THREAD_SUPPORT) @@ -114,6 +116,7 @@ extern "C" Bool XftInitFtLibrary(void); #include #include #include +#include //#define X_NOT_BROKEN #ifdef X_NOT_BROKEN @@ -271,10 +274,16 @@ Atom qt_net_wm_window_type_menu = 0; Atom qt_net_wm_window_type_utility = 0; Atom qt_net_wm_window_type_splash = 0; Atom qt_net_wm_window_type_override = 0; // KDE extension +Atom qt_net_wm_window_type_dropdown_menu = 0; +Atom qt_net_wm_window_type_popup_menu = 0; +Atom qt_net_wm_window_type_tooltip = 0; +Atom qt_net_wm_window_type_combo = 0; +Atom qt_net_wm_window_type_dnd = 0; Atom qt_net_wm_frame_strut = 0; // KDE extension Atom qt_net_wm_state_stays_on_top = 0; // KDE extension Atom qt_net_wm_pid = 0; Atom qt_net_wm_user_time = 0; +Atom qt_net_wm_full_placement = 0; // KDE extension // Enlightenment support Atom qt_enlightenment_desktop = 0; @@ -284,6 +293,11 @@ Atom *qt_net_supported_list = 0; Window *qt_net_virtual_root_list = 0; +// X11 SYNC support +#ifndef TQT_NO_XSYNC +Atom qt_net_wm_sync_request_counter = 0; +Atom qt_net_wm_sync_request = 0; +#endif // client leader window Window qt_x11_wm_client_leader = 0; @@ -308,6 +322,13 @@ static int xrandr_eventbase; // Display TQ_EXPORT bool qt_use_xrender = FALSE; +#ifndef TQT_NO_XSYNC +// True if SYNC extension exists on the connected display +bool qt_use_xsync = FALSE; +static int xsync_eventbase; +static int xsync_errorbase; +#endif + // modifier masks for alt/meta - detected when the application starts static long qt_alt_mask = 0; static long qt_meta_mask = 0; @@ -1709,17 +1730,28 @@ void qt_init_internal( int *argcptr, char **argv, qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_UTILITY", &qt_net_wm_window_type_utility ); qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_SPLASH", &qt_net_wm_window_type_splash ); qt_x11_intern_atom( "_KDE_NET_WM_WINDOW_TYPE_OVERRIDE", &qt_net_wm_window_type_override ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_DROPDOWN_MENU", &qt_net_wm_window_type_dropdown_menu ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_POPUP_MENU", &qt_net_wm_window_type_popup_menu ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_TOOLTIP", &qt_net_wm_window_type_tooltip ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_COMBO", &qt_net_wm_window_type_combo ); + qt_x11_intern_atom( "_NET_WM_WINDOW_TYPE_DND", &qt_net_wm_window_type_dnd ); qt_x11_intern_atom( "_KDE_NET_WM_FRAME_STRUT", &qt_net_wm_frame_strut ); qt_x11_intern_atom( "_NET_WM_STATE_STAYS_ON_TOP", &qt_net_wm_state_stays_on_top ); qt_x11_intern_atom( "_NET_WM_PID", &qt_net_wm_pid ); qt_x11_intern_atom( "_NET_WM_USER_TIME", &qt_net_wm_user_time ); + qt_x11_intern_atom( "_NET_WM_FULL_PLACEMENT", &qt_net_wm_full_placement ); qt_x11_intern_atom( "ENLIGHTENMENT_DESKTOP", &qt_enlightenment_desktop ); qt_x11_intern_atom( "_NET_WM_NAME", &qt_net_wm_name ); qt_x11_intern_atom( "_NET_WM_ICON_NAME", &qt_net_wm_icon_name ); qt_x11_intern_atom( "UTF8_STRING", &qt_utf8_string ); qt_x11_intern_atom( "_SGI_DESKS_MANAGER", &qt_sgi_desks_manager ); +#ifndef TQT_NO_XSYNC + qt_x11_intern_atom( "_NET_WM_SYNC_REQUEST_COUNTER", &qt_net_wm_sync_request_counter ); + qt_x11_intern_atom( "_NET_WM_SYNC_REQUEST", &qt_net_wm_sync_request ); +#endif + qt_xdnd_setup(); qt_x11_motifdnd_init(); @@ -1756,6 +1788,15 @@ void qt_init_internal( int *argcptr, char **argv, } #endif // TQT_NO_XRENDER +#ifndef TQT_NO_XSYNC + // Try to initialize SYNC extension on the connected display + int xsync_major, xsync_minor; + if ( XSyncQueryExtension( appDpy, &xsync_eventbase, &xsync_errorbase ) && + XSyncInitialize( appDpy, &xsync_major, &xsync_minor ) ) { + qt_use_xsync = TRUE; + } +#endif + #ifndef TQT_NO_XKB // If XKB is detected, set the GrabsUseXKBState option so input method // compositions continue to work (ie. deadkeys) @@ -2731,10 +2772,9 @@ static const char *appBTNCol = 0; // application btn color static const char *mwGeometry = 0; // main widget tqgeometry static const char *mwTitle = 0; // main widget title //Ming-Che 10/10 -static char *ximServer = 0; // XIM Server will connect to +char *qt_ximServer = 0; // XIM Server will connect to static bool mwIconic = FALSE; // main widget iconified //Ming-Che 10/10 -static bool noxim = FALSE; // connect to xim or not static Display *appDpy = 0; // X11 application display static char *appDpyName = 0; // X11 display name static bool appForeignDpy = FALSE; // we didn't create display @@ -2933,14 +2973,14 @@ static bool qt_x11EventFilter( XEvent* ev ) #if !defined(TQT_NO_XIM) -XIM qt_xim = 0; +//XIM qt_xim = 0; XIMStyle qt_xim_style = 0; +XIMStyle qt_xim_preferred_style = 0; static XIMStyle xim_default_style = XIMPreeditCallbacks | XIMStatusNothing; -static XIMStyle xim_preferred_style = 0; #endif -static int composingKeycode=0; -static TQTextCodec * input_mapper = 0; +int qt_ximComposingKeycode=0; +TQTextCodec * qt_input_mapper = 0; extern bool qt_check_clipboard_sentinel(); //def in qclipboard_x11.cpp extern bool qt_check_selection_sentinel(); //def in qclipboard_x11.cpp @@ -3051,8 +3091,7 @@ public: void setWFlags( WFlags f ) { TQWidget::setWFlags(f); } void clearWFlags( WFlags f ) { TQWidget::clearWFlags(f); } bool translateMouseEvent( const XEvent * ); - bool translateKeyEventInternal( const XEvent *, int& count, TQString& text, int& state, char& ascii, int &code, - TQEvent::Type &type, bool willRepeat=FALSE ); + bool translateKeyEventInternal( const XEvent *, int& count, TQString& text, int& state, char& ascii, int &code, TQEvent::Type &type, bool willRepeat=FALSE, bool statefulTranslation=TRUE ); bool translateKeyEvent( const XEvent *, bool grab ); bool translatePaintEvent( const XEvent * ); bool translateConfigEvent( const XEvent * ); @@ -3069,114 +3108,120 @@ public: // ************************************************************************ -// X Input Method support +// Input Method support // ************************************************************************ -#if !defined(TQT_NO_XIM) +/*! + An identifier name of the default input method. +*/ +TQString TQApplication::defaultIM = "imsw-multi"; -#if defined(TQ_C_CALLBACKS) -extern "C" { -#endif // TQ_C_CALLBACKS -#ifdef USE_X11R6_XIM - static void xim_create_callback(XIM /*im*/, - XPointer /*client_data*/, - XPointer /*call_data*/) - { - // qDebug("xim_create_callback"); - TQApplication::create_xim(); - } +/*! + This function handles the query about location of the widget + holding the TQInputContext instance for widget \a w. - static void xim_destroy_callback(XIM /*im*/, - XPointer /*client_data*/, - XPointer /*call_data*/) - { - // qDebug("xim_destroy_callback"); - TQApplication::close_xim(); - XRegisterIMInstantiateCallback(appDpy, 0, 0, 0, - (XIMProc) xim_create_callback, 0); - } + The input context is used for text input to widget \a w. By + default, it returns the top-level widget of \a w. -#endif // USE_X11R6_XIM + If you want to change the mapping of widget \w to TQInputContext + instance, reimplement both this function and + TQApplication::icHolderWidgets(). For example, suppose a tabbed web + browser. The browser should allocate a input context per tab + widget because users may switch the tabs and input a new text + during previous input contexts live. -#if defined(TQ_C_CALLBACKS) + See also 'Sharing input context between text widgets' and 'Preedit + preservation' section of the class description of TQInputContext. + + \sa TQInputContext, icHolderWidgets() +*/ +TQWidget *TQApplication::locateICHolderWidget( TQWidget *w ) +{ + return w->tqtopLevelWidget(); } -#endif // TQ_C_CALLBACKS -#endif // TQT_NO_XIM +/*! + This function returns all widgets holding TQInputContext. -/*! \internal - Creates the application input method. - */ -void TQApplication::create_xim() + By default, This function returns top-level widgets. So if you + want to change the mapping of a widget to TQInputContext instance, + you must override this function and locateICHolderWidget(). + + \sa locateICHolderWidget() +*/ +TQWidgetList *TQApplication::icHolderWidgets() { -#ifndef TQT_NO_XIM - qt_xim = XOpenIM( appDpy, 0, 0, 0 ); - if ( qt_xim ) { + return TQApplication::tqtopLevelWidgets(); +} -#ifdef USE_X11R6_XIM - XIMCallback destroy; - destroy.callback = (XIMProc) xim_destroy_callback; - destroy.client_data = 0; - if ( XSetIMValues( qt_xim, XNDestroyCallback, &destroy, (char *) 0 ) != 0 ) - qWarning( "Xlib dosn't support destroy callback"); -#endif // USE_X11R6_XIM - XIMStyles *styles = 0; - XGetIMValues(qt_xim, XNQueryInputStyle, &styles, (char *) 0, (char *) 0); - if ( styles ) { - int i; - for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { - if ( styles->supported_styles[i] == xim_preferred_style ) { - qt_xim_style = xim_preferred_style; - break; - } - } - // if the preferred input style couldn't be found, look for - // Nothing - for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { - if ( styles->supported_styles[i] == (XIMPreeditNothing | - XIMStatusNothing) ) { - qt_xim_style = XIMPreeditNothing | XIMStatusNothing; - break; - } - } - // ... and failing that, None. - for ( i = 0; !qt_xim_style && i < styles->count_styles; i++ ) { - if ( styles->supported_styles[i] == (XIMPreeditNone | - XIMStatusNone) ) { - qt_xim_style = XIMPreeditNone | XIMStatusNone; - break; - } - } +/*! + This function replaces all TQInputContext instances in the + application. The function's argument is the identifier name of + the newly selected input method. +*/ +void TQApplication::changeAllInputContext( const TQString &identifierName ) +{ + TQWidgetList *list = tqApp->icHolderWidgets(); + TQWidgetListIt it(*list); + while(it.current()) { + it.current()->changeInputContext( identifierName ); + ++it; + } + delete list; - // qDebug("TQApplication: using im style %lx", qt_xim_style); - XFree( (char *)styles ); - } + // defaultIM = identifierName ; // Change of defaultIM -- default input method -- may be enabled. +} - if ( qt_xim_style ) { -#ifdef USE_X11R6_XIM - XUnregisterIMInstantiateCallback(appDpy, 0, 0, 0, - (XIMProc) xim_create_callback, 0); -#endif // USE_X11R6_XIM +/*! + \internal + This is an internal function, you should never call this. - TQWidgetList *list= tqApp->tqtopLevelWidgets(); - TQWidgetListIt it(*list); - TQWidget * w; - while( (w=it.current()) != 0 ) { - ++it; - w->createTLSysExtra(); - } - delete list; - } else { - // Give up - qWarning( "No supported input style found." - " See InputMethod documentation."); - close_xim(); - } + \sa TQInputContext::imEventGenerated() +*/ +void TQApplication::postIMEvent( TQObject *receiver, TQIMEvent *event ) +{ + if ( event->type() == TQEvent::IMCompose ) { + // enable event compression to reduce preedit flicker on fast + // typing + postEvent( receiver, event ); + } else { + // cancel queued preedit update + if ( event->type() == TQEvent::IMEnd ) + removePostedEvents( receiver, TQEvent::IMCompose ); + + // to avoid event receiving order inversion between TQKeyEvent + // and TQIMEvent, we must send IMStart and IMEnd via + // sendEvent(). + sendEvent( receiver, event ); + delete event; } +} + + +/*! + This function returns the identifier name of the default input + method in this Application. The value is identical to the value of + TQApplication::defaultIM. +*/ +TQString TQApplication::defaultInputMethod() +{ + return TQApplication::defaultIM; +} + + +#if !defined(TQT_NO_IM_EXTENSIONS) +/*! \internal + Creates the application input method. +*/ +void TQApplication::create_im() +{ +#ifndef TQT_NO_XIM + if ( ! qt_xim_preferred_style ) // no configured input style, use the default + qt_xim_preferred_style = xim_default_style; #endif // TQT_NO_XIM } @@ -3184,6 +3229,43 @@ void TQApplication::create_xim() /*! \internal Closes the application input method. */ +void TQApplication::close_im() +{ + TQWidgetList *list = tqApp->icHolderWidgets(); + TQWidgetListIt it(*list); + while(it.current()) { + it.current()->destroyInputContext(); + ++it; + } + delete list; +} + +#else + +/*! \internal + Creates the application input method. +*/ +void TQApplication::create_xim() +{ +#ifndef TQT_NO_XIM + if ( ! qt_xim_preferred_style ) // no configured input style, use the default + qt_xim_preferred_style = xim_default_style; +#endif // TQT_NO_XIM + + TQWidgetList *list= tqApp->tqtopLevelWidgets(); + TQWidgetListIt it(*list); + TQWidget * w; + while( (w=it.current()) != 0 ) { + ++it; + w->createTLSysExtra(); + } + delete list; +} + + + /*! \internal + Closes the application input method. + */ void TQApplication::close_xim() { #ifndef TQT_NO_XIM @@ -3191,7 +3273,10 @@ void TQApplication::close_xim() // XCloseIM( qt_xim ); // We prefer a less serious memory leak - qt_xim = 0; + // if ( qt_xim ) + // qt_xim = 0; + +#endif // TQT_NO_XIM TQWidgetList *list = tqApp->tqtopLevelWidgets(); TQWidgetListIt it(*list); while(it.current()) { @@ -3199,9 +3284,8 @@ void TQApplication::close_xim() ++it; } delete list; -#endif // TQT_NO_XIM } - +#endif /***************************************************************************** Default X error handlers @@ -3572,18 +3656,40 @@ bool TQApplication::x11_apply_settings() settings.readBoolEntry("/qt/useRtlExtensions", FALSE); #ifndef TQT_NO_XIM - if (xim_preferred_style == 0) { + if (qt_xim_preferred_style == 0) { TQString ximInputStyle = settings.readEntry( "/qt/XIMInputStyle", TQObject::trUtf8( "On The Spot" ) ).lower(); if ( ximInputStyle == "on the spot" ) - xim_preferred_style = XIMPreeditCallbacks | XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditCallbacks | XIMStatusNothing; else if ( ximInputStyle == "over the spot" ) - xim_preferred_style = XIMPreeditPosition | XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditPosition | XIMStatusNothing; else if ( ximInputStyle == "off the spot" ) - xim_preferred_style = XIMPreeditArea | XIMStatusArea; + qt_xim_preferred_style = XIMPreeditArea | XIMStatusArea; else if ( ximInputStyle == "root" ) - xim_preferred_style = XIMPreeditNothing | XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditNothing | XIMStatusNothing; + } +#endif + +#ifndef TQT_NO_IM + /* + The identifier name of an input method is acquired from the + configuration file as a default. If a environment variable + "TQT_IM_SWITCHER" is not empty it will overwrite the + configuration file. The "imsw-multi" becomes the default if the entry + is not configured. + */ + if ( getenv( "TQT_IM_SWITCHER" ) ) + defaultIM = getenv( "TQT_IM_SWITCHER" ); +#ifndef TQT_NO_IM_EXTENSIONS + else + defaultIM = settings.readEntry( "/qt/DefaultInputMethodSwitcher", "imsw-multi" ); +#endif + + // defaultIM is restricted to be an IM-switcher. An IM-switcher + // has a 'imsw-' prefix + if ( ! defaultIM.startsWith( "imsw-" ) ) { + defaultIM = "imsw-multi"; } #endif @@ -3619,19 +3725,19 @@ static void qt_set_input_encoding() // Always use the locale codec, since we have no examples of non-local // XIMs, and since we cannot get a sensible answer about the encoding // from the XIM. - input_mapper = TQTextCodec::codecForLocale(); + qt_input_mapper = TQTextCodec::codecForLocale(); } else { if ( !qstricmp( data, "locale" ) ) - input_mapper = TQTextCodec::codecForLocale(); + qt_input_mapper = TQTextCodec::codecForLocale(); else - input_mapper = TQTextCodec::codecForName( data ); + qt_input_mapper = TQTextCodec::codecForName( data ); // make sure we have an input codec - if( !input_mapper ) - input_mapper = TQTextCodec::codecForName( "ISO 8859-1" ); + if( !qt_input_mapper ) + qt_input_mapper = TQTextCodec::codecForName( "ISO 8859-1" ); } - if ( input_mapper->mibEnum() == 11 ) // 8859-8 - input_mapper = TQTextCodec::codecForName( "ISO 8859-8-I"); + if ( qt_input_mapper->mibEnum() == 11 ) // 8859-8 + qt_input_mapper = TQTextCodec::codecForName( "ISO 8859-8-I"); if( data ) XFree( (char *)data ); } @@ -4071,6 +4177,8 @@ static Visual *tqfind_truecolor_visual( Display *dpy, int scr, int *depth, int * #define XK_MISCELLANY #define XK_LATIN1 +#define XK_KOREAN +#define XK_XKB_KEYS #include // ### This should be static but it isn't because of the friend declaration @@ -4161,10 +4269,7 @@ void qt_init_internal( int *argcptr, char **argv, //Ming-Che 10/10 } else if ( arg == "-im" ) { if ( ++i < argc ) - ximServer = argv[i]; - } else if ( arg == "-noxim" ) { - noxim=TRUE; - // + qt_ximServer = argv[i]; } else if ( arg == "-iconic" ) { mwIconic = !mwIconic; } else if ( arg == "-ncols" ) { // xv and netscape use this name @@ -4184,17 +4289,17 @@ void qt_init_internal( int *argcptr, char **argv, if ( ++i < argc ) { TQCString s = TQCString(argv[i]).lower(); if ( s == "onthespot" ) - xim_preferred_style = XIMPreeditCallbacks | - XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditCallbacks | + XIMStatusNothing; else if ( s == "overthespot" ) - xim_preferred_style = XIMPreeditPosition | - XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditPosition | + XIMStatusNothing; else if ( s == "offthespot" ) - xim_preferred_style = XIMPreeditArea | - XIMStatusArea; + qt_xim_preferred_style = XIMPreeditArea | + XIMStatusArea; else if ( s == "root" ) - xim_preferred_style = XIMPreeditNothing | - XIMStatusNothing; + qt_xim_preferred_style = XIMPreeditNothing | + XIMStatusNothing; } #endif } else if ( arg == "-cmap" ) { // xv uses this name @@ -4642,34 +4747,13 @@ void qt_init_internal( int *argcptr, char **argv, TQApplication::setFont( f ); } -#ifndef TQT_NO_XIM - if ( ! xim_preferred_style ) // no configured input style, use the default - xim_preferred_style = xim_default_style; - - qt_xim = 0; - TQString ximServerName(ximServer); - if (ximServer) - ximServerName.prepend("@im="); - else - ximServerName = ""; - - if ( !XSupportsLocale() ) - qWarning("TQt: Locales not supported on X server"); - -#ifdef USE_X11R6_XIM - else if ( XSetLocaleModifiers (ximServerName.ascii()) == 0 ) - qWarning( "TQt: Cannot set locale modifiers: %s", - ximServerName.ascii()); - else if (! noxim) - XRegisterIMInstantiateCallback(appDpy, 0, 0, 0, - (XIMProc) xim_create_callback, 0); -#else // !USE_X11R6_XIM - else if ( XSetLocaleModifiers ("") == 0 ) - qWarning("TQt: Cannot set locale modifiers"); - else if (! noxim) - TQApplication::create_xim(); -#endif // USE_X11R6_XIM -#endif // TQT_NO_XIM +#if !defined(TQT_NO_IM) +#if !defined(TQT_NO_IM_EXTENSIONS) + TQApplication::create_im(); +#else + TQApplication::create_xim(); +#endif +#endif #if defined (TQT_TABLET_SUPPORT) int ndev, @@ -4918,9 +5002,12 @@ void qt_cleanup() XCloseDevice( appDpy, devEraser ); #endif -#if !defined(TQT_NO_XIM) - if ( qt_xim ) - TQApplication::close_xim(); +#if !defined(TQT_NO_IM) +#if !defined(TQT_NO_IM_EXTENSIONS) + TQApplication::close_im(); +#else + TQApplication::close_xim(); +#endif #endif if ( qt_is_gui_used ) { @@ -5673,6 +5760,10 @@ int TQApplication::x11ClientMessage(TQWidget* w, XEvent* event, bool passive_onl XSendEvent( event->xclient.display, event->xclient.window, False, SubstructureNotifyMask|SubstructureRedirectMask, event ); } +#ifndef TQT_NO_XSYNC + } else if (a == qt_net_wm_sync_request ) { + widget->handleSyncRequest( event ); +#endif } } else if ( event->xclient.message_type == qt_qt_scrolldone ) { widget->translateScrollDoneEvent(event); @@ -5779,77 +5870,59 @@ int TQApplication::x11ProcessEvent( XEvent* event ) } } - int xkey_keycode = event->xkey.keycode; - if ( XFilterEvent( event, - keywidget ? keywidget->tqtopLevelWidget()->winId() : None ) ) { - if ( keywidget ) - composingKeycode = xkey_keycode; // ### not documented in xlib +#ifndef TQT_NO_IM + // Filtering input events by the input context. It has to be taken + // place before any other key event consumers such as eventfilters + // and accelerators because some input methods require quite + // various key combination and sequences. It often conflicts with + // accelerators and so on, so we must give the input context the + // filtering opportunity first to ensure all input methods work + // properly regardless of application design. -#ifndef TQT_NO_XIM - if ( event->type != XKeyPress || ! (qt_xim_style & XIMPreeditCallbacks) ) - return 1; - - /* - * The Solaris htt input method will transform a ClientMessage - * event into a filtered KeyPress event, in which case our - * keywidget is still zero. - */ - if ( ! keywidget ) { - keywidget = (TQETWidget*)TQWidget::keyboardGrabber(); - if ( keywidget ) { - grabbed = TRUE; - } else { - if ( focus_widget ) - keywidget = (TQETWidget*)focus_widget; - if ( !keywidget ) { - if ( inPopupMode() ) // no focus widget, see if we have a popup - keywidget = (TQETWidget*) activePopupWidget(); - else if ( widget ) - keywidget = (TQETWidget*)widget->tqtopLevelWidget(); - } - } - } - - /* - if the composition string has been emptied, we need to send - an IMEnd event. however, we have no way to tell if the user - has cancelled input, or if the user has accepted the - composition. - - so, we have to look for the next keypress and see if it is - the 'commit' key press (keycode == 0). if it is, we deliver - an IMEnd event with the final text, otherwise we deliver an - IMEnd with empty text (meaning the user has cancelled the - input). - */ - TQInputContext *qic = - (TQInputContext *) keywidget->tqtopLevelWidget()->topData()->xic; - extern bool qt_compose_emptied; // qinputcontext_x11.cpp - if ( qic && qic->composing && qic->tqfocusWidget && qt_compose_emptied ) { - XEvent event2; - bool found = FALSE; - if ( XCheckTypedEvent( TQPaintDevice::x11AppDisplay(), - XKeyPress, &event2 ) ) { - if ( event2.xkey.keycode == 0 ) { - // found a key event with the 'commit' string - found = TRUE; - XPutBackEvent( TQPaintDevice::x11AppDisplay(), &event2 ); - } - } - - if ( !found ) { - // no key event, so the user must have cancelled the composition - TQIMEvent endevent( TQEvent::IMEnd, TQString::null, -1 ); - TQApplication::sendEvent( qic->tqfocusWidget, &endevent ); +// #ifndef TQT_NO_IM_EXTENSIONS + if( keywidget && keywidget->isEnabled() && keywidget->isInputMethodEnabled() ) { +// #else +// if( keywidget && keywidget->isEnabled() ) { +// #endif + if( ( event->type==XKeyPress || event->type==XKeyRelease ) && + sm_blockUserInput ) // block user interaction during session management + return TRUE; - qic->tqfocusWidget = 0; - } + // for XIM handling + TQInputContext *qic = keywidget->getInputContext(); + if( qic && qic->x11FilterEvent( keywidget, event ) ) + return TRUE; - qt_compose_emptied = FALSE; + // filterEvent() accepts TQEvent *event rather than preexpanded key + // event attribute values. This is intended to pass other IM-related + // events in future. The IM-related events are supposed as + // TQWheelEvent, TQTabletEvent and so on. Other non IM-related events + // should not be forwarded to input contexts to prevent weird event + // handling. + if ( ( event->type == XKeyPress || event->type == XKeyRelease ) ) { + int code = -1; + int count = 0; + int state; + char ascii = 0; + TQEvent::Type type; + TQString text; + + keywidget->translateKeyEventInternal( event, count, text, + state, ascii, code, type, + FALSE, FALSE ); + + // both key press/release is required for some complex + // input methods. don't eliminate anything. + TQKeyEvent keyevent( type, code, ascii, state, text, FALSE, count ); + + if( qic && qic->filterEvent( &keyevent ) ) + return TRUE; } -#endif // TQT_NO_XIM - - return 1; + } else +#endif // TQT_NO_IM + { + if ( XFilterEvent( event, None ) ) + return TRUE; } if ( qt_x11EventFilter(event) ) // send through app filter @@ -5946,7 +6019,8 @@ int TQApplication::x11ProcessEvent( XEvent* event ) #endif #ifndef TQT_NO_XRANDR - if (event->type == xrandr_eventbase + RRScreenChangeNotify) { + if (event->type == xrandr_eventbase + RRScreenChangeNotify + || ( event->type == ConfigureNotify && event->xconfigure.window == TQPaintDevice::x11AppRootWindow())) { // update Xlib internals with the latest screen configuration XRRUpdateConfiguration(event); @@ -6000,34 +6074,8 @@ int TQApplication::x11ProcessEvent( XEvent* event ) case XKeyRelease: { if ( keywidget && keywidget->isEnabled() ) { // should always exist -#ifndef TQT_NO_XIM - TQInputContext *qic = - (TQInputContext *) keywidget->tqtopLevelWidget()->topData()->xic; - - if ((qt_xim_style & XIMPreeditCallbacks) && event->xkey.keycode == 0 && - qic && qic->composing && qic->tqfocusWidget) { - // input method has sent us a commit string - TQCString data(513); - KeySym sym; // unused - Status status; // unused - TQString text; - int count = qic->lookupString( &(event->xkey), data, - &sym, &status ); - if ( count > 0 ) - text = input_mapper->toUnicode( data, count ); - - // qDebug( "sending IMEnd with %d chars", text.length() ); - TQIMEvent endevent( TQEvent::IMEnd, text, -1 ); - TQApplication::sendEvent( qic->tqfocusWidget, &endevent ); - - qic->tqfocusWidget = 0; - qic->text = TQString::null; - } else -#endif // !TQT_NO_XIM - { - // qDebug( "sending key event" ); - keywidget->translateKeyEvent( event, grabbed ); - } + // qDebug( "sending key event" ); + keywidget->translateKeyEvent( event, grabbed ); } break; } @@ -6514,7 +6562,7 @@ void TQApplication::closePopup( TQWidget *popup ) // Keyboard event translation // -static int translateButtonState( int s ) +int qt_x11_translateButtonState( int s ) { int bst = 0; if ( s & Button1Mask ) @@ -6580,7 +6628,7 @@ bool TQETWidget::translateMouseEvent( const XEvent *event ) pos.ry() = lastMotion.y; globalPos.rx() = lastMotion.x_root; globalPos.ry() = lastMotion.y_root; - state = translateButtonState( lastMotion.state ); + state = qt_x11_translateButtonState( lastMotion.state ); if ( qt_button_down && (state & (LeftButton | MidButton | RightButton ) ) == 0 ) @@ -6604,7 +6652,7 @@ bool TQETWidget::translateMouseEvent( const XEvent *event ) pos.ry() = xevent->xcrossing.y; globalPos.rx() = xevent->xcrossing.x_root; globalPos.ry() = xevent->xcrossing.y_root; - state = translateButtonState( xevent->xcrossing.state ); + state = qt_x11_translateButtonState( xevent->xcrossing.state ); if ( qt_button_down && (state & (LeftButton | MidButton | RightButton ) ) == 0 ) @@ -6616,7 +6664,7 @@ bool TQETWidget::translateMouseEvent( const XEvent *event ) pos.ry() = event->xbutton.y; globalPos.rx() = event->xbutton.x_root; globalPos.ry() = event->xbutton.y_root; - state = translateButtonState( event->xbutton.state ); + state = qt_x11_translateButtonState( event->xbutton.state ); switch ( event->xbutton.button ) { case Button1: button = LeftButton; break; case Button2: button = MidButton; break; @@ -7322,6 +7370,92 @@ static const KeySym KeyTbl[] = { // keyboard mapping table 0x1005FF10, TQt::Key_F11, // hardcoded Sun F36 (labeled F11) 0x1005FF11, TQt::Key_F12, // hardcoded Sun F37 (labeled F12) + // International input method support keys + + // International & multi-key character composition + XK_Multi_key, TQt::Key_Multi_key, + XK_Codeinput, TQt::Key_Codeinput, + XK_SingleCandidate, TQt::Key_SingleCandidate, + XK_MultipleCandidate, TQt::Key_MultipleCandidate, + XK_PreviousCandidate, TQt::Key_PreviousCandidate, + + // Misc Functions + XK_Mode_switch, TQt::Key_Mode_switch, + //XK_script_switch, TQt::Key_script_switch, + XK_script_switch, TQt::Key_Mode_switch, + + // Japanese keyboard support + XK_Kanji, TQt::Key_Kanji, + XK_Muhenkan, TQt::Key_Muhenkan, + //XK_Henkan_Mode, TQt::Key_Henkan_Mode, + XK_Henkan_Mode, TQt::Key_Henkan, + XK_Henkan, TQt::Key_Henkan, + XK_Romaji, TQt::Key_Romaji, + XK_Hiragana, TQt::Key_Hiragana, + XK_Katakana, TQt::Key_Katakana, + XK_Hiragana_Katakana, TQt::Key_Hiragana_Katakana, + XK_Zenkaku, TQt::Key_Zenkaku, + XK_Hankaku, TQt::Key_Hankaku, + XK_Zenkaku_Hankaku, TQt::Key_Zenkaku_Hankaku, + XK_Touroku, TQt::Key_Touroku, + XK_Massyo, TQt::Key_Massyo, + XK_Kana_Lock, TQt::Key_Kana_Lock, + XK_Kana_Shift, TQt::Key_Kana_Shift, + XK_Eisu_Shift, TQt::Key_Eisu_Shift, + XK_Eisu_toggle, TQt::Key_Eisu_toggle, + //XK_Kanji_Bangou, TQt::Key_Kanji_Bangou, + //XK_Zen_Koho, TQt::Key_Zen_Koho, + //XK_Mae_Koho, TQt::Key_Mae_Koho, + XK_Kanji_Bangou, TQt::Key_Codeinput, + XK_Zen_Koho, TQt::Key_MultipleCandidate, + XK_Mae_Koho, TQt::Key_PreviousCandidate, + +#ifdef XK_KOREAN + // Korean keyboard support + XK_Hangul, TQt::Key_Hangul, + XK_Hangul_Start, TQt::Key_Hangul_Start, + XK_Hangul_End, TQt::Key_Hangul_End, + XK_Hangul_Hanja, TQt::Key_Hangul_Hanja, + XK_Hangul_Jamo, TQt::Key_Hangul_Jamo, + XK_Hangul_Romaja, TQt::Key_Hangul_Romaja, + //XK_Hangul_Codeinput, TQt::Key_Hangul_Codeinput, + XK_Hangul_Codeinput, TQt::Key_Codeinput, + XK_Hangul_Jeonja, TQt::Key_Hangul_Jeonja, + XK_Hangul_Banja, TQt::Key_Hangul_Banja, + XK_Hangul_PreHanja, TQt::Key_Hangul_PreHanja, + XK_Hangul_PostHanja, TQt::Key_Hangul_PostHanja, + //XK_Hangul_SingleCandidate, TQt::Key_Hangul_SingleCandidate, + //XK_Hangul_MultipleCandidate, TQt::Key_Hangul_MultipleCandidate, + //XK_Hangul_PreviousCandidate, TQt::Key_Hangul_PreviousCandidate, + XK_Hangul_SingleCandidate, TQt::Key_SingleCandidate, + XK_Hangul_MultipleCandidate, TQt::Key_MultipleCandidate, + XK_Hangul_PreviousCandidate, TQt::Key_PreviousCandidate, + XK_Hangul_Special, TQt::Key_Hangul_Special, + //XK_Hangul_switch, TQt::Key_Hangul_switch, + XK_Hangul_switch, TQt::Key_Mode_switch, +#endif // XK_KOREAN + + // dead keys + XK_dead_grave, TQt::Key_Dead_Grave, + XK_dead_acute, TQt::Key_Dead_Acute, + XK_dead_circumflex, TQt::Key_Dead_Circumflex, + XK_dead_tilde, TQt::Key_Dead_Tilde, + XK_dead_macron, TQt::Key_Dead_Macron, + XK_dead_breve, TQt::Key_Dead_Breve, + XK_dead_abovedot, TQt::Key_Dead_Abovedot, + XK_dead_diaeresis, TQt::Key_Dead_Diaeresis, + XK_dead_abovering, TQt::Key_Dead_Abovering, + XK_dead_doubleacute, TQt::Key_Dead_Doubleacute, + XK_dead_caron, TQt::Key_Dead_Caron, + XK_dead_cedilla, TQt::Key_Dead_Cedilla, + XK_dead_ogonek, TQt::Key_Dead_Ogonek, + XK_dead_iota, TQt::Key_Dead_Iota, + XK_dead_voiced_sound, TQt::Key_Dead_Voiced_Sound, + XK_dead_semivoiced_sound, TQt::Key_Dead_Semivoiced_Sound, + XK_dead_belowdot, TQt::Key_Dead_Belowdot, + XK_dead_hook, TQt::Key_Dead_Hook, + XK_dead_horn, TQt::Key_Dead_Horn, + // Special multimedia keys // currently only tested with MS internet keyboard @@ -7539,9 +7673,9 @@ static TQChar keysymToUnicode(unsigned char byte3, unsigned char byte4) bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, TQString& text, int& state, - char& ascii, int& code, TQEvent::Type &type, bool willRepeat ) + char& ascii, int& code, TQEvent::Type &type, bool willRepeat, bool statefulTranslation ) { - TQTextCodec *mapper = input_mapper; + TQTextCodec *mapper = qt_input_mapper; // some XmbLookupString implementations don't return buffer overflow correctly, // so we increase the input buffer to allow for long strings... // 256 chars * 2 bytes + 1 null-term == 513 bytes @@ -7562,7 +7696,7 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, XKeyEvent xkeyevent = event->xkey; // save the modifier state, we will use the keystate uint later by passing - // it to translateButtonState + // it to qt_x11_translateButtonState uint keystate = event->xkey.state; // remove the modifiers where mode_switch exists... HPUX machines seem // to have alt *AND* mode_switch both in Mod1Mask, which causes @@ -7588,6 +7722,11 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, if ( type == TQEvent::KeyPress ) { bool mb=FALSE; + // commit string handling is done by + // TQXIMInputContext::x11FilterEvent() and are passed to + // widgets via TQIMEvent regardless of XIM style, so the + // following code is commented out. +#if 0 if ( qt_xim ) { TQTLWExtra* xd = tlw->topData(); TQInputContext *qic = (TQInputContext *) xd->xic; @@ -7596,13 +7735,14 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, count = qic->lookupString(&xkeyevent, chars, &key, &status); } } +#endif if ( !mb ) { count = XLookupString( &xkeyevent, chars.data(), chars.size(), &key, 0 ); } if ( count && !keycode ) { - keycode = composingKeycode; - composingKeycode = 0; + keycode = qt_ximComposingKeycode; + qt_ximComposingKeycode = 0; } if ( key ) keyDict->tqreplace( keycode, (void*)key ); @@ -7666,28 +7806,32 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, } else { key = (int)(long)keyDict->tqfind( keycode ); if ( key ) - if( !willRepeat ) // Take out key of dictionary only if this call. + if( !willRepeat && statefulTranslation ) // Take out key of dictionary only if this call. keyDict->take( keycode ); long s = (long)textDict->tqfind( keycode ); if ( s ) { - textDict->take( keycode ); + if( statefulTranslation ) + textDict->take( keycode ); ascii = (char)(s-256); } } #endif // !TQT_NO_XIM - state = translateButtonState( keystate ); + state = qt_x11_translateButtonState( keystate ); static int directionKeyEvent = 0; - if ( qt_use_rtl_extensions && type == TQEvent::KeyRelease ) { + static unsigned int lastWinId = 0; + if ( qt_use_rtl_extensions && type == TQEvent::KeyRelease && statefulTranslation ) { if (directionKeyEvent == Key_Direction_R || directionKeyEvent == Key_Direction_L ) { type = TQEvent::KeyPress; code = directionKeyEvent; chars[0] = 0; directionKeyEvent = 0; + lastWinId = 0; return TRUE; } else { directionKeyEvent = 0; + lastWinId = 0; } } @@ -7697,10 +7841,14 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, // (to figure out whether the Ctrl modifier is held while Shift is pressed, // or Shift is held while Ctrl is pressed) since the 'state' doesn't tell // us whether the modifier held is Left or Right. - if (qt_use_rtl_extensions && type == TQEvent::KeyPress) + if ( qt_use_rtl_extensions && type == TQEvent::KeyPress && statefulTranslation ) if (key == XK_Control_L || key == XK_Control_R || key == XK_Shift_L || key == XK_Shift_R) { - if (!directionKeyEvent) + if (!directionKeyEvent) { directionKeyEvent = key; + // This code exists in order to check that + // the event is occurred in the same widget. + lastWinId = winId(); + } } else { // this can no longer be a direction-changing accel. // if any other key was pressed. @@ -7714,7 +7862,7 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, // TQt keycodes between 128 and 255, but should rather use the // TQKeyEvent::text(). // - if ( key < 128 || (key < 256 && (!input_mapper || input_mapper->mibEnum()==4)) ) { + if ( key < 128 || (key < 256 && (!qt_input_mapper || qt_input_mapper->mibEnum()==4)) ) { code = isprint((int)key) ? toupper((int)key) : 0; // upper-case key, if known } else if ( key >= XK_F1 && key <= XK_F35 ) { code = Key_F1 + ((int)key - XK_F1); // function keys @@ -7765,8 +7913,8 @@ bool TQETWidget::translateKeyEventInternal( const XEvent *event, int& count, chars[0] = 0; } - if ( qt_use_rtl_extensions && type == TQEvent::KeyPress ) { - if ( directionKeyEvent ) { + if ( qt_use_rtl_extensions && type == TQEvent::KeyPress && statefulTranslation ) { + if ( directionKeyEvent && lastWinId == winId() ) { if ( key == XK_Shift_L && directionKeyEvent == XK_Control_L || key == XK_Control_L && directionKeyEvent == XK_Shift_L ) { directionKeyEvent = Key_Direction_L; @@ -7838,8 +7986,10 @@ static Bool qt_keypress_scanner(Display *, XEvent *event, XPointer arg) qt_auto_repeat_data *d = (qt_auto_repeat_data *) arg; if (d->error || event->xkey.window != d->window || - event->xkey.keycode != d->keycode) + event->xkey.keycode != d->keycode) { + d->error = TRUE; return FALSE; + } if (event->type == XKeyPress) { d->error = (! d->release || event->xkey.time - d->timestamp > 10); @@ -7942,8 +8092,34 @@ bool TQETWidget::translateKeyEvent( const XEvent *event, bool grab ) translateKeyEventInternal( event, count, text, state, ascii, code, type ); } +#ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); +#endif + // compress keys if ( !text.isEmpty() && testWState(WState_CompressKeys) && +#ifndef TQT_NO_IM + // Ordinary input methods require discrete key events to work + // properly, so key compression has to be disabled when input + // context exists. + // + // And further consideration, some complex input method + // require all key press/release events discretely even if + // the input method awares of key compression and compressed + // keys are ordinary alphabets. For example, the uim project + // is planning to implement "combinational shift" feature for + // a Japanese input method, uim-skk. It will work as follows. + // + // 1. press "r" + // 2. press "u" + // 3. release both "r" and "u" in arbitrary order + // 4. above key sequence generates "Ru" + // + // Of course further consideration about other participants + // such as key repeat mechanism is required to implement such + // feature. + ! qic && +#endif // TQT_NO_IM // do not compress keys if the key event we just got above matches // one of the key ranges used to compute stopCompression ! ( ( code >= Key_Escape && code <= Key_SysReq ) || @@ -8002,7 +8178,12 @@ bool TQETWidget::translateKeyEvent( const XEvent *event, bool grab ) // autorepeat compression makes sense for all widgets (Windows // does it automatically .... ) - if ( event->type == XKeyPress && text.length() <= 1 ) { + if ( event->type == XKeyPress && text.length() <= 1 +#ifndef TQT_NO_IM + // input methods need discrete key events + && ! qic +#endif// TQT_NO_IM + ) { XEvent dummy; for (;;) { @@ -8210,6 +8391,21 @@ bool TQETWidget::translateScrollDoneEvent( const XEvent *event ) return FALSE; } +#if defined(TQ_C_CALLBACKS) +extern "C" { +#endif +#ifndef TQT_NO_XSYNC +static Bool qt_net_wm_sync_request_scanner(Display*, XEvent* event, XPointer arg) +{ + return (event->type == ClientMessage && event->xclient.window == *(Window*)arg + && event->xclient.message_type == qt_wm_protocols + && event->xclient.data.l[ 0 ] == qt_net_wm_sync_request ); +} +#endif + +#if defined(TQ_C_CALLBACKS) +} +#endif // // ConfigureNotify (window move and resize) event translation @@ -8241,6 +8437,7 @@ bool TQETWidget::translateConfigEvent( const XEvent *event ) if (! extra || extra->compress_events) { // ConfigureNotify compression for faster opaque resizing XEvent otherEvent; + int compressed_configs = 0; while ( XCheckTypedWindowEvent( x11Display(), winId(), ConfigureNotify, &otherEvent ) ) { if ( qt_x11EventFilter( &otherEvent ) ) @@ -8261,7 +8458,18 @@ bool TQETWidget::translateConfigEvent( const XEvent *event ) newCPos.ry() = otherEvent.xconfigure.y + otherEvent.xconfigure.border_width; } + ++compressed_configs; } +#ifndef TQT_NO_XSYNC + // _NET_WM_SYNC_REQUEST compression + Window wid = winId(); + while ( compressed_configs && + XCheckIfEvent( x11Display(), &otherEvent, + qt_net_wm_sync_request_scanner, (XPointer)&wid ) ) { + handleSyncRequest( (void*)&otherEvent ); + --compressed_configs; + } +#endif } TQRect cr ( tqgeometry() ); @@ -8315,6 +8523,8 @@ bool TQETWidget::translateConfigEvent( const XEvent *event ) tqrepaint( !testWFlags(WResizeNoErase) || transbg ); } + incrementSyncCounter(); + return TRUE; } diff --git a/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp b/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp index 14e7f08..9fd90e4 100644 --- a/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqclipboard_x11.cpp @@ -111,6 +111,7 @@ static int pending_timer_id = 0; static bool pending_clipboard_changed = FALSE; static bool pending_selection_changed = FALSE; +TQ_EXPORT bool qt_qclipboard_bailout_hack = false; // event capture mechanism for qt_xclb_wait_for_event static bool waiting_for_data = FALSE; @@ -142,6 +143,15 @@ static Bool checkForClipboardEvents(Display *, XEvent *e, XPointer) || e->xselectionclear.selection == qt_xa_clipboard))); } +static bool selection_request_pending = false; + +static Bool check_selection_request_pending( Display*, XEvent* e, XPointer ) + { + if( e->type == SelectionRequest && e->xselectionrequest.owner == owner->winId()) + selection_request_pending = true; + return False; + } + bool qt_xclb_wait_for_event( Display *dpy, Window win, int type, XEvent *event, int timeout ) { @@ -193,6 +203,14 @@ bool qt_xclb_wait_for_event( Display *dpy, Window win, int type, XEvent *event, do { if ( XCheckTypedWindowEvent(dpy,win,type,event) ) return TRUE; + if( qt_qclipboard_bailout_hack ) { + XEvent dummy; + selection_request_pending = false; + if ( owner != NULL ) + XCheckIfEvent(dpy,&dummy,check_selection_request_pending,NULL); + if( selection_request_pending ) + return TRUE; + } // process other clipboard events, since someone is probably requesting data from us XEvent e; diff --git a/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp b/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp index e2bd9f9..84da179 100644 --- a/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqdesktopwidget_x11.cpp @@ -111,7 +111,7 @@ TQDesktopWidgetPrivate::~TQDesktopWidgetPrivate() screens[i] = 0; } - delete [] screens; + free(screens); } if ( rects ) delete [] rects; @@ -121,6 +121,8 @@ TQDesktopWidgetPrivate::~TQDesktopWidgetPrivate() void TQDesktopWidgetPrivate::init() { // get the screen count + int newScreenCount; + #ifndef TQT_NO_XINERAMA XineramaScreenInfo *xinerama_screeninfo = 0; int unused; @@ -130,23 +132,26 @@ void TQDesktopWidgetPrivate::init() if (use_xinerama) { xinerama_screeninfo = - XineramaQueryScreens(TQPaintDevice::x11AppDisplay(), &screenCount); + XineramaQueryScreens(TQPaintDevice::x11AppDisplay(), &newScreenCount); + + if (xinerama_screeninfo) defaultScreen = 0; } else #endif // TQT_NO_XINERAMA { defaultScreen = DefaultScreen(TQPaintDevice::x11AppDisplay()); - screenCount = ScreenCount(TQPaintDevice::x11AppDisplay()); + newScreenCount = ScreenCount(TQPaintDevice::x11AppDisplay()); + use_xinerama = false; } delete [] rects; - rects = new TQRect[ screenCount ]; + rects = new TQRect[ newScreenCount ]; delete [] workareas; - workareas = new TQRect[ screenCount ]; + workareas = new TQRect[ newScreenCount ]; // get the tqgeometry of each screen - int i, x, y, w, h; - for ( i = 0; i < screenCount; i++ ) { + int i, j, x, y, w, h; + for ( i = 0, j = 0; i < newScreenCount; i++ ) { #ifndef TQT_NO_XINERAMA if (use_xinerama) { @@ -163,11 +168,33 @@ void TQDesktopWidgetPrivate::init() h = HeightOfScreen(ScreenOfDisplay(TQPaintDevice::x11AppDisplay(), i)); } - rects[i].setRect(x, y, w, h); workareas[i] = TQRect(); + rects[j].setRect(x, y, w, h); + + // overlapping? + if (j > 0 && rects[j-1].intersects(rects[j])) { + // pick the bigger one, ignore the other + if ((rects[j].width()*rects[j].height()) > + (rects[j-1].width()*rects[j-1].height())) + rects[j-1] = rects[j]; + } + else + j++; } + if (screens) { + // leaks TQWidget* pointers on purpose, can't delete them as pointer escapes + screens = (TQWidget**) realloc(screens, j * sizeof(TQWidget*)); + if (j > screenCount) + memset(&screens[screenCount], 0, (j-screenCount) * sizeof(TQWidget*)); + } + + screenCount = j; + #ifndef TQT_NO_XINERAMA + if (use_xinerama && screenCount == 1) + use_xinerama = false; + if (xinerama_screeninfo) XFree(xinerama_screeninfo); #endif // TQT_NO_XINERAMA @@ -220,8 +247,7 @@ TQWidget *TQDesktopWidget::screen( int screen ) screen = d->defaultScreen; if ( ! d->screens ) { - d->screens = new TQWidget*[ d->screenCount ]; - memset( d->screens, 0, d->screenCount * sizeof( TQWidget * ) ); + d->screens = (TQWidget**) calloc( d->screenCount, sizeof(TQWidget*)); d->screens[ d->defaultScreen ] = this; } diff --git a/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp b/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp index 7882349..3ba66b9 100644 --- a/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqdnd_x11.cpp @@ -52,13 +52,15 @@ #include "tqdragobject.h" #include "tqobjectlist.h" #include "tqcursor.h" +#include "tqbitmap.h" +#include "tqpainter.h" #include "tqt_x11_p.h" // conflict resolution -// unused, may be used again later: const int XKeyPress = KeyPress; -// unused, may be used again later: const int XKeyRelease = KeyRelease; +const int XKeyPress = KeyPress; +const int XKeyRelease = KeyRelease; #undef KeyPress #undef KeyRelease @@ -114,6 +116,8 @@ Atom qt_xdnd_finished; Atom qt_xdnd_type_list; const int qt_xdnd_version = 4; +extern int qt_x11_translateButtonState( int s ); + // Actions // // The Xdnd spec allows for user-defined actions. This could be implemented @@ -199,6 +203,8 @@ static Time qt_xdnd_target_current_time; static int qt_xdnd_current_screen = -1; // state of dragging... true if dragging, false if not bool qt_xdnd_dragging = FALSE; +// need to check state of keyboard modifiers +static bool need_modifiers_check = FALSE; // dict of payload data, sorted by type atom static TQIntDict * qt_xdnd_target_data = 0; @@ -257,21 +263,49 @@ class TQShapedPixmapWidget : public TQWidget { public: TQShapedPixmapWidget(int screen = -1) : TQWidget(TQApplication::desktop()->screen( screen ), - 0, (Qt::WindowType)(WStyle_Customize | WStyle_Tool | WStyle_NoBorder | WX11BypassWM) ) + 0, (Qt::WindowType)(WStyle_Customize | WStyle_Tool | WStyle_NoBorder | WX11BypassWM) ), oldpmser( 0 ), oldbmser( 0 ) { + x11SetWindowType( X11WindowTypeDND ); } - void setPixmap(TQPixmap pm) + void setPixmap(TQPixmap pm, TQPoint hot) { - const TQBitmap* mask = pm.tqmask(); - if ( mask ) { + int bmser = pm.tqmask() ? pm.tqmask()->serialNumber() : 0; + if( oldpmser == pm.serialNumber() && oldbmser == bmser + && oldhot == hot ) + return; + oldpmser = pm.serialNumber(); + oldbmser = bmser; + oldhot = hot; + bool hotspot_in = !(hot.x() < 0 || hot.y() < 0 || hot.x() >= pm.width() || hot.y() >= pm.height()); +// if the pixmap has hotspot in its area, make a "hole" in it at that position +// this will allow XTranslateCoordinates() to find directly the window below the cursor instead +// of finding this pixmap, and therefore there won't be needed any (slow) search for the window +// using findRealWindow() + if( hotspot_in ) { + TQBitmap tqmask = pm.tqmask() ? *pm.tqmask() : TQBitmap( pm.width(), pm.height()); + if( !pm.tqmask()) + tqmask.fill( TQt::color1 ); + TQPainter p( &tqmask ); + p.setPen( TQt::color0 ); + p.drawPoint( hot.x(), hot.y()); + p.end(); + pm.setMask( tqmask ); + setMask( tqmask ); + } else if ( pm.tqmask() ) { setMask( *mask ); } else { clearMask(); } resize(pm.width(),pm.height()); setErasePixmap(pm); + erase(); } + +private: + int oldpmser; + int oldbmser; + TQPoint oldhot; }; static TQShapedPixmapWidget * qt_xdnd_deco = 0; @@ -875,8 +909,59 @@ void qt_handle_xdnd_finished( TQWidget *, const XEvent * xe, bool passive ) void TQDragManager::timerEvent( TQTimerEvent* e ) { - if ( e->timerId() == heartbeat && qt_xdnd_source_sameanswer.isNull() ) - move( TQCursor::pos() ); + if ( e->timerId() == heartbeat ) { + if( need_modifiers_check ) { + Window root, child; + int root_x, root_y, win_x, win_y; + unsigned int tqmask; + XQueryPointer( qt_xdisplay(), qt_xrootwin( qt_xdnd_current_screen ), + &root, &child, &root_x, &root_y, &win_x, &win_y, &tqmask ); + if( updateMode( (ButtonState)qt_x11_translateButtonState( tqmask ))) + qt_xdnd_source_sameanswer = TQRect(); // force move + } + need_modifiers_check = TRUE; + if( qt_xdnd_source_sameanswer.isNull() ) + move( TQCursor::pos() ); + } +} + +static bool qt_xdnd_was_move = false; +static bool qt_xdnd_found = false; +// check whole incoming X queue for move events +// checking whole queue is done by always returning False in the predicate +// if there's another move event in the queue, and there's not a mouse button +// or keyboard or ClientMessage event before it, the current move event +// may be safely discarded +// this helps avoiding being overloaded by being flooded from many events +// from the XServer +static +Bool qt_xdnd_predicate( Display*, XEvent* ev, XPointer ) +{ + if( qt_xdnd_found ) + return False; + if( ev->type == MotionNotify ) + { + qt_xdnd_was_move = true; + qt_xdnd_found = true; + } + if( ev->type == ButtonPress || ev->type == ButtonRelease + || ev->type == XKeyPress || ev->type == XKeyRelease + || ev->type == ClientMessage ) + { + qt_xdnd_was_move = false; + qt_xdnd_found = true; + } + return False; +} + +static +bool qt_xdnd_another_movement() +{ + qt_xdnd_was_move = false; + qt_xdnd_found = false; + XEvent dummy; + XCheckIfEvent( qt_xdisplay(), &dummy, qt_xdnd_predicate, NULL ); + return qt_xdnd_was_move; } bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) @@ -901,8 +986,11 @@ bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) if ( e->type() == TQEvent::MouseMove ) { TQMouseEvent* me = (TQMouseEvent *)e; - updateMode(me->stateAfter()); - move( me->globalPos() ); + if( !qt_xdnd_another_movement()) { + updateMode(me->stateAfter()); + move( me->globalPos() ); + } + need_modifiers_check = FALSE; return TRUE; } else if ( e->type() == TQEvent::MouseButtonRelease ) { tqApp->removeEventFilter( this ); @@ -941,9 +1029,11 @@ bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) beingCancelled = FALSE; tqApp->exit_loop(); } else { - updateMode(ke->stateAfter()); - qt_xdnd_source_sameanswer = TQRect(); // force move - move( TQCursor::pos() ); + if( updateMode(ke->stateAfter())) { + qt_xdnd_source_sameanswer = TQRect(); // force move + move( TQCursor::pos() ); + } + need_modifiers_check = FALSE; } return TRUE; // Eat all key events } @@ -970,10 +1060,10 @@ bool TQDragManager::eventFilter( TQObject * o, TQEvent * e) static TQt::ButtonState oldstate; -void TQDragManager::updateMode( TQt::ButtonState newstate ) +bool TQDragManager::updateMode( TQt::ButtonState newstate ) { if ( newstate == oldstate ) - return; + return false; const int both = ShiftButton|ControlButton; if ( (newstate & both) == both ) { global_requested_action = TQDropEvent::Link; @@ -997,6 +1087,7 @@ void TQDragManager::updateMode( TQt::ButtonState newstate ) } } oldstate = newstate; + return true; } @@ -1138,12 +1229,13 @@ void TQDragManager::move( const TQPoint & globalPos ) // recreate the pixmap on the new screen... delete qt_xdnd_deco; qt_xdnd_deco = new TQShapedPixmapWidget( screen ); + qt_xdnd_deco->x11SetWindowTransient( dragSource->tqtopLevelWidget()); if (!TQWidget::mouseGrabber()) { updatePixmap(); qt_xdnd_deco->grabMouse(); } } - updatePixmap(); + updatePixmap( globalPos ); if ( qt_xdnd_source_sameanswer.contains( globalPos ) && qt_xdnd_source_sameanswer.isValid() ) { @@ -1691,6 +1783,7 @@ bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) dragSource = (TQWidget *)(object->tqparent()); + qt_xdnd_deco->x11SetWindowTransient( dragSource->tqtopLevelWidget()); tqApp->installEventFilter( this ); qt_xdnd_source_current_time = GET_QT_X_TIME(); XSetSelectionOwner( TQPaintDevice::x11AppDisplay(), qt_xdnd_selection, @@ -1703,6 +1796,7 @@ bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) qt_xdnd_source_sameanswer = TQRect(); move(TQCursor::pos()); heartbeat = startTimer(200); + need_modifiers_check = FALSE; #ifndef TQT_NO_CURSOR tqApp->setOverrideCursor( Qt::ArrowCursor ); @@ -1736,7 +1830,7 @@ bool TQDragManager::drag( TQDragObject * o, TQDragObject::DragMode mode ) // qt_xdnd_source_object persists until we get an xdnd_finish message } -void TQDragManager::updatePixmap() +void TQDragManager::updatePixmap( const TQPoint& cursorPos ) { if ( qt_xdnd_deco ) { TQPixmap pm; @@ -1751,9 +1845,8 @@ void TQDragManager::updatePixmap() defaultPm = new TQPixmap(default_pm); pm = *defaultPm; } - qt_xdnd_deco->setPixmap(pm); - qt_xdnd_deco->move(TQCursor::pos()-pm_hot); - qt_xdnd_deco->tqrepaint(FALSE); + qt_xdnd_deco->setPixmap(pm, pm_hot); + qt_xdnd_deco->move(cursorPos-pm_hot); //if ( willDrop ) { qt_xdnd_deco->show(); //} else { @@ -1762,4 +1855,9 @@ void TQDragManager::updatePixmap() } } +void TQDragManager::updatePixmap() +{ + updatePixmap( TQCursor::pos()); +} + #endif // TQT_NO_DRAGANDDROP diff --git a/tqtinterface/qt4/src/kernel/tqdragobject.cpp b/tqtinterface/qt4/src/kernel/tqdragobject.cpp index 6e58f84..5a4d2fe 100644 --- a/tqtinterface/qt4/src/kernel/tqdragobject.cpp +++ b/tqtinterface/qt4/src/kernel/tqdragobject.cpp @@ -2468,6 +2468,16 @@ bool TQTextDrag::decode( const TQMimeSource* e, TQString& str, TQCString& subtyp { if(!e) return FALSE; + + // when subtype is not specified, try text/plain first, otherwise this may read + // things like text/x-moz-url even though better targets are available + if( subtype.isNull()) { + TQCString subtmp = "plain"; + if( decode( e, str, subtmp )) { + subtype = subtmp; + return true; + } + } if ( e->cacheType == TQMimeSource::Text ) { str = *e->cache.txt.str; diff --git a/tqtinterface/qt4/src/kernel/tqdragobject.h b/tqtinterface/qt4/src/kernel/tqdragobject.h index 3d55967..7133c0f 100644 --- a/tqtinterface/qt4/src/kernel/tqdragobject.h +++ b/tqtinterface/qt4/src/kernel/tqdragobject.h @@ -476,10 +476,11 @@ private: void move( const TQPoint & ); void drop(); void updatePixmap(); + void updatePixmap( const TQPoint& cursorPos ); private: TQDragObject * object; - void updateMode( TQt::ButtonState newstate ); + bool updateMode( TQt::ButtonState newstate ); void updateCursor(); #if defined(TQ_WS_X11) void createCursors(); diff --git a/tqtinterface/qt4/src/kernel/tqevent.cpp b/tqtinterface/qt4/src/kernel/tqevent.cpp index b34f38d..59a6ca7 100644 --- a/tqtinterface/qt4/src/kernel/tqevent.cpp +++ b/tqtinterface/qt4/src/kernel/tqevent.cpp @@ -874,6 +874,10 @@ TQWheelEvent::TQWheelEvent( const TQPoint &pos, int delta, int state, Orientatio the result of a known key (e.g. it may be the result of a compose sequence or a keyboard macro, or due to key event compression). + Applications should not use the TQt latin 1 keycodes between 128 + and 255, but should rather use the TQKeyEvent::text(). This is + mainly for compatibility. + \sa TQWidget::setKeyCompression() */ diff --git a/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp b/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp index f79c14b..e70be03 100644 --- a/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp +++ b/tqtinterface/qt4/src/kernel/tqfontdatabase.cpp @@ -707,6 +707,10 @@ static TQtFontStyle *bestStyle(TQtFontFoundry *foundry, const TQtFontStyle::Key } FM_DEBUG( " best style has distance 0x%x", dist ); + if (!foundry->count) { + TQtFontStyle *temp = NULL; + return temp; + } return foundry->styles[best]; } @@ -980,20 +984,22 @@ TQFontDatabase::tqfindFont( TQFont::Script script, const TQFontPrivate *fp, #ifdef TQ_WS_X11 if (script == TQFont::Han) { - // modify script according to locale - static TQFont::Script defaultHan = TQFont::UnknownScript; - if (defaultHan == TQFont::UnknownScript) { - TQCString locale = setlocale(LC_ALL, NULL); - if (locale.tqcontains("ko")) - defaultHan = TQFont::Han_Korean; - else if (locale.tqcontains("zh_TW") || locale.tqcontains("zh_HK")) - defaultHan = TQFont::Han_TraditionalChinese; - else if (locale.tqcontains("zh")) - defaultHan = TQFont::Han_SimplifiedChinese; - else - defaultHan = TQFont::Han_Japanese; - } - script = defaultHan; + // modify script according to locale + static TQFont::Script defaultHan; + TQCString locale = setlocale(LC_ALL, NULL); + + if (locale.tqcontains("ko")) + defaultHan = TQFont::Han_Korean; + else if (locale.tqcontains("zh_TW") || locale.tqcontains("zh_HK")) + defaultHan = TQFont::Han_TraditionalChinese; + else if (locale.tqcontains("zh")) + defaultHan = TQFont::Han_SimplifiedChinese; + else if (locale.tqcontains("ja")) + defaultHan = TQFont::Han_Japanese; + else + defaultHan = TQFont::Han; // don't change + + script = defaultHan; } #endif diff --git a/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp b/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp index 8ea403f..97cb544 100644 --- a/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqfontdatabase_x11.cpp @@ -721,6 +721,9 @@ static void loadXlfds( const char *reqFamily, int encoding_id ) if ( fontFamily && fontFamily->xlfdLoaded ) return; +#ifdef TQT_XFT2 + if ( !qt_has_xft ) { +#endif // TQT_XFT2 int fontCount; // force the X server to give us XLFDs TQCString xlfd_pattern = "-*-"; @@ -822,8 +825,11 @@ static void loadXlfds( const char *reqFamily, int encoding_id ) } XFreeFontNames( fontList ); -} +#ifdef TQT_XFT2 + } +#endif // TQT_XFT2 +} #ifndef TQT_NO_XFTFREETYPE static int getXftWeight(int xftweight) diff --git a/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp b/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp index 0b45ec9..8d76e0b 100644 --- a/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqfontengine_x11.cpp @@ -2694,23 +2694,16 @@ bool TQOpenType::positionAndAdd(TQShaperItem *item, bool doLogClusters) // ###### fix the case where we have y advances. How do we handle this in Uniscribe????? if (positions[i].new_advance) { item->advances[i] = item->flags & TQTextEngine::RightToLeft - ? -tqRound((positions[i].x_advance >> 6)*scale) + ? -tqRound((positions[i].x_advance >> 6)*scale) : tqRound((positions[i].x_advance >> 6)*scale); } else { item->advances[i] += item->flags & TQTextEngine::RightToLeft - ? -tqRound((positions[i].x_advance >> 6)*scale) + ? -tqRound((positions[i].x_advance >> 6)*scale) : tqRound((positions[i].x_advance >> 6)*scale); } - int back = 0; - item->offsets[i].x = tqRound((positions[i].x_pos >> 6)*scale); - item->offsets[i].y = tqRound((positions[i].y_pos >> 6)*scale); - while (positions[i-back].back) { - back += positions[i - back].back; - item->offsets[i].x += tqRound((positions[i - back].x_pos >> 6)*scale); - item->offsets[i].y += tqRound((positions[i - back].y_pos >> 6)*scale); - } - item->offsets[i].y = -item->offsets[i].y; - back = positions[i].back; + item->offsets[i].x = tqRound((positions[i].x_pos >> 6)*scale); + item->offsets[i].y = -tqRound((positions[i].y_pos >> 6)*scale); + int back = positions[i].back; if (item->flags & TQTextEngine::RightToLeft) { while (back--) { item->offsets[i].x -= item->advances[i-back]; diff --git a/tqtinterface/qt4/src/kernel/tqinputcontext.cpp b/tqtinterface/qt4/src/kernel/tqinputcontext.cpp new file mode 100644 index 0000000..dfb38f7 --- /dev/null +++ b/tqtinterface/qt4/src/kernel/tqinputcontext.cpp @@ -0,0 +1,856 @@ +/**************************************************************************** +** $Id: qinputcontext.cpp,v 1.6 2004/06/22 06:47:30 daisuke Exp $ +** +** Implementation of TQInputContext class +** +** Copyright (C) 2000-2003 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses for Unix/X11 may use this file in accordance with the TQt Commercial +** License Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** 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. +** +**********************************************************************/ + +//#define TQT_NO_IM_PREEDIT_RELOCATION + +#include "tqinputcontext.h" + +#ifndef TQT_NO_IM + +#include "tqplatformdefs.h" + +#include "tqapplication.h" +#include "tqwidget.h" +#include "tqpopupmenu.h" + +#include +#include + +class TQInputContextPrivate +{ +public: + TQInputContextPrivate() + : holderWidget( 0 ), composingWidget( 0 ), hasFocus( FALSE ), + isComposing( FALSE ) +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + , preeditString( TQString() ), + cursorPosition( -1 ), selLength ( 0 ) +#endif + {} + + TQWidget *holderWidget; // widget to which TQInputContext instance belongs. + TQWidget *composingWidget; + bool hasFocus; + bool isComposing; + + void updateComposingState( const TQString &text, + int newCursorPosition, int newSelLength ) { +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + preeditString = text; + cursorPosition = newCursorPosition; + selLength = newSelLength; +#endif + } + + void resetComposingState() { + isComposing = FALSE; +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + preeditString = TQString(); + cursorPosition = -1; + selLength = 0; +#endif + } + +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + TQString preeditString; + int cursorPosition; + int selLength; +#endif +}; + + +// UPDATED COMMENT RETQUIRED -- 2004-07-08 YamaKen +/*! + \class TQInputContext qinputcontext.h + \brief The TQInputContext class abstracts the input method dependent data and composing state. + + \ingroup i18n + + An input method is responsible to input complex text that cannot + be inputted via simple keymap. It converts a sequence of input + events (typically key events) into a text string through the input + method specific converting process. The class of the processes are + widely ranging from simple finite state machine to complex text + translator that pools a whole paragraph of a text with text + editing capability to perform grammar and semantic analysis. + + To abstract such different input method specific intermediate + information, TQt offers the TQInputContext as base class. The + concept is well known as 'input context' in the input method + domain. an input context is created for a text widget in response + to a demand. It is ensured that an input context is prepared for + an input method before input to a text widget. + + Multiple input contexts that is belonging to a single input method + may concurrently coexist. Suppose multi-window text editor. Each + text widget of window A and B holds different TQInputContext + instance which contains different state information such as + partially composed text. + + \section1 Groups of functions: + + \table + \header \i Context \i Functions + + \row \i Receiving information \i + x11FilterEvent(), + filterEvent(), + setMicroFocus(), + mouseHandler() + + \row \i Sending back composed text \i + sendIMEvent(), + + \row \i State change notification \i + setFocus(), + unsetFocus(), + reset() + + \row \i Context information \i + identifierName(), + language(), + font(), + isComposing(), + + \endtable + + + \section1 Sharing input context between text widgets + + Any input context can be shared between several text widgets to + reduce resource consumption. In ideal case, each text widgets + should be allocated dedicated input context. But some complex + input contexts require slightly heavy resource such as 100 + kilobytes of memory. It prevents quite many text widgets from + being used concurrently. + + To resolve such problem, we can share an input context. There is + one 'input context holder widget' per text widgets that shares + identical input context. In this model, the holder widget owns the + shared input context. Other text widgets access the input context + via TQApplication::locateICHolderWidget(). But the access + convention is transparently hidden into TQWidget, so developers are + not required to aware of it. + + What developer should know is only the mapping function + TQApplication::locateICHolderWidget(). It accepts a widget as + argument and returns its holder widget. Default implementation + returns the top-level widget of the widget as reasonable + assumption. But some applications should reimplement the function + to fit application specific usability. See + TQApplication::locateICHolderWidget() for further information. + + + \section1 Preedit preservation + + As described above, input contexts have wide variety of amount of + the state information in accordance with belonging input + method. It is ranging from 2-3 keystrokes of sequence in + deterministic input methods to hundreds of keystrokes with + semantic text refinement in complex input methods such as ordinary + Japanese input method. The difference requires the different reset + policies in losing input focus. + + The former simple input method case, users will prefer resetting + the context to back to the neutral state when something + happened. Suppose a web browsing. The user scroll the page by + scrollbar after he or she has typed a half of the valid key + sequence into a text widget. In the case, the input context should + be reset in losing focus when he or she has dragged the + scrollbar. He or she will be confused if the input context is + still preserved until focused back to the text widget because he + or she will restart typing with first key of the sequence as a + habitual operation. + + On the other hand, we should choose completely different policy + for the latter complex input method case. Suppose same situation + as above but he or she is using a complex input method. In the + case, he or she will be angry if the input context has been lost + when he or she has dragged the scrollbar because the input context + contained a valuably composed text made up by considerable input + cost. So we should not reset the input context in the case. And + the input context should be preserved until focused back to the + text widget. This behavior is named as 'preedit preservation'. + + The two policies can be switched by calling or not calling reset() + in unsetFocus(). Default implementation of unsetFocus() calls + reset() to fit the simple input methods. The implementation is + expressed as 'preedit preservation is disabled'. + + + \section1 Preedit relocation + + Although the most case of the preedit preservation problem for + complex input methods is resolved as described above, there is a + special case. Suppose the case that matches all of the following + conditions. + + \list + + \i a input focus has been moved from a text widget to another text + widget directly + + \i the input context is shared between the two text widgets + + \i preedit preservation is enabled for the input context + + \endlist + + In the case, there are the following two requirements that + contradicts each other. The input context sharing causes it. + + \list + + \i the input context has to be reset to prepare to input to the + newly focused text widget + + \i the input context has to be preserved until focused back to the + previous text widget + + \endlist + + A intrinsic feature named 'preedit relocation' is available to + compromise the requirements. If the feature is enabled for the + input context, it is simply moved to the new text widget with the + preedit string. The user continues the input on the new text + widget, or relocate it to another text widget. The preedit of + previous text widget is automatically cleared to back to the + neutral state of the widget. + + This strange behavior is just a compromise. As described in + previous section, complex input method user should not be exposed + to the risk losing the input context because it contains valuable + long text made up with considerable input cost. The user will + immediately focus back to the previous text widget to continue the + input in the correct text widget if the preedit relocation + occurred. The feature is mainly existing as safety. + + The feature properly works even if the focus is moved as + following. Input method developers are not required to be aware of + the relocation protocol since TQInputContext transparently handles + it. + + a text widget -> a non-text widget -> another text widget + + To enable the preedit relocation feature, the input context class + have to reimplement isPreeditRelocationEnabled() as returns TRUE. + The implementation requires that the preedit preservation is also + enabled since preedit relocation is a special case of the preedit + preservation. If the preedit relocation is disabled, the input + context is simply reset in the relocation case. + + + \section1 Input context instanciation + \section1 Input method switching + + \section1 Text widget implementor's guide + + Add following code fragment into createPopupMenu() to add input + method dependent submenus. + + \code + #ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->addMenusTo( popup ); + #endif + \endcode + + \sa TQInputContextPlugin, TQInputContextFactory, TQApplication::locateICHolderWidget(), TQApplication::defaultInputMethod() +*/ + + +/*! + Constructs an input context. + + holderWidget is set immediately after this constructor has been + returned on the X11 platform. +*/ +TQInputContext::TQInputContext( TQObject *tqparent ) + : TQObject( tqparent ) +{ + d = new TQInputContextPrivate; +} + + +/*! + Destroys the input context. +*/ +TQInputContext::~TQInputContext() +{ + delete d; +} + +#if defined(TQ_WS_X11) +/*! + \internal + Returns the owner of this input context. Ordinary input methods + should not call this function directly to keep platform + independence and flexible configuration possibility. + + The return value may differ from tqfocusWidget() if the input + context is shared between several text widgets. + + \sa setHolderWidget(), tqfocusWidget() +*/ +TQWidget *TQInputContext::holderWidget() const +{ + return d->holderWidget; +} + +/*! + \internal + Sets the owner of this input context. Ordinary input methods + must not call this function directly. + + \sa holderWidget() +*/ +void TQInputContext::setHolderWidget( TQWidget *w ) +{ + d->holderWidget = w; +} + +/*! + \internal + Returns the widget that has an input focus for this input + context. Ordinary input methods should not call this function + directly to keep platform independence and flexible configuration + possibility. + + The return value may differ from holderWidget() if the input + context is shared between several text widgets. + + \sa setFocusWidget(), holderWidget() +*/ +TQWidget *TQInputContext::tqfocusWidget() const +{ + return d->hasFocus ? d->composingWidget : 0; +} + + +/*! + \internal + Sets the widget that has an input focus for this input + context. Ordinary input methods must not call this function + directly. + + \sa tqfocusWidget() +*/ +void TQInputContext::setFocusWidget( TQWidget *w ) +{ + if ( w ) { + bool isFocusingBack = ( w == d->composingWidget ); + bool isPreeditRelocation = ( ! isFocusingBack && isComposing() && + d->composingWidget ); + // invoke sendIMEventInternal() rather than sendIMEvent() to + // avoid altering the composing state + if ( isPreeditRelocation == TRUE ) { + // clear preedit of previously focused text + // widget. preserved preedit may be exist even if + // isPreeditRelocationEnabled() == FALSE. + sendIMEventInternal( TQEvent::IMEnd ); + } + d->composingWidget = w; // changes recipient of TQIMEvent + if ( isPreeditRelocation == TRUE ) { +#if !defined(TQT_NO_IM_PREEDIT_RELOCATION) + if ( isPreeditRelocationEnabled() ) { + // copy preedit state to the widget that gaining focus + sendIMEventInternal( TQEvent::IMStart ); + sendIMEventInternal( TQEvent::IMCompose, d->preeditString, + d->cursorPosition, d->selLength ); + } else +#endif + { + // reset input context when the shared context has + // focused on another text widget + reset(); + } + } + } + d->hasFocus = w ? TRUE : FALSE; +} + + +/*! + \internal + This function is called from TQWidget to keep input state + consistency. Ordinary input method must not call this function + directly. +*/ +void TQInputContext::releaseComposingWidget( TQWidget *w ) +{ + if ( d->composingWidget == w ) { + d->composingWidget = 0; + d->hasFocus = FALSE; + } +} +#endif // TQ_WS_X11 + +/*! + \internal + This function can be reimplemented in a subclass as returning TRUE + if you want making your input method enable the preedit + relocation. See the description for preedit relocation of + TQInputContext. + + /sa TQInputContext +*/ +bool TQInputContext::isPreeditRelocationEnabled() +{ + return FALSE; +} + +/*! + This function indicates whether IMStart event had been sent to the + text widget. It is ensured that an input context can send IMCompose + or IMEnd event safely if this function returned TRUE. + + The state is automatically being tracked through sendIMEvent(). + + \sa sendIMEvent() +*/ +bool TQInputContext::isComposing() const +{ + return d->isComposing; +} + + +/*! + This function can be reimplemented in a subclass to filter input + events. + + Return TRUE if the \a event has been consumed. Otherwise, the + unfiltered \a event will be forwarded to widgets as ordinary + way. Although the input events have accept() and ignore() + methods, leave it untouched. + + \a event is currently restricted to TQKeyEvent. But some input + method related events such as TQWheelEvent or TQTabletEvent may be + added in future. + + The filtering opportunity is always given to the input context as + soon as possible. It has to be taken place before any other key + event consumers such as eventfilters and accelerators because some + input methods require quite various key combination and + sequences. It often conflicts with accelerators and so on, so we + must give the input context the filtering opportunity first to + ensure all input methods work properly regardless of application + design. + + Ordinary input methods require discrete key events to work + properly, so TQt's key compression is always disabled for any input + contexts. + + \sa TQKeyEvent, x11FilterEvent() +*/ +bool TQInputContext::filterEvent( const TQEvent *event ) +{ + return FALSE; +} + + +/*! + \fn void TQInputContext::deletionRequested() + + Emit this signal when a fatal error has been caused in the input + context. The input context will be deleted by the owner which is + usually the holder widget. +*/ + +/*! + \fn void TQInputContext::imEventGenerated( TQObject *receiver, TQIMEvent *e ) + + \internal + This signal is emitted when the user has sent a TQIMEvent through + sendIMEvent(). Ordinary input methods should not emit this signal + directly. + + \a receiver is a platform dependent destination of the \a e. + + \sa TQIMEvent, sendIMEvent(), sendIMEventInternal(), +*/ + +/*! + \internal + Sends a TQIMEvent to the client via imEventGenerated() + signal. Ordinary input method should not call this function + directly. + + \sa TQIMEvent, TQIMComposeEvent, sendIMEvent(), imEventGenerated() +*/ +void TQInputContext::sendIMEventInternal( TQEvent::Type type, + const TQString &text, + int cursorPosition, int selLength ) +{ + TQObject *receiver = 0; + TQIMEvent *event = 0; + +#if defined(TQ_WS_X11) + receiver = d->composingWidget; +#elif defined(TQ_WS_TQWS) + // just a placeholder +#endif + if ( ! receiver ) + return; + + if ( type == TQEvent::IMStart ) { + qDebug( "sending IMStart with %d chars to %p", + text.length(), receiver ); + event = new TQIMEvent( type, text, cursorPosition ); + } else if ( type == TQEvent::IMEnd ) { + qDebug( "sending IMEnd with %d chars to %p, text=%s", + text.length(), receiver, (const char*)text.local8Bit() ); + event = new TQIMEvent( type, text, cursorPosition ); + } else if ( type == TQEvent::IMCompose ) { + qDebug( "sending IMCompose to %p with %d chars, cpos=%d, sellen=%d, text=%s", + receiver, text.length(), cursorPosition, selLength, + (const char*)text.local8Bit() ); + event = new TQIMComposeEvent( type, text, cursorPosition, selLength ); + } + + if ( event ) + emit imEventGenerated( receiver, event ); +} + + +/*! + Call this function to send TQIMEvent to the text widget. This + function constructs a TQIMEvent based on the arguments and send it + to the appropriate widget. Ordinary input method should not + reimplement this function. + + \a type is either \c TQEvent::IMStart or \c TQEvent::IMCompose or \c + TQEvent::IMEnd. You have to send a \c TQEvent::IMStart to start + composing, then send several \c TQEvent::IMCompose to update the + preedit of the widget, and finalize the composition with sending + \c TQEvent::IMEnd. + + \c TQEvent::IMStart should always be sent without arguments as: + \code + sendIMEvent( TQEvent::IMStart ) + \endcode + + And \c TQEvent::IMCompose can be sent without cursor: + \code + sendIMEvent( TQEvent::IMCompose, TQString( "a text" ) ) + \endcode + + Or optionally with cursor with \a cursorPosition: + \code + sendIMEvent( TQEvent::IMCompose, TQString( "a text with cursor" ), 12 ) + \endcode + Note that \a cursorPosition also specifies microfocus position. + + Or optionally with selection text: + \code + sendIMEvent( TQEvent::IMCompose, TQString( "a text with selection" ), 12, 9 ) + \endcode + \a cursorPosition and \a selLength must be within the \a text. The + \a cursorPosition also specifies microfocus position in the case: + + \c TQEvent::IMEnd can be sent without arguments to terminate the + composition with null string: + \code + sendIMEvent( TQEvent::IMEnd ) + \endcode + + Or optionally accepts \a text to commit a string: + \code + sendIMEvent( TQEvent::IMEnd, TQString( "a text" ) ) + \endcode + + \sa TQIMEvent, TQIMComposeEvent, setMicroFocus() +*/ +void TQInputContext::sendIMEvent( TQEvent::Type type, const TQString &text, + int cursorPosition, int selLength ) +{ +#if defined(TQ_WS_X11) + if ( !tqfocusWidget() ) + return; +#endif + + if ( type == TQEvent::IMStart ) { + sendIMEventInternal( type, text, cursorPosition, selLength ); + d->isComposing = TRUE; + } else if ( type == TQEvent::IMEnd ) { + d->resetComposingState(); + sendIMEventInternal( type, text, cursorPosition, selLength ); + } else if ( type == TQEvent::IMCompose ) { + d->updateComposingState( text, cursorPosition, selLength ); + sendIMEventInternal( type, text, cursorPosition, selLength ); + } +} + + +/*! + This function can be reimplemented in a subclass to detect + that the input context has been focused on. + + The input context will receive input events through + x11FilterEvent() and filterEvent() after setFocus() until + unsetFocus() has been called. + + an input context is ensured that setFocus() is called exactly once + until unsetFocus() has been called even if preedit relocation has + occurred. This means that an input focus will survive between + several widgets that sharing the input context. + + On the X11 platform, tqfocusWidget is already set before this + function has been called. + + \sa unsetFocus() +*/ +void TQInputContext::setFocus() +{ +} + + +/*! + This function can be reimplemented in a subclass to detect + that the input context has lost the focus. + + an input context is ensured that unsetFocus() is not called during + preedit relocation. This means that an input focus will survive + between several widgets that sharing the input context. + + Default implementation that calls reset() is sufficient for simple + input methods. You can override this function to alter the + behavior. For example, most Japanese input contexts should not be + reset on losing focus. The context sometimes contains a whole + paragraph and has minutes of lifetime different to ephemeral one + in other languages. The piled input context should be survived + until focused again since Japanese user naturally expects so. + + On the X11 platform, tqfocusWidget is valid until this function has + been returned. + + \sa setFocus() +*/ +void TQInputContext::unsetFocus() +{ + reset(); +} + + +/*! + This function can be implemented in a subclass to handle + microfocus changes. + + 'microfocus' stands for the input method focus point in the + preedit (XIM "spot" point) for complex language input handling. It + can be used to place auxiliary GUI widgets such as candidate + selection window. + + \a x, \a y, \a w and \a h represents the position and size of the + cursor in the preedit string. \a f is the font on the location of + the cursor. +*/ +void TQInputContext::setMicroFocus( int x, int y, int w, int h, TQFont *f ) +{ +} + + +/*! + This function can be reimplemented in a subclass to handle mouse + presses/releases/doubleclicks/moves within the preedit text. You + can use the function to implement mouse-oriented user interface + such as text selection or popup menu for candidate selection. + + The parameter \a x is the offset within the string that was sent + with the IMCompose event. The alteration boundary of \a x is + ensured as character boundary of preedit string accurately. + + \a type is either \c TQEvent::MouseButtonPress or \c + TQEvent::MouseButtonRelease or \c TQEvent::MouseButtonDblClick or \c + TQEvent::MouseButtonMove. Refer \a button and \a state to determine + what operation has performed. + + The method interface is imported from + TQWSInputMethod::mouseHandler() of TQt/Embedded 2.3.7 and extended + for desktop system. + */ +void TQInputContext::mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ) +{ + // Default behavior for simple ephemeral input contexts. Some + // complex input contexts should not be reset here. + if ( type == TQEvent::MouseButtonPress || + type == TQEvent::MouseButtonDblClick ) + reset(); +} + + +/*! + Returns the font of the current input widget + */ +TQFont TQInputContext::font() const +{ + if ( !tqfocusWidget() ) + return TQApplication::font(); //### absolutely last resort + + return tqfocusWidget()->font(); +} + + +/*! + This function can be reimplemented in a subclass to reset the + state of the input method. + + This function is called by several widgets to reset input + state. For example, a text widget call this function before + inserting a text to make widget ready to accept a text. + + Default implementation is sufficient for simple input method. You + can override this function to reset external input method engines + in complex input method. In the case, call TQInputContext::reset() + to ensure proper termination of inputting. + + You must not send any TQIMEvent except empty IMEnd event using + TQInputContext::reset() at reimplemented reset(). It will break + input state consistency. +*/ +void TQInputContext::reset() +{ + if ( isComposing() ) + sendIMEvent( TQEvent::IMEnd ); +} + + +/*! + This function must be implemented in any subclasses to return the + identifier name of the input method. + + Return value is the name to identify and specify input methods for + the input method switching mechanism and so on. The name has to be + consistent with TQInputContextPlugin::keys(). The name has to + consist of ASCII characters only. + + There are two different names with different responsibility in the + input method domain. This function returns one of them. Another + name is called 'display name' that stands for the name for + endusers appeared in a menu and so on. + + \sa TQInputContextPlugin::keys(), TQInputContextPlugin::displayName() +*/ +TQString TQInputContext::identifierName() +{ + return ""; +} + + +/*! + This function must be implemented in any subclasses to return a + language code (e.g. "zh_CN", "zh_TW", "zh_HK", "ja", "ko", ...) + of the input context. If the input context can handle multiple + languages, return the currently used one. The name has to be + consistent with TQInputContextPlugin::language(). + + This information will be used by language tagging feature in + TQIMEvent. It is required to distinguish unified han characters + correctly. It enables proper font and character code + handling. Suppose CJK-awared multilingual web browser + (that automatically modifies fonts in CJK-mixed text) and XML editor + (that automatically inserts lang attr). + + \sa TQInputContextPlugin::language() +*/ +TQString TQInputContext::language() +{ + return ""; +} + + +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) +/*! + This is a preliminary interface for TQt4 + */ +TQList TQInputContext::actions() +{ +} +#else +/*! + This function can be reimplemented in a subclass to provide input + method dependent popup menus. Return 0 if the menus are + unnecessary. + + Ownership of the object and tqchildren are transferred to the + caller, and the result must not be called + setAutoDelete(). TQInputContextMenu::title is used for label text + of the popup menu as submenu. + + \sa addMenusTo() +*/ +TQPtrList *TQInputContext::menus() +{ + return 0; +} +#endif + +/*! + Appends input method dependent submenus into \a popup. A separator + is also inserted into \a popup if \a action is InsertSeparator. + + This is an utility function only for convenience in limited + situation. This function is used by input context owner such as + text widgets to add the submenus to its own context menu. If you + want to insert the submenus in more flexible way, use + TQInputContext::menus() manually. \a popup is not restricted to + context menu of a text widget. For example, the owner may be a + input method menu of TQtopia taskbar in TQt/Embedded platform. + + \sa menus(), TQInputContextMenu::Action +*/ +void TQInputContext::addMenusTo( TQPopupMenu *popup, TQInputContextMenu::Action action ) +{ + if ( ! popup ) + return; + + TQPtrList *imMenus = menus(); + if ( imMenus ) { + if ( action == TQInputContextMenu::InsertSeparator ) + popup->insertSeparator(); + for ( TQPtrList::Iterator it = imMenus->begin(); + it != imMenus->end(); + ++it ) { + TQInputContextMenu *imMenu = *it; + popup->insertItem( imMenu->title, imMenu->popup ); + } + imMenus->clear(); + delete imMenus; + } +} + +#endif //TQ_NO_IM diff --git a/tqtinterface/qt4/src/kernel/tqinputcontext.h b/tqtinterface/qt4/src/kernel/tqinputcontext.h new file mode 100644 index 0000000..9dbd9bf --- /dev/null +++ b/tqtinterface/qt4/src/kernel/tqinputcontext.h @@ -0,0 +1,143 @@ +/**************************************************************************** +** $Id: qinputcontext.h,v 1.8 2004/06/22 06:47:30 daisuke Exp $ +** +** Definition of TQInputContext +** +** Copyright (C) 1992-2002 Trolltech AS. All rights reserved. +** +** This file is part of the kernel module of the TQt GUI Toolkit. +** +** This file may be distributed under the terms of the Q Public License +** as defined by Trolltech AS of Norway and appearing in the file +** LICENSE.TQPL included in the packaging of this file. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** Licensees holding valid TQt Enterprise Edition or TQt Professional Edition +** licenses may use this file in accordance with the TQt Commercial License +** Agreement provided with the Software. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for +** information about TQt Commercial License Agreements. +** See http://www.trolltech.com/qpl/ for TQPL licensing information. +** 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 TQINPUTCONTEXT_H +#define TQINPUTCONTEXT_H + +#ifndef TQT_NO_IM + +#ifndef TQT_H +#include "tqobject.h" +#include "tqglobal.h" +#include "tqevent.h" +#include "tqstring.h" +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) +#include "tqlist.h" +#include "tqaction.h" +#else +#include "tqptrlist.h" +#endif +#endif + +class TQWidget; +class TQFont; +class TQPopupMenu; +class TQInputContextPrivate; + + +struct TQInputContextMenu { + enum Action { + NoSeparator, + InsertSeparator + }; +#if !([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) + TQString title; + TQPopupMenu *popup; +#endif +}; + + +class TQInputContext : public TQObject +{ + TQ_OBJECT +public: + TQInputContext( TQObject *tqparent = 0 ); + virtual ~TQInputContext(); + + virtual TQString identifierName(); + virtual TQString language(); + +#if defined(TQ_WS_X11) + virtual bool x11FilterEvent( TQWidget *keywidget, XEvent *event ); +#endif // TQ_WS_X11 + virtual bool filterEvent( const TQEvent *event ); + virtual void reset(); + + virtual void setFocus(); + virtual void unsetFocus(); + virtual void setMicroFocus( int x, int y, int w, int h, TQFont *f = 0 ); + virtual void mouseHandler( int x, TQEvent::Type type, + TQt::ButtonState button, TQt::ButtonState state ); + virtual TQFont font() const; + virtual bool isComposing() const; + virtual bool isPreeditRelocationEnabled(); + +#if ([[[TQT_VERSION IS DEPRECATED]]]-0 >= 0x040000) + virtual TQList actions(); + void addActionsTo( TQMenu *menu, TQInputContextMenu::Action action = TQInputContextMenu::InsertSeparator ); +#else + virtual TQPtrList *menus(); + void addMenusTo( TQPopupMenu *popup, TQInputContextMenu::Action action = TQInputContextMenu::InsertSeparator ); +#endif + +#if defined(TQ_WS_X11) + // these functions are not recommended for ordinary use + virtual TQWidget *tqfocusWidget() const; + virtual TQWidget *holderWidget() const; + + // these functions must not be used by ordinary input method + virtual void setFocusWidget( TQWidget *w ); + virtual void setHolderWidget( TQWidget *w ); + virtual void releaseComposingWidget( TQWidget *w ); +#endif + +signals: + void deletionRequested(); + void imEventGenerated( TQObject *receiver, TQIMEvent *e ); + +protected: + virtual void sendIMEvent( TQEvent::Type type, + const TQString &text = TQString(), + int cursorPosition = -1, int selLength = 0 ); + +private: + void sendIMEventInternal( TQEvent::Type type, + const TQString &text = TQString(), + int cursorPosition = -1, int selLength = 0 ); + + TQInputContextPrivate *d; + + friend class TQWidget; + friend class TQInputContextFactory; + +private: // Disabled copy constructor and operator= + TQInputContext( const TQInputContext & ); + TQInputContext &operator=( const TQInputContext & ); + +}; + +#endif //TQ_NO_IM + +#endif // TQINPUTCONTEXT_H diff --git a/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp b/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp index 758b56d..e96c75c 100644 --- a/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqinputcontext_x11.cpp @@ -36,500 +36,34 @@ ** **********************************************************************/ +#include "tqinputcontext.h" + +#ifndef TQT_NO_IM + #include "tqplatformdefs.h" #include "tqapplication.h" #include "tqwidget.h" -#include "tqinputcontext_p.h" - -#include -#include +#include "tqt_x11_p.h" -bool qt_compose_emptied = FALSE; +/*! + This function may be overridden only if input method is depending + on X11 and you need raw XEvent. Otherwise, this function must not. -#if !defined(TQT_NO_XIM) + This function is designed to filter raw key events for XIM, but + other input methods may use this to implement some special + features such as distinguishing Shift_L and Shift_R. -#define XK_MISCELLANY -#define XK_LATIN1 -#include + Return TRUE if the \a event has been consumed. Otherwise, the + unfiltered \a event will be translated into TQEvent and forwarded + to filterEvent(). Filtering at both x11FilterEvent() and + filterEvent() in single input method is allowed. -// #define TQT_XIM_DEBUG + \a keywidget is a client widget into which a text is inputted. \a + event is inputted XEvent. -// from qapplication_x11.cpp -extern XIM qt_xim; -extern XIMStyle qt_xim_style; - -/* The cache here is needed, as X11 leaks a few kb for every - XFreeFontSet call, so we avoid creating and deletion of fontsets as - much as possible + \sa filterEvent() */ -static XFontSet fontsetCache[8] = { 0, 0, 0, 0, 0, 0, 0, 0 }; -static int fontsetRefCount = 0; - -static const char * const fontsetnames[] = { - "-*-fixed-medium-r-*-*-16-*,-*-*-medium-r-*-*-16-*", - "-*-fixed-medium-i-*-*-16-*,-*-*-medium-i-*-*-16-*", - "-*-fixed-bold-r-*-*-16-*,-*-*-bold-r-*-*-16-*", - "-*-fixed-bold-i-*-*-16-*,-*-*-bold-i-*-*-16-*", - "-*-fixed-medium-r-*-*-24-*,-*-*-medium-r-*-*-24-*", - "-*-fixed-medium-i-*-*-24-*,-*-*-medium-i-*-*-24-*", - "-*-fixed-bold-r-*-*-24-*,-*-*-bold-r-*-*-24-*", - "-*-fixed-bold-i-*-*-24-*,-*-*-bold-i-*-*-24-*" -}; - -static XFontSet getFontSet( const TQFont &f ) -{ - int i = 0; - if (f.italic()) - i |= 1; - if (f.bold()) - i |= 2; - - if ( f.pointSize() > 20 ) - i += 4; - - if ( !fontsetCache[i] ) { - Display* dpy = TQPaintDevice::x11AppDisplay(); - int missCount; - char** missList; - fontsetCache[i] = XCreateFontSet(dpy, fontsetnames[i], &missList, &missCount, 0); - if(missCount > 0) - XFreeStringList(missList); - if ( !fontsetCache[i] ) { - fontsetCache[i] = XCreateFontSet(dpy, "-*-fixed-*-*-*-*-16-*", &missList, &missCount, 0); - if(missCount > 0) - XFreeStringList(missList); - if ( !fontsetCache[i] ) - fontsetCache[i] = (XFontSet)-1; - } - } - return (fontsetCache[i] == (XFontSet)-1) ? 0 : fontsetCache[i]; -} - - -#ifdef TQ_C_CALLBACKS -extern "C" { -#endif // TQ_C_CALLBACKS - - static int xic_start_callback(XIC, XPointer client_data, XPointer) { - TQInputContext *qic = (TQInputContext *) client_data; - if (! qic) { -#ifdef TQT_XIM_DEBUG - qDebug("compose start: no qic"); -#endif // TQT_XIM_DEBUG - - return 0; - } - - qic->composing = TRUE; - qic->text = TQString::null; - qic->tqfocusWidget = 0; - - if ( qic->selectedChars.size() < 128 ) - qic->selectedChars.resize( 128 ); - qic->selectedChars.fill( 0 ); - -#ifdef TQT_XIM_DEBUG - qDebug("compose start"); -#endif // TQT_XIM_DEBUG - - return 0; - } - - static int xic_draw_callback(XIC, XPointer client_data, XPointer call_data) { - TQInputContext *qic = (TQInputContext *) client_data; - if (! qic) { -#ifdef TQT_XIM_DEBUG - qDebug("compose event: invalid compose event %p", qic); -#endif // TQT_XIM_DEBUG - - return 0; - } - - bool send_imstart = FALSE; - if (tqApp->tqfocusWidget() != qic->tqfocusWidget && qic->text.isEmpty()) { - if (qic->tqfocusWidget) { -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMEnd (empty) to %p", qic->tqfocusWidget ); -#endif // TQT_XIM_DEBUG - - TQIMEvent endevent(TQEvent::IMEnd, TQString::null, -1); - TQApplication::sendEvent(qic->tqfocusWidget, &endevent); - } - - qic->text = TQString::null; - qic->tqfocusWidget = tqApp->tqfocusWidget(); - qic->composing = FALSE; - - if ( qic->selectedChars.size() < 128 ) - qic->selectedChars.resize( 128 ); - qic->selectedChars.fill( 0 ); - - if (qic->tqfocusWidget) { - qic->composing = TRUE; - send_imstart = TRUE; - } - } - - if (! qic->composing || ! qic->tqfocusWidget) { -#ifdef TQT_XIM_DEBUG - qDebug("compose event: invalid compose event %d %p", - qic->composing, qic->tqfocusWidget); -#endif // TQT_XIM_DEBUG - - return 0; - } - - if ( send_imstart ) { -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMStart to %p", qic->tqfocusWidget ); -#endif // TQT_XIM_DEBUG - - qt_compose_emptied = FALSE; - TQIMEvent startevent(TQEvent::IMStart, TQString::null, -1); - TQApplication::sendEvent(qic->tqfocusWidget, &startevent); - } - - XIMPreeditDrawCallbackStruct *drawstruct = - (XIMPreeditDrawCallbackStruct *) call_data; - XIMText *text = (XIMText *) drawstruct->text; - int cursor = drawstruct->caret, sellen = 0; - - if ( ! drawstruct->caret && ! drawstruct->chg_first && - ! drawstruct->chg_length && ! text ) { - // nothing to do - return 0; - } - - if (text) { - char *str = 0; - if (text->encoding_is_wchar) { - int l = wcstombs(NULL, text->string.wide_char, text->length); - if (l != -1) { - str = new char[l + 1]; - wcstombs(str, text->string.wide_char, l); - str[l] = 0; - } - } else - str = text->string.multi_byte; - - if (! str) - return 0; - - TQString s = TQString::fromLocal8Bit(str); - - if (text->encoding_is_wchar) - delete [] str; - - if (drawstruct->chg_length < 0) - qic->text.tqreplace(drawstruct->chg_first, UINT_MAX, s); - else - qic->text.tqreplace(drawstruct->chg_first, drawstruct->chg_length, s); - - if ( qic->selectedChars.size() < qic->text.length() ) { - // expand the selectedChars array if the compose string is longer - uint from = qic->selectedChars.size(); - qic->selectedChars.resize( qic->text.length() ); - for ( uint x = from; from < qic->selectedChars.size(); ++x ) - qic->selectedChars[x] = 0; - } - - uint x; - bool *p = qic->selectedChars.data() + drawstruct->chg_first; - // determine if the changed chars are selected based on text->feedback - for ( x = 0; x < s.length(); ++x ) - *p++ = ( text->feedback ? ( text->feedback[x] & XIMReverse ) : 0 ); - - // figure out where the selection starts, and how long it is - p = qic->selectedChars.data(); - bool started = FALSE; - for ( x = 0; x < TQMIN(qic->text.length(), qic->selectedChars.size()); ++x ) { - if ( started ) { - if ( *p ) ++sellen; - else break; - } else { - if ( *p ) { - cursor = x; - started = TRUE; - sellen = 1; - } - } - ++p; - } - } else { - if (drawstruct->chg_length == 0) - drawstruct->chg_length = -1; - - qic->text.remove(drawstruct->chg_first, drawstruct->chg_length); - qt_compose_emptied = qic->text.isEmpty(); - if ( qt_compose_emptied ) { -#ifdef TQT_XIM_DEBUG - qDebug( "compose emptied" ); -#endif // TQT_XIM_DEBUG - - // don't send an empty compose, since we will send an IMEnd with - // either the correct compose text (or null text if the user has - // cancelled the compose or deleted all chars). - return 0; - } - } - -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMCompose to %p with %d chars", - qic->tqfocusWidget, qic->text.length() ); -#endif // TQT_XIM_DEBUG - - TQIMComposeEvent event( TQEvent::IMCompose, qic->text, cursor, sellen ); - TQApplication::sendEvent(qic->tqfocusWidget, &event); - return 0; - } - - static int xic_done_callback(XIC, XPointer client_data, XPointer) { - TQInputContext *qic = (TQInputContext *) client_data; - if (! qic) - return 0; - - if (qic->composing && qic->tqfocusWidget) { -#ifdef TQT_XIM_DEBUG - qDebug( "sending IMEnd (empty) to %p", qic->tqfocusWidget ); -#endif // TQT_XIM_DEBUG - - TQIMEvent event(TQEvent::IMEnd, TQString::null, -1); - TQApplication::sendEvent(qic->tqfocusWidget, &event); - } - - qic->composing = FALSE; - qic->tqfocusWidget = 0; - - if ( qic->selectedChars.size() < 128 ) - qic->selectedChars.resize( 128 ); - qic->selectedChars.fill( 0 ); - - return 0; - } - -#ifdef TQ_C_CALLBACKS -} -#endif // TQ_C_CALLBACKS - -#endif // !TQT_NO_XIM - - - -TQInputContext::TQInputContext(TQWidget *widget) - : ic(0), tqfocusWidget(0), composing(FALSE), fontset(0) -{ -#if !defined(TQT_NO_XIM) - fontsetRefCount++; - if (! qt_xim) { - qWarning("TQInputContext: no input method context available"); - return; - } - - if (! widget->isTopLevel()) { - qWarning("TQInputContext: cannot create input context for non-toplevel widgets"); - return; - } - - XPoint spot; - XRectangle rect; - XVaNestedList preedit_attr = 0; - XIMCallback startcallback, drawcallback, donecallback; - - font = widget->font(); - fontset = getFontSet( font ); - - if (qt_xim_style & XIMPreeditArea) { - rect.x = 0; - rect.y = 0; - rect.width = widget->width(); - rect.height = widget->height(); - - preedit_attr = XVaCreateNestedList(0, - XNArea, &rect, - XNFontSet, fontset, - (char *) 0); - } else if (qt_xim_style & XIMPreeditPosition) { - spot.x = 1; - spot.y = 1; - - preedit_attr = XVaCreateNestedList(0, - XNSpotLocation, &spot, - XNFontSet, fontset, - (char *) 0); - } else if (qt_xim_style & XIMPreeditCallbacks) { - startcallback.client_data = (XPointer) this; - startcallback.callback = (XIMProc) xic_start_callback; - drawcallback.client_data = (XPointer) this; - drawcallback.callback = (XIMProc)xic_draw_callback; - donecallback.client_data = (XPointer) this; - donecallback.callback = (XIMProc) xic_done_callback; - - preedit_attr = XVaCreateNestedList(0, - XNPreeditStartCallback, &startcallback, - XNPreeditDrawCallback, &drawcallback, - XNPreeditDoneCallback, &donecallback, - (char *) 0); - } - - if (preedit_attr) { - ic = XCreateIC(qt_xim, - XNInputStyle, qt_xim_style, - XNClientWindow, widget->winId(), - XNPreeditAttributes, preedit_attr, - (char *) 0); - XFree(preedit_attr); - } else - ic = XCreateIC(qt_xim, - XNInputStyle, qt_xim_style, - XNClientWindow, widget->winId(), - (char *) 0); - - if (! ic) - qFatal("Failed to create XIM input context!"); - - // when resetting the input context, preserve the input state - (void) XSetICValues((XIC) ic, XNResetState, XIMPreserveState, (char *) 0); -#endif // !TQT_NO_XIM -} - - -TQInputContext::~TQInputContext() -{ - -#if !defined(TQT_NO_XIM) - if (ic) - XDestroyIC((XIC) ic); - - if ( --fontsetRefCount == 0 ) { - Display *dpy = TQPaintDevice::x11AppDisplay(); - for ( int i = 0; i < 8; i++ ) { - if ( fontsetCache[i] && fontsetCache[i] != (XFontSet)-1 ) { - XFreeFontSet(dpy, fontsetCache[i]); - fontsetCache[i] = 0; - } - } - } - -#endif // !TQT_NO_XIM - - ic = 0; - tqfocusWidget = 0; - composing = FALSE; -} - - -void TQInputContext::reset() -{ -#if !defined(TQT_NO_XIM) - if (tqfocusWidget && composing && ! text.isNull()) { -#ifdef TQT_XIM_DEBUG - qDebug("TQInputContext::reset: composing - sending IMEnd (empty) to %p", - tqfocusWidget); -#endif // TQT_XIM_DEBUG - - TQIMEvent endevent(TQEvent::IMEnd, TQString::null, -1); - TQApplication::sendEvent(tqfocusWidget, &endevent); - tqfocusWidget = 0; - text = TQString::null; - if ( selectedChars.size() < 128 ) - selectedChars.resize( 128 ); - selectedChars.fill( 0 ); - - char *mb = XmbResetIC((XIC) ic); - if (mb) - XFree(mb); - } -#endif // !TQT_NO_XIM -} - - -void TQInputContext::setComposePosition(int x, int y) -{ -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) { - XPoint point; - point.x = x; - point.y = y; - - XVaNestedList preedit_attr = - XVaCreateNestedList(0, - XNSpotLocation, &point, - - (char *) 0); - XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); - XFree(preedit_attr); - } -#endif // !TQT_NO_XIM -} - - -void TQInputContext::setComposeArea(int x, int y, int w, int h) -{ -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) { - XRectangle rect; - rect.x = x; - rect.y = y; - rect.width = w; - rect.height = h; - - XVaNestedList preedit_attr = XVaCreateNestedList(0, - XNArea, &rect, - - (char *) 0); - XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); - XFree(preedit_attr); - } -#endif -} - - -int TQInputContext::lookupString(XKeyEvent *event, TQCString &chars, - KeySym *key, Status *status) const -{ - int count = 0; - -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) { - count = XmbLookupString((XIC) ic, event, chars.data(), - chars.size(), key, status); - - if ((*status) == XBufferOverflow ) { - chars.resize(count + 1); - count = XmbLookupString((XIC) ic, event, chars.data(), - chars.size(), key, status); - } - } - -#endif // TQT_NO_XIM - - return count; -} - -void TQInputContext::setFocus() -{ -#if !defined(TQT_NO_XIM) - if (qt_xim && ic) - XSetICFocus((XIC) ic); -#endif // !TQT_NO_XIM -} - -void TQInputContext::setXFontSet(const TQFont &f) -{ -#if !defined(TQT_NO_XIM) - if (font == f) return; // nothing to do - font = f; - - XFontSet fs = getFontSet(font); - if (fontset == fs) return; // nothing to do - fontset = fs; - XVaNestedList preedit_attr = XVaCreateNestedList(0, XNFontSet, fontset, (char *) 0); - XSetICValues((XIC) ic, XNPreeditAttributes, preedit_attr, (char *) 0); - XFree(preedit_attr); -#else - TQ_UNUSED( f ); -#endif -} +#endif //TQ_NO_IM \ No newline at end of file diff --git a/tqtinterface/qt4/src/kernel/tqnamespace.h b/tqtinterface/qt4/src/kernel/tqnamespace.h index b158936..d3919c9 100644 --- a/tqtinterface/qt4/src/kernel/tqnamespace.h +++ b/tqtinterface/qt4/src/kernel/tqnamespace.h @@ -512,7 +512,8 @@ typedef Qt::Orientation Orientation; #ifdef TQT_NO_COMPAT enum GUIStyle { WindowsStyle = 1, // ### TQt 4.0: either remove the obsolete enums or clean up compat vs. - MotifStyle = 4 // ### TQT_NO_COMPAT by reordering or combination into one enum. + MotifStyle = 4, // ### TQT_NO_COMPAT by reordering or combination into one enum. + GtkStyle = 6 // Gtk compability mode }; #else enum GUIStyle { @@ -520,7 +521,8 @@ typedef Qt::Orientation Orientation; WindowsStyle, Win3Style, // OBSOLETE PMStyle, // OBSOLETE - MotifStyle + MotifStyle, + GtkStyle = 6 // Gtk compability mode }; #endif @@ -631,6 +633,87 @@ typedef Qt::Orientation Orientation; Key_Help = (int)Qt::Key_Help, Key_Direction_L = (int)Qt::Key_Direction_L, Key_Direction_R = (int)Qt::Key_Direction_R, + + // International input method support (X keycode - 0xEE00, the + // definition follows TQt/Embedded 2.3.7) Only interesting if + // you are writing your own input method + + // International & multi-key character composition + Key_Multi_key = 0x1120, // Multi-key character compose + Key_Codeinput = 0x1137, + Key_SingleCandidate = 0x113c, + Key_MultipleCandidate = 0x113d, + Key_PreviousCandidate = 0x113e, + + // Misc Functions + Key_Mode_switch = 0x117e, // Character set switch + //Key_script_switch = 0x117e, // Alias for mode_switch + + // Japanese keyboard support + Key_Kanji = 0x1121, // Kanji, Kanji convert + Key_Muhenkan = 0x1122, // Cancel Conversion + //Key_Henkan_Mode = 0x1123, // Start/Stop Conversion + Key_Henkan = 0x1123, // Alias for Henkan_Mode + Key_Romaji = 0x1124, // to Romaji + Key_Hiragana = 0x1125, // to Hiragana + Key_Katakana = 0x1126, // to Katakana + Key_Hiragana_Katakana = 0x1127, // Hiragana/Katakana toggle + Key_Zenkaku = 0x1128, // to Zenkaku + Key_Hankaku = 0x1129, // to Hankaku + Key_Zenkaku_Hankaku = 0x112a, // Zenkaku/Hankaku toggle + Key_Touroku = 0x112b, // Add to Dictionary + Key_Massyo = 0x112c, // Delete from Dictionary + Key_Kana_Lock = 0x112d, // Kana Lock + Key_Kana_Shift = 0x112e, // Kana Shift + Key_Eisu_Shift = 0x112f, // Alphanumeric Shift + Key_Eisu_toggle = 0x1130, // Alphanumeric toggle + //Key_Kanji_Bangou = 0x1137, // Codeinput + //Key_Zen_Koho = 0x113d, // Multiple/All Candidate(s) + //Key_Mae_Koho = 0x113e, // Previous Candidate + + // Korean keyboard support + // + // In fact, many Korean users need only 2 keys, Key_Hangul and + // Key_Hangul_Hanja. But rest of the keys are good for future. + + Key_Hangul = 0x1131, // Hangul start/stop(toggle) + Key_Hangul_Start = 0x1132, // Hangul start + Key_Hangul_End = 0x1133, // Hangul end, English start + Key_Hangul_Hanja = 0x1134, // Start Hangul->Hanja Conversion + Key_Hangul_Jamo = 0x1135, // Hangul Jamo mode + Key_Hangul_Romaja = 0x1136, // Hangul Romaja mode + //Key_Hangul_Codeinput = 0x1137, // Hangul code input mode + Key_Hangul_Jeonja = 0x1138, // Jeonja mode + Key_Hangul_Banja = 0x1139, // Banja mode + Key_Hangul_PreHanja = 0x113a, // Pre Hanja conversion + Key_Hangul_PostHanja = 0x113b, // Post Hanja conversion + //Key_Hangul_SingleCandidate = 0x113c, // Single candidate + //Key_Hangul_MultipleCandidate = 0x113d, // Multiple candidate + //Key_Hangul_PreviousCandidate = 0x113e, // Previous candidate + Key_Hangul_Special = 0x113f, // Special symbols + //Key_Hangul_switch = 0x117e, // Alias for mode_switch + + // dead keys (X keycode - 0xED00 to avoid the conflict) + Key_Dead_Grave = 0x1250, + Key_Dead_Acute = 0x1251, + Key_Dead_Circumflex = 0x1252, + Key_Dead_Tilde = 0x1253, + Key_Dead_Macron = 0x1254, + Key_Dead_Breve = 0x1255, + Key_Dead_Abovedot = 0x1256, + Key_Dead_Diaeresis = 0x1257, + Key_Dead_Abovering = 0x1258, + Key_Dead_Doubleacute = 0x1259, + Key_Dead_Caron = 0x125a, + Key_Dead_Cedilla = 0x125b, + Key_Dead_Ogonek = 0x125c, + Key_Dead_Iota = 0x125d, + Key_Dead_Voiced_Sound = 0x125e, + Key_Dead_Semivoiced_Sound = 0x125f, + Key_Dead_Belowdot = 0x1260, + Key_Dead_Hook = 0x1261, + Key_Dead_Horn = 0x1262, + Key_Space = (int)Qt::Key_Space, // 7 bit printable ASCII Key_Any = Key_Space, Key_Exclam = (int)Qt::Key_Exclam, @@ -703,6 +786,11 @@ typedef Qt::Orientation Orientation; Key_AsciiTilde = (int)Qt::Key_AsciiTilde, // Latin 1 codes adapted from X: keysymdef.h,v 1.21 94/08/28 16:17:06 + // + // This is mainly for compatibility - applications and input + // methods should not use the TQt keycodes between 128 and 255, + // but should rather use the TQKeyEvent::text(). See + // TQETWidget::translateKeyEventInternal() for more details. Key_nobreakspace = (int)Qt::Key_nobreakspace, Key_exclamdown = (int)Qt::Key_exclamdown, diff --git a/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp b/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp index 2432607..fd4cc0b 100644 --- a/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqpaintdevice_x11.cpp @@ -1105,11 +1105,16 @@ static void create_dpis() TQ_CHECK_PTR( dpisX ); TQ_CHECK_PTR( dpisY ); for ( i = 0; i < screens; i++ ) { - dpisX[ i ] = (DisplayWidth(dpy,i) * 254 + DisplayWidthMM(dpy,i)*5) - - / (DisplayWidthMM(dpy,i)*10); - dpisY[ i ] = (DisplayHeight(dpy,i) * 254 + DisplayHeightMM(dpy,i)*5) - / (DisplayHeightMM(dpy,i)*10); + if (DisplayWidthMM(dpy,i) < 1) + dpisX[ i ] = 75; // default the dpi to 75. + else + dpisX[ i ] = (DisplayWidth(dpy,i) * 254 + DisplayWidthMM(dpy,i)*5) + / (DisplayWidthMM(dpy,i)*10); + if (DisplayHeightMM(dpy,i) < 1) + dpisY[ i ] = 75; // default the dpi to 75. + else + dpisY[ i ] = (DisplayHeight(dpy,i) * 254 + DisplayHeightMM(dpy,i)*5) + / (DisplayHeightMM(dpy,i)*10); } } diff --git a/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp b/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp index 974f23c..2a497e5 100644 --- a/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqpixmap_x11.cpp @@ -40,7 +40,19 @@ // NOT REVISED +#include "tqplatformdefs.h" + +#if defined(Q_OS_WIN32) && defined(TQT_MITSHM) +#undef TQT_MITSHM +#endif + +#ifdef TQT_MITSHM + +// Use the MIT Shared Memory extension for pixmap<->image conversions +#define TQT_MITSHM_CONVERSIONS + // Uncomment the next line to enable the MIT Shared Memory extension +// for TQPixmap::xForm() // // WARNING: This has some problems: // @@ -48,7 +60,7 @@ // 2. TQt does not handle the ShmCompletion message, so you will // get strange effects if you xForm() repeatedly. // -// #define TQT_MITSHM +// #define TQT_MITSHM_XFORM #if defined(TQ_OS_WIN32) && defined(TQT_MITSHM) #undef TQT_MITSHM @@ -131,7 +143,7 @@ inline static void qSafeXDestroyImage( XImage *x ) MIT Shared Memory Extension support: makes xForm noticeably (~20%) faster. *****************************************************************************/ -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) static bool xshminit = FALSE; static XShmSegmentInfo xshminfo; @@ -213,8 +225,100 @@ static bool qt_create_mitshm_buffer( const TQPaintDevice* dev, int w, int h ) // return FALSE; // } -#endif // TQT_MITSHM +#endif // TQT_MITSHM_XFORM + +#ifdef TQT_MITSHM_CONVERSIONS + +static bool qt_mitshm_error = false; +static int qt_mitshm_errorhandler( Display*, XErrorEvent* ) +{ + qt_mitshm_error = true; + return 0; +} + +static XImage* qt_XShmCreateImage( Display* dpy, Visual* visual, unsigned int depth, + int format, int /*offset*/, char* /*data*/, unsigned int width, unsigned int height, + int /*bitmap_pad*/, int /*bytes_per_line*/, XShmSegmentInfo* shminfo ) +{ + if( width * height * depth < 100*100*32 ) + return NULL; + static int shm_inited = -1; + if( shm_inited == -1 ) { + if( XShmQueryExtension( dpy )) + shm_inited = 1; + else + shm_inited = 0; + } + if( shm_inited == 0 ) + return NULL; + XImage* xi = XShmCreateImage( dpy, visual, depth, format, NULL, shminfo, width, + height ); + if( xi == NULL ) + return NULL; + shminfo->shmid = shmget( IPC_PRIVATE, xi->bytes_per_line * xi->height, + IPC_CREAT|0600); + if( shminfo->shmid < 0 ) { + XDestroyImage( xi ); + return NULL; + } + shminfo->readOnly = False; + shminfo->shmaddr = (char*)shmat( shminfo->shmid, 0, 0 ); + if( shminfo->shmaddr == (char*)-1 ) { + XDestroyImage( xi ); + shmctl( shminfo->shmid, IPC_RMID, 0 ); + return NULL; + } + xi->data = shminfo->shmaddr; +#ifndef TQT_MITSHM_RMID_IGNORES_REFCOUNT + // mark as deleted to automatically free the memory in case + // of a crash (but this doesn't work e.g. on Solaris) + shmctl( shminfo->shmid, IPC_RMID, 0 ); +#endif + if( shm_inited == 1 ) { // first time + XErrorHandler old_h = XSetErrorHandler( qt_mitshm_errorhandler ); + XShmAttach( dpy, shminfo ); + shm_inited = 2; + XSync( dpy, False ); + XSetErrorHandler( old_h ); + if( qt_mitshm_error ) { // oops ... perhaps we are remote? + shm_inited = 0; + XDestroyImage( xi ); + shmdt( shminfo->shmaddr ); +#ifdef TQT_MITSHM_RMID_IGNORES_REFCOUNT + shmctl( shminfo->shmid, IPC_RMID, 0 ); +#endif + return NULL; + } + } else + XShmAttach( dpy, shminfo ); + return xi; +} + +static void qt_XShmDestroyImage( XImage* xi, XShmSegmentInfo* shminfo ) +{ + XShmDetach( TQPaintDevice::x11AppDisplay(), shminfo ); + XDestroyImage( xi ); + shmdt( shminfo->shmaddr ); +#ifdef TQT_MITSHM_RMID_IGNORES_REFCOUNT + shmctl( shminfo->shmid, IPC_RMID, 0 ); +#endif +} +static XImage* qt_XShmGetImage( const TQPixmap* pix, int format, + XShmSegmentInfo* shminfo ) +{ + XImage* xi = qt_XShmCreateImage( pix->x11Display(), (Visual*)pix->x11Visual(), + pix->depth(), format, 0, 0, pix->width(), pix->height(), 32, 0, shminfo ); + if( xi == NULL ) + return NULL; + if( XShmGetImage( pix->x11Display(), pix->handle(), xi, 0, 0, AllPlanes ) == False ) { + qt_XShmDestroyImage( xi, shminfo ); + return NULL; + } + return xi; +} + +#endif // TQT_MITSHM_CONVERSIONS /***************************************************************************** Internal functions @@ -667,9 +771,20 @@ TQImage TQPixmap::convertToImage() const d = 32; // > 8 ==> 32 XImage *xi = (XImage *)data->ximage; // any cached ximage? - if ( !xi ) // fetch data from X server +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_ximage = false; + XShmSegmentInfo shminfo; +#endif + if ( !xi ) { // fetch data from X server +#ifdef TQT_MITSHM_CONVERSIONS + xi = qt_XShmGetImage( this, mono ? XYPixmap : ZPixmap, &shminfo ); + if( xi ) { + mitshm_ximage = true; + } else +#endif xi = XGetImage( x11Display(), hd, 0, 0, w, h, AllPlanes, mono ? XYPixmap : ZPixmap ); + } TQ_CHECK_PTR( xi ); if (!xi) return image; // null image @@ -680,15 +795,31 @@ TQImage TQPixmap::convertToImage() const TQImage::LittleEndian : TQImage::BigEndian; } image.create( w, h, d, 0, bitOrder ); - if ( image.isNull() ) // could not create image + if ( image.isNull() ) { // could not create image +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif + qSafeXDestroyImage( xi ); return image; + } const TQPixmap* msk = tqmask(); const TQPixmap *alf = data->alphapm; TQImage alpha; if (alf) { - XImage *axi = XGetImage(x11Display(), alf->hd, 0, 0, w, h, AllPlanes, ZPixmap); + XImage* axi; +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_aximage = false; + XShmSegmentInfo ashminfo; + axi = qt_XShmGetImage( alf, ZPixmap, &ashminfo ); + if( axi ) { + mitshm_aximage = true; + } else +#endif + axi = XGetImage(x11Display(), alf->hd, 0, 0, w, h, AllPlanes, ZPixmap); if (axi) { image.setAlphaBuffer( TRUE ); @@ -702,6 +833,11 @@ TQImage TQPixmap::convertToImage() const src += axi->bytes_per_line; } +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_aximage ) + qt_XShmDestroyImage( axi, &ashminfo ); + else +#endif qSafeXDestroyImage( axi ); } } else if (msk) { @@ -844,6 +980,12 @@ TQImage TQPixmap::convertToImage() const xi->bits_per_pixel ); #endif image.reset(); +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif + qSafeXDestroyImage( xi ); return image; } @@ -949,10 +1091,22 @@ TQImage TQPixmap::convertToImage() const delete [] carr; } if ( data->optim != BestOptim ) { // throw away image data +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif qSafeXDestroyImage( xi ); ((TQPixmap*)this)->data->ximage = 0; - } else // keep ximage data + } else { // keep ximage data +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) { // copy the XImage? + qt_XShmDestroyImage( xi, &shminfo ); + xi = 0; + } +#endif ((TQPixmap*)this)->data->ximage = xi; + } return image; } @@ -1125,6 +1279,11 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) bool trucol = (visual->c_class == TrueColor || visual->c_class == DirectColor); int nbytes = image.numBytes(); uchar *newbits= 0; + int newbits_size = 0; +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_ximage = false; + XShmSegmentInfo shminfo; +#endif if ( trucol ) { // truecolor display TQRgb pix[256]; // pixel translation table @@ -1153,19 +1312,24 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } } +#ifdef TQT_MITSHM_CONVERSIONS + xi = qt_XShmCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0, &shminfo ); + if( xi != NULL ) { + mitshm_ximage = true; + newbits = (uchar*)xi->data; + } + else +#endif xi = XCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0 ); - TQ_CHECK_PTR( xi ); if (!xi) return false; + if( newbits == NULL ) newbits = (uchar *)malloc( xi->bytes_per_line*h ); TQ_CHECK_PTR( newbits ); if ( !newbits ) // no memory return FALSE; int bppc = xi->bits_per_pixel; - if ( bppc > 8 && xi->byte_order == LSBFirst ) - bppc++; - bool contig_bits = n_bits(red_mask) == rbits && n_bits(green_mask) == gbits && n_bits(blue_mask) == bbits; @@ -1215,31 +1379,70 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) init=TRUE; } - for ( uint y=0; ybytes_per_line*y; - TQRgb* p = (TQRgb *)src; + enum { BPP8, + BPP16_8_3_M3, BPP16_7_2_M3, BPP16_MSB, BPP16_LSB, + BPP24_MSB, BPP24_LSB, + BPP32_16_8_0, BPP32_MSB, BPP32_LSB + } mode = BPP8; -#define GET_RGB \ - int r = tqRed ( *p ); \ - int g = tqGreen( *p ); \ - int b = tqBlue ( *p++ ); \ - r = red_shift > 0 \ - ? r << red_shift : r >> -red_shift; \ - g = green_shift > 0 \ - ? g << green_shift : g >> -green_shift; \ - b = blue_shift > 0 \ - ? b << blue_shift : b >> -blue_shift; + if ( bppc > 8 && xi->byte_order == LSBFirst ) + bppc++; + + int wordsize; + bool bigendian; + qSysInfo( &wordsize, &bigendian ); + bool same_msb_lsb = ( xi->byte_order == MSBFirst ) == ( bigendian ); + + if( bppc == 8 ) // 8 bit + mode = BPP8; + else if( bppc == 16 || bppc == 17 ) { // 16 bit MSB/LSB + if( red_shift == 8 && green_shift == 3 && blue_shift == -3 + && !d8 && same_msb_lsb ) + mode = BPP16_8_3_M3; + else if( red_shift == 7 && green_shift == 2 && blue_shift == -3 + && !d8 && same_msb_lsb ) + mode = BPP16_7_2_M3; + else + mode = bppc == 17 ? BPP16_LSB : BPP16_MSB; + } else if( bppc == 24 || bppc == 25 ) { // 24 bit MSB/LSB + mode = bppc == 25 ? BPP24_LSB : BPP24_MSB; + } else if( bppc == 32 || bppc == 33 ) { // 32 bit MSB/LSB + if( red_shift == 16 && green_shift == 8 && blue_shift == 0 + && !d8 && same_msb_lsb ) + mode = BPP32_16_8_0; + else + mode = bppc == 33 ? BPP32_LSB : BPP32_MSB; + } else + qFatal("Logic error 3"); #define GET_PIXEL \ int pixel; \ if ( d8 ) pixel = pix[*src++]; \ else { \ - GET_RGB \ - pixel = (b & blue_mask)|(g & green_mask) | (r & red_mask) \ + int r = tqRed ( *p ); \ + int g = tqGreen( *p ); \ + int b = tqBlue ( *p++ ); \ + r = red_shift > 0 \ + ? r << red_shift : r >> -red_shift; \ + g = green_shift > 0 \ + ? g << green_shift : g >> -green_shift; \ + b = blue_shift > 0 \ + ? b << blue_shift : b >> -blue_shift; \ + pixel = (r & red_tqmask)|(g & green_tqmask) | (b & blue_tqmask) \ | ~(blue_mask | green_mask | red_mask); \ } +// optimized case - no d8 case, shift only once instead of twice, tqmask only once instead of twice, +// use direct values instead of variables, and use only one statement +// (*p >> 16), (*p >> 8 ) and (*p) are tqRed(),tqGreen() and tqBlue() without masking +// shifts have to be passed including the shift operator (e.g. '>>3'), because of the direction +#define GET_PIXEL_OPT(red_shift,green_shift,blue_shift,red_tqmask,green_tqmask,blue_tqmask) \ + int pixel = ((( *p >> 16 ) red_shift ) & red_tqmask ) \ + | ((( *p >> 8 ) green_shift ) & green_tqmask ) \ + | ((( *p ) blue_shift ) & blue_tqmask ); \ + ++p; + + #define GET_PIXEL_DITHER_TC \ int r = tqRed ( *p ); \ int g = tqGreen( *p ); \ @@ -1262,89 +1465,176 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) ? b << blue_shift : b >> -blue_shift; \ int pixel = (b & blue_mask)|(g & green_mask) | (r & red_mask); - if ( dither_tc ) { - uint x; - switch ( bppc ) { - case 16: // 16 bit MSB - for ( x=0; x> 8); - *dst++ = pixel; - } +// again, optimized case +// can't be optimized that much :( +#define GET_PIXEL_DITHER_TC_OPT(red_shift,green_shift,blue_shift,red_tqmask,green_tqmask,blue_tqmask, \ + rbits,gbits,bbits) \ + const int thres = D[x%16][y%16]; \ + int r = tqRed ( *p ); \ + if ( r <= (255-(1<<(8-rbits))) && ((r< thres) \ + r += (1<<(8-rbits)); \ + int g = tqGreen( *p ); \ + if ( g <= (255-(1<<(8-gbits))) && ((g< thres) \ + g += (1<<(8-gbits)); \ + int b = tqBlue ( *p++ ); \ + if ( b <= (255-(1<<(8-bbits))) && ((b< thres) \ + b += (1<<(8-bbits)); \ + int pixel = (( r red_shift ) & red_tqmask ) \ + | (( g green_shift ) & green_tqmask ) \ + | (( b blue_shift ) & blue_tqmask ); + +#define CYCLE(body) \ + for ( uint y=0; ybytes_per_line*y; \ + TQRgb* p = (TQRgb *)src; \ + body \ + } + + if ( dither_tc ) { + switch ( mode ) { + case BPP16_8_3_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0xf800,0x7e0,0x1f,5,6,5) + *dst16++ = pixel; + } + ) break; - case 17: // 16 bit LSB - for ( x=0; x> 8; - } + case BPP16_7_2_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0x7c00,0x3e0,0x1f) + *dst16++ = pixel; + } + ) break; default: qFatal("Logic error"); } - } else { - uint x; - switch ( bppc ) { - case 8: // 8 bit - for ( x=0; x> 8); - *dst++ = pixel; - } + case BPP16_8_3_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0xf800,0x7e0,0x1f) + *dst16++ = pixel; + } + ) break; - case 17: // 16 bit LSB - for ( x=0; x> 8; - } + case BPP16_7_2_M3: + CYCLE( + TQ_INT16* dst16 = (TQ_INT16*)dst; + for ( uint x=0; x>3,0x7c00,0x3e0,0x1f,5,5,5) + *dst16++ = pixel; + } + ) break; - case 24: // 24 bit MSB - for ( x=0; x> 16; - *dst++ = pixel >> 8; - *dst++ = pixel; - } + case BPP16_MSB: // 16 bit MSB + CYCLE( + for ( uint x=0; x> 8); + *dst++ = pixel; + } + ) break; - case 25: // 24 bit LSB - for ( x=0; x> 8; - *dst++ = pixel >> 16; - } + case BPP16_LSB: // 16 bit LSB + CYCLE( + for ( uint x=0; x> 8; + } + ) break; - case 32: // 32 bit MSB - for ( x=0; x> 24; - *dst++ = pixel >> 16; - *dst++ = pixel >> 8; - *dst++ = pixel; - } + case BPP16_MSB: // 16 bit MSB + CYCLE( + for ( uint x=0; x> 8); + *dst++ = pixel; + } + ) + break; + case BPP16_LSB: // 16 bit LSB + CYCLE( + for ( uint x=0; x> 8; + } + ) + break; + case BPP24_MSB: // 24 bit MSB + CYCLE( + for ( uint x=0; x> 16; + *dst++ = pixel >> 8; + *dst++ = pixel; + } + ) break; case 33: // 32 bit LSB - for ( x=0; x> 8; - *dst++ = pixel >> 16; - *dst++ = pixel >> 24; - } + case BPP24_LSB: // 24 bit LSB + CYCLE( + for ( uint x=0; x> 8; + *dst++ = pixel >> 16; + } + ) break; - default: - qFatal("Logic error 2"); - } - } - } - xi->data = (char *)newbits; + case BPP32_16_8_0: + CYCLE( + memcpy( dst, p, w * 4 ); + ) + break; + case BPP32_MSB: // 32 bit MSB + CYCLE( + for ( uint x=0; x> 24; + *dst++ = pixel >> 16; + *dst++ = pixel >> 8; + *dst++ = pixel; + } + ) + break; + case BPP32_LSB: // 32 bit LSB + CYCLE( + for ( uint x=0; x> 8; + *dst++ = pixel >> 16; + *dst++ = pixel >> 24; + } + ) + break; + default: + qFatal("Logic error 2"); + } + } + xi->data = (char *)newbits; } if ( d == 8 && !trucol ) { // 8 bit pixmap @@ -1363,6 +1653,7 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } newbits = (uchar *)malloc( nbytes ); // copy image into newbits + newbits_size = nbytes; TQ_CHECK_PTR( newbits ); if ( !newbits ) // no memory return FALSE; @@ -1479,12 +1770,19 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } } - if ( !xi ) { // X image not created + if ( !xi ) { +#ifdef TQT_MITSHM_CONVERSIONS + xi = qt_XShmCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0, &shminfo ); + if( xi != NULL ) + mitshm_ximage = true; + else +#endif // X image not created xi = XCreateImage( dpy, visual, dd, ZPixmap, 0, 0, w, h, 32, 0 ); if ( xi->bits_per_pixel == 16 ) { // convert 8 bpp ==> 16 bpp ushort *p2; int p2inc = xi->bytes_per_line/sizeof(ushort); ushort *newerbits = (ushort *)malloc( xi->bytes_per_line * h ); + newbits_size = xi->bytes_per_line * h; TQ_CHECK_PTR( newerbits ); if ( !newerbits ) // no memory return FALSE; @@ -1502,6 +1800,14 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) "(bpp=%d)", xi->bits_per_pixel ); #endif } +#ifdef TQT_MITSHM_CONVERSIONS + if( newbits_size > 0 && mitshm_ximage ) { // need to copy to shared memory + memcpy( xi->data, newbits, newbits_size ); + free( newbits ); + newbits = (uchar*)xi->data; + } + else +#endif xi->data = (char *)newbits; } @@ -1535,19 +1841,24 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) } +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + XShmPutImage( dpy, hd, qt_xget_readonly_gc( x11Screen(), FALSE ), + xi, 0, 0, 0, 0, w, h, False ); + else +#endif XPutImage( dpy, hd, qt_xget_readonly_gc( x11Screen(), FALSE ), xi, 0, 0, 0, 0, w, h ); - if ( data->optim != BestOptim ) { // throw away image - qSafeXDestroyImage( xi ); - data->ximage = 0; - } else { // keep ximage that we created - data->ximage = xi; - } data->w = w; data->h = h; data->d = dd; + XImage* axi = NULL; +#ifdef TQT_MITSHM_CONVERSIONS + bool mitshm_aximage = false; + XShmSegmentInfo ashminfo; +#endif if ( image.hasAlphaBuffer() ) { TQBitmap m; m = image.createAlphaMask( conversion_flags ); @@ -1583,38 +1894,90 @@ bool TQPixmap::convertFromImage( const TQImage &img, int conversion_flags ) data->alphapm->rendhd = (HANDLE) XftDrawCreateAlpha( x11Display(), data->alphapm->hd, 8 ); - XImage *axi = XCreateImage(x11Display(), (Visual *) x11Visual(), +#ifdef TQT_MITSHM_CONVERSIONS + axi = qt_XShmCreateImage( x11Display(), (Visual*)x11Visual(), + 8, ZPixmap, 0, 0, w, h, 8, 0, &ashminfo ); + if( axi != NULL ) + mitshm_aximage = true; + else +#endif + axi = XCreateImage(x11Display(), (Visual *) x11Visual(), 8, ZPixmap, 0, 0, w, h, 8, 0); if (axi) { + if( axi->data==NULL ) { // the data is deleted by qSafeXDestroyImage axi->data = (char *) malloc(h * axi->bytes_per_line); TQ_CHECK_PTR( axi->data ); + } char *aptr = axi->data; if (image.depth() == 32) { const int *iptr = (const int *) image.bits(); - int max = w * h; - while (max--) - *aptr++ = *iptr++ >> 24; // squirt + if( axi->bytes_per_line == (int)w ) { + int max = w * h; + while (max--) + *aptr++ = *iptr++ >> 24; // squirt + } else { + for (uint i = 0; i < h; ++i ) { + for (uint j = 0; j < w; ++j ) + *aptr++ = *iptr++ >> 24; // squirt + aptr += ( axi->bytes_per_line - w ); + } + } } else if (image.depth() == 8) { const TQRgb * const rgb = image.colorTable(); for (uint y = 0; y < h; ++y) { const uchar *iptr = image.scanLine(y); for (uint x = 0; x < w; ++x) *aptr++ = tqAlpha(rgb[*iptr++]); + aptr += ( axi->bytes_per_line - w ); } } GC gc = XCreateGC(x11Display(), data->alphapm->hd, 0, 0); + #ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_aximage ) + XShmPutImage( dpy, data->alphapm->hd, gc, axi, 0, 0, 0, 0, w, h, False ); + else +#endif XPutImage(dpy, data->alphapm->hd, gc, axi, 0, 0, 0, 0, w, h); XFreeGC(x11Display(), gc); - qSafeXDestroyImage(axi); } } #endif // TQT_NO_XFTFREETYPE } +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage || mitshm_aximage ) + XSync( x11Display(), False ); // wait until processed +#endif + + if ( data->optim != BestOptim ) { // throw away image +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) + qt_XShmDestroyImage( xi, &shminfo ); + else +#endif + qSafeXDestroyImage( xi ); + data->ximage = 0; + } else { // keep ximage that we created +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_ximage ) { // copy the XImage? + qt_XShmDestroyImage( xi, &shminfo ); + xi = 0; + } +#endif + data->ximage = xi; + } + if( axi ) { +#ifdef TQT_MITSHM_CONVERSIONS + if( mitshm_aximage ) + qt_XShmDestroyImage( axi, &ashminfo ); + else +#endif + qSafeXDestroyImage(axi); + } return TRUE; } @@ -1777,7 +2140,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const return pm; } -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) static bool try_once = TRUE; if (try_once) { try_once = FALSE; @@ -1810,7 +2173,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const dbpl = ((w*bpp+31)/32)*4; dbytes = dbpl*h; -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) if ( use_mitshm ) { dptr = (uchar *)xshmimg->data; uchar fillbyte = bpp == 8 ? white.pixel() : 0xff; @@ -1826,7 +2189,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const memset( dptr, TQt::white.pixel( x11Screen() ), dbytes ); else memset( dptr, 0xff, dbytes ); -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) } #endif @@ -1857,7 +2220,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const } else { xbpl = (w*bpp)/8; p_inc = dbpl - xbpl; -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) if ( use_mitshm ) p_inc = xshmimg->bytes_per_line - xbpl; #endif @@ -1894,7 +2257,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const TQPixmap pm( w, h ); pm.data->uninit = FALSE; pm.x11SetScreen( x11Screen() ); -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) if ( use_mitshm ) { XCopyArea( dpy, xshmpm, pm.handle(), gc, 0, 0, w, h, 0, 0 ); } else { @@ -1903,7 +2266,7 @@ TQPixmap TQPixmap::xForm( const TQWMatrix &matrix ) const ZPixmap, 0, (char *)dptr, w, h, 32, 0 ); XPutImage( dpy, pm.handle(), gc, xi, 0, 0, 0, 0, w, h); qSafeXDestroyImage( xi ); -#if defined(TQT_MITSHM) +#if defined(TQT_MITSHM_XFORM) } #endif diff --git a/tqtinterface/qt4/src/kernel/tqrichtext.cpp b/tqtinterface/qt4/src/kernel/tqrichtext.cpp index 8b614d6..00484d6 100644 --- a/tqtinterface/qt4/src/kernel/tqrichtext.cpp +++ b/tqtinterface/qt4/src/kernel/tqrichtext.cpp @@ -9028,7 +9028,7 @@ void TQTextCursor::restoreState() pop(); } -bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) +bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link, bool loosePlacing, bool matchBetweenCharacters ) { TQPoint pos( p ); TQRect r; @@ -9046,7 +9046,7 @@ bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) str = s; if ( pos.y() >= r.y() && pos.y() <= r.y() + r.height() ) break; - if ( !s->next() ) { + if ( loosePlacing == TRUE && !s->next() ) { #ifdef TQ_WS_MACX pos.setX( s->rect().x() + s->rect().width() ); #endif @@ -9087,7 +9087,7 @@ bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) if ( pos.x() < x ) pos.setX( x + 1 ); int cw; - int curpos = s->length()-1; + int curpos = -1; int dist = 10000000; bool inCustom = FALSE; while ( i < nextLine ) { @@ -9109,14 +9109,21 @@ bool TQTextCursor::place( const TQPoint &p, TQTextParagraph *s, bool link ) cpos += cw; int d = cpos - pos.x(); bool dm = d < 0 ? !chr->rightToLeft : chr->rightToLeft; - if ( (TQABS( d ) < dist || (dist == d && dm == TRUE )) && para->string()->validCursorPosition( i ) ) { + if ( ( matchBetweenCharacters == TRUE && (TQABS( d ) < dist || (dist == d && dm == TRUE )) && para->string()->validCursorPosition( i ) ) || + ( matchBetweenCharacters == FALSE && ( d == 0 || dm == TRUE ) ) ) { dist = TQABS( d ); - if ( !link || pos.x() >= x + chr->x ) + if ( !link || ( pos.x() >= x + chr->x && ( loosePlacing == TRUE || pos.x() < cpos ) ) ) curpos = i; } } i++; } + if ( curpos == -1 ) { + if ( loosePlacing == TRUE ) + curpos = s->length()-1; + else + return FALSE; + } setIndex( curpos ); #ifndef TQT_NO_TEXTCUSTOMITEM @@ -13244,6 +13251,9 @@ void TQTextParagraph::drawString( TQPainter &painter, const TQString &str, int s tmpw = fullSelectionWidth - xleft; painter.fillRect( xleft, y, tmpw, h, color ); painter.drawText( xstart, y + baseLine, str, start, len, dir ); + // draw preedit's underline + if (selection == TQTextDocument::IMCompositionText) + painter.drawLine(xstart, y + baseLine + 1, xstart + w, y + baseLine + 1); if (selStart != start || selEnd != start + len || selWrap) painter.restore(); } diff --git a/tqtinterface/qt4/src/kernel/tqrichtext_p.h b/tqtinterface/qt4/src/kernel/tqrichtext_p.h index b9cbd98..edb8c76 100644 --- a/tqtinterface/qt4/src/kernel/tqrichtext_p.h +++ b/tqtinterface/qt4/src/kernel/tqrichtext_p.h @@ -2523,7 +2523,8 @@ public: int totalOffsetY() const; // total document offset bool place( const TQPoint &pos, TQTextParagraph *s ) { return place( pos, s, FALSE ); } - bool place( const TQPoint &pos, TQTextParagraph *s, bool link ); + bool place( const TQPoint &pos, TQTextParagraph *s, bool link ) { return place( pos, s, link, TRUE, TRUE ); } + bool place( const TQPoint &pos, TQTextParagraph *s, bool link, bool loosePlacing, bool matchBetweenCharacters ); void restoreState(); diff --git a/tqtinterface/qt4/src/kernel/tqt_x11_p.h b/tqtinterface/qt4/src/kernel/tqt_x11_p.h index e08531d..a33ce01 100644 --- a/tqtinterface/qt4/src/kernel/tqt_x11_p.h +++ b/tqtinterface/qt4/src/kernel/tqt_x11_p.h @@ -177,6 +177,11 @@ extern "C" { #endif // TQT_NO_XRENDER +#ifndef TQT_NO_XSYNC +# include +#endif // TQT_NO_XSYNC + + #ifndef TQT_NO_XKB # include #endif // TQT_NO_XKB diff --git a/tqtinterface/qt4/src/kernel/tqwidget.cpp b/tqtinterface/qt4/src/kernel/tqwidget.cpp index 9e60bac..67d0e1b 100644 --- a/tqtinterface/qt4/src/kernel/tqwidget.cpp +++ b/tqtinterface/qt4/src/kernel/tqwidget.cpp @@ -5953,8 +5953,24 @@ void TQWidget::setFocus() if ( isActiveWindow() ) { TQWidget * prev = tqApp->focus_widget; if ( prev ) { - if ( prev != this ) + // This part is never executed when TQ_WS_X11? Preceding XFocusOut + // had already reset focus_widget when received XFocusIn + + // Don't reset input context explicitly here. Whether reset or not + // when focusing out is a responsibility of input methods. For + // example, Japanese input context should not be reset here. The + // context sometimes contains a whole paragraph and has minutes of + // lifetime different to ephemeral one in other languages. The + // input context should be survived until focused again. So we + // delegate the responsibility to input context via + // unfocusInputContext(). + if ( prev != this && prev->isInputMethodEnabled() ) { +#if 0 prev->resetInputContext(); +#else + prev->unfocusInputContext(); +#endif + } } #if defined(TQ_WS_WIN) else { @@ -5962,9 +5978,8 @@ void TQWidget::setFocus() } #endif tqApp->focus_widget = this; -#if defined(TQ_WS_X11) - focusInputContext(); -#endif + if( isInputMethodEnabled() ) + focusInputContext(); #if defined(TQ_WS_WIN) if ( !tqtopLevelWidget()->isPopup() ) @@ -6012,7 +6027,11 @@ void TQWidget::clearFocus() focusProxy()->clearFocus(); return; } else if ( hasFocus() ) { +#if !defined(TQ_WS_X11) resetInputContext(); +#else + unfocusInputContext(); +#endif TQWidget* w = tqApp->tqfocusWidget(); // clear active focus tqApp->focus_widget = 0; @@ -7338,7 +7357,13 @@ bool TQWidget::event( TQEvent *e ) break; case TQEvent::MouseButtonPress: + // Don't reset input context here. Whether reset or not is + // a responsibility of input method. reset() will be + // called by mouseHandler() of input method if necessary + // via mousePressEvent() of text widgets. +#if 0 resetInputContext(); +#endif mousePressEvent( (TQMouseEvent*)e ); if ( ! ((TQMouseEvent*)e)->isAccepted() ) return FALSE; diff --git a/tqtinterface/qt4/src/kernel/tqwidget.h b/tqtinterface/qt4/src/kernel/tqwidget.h index c027464..65b424e 100644 --- a/tqtinterface/qt4/src/kernel/tqwidget.h +++ b/tqtinterface/qt4/src/kernel/tqwidget.h @@ -64,6 +64,10 @@ #endif // TQFONTENGINE_P_H #endif // USE_QT4 +#if defined(TQ_WS_X11) && !defined(TQT_NO_IM) +class TQInputContext; +#endif + class TQLayout; #ifdef USE_QT4 @@ -980,7 +984,19 @@ public: CGContextRef macCGContext(bool clipped=TRUE) const; #endif #endif - +#if defined(TQ_WS_X11) + enum X11WindowType { + X11WindowTypeSelect, + X11WindowTypeCombo, + X11WindowTypeDND, + X11WindowTypeTooltip, + X11WindowTypeMenu, // torn-off + X11WindowTypeDropdown, + X11WindowTypePopup + }; + void x11SetWindowType( X11WindowType type = X11WindowTypeSelect ); + void x11SetWindowTransient( TQWidget* tqparent ); +#endif void setWindowOpacity(double level); double windowOpacity() const; @@ -1051,6 +1067,18 @@ protected: int metric( int ) const; +#if defined(TQ_WS_X11) +#if !defined(TQT_NO_IM_EXTENSIONS) + virtual TQWidget *icHolderWidget(); +#else + TQWidget *icHolderWidget(); +#endif + TQInputContext *getInputContext(); + void changeInputContext( const TQString & ); + void sendMouseEventToInputContext( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ); +#endif void resetInputContext(); virtual void create( WId = 0, bool initializeWindow = TRUE, @@ -1082,14 +1110,25 @@ protected: private Q_SLOTS: void focusProxyDestroyed(); +#if defined(TQ_WS_X11) + void destroyInputContext(); +#endif private: void setFontSys( TQFont *f = 0 ); #if defined(TQ_WS_X11) void createInputContext(); - void destroyInputContext(); void focusInputContext(); + void unfocusInputContext(); void checkChildrenDnd(); + +#ifndef TQT_NO_XSYNC + void createSyncCounter(); + void destroySyncCounter(); + void incrementSyncCounter(); + void handleSyncRequest( void* ev ); +#endif + #elif defined(TQ_WS_MAC) uint own_id : 1, macDropEnabled : 1; EventHandlerRef window_event; @@ -1159,6 +1198,9 @@ private: TQFont fnt; #ifndef TQT_NO_LAYOUT TQLayout *lay_out; +#endif +#if defined(TQ_WS_X11) && !defined(TQT_NO_IM) && !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext *ic; // Input Context #endif TQWExtra *extra; #if defined(TQ_WS_TQWS) @@ -1471,7 +1513,13 @@ struct TQ_EXPORT TQTLWExtra { uint dnd : 1; // DND properties installed uint uspos : 1; // User defined position uint ussize : 1; // User defined size - void *xic; // XIM Input Context +#if defined(TQT_NO_IM_EXTENSIONS) + void *xic; // Input Context +#endif +#ifndef TQT_NO_XSYNC + ulong syncCounter; + uint syncRequestValue[2]; +#endif #endif #if defined(TQ_WS_MAC) WindowGroupRef group; diff --git a/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp b/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp index f8c605a..c6e7abb 100644 --- a/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp +++ b/tqtinterface/qt4/src/kernel/tqwidget_x11.cpp @@ -83,6 +83,11 @@ extern Atom qt_net_wm_window_type_menu; extern Atom qt_net_wm_window_type_utility; extern Atom qt_net_wm_window_type_splash; extern Atom qt_net_wm_window_type_override; +extern Atom qt_net_wm_window_type_dropdown_menu; +extern Atom qt_net_wm_window_type_popup_menu; +extern Atom qt_net_wm_window_type_combo; +extern Atom qt_net_wm_window_type_dnd; +extern Atom qt_net_wm_window_type_tooltip; extern Atom qt_net_wm_pid; extern Atom qt_net_wm_user_time; extern Atom qt_enlightenment_desktop; @@ -300,11 +305,9 @@ int qt_sip_count( TQWidget* ); bool qt_wstate_iconified( WId ); void qt_updated_rootinfo(); -#ifndef TQT_NO_XIM -#include "tqinputcontext_p.h" - -extern XIM qt_xim; -extern XIMStyle qt_xim_style; +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#include "tqinputcontextfactory.h" #endif // Paint event clipping magic @@ -322,6 +325,12 @@ extern bool qt_deferred_map_tqcontains(TQWidget *); static TQWidget *mouseGrb = 0; static TQWidget *keyboardGrb = 0; +#ifndef TQT_NO_XSYNC +extern Atom qt_net_wm_sync_request_counter; +extern Atom qt_net_wm_sync_request; +extern bool qt_use_xsync; +#endif + // defined in qfont_x11.cpp extern bool qt_has_xft; @@ -683,10 +692,6 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) x11Colormap() ); #endif // TQT_NO_XFTFREETYPE - // NET window types - long net_wintypes[7] = { 0, 0, 0, 0, 0, 0, 0 }; - int curr_wintype = 0; - // NET window states long net_winstates[6] = { 0, 0, 0, 0, 0, 0 }; int curr_winstate = 0; @@ -708,7 +713,6 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) if ( testWFlags(WStyle_Splash) ) { if (qt_net_supports(qt_net_wm_window_type_splash)) { clearWFlags( WX11BypassWM ); - net_wintypes[curr_wintype++] = qt_net_wm_window_type_splash; } else { setWFlags( WX11BypassWM | WStyle_Tool | WStyle_NoBorder ); } @@ -717,27 +721,22 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) mwmhints.decorations = 0L; mwmhints.flags |= (1L << 1); // MWM_HINTS_DECORATIONS - if ( testWFlags( WStyle_NoBorder ) ) { - // override netwm type - quick and easy for KDE noborder - net_wintypes[curr_wintype++] = qt_net_wm_window_type_override; - } else { - if ( testWFlags( WStyle_NormalBorder | WStyle_DialogBorder ) ) { - mwmhints.decorations |= (1L << 1); // MWM_DECOR_BORDER - mwmhints.decorations |= (1L << 2); // MWM_DECOR_RESIZEH - } + if ( testWFlags( WStyle_NormalBorder | WStyle_DialogBorder ) ) { + mwmhints.decorations |= (1L << 1); // MWM_DECOR_BORDER + mwmhints.decorations |= (1L << 2); // MWM_DECOR_RESIZEH + } - if ( testWFlags( WStyle_Title ) ) - mwmhints.decorations |= (1L << 3); // MWM_DECOR_TITLE + if ( testWFlags( WStyle_Title ) ) + mwmhints.decorations |= (1L << 3); // MWM_DECOR_TITLE - if ( testWFlags( WStyle_SysMenu ) ) - mwmhints.decorations |= (1L << 4); // MWM_DECOR_MENU + if ( testWFlags( WStyle_SysMenu ) ) + mwmhints.decorations |= (1L << 4); // MWM_DECOR_MENU - if ( testWFlags( WStyle_Minimize ) ) - mwmhints.decorations |= (1L << 5); // MWM_DECOR_MINIMIZE + if ( testWFlags( WStyle_Minimize ) ) + mwmhints.decorations |= (1L << 5); // MWM_DECOR_MINIMIZE - if ( testWFlags( WStyle_Maximize ) ) - mwmhints.decorations |= (1L << 6); // MWM_DECOR_MAXIMIZE - } + if ( testWFlags( WStyle_Maximize ) ) + mwmhints.decorations |= (1L << 6); // MWM_DECOR_MAXIMIZE if (testWFlags(WStyle_Tool)) { wsa.save_under = True; @@ -757,23 +756,6 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) } } - // ### need a better way to do this - if (inherits("TQPopupMenu")) { - // menu netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_menu; - } else if (inherits("TQToolBar")) { - // toolbar netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_toolbar; - } else if (testWFlags(WStyle_Customize) && testWFlags(WStyle_Tool)) { - // utility netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_utility; - } - - if (dialog) // dialog netwm type - net_wintypes[curr_wintype++] = qt_net_wm_window_type_dialog; - // normal netwm type - default - net_wintypes[curr_wintype++] = qt_net_wm_window_type_normal; - // stays on top if (testWFlags(WStyle_StaysOnTop)) { net_winstates[curr_winstate++] = qt_net_wm_state_above; @@ -808,6 +790,7 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) wsa.save_under = True; XChangeWindowAttributes( dpy, id, CWOverrideRedirect | CWSaveUnder, &wsa ); + x11SetWindowType(); } else if ( topLevel && !desktop ) { // top-level widget TQWidget *p = parentWidget(); // real tqparent if (p) @@ -851,11 +834,14 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) XResizeWindow( dpy, id, crect.width(), crect.height() ); XStoreName( dpy, id, tqAppName() ); - Atom protocols[4]; + Atom protocols[5]; int n = 0; protocols[n++] = qt_wm_delete_window; // support del window protocol protocols[n++] = qt_wm_take_focus; // support take focus window protocol protocols[n++] = qt_net_wm_ping; // support _NET_WM_PING protocol +#ifndef TQT_NO_XSYNC + protocols[n++] = qt_net_wm_sync_request;// support the _NET_WM_SYNC_REQUEST protocol +#endif if ( testWFlags( WStyle_ContextHelp ) ) protocols[n++] = qt_net_wm_context_help; XSetWMProtocols( dpy, id, protocols, n ); @@ -867,12 +853,7 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) else XDeleteProperty(dpy, id, qt_xa_motif_wm_hints); - // set _NET_WM_WINDOW_TYPE - if (curr_wintype > 0) - XChangeProperty(dpy, id, qt_net_wm_window_type, XA_ATOM, 32, PropModeReplace, - (unsigned char *) net_wintypes, curr_wintype); - else - XDeleteProperty(dpy, id, qt_net_wm_window_type); + x11SetWindowType(); // set _NET_WM_WINDOW_STATE if (curr_winstate > 0) @@ -886,6 +867,14 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) XChangeProperty(dpy, id, qt_net_wm_pid, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) &curr_pid, 1); +#ifndef TQT_NO_XSYNC + // set _NET_WM_SYNC_COUNTER + createSyncCounter(); + long counterVal = topData()->syncCounter; + XChangeProperty( dpy, id, qt_net_wm_sync_request_counter, XA_CARDINAL, 32, PropModeReplace, + (unsigned char*) &counterVal, 1); +#endif + // when we create a toplevel widget, the frame strut should be dirty fstrut_dirty = 1; @@ -923,6 +912,10 @@ void TQWidget::create( WId window, bool initializeWindow, bool destroyOldWindow) if ( destroyw ) qt_XDestroyWindow( this, dpy, destroyw ); + +#if !defined(TQT_NO_IM_EXTENSIONS) + ic = 0; +#endif } @@ -981,11 +974,24 @@ void TQWidget::destroy( bool destroyWindow, bool destroySubWindows ) if ( destroyWindow ) qt_XDestroyWindow( this, x11Display(), winid ); } +#ifndef TQT_NO_XSYNC + destroySyncCounter(); +#endif setWinId( 0 ); extern void qPRCleanup( TQWidget *widget ); // from qapplication_x11.cpp if ( testWState(WState_Reparented) ) qPRCleanup(this); + + if( this == icHolderWidget() ) { + destroyInputContext(); + } else { + // release previous focus information participating with + // preedit preservation of qic + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->releaseComposingWidget( this ); + } } } @@ -1022,14 +1028,18 @@ void TQWidget::reparentSys( TQWidget *tqparent, WFlags f, const TQPoint &p, bool XReparentWindow( x11Display(), old_winid, RootWindow( x11Display(), x11Screen() ), 0, 0 ); - if ( isTopLevel() ) { - // input contexts are associated with toplevel widgets, so we need - // destroy the context here. if we are reparenting back to toplevel, - // then we will have another context created, otherwise we will - // use our new toplevel's context + if ( this == icHolderWidget() ) { + // input contexts are sometimes associated with toplevel widgets, so + // we need destroy the context here. if we are reparenting back to + // toplevel, then we may have another context created, otherwise we + // will use our new ic holder's context destroyInputContext(); } +#ifndef TQT_NO_XSYNC + destroySyncCounter(); +#endif + if ( isTopLevel() || !tqparent ) // we are toplevel, or reparenting to toplevel topData()->parentWinId = 0; @@ -1131,6 +1141,64 @@ void TQWidget::reparentSys( TQWidget *tqparent, WFlags f, const TQPoint &p, bool setMouseTracking(mouse_tracking); } +// Sets the EWMH (netwm) window type. Needed as a separate function +// because create() may be too soon in some cases. +void TQWidget::x11SetWindowType( X11WindowType type ) +{ + // NET window types + long net_wintypes[7] = { 0, 0, 0, 0, 0, 0, 0 }; + int curr_wintype = 0; + if( testWFlags(WType_Desktop)) + return; + if( type == X11WindowTypeSelect ) { + if ( testWFlags(WStyle_Splash)) { + if (qt_net_supports(qt_net_wm_window_type_splash)) { + net_wintypes[curr_wintype++] = qt_net_wm_window_type_splash; + } + } else if (inherits(TQTOOLBAR_OBJECT_NAME_STRING)) { + // toolbar netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_toolbar; + } else if (testWFlags(WStyle_Customize) && testWFlags(WStyle_Tool)) { + // utility netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_utility; + } else if (testWFlags(WType_Dialog)) { + // dialog netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_dialog; + } + } else if( type == X11WindowTypeCombo ) { + // combo netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_combo; + } else if( type == X11WindowTypeDND ) { + // dnd netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_dnd; + } else if( type == X11WindowTypeDropdown ) { + // dropdown netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_dropdown_menu; + } else if( type == X11WindowTypePopup ) { + // popup netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_popup_menu; + } else if( type == X11WindowTypeMenu ) { + // menu netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_menu; + } else if( type == X11WindowTypeTooltip ) { + // tooltip netwm type + net_wintypes[curr_wintype++] = qt_net_wm_window_type_tooltip; + } + + // normal netwm type - default + net_wintypes[curr_wintype++] = qt_net_wm_window_type_normal; + // set _NET_WM_WINDOW_TYPE + if (curr_wintype > 0) + XChangeProperty(x11Display(), winId(), qt_net_wm_window_type, XA_ATOM, 32, PropModeReplace, + (unsigned char *) net_wintypes, curr_wintype); + else + XDeleteProperty(x11Display(), winId(), qt_net_wm_window_type); +} + +void TQWidget::x11SetWindowTransient( TQWidget* tqparent ) +{ + XSetTransientForHint( x11Display(), winId(), tqparent->winId()); +} /*! Translates the widget coordinate \a pos to global screen @@ -1182,7 +1250,8 @@ TQPoint TQWidget::mapFromGlobal( const TQPoint &pos ) const language input systems. In the X11 version of TQt, if \a text is TRUE, this method sets the - XIM "spot" point for complex language input handling. + input method focus point in the preedit (XIM "spot" point) for + complex language input handling. The font \a f is a rendering hint to the currently active input method. If \a f is 0 the widget's font is used. @@ -1192,22 +1261,15 @@ TQPoint TQWidget::mapFromGlobal( const TQPoint &pos ) const void TQWidget::setMicroFocusHint(int x, int y, int width, int height, bool text, TQFont *f ) { -#ifndef TQT_NO_XIM +#ifndef TQT_NO_IM if ( text ) { - TQWidget* tlw = tqtopLevelWidget(); - TQTLWExtra *topdata = tlw->topData(); - // trigger input context creation if it hasn't happened already createInputContext(); - TQInputContext *qic = (TQInputContext *) topdata->xic; - - if ( qt_xim && qic ) { - TQPoint p( x, y ); - TQPoint p2 = mapTo( tqtopLevelWidget(), TQPoint( 0, 0 ) ); - p = mapTo( tqtopLevelWidget(), p); - qic->setXFontSet( f ? *f : fnt ); - qic->setComposePosition(p.x(), p.y() + height); - qic->setComposeArea(p2.x(), p2.y(), this->width(), this->height()); + + TQInputContext *qic = getInputContext(); + if(qic) { + TQPoint gp = mapToGlobal( TQPoint( x, y ) ); + qic->setMicroFocus(gp.x(), gp.y(), width, height, f); } } #endif @@ -2659,13 +2721,21 @@ void TQWidget::deleteSysExtra() void TQWidget::createTLSysExtra() { +#if defined(TQT_NO_IM_EXTENSIONS) // created lazily extra->topextra->xic = 0; +#endif +#ifndef TQT_NO_XSYNC + extra->topextra->syncCounter = 0; + extra->topextra->syncRequestValue[0] = 0; + extra->topextra->syncRequestValue[1] = 0; +#endif } void TQWidget::deleteTLSysExtra() { - destroyInputContext(); + // don't destroy input context here. it will be destroyed in + // TQWidget::destroy() destroyInputContext(); } /* @@ -2706,6 +2776,51 @@ void TQWidget::checkChildrenDnd() } } + +#ifndef TQT_NO_XSYNC +// create a window's XSyncCounter +void TQWidget::createSyncCounter() +{ + if( !qt_use_xsync || !isTopLevel() || topData()->syncCounter ) + return; + XSyncValue zero; + XSyncIntToValue( &zero, 0 ); + topData()->syncCounter = XSyncCreateCounter( x11Display(), zero ); +} + +// destroy a window's XSyncCounter +void TQWidget::destroySyncCounter() +{ + if( !qt_use_xsync || !extra || !extra->topextra + || !extra->topextra->syncCounter ) + return; + XSyncDestroyCounter( x11Display(), extra->topextra->syncCounter ); + extra->topextra->syncCounter = 0; +} + +// increment a window's XSyncCounter +void TQWidget::incrementSyncCounter() +{ + if( qt_use_xsync && topData()->syncCounter && + !(topData()->syncRequestValue[0] == 0 && + topData()->syncRequestValue[1] == 0) ) { + XSyncValue val; + XSyncIntsToValue( &val, topData()->syncRequestValue[ 0 ], topData()->syncRequestValue[ 1 ] ); + XSyncSetCounter( x11Display(), topData()->syncCounter, val ); + topData()->syncRequestValue[0] = topData()->syncRequestValue[1] = 0; + } +} + +// handle _NET_WM_SYNC_REQUEST +void TQWidget::handleSyncRequest( void* ev ) +{ + XEvent* xev = (XEvent*)ev; + topData()->syncRequestValue[ 0 ] = xev->xclient.data.l[ 2 ]; + topData()->syncRequestValue[ 1 ] = xev->xclient.data.l[ 3 ]; +} +#endif // TQT_NO_XSYNC + + /*! \property TQWidget::acceptDrops \brief whether drop events are enabled for this widget @@ -2897,76 +3012,256 @@ void TQWidget::updateFrameStrut() const } +/*! + This function returns the widget holding the TQInputContext + instance for this widget. The instance is used for text input to + this widget, switching input method, etc. + + By default, this function delegates the role of returning input + context holder widget to TQApplication::locateICHolderWidget(). + + This definition enables application developer to change the + mapping of widgets to TQInputContext instance simply by overriding + TQApplication::locateICHolderWidget(). + + \sa TQApplication::locateICHolderWidget() +*/ +TQWidget *TQWidget::icHolderWidget() +{ + return tqApp->locateICHolderWidget(this); +} + + +/*! + This function returns the TQInputContext instance for this widget. + This instance is used for text input to this widget, etc. + It is simply the accessor function. +*/ +TQInputContext *TQWidget::getInputContext() +{ + TQInputContext *qic = 0; + +// #if !defined(TQT_NO_IM_EXTENSIONS) + if ( isInputMethodEnabled() ) { +#if !defined(TQT_NO_IM_EXTENSIONS) + qic = icHolderWidget()->ic; +#else +// { + // icHolderWidget is always tqtopLevelWidget + TQTLWExtra *topdata = icHolderWidget()->topData(); + qic = (TQInputContext *)topdata->xic; +#endif + } + + return qic; +} + + +/*! + This function replaces the TQInputContext instance used for text + input to this widget. The \a identifierName is the identifier name + of newly choosed input method. +*/ +void TQWidget::changeInputContext( const TQString& identifierName ) +{ + TQWidget *icWidget = icHolderWidget(); +#if !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext **qicp = &icWidget->ic; +#else + TQInputContext **qicp = (TQInputContext **)&icWidget->topData()->xic; +#endif + + if( *qicp ) + delete *qicp; + // an input context that has the identifierName is generated. + TQInputContext *qic = TQInputContextFactory::create( identifierName, icWidget ); + *qicp = qic; + if ( qic ) { + TQObject::connect( qic, TQT_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)), + tqApp, TQT_SLOT(postIMEvent(TQObject *,TQIMEvent *)) ); + TQObject::connect( qic, TQT_SIGNAL(deletionRequested()), + icWidget, TQT_SLOT(destroyInputContext()) ); + } +} + + +/*! + \internal + This is an internal function, you should never call this. + + This function is called to generate an input context + according to a configuration for default input method + + When TQT_NO_IM_EXTENSIONS is not set, input context is + generated only when isInputMethodEnabled() returns TRUE. +*/ void TQWidget::createInputContext() { - TQWidget *tlw = tqtopLevelWidget(); - TQTLWExtra *topdata = tlw->topData(); +// #if !defined(TQT_NO_IM_EXTENSIONS) + if( !isInputMethodEnabled() || TQApplication::closingDown() ) + return; +// #endif -#ifndef TQT_NO_XIM - if (qt_xim) { - if (! topdata->xic) { - TQInputContext *qic = new TQInputContext(tlw); - topdata->xic = (void *) qic; - } - } else -#endif // TQT_NO_XIM - { - // qDebug("TQWidget::createInputContext: no xim"); - topdata->xic = 0; - } + TQWidget *icWidget = icHolderWidget(); +#ifndef TQT_NO_IM +#if !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext **qicp = &icWidget->ic; +#else + TQInputContext **qicp = (TQInputContext **)&icWidget->topData()->xic; +#endif + + if ( ! *qicp ) { + // an input context of the default input method is generated. + TQInputContext *qic = TQInputContextFactory::create( TQApplication::defaultInputMethod(), icWidget ); + + *qicp = qic; + if ( qic ) { + TQObject::connect( qic, TQT_SIGNAL(imEventGenerated(TQObject *,TQIMEvent *)), + tqApp, TQT_SLOT(postIMEvent(TQObject *,TQIMEvent *)) ); + TQObject::connect( qic, TQT_SIGNAL(deletionRequested()), + icWidget, TQT_SLOT(destroyInputContext()) ); + } + } +#endif // TQT_NO_IM } +/*! + \internal + + This slot is used to destroy the input context that belonging + to the widget itself, so icHolderWidget()->ic is not fetched. + + \sa TQInputContext::deletionRequested() +*/ void TQWidget::destroyInputContext() { -#ifndef TQT_NO_XIM - TQInputContext *qic = (TQInputContext *) extra->topextra->xic; - delete qic; -#endif // TQT_NO_XIM - extra->topextra->xic = 0; +#ifndef TQT_NO_IM +#if !defined(TQT_NO_IM_EXTENSIONS) + TQInputContext **qicp = ⁣ +#else + if ( ! extra || ! extra->topextra ) + return; + + TQInputContext **qicp = (TQInputContext **)&extra->topextra->xic; +#endif + + if( *qicp ) + delete *qicp; + + *qicp = 0; +#endif // TQT_NO_IM } /*! - This function is called when the user finishes input composition, - e.g. changes focus to another widget, moves the cursor, etc. + This function is called when text widgets need to be neutral state to + execute text operations properly. See qlineedit.cpp and qtextedit.cpp as + example. + + Ordinary reset that along with changing focus to another widget, + moving the cursor, etc, is implicitly handled via + unfocusInputContext() because whether reset or not when such + situation is a responsibility of input methods. So we delegate the + responsibility to the input context via unfocusInputContext(). See + 'Preedit preservation' section of the class description of + TQInputContext for further information. + + \sa TQInputContext, unfocusInputContext(), TQInputContext::unsetFocus() */ void TQWidget::resetInputContext() { -#ifndef TQT_NO_XIM - if ((qt_xim_style & XIMPreeditCallbacks) && hasFocus()) { - TQWidget *tlw = tqtopLevelWidget(); - TQTLWExtra *topdata = tlw->topData(); +#ifndef TQT_NO_IM + // trigger input context creation if it hasn't happened already + createInputContext(); + + TQInputContext *qic = getInputContext(); + if( qic ) + qic->reset(); +#endif // TQT_NO_IM +} + + +/*! + \internal + This is an internal function, you should never call this. + + This function is called to focus associated input context. The + code intends to eliminate duplicate focus for the context even if + the context is shared between widgets + + \sa TQInputContext::setFocus() + */ +void TQWidget::focusInputContext() +{ +#ifndef TQT_NO_IM + TQWidget* tlw = tqtopLevelWidget(); + if (!tlw->isPopup() || isInputMethodEnabled()) { // trigger input context creation if it hasn't happened already createInputContext(); - if (topdata->xic) { - TQInputContext *qic = (TQInputContext *) topdata->xic; - qic->reset(); + TQInputContext *qic = getInputContext(); + if ( qic ) { + if( qic->tqfocusWidget() != this ) { + qic->setFocusWidget( this ); + qic->setFocus(); + } } } -#endif // TQT_NO_XIM +#endif // TQT_NO_IM } -void TQWidget::focusInputContext() -{ -#ifndef TQT_NO_XIM - TQWidget *tlw = tqtopLevelWidget(); - if (!tlw->isPopup() || isInputMethodEnabled()) { - TQTLWExtra *topdata = tlw->topData(); +/*! + \internal + This is an internal function, you should never call this. - // trigger input context creation if it hasn't happened already - createInputContext(); + This function is called to remove focus from associated input + context. - if (topdata->xic) { - TQInputContext *qic = (TQInputContext *) topdata->xic; - qic->setFocus(); - } + \sa TQInputContext::unsetFocus() + */ +void TQWidget::unfocusInputContext() +{ +#ifndef TQT_NO_IM + // trigger input context creation if it hasn't happened already + createInputContext(); + + TQInputContext *qic = getInputContext(); + if ( qic ) { + // may be caused reset() in some input methods + qic->unsetFocus(); + qic->setFocusWidget( 0 ); } -#endif // TQT_NO_XIM +#endif // TQT_NO_IM } + + +/*! + This function is called to send mouse event to associated input + context by derived text widgets. A derived text widget must be + calculate \a x as character offset at the mouse cursor in the + preedit. + + \sa TQInputContext::mouseHandler() + */ +void TQWidget::sendMouseEventToInputContext( int x, TQEvent::Type type, + TQt::ButtonState button, + TQt::ButtonState state ) +{ +#ifndef TQT_NO_IM + // trigger input context creation if it hasn't happened already + createInputContext(); + + TQInputContext *qic = getInputContext(); + if ( qic ) { + // may be causing reset() in some input methods + qic->mouseHandler( x, type, button, state ); + } +#endif // TQT_NO_IM +} + void TQWidget::setWindowOpacity(double) { diff --git a/tqtinterface/qt4/src/opengl/tqgl_x11.cpp b/tqtinterface/qt4/src/opengl/tqgl_x11.cpp index 56fc053..70abe7d 100644 --- a/tqtinterface/qt4/src/opengl/tqgl_x11.cpp +++ b/tqtinterface/qt4/src/opengl/tqgl_x11.cpp @@ -128,7 +128,7 @@ bool qt_resolve_gl_symbols(bool fatal) if (gl_syms_resolved) return TRUE; - TQLibrary gl("GL"); + TQLibrary gl("GL.so.1"); gl.setAutoUnload(FALSE); qt_glCallLists = (_glCallLists) gl.resolve("glCallLists"); @@ -286,7 +286,7 @@ static Colormap choose_cmap( Display *dpy, XVisualInfo *vi ) typedef Status (*_XmuLookupStandardColormap)( Display *dpy, int screen, VisualID visualid, unsigned int depth, Atom property, Bool tqreplace, Bool retain ); _XmuLookupStandardColormap qt_XmuLookupStandardColormap; - qt_XmuLookupStandardColormap = (_XmuLookupStandardColormap) TQLibrary::resolve("Xmu", "XmuLookupStandardColormap"); + qt_XmuLookupStandardColormap = (_XmuLookupStandardColormap) TQLibrary::resolve("Xmu.so.6", "XmuLookupStandardColormap"); if (!qt_XmuLookupStandardColormap) qFatal("Unable to resolve Xmu symbols - please check your Xmu library installation."); #define XmuLookupStandardColormap qt_XmuLookupStandardColormap diff --git a/tqtinterface/qt4/src/qt.pro b/tqtinterface/qt4/src/qt.pro index 9f91a6b..63e75d9 100644 --- a/tqtinterface/qt4/src/qt.pro +++ b/tqtinterface/qt4/src/qt.pro @@ -38,6 +38,7 @@ OPENGL_CPP = opengl TOOLS_CPP = tools CODECS_CPP = codecs WORKSPACE_CPP = workspace +INPUTMETHOD_CPP = inputmethod XML_CPP = xml STYLES_CPP = styles EMBEDDED_CPP = embedded @@ -55,6 +56,7 @@ win32 { TOOLS_H = $$TOOLS_CPP CODECS_H = $$CODECS_CPP WORKSPACE_H = $$WORKSPACE_CPP + #INPUTMETHOD_H = $$INPUTMETHOD_CPP XML_H = $$XML_CPP CANVAS_H = $$CANVAS_CPP STYLES_H = $$STYLES_CPP @@ -71,6 +73,7 @@ win32 { TOOLS_H = $$WIN_ALL_H CODECS_H = $$WIN_ALL_H WORKSPACE_H = $$WIN_ALL_H + #INPUTMETHOD_H = $$WIN_ALL_H XML_H = $$WIN_ALL_H CANVAS_H = $$WIN_ALL_H STYLES_H = $$WIN_ALL_H @@ -99,6 +102,7 @@ unix { TOOLS_H = $$TOOLS_CPP CODECS_H = $$CODECS_CPP WORKSPACE_H = $$WORKSPACE_CPP + INPUTMETHOD_H = $$INPUTMETHOD_CPP XML_H = $$XML_CPP STYLES_H = $$STYLES_CPP !embedded:!mac:CONFIG += x11 x11inc @@ -114,7 +118,7 @@ embedded { EMBEDDED_H = $$EMBEDDED_CPP } -DEPENDPATH += ;$$NETWORK_H;$$KERNEL_H;$$WIDGETS_H;$$SQL_H;$$TABLE_H;$$DIALOGS_H; +DEPENDPATH += ;$$NETWORK_H;$$KERNEL_H;$$WIDGETS_H;$$INPUTMETHOD_H;$$SQL_H;$$TABLE_H;$$DIALOGS_H; DEPENDPATH += $$ICONVIEW_H;$$OPENGL_H;$$TOOLS_H;$$CODECS_H;$$WORKSPACE_H;$$XML_H; DEPENDPATH += $$CANVAS_H;$$STYLES_H embedded:DEPENDPATH += ;$$EMBEDDED_H @@ -149,6 +153,7 @@ include($$WIDGETS_CPP/qt_widgets.pri) include($$DIALOGS_CPP/qt_dialogs.pri) include($$ICONVIEW_CPP/qt_iconview.pri) include($$WORKSPACE_CPP/qt_workspace.pri) +include($$INPUTMETHOD_CPP/qt_inputmethod.pri) include($$NETWORK_CPP/qt_network.pri) include($$CANVAS_CPP/qt_canvas.pri) include($$TABLE_CPP/qt_table.pri) @@ -176,6 +181,16 @@ unix { QMAKE_PKGCONFIG_INCDIR = $$headers.path } +unix { + # Debian - compile __debian_export_symbols.cpp with -fno-inline + debian_no_inline.output = .obj/${TQMAKE_FILE_BASE}.o + debian_no_inline.commands = $(CXX) -c $(CXXFLAGS) $(INCPATH) -fno-inline ${TQMAKE_FILE_NAME} -o ${TQMAKE_FILE_OUT} + debian_no_inline.input = DEBIAN_NO_INLINE + TQMAKE_EXTRA_UNIX_COMPILERS += debian_no_inline + + DEBIAN_NO_INLINE = __debian_export_symbols.cpp +} + wince-* { CONFIG -= incremental message( ...removing plugin stuff... (not permanent) ) diff --git a/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp b/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp index 955ecc4..ddc103a 100644 --- a/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp +++ b/tqtinterface/qt4/src/sql/drivers/ibase/tqsql_ibase.cpp @@ -767,7 +767,7 @@ TQIBaseDriver::TQIBaseDriver(void *connection, TQObject *tqparent, const char *n : TQSqlDriver(tqparent, name ? name : TQIBASE_DRIVER_NAME) { d = new TQIBaseDriverPrivate(this); - d->ibase = (isc_db_handle)connection; + d->ibase = (isc_db_handle)(long int)connection; setOpen(TRUE); setOpenError(FALSE); } diff --git a/tqtinterface/qt4/src/sql/qt_sql.pri b/tqtinterface/qt4/src/sql/qt_sql.pri index 198edee..29845f8 100644 --- a/tqtinterface/qt4/src/sql/qt_sql.pri +++ b/tqtinterface/qt4/src/sql/qt_sql.pri @@ -188,7 +188,7 @@ sql { SOURCES += $$SQL_CPP/drivers/ibase/tqsql_ibase.cpp DEFINES += TQT_SQL_IBASE unix { - LIBS *= -lgds + LIBS *= -lfbclient } win32 { !win32-borland:LIBS *= gds32_ms.lib diff --git a/tqtinterface/qt4/src/tools/tqdir_unix.cpp b/tqtinterface/qt4/src/tools/tqdir_unix.cpp index 5d69993..f96808b 100644 --- a/tqtinterface/qt4/src/tools/tqdir_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqdir_unix.cpp @@ -74,6 +74,20 @@ TQString TQDir::homeDirPath() TQString TQDir::canonicalPath() const { TQString r; +#if defined(__GLIBC__) && !defined(PATH_MAX) + char *cur = ::get_current_dir_name(); + if ( cur ) { + char *tmp = canonicalize_file_name( TQFile::encodeName( dPath ).data() ); + if ( tmp ) { + r = TQFile::decodeName( tmp ); + free( tmp ); + } + slashify( r ); + // always make sure we go back to the current dir + ::chdir( cur ); + free( cur ); + } +#else char cur[PATH_MAX+1]; if ( ::getcwd( cur, PATH_MAX ) ) { char tmp[PATH_MAX+1]; @@ -86,6 +100,7 @@ TQString TQDir::canonicalPath() const // always make sure we go back to the current dir ::chdir( cur ); } +#endif /* __GLIBC__ && !PATH_MAX */ return r; } @@ -147,9 +162,17 @@ TQString TQDir::currentDirPath() struct stat st; if ( ::stat( ".", &st ) == 0 ) { +#if defined(__GLIBC__) && !defined(PATH_MAX) + char *currentName = ::get_current_dir_name(); + if ( currentName ) { + result = TQFile::decodeName(currentName); + free( currentName ); + } +#else char currentName[PATH_MAX+1]; if ( ::getcwd( currentName, PATH_MAX ) ) result = TQFile::decodeName(currentName); +#endif /* __GLIBC__ && !PATH_MAX */ #if defined(TQT_DEBUG) if ( result.isNull() ) qWarning( "TQDir::currentDirPath: getcwd() failed" ); diff --git a/tqtinterface/qt4/src/tools/tqfeatures.h b/tqtinterface/qt4/src/tools/tqfeatures.h index f06fe39..dfafe61 100644 --- a/tqtinterface/qt4/src/tools/tqfeatures.h +++ b/tqtinterface/qt4/src/tools/tqfeatures.h @@ -982,3 +982,13 @@ #define TQT_NO_WORKSPACE #endif +// Input method +#if !defined(TQT_NO_IM) && (defined(TQT_NO_STRINGLIST)) +#define TQT_NO_IM +#endif + +// Input method extensions +#if !defined(TQT_NO_IM_EXTENSIONS) && (defined(TQT_NO_IM) || defined(TQT_NO_STRINGLIST)) +#define TQT_NO_IM_EXTENSIONS +#endif + diff --git a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp index 921b9f9..3be62bf 100644 --- a/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp +++ b/tqtinterface/qt4/src/tools/tqfileinfo_unix.cpp @@ -48,6 +48,9 @@ #if !defined(TQWS) && defined(TQ_OS_MAC) # include #endif +#if defined(Q_OS_HURD) +# include +#endif void TQFileInfo::slashify( TQString& ) { @@ -127,16 +130,43 @@ bool TQFileInfo::isSymLink() const TQString TQFileInfo::readLink() const { + if ( !isSymLink() ) + return TQString(); #if defined(TQ_OS_UNIX) && !defined(TQ_OS_OS2EMX) +#if defined(__GLIBC__) && !defined(PATH_MAX) + int size = 256; + char *s = NULL, *s2; + + while (1) + { + s2 = (char *) realloc (s, size); + if (s2 == NULL) { + free( s ); + return TQString(); + } + s = s2; + int len = readlink ( TQFile::encodeName(fn).data(), s, size ); + if ( len < 0 ) { + free( s ); + return TQString(); + } + if ( len < size ) { + s[len] = '\0'; + TQString str = TQFile::decodeName(s); + free(s); + return str; + } + size *= 2; + } +#else char s[PATH_MAX+1]; - if ( !isSymLink() ) - return TQString(); int len = readlink( TQFile::encodeName(fn).data(), s, PATH_MAX ); if ( len >= 0 ) { s[len] = '\0'; return TQFile::decodeName(s); } -#endif +#endif /* __GLIBC__ && !PATH_MAX */ +#endif /* Q_OS_UNIX && !Q_OS_OS2EMX */ #if !defined(TQWS) && defined(TQ_OS_MAC) { FSRef fref; diff --git a/tqtinterface/qt4/src/tools/tqglobal.h b/tqtinterface/qt4/src/tools/tqglobal.h index 3fe0fb0..693da3f 100644 --- a/tqtinterface/qt4/src/tools/tqglobal.h +++ b/tqtinterface/qt4/src/tools/tqglobal.h @@ -115,7 +115,9 @@ # define TQ_OS_ULTRIX #elif defined(sinix) # define TQ_OS_RELIANT -#elif defined(__linux__) || defined(__linux) +#elif defined(__GNU__) +# define TQ_OS_HURD +#elif defined(__linux__) || defined(__linux) || defined(__GNU__) || defined(__GLIBC__) # define TQ_OS_LINUX #elif defined(__FreeBSD__) || defined(__DragonFly__) # define TQ_OS_FREEBSD @@ -137,8 +139,6 @@ # define TQ_OS_AIX #elif defined(__Lynx__) # define TQ_OS_LYNX -#elif defined(__GNU_HURD__) -# define TQ_OS_HURD #elif defined(__DGUX__) # define TQ_OS_DGUX #elif defined(__TQNXNTO__) @@ -318,9 +318,9 @@ TQString bloat. However, gcc 3.4 doesn't allow us to create references to members of a packed struct. (Pointers are OK, because then you supposedly know what you are doing.) */ -# if (defined(__arm__) || defined(__ARMEL__)) && !defined(TQT_TQMOC_CPP) +# if (defined(__arm__) || defined(__ARMEL__)) && !defined(__ARM_EABI__) && !defined(TQT_TQMOC_CPP) # define TQ_PACKED __attribute__ ((packed)) -# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 +# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 || __GNUC__ > 3 # define TQ_NO_PACKED_REFERENCE # endif # endif diff --git a/tqtinterface/qt4/src/tools/tqlibrary.cpp b/tqtinterface/qt4/src/tools/tqlibrary.cpp index 140e017..cf34295 100644 --- a/tqtinterface/qt4/src/tools/tqlibrary.cpp +++ b/tqtinterface/qt4/src/tools/tqlibrary.cpp @@ -429,6 +429,7 @@ TQString TQLibrary::library() const } else { tmpfilename = TQString( "lib%1" ).arg( filename ); } + if ( !filename.tqcontains(".so") ) tmpfilename += filter; if(TQFile::exists(tmpfilename) || it == filters.end()) { filename = tmpfilename; diff --git a/tqtinterface/qt4/src/tools/tqlocale.cpp b/tqtinterface/qt4/src/tools/tqlocale.cpp index 26a3230..69c8c39 100644 --- a/tqtinterface/qt4/src/tools/tqlocale.cpp +++ b/tqtinterface/qt4/src/tools/tqlocale.cpp @@ -125,13 +125,24 @@ static inline double nan() #endif // We can't rely on -NAN, since all operations on a NAN should return a NAN. +static double be_neg_nan; +static double le_neg_nan; static const unsigned char be_neg_nan_bytes[] = { 0xff, 0xf8, 0, 0, 0, 0, 0, 0 }; static const unsigned char le_neg_nan_bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0xff }; +static bool neg_nan_init = false; + static inline double negNan() { + if (!neg_nan_init) + { + memcpy(&be_neg_nan,be_neg_nan_bytes,sizeof(be_neg_nan_bytes)); + memcpy(&le_neg_nan,le_neg_nan_bytes,sizeof(le_neg_nan_bytes)); + neg_nan_init = true; + } return (ByteOrder == BigEndian ? - *((const double *) be_neg_nan_bytes) : - *((const double *) le_neg_nan_bytes)); + be_neg_nan : + le_neg_nan); + } // Sizes as defined by the ISO C99 standard - fallback diff --git a/tqtinterface/qt4/src/tools/tqmap.h b/tqtinterface/qt4/src/tools/tqmap.h index 029f4a3..fe36e97 100644 --- a/tqtinterface/qt4/src/tools/tqmap.h +++ b/tqtinterface/qt4/src/tools/tqmap.h @@ -60,6 +60,7 @@ #ifndef TQT_NO_STL #include #include +#include #endif //#define TQT_CHECK_MAP_RANGE diff --git a/tqtinterface/qt4/src/tools/tqstring.h b/tqtinterface/qt4/src/tools/tqstring.h index b4db802..71bc563 100644 --- a/tqtinterface/qt4/src/tools/tqstring.h +++ b/tqtinterface/qt4/src/tools/tqstring.h @@ -754,7 +754,7 @@ public: char latin1() const { return ucs > 0xff ? 0 : (char) ucs; } ushort tqunicode() const { return ucs; } #ifdef TQ_NO_PACKED_REFERENCE - ushort &tqunicode() { return *(&ucs); } + ushort &tqunicode() { return *((ushort*)&ucs); } #else ushort &tqunicode() { return ucs; } #endif diff --git a/tqtinterface/qt4/src/tools/tqvaluelist.h b/tqtinterface/qt4/src/tools/tqvaluelist.h index 67c2574..799473a 100644 --- a/tqtinterface/qt4/src/tools/tqvaluelist.h +++ b/tqtinterface/qt4/src/tools/tqvaluelist.h @@ -50,6 +50,7 @@ #ifndef TQT_NO_STL #include #include +#include #endif //#define TQT_CHECK_VALUELIST_RANGE diff --git a/tqtinterface/qt4/src/widgets/tqbutton.h b/tqtinterface/qt4/src/widgets/tqbutton.h index f75de1a..42088a7 100644 --- a/tqtinterface/qt4/src/widgets/tqbutton.h +++ b/tqtinterface/qt4/src/widgets/tqbutton.h @@ -184,7 +184,7 @@ inline const TQPixmap *TQButton::pixmap() const inline bool TQButton::isToggleButton() const { - return toggleTyp != SingleShot; + return ToggleType(toggleTyp) != SingleShot; } inline bool TQButton::isDown() const @@ -194,7 +194,7 @@ inline bool TQButton::isDown() const inline bool TQButton::isOn() const { - return stat != Off; + return ToggleState(stat) != Off; } #ifndef TQT_NO_COMPAT diff --git a/tqtinterface/qt4/src/widgets/tqcombobox.cpp b/tqtinterface/qt4/src/widgets/tqcombobox.cpp index d152da2..6305993 100644 --- a/tqtinterface/qt4/src/widgets/tqcombobox.cpp +++ b/tqtinterface/qt4/src/widgets/tqcombobox.cpp @@ -392,12 +392,8 @@ public: inline TQListBox * listBox() { return lBox; } inline TQComboBoxPopup * popup() { return pop; } void updateLinedGeometry(); - - void setListBox( TQListBox *l ) { lBox = l ; usingLBox = TRUE; - l->setMouseTracking( TRUE );} - - void setPopupMenu( TQComboBoxPopup * pm, bool isPopup=TRUE ) - { pop = pm; if(isPopup) usingLBox = FALSE; } + void setListBox( TQListBox *l ); + void setPopupMenu( TQComboBoxPopup * pm, bool isPopup=TRUE ); int current; int maxCount; @@ -443,6 +439,30 @@ void TQComboBoxData::updateLinedGeometry() ed->setGeometry( r ); } +void TQComboBoxData::setListBox( TQListBox *l ) +{ + lBox = l; + usingLBox = TRUE; + l->setMouseTracking( TRUE ); +#ifdef TQ_WS_X11 + l->x11SetWindowType( TQWidget::X11WindowTypeCombo ); + l->x11SetWindowTransient( combo->tqtopLevelWidget()); +#endif +} + +void TQComboBoxData::setPopupMenu( TQComboBoxPopup * pm, bool isPopup ) +{ + pop = pm; + if(isPopup) + usingLBox = FALSE; +#ifdef TQ_WS_X11 + if( pm ) { + pm->x11SetWindowType( TQWidget::X11WindowTypeCombo ); + pm->x11SetWindowTransient( combo->tqtopLevelWidget()); + } +#endif +} + static inline bool checkInsertIndex( const char *method, const char * name, int count, int *index) { diff --git a/tqtinterface/qt4/src/widgets/tqlineedit.cpp b/tqtinterface/qt4/src/widgets/tqlineedit.cpp index 2d41152..10c1be8 100644 --- a/tqtinterface/qt4/src/widgets/tqlineedit.cpp +++ b/tqtinterface/qt4/src/widgets/tqlineedit.cpp @@ -40,6 +40,12 @@ #include "tqlineedit.h" #ifndef TQT_NO_LINEEDIT + +// Keep this position to avoid patch rejection +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#endif + #include "tqpainter.h" #include "tqdrawutil.h" #include "tqfontmetrics.h" @@ -248,12 +254,17 @@ struct TQLineEditPrivate : public TQt // input methods int imstart, imend, imselstart, imselend; + bool composeMode() const { return preeditLength(); } + bool hasIMSelection() const { return imSelectionLength(); } + int preeditLength() const { return ( imend - imstart ); } + int imSelectionLength() const { return ( imselend - imselstart ); } // complex text tqlayout TQTextLayout textLayout; void updateTextLayout(); void moveCursor( int pos, bool mark = FALSE ); void setText( const TQString& txt ); + int xToPosInternal( int x, TQTextItem::CursorPosition ) const; int xToPos( int x, TQTextItem::CursorPosition = TQTextItem::BetweenCharacters ) const; inline int visualAlignment() const { return tqalignment ? tqalignment : int( isRightToLeft() ? TQt::AlignRight : TQt::AlignLeft ); } TQRect cursorRect() const; @@ -591,6 +602,7 @@ void TQLineEdit::setEchoMode( EchoMode mode ) return; d->echoMode = mode; d->updateTextLayout(); + setInputMethodEnabled( mode == Normal ); update(); } @@ -1422,6 +1434,8 @@ bool TQLineEdit::event( TQEvent * e ) */ void TQLineEdit::mousePressEvent( TQMouseEvent* e ) { + if ( sendMouseEventToInputContext( e ) ) + return; if ( e->button() == Qt::RightButton ) return; if ( d->tripleClickTimer && ( e->pos() - d->tripleClick ).manhattanLength() < @@ -1451,7 +1465,8 @@ void TQLineEdit::mousePressEvent( TQMouseEvent* e ) */ void TQLineEdit::mouseMoveEvent( TQMouseEvent * e ) { - + if ( sendMouseEventToInputContext( e ) ) + return; #ifndef TQT_NO_CURSOR if ( ( e->state() & Qt::MouseButtonMask ) == 0 ) { if ( !d->readOnly && d->dragEnabled @@ -1480,6 +1495,8 @@ void TQLineEdit::mouseMoveEvent( TQMouseEvent * e ) */ void TQLineEdit::mouseReleaseEvent( TQMouseEvent* e ) { + if ( sendMouseEventToInputContext( e ) ) + return; #ifndef TQT_NO_DRAGANDDROP if ( e->button() == Qt::LeftButton ) { if ( d->dndTimer ) { @@ -1506,6 +1523,8 @@ void TQLineEdit::mouseReleaseEvent( TQMouseEvent* e ) */ void TQLineEdit::mouseDoubleClickEvent( TQMouseEvent* e ) { + if ( sendMouseEventToInputContext( e ) ) + return; if ( e->button() == Qt::LeftButton ) { deselect(); d->cursor = d->xToPos( e->pos().x() ); @@ -1775,6 +1794,33 @@ void TQLineEdit::keyPressEvent( TQKeyEvent * e ) e->ignore(); } + +/*! + This function is not intended as polymorphic usage. Just a shared code + fragment that calls TQWidget::sendMouseEventToInputContext() easily for this + class. + */ +bool TQLineEdit::sendMouseEventToInputContext( TQMouseEvent *e ) +{ +#ifndef TQT_NO_IM + if ( d->composeMode() ) { + int cursor = d->xToPosInternal( e->pos().x(), TQTextItem::OnCharacters ); + int mousePos = cursor - d->imstart; + if ( mousePos >= 0 && mousePos < d->preeditLength() ) { + TQWidget::sendMouseEventToInputContext( mousePos, e->type(), + e->button(), e->state() ); + } else if ( e->type() != TQEvent::MouseMove ) { + // send button events on out of preedit + TQWidget::sendMouseEventToInputContext( -1, e->type(), + e->button(), e->state() ); + } + return TRUE; + } +#endif + return FALSE; +} + + /*! \reimp */ void TQLineEdit::imStartEvent( TQIMEvent *e ) @@ -1841,6 +1887,8 @@ void TQLineEdit::focusInEvent( TQFocusEvent* tqfe ) } if( !hasSelectedText() || tqstyle().tqstyleHint( TQStyle::SH_BlinkCursorWhenTextSelected ) ) d->setCursorVisible( TRUE ); + if ( d->hasIMSelection() ) + d->cursor = d->imselstart; d->updateMicroFocusHint(); } @@ -1934,6 +1982,14 @@ void TQLineEdit::drawContents( TQPainter *p ) } else if (d->hscroll < 0) { d->hscroll = 0; } + // This updateMicroFocusHint() is corresponding to update() at + // IMCompose event. Although the function is invoked from various + // other points, some situations such as "candidate selection on + // AlignHCenter'ed text" need this invocation because + // updateMicroFocusHint() requires updated contentsRect(), and + // there are no other chances in such situation that invoke the + // function. + d->updateMicroFocusHint(); // the y offset is there to keep the baseline constant in case we have script changes in the text. TQPoint topLeft = lineRect.topLeft() - TQPoint(d->hscroll, d->ascent-fm.ascent()); @@ -1974,7 +2030,7 @@ void TQLineEdit::drawContents( TQPainter *p ) } // input method edit area - if ( d->imstart < d->imend && (last >= d->imstart && first < d->imend ) ) { + if ( d->composeMode() && (last >= d->imstart && first < d->imend ) ) { TQRect highlight = TQRect( TQPoint( tix + ti.cursorToX( TQMAX( d->imstart - first, 0 ) ), lineRect.top() ), TQPoint( tix + ti.cursorToX( TQMIN( d->imend - first, last - first + 1 ) )-1, lineRect.bottom() ) ).normalize(); p->save(); @@ -1987,11 +2043,16 @@ void TQLineEdit::drawContents( TQPainter *p ) imCol.setHsv( h1, s1, ( v1 + v2 ) / 2 ); p->fillRect( highlight, imCol ); p->tqdrawTextItem( topLeft, ti, textflags ); + // draw preedit's underline + if (d->imend - d->imstart > 0) { + p->setPen( cg.text() ); + p->drawLine( highlight.bottomLeft(), highlight.bottomRight() ); + } p->restore(); } // input method selection - if ( d->imselstart < d->imselend && (last >= d->imselstart && first < d->imselend ) ) { + if ( d->hasIMSelection() && (last >= d->imselstart && first < d->imselend ) ) { TQRect highlight = TQRect( TQPoint( tix + ti.cursorToX( TQMAX( d->imselstart - first, 0 ) ), lineRect.top() ), TQPoint( tix + ti.cursorToX( TQMIN( d->imselend - first, last - first + 1 ) )-1, lineRect.bottom() ) ).normalize(); p->save(); @@ -2019,7 +2080,11 @@ void TQLineEdit::drawContents( TQPainter *p ) } // draw cursor - if ( d->cursorVisible && !supressCursor ) { + // + // Asian users regard IM selection text as cursor on candidate + // selection phase of input method, so ordinary cursor should be + // invisible if IM selection text exists. + if ( d->cursorVisible && !supressCursor && !d->hasIMSelection() ) { TQPoint from( topLeft.x() + cix, lineRect.top() ); TQPoint to = from + TQPoint( 0, lineRect.height() ); p->drawLine( from, to ); @@ -2134,6 +2199,10 @@ enum { IdUndo, IdRedo, IdSep1, IdCut, IdCopy, IdPaste, IdClear, IdSep2, IdSelect void TQLineEdit::contextMenuEvent( TQContextMenuEvent * e ) { #ifndef TQT_NO_POPUPMENU +#ifndef TQT_NO_IM + if ( d->composeMode() ) + return; +#endif d->separate(); TQPopupMenu *menu = createPopupMenu(); if (!menu) @@ -2187,6 +2256,13 @@ TQPopupMenu *TQLineEdit::createPopupMenu() + ACCEL_KEY( A ) #endif ); + +#ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->addMenusTo( popup ); +#endif + popup->setItemEnabled( id - IdUndo, d->isUndoAvailable() ); popup->setItemEnabled( id - IdRedo, d->isRedoAvailable() ); #ifndef TQT_NO_CLIPBOARD @@ -2320,7 +2396,7 @@ void TQLineEditPrivate::updateTextLayout() textLayout.endLine(0, 0, TQt::AlignLeft|TQt::SingleLine, &ascent); } -int TQLineEditPrivate::xToPos( int x, TQTextItem::CursorPosition betweenOrOn ) const +int TQLineEditPrivate::xToPosInternal( int x, TQTextItem::CursorPosition betweenOrOn ) const { x-= q->contentsRect().x() - hscroll + innerMargin; for ( int i = 0; i < textLayout.numItems(); ++i ) { @@ -2329,7 +2405,13 @@ int TQLineEditPrivate::xToPos( int x, TQTextItem::CursorPosition betweenOrOn ) c if ( x >= tir.left() && x <= tir.right() ) return ti.xToCursor( x - tir.x(), betweenOrOn ) + ti.from(); } - return x < 0 ? 0 : text.length(); + return x < 0 ? -1 : text.length(); +} + +int TQLineEditPrivate::xToPos( int x, TQTextItem::CursorPosition betweenOrOn ) const +{ + int pos = xToPosInternal( x, betweenOrOn ); + return ( pos < 0 ) ? 0 : pos; } @@ -2350,9 +2432,19 @@ TQRect TQLineEditPrivate::cursorRect() const void TQLineEditPrivate::updateMicroFocusHint() { + // To reduce redundant microfocus update notification, we remember + // the old rect and update the microfocus if actual update is + // required. The rect o is intentionally static because some + // notifyee requires the microfocus information as global update + // rather than per notifyee update to place shared widget around + // microfocus. + static TQRect o; if ( q->hasFocus() ) { - TQRect r = cursorRect(); - q->setMicroFocusHint( r.x(), r.y(), r.width(), r.height() ); + TQRect r = cursorRect(); + if ( o != r ) { + o = r; + q->setMicroFocusHint( r.x(), r.y(), r.width(), r.height() ); + } } } diff --git a/tqtinterface/qt4/src/widgets/tqlineedit.h b/tqtinterface/qt4/src/widgets/tqlineedit.h index a8c3242..0b7fd52 100644 --- a/tqtinterface/qt4/src/widgets/tqlineedit.h +++ b/tqtinterface/qt4/src/widgets/tqlineedit.h @@ -202,6 +202,7 @@ protected: void dropEvent( TQDropEvent * ); #endif void contextMenuEvent( TQContextMenuEvent * ); + bool sendMouseEventToInputContext( TQMouseEvent *e ); virtual TQPopupMenu *createPopupMenu(); void windowActivationChange( bool ); #ifndef TQT_NO_COMPAT diff --git a/tqtinterface/qt4/src/widgets/tqlistview.cpp b/tqtinterface/qt4/src/widgets/tqlistview.cpp index bd706e9..46060c8 100644 --- a/tqtinterface/qt4/src/widgets/tqlistview.cpp +++ b/tqtinterface/qt4/src/widgets/tqlistview.cpp @@ -4569,6 +4569,7 @@ void TQListView::contentsMouseReleaseEventEx( TQMouseEvent * e ) } emitClicked = emitClicked && d->pressedItem == i; d->pressedItem = 0; + d->highlighted = 0; if ( emitClicked ) { if ( !i || ( i && i->isEnabled() ) ) { @@ -7597,21 +7598,21 @@ TQListViewItemIterator::~TQListViewItemIterator() TQListViewItemIterator &TQListViewItemIterator::operator++() { - if ( !curr ) - return *this; + do { + if ( !curr ) + return *this; - TQListViewItem *item = curr->firstChild(); - if ( !item ) { - while ( (item = curr->nextSibling()) == 0 ) { - curr = curr->tqparent(); - if ( curr == 0 ) - break; + TQListViewItem *item = curr->firstChild(); + if ( !item ) { + while ( (item = curr->nextSibling()) == 0 ) { + curr = curr->tqparent(); + if ( curr == 0 ) + break; + } } - } - curr = item; - // if the next one doesn't match the flags we try one more ahead - if ( curr && !matchesFlags( curr ) ) - ++( *this ); + curr = item; + // if the next one doesn't match the flags we try one more ahead + } while ( curr && !matchesFlags( curr ) ); return *this; } diff --git a/tqtinterface/qt4/src/widgets/tqmenubar.cpp b/tqtinterface/qt4/src/widgets/tqmenubar.cpp index aadb3ee..c8fed6d 100644 --- a/tqtinterface/qt4/src/widgets/tqmenubar.cpp +++ b/tqtinterface/qt4/src/widgets/tqmenubar.cpp @@ -231,6 +231,10 @@ static const int motifItemFrame = 2; // menu item frame width static const int motifItemHMargin = 5; // menu item hor text margin static const int motifItemVMargin = 4; // menu item ver text margin +// The others are 0 +static const int gtkItemHMargin = 8; +static const int gtkItemVMargin = 8; + /* +----------------------------- @@ -295,7 +299,14 @@ TQMenuBar::TQMenuBar( TQWidget *tqparent, const char *name ) setFrameStyle( TQFrame::MenuBarPanel | TQFrame::Raised ); TQFontMetrics fm = fontMetrics(); - int h = 2*motifBarVMargin + fm.height() + motifItemVMargin + 2*frameWidth() + 2*motifItemFrame; + + int h; + int gs = style().tqstyleHint(TQStyle::SH_GUIStyle); + if (gs == GtkStyle) { + h = fm.height() + gtkItemVMargin; + } else { + h = 2*motifBarVMargin + fm.height() + motifItemVMargin + 2*frameWidth() + 2*motifItemFrame; + } setGeometry( 0, 0, width(), h ); @@ -949,12 +960,19 @@ int TQMenuBar::calculateRects( int max_width ) h = TQMAX( mi->pixmap()->height() + 4, TQApplication::globalStrut().height() ); } else if ( !mi->text().isNull() ) { // text item TQString s = mi->text(); - w = fm.boundingRect( s ).width() - + 2*motifItemHMargin; + if ( gs == GtkStyle ) { + w = fm.boundingRect( s ).width() + 2*gtkItemHMargin; + } else { + w = fm.boundingRect( s ).width() + 2*motifItemHMargin; + } w -= s.tqcontains('&')*fm.width('&'); w += s.tqcontains("&&")*fm.width('&'); w = TQMAX( w, TQApplication::globalStrut().width() ); - h = TQMAX( fm.height() + motifItemVMargin, TQApplication::globalStrut().height() ); + if (gs == GtkStyle ) { + h = TQMAX( fm.height() + gtkItemVMargin, TQApplication::globalStrut().height() ); + } else { + h = TQMAX( fm.height() + motifItemVMargin, TQApplication::globalStrut().height() ); + } } else if ( mi->isSeparator() ) { // separator item if ( tqstyle().tqstyleHint(TQStyle::SH_GUIStyle) == TQt::MotifStyle ) separator = i; //### only motif? diff --git a/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp b/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp index bbfdb60..993c065 100644 --- a/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp +++ b/tqtinterface/qt4/src/widgets/tqpopupmenu.cpp @@ -224,6 +224,8 @@ static TQMenuItem* whatsThisItem = 0; Pop-Up\endlink */ +static const int gtkArrowHMargin = 0; // arrow horizontal margin +static const int gtkArrowVMargin = 0; // arrow vertical margin /*! \fn void TQPopupMenu::aboutToShow() @@ -272,6 +274,8 @@ public: } scroll; TQSize calcSize; TQRegion mouseMoveBuffer; + uint hasmouse : 1; + TQPoint ignoremousepos; }; static TQPopupMenu* active_popup_menu = 0; @@ -291,6 +295,7 @@ TQPopupMenu::TQPopupMenu( TQWidget *tqparent, const char *name ) d->scroll.scrollableSize = d->scroll.topScrollableIndex = 0; d->scroll.scrollable = TQPopupMenuPrivate::Scroll::ScrollNone; d->scroll.scrolltimer = 0; + d->hasmouse = 0; isPopupMenu = TRUE; #ifndef TQT_NO_ACCEL autoaccel = 0; @@ -314,6 +319,9 @@ TQPopupMenu::TQPopupMenu( TQWidget *tqparent, const char *name ) connectModalRecursionSafety = 0; setFocusPolicy( Qt::StrongFocus ); +#ifdef TQ_WS_X11 + x11SetWindowType( X11WindowTypePopup ); +#endif } /*! @@ -473,6 +481,15 @@ void TQPopupMenu::frameChanged() menuContentsChanged(); } +TQRect TQPopupMenu::screenRect( const TQPoint& pos ) +{ + int screen_num = TQApplication::desktop()->screenNumber( pos ); +#ifdef TQ_WS_MAC + return TQApplication::desktop()->availableGeometry( screen_num ); +#else + return TQApplication::desktop()->screenGeometry( screen_num ); +#endif +} /*! Displays the popup menu so that the item number \a indexAtPoint will be at the specified \e global position \a pos. To translate a @@ -517,6 +534,15 @@ void TQPopupMenu::popup( const TQPoint &pos, int indexAtPoint ) // point. #endif + TQRect screen = screenRect( tqgeometry().center()); + TQRect screen2 = screenRect( TQApplication::reverseLayout() + ? pos+TQPoint(width(),0) : pos ); + // if the widget is not in the screen given by the position, move it + // there, so that updateSize() uses the right size of the screen + if( screen != screen2 ) { + screen = screen2; + move( screen.x(), screen.y()); + } if(d->scroll.scrollable) { d->scroll.scrollable = TQPopupMenuPrivate::Scroll::ScrollNone; d->scroll.topScrollableIndex = d->scroll.scrollableSize = 0; @@ -536,18 +562,6 @@ void TQPopupMenu::popup( const TQPoint &pos, int indexAtPoint ) updateSize(TRUE); } - int screen_num; - if (TQApplication::desktop()->isVirtualDesktop()) - screen_num = - TQApplication::desktop()->screenNumber( TQApplication::reverseLayout() ? - pos+TQPoint(width(),0) : pos ); - else - screen_num = TQApplication::desktop()->screenNumber( this ); -#ifdef TQ_WS_MAC - TQRect screen = TQApplication::desktop()->availableGeometry( screen_num ); -#else - TQRect screen = TQApplication::desktop()->screenGeometry( screen_num ); -#endif int sw = screen.width(); // screen width int sh = screen.height(); // screen height int sx = screen.x(); // screen pos @@ -571,6 +585,29 @@ void TQPopupMenu::popup( const TQPoint &pos, int indexAtPoint ) if ( y < sy ) y = sy; } +#ifdef TQ_WS_X11 +#ifndef TQT_NO_MENUBAR + TQMenuData *top = this; // find top level + while ( top->parentMenu ) + top = top->parentMenu; + if( top->isMenuBar ) + x11SetWindowType( X11WindowTypeDropdown ); + if( parentMenu && parentMenu->isMenuBar ) + x11SetWindowTransient( static_cast< TQMenuBar* >( parentMenu )->tqtopLevelWidget()); +#endif + if( parentMenu && !parentMenu->isMenuBar ) + x11SetWindowTransient( static_cast< TQPopupMenu* >( parentMenu )); + if( !parentMenu ) { + // hackish ... try to find the main window related to this popup + TQWidget* tqparent = parentWidget() ? parentWidget()->tqtopLevelWidget() : NULL; + if( tqparent == NULL ) + tqparent = TQApplication::widgetAt( pos ); + if( tqparent == NULL ) + tqparent = tqApp->activeWindow(); + if( tqparent != NULL ) + x11SetWindowTransient( tqparent ); + } +#endif if ( x+w > sx+sw ) // the complete widget must x = sx+sw - w; // be visible @@ -1075,7 +1112,7 @@ TQSize TQPopupMenu::updateSize(bool force_update, bool do_resize) mi->iconSet()->pixmap( TQIconSet::Small, TQIconSet::Normal ).width() + 4 ); } - int dh = TQApplication::desktop()->height(); + int dh = screenRect( tqgeometry().center()).height(); ncols = 1; for ( TQMenuItemListIt it2( *mitems ); it2.current(); ++it2 ) { @@ -1389,6 +1426,7 @@ void TQPopupMenu::show() popupActive = -1; if(tqstyle().tqstyleHint(TQStyle::SH_PopupMenu_SubMenuPopupDelay, this)) d->mouseMoveBuffer = TQRegion(); + d->ignoremousepos = TQCursor::pos(); } /*! @@ -1414,6 +1452,13 @@ void TQPopupMenu::hide() mouseBtDn = FALSE; // mouse button up #if defined(TQT_ACCESSIBILITY_SUPPORT) TQAccessible::updateAccessibility( this, 0, TQAccessible::PopupMenuEnd ); +#endif +#ifndef TQT_NO_MENUBAR + TQMenuData *top = this; // find top level + while ( top->parentMenu ) + top = top->parentMenu; + if( top->isMenuBar ) + x11SetWindowType( X11WindowTypePopup ); // reset #endif parentMenu = 0; hidePopups(); @@ -1738,6 +1783,11 @@ void TQPopupMenu::mouseReleaseEvent( TQMouseEvent *e ) void TQPopupMenu::mouseMoveEvent( TQMouseEvent *e ) { + if( e->globalPos() == d->ignoremousepos ) { + return; + } + d->ignoremousepos = TQPoint(); + motion++; if ( parentMenu && parentMenu->isPopupMenu ) { @@ -1778,6 +1828,11 @@ void TQPopupMenu::mouseMoveEvent( TQMouseEvent *e ) int item = itemAtPos( e->pos() ); if ( item == -1 ) { // no valid item + if( !d->hasmouse ) { + tryMenuBar( e ); + return; + } + d->hasmouse = 0; int lastActItem = actItem; actItem = -1; if ( lastActItem >= 0 ) @@ -1789,6 +1844,7 @@ void TQPopupMenu::mouseMoveEvent( TQMouseEvent *e ) } } else { // mouse on valid item // but did not register mouse press + d->hasmouse = 1; if ( (e->state() & Qt::MouseButtonMask) && !mouseBtDn ) mouseBtDn = TRUE; // so mouseReleaseEvent will pop down @@ -2200,6 +2256,7 @@ void TQPopupMenu::timerEvent( TQTimerEvent *e ) */ void TQPopupMenu::leaveEvent( TQEvent * ) { + d->hasmouse = 0; if ( testWFlags( TQt::WStyle_Tool ) && tqstyle().tqstyleHint(TQStyle::SH_PopupMenu_MouseTracking, this) ) { int lastActItem = actItem; actItem = -1; @@ -2329,27 +2386,37 @@ void TQPopupMenu::subMenuTimer() { TQRect r( itemGeometry( actItem ) ); TQPoint p; TQSize ps = popup->tqsizeHint(); + // GUI Style + int gs = style().tqstyleHint(TQStyle::SH_GUIStyle); + int arrowHMargin, arrowVMargin; + if (gs == GtkStyle) { + arrowHMargin = gtkArrowHMargin; + arrowVMargin = gtkArrowVMargin; + } else { + arrowHMargin = motifArrowHMargin; + arrowVMargin = motifArrowVMargin; + } if( TQApplication::reverseLayout() ) { - p = TQPoint( r.left() + motifArrowHMargin - ps.width(), r.top() + motifArrowVMargin ); + p = TQPoint( r.left() + arrowHMargin - ps.width(), r.top() + arrowVMargin ); p = mapToGlobal( p ); bool right = FALSE; if ( ( parentMenu && parentMenu->isPopupMenu && ((TQPopupMenu*)parentMenu)->tqgeometry().x() < tqgeometry().x() ) || - p.x() < 0 ) + p.x() < screenRect( p ).left()) right = TRUE; - if ( right && (ps.width() > TQApplication::desktop()->width() - mapToGlobal( r.topRight() ).x() ) ) + if ( right && (ps.width() > screenRect( p ).right() - mapToGlobal( r.topRight() ).x() ) ) right = FALSE; if ( right ) p.setX( mapToGlobal( r.topRight() ).x() ); } else { - p = TQPoint( r.right() - motifArrowHMargin, r.top() + motifArrowVMargin ); + p = TQPoint( r.right() - arrowHMargin, r.top() + arrowVMargin ); p = mapToGlobal( p ); bool left = FALSE; if ( ( parentMenu && parentMenu->isPopupMenu && ((TQPopupMenu*)parentMenu)->tqgeometry().x() > tqgeometry().x() ) || - p.x() + ps.width() > TQApplication::desktop()->width() ) + p.x() + ps.width() > screenRect( p ).right() ) left = TRUE; if ( left && (ps.width() > mapToGlobal( r.topLeft() ).x() ) ) left = FALSE; @@ -2357,8 +2424,8 @@ void TQPopupMenu::subMenuTimer() { p.setX( mapToGlobal( r.topLeft() ).x() - ps.width() ); } TQRect pr = popup->itemGeometry(popup->count() - 1); - if (p.y() + ps.height() > TQApplication::desktop()->height() && - p.y() - ps.height() + (TQCOORD) pr.height() >= 0) + if (p.y() + ps.height() > screenRect( p ).bottom() && + p.y() - ps.height() + (TQCOORD) pr.height() >= screenRect( p ).top()) p.setY( p.y() - ps.height() + (TQCOORD) pr.height()); if ( tqstyle().tqstyleHint(TQStyle::SH_PopupMenu_SloppySubMenus, this )) { @@ -2569,7 +2636,7 @@ TQSize TQPopupMenu::tqsizeHint() const constPolish(); TQPopupMenu* that = (TQPopupMenu*) this; //We do not need a resize here, just the tqsizeHint.. - return that->updateSize(FALSE, FALSE).expandedTo( TQApplication::globalStrut() ); + return that->updateSize(FALSE).expandedTo( TQApplication::globalStrut() ); } @@ -2730,6 +2797,9 @@ void TQPopupMenu::toggleTearOff() tqgeometry().topLeft(), FALSE ); p->mitems->setAutoDelete( FALSE ); p->tornOff = TRUE; +#ifdef TQ_WS_X11 + p->x11SetWindowType( X11WindowTypeMenu ); +#endif for ( TQMenuItemListIt it( *mitems ); it.current(); ++it ) { if ( it.current()->id() != TQMenuData::d->aInt && !it.current()->widget() ) p->mitems->append( it.current() ); diff --git a/tqtinterface/qt4/src/widgets/tqpopupmenu.h b/tqtinterface/qt4/src/widgets/tqpopupmenu.h index 0dd00b5..8863cd5 100644 --- a/tqtinterface/qt4/src/widgets/tqpopupmenu.h +++ b/tqtinterface/qt4/src/widgets/tqpopupmenu.h @@ -156,6 +156,7 @@ private: TQSize updateSize(bool force_recalc=FALSE, bool do_resize=TRUE); void updateRow( int row ); + TQRect screenRect(const TQPoint& pos); #ifndef TQT_NO_ACCEL void updateAccel( TQWidget * ); void enableAccel( bool ); diff --git a/tqtinterface/qt4/src/widgets/tqscrollview.cpp b/tqtinterface/qt4/src/widgets/tqscrollview.cpp index 49c5b4d..3ba7eec 100644 --- a/tqtinterface/qt4/src/widgets/tqscrollview.cpp +++ b/tqtinterface/qt4/src/widgets/tqscrollview.cpp @@ -1553,6 +1553,9 @@ bool TQScrollView::eventFilter( TQObject *obj, TQEvent *e ) case TQEvent::LayoutHint: d->autoRetqsizeHint(this); break; + case TQEvent::WindowActivate: + case TQEvent::WindowDeactivate: + return TRUE; default: break; } @@ -1865,7 +1868,7 @@ void TQScrollView::viewportWheelEvent( TQWheelEvent* e ) the event itself. */ TQWheelEvent ce( viewportToContents(e->pos()), - e->globalPos(), e->delta(), e->state()); + e->globalPos(), e->delta(), e->state(), e->orientation()); contentsWheelEvent(&ce); if ( ce.isAccepted() ) e->accept(); diff --git a/tqtinterface/qt4/src/widgets/tqtextedit.cpp b/tqtinterface/qt4/src/widgets/tqtextedit.cpp index 62c1d5f..e299348 100644 --- a/tqtinterface/qt4/src/widgets/tqtextedit.cpp +++ b/tqtinterface/qt4/src/widgets/tqtextedit.cpp @@ -42,6 +42,11 @@ #ifndef TQT_NO_TEXTEDIT +// Keep this position to avoid patch rejection +#ifndef TQT_NO_IM +#include "tqinputcontext.h" +#endif + #include "../kernel/tqrichtext_p.h" #include "tqpainter.h" #include "tqpen.h" @@ -111,6 +116,8 @@ public: int id[ 7 ]; int preeditStart; int preeditLength; + bool composeMode() const { return ( preeditLength > 0 ); } + uint ensureCursorVisibleInShowEvent : 1; uint tabChangesFocus : 1; TQString scrollToAnchor; // used to deferr scrollToAnchor() until the show event when we are resized @@ -1081,6 +1088,10 @@ void TQTextEdit::drawContents( TQPainter *p, int cx, int cy, int cw, int ch ) l += v; } } + + // This invocation is required to follow dragging of active window + // by the showed candidate window. + updateMicroFocusHint(); } /*! @@ -1555,6 +1566,35 @@ void TQTextEdit::keyPressEvent( TQKeyEvent *e ) e->ignore(); } +/*! + This function is not intended as polymorphic usage. Just a shared code + fragment that calls TQWidget::sendMouseEventToInputContext() easily for this + class. + */ +bool TQTextEdit::sendMouseEventToInputContext( TQMouseEvent *e ) +{ +#ifndef TQT_NO_IM + if ( d->composeMode() ) { + TQTextCursor c( doc ); + if ( c.place( e->pos(), doc->firstParagraph(), FALSE, FALSE, FALSE ) ) { + int mousePos = c.index() - d->preeditStart; + if ( cursor->globalY() == c.globalY() && + mousePos >= 0 && mousePos < d->preeditLength ) { + TQWidget::sendMouseEventToInputContext( mousePos, e->type(), + e->button(), e->state() ); + } + } else if ( e->type() != TQEvent::MouseMove ) { + // send button events on out of preedit + TQWidget::sendMouseEventToInputContext( -1, e->type(), + e->button(), e->state() ); + } + return TRUE; + } +#endif + return FALSE; +} + + /*! \reimp */ @@ -1585,11 +1625,17 @@ void TQTextEdit::imComposeEvent( TQIMEvent *e ) doc->removeSelection( TQTextDocument::IMCompositionText ); doc->removeSelection( TQTextDocument::IMSelectionText ); - if ( d->preeditLength > 0 && cursor->paragraph() ) + if ( d->composeMode() && cursor->paragraph() ) cursor->paragraph()->remove( d->preeditStart, d->preeditLength ); cursor->setIndex( d->preeditStart ); d->preeditLength = e->text().length(); - insert( e->text() ); + + int sellen = e->selectionLength(); + uint insertionFlags = CheckNewLines | RemoveSelected | AsIMCompositionText; + if ( sellen > 0 ) { + insertionFlags |= WithIMSelection; + } + insert( e->text(), insertionFlags ); // insert can trigger an imEnd event as it emits a textChanged signal, so better // be careful if(d->preeditStart != -1) { @@ -1601,14 +1647,20 @@ void TQTextEdit::imComposeEvent( TQIMEvent *e ) cursor->setIndex( d->preeditStart + e->cursorPos() ); - int sellen = e->selectionLength(); if ( sellen > 0 ) { cursor->setIndex( d->preeditStart + e->cursorPos() + sellen ); c = *cursor; cursor->setIndex( d->preeditStart + e->cursorPos() ); doc->setSelectionStart( TQTextDocument::IMSelectionText, *cursor ); doc->setSelectionEnd( TQTextDocument::IMSelectionText, c ); +#if 0 + // Disabled for Asian input method that shows candidate + // window. This behavior is same as TQt/E 2.3.7 which supports + // Asian input methods. Asian input methods need start point + // of IM selection text to place candidate window as adjacent + // to the selection text. cursor->setIndex( d->preeditStart + d->preeditLength ); +#endif } } @@ -1632,11 +1684,12 @@ void TQTextEdit::imEndEvent( TQIMEvent *e ) if (undoRedoInfo.type == UndoRedoInfo::IME) undoRedoInfo.type = UndoRedoInfo::Invalid; - if ( d->preeditLength > 0 && cursor->paragraph() ) + if ( d->composeMode() && cursor->paragraph() ) cursor->paragraph()->remove( d->preeditStart, d->preeditLength ); if ( d->preeditStart >= 0 ) { cursor->setIndex( d->preeditStart ); - insert( e->text() ); + //TODO: TQt 4 we should use the new virtual insert function + insert( e->text(), FALSE ); } d->preeditStart = d->preeditLength = -1; @@ -2127,6 +2180,13 @@ void TQTextEdit::drawCursor( bool visible ) isReadOnly() ) return; + // Asian users regard selection text as cursor on candidate + // selection phase of input method, so ordinary cursor should be + // invisible if IM selection text exists. + if ( doc->hasSelection( TQTextDocument::IMSelectionText ) ) { + visible = FALSE; + } + TQPainter p( viewport() ); TQRect r( cursor->topParagraph()->rect() ); cursor->paragraph()->setChanged( TRUE ); @@ -2201,6 +2261,9 @@ void TQTextEdit::contentsMousePressEvent( TQMouseEvent *e ) } #endif + if ( sendMouseEventToInputContext( e ) ) + return; + if ( d->trippleClickTimer->isActive() && ( e->globalPos() - d->trippleClickPoint ).manhattanLength() < TQApplication::startDragDistance() ) { @@ -2306,7 +2369,9 @@ void TQTextEdit::contentsMouseMoveEvent( TQMouseEvent *e ) return; } #endif - if ( mousePressed ) { + if ( sendMouseEventToInputContext( e ) ) { + // don't return from here to avoid cursor vanishing + } else if ( mousePressed ) { #ifndef TQT_NO_DRAGANDDROP if ( mightStartDrag ) { dragStartTimer->stop(); @@ -2363,7 +2428,7 @@ void TQTextEdit::copyToClipboard() void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e ) { - if ( !inDoubleClick ) { // could be the release of a dblclick + if ( !inDoubleClick && !d->composeMode() ) { // could be the release of a dblclick int para = 0; int index = charAt( e->pos(), ¶ ); emit clicked( para, index ); @@ -2374,6 +2439,8 @@ void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e ) return; } #endif + if ( sendMouseEventToInputContext( e ) ) + return; TQTextCursor oldCursor = *cursor; if ( scrollTimer->isActive() ) scrollTimer->stop(); @@ -2467,7 +2534,7 @@ void TQTextEdit::contentsMouseReleaseEvent( TQMouseEvent * e ) void TQTextEdit::contentsMouseDoubleClickEvent( TQMouseEvent * e ) { - if ( e->button() != Qt::LeftButton ) { + if ( e->button() != Qt::LeftButton && !d->composeMode() ) { e->ignore(); return; } @@ -2498,6 +2565,9 @@ void TQTextEdit::contentsMouseDoubleClickEvent( TQMouseEvent * e ) } else #endif { + if ( sendMouseEventToInputContext( e ) ) + return; + TQTextCursor c1 = *cursor; TQTextCursor c2 = *cursor; #if defined(TQ_OS_MAC) @@ -2673,10 +2743,15 @@ void TQTextEdit::contentsDropEvent( TQDropEvent *e ) */ void TQTextEdit::contentsContextMenuEvent( TQContextMenuEvent *e ) { + e->accept(); +#ifndef TQT_NO_IM + if ( d->composeMode() ) + return; +#endif + clearUndoRedo(); mousePressed = FALSE; - e->accept(); #ifndef TQT_NO_POPUPMENU TQGuardedPtr that = this; TQGuardedPtr popup = createPopupMenu( e->pos() ); @@ -2826,6 +2901,12 @@ void TQTextEdit::placeCursor( const TQPoint &pos, TQTextCursor *c, bool link ) void TQTextEdit::updateMicroFocusHint() { TQTextCursor c( *cursor ); +#if 0 + // Disabled for Asian input method that shows candidate + // window. This behavior is same as TQt/E 2.3.7 which supports + // Asian input methods. Asian input methods need start point of IM + // selection text to place candidate window as adjacent to the + // selection text. if ( d->preeditStart != -1 ) { c.setIndex( d->preeditStart ); if(doc->hasSelection(TQTextDocument::IMSelectionText)) { @@ -2834,7 +2915,8 @@ void TQTextEdit::updateMicroFocusHint() c.setIndex(index); } } - +#endif + if ( hasFocus() || viewport()->hasFocus() ) { int h = c.paragraph()->lineHeightOfChar( cursor->index() ); if ( !readonly ) { @@ -2998,6 +3080,8 @@ void TQTextEdit::insert( const TQString &text, uint insertionFlags ) bool indent = insertionFlags & RedoIndentation; bool checkNewLine = insertionFlags & CheckNewLines; bool removeSelected = insertionFlags & RemoveSelected; + bool imComposition = insertionFlags & AsIMCompositionText; + bool imSelection = insertionFlags & WithIMSelection; TQString txt( text ); drawCursor( FALSE ); if ( !isReadOnly() && doc->hasSelection( TQTextDocument::Standard ) && removeSelected ) @@ -3037,7 +3121,10 @@ void TQTextEdit::insert( const TQString &text, uint insertionFlags ) formatMore(); repaintChanged(); ensureCursorVisible(); - drawCursor( TRUE ); + // Asian users regard selection text as cursor on candidate + // selection phase of input method, so ordinary cursor should be + // invisible if IM selection text exists. + drawCursor( !imSelection ); if ( undoEnabled && !isReadOnly() && undoRedoInfo.type != UndoRedoInfo::IME ) { undoRedoInfo.d->text += txt; @@ -3059,7 +3146,13 @@ void TQTextEdit::insert( const TQString &text, uint insertionFlags ) doc->setSelectionEnd( TQTextDocument::Standard, *cursor ); repaintChanged(); } - updateMicroFocusHint(); + // updateMicroFocusHint() should not be invoked here when this + // function is invoked from imComposeEvent() because cursor + // postion is incorrect yet. imComposeEvent() invokes + // updateMicroFocusHint() later. + if ( !imComposition ) { + updateMicroFocusHint(); + } setModified(); emit textChanged(); } @@ -5571,6 +5664,13 @@ TQPopupMenu *TQTextEdit::createPopupMenu( const TQPoint& pos ) #else d->id[ IdSelectAll ] = popup->insertItem( tr( "Select All" ) + ACCEL_KEY( A ) ); #endif + +#ifndef TQT_NO_IM + TQInputContext *qic = getInputContext(); + if ( qic ) + qic->addMenusTo( popup ); +#endif + popup->setItemEnabled( d->id[ IdUndo ], !isReadOnly() && doc->commands()->isUndoAvailable() ); popup->setItemEnabled( d->id[ IdRedo ], !isReadOnly() && doc->commands()->isRedoAvailable() ); #ifndef TQT_NO_CLIPBOARD diff --git a/tqtinterface/qt4/src/widgets/tqtextedit.h b/tqtinterface/qt4/src/widgets/tqtextedit.h index c78371e..ebca634 100644 --- a/tqtinterface/qt4/src/widgets/tqtextedit.h +++ b/tqtinterface/qt4/src/widgets/tqtextedit.h @@ -216,7 +216,9 @@ public: enum TextInsertionFlags { RedoIndentation = 0x0001, CheckNewLines = 0x0002, - RemoveSelected = 0x0004 + RemoveSelected = 0x0004, + AsIMCompositionText = 0x0008, // internal use + WithIMSelection = 0x0010 // internal use }; TQTextEdit( const TQString& text, const TQString& context = TQString::null, @@ -446,6 +448,7 @@ protected: void contentsDropEvent( TQDropEvent *e ); #endif void contentsContextMenuEvent( TQContextMenuEvent *e ); + bool sendMouseEventToInputContext( TQMouseEvent *e ); bool focusNextPrevChild( bool next ); TQTextDocument *document() const; TQTextCursor *textCursor() const; diff --git a/tqtinterface/qt4/src/widgets/tqtooltip.cpp b/tqtinterface/qt4/src/widgets/tqtooltip.cpp index 1bb37fd..1c82b0e 100644 --- a/tqtinterface/qt4/src/widgets/tqtooltip.cpp +++ b/tqtinterface/qt4/src/widgets/tqtooltip.cpp @@ -76,6 +76,7 @@ public: polish(); setText(text); adjustSize(); + x11SetWindowType( X11WindowTypeTooltip ); } void setWidth( int w ) { resize( sizeForWidth( w ) ); } }; @@ -534,6 +535,10 @@ void TQTipManager::showTip() if (!widget) return; +#ifdef TQ_WS_X11 + label->x11SetWindowTransient( widget->tqtopLevelWidget()); +#endif + #ifdef TQ_WS_MAC TQRect screen = TQApplication::desktop()->availableGeometry( scr ); #else -- cgit v1.2.3