rev 2991 - trunk/packages/kdelibs/debian/patches
Christopher Martin
chrsmrtn at costa.debian.org
Fri Jan 27 19:06:08 UTC 2006
Author: chrsmrtn
Date: 2006-01-27 19:06:01 +0000 (Fri, 27 Jan 2006)
New Revision: 2991
Added:
trunk/packages/kdelibs/debian/patches/01_kdelibs_branch_r502693.diff
Log:
New kdelibs branch pull.
Added: trunk/packages/kdelibs/debian/patches/01_kdelibs_branch_r502693.diff
===================================================================
--- trunk/packages/kdelibs/debian/patches/01_kdelibs_branch_r502693.diff 2006-01-27 19:05:44 UTC (rev 2990)
+++ trunk/packages/kdelibs/debian/patches/01_kdelibs_branch_r502693.diff 2006-01-27 19:06:01 UTC (rev 2991)
@@ -0,0 +1,2878 @@
+#DPATCHLEVEL=0
+--- kate/part/kateautoindent.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kate/part/kateautoindent.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -1054,7 +1054,7 @@
+
+ QRegExp KatePythonIndent::endWithColon = QRegExp( "^[^#]*:\\s*(#.*)?$" );
+ QRegExp KatePythonIndent::stopStmt = QRegExp( "^\\s*(break|continue|raise|return|pass)\\b.*" );
+-QRegExp KatePythonIndent::blockBegin = QRegExp( "^\\s*(def|if|elif|else|for|while|try)\\b.*" );
++QRegExp KatePythonIndent::blockBegin = QRegExp( "^\\s*(class|def|if|elif|else|for|while|try)\\b.*" );
+
+ KatePythonIndent::KatePythonIndent (KateDocument *doc)
+ : KateNormalIndent (doc)
+@@ -1857,8 +1857,9 @@
+ KateTextLine::Ptr indentLine = doc->plainKateTextLine(indentCursor.line());
+
+ QString whitespaceToKeyword = initialWhitespace( keywordLine, keywordPos, false );
+- if( blockKeyword )
+- ; // FIXME: we could add the open brace and subsequent newline here since they're definitely needed.
++ if( blockKeyword ) {
++ // FIXME: we could add the open brace and subsequent newline here since they're definitely needed.
++ }
+
+ // If the line starts with an open brace, don't indent...
+ int first = indentLine->firstChar();
+--- kunittest/tester.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kunittest/tester.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -531,7 +531,7 @@
+ public:
+ /*! Implement this method with the tests and checks you want to perform.
+ */
+- virtual void allTests() = 0L;
++ virtual void allTests() = 0;
+
+ public:
+ /*! @return The TestResults instance.
+--- kioslave/file/file.cc (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kioslave/file/file.cc (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -1213,8 +1213,8 @@
+ *it /* we can use the filename as relative path*/,
+ entry, 2, true ) )
+ listEntry( entry, false);
+- else
+- ;//Well, this should never happen... but with wrong encoding names
++ //else
++ // ;//Well, this should never happen... but with wrong encoding names
+ }
+
+ listEntry( entry, true ); // ready
+--- kinit/kinit.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kinit/kinit.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -290,6 +290,8 @@
+ {
+ if (type_ret == XA_CARDINAL && format_ret == 32 && nitems_ret == 1)
+ desktop = *((long *) data_ret) + 1;
++ if (data_ret)
++ XFree ((char*) data_ret);
+ }
+ #endif
+ return desktop;
+--- kio/kio/kdirwatch.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/kio/kdirwatch.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -89,15 +89,19 @@
+ }
+
+ #ifndef IN_ONLYDIR
+-#define IN_ONLYDIR 0x01000000
++#define IN_ONLYDIR 0x01000000
+ #endif
+
+ #ifndef IN_DONT_FOLLOW
+ #define IN_DONT_FOLLOW 0x02000000
+ #endif
+
++#ifndef IN_MOVE_SELF
++#define IN_MOVE_SELF 0x00000800
+ #endif
+
++#endif
++
+ #include <sys/utsname.h>
+
+ #include "kdirwatch.h"
+@@ -269,22 +273,10 @@
+ }
+
+ if ( supports_inotify ) {
+- int wd = inotify_add_watch ( m_inotify_fd, "/", 0x800 );
+- if (wd > 0) {
+- inotify_rm_watch( m_inotify_fd, wd );
+- available += ", INotify";
++ fcntl(m_inotify_fd, F_SETFD, FD_CLOEXEC);
+
+- fcntl(m_inotify_fd, F_SETFD, FD_CLOEXEC);
+-
+- mSn = new QSocketNotifier( m_inotify_fd, QSocketNotifier::Read, this );
+- connect( mSn, SIGNAL(activated( int )), this, SLOT( slotActivated() ) );
+- }
+- else {
+- kdDebug(7001) << "kernel too old for inotify" << endl;
+- supports_inotify = false;
+- close(m_inotify_fd);
+- m_inotify_fd = -1;
+- }
++ mSn = new QSocketNotifier( m_inotify_fd, QSocketNotifier::Read, this );
++ connect( mSn, SIGNAL(activated( int )), this, SLOT( slotActivated() ) );
+ }
+ #endif
+
+@@ -718,9 +710,12 @@
+
+ e->m_mode = INotifyMode;
+
+- int mask = IN_DELETE|IN_DELETE_SELF|IN_CREATE|IN_MOVE|0x800|IN_DONT_FOLLOW;
++ int mask = IN_DELETE|IN_DELETE_SELF|IN_CREATE|IN_MOVE|IN_MOVE_SELF|IN_DONT_FOLLOW;
+ if(!e->isDir)
+- mask |= IN_MODIFY|IN_ATTRIB|IN_ONLYDIR;
++ mask |= IN_MODIFY|IN_ATTRIB;
++ else
++ mask |= IN_ONLYDIR;
++
+ // if dependant is a file watch, we check for MODIFY & ATTRIB too
+ for(Entry* dep=e->m_entries.first();dep;dep=e->m_entries.next()) {
+ if (!dep->isDir) { mask |= IN_MODIFY|IN_ATTRIB; break; }
+@@ -1138,9 +1133,9 @@
+
+ #if defined ( HAVE_DNOTIFY ) || defined( HAVE_INOTIFY )
+ if (e->m_mode == DNotifyMode || e->m_mode == INotifyMode ) {
+- kdDebug(7001) << "scanning " << e->path << " " << e->dirty << " " << e->m_status << " " << e->m_ctime << endl;
+ // we know nothing has changed, no need to stat
+ if(!e->dirty) return NoChange;
++ kdDebug(7001) << "scanning " << e->path << " " << e->m_status << " " << e->m_ctime << endl;
+ e->dirty = false;
+ }
+ #endif
+--- kio/kfile/kurlcombobox.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/kfile/kurlcombobox.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -180,6 +180,12 @@
+ }
+ u = KURL::fromPathOrURL( *it );
+
++ // Don't restore if file doesn't exist anymore
++ if (u.isLocalFile() && !QFile::exists(u.path())) {
++ ++it;
++ continue;
++ }
++
+ item = new KURLComboItem;
+ item->url = u;
+ item->pixmap = getPixmap( u );
+--- kio/kfile/kpreviewprops.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/kfile/kpreviewprops.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -69,7 +69,7 @@
+ if( !KGlobalSettings::showFilePreview(_items.first()->url()))
+ return false;
+ KMimeType::Ptr mt = KMimeType::findByURL( _items.first()->url() );
+- if ( mt->name() == "inode/directory" )
++ if ( mt->inherits("inode/directory") || mt->name() == "application/octet-stream" )
+ return false;
+
+ //TODO Copy everything of KFileMetaPreview::previewProviderFor() ?
+--- kio/kfile/kacleditwidget_p.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/kfile/kacleditwidget_p.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -78,6 +78,9 @@
+ acl_perm_t maskPartialPermissions() const;
+ void setMaskPartialPermissions( acl_perm_t maskPerms );
+
++ bool maskCanBeDeleted() const;
++ bool defaultMaskCanBeDeleted() const;
++
+ const KACLListViewItem* findDefaultItemByType( EntryType type ) const;
+ const KACLListViewItem* findItemByType( EntryType type,
+ bool defaults = false ) const;
+@@ -171,6 +174,9 @@
+
+ void calcEffectiveRights();
+
++ bool isDeletable() const;
++ bool isAllowedToChangeType() const;
++
+ void togglePerm( acl_perm_t perm );
+
+ virtual void paintCell( QPainter *p, const QColorGroup &cg,
+--- kio/kfile/kfiledialog.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/kfile/kfiledialog.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -776,29 +776,29 @@
+ setNonExtSelection();
+ }
+
+-static QString autocompletionWhatsThisText = i18n("<p>While typing in the text area, you may be presented "
++static const char autocompletionWhatsThisText[] = I18N_NOOP("<p>While typing in the text area, you may be presented "
+ "with possible matches. "
+ "This feature can be controlled by clicking with the right mouse button "
+- "and selecting a preferred mode from the <b>Text Completion</b> menu.") + "</qt>";
++ "and selecting a preferred mode from the <b>Text Completion</b> menu.") "</qt>";
+ void KFileDialog::updateLocationWhatsThis (void)
+ {
+ QString whatsThisText;
+ if (d->operationMode == KFileDialog::Saving)
+ {
+ whatsThisText = "<qt>" + i18n("This is the name to save the file as.") +
+- autocompletionWhatsThisText;
++ i18n (autocompletionWhatsThisText);
+ }
+ else if (ops->mode() & KFile::Files)
+ {
+ whatsThisText = "<qt>" + i18n("This is the list of files to open. More than "
+ "one file can be specified by listing several "
+ "files, separated by spaces.") +
+- autocompletionWhatsThisText;
++ i18n (autocompletionWhatsThisText);
+ }
+ else
+ {
+ whatsThisText = "<qt>" + i18n("This is the name of the file to open.") +
+- autocompletionWhatsThisText;
++ i18n (autocompletionWhatsThisText);
+ }
+
+ QWhatsThis::add(d->locationLabel, whatsThisText);
+@@ -839,7 +839,7 @@
+ QWhatsThis::add( d->pathCombo, "<qt>" + i18n("This is the currently listed location. "
+ "The drop-down list also lists commonly used locations. "
+ "This includes standard locations, such as your home folder, as well as "
+- "locations that have been visited recently.") + autocompletionWhatsThisText);
++ "locations that have been visited recently.") + i18n (autocompletionWhatsThisText));
+
+ KURL u;
+ u.setPath( QDir::rootDirPath() );
+--- kio/kfile/kacleditwidget.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/kfile/kacleditwidget.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -91,15 +91,19 @@
+
+ void KACLEditWidget::slotUpdateButtons()
+ {
+- int selectedItemsCount = 0;
++ bool atLeastOneIsNotDeletable = false;
++ bool atLeastOneIsNotAllowedToChangeType = false;
++ int selectedCount = 0;
+ QListViewItemIterator it( m_listView, QListViewItemIterator::Selected );
+- while ( it.current() ) {
+- ++it;
+- if ( ++selectedItemsCount > 1 )
+- break;
++ while ( KACLListViewItem *item = dynamic_cast<KACLListViewItem*>( it.current() ) ) {
++ ++it; ++selectedCount;
++ if ( !item->isDeletable() )
++ atLeastOneIsNotDeletable = true;
++ if ( !item->isAllowedToChangeType() )
++ atLeastOneIsNotAllowedToChangeType = true;
+ }
+- m_EditBtn->setEnabled( selectedItemsCount == 1 );
+- m_DelBtn->setEnabled( selectedItemsCount > 0 );
++ m_EditBtn->setEnabled( selectedCount && !atLeastOneIsNotAllowedToChangeType );
++ m_DelBtn->setEnabled( selectedCount && !atLeastOneIsNotDeletable );
+ }
+
+ KACL KACLEditWidget::getACL() const
+@@ -331,7 +335,29 @@
+ setText( 5, strEffective );
+ }
+
++bool KACLListViewItem::isDeletable() const
++{
++ bool isMaskAndDeletable = false;
++ if (type == KACLListView::Mask ) {
++ if ( !isDefault && m_pACLListView->maskCanBeDeleted() )
++ isMaskAndDeletable = true;
++ else if ( isDefault && m_pACLListView->defaultMaskCanBeDeleted() )
++ isMaskAndDeletable = true;
++ }
++ return type != KACLListView::User &&
++ type != KACLListView::Group &&
++ type != KACLListView::Others &&
++ ( type != KACLListView::Mask || isMaskAndDeletable );
++}
+
++bool KACLListViewItem::isAllowedToChangeType() const
++{
++ return type != KACLListView::User &&
++ type != KACLListView::Group &&
++ type != KACLListView::Others &&
++ type != KACLListView::Mask;
++}
++
+ void KACLListViewItem::togglePerm( acl_perm_t perm )
+ {
+ value ^= perm; // Toggle the perm
+@@ -976,8 +1002,6 @@
+
+ void KACLListView::slotRemoveEntry()
+ {
+- bool needsMask = findItemByType( NamedUser ) || findItemByType( NamedGroup );
+- bool needsDefaultMask = findDefaultItemByType( NamedUser ) || findDefaultItemByType( NamedGroup );
+ QListViewItemIterator it( this, QListViewItemIterator::Selected );
+ while ( it.current() ) {
+ KACLListViewItem *item = static_cast<KACLListViewItem*>( it.current() );
+@@ -987,11 +1011,11 @@
+ * removed, or don't remove it, but reset it. That is allowed. */
+ if ( item->type == Mask ) {
+ bool itemWasDefault = item->isDefault;
+- if ( !itemWasDefault && !needsMask ) {
++ if ( !itemWasDefault && maskCanBeDeleted() ) {
+ m_hasMask= false;
+ m_mask = 0;
+ delete item;
+- } else if ( itemWasDefault && !needsDefaultMask ) {
++ } else if ( itemWasDefault && defaultMaskCanBeDeleted() ) {
+ delete item;
+ } else {
+ item->value = 0;
+@@ -1014,6 +1038,16 @@
+ }
+ }
+
++bool KACLListView::maskCanBeDeleted() const
++{
++ return !findItemByType( NamedUser ) && !findItemByType( NamedGroup );
++}
++
++bool KACLListView::defaultMaskCanBeDeleted() const
++{
++ return !findDefaultItemByType( NamedUser ) && !findDefaultItemByType( NamedGroup );
++}
++
+ #include "kacleditwidget.moc"
+ #include "kacleditwidget_p.moc"
+ #endif
+--- kio/tests/kdirwatchunittest.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 0)
++++ kio/tests/kdirwatchunittest.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -0,0 +1,136 @@
++ /*
++ This file is or will be part of KDE desktop environment
++
++ (c) 2006 Dirk Mueller <mueller at kde.org>
++
++ It is licensed under GPL version 2.
++
++ If it is part of KDE libraries than this file is licensed under
++ LGPL version 2.
++ */
++
++#include <unistd.h>
++
++#include <qfile.h>
++#include <qdir.h>
++
++#include <kdebug.h>
++
++#include "kdirwatchunittest.h"
++
++void KDirWatchTest::VERIFY_NOTHING()
++{
++ unsigned m_s[3];
++ for(int i = 0; i < 3; ++i)
++ m_s[i] = m_signals[i];
++
++ for (int i = 0; i < 20; ++i) {
++ usleep(100*1000);
++ qApp->processEvents();
++ }
++
++ bool nothing_failed = true;
++ for (int i = 0; i < 3; ++i)
++ if (m_s[i] != m_signals[i])
++ nothing_failed = false;
++
++ VERIFY (nothing_failed);
++}
++
++void KDirWatchTest::VERIFY_DIRTY(const QString& alert)
++{
++ unsigned m_s[3];
++ for(int i = 0; i < 3; ++i)
++ m_s[i] = m_signals[i];
++
++ for (int i = 0; i < 20; ++i) {
++ usleep(100*1000);
++ qApp->processEvents();
++ }
++
++ VERIFY (m_s[sigCreated] == m_signals[sigCreated] &&
++ m_s[sigDeleted] == m_signals[sigDeleted] &&
++ m_s[sigDirty] + 1 == m_signals[sigDirty] &&
++ m_lastSignal == alert);
++}
++
++void KDirWatchTest::VERIFY_CREATED(const QString& alert)
++{
++ unsigned m_s[3];
++ for(int i = 0; i < 3; ++i)
++ m_s[i] = m_signals[i];
++
++ for (int i = 0; i < 20; ++i) {
++ usleep(100*1000);
++ qApp->processEvents();
++ }
++
++ VERIFY (m_s[sigDirty] == m_signals[sigDirty] &&
++ m_s[sigDeleted] == m_signals[sigDeleted] &&
++ m_s[sigCreated] + 1 == m_signals[sigCreated] &&
++ m_lastSignal == alert);
++}
++
++void KDirWatchTest::VERIFY_DELETED(const QString& alert)
++{
++ unsigned m_s[3];
++ for(int i = 0; i < 3; ++i)
++ m_s[i] = m_signals[i];
++
++ for (int i = 0; i < 20; ++i) {
++ usleep(100*1000);
++ qApp->processEvents();
++ }
++
++ VERIFY (m_s[sigDirty] == m_signals[sigDirty] &&
++ m_s[sigCreated] == m_signals[sigCreated] &&
++ m_s[sigDeleted] + 1 == m_signals[sigDeleted] &&
++ m_lastSignal == alert);
++}
++
++KUNITTEST_MODULE ( kunittest_kdirwatch, "KDirWatchTest" )
++KUNITTEST_MODULE_REGISTER_TESTER (KDirWatchTest)
++
++#define SLEEP() QApplication::processEvents();
++
++void KDirWatchTest::allTests()
++{
++ for(int loop=0; loop<3; ++loop) {
++ d = new KDirWatch;
++ VERIFY (d != 0);
++
++ QDir* dir = new QDir(m_workingDir);
++ VERIFY (dir != 0);
++
++ connect(d, SIGNAL (dirty( const QString &)), SLOT( slotDirty( const QString &)) );
++ connect(d, SIGNAL (created( const QString &)), SLOT( slotCreated( const QString &)) );
++ connect(d, SIGNAL (deleted( const QString &)), SLOT( slotDeleted( const QString &)) );
++
++ VERIFY (dir->mkdir (m_workingDir));
++
++ d->addDir (m_workingDir);
++ VERIFY_NOTHING();
++ dir->mkdir ("does");
++ VERIFY_DIRTY (m_workingDir);
++ d->addDir (m_workingDir + "/does/not/exist");
++ d->removeDir (m_workingDir);
++ VERIFY_NOTHING();
++
++ dir->mkdir ("does/not");
++ VERIFY_NOTHING();
++ dir->mkdir ("does/not/exist");
++ VERIFY_CREATED (m_workingDir + "/does/not/exist");
++
++ dir->rmdir ("does/not/exist");
++ VERIFY_DELETED (m_workingDir + "/does/not/exist");
++ dir->rmdir ("does/not");
++ VERIFY_NOTHING();
++ dir->rmdir ("does");
++ VERIFY_NOTHING();
++
++ VERIFY (dir->rmdir (m_workingDir));
++ delete d;
++ }
++}
++
++#include "kdirwatchunittest.moc"
+--- kio/tests/kioslavetest.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/tests/kioslavetest.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -13,6 +13,7 @@
+ #include <qmessagebox.h>
+ #include <qdir.h>
+
++#include <kacl.h>
+ #include <kapplication.h>
+ #include <kcmdlineargs.h>
+ #include <kdebug.h>
+--- kio/tests/kdirwatchunittest.h (.../tags/KDE/3.5.1/kdelibs) (revision 0)
++++ kio/tests/kdirwatchunittest.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -0,0 +1,62 @@
++ /*
++ This file is or will be part of KDE desktop environment
++
++ Copyright 1998 Sven Radej <sven at lisa.exp.univie.ac.at>
++
++ It is licensed under GPL version 2.
++
++ If it is part of KDE libraries than this file is licensed under
++ LGPL version 2.
++ */
++
++#ifndef _KDIRWATCHTEST_H_
++#define _KDIRWATCHTEST_H_
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <qobject.h>
++
++#include "kdirwatch.h"
++#include "kapplication.h"
++
++#include <kunittest/tester.h>
++#include <kunittest/module.h>
++
++class KDirWatchTest : public KUnitTest::Tester
++{
++ Q_OBJECT
++
++public:
++ enum { sigDirty, sigCreated, sigDeleted };
++
++ KDirWatchTest()
++ {
++ m_signals[sigDirty] = m_signals[sigCreated] = m_signals[sigDeleted] = 0;
++ m_workingDir = "/tmp/kdirwatchtest";
++ }
++
++ virtual void allTests();
++
++private slots:
++ void slotDirty (const QString& s) { m_signals[sigDirty]++; m_lastSignal = s; }
++ void slotCreated (const QString& s) { m_signals[sigCreated]++; m_lastSignal = s; }
++ void slotDeleted (const QString& s) { m_signals[sigDeleted]++; m_lastSignal = s; }
++
++private:
++ unsigned m_signals[3];
++
++ /* verify nothing happens */
++ void VERIFY_NOTHING();
++ /* verify that dirty got emitted */
++ void VERIFY_DIRTY (const QString&);
++ /* verify that created got emitted */
++ void VERIFY_CREATED (const QString&);
++ /* verify that deleted got emitted */
++ void VERIFY_DELETED (const QString&);
++
++ QString m_lastSignal;
++ QString m_workingDir;
++ KDirWatch* d;
++};
++
++#endif
+--- kio/tests/Makefile.am (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kio/tests/Makefile.am (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -74,6 +74,12 @@
+ kmimetypetest_SOURCES = kmimetypetest.cpp
+ kacltest_SOURCES = kacltest.cpp
+
++
++check_LTLIBRARIES = kunittest_kdirwatch.la
++kunittest_kdirwatch_la_SOURCES = kdirwatchunittest.cpp
++kunittest_kdirwatch_la_LIBADD = $(LIB_KUNITTEST) $(LIB_KIO)
++kunittest_kdirwatch_la_LDFLAGS = -module $(KDE_CHECK_PLUGIN)
++
+ # kfile meta stuff. Comment this in, if you want a small
+ # metadata plugin test and "make install".
+ #kde_module_LTLIBRARIES = dummymeta.la
+--- win/tools/build_kdelibs_dbg (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ win/tools/build_kdelibs_dbg (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -28,7 +28,7 @@
+ cd "$pwd"
+
+ if [ -d "kstyles/thinkeramik/widget-engine" ] ; then
+- additional="kstyles/thinkeramik/widget-engine"
++ additional="kstyles/thinkeramik/widget-engine/genembed kstyles/thinkeramik/widget-engine "
+ fi
+
+ # all
+--- win/win32_utils2.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ win/win32_utils2.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -116,7 +116,8 @@
+ if (p!=-1) {
+ new_f = current.left(p);
+ new_name = current.mid(p+1);
+- }else {
++ }
++ else {
+ new_f = current;
+ new_name = current; //nothing better
+ }
+@@ -134,10 +135,20 @@
+ new_name.replace(')',"");
+ new_name = new_name.stripWhiteSpace();
+
++ // make filters unique: remove uppercase extensions (case doesn't matter on win32, BTW)
++ QStringList allfiltersUnique;
++ QStringList origList( QStringList::split(" ", new_f) );
++ for (QStringList::ConstIterator it = origList.constBegin();
++ it!=origList.constEnd(); ++it)
++ {
++ if ((*it) == (*it).lower())
++ allfiltersUnique += *it;
++ }
++
+ if (!converted.isEmpty())
+ converted += ";;";
+
+- converted += (new_name + " (" + new_f + ")");
++ converted += (new_name + " (" + allfiltersUnique.join(" ") + ")");
+ }
+ return converted;
+ }
+--- win/common.pro (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ win/common.pro (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -49,8 +49,9 @@
+ KDEBINDESTDIR = $(KDEDIR)
+ }
+
+-# global library destination directory
+-KDELIBDESTDIR = $$KDEBINDESTDIR\lib
++# global library destination directory
++KDELIBDESTDIR = $$KDEBINDESTDIR\bin #shared with all binaries
++###KDELIBDESTDIR = $$KDEBINDESTDIR\lib
+
+ # dlls suffixes for given target
+ isEmpty( KDEBUG ) {
+@@ -102,15 +103,15 @@
+
+ # lib/kde3 dest dir (for modules)
+ contains( CONFIG, kde3lib ) {
+- DESTDIR = $$KDELIBDESTDIR/kde3
+- TARGET_EXT = .dll #- no ver. in filename
++ DESTDIR = $$KDEBINDESTDIR/lib/kde3
++ TARGET_EXT = .dll #- no ver. in filename
+ }
+ !contains( CONFIG, kde3lib ) {
+- DESTDIR = $$KDELIBDESTDIR
++ DESTDIR = $$KDELIBDESTDIR
+ }
+ contains( CONFIG, kstyle ) {
+- DESTDIR = $$KDELIBDESTDIR/kde3/plugins/styles
+- CONFIG += plugin
++ DESTDIR = $$KDEBINDESTDIR/lib/kde3/plugins/styles
++ CONFIG += plugin
+ }
+ # !contains(CONFIG,debug) {
+ # DESTDIR = $$KDEBINDESTDIR\release-lib
+--- kabc/vcard/ContentLine.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kabc/vcard/ContentLine.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -270,8 +270,9 @@
+ vDebug("Adding value");
+ if (value_ != 0)
+ line += ":" + value_->asString();
+- else
++ else {
+ vDebug("No value");
++ }
+
+ // Quote newlines
+ line = line.replace( QRegExp( "\n" ), "\\n" );
+--- kdecore/ksycoca.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdecore/ksycoca.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -42,6 +42,10 @@
+ #include <sys/mman.h>
+ #endif
+
++#ifdef Q_OS_SOLARIS
++extern "C" extern int madvise(caddr_t, size_t, int);
++#endif
++
+ #ifndef MAP_FAILED
+ #define MAP_FAILED ((void *) -1)
+ #endif
+@@ -145,7 +149,7 @@
+ else
+ {
+ #ifdef HAVE_MADVISE
+- (void) madvise((void*)m_sycoca_mmap, m_sycoca_size, MADV_WILLNEED);
++ (void) madvise((char*)m_sycoca_mmap, m_sycoca_size, MADV_WILLNEED);
+ #endif
+ QByteArray b_array;
+ b_array.setRawData(m_sycoca_mmap, m_sycoca_size);
+@@ -439,7 +443,8 @@
+ return;
+ _self->d->readError = true;
+ if (_self->d->autoRebuild)
+- system("kbuildsycoca"); // Rebuild the damned thing.
++ if(system("kbuildsycoca") < 0) // Rebuild the damned thing.
++ qWarning("ERROR: Running KSycoca failed.");
+ }
+ }
+
+--- kdecore/eventsrc (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdecore/eventsrc (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -197,7 +197,7 @@
+ Name[bn]=Textcompletion: আবর্তন
+ Name[br]=KlokadurSrid : troerezh
+ Name[bs]=Textcompletion: rotacija
+-Name[ca]=Completat de text: rotació
++Name[ca]=Compleció de text: rotació
+ Name[cs]=Doplňování textu: rotace
+ Name[cy]=CwblhauTestun: cylchdroi
+ Name[da]=Tekstkomplettering: rotation
+@@ -332,7 +332,7 @@
+ Name[bn]=Textcompletion: কোনো মিল পাওয়া যায়নি
+ Name[br]=KlokadurSrid : kendoare ebet
+ Name[bs]=Textcompletion: bez poklapanja
+-Name[ca]=Completat de text: cap coincidència
++Name[ca]=Compleció de text: cap coincidència
+ Name[cs]=Doplňování textu: žádná shoda
+ Name[cy]=CwblhauTestun: cydweddiad
+ Name[da]=Tekstkomplettering: intet fundet
+@@ -468,7 +468,7 @@
+ Name[bn]=Textcompletion: আংশিক মিল
+ Name[br]=KlokadurSrid : kendoare darnek
+ Name[bs]=Textcompletion: djelomično poklapanje
+-Name[ca]=Completat de text: coincidència parcial
++Name[ca]=Compleció de text: coincidència parcial
+ Name[cs]=Doplňování textu: částečná shoda
+ Name[cy]=CwblhauTestun: cydweddiad rhannol
+ Name[da]=Tekstkomplettering: delvist fundet
+--- kdecore/all_languages.desktop (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdecore/all_languages.desktop (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -1468,7 +1468,7 @@
+ Name[mk]=Црковнословенски
+ Name[mn]=Чүрч славик
+ Name[nb]=Kirkeslavisk
+-Name[nds]=Slaawsch (as vun de Kark)
++Name[nds]=Oolslaawsch
+ Name[nl]=Kerk Slavisch
+ Name[nn]=Kyrkjeslavisk
+ Name[nso]=Se-Church Slavic
+@@ -8415,7 +8415,7 @@
+ Name[is]=Serbnesk latína
+ Name[it]=Serbo latino
+ Name[lb]=Latäinescht Serbesch
+-Name[nds]=Serbsch latiensch
++Name[nds]=Serbsch (latiensch Schrift)
+ Name[nl]=Servisch Latijn
+ Name[pl]=Serbski łaciński
+ Name[pt]=Sérvio Latino
+--- khtml/html/html_formimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/html/html_formimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -942,14 +942,21 @@
+
+ bool HTMLGenericFormElementImpl::isFocusable() const
+ {
+- return (!disabled() && m_render && m_render->isWidget() &&
+- static_cast<RenderWidget*>(m_render)->widget() &&
+- static_cast<RenderWidget*>(m_render)->widget()->focusPolicy() >= QWidget::TabFocus) ||
+- /* INPUT TYPE="image" supports focus too */
+- (
+- id() == ID_INPUT &&
+- static_cast<const HTMLInputElementImpl *>(this)->inputType() == HTMLInputElementImpl::IMAGE
+- );
++ if (disabled())
++ return false;
++
++ //Non-widget INPUT TYPE="image" and <BUTTON> support focus, too.
++ if (id() == ID_INPUT && static_cast<const HTMLInputElementImpl *>(this)->inputType() == HTMLInputElementImpl::IMAGE)
++ return true;
++
++ if (id() == ID_BUTTON)
++ return true;
++
++ if (!m_render)
++ return false;
++
++ QWidget* widget = static_cast<RenderWidget*>(m_render)->widget();
++ return widget && widget->focusPolicy() >= QWidget::TabFocus;
+ }
+
+ class FocusHandleWidget : public QWidget
+@@ -1008,8 +1015,8 @@
+
+ if (!evt->defaultHandled() && m_render && m_render->isWidget()) {
+ // handle tabbing out, either from a single or repeated key event.
+- if ( evt->id() == EventImpl::KEYPRESS_EVENT ) {
+- QKeyEvent* const k = static_cast<TextEventImpl *>(evt)->qKeyEvent();
++ if ( evt->id() == EventImpl::KEYPRESS_EVENT && evt->isKeyRelatedEvent() ) {
++ QKeyEvent* const k = static_cast<KeyEventBaseImpl *>(evt)->qKeyEvent();
+ if ( k && (k->key() == Qt::Key_Tab || k->key() == Qt::Key_BackTab) ) {
+ QWidget* const widget = static_cast<RenderWidget*>(m_render)->widget();
+ QFocusEvent::setReason( k->key() == Qt::Key_Tab ? QFocusEvent::Tab : QFocusEvent::Backtab );
+@@ -1109,8 +1116,8 @@
+ {
+ if (m_type != BUTTON && !m_disabled) {
+ bool act = (evt->id() == EventImpl::DOMACTIVATE_EVENT);
+- if (!act && evt->id()==EventImpl::KEYUP_EVENT) {
+- QKeyEvent* const ke = static_cast<TextEventImpl *>(evt)->qKeyEvent();
++ if (!act && evt->id()==EventImpl::KEYUP_EVENT && evt->isKeyRelatedEvent()) {
++ QKeyEvent* const ke = static_cast<KeyEventBaseImpl *>(evt)->qKeyEvent();
+ if (ke && active() && (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Space))
+ act = true;
+ }
+@@ -1736,8 +1743,8 @@
+ // must dispatch a DOMActivate event - a click event will not do the job.
+ if (m_type == IMAGE || m_type == SUBMIT || m_type == RESET) {
+ bool act = (evt->id() == EventImpl::DOMACTIVATE_EVENT);
+- if (!act && evt->id() == EventImpl::KEYUP_EVENT) {
+- QKeyEvent* const ke = static_cast<TextEventImpl *>(evt)->qKeyEvent();
++ if (!act && evt->id() == EventImpl::KEYUP_EVENT && evt->isKeyRelatedEvent()) {
++ QKeyEvent* const ke = static_cast<KeyEventBaseImpl *>(evt)->qKeyEvent();
+ if (ke && active() && (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Space))
+ act = true;
+ }
+@@ -1821,9 +1828,9 @@
+ if ( evt->id() == EventImpl::CLICK_EVENT ) {
+ act = true;
+ }
+- else if ( evt->id() == EventImpl::KEYUP_EVENT ||
+- evt->id() == EventImpl::KEYPRESS_EVENT ) {
+- QKeyEvent* const ke = static_cast<TextEventImpl *>(evt)->qKeyEvent();
++ else if ( evt->isKeyRelatedEvent() && ( evt->id() == EventImpl::KEYUP_EVENT ||
++ evt->id() == EventImpl::KEYPRESS_EVENT ) ) {
++ QKeyEvent* const ke = static_cast<KeyEventBaseImpl *>(evt)->qKeyEvent();
+ if (ke && active() && (ke->key() == Qt::Key_Return || ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Space))
+ act = true;
+ }
+@@ -2303,7 +2310,7 @@
+ NodeImpl* const parent = current->parentNode();
+ current = current->nextSibling();
+ if (!current) {
+- if (parent != this)
++ if (static_cast<const NodeImpl *>(parent) != this)
+ current = parent->nextSibling();
+ }
+ }
+--- khtml/html/html_baseimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/html/html_baseimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -158,6 +158,18 @@
+ getDocument()->setHTMLWindowEventListener(EventImpl::RESIZE_EVENT,
+ getDocument()->createHTMLEventListener(attr->value().string(), "onresize", NULL));
+ break;
++ case ATTR_ONKEYUP:
++ getDocument()->setHTMLWindowEventListener(EventImpl::KEYUP_EVENT,
++ getDocument()->createHTMLEventListener(attr->value().string(), "onkeyup", NULL));
++ break;
++ case ATTR_ONKEYDOWN:
++ getDocument()->setHTMLWindowEventListener(EventImpl::KEYDOWN_EVENT,
++ getDocument()->createHTMLEventListener(attr->value().string(), "onkeydown", NULL));
++ break;
++ case ATTR_ONKEYPRESS:
++ getDocument()->setHTMLWindowEventListener(EventImpl::KEYPRESS_EVENT,
++ getDocument()->createHTMLEventListener(attr->value().string(), "onkeypress", NULL));
++ break;
+ case ATTR_NOSAVE:
+ break;
+ default:
+--- khtml/html/html_inlineimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/html/html_inlineimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -51,7 +51,7 @@
+
+ void HTMLAnchorElementImpl::defaultEventHandler(EventImpl *evt)
+ {
+- bool keydown = evt->id() == EventImpl::KEYDOWN_EVENT;
++ bool keydown = evt->id() == EventImpl::KEYDOWN_EVENT && evt->isKeyRelatedEvent();
+
+ // React on clicks and on keypresses.
+ // Don't make this KEYUP_EVENT again, it makes khtml follow links
+@@ -63,9 +63,9 @@
+ if ( evt->id() == EventImpl::CLICK_EVENT )
+ e = static_cast<MouseEventImpl*>( evt );
+
+- TextEventImpl *k = 0;
++ KeyEventBaseImpl *k = 0;
+ if (keydown)
+- k = static_cast<TextEventImpl *>( evt );
++ k = static_cast<KeyEventBaseImpl *>( evt );
+
+ QString utarget;
+ QString url;
+@@ -75,7 +75,7 @@
+ }
+
+ if ( k ) {
+- if (k->virtKeyVal() != TextEventImpl::DOM_VK_ENTER) {
++ if (k->virtKeyVal() != KeyEventBaseImpl::DOM_VK_ENTER) {
+ if (k->qKeyEvent())
+ k->qKeyEvent()->ignore();
+ HTMLElementImpl::defaultEventHandler(evt);
+--- khtml/ecma/kjs_events.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/ecma/kjs_events.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -25,6 +25,7 @@
+ #include "ecma/kjs_dom.h"
+ #include "dom/dom2_events.h"
+ #include "dom/dom_misc.h"
++#include "xml/dom2_eventsimpl.h"
+
+ namespace KJS {
+
+@@ -172,8 +173,22 @@
+ DOM::MouseEvent toMouseEvent() const { return static_cast<DOM::MouseEvent>(event); }
+ };
+
+- class DOMTextEvent : public DOMUIEvent {
++ class DOMKeyEventBase : public DOMUIEvent {
+ public:
++ DOMKeyEventBase(const Object &proto, DOM::TextEvent ke);
++ ~DOMKeyEventBase();
++
++ virtual Value tryGet(ExecState *exec,const Identifier &p) const;
++ Value getValueProperty(ExecState *, int token) const;
++ // no put - all read-only
++ virtual const ClassInfo* classInfo() const { return &info; }
++ static const ClassInfo info;
++ enum { Key, VirtKey, CtrlKey, ShiftKey, AltKey, MetaKey };
++ DOM::KeyEventBaseImpl* impl() const { return static_cast<DOM::KeyEventBaseImpl*>(event.handle()); }
++ };
++
++ class DOMTextEvent : public DOMKeyEventBase {
++ public:
+ DOMTextEvent(ExecState *exec, DOM::TextEvent ke);
+ ~DOMTextEvent();
+ virtual Value tryGet(ExecState *exec,const Identifier &p) const;
+@@ -181,11 +196,36 @@
+ // no put - all read-only
+ virtual const ClassInfo* classInfo() const { return &info; }
+ static const ClassInfo info;
+- enum { Key, VirtKey, OutputString, InitTextEvent, InputGenerated, NumPad,
+- CtrlKey, ShiftKey, AltKey, MetaKey };
+- DOM::TextEvent toTextEvent() const { return static_cast<DOM::TextEvent>(event); }
++ enum {Data, InitTextEvent};
++ DOM::TextEventImpl* impl() const { return static_cast<DOM::TextEventImpl*>(event.handle()); }
+ };
+
++ class DOMKeyboardEvent : public DOMKeyEventBase {
++ public:
++ DOMKeyboardEvent(ExecState *exec, DOM::TextEvent ke);
++ ~DOMKeyboardEvent();
++ virtual Value tryGet(ExecState *exec,const Identifier &p) const;
++ Value getValueProperty(ExecState *, int token) const;
++ // no put - all read-only
++ virtual const ClassInfo* classInfo() const { return &info; }
++ static const ClassInfo info;
++ enum {KeyIdentifier, KeyLocation, GetModifierState, InitKeyboardEvent};
++ DOM::KeyboardEventImpl* impl() const { return static_cast<DOM::KeyboardEventImpl*>(event.handle()); }
++ };
++
++ // Constructor object KeyboardEvent
++ class KeyboardEventConstructor : public DOMObject {
++ public:
++ KeyboardEventConstructor(ExecState *);
++ virtual Value tryGet(ExecState *exec,const Identifier &p) const;
++ Value getValueProperty(ExecState *, int token) const;
++ // no put - all read-only
++ virtual const ClassInfo* classInfo() const { return &info; }
++ static const ClassInfo info;
++ };
++
++ Value getKeyboardEventConstructor(ExecState *exec);
++
+ // Constructor object MutationEvent
+ class MutationEventConstructor : public DOMObject {
+ public:
+--- khtml/ecma/kjs_window.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/ecma/kjs_window.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -143,7 +143,8 @@
+ Onchange, Onclick, Ondblclick, Ondragdrop, Onerror, Onfocus,
+ Onkeydown, Onkeypress, Onkeyup, Onload, Onmousedown, Onmousemove,
+ Onmouseout, Onmouseover, Onmouseup, Onmove, Onreset, Onresize,
+- Onselect, Onsubmit, Onunload };
++ Onselect, Onsubmit, Onunload,
++ MutationEventCtor, KeyboardEventCtor, EventExceptionCtor };
+ WindowQObject *winq;
+
+ void forgetSuppressedWindows();
+--- khtml/ecma/kjs_dom.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/ecma/kjs_dom.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -210,7 +210,7 @@
+ case OnDragDrop:
+ return getListener(DOM::EventImpl::KHTML_DRAGDROP_EVENT);
+ case OnError:
+- return getListener(DOM::EventImpl::KHTML_ERROR_EVENT);
++ return getListener(DOM::EventImpl::ERROR_EVENT);
+ case OnFocus:
+ return getListener(DOM::EventImpl::FOCUS_EVENT);
+ case OnKeyDown:
+@@ -351,7 +351,7 @@
+ setListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT,value);
+ break;
+ case OnError:
+- setListener(exec,DOM::EventImpl::KHTML_ERROR_EVENT,value);
++ setListener(exec,DOM::EventImpl::ERROR_EVENT,value);
+ break;
+ case OnFocus:
+ setListener(exec,DOM::EventImpl::FOCUS_EVENT,value);
+--- khtml/ecma/kjs_events.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/ecma/kjs_events.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -401,8 +401,10 @@
+ ScriptInterpreter* interp = static_cast<ScriptInterpreter *>(exec->interpreter());
+ DOMObject *ret = interp->getDOMObject(ei);
+ if (!ret) {
+- if (ei->isTextEvent())
++ if (ei->isTextInputEvent())
+ ret = new DOMTextEvent(exec, e);
++ else if (ei->isKeyboardEvent())
++ ret = new DOMKeyboardEvent(exec, e);
+ else if (ei->isMouseEvent())
+ ret = new DOMMouseEvent(exec, e);
+ else if (ei->isUIEvent())
+@@ -697,32 +699,75 @@
+
+ // -------------------------------------------------------------------------
+
+-const ClassInfo DOMTextEvent::info = { "TextEvent", &DOMUIEvent::info, &DOMTextEventTable, 0 };
++const ClassInfo DOMKeyEventBase::info = { "KeyEventBase", &DOMUIEvent::info, &DOMKeyEventBaseTable, 0 };
+
+ /*
+- at begin DOMTextEventTable 5
+- keyVal DOMTextEvent::Key DontDelete|ReadOnly
+- virtKeyVal DOMTextEvent::VirtKey DontDelete|ReadOnly
+- outputString DOMTextEvent::OutputString DontDelete|ReadOnly
+- inputGenerated DOMTextEvent::InputGenerated DontDelete|ReadOnly
+- numPad DOMTextEvent::NumPad DontDelete|ReadOnly
+- # actually belonging to KeyboardEvent
+- ctrlKey DOMTextEvent::CtrlKey DontDelete|ReadOnly
+- altKey DOMTextEvent::AltKey DontDelete|ReadOnly
+- shiftKey DOMTextEvent::ShiftKey DontDelete|ReadOnly
+- altKey DOMTextEvent::AltKey DontDelete|ReadOnly
++ at begin DOMKeyEventBaseTable 5
++ keyVal DOMKeyEventBase::Key DontDelete|ReadOnly
++ virtKeyVal DOMKeyEventBase::VirtKey DontDelete|ReadOnly
++ ctrlKey DOMKeyEventBase::CtrlKey DontDelete|ReadOnly
++ altKey DOMKeyEventBase::AltKey DontDelete|ReadOnly
++ shiftKey DOMKeyEventBase::ShiftKey DontDelete|ReadOnly
++ altKey DOMKeyEventBase::AltKey DontDelete|ReadOnly
+ @end
++*/
++
++DOMKeyEventBase::DOMKeyEventBase(const Object &proto, DOM::TextEvent ke) :
++ DOMUIEvent(proto, ke) {}
++
++DOMKeyEventBase::~DOMKeyEventBase()
++{}
++
++Value DOMKeyEventBase::tryGet(ExecState *exec,const Identifier &p) const
++{
++#ifdef KJS_VERBOSE
++ kdDebug(6070) << "DOMKeyEventBase::tryGet " << p.qstring() << endl;
++#endif
++ return DOMObjectLookupGetValue<DOMKeyEventBase,DOMUIEvent>(exec,p,&DOMKeyEventBaseTable,this);
++}
++
++Value DOMKeyEventBase::getValueProperty(ExecState *, int token) const
++{
++ DOM::KeyEventBaseImpl* tevent = impl();
++ switch (token) {
++ case Key:
++ return Number(tevent->keyVal());
++ case VirtKey:
++ return Number(tevent->virtKeyVal());
++ // these modifier attributes actually belong into a KeyboardEvent interface,
++ // but we want them on "keypress" as well.
++ case CtrlKey:
++ return Boolean(tevent->ctrlKey());
++ case ShiftKey:
++ return Boolean(tevent->shiftKey());
++ case AltKey:
++ return Boolean(tevent->altKey());
++ case MetaKey:
++ return Boolean(tevent->metaKey());
++ default:
++ kdDebug(6070) << "WARNING: Unhandled token in DOMTextEvent::getValueProperty : " << token << endl;
++ return KJS::Undefined();
++ }
++}
++
++// -------------------------------------------------------------------------
++const ClassInfo DOMTextEvent::info = { "TextEvent", &DOMKeyEventBase::info, &DOMTextEventTable, 0 };
++
++/*
++ at begin DOMTextEventTable 1
++ data DOMTextEvent::Data DontDelete|ReadOnly
++ at end
+ @begin DOMTextEventProtoTable 1
+- initTextEvent DOMTextEvent::InitTextEvent DontDelete|Function 10
+- # Missing: initTextEventNS, initModifier
++ initTextEvent DOMTextEvent::InitTextEvent DontDelete|Function 5
++ # Missing: initTextEventNS
+ @end
+ */
+ DEFINE_PROTOTYPE("DOMTextEvent",DOMTextEventProto)
+ IMPLEMENT_PROTOFUNC_DOM(DOMTextEventProtoFunc)
+-IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMTextEventProto,DOMTextEventProtoFunc,DOMUIEventProto)
++IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMTextEventProto,DOMTextEventProtoFunc,DOMUIEventProto) //Note: no proto in KeyBase
+
+ DOMTextEvent::DOMTextEvent(ExecState *exec, DOM::TextEvent ke) :
+- DOMUIEvent(DOMTextEventProto::self(exec), ke) {}
++ DOMKeyEventBase(DOMTextEventProto::self(exec), ke) {}
+
+ DOMTextEvent::~DOMTextEvent()
+ {
+@@ -733,33 +778,15 @@
+ #ifdef KJS_VERBOSE
+ kdDebug(6070) << "DOMTextEvent::tryGet " << p.qstring() << endl;
+ #endif
+- return DOMObjectLookupGetValue<DOMTextEvent,DOMUIEvent>(exec,p,&DOMTextEventTable,this);
++ return DOMObjectLookupGetValue<DOMTextEvent,DOMKeyEventBase>(exec,p,&DOMTextEventTable,this);
+ }
+
+ Value DOMTextEvent::getValueProperty(ExecState *, int token) const
+ {
+- // ### KDE 4: use const reference
+- DOM::TextEvent tevent = static_cast<DOM::TextEvent>(event);
++ DOM::TextEventImpl* tevent = impl();
+ switch (token) {
+- case Key:
+- return Number(tevent.keyVal());
+- case VirtKey:
+- return Number(tevent.virtKeyVal());
+- case OutputString:
+- return String(tevent.outputString());
+- case InputGenerated:
+- return Boolean(tevent.inputGenerated());
+- case NumPad:
+- return Boolean(tevent.numPad());
+- // these modifier attributes actually belong into a KeyboardEvent interface
+- case CtrlKey:
+- return Boolean(tevent.checkModifier(Qt::ControlButton));
+- case ShiftKey:
+- return Boolean(tevent.checkModifier(Qt::ShiftButton));
+- case AltKey:
+- return Boolean(tevent.checkModifier(Qt::AltButton));
+- case MetaKey:
+- return Boolean(tevent.checkModifier(Qt::MetaButton));
++ case Data:
++ return String(tevent->data());
+ default:
+ kdDebug(6070) << "WARNING: Unhandled token in DOMTextEvent::getValueProperty : " << token << endl;
+ return KJS::Undefined();
+@@ -769,27 +796,116 @@
+ Value DOMTextEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
+ {
+ KJS_CHECK_THIS( KJS::DOMTextEvent, thisObj );
+- DOM::TextEvent keyEvent = static_cast<DOMTextEvent *>(thisObj.imp())->toTextEvent();
++ DOM::TextEventImpl* keyEvent = static_cast<DOMTextEvent *>(thisObj.imp())->impl();
+ switch (id) {
+ case DOMTextEvent::InitTextEvent:
+- keyEvent.initTextEvent(args[0].toString(exec).string(), // typeArg
++ keyEvent->initTextEvent(args[0].toString(exec).string(), // typeArg
+ args[1].toBoolean(exec), // canBubbleArg
+ args[2].toBoolean(exec), // cancelableArg
+ toAbstractView(args[3]), // viewArg
+- args[4].toInteger(exec), // detailArg
+- args[5].toString(exec).string(), // outputStringArg
+- args[6].toInteger(exec), // keyValArg
+- args[7].toInteger(exec), // virtKeyValArg
+- args[8].toBoolean(exec), // inputGeneratedArg
+- args[9].toBoolean(exec));// numPadArg
++ args[4].toString(exec).string()); // dataArg
+
+ return Undefined();
+ }
+ return Undefined();
+ }
++// -------------------------------------------------------------------------
++const ClassInfo DOMKeyboardEvent::info = { "KeyboardEvent", &DOMKeyEventBase::info, &DOMKeyboardEventTable, 0 };
+
++/*
++ at begin DOMKeyboardEventTable 2
++ keyIdentifier DOMKeyboardEvent::KeyIdentifier DontDelete|ReadOnly
++ keyLocation DOMKeyboardEvent::KeyLocation DontDelete|ReadOnly
++ at end
++ at begin DOMKeyboardEventProtoTable 2
++ initKeyboardEvent DOMKeyboardEvent::InitKeyboardEvent DontDelete|Function 7
++ getModifierState DOMKeyboardEvent::GetModifierState DontDelete|Function 1
++ at end
++*/
++DEFINE_PROTOTYPE("DOMKeyboardEvent",DOMKeyboardEventProto)
++IMPLEMENT_PROTOFUNC_DOM(DOMKeyboardEventProtoFunc)
++IMPLEMENT_PROTOTYPE_WITH_PARENT(DOMKeyboardEventProto,DOMKeyboardEventProtoFunc,DOMUIEventProto) //Note: no proto in KeyBase
++
++DOMKeyboardEvent::DOMKeyboardEvent(ExecState *exec, DOM::TextEvent ke) :
++ DOMKeyEventBase(DOMKeyboardEventProto::self(exec), ke) {}
++
++DOMKeyboardEvent::~DOMKeyboardEvent()
++{
++}
++
++Value DOMKeyboardEvent::tryGet(ExecState *exec, const Identifier &p) const
++{
++#ifdef KJS_VERBOSE
++ kdDebug(6070) << "DOMKeyboardEvent::tryGet " << p.qstring() << endl;
++#endif
++ return DOMObjectLookupGetValue<DOMKeyboardEvent,DOMKeyEventBase>(exec,p,&DOMKeyboardEventTable,this);
++}
++
++Value DOMKeyboardEvent::getValueProperty(ExecState *, int token) const
++{
++ DOM::KeyboardEventImpl* tevent = impl();
++ switch (token) {
++ case KeyIdentifier:
++ return String(tevent->keyIdentifier());
++ case KeyLocation:
++ return Number(tevent->keyLocation());
++ default:
++ kdDebug(6070) << "WARNING: Unhandled token in DOMKeyboardEvent::getValueProperty : " << token << endl;
++ return KJS::Undefined();
++ }
++}
++
++Value DOMKeyboardEventProtoFunc::tryCall(ExecState *exec, Object &thisObj, const List &args)
++{
++ KJS_CHECK_THIS( KJS::DOMKeyboardEvent, thisObj );
++ DOM::KeyboardEventImpl* keyEvent = static_cast<DOMKeyboardEvent *>(thisObj.imp())->impl();
++ switch (id) {
++ case DOMKeyboardEvent::InitKeyboardEvent:
++ keyEvent->initKeyboardEvent(args[0].toString(exec).string(), // typeArg
++ args[1].toBoolean(exec), // canBubbleArg
++ args[2].toBoolean(exec), // cancelableArg
++ toAbstractView(args[3]), // viewArg
++ args[4].toString(exec).string(), // keyIdentifierArg
++ args[5].toInteger(exec), // keyLocationArg
++ args[6].toString(exec).string()); //modifiersList
++
++ return Undefined();
++ }
++ return Undefined();
++}
++
+ // -------------------------------------------------------------------------
++const ClassInfo KeyboardEventConstructor::info = { "KeyboardEventConstructor", 0, &KeyboardEventConstructorTable, 0 };
++/*
++ at begin KeyboardEventConstructorTable 4
++ DOM_KEY_LOCATION_STANDARD DOM::KeyboardEventImpl::DOM_KEY_LOCATION_STANDARD DontDelete|ReadOnly
++ DOM_KEY_LOCATION_LEFT DOM::KeyboardEventImpl::DOM_KEY_LOCATION_LEFT DontDelete|ReadOnly
++ DOM_KEY_LOCATION_RIGHT DOM::KeyboardEventImpl::DOM_KEY_LOCATION_RIGHT DontDelete|ReadOnly
++ DOM_KEY_LOCATION_NUMPAD DOM::KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD DontDelete|ReadOnly
++ at end
++*/
++KeyboardEventConstructor::KeyboardEventConstructor(ExecState* exec)
++ : DOMObject(exec->interpreter()->builtinObjectPrototype())
++{}
+
++Value KeyboardEventConstructor::tryGet(ExecState *exec, const Identifier &p) const
++{
++ return DOMObjectLookupGetValue<KeyboardEventConstructor,DOMObject>(exec,p,&KeyboardEventConstructorTable,this);
++}
++
++Value KeyboardEventConstructor::getValueProperty(ExecState *, int token) const
++{
++ // We use the token as the value to return directly
++ return Number(token);
++}
++
++Value KJS::getKeyboardEventConstructor(ExecState *exec)
++{
++ return cacheGlobalObject<KeyboardEventConstructor>(exec, "[[keyboardEvent.constructor]]");
++}
++
++
++// -------------------------------------------------------------------------
+ const ClassInfo MutationEventConstructor::info = { "MutationEventConstructor", 0, &MutationEventConstructorTable, 0 };
+ /*
+ @begin MutationEventConstructorTable 3
+--- khtml/ecma/kjs_window.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/ecma/kjs_window.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -227,13 +227,7 @@
+ defaultstatus Window::DefaultStatus DontDelete
+ status Window::Status DontDelete
+ document Window::Document DontDelete|ReadOnly
+- Node Window::Node DontDelete
+ frameElement Window::FrameElement DontDelete|ReadOnly
+- Event Window::EventCtor DontDelete
+- Range Window::Range DontDelete
+- NodeFilter Window::NodeFilter DontDelete
+- DOMException Window::DOMException DontDelete
+- CSSRule Window::CSSRule DontDelete
+ frames Window::Frames DontDelete|ReadOnly
+ history Window::_History DontDelete|ReadOnly
+ external Window::_External DontDelete|ReadOnly
+@@ -270,11 +264,6 @@
+ window Window::_Window DontDelete|ReadOnly
+ top Window::Top DontDelete|ReadOnly
+ screen Window::_Screen DontDelete|ReadOnly
+- Image Window::Image DontDelete|ReadOnly
+- Option Window::Option DontDelete|ReadOnly
+- XMLHttpRequest Window::XMLHttpRequest DontDelete|ReadOnly
+- XMLSerializer Window::XMLSerializer DontDelete|ReadOnly
+- DOMParser Window::DOMParser DontDelete|ReadOnly
+ alert Window::Alert DontDelete|Function 1
+ confirm Window::Confirm DontDelete|Function 1
+ prompt Window::Prompt DontDelete|Function 2
+@@ -326,6 +315,22 @@
+ onselect Window::Onselect DontDelete
+ onsubmit Window::Onsubmit DontDelete
+ onunload Window::Onunload DontDelete
++
++# Constructors/constant tables
++ Node Window::Node DontDelete
++ Event Window::EventCtor DontDelete
++ Range Window::Range DontDelete
++ NodeFilter Window::NodeFilter DontDelete
++ DOMException Window::DOMException DontDelete
++ CSSRule Window::CSSRule DontDelete
++ MutationEvent Window::MutationEventCtor DontDelete
++ KeyboardEvent Window::KeyboardEventCtor DontDelete
++ EventException Window::EventExceptionCtor DontDelete
++ Image Window::Image DontDelete|ReadOnly
++ Option Window::Option DontDelete|ReadOnly
++ XMLHttpRequest Window::XMLHttpRequest DontDelete|ReadOnly
++ XMLSerializer Window::XMLSerializer DontDelete|ReadOnly
++ DOMParser Window::DOMParser DontDelete|ReadOnly
+ @end
+ */
+ IMPLEMENT_PROTOFUNC_DOM(WindowFunc)
+@@ -595,6 +600,12 @@
+ return getCSSRuleConstructor(exec);
+ case EventCtor:
+ return getEventConstructor(exec);
++ case MutationEventCtor:
++ return getMutationEventConstructor(exec);
++ case KeyboardEventCtor:
++ return getKeyboardEventConstructor(exec);
++ case EventExceptionCtor:
++ return getEventExceptionConstructor(exec);
+ case _History:
+ return Value(history ? history :
+ (const_cast<Window*>(this)->history = new History(exec,part)));
+@@ -741,7 +752,7 @@
+ case Ondragdrop:
+ return getListener(exec,DOM::EventImpl::KHTML_DRAGDROP_EVENT);
+ case Onerror:
+- return getListener(exec,DOM::EventImpl::KHTML_ERROR_EVENT);
++ return getListener(exec,DOM::EventImpl::ERROR_EVENT);
+ case Onfocus:
+ return getListener(exec,DOM::EventImpl::FOCUS_EVENT);
+ case Onkeydown:
+@@ -917,7 +928,7 @@
+ return;
+ case Onerror:
+ if (isSafeScript(exec))
+- setListener(exec,DOM::EventImpl::KHTML_ERROR_EVENT,value);
++ setListener(exec,DOM::EventImpl::ERROR_EVENT,value);
+ return;
+ case Onfocus:
+ if (isSafeScript(exec))
+--- khtml/ecma/kjs_proxy.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/ecma/kjs_proxy.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -344,7 +344,8 @@
+ else
+ // If we find "Mozilla" but not "(compatible, ...)" we are a real Netscape
+ if (userAgent.find(QString::fromLatin1("Mozilla")) >= 0 &&
+- userAgent.find(QString::fromLatin1("compatible")) == -1)
++ userAgent.find(QString::fromLatin1("compatible")) == -1 &&
++ userAgent.find(QString::fromLatin1("KHTML")) == -1)
+ {
+ m_script->setCompatMode(Interpreter::NetscapeCompat);
+ #ifdef KJS_VERBOSE
+--- khtml/rendering/render_form.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/rendering/render_form.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -328,6 +328,7 @@
+
+ virtual bool isEditable() const { return true; }
+ virtual bool canHaveBorder() const { return true; }
++ virtual bool acceptsSyntheticEvents() const { return false; }
+
+ bool m_clicked;
+ bool m_haveFocus;
+--- khtml/rendering/render_replaced.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/rendering/render_replaced.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -119,6 +119,8 @@
+ protected:
+ virtual bool canHaveBorder() const { return false; }
+
++ virtual bool acceptsSyntheticEvents() const { return true; }
++
+ virtual void handleFocusOut() {}
+ bool event( QEvent *e );
+
+--- khtml/rendering/render_replaced.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/rendering/render_replaced.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -682,6 +682,7 @@
+ case EventImpl::MOUSEDOWN_EVENT:
+ case EventImpl::MOUSEUP_EVENT:
+ case EventImpl::MOUSEMOVE_EVENT: {
++ if (!ev.isMouseEvent()) break;
+ const MouseEventImpl &me = static_cast<const MouseEventImpl &>(ev);
+ QMouseEvent* const qme = me.qEvent();
+
+@@ -748,13 +749,22 @@
+ // do nothing; see the mapping table below
+ break;
+ case EventImpl::KEYUP_EVENT: {
+- QKeyEvent* const ke = static_cast<const TextEventImpl &>(ev).qKeyEvent();
++ if (!ev.isKeyRelatedEvent()) break;
++
++ const KeyEventBaseImpl& domKeyEv = static_cast<const KeyEventBaseImpl &>(ev);
++ if (domKeyEv.isSynthetic() && !acceptsSyntheticEvents()) break;
++
++ QKeyEvent* const ke = domKeyEv.qKeyEvent();
+ static_cast<EventPropagator *>(m_widget)->sendEvent(ke);
+ ret = ke->isAccepted();
+ break;
+ }
+ case EventImpl::KEYPRESS_EVENT: {
++ if (!ev.isKeyRelatedEvent()) break;
+
++ const KeyEventBaseImpl& domKeyEv = static_cast<const KeyEventBaseImpl &>(ev);
++ if (domKeyEv.isSynthetic() && !acceptsSyntheticEvents()) break;
++
+ // See KHTMLView::dispatchKeyEvent: autorepeat is just keypress in the DOM
+ // but it's keyrelease+keypress in Qt. So here we do the inverse mapping as
+ // the one done in KHTMLView: generate two events for one DOM auto-repeat keypress.
+@@ -768,7 +778,7 @@
+ // Qt::KeyPress is sent for DOM keypress and not DOM keydown to allow
+ // sites to block a key with onkeypress, #99749
+
+- QKeyEvent* const ke = static_cast<const TextEventImpl &>(ev).qKeyEvent();
++ QKeyEvent* const ke = domKeyEv.qKeyEvent();
+ if (ke->isAutoRepeat()) {
+ QKeyEvent releaseEv( QEvent::KeyRelease, ke->key(), ke->ascii(), ke->state(),
+ ke->text(), ke->isAutoRepeat(), ke->count() );
+--- khtml/dom/html_misc.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/dom/html_misc.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -211,7 +211,7 @@
+ /**
+ @internal. Not part of the public API
+ */
+-class HTMLMappedNameCollection : public HTMLCollection
++class KHTML_EXPORT HTMLMappedNameCollection : public HTMLCollection
+ {
+ public:
+ HTMLMappedNameCollection(NodeImpl *base, int type, const DOMString &name );
+--- khtml/dom/dom2_events.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/dom/dom2_events.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -41,7 +41,7 @@
+ class EventImpl;
+ class UIEventImpl;
+ class MouseEventImpl;
+-class TextEventImpl;
++class KeyEventBaseImpl;
+ class MutationEventImpl;
+
+
+@@ -547,6 +547,10 @@
+ * The detail attribute inherited from UIEvent is used to indicate
+ * the number of keypresses which have occurred during key repetition.
+ * If this information is not available this value should be 0.
++ *
++ * ### KDE4: split this up into proper KeyboardEvent and TextEvent classes
++ * as specified in current DOM3 Events revision. This is doing heavy emulation
++ * at the moment
+ */
+ class KHTML_EXPORT TextEvent : public UIEvent {
+ public:
+@@ -618,15 +622,10 @@
+ * true, all modifiers have a value of false. This method has no
+ * effect if called after the event has been dispatched. The list of
+ * keys below represents the allowable modifier parameters for this
+- * method:
+- * DOM_VK_LEFT_ALT
+- * DOM_VK_RIGHT_ALT
+- * DOM_VK_LEFT_CONTROL
+- * DOM_VK_RIGHT_CONTROL
+- * DOM_VK_LEFT_SHIFT
+- * DOM_VK_RIGHT_SHIFT
+- * DOM_VK_META
++ * method (note: this was not documented properly in earlier versions):
+ *
++ * Qt::ShiftButton, Qt::AltButton, Qt::ControlButton, Qt::MetaButton
++ *
+ * Parameters:
+ *
+ * modifier of type unsigned long
+@@ -708,14 +707,9 @@
+ * modifier in question is passed into the CheckModifier function. If
+ * the modifier is triggered it will return true. If not, it will
+ * return false. The list of keys below represents the allowable
+- * modifier parameters for this method:
+- * DOM_VK_LEFT_ALT
+- * DOM_VK_RIGHT_ALT
+- * DOM_VK_LEFT_CONTROL
+- * DOM_VK_RIGHT_CONTROL
+- * DOM_VK_LEFT_SHIFT
+- * DOM_VK_RIGHT_SHIFT
+- * DOM_VK_META
++ * modifier parameters for this method (warning: this was not documented
++ * properly in earlier versions):
++ * Qt::ShiftButton, Qt::AltButton, Qt::ControlButton, Qt::MetaButton
+ *
+ * Parameters:
+ *
+@@ -730,7 +724,7 @@
+ bool checkModifier(unsigned long modifierArg); // ### KDE 4: const!
+
+ protected:
+- TextEvent(TextEventImpl *impl);
++ TextEvent(KeyEventBaseImpl *impl);
+ };
+
+
+--- khtml/dom/dom2_events.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/dom/dom2_events.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -251,8 +251,8 @@
+ {
+ if ( !impl ) throw DOMException( DOMException::INVALID_STATE_ERR );
+
+- if( impl->isTextEvent() )
+- return static_cast<TextEventImpl*>( impl )->keyCode();
++ if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
++ return static_cast<KeyEventBaseImpl*>( impl )->keyCode();
+
+ return 0;
+ }
+@@ -262,8 +262,8 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- if( impl->isTextEvent() )
+- return static_cast<TextEventImpl*>( impl )->charCode();
++ if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
++ return static_cast<KeyEventBaseImpl*>( impl )->charCode();
+
+ return 0;
+ }
+@@ -316,8 +316,8 @@
+
+ if( impl->isMouseEvent() )
+ return static_cast<MouseEventImpl*>( impl )->button() + 1;
+- else if( impl->isTextEvent() )
+- return static_cast<TextEventImpl*>( impl )->keyCode();
++ else if( impl->isTextInputEvent() || impl->isKeyboardEvent() )
++ return static_cast<KeyEventBaseImpl*>( impl )->keyCode();
+
+ return 0;
+ }
+@@ -496,7 +496,7 @@
+ (*this)=other;
+ }
+
+-TextEvent::TextEvent(TextEventImpl *impl) : UIEvent(impl)
++TextEvent::TextEvent(KeyEventBaseImpl *impl) : UIEvent(impl)
+ {
+ }
+
+@@ -510,7 +510,7 @@
+ {
+ Event e;
+ e = other;
+- if (!e.isNull() && !e.handle()->isTextEvent()) {
++ if (!e.isNull() && !(e.handle()->isTextInputEvent() || e.handle()->isKeyboardEvent())) {
+ if ( impl ) impl->deref();
+ impl = 0;
+ } else
+@@ -526,17 +526,31 @@
+ bool canBubbleArg,
+ bool cancelableArg,
+ const AbstractView &viewArg,
+- long detailArg,
++ long /*detailArg*/,
+ const DOMString &outputStringArg,
+ unsigned long keyValArg,
+ unsigned long virtKeyValArg,
+- bool inputGeneratedArg,
++ bool /*inputGeneratedArg*/,
+ bool numPadArg)
+ {
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg, outputStringArg, keyValArg, virtKeyValArg, inputGeneratedArg, numPadArg);
++ if (impl->isTextInputEvent()) {
++ //Initialize based on the outputStringArg or virtKeyValArg.
++ QString text = outputStringArg.string();
++ if (outputStringArg.length() == 0 && virtKeyValArg) {
++ text += QChar((unsigned short)virtKeyValArg);
++ }
++
++ TextEventImpl* tImpl = static_cast<TextEventImpl*>(impl);
++ tImpl->initTextEvent(typeArg, canBubbleArg, cancelableArg, viewArg, text);
++ } else {
++ KeyboardEventImpl* kbImpl = static_cast<KeyboardEventImpl*>(impl);
++ kbImpl->initKeyboardEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
++ keyValArg, virtKeyValArg, 0, numPadArg ?
++ KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD : KeyboardEventImpl::DOM_KEY_LOCATION_STANDARD);
++ }
+ }
+
+ unsigned long TextEvent::keyVal() const
+@@ -544,7 +558,7 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->keyVal();
++ return static_cast<KeyEventBaseImpl*>(impl)->keyVal();
+ }
+
+ DOMString TextEvent::outputString() const
+@@ -552,7 +566,15 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->outputString();
++ KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl);
++ if (ke->isTextInputEvent())
++ return static_cast<TextEventImpl*>(ke)->data();
++ else {
++ if (ke->keyVal())
++ return QString(QChar((ushort)ke->keyVal()));
++ else
++ return DOMString();
++ }
+ }
+
+ unsigned long TextEvent::virtKeyVal() const
+@@ -560,7 +582,7 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->virtKeyVal();
++ return static_cast<KeyEventBaseImpl*>(impl)->virtKeyVal();
+ }
+
+ void TextEvent::initModifier(unsigned long modifierArg, bool valueArg)
+@@ -568,7 +590,7 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->initModifier(modifierArg,valueArg);
++ return static_cast<KeyEventBaseImpl*>(impl)->initModifier(modifierArg,valueArg);
+ }
+
+ bool TextEvent::checkModifier(unsigned long modifierArg)
+@@ -576,7 +598,7 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->checkModifier(modifierArg);
++ return static_cast<KeyEventBaseImpl*>(impl)->checkModifier(modifierArg);
+ }
+
+ bool TextEvent::inputGenerated() const
+@@ -584,7 +606,7 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->inputGenerated();
++ return static_cast<KeyEventBaseImpl*>(impl)->inputGenerated();
+ }
+
+ bool TextEvent::numPad() const
+@@ -592,7 +614,11 @@
+ if (!impl)
+ throw DOMException(DOMException::INVALID_STATE_ERR);
+
+- return static_cast<TextEventImpl*>(impl)->numPad();
++ KeyEventBaseImpl* ke = static_cast<KeyEventBaseImpl*>(impl);
++ if (ke->isKeyboardEvent())
++ return static_cast<KeyboardEventImpl*>(ke)->keyLocation() ==
++ KeyboardEventImpl::DOM_KEY_LOCATION_NUMPAD;
++ else return false;
+ }
+ // -----------------------------------------------------------------------------
+
+--- khtml/css/css_ruleimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/css/css_ruleimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -368,8 +368,9 @@
+ CSSRuleImpl *rule = m_lstCSSRules.take( index );
+ if( rule )
+ rule->deref();
+- else
+- ; // ### Throw INDEX_SIZE_ERR exception here (TODO)
++ else {
++ // ### Throw INDEX_SIZE_ERR exception here (TODO)
++ }
+ }
+
+ unsigned long CSSRuleListImpl::insertRule( CSSRuleImpl *rule,
+--- khtml/css/cssstyleselector.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/css/cssstyleselector.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -3017,9 +3017,9 @@
+ int type = primitiveValue->primitiveType();
+ if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG) {
+ if ( !khtml::printpainter && type != CSSPrimitiveValue::CSS_EMS && type != CSSPrimitiveValue::CSS_EXS &&
+- element && element->getDocument()->view())
++ view && view->part())
+ size = int( primitiveValue->computeLengthFloat(parentStyle, paintDeviceMetrics) *
+- element->getDocument()->view()->part()->zoomFactor() ) / 100;
++ view->part()->zoomFactor() ) / 100;
+ else
+ size = int( primitiveValue->computeLengthFloat(parentStyle, paintDeviceMetrics) );
+ }
+@@ -3093,17 +3093,14 @@
+ if (primitiveValue->getIdent() == CSS_VAL_NORMAL)
+ lineHeight = Length( -100, Percent );
+ else if (type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG) {
+-#ifdef APPLE_CHANGES
+- double multiplier = 1.0;
+ // Scale for the font zoom factor only for types other than "em" and "ex", since those are
+ // already based on the font size.
+- if (type != CSSPrimitiveValue::CSS_EMS && type != CSSPrimitiveValue::CSS_EXS && view && view->part()) {
+- multiplier = view->part()->zoomFactor() / 100.0;
+- }
+- lineHeight = Length(primitiveValue->computeLength(style, paintDeviceMetrics, multiplier), Fixed);
+-#else
+- lineHeight = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed);
+-#endif
++ if ( !khtml::printpainter && type != CSSPrimitiveValue::CSS_EMS && type != CSSPrimitiveValue::CSS_EXS &&
++ view && view->part())
++ lineHeight = Length(primitiveValue->computeLength(style, paintDeviceMetrics) *
++ view->part()->zoomFactor()/100, Fixed );
++ else
++ lineHeight = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed );
+ } else if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
+ lineHeight = Length( ( style->font().pixelSize() * int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE)) ) / 100, Fixed );
+ else if (type == CSSPrimitiveValue::CSS_NUMBER)
+--- khtml/kjserrordlg.ui.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/kjserrordlg.ui.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -10,14 +10,14 @@
+
+ void KJSErrorDlg::init()
+ {
+- _errorText->setText("<qt>");
++ _errorText->setTextFormat(QTextEdit::LogText);
++ _errorText->setMaxLogLines(2048);//Limit to about 2K errors so we don't use much CPU
+ }
+
+ void KJSErrorDlg::addError( const QString & error )
+ {
+- // Argh why doesn't QText* interpret html tags unless I use setText()?
+- // This is really inefficient!
+- _errorText->setText(_errorText->text() + "<br>\n" + error);
++
++ _errorText->append(error);
+ }
+
+ void KJSErrorDlg::setURL( const QString & url )
+@@ -28,5 +28,5 @@
+ void KJSErrorDlg::clear()
+ {
+ _errorText->clear();
+- _errorText->insert("<qt>");
++ init();
+ }
+--- khtml/misc/loader.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/misc/loader.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -492,8 +492,8 @@
+
+ const QPixmap &CachedImage::tiled_pixmap(const QColor& newc)
+ {
+- static QRgb bgTransparant = qRgba( 0, 0, 0, 0xFF );
+- if ( (bgColor != bgTransparant) && (bgColor != newc.rgb()) ) {
++ static QRgb bgTransparent = qRgba( 0, 0, 0, 0xFF );
++ if ( (bgColor != bgTransparent) && (bgColor != newc.rgb()) ) {
+ delete bg; bg = 0;
+ }
+
+@@ -511,6 +511,21 @@
+ QSize s(pixmap_size());
+ int w = r.width();
+ int h = r.height();
++
++ const QPixmap* src; //source for pretiling, if any
++ //See whether we can - and should - pre-blend
++ if (isvalid && (r.hasAlphaChannel() || r.mask() )) {
++ bg = new QPixmap(w, h);
++ bg->fill(newc);
++ bitBlt(bg, 0, 0, &r);
++ bgColor = newc.rgb();
++ src = bg;
++ } else {
++ src = &r;
++ bgColor = bgTransparent;
++ }
++
++ //See whether to pre-tile.
+ if ( w*h < 8192 )
+ {
+ if ( r.width() < BGMINWIDTH )
+@@ -519,74 +534,20 @@
+ h = ((BGMINHEIGHT / s.height())+1) * s.height();
+ }
+
+-#ifdef Q_WS_X11
+- if ( r.hasAlphaChannel() &&
+- ((w != r.width()) || (h != r.height())) )
++ if ( w != r.width() || h != r.height() )
+ {
+ bg = new QPixmap(w, h);
+ //Tile horizontally on the first stripe
+ for (int x = 0; x < w; x += r.width())
+- copyBlt(bg, x, 0, &r, 0, 0, r.width(), r.height());
++ copyBlt(bg, x, 0, src, 0, 0, r.width(), r.height());
+
+ //Copy first stripe down
+ for (int y = r.height(); y < h; y += r.height())
+ copyBlt(bg, 0, y, bg, 0, 0, w, r.height());
+-
+- return *bg;
+ }
+-#endif
+
+- if (
+-#ifdef Q_WS_X11
+- !r.hasAlphaChannel() &&
+-#endif
+- ( (w != r.width()) || (h != r.height()) || (isvalid && r.mask())) )
+- {
+- QPixmap pix = r;
+- if ( w != r.width() || (isvalid && pix.mask()))
+- {
+- bg = new QPixmap(w, r.height());
+- QPainter p(bg);
+- if(isvalid) p.fillRect(0, 0, w, r.height(), newc);
+- p.drawTiledPixmap(0, 0, w, r.height(), pix);
+- p.end();
+-
+- if(!isvalid && pix.mask())
+- {
+- // unfortunately our anti-transparency trick doesn't work here
+- // we need to create a mask.
+- QBitmap newmask(w, r.height());
+- QPainter pm(&newmask);
+- pm.drawTiledPixmap(0, 0, w, r.height(), *pix.mask());
+- bg->setMask(newmask);
+- bgColor = bgTransparant;
+- }
+- else
+- bgColor= newc.rgb();
+- pix = *bg;
+- }
+- if ( h != r.height() )
+- {
+- delete bg;
+- bg = new QPixmap(w, h);
+- QPainter p(bg);
+- if(isvalid) p.fillRect(0, 0, w, h, newc);
+- p.drawTiledPixmap(0, 0, w, h, pix);
+- if(!isvalid && pix.mask())
+- {
+- // unfortunately our anti-transparency trick doesn't work here
+- // we need to create a mask.
+- QBitmap newmask(w, h);
+- QPainter pm(&newmask);
+- pm.drawTiledPixmap(0, 0, w, h, *pix.mask());
+- bg->setMask(newmask);
+- bgColor = bgTransparant;
+- }
+- else
+- bgColor= newc.rgb();
+- }
++ if (bg)
+ return *bg;
+- }
+
+ return r;
+ }
+--- khtml/xml/dom2_viewsimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/xml/dom2_viewsimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -41,7 +41,7 @@
+
+ CSSStyleDeclarationImpl *AbstractViewImpl::getComputedStyle(ElementImpl* elt, DOMStringImpl* /*pseudoElt*/)
+ {
+- if (!elt || !elt->renderer())
++ if (!elt)
+ return 0;
+
+ CSSStyleDeclarationImpl* style = new RenderStyleDeclarationImpl( elt );
+--- khtml/xml/dom_nodeimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/xml/dom_nodeimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -572,7 +572,11 @@
+ {
+ int exceptioncode = 0;
+ //kdDebug(6010) << "DOM::NodeImpl: dispatching keyboard event" << endl;
+- TextEventImpl* const keyEventImpl = new TextEventImpl(key, keypress, getDocument()->defaultView());
++ EventImpl* keyEventImpl;
++ if (keypress)
++ keyEventImpl = new TextEventImpl(key, getDocument()->defaultView());
++ else
++ keyEventImpl = new KeyboardEventImpl(key, getDocument()->defaultView());
+ keyEventImpl->ref();
+ dispatchEvent(keyEventImpl,exceptioncode,true);
+ bool r = keyEventImpl->defaultHandled() || keyEventImpl->defaultPrevented();
+--- khtml/xml/dom2_eventsimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/xml/dom2_eventsimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -4,6 +4,7 @@
+ * Copyright (C) 2001 Peter Kelly (pmk at post.com)
+ * (C) 2001 Tobias Anton (anton at stud.fbi.fh-darmstadt.de)
+ * (C) 2003 Apple Computer, Inc.
++ * (C) 2006 Maksim Orlovich (maksim at kde.org)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+@@ -173,6 +174,8 @@
+ return KEYDOWN_EVENT;
+ else if ( type == "keyup" )
+ return KEYUP_EVENT;
++ else if ( type == "textInput" )
++ return KEYPRESS_EVENT;
+ else if ( type == "keypress" )
+ return KEYPRESS_EVENT;
+ else if ( type == "readystatechange" )
+@@ -248,7 +251,7 @@
+ case KEYUP_EVENT:
+ return "keyup";
+ case KEYPRESS_EVENT:
+- return "keypress";
++ return "keypress"; //DOM3 ev. suggests textInput, but it's better for compat this way
+
+ //khtml extensions
+ case KHTML_ECMA_DBLCLICK_EVENT:
+@@ -257,8 +260,6 @@
+ return "click";
+ case KHTML_DRAGDROP_EVENT:
+ return "khtml_dragdrop";
+- case KHTML_ERROR_EVENT:
+- return "khtml_error";
+ case KHTML_MOVE_EVENT:
+ return "khtml_move";
+ case KHTML_READYSTATECHANGE_EVENT:
+@@ -285,11 +286,16 @@
+ return false;
+ }
+
+-bool EventImpl::isTextEvent() const
++bool EventImpl::isTextInputEvent() const
+ {
+ return false;
+ }
+
++bool EventImpl::isKeyboardEvent() const
++{
++ return false;
++}
++
+ // -----------------------------------------------------------------------------
+
+ UIEventImpl::UIEventImpl(EventId _id, bool canBubbleArg, bool cancelableArg,
+@@ -474,297 +480,411 @@
+ }
+
+ //---------------------------------------------------------------------------------------------
++/* This class is used to do remapping between different encodings reasonably compactly */
+
+-TextEventImpl::TextEventImpl()
++template<typename L, typename R, typename MemL>
++class IDTranslator
+ {
+- m_keyEvent = 0;
+-}
++public:
++ struct Info {
++ MemL l;
++ R r;
++ };
+
+-TextEventImpl::TextEventImpl(QKeyEvent *key, bool keypress, AbstractViewImpl *view)
+- : UIEventImpl(KEYDOWN_EVENT,true,true,view,0)
+-{
+- m_keyEvent = new QKeyEvent(key->type(), key->key(), key->ascii(), key->state(), key->text(), key->isAutoRepeat(), key->count() );
+- // Events are supposed to be accepted by default in Qt!
+- // This line made QLineEdit's keyevents be ignored, so they were sent to the khtmlview
+- // (and e.g. space would make it scroll down)
+- //m_keyEvent->ignore();
++ IDTranslator(const Info* table) {
++ for (const Info* cursor = table; cursor->l; ++cursor) {
++ m_lToR.insert(cursor->l, cursor->r);
++ m_rToL.insert(cursor->r, cursor->l);
++ }
++ }
+
+- if( keypress )
+- m_id = KEYPRESS_EVENT;
+- else if( key->type() == QEvent::KeyPress )
+- m_id = KEYDOWN_EVENT;
+- else if( key->type() == QEvent::KeyRelease )
+- m_id = KEYUP_EVENT;
++ L toLeft(R r) {
++ typename QMap<R,L>::iterator i = m_rToL.find(r);
++ if (i != m_rToL.end())
++ return *i;
++ return L();
++ }
+
+- m_detail = key->count();
++ R toRight(L l) {
++ typename QMap<L,R>::iterator i = m_lToR.find(l);
++ if (i != m_lToR.end())
++ return *i;
++ return R();
++ }
+
+- m_numPad = false;
+- m_keyVal = key->ascii();
+- m_virtKeyVal = DOM_VK_UNDEFINED;
+- m_inputGenerated = true;
++private:
++ QMap<L, R> m_lToR;
++ QMap<R, L> m_rToL;
++};
+
+- switch(key->key())
+- {
+- case Qt::Key_Enter:
+- m_numPad = true;
+- /* fall through */
+- case Qt::Key_Return:
+- m_virtKeyVal = DOM_VK_ENTER;
+- break;
+- case Qt::Key_NumLock:
+- m_numPad = true;
+- m_virtKeyVal = DOM_VK_NUM_LOCK;
+- break;
+- case Qt::Key_Alt:
+- m_virtKeyVal = DOM_VK_RIGHT_ALT;
+- // ### DOM_VK_LEFT_ALT;
+- break;
+- case Qt::Key_Control:
+- m_virtKeyVal = DOM_VK_LEFT_CONTROL;
+- // ### DOM_VK_RIGHT_CONTROL
+- break;
+- case Qt::Key_Shift:
+- m_virtKeyVal = DOM_VK_LEFT_SHIFT;
+- // ### DOM_VK_RIGHT_SHIFT
+- break;
+- case Qt::Key_Meta:
+- m_virtKeyVal = DOM_VK_META;
+- break;
+- case Qt::Key_CapsLock:
+- m_virtKeyVal = DOM_VK_CAPS_LOCK;
+- break;
+- case Qt::Key_Delete:
+- m_virtKeyVal = DOM_VK_DELETE;
+- break;
+- case Qt::Key_End:
+- m_virtKeyVal = DOM_VK_END;
+- break;
+- case Qt::Key_Escape:
+- m_virtKeyVal = DOM_VK_ESCAPE;
+- break;
+- case Qt::Key_Home:
+- m_virtKeyVal = DOM_VK_HOME;
+- break;
+-// case Qt::Key_Insert:
+-// m_virtKeyVal = DOM_VK_INSERT;
+-// break;
+- case Qt::Key_Pause:
+- m_virtKeyVal = DOM_VK_PAUSE;
+- break;
+- case Qt::Key_Print:
+- m_virtKeyVal = DOM_VK_PRINTSCREEN;
+- break;
+- case Qt::Key_ScrollLock:
+- m_virtKeyVal = DOM_VK_SCROLL_LOCK;
+- break;
+- case Qt::Key_Left:
+- m_virtKeyVal = DOM_VK_LEFT;
+- break;
+- case Qt::Key_Right:
+- m_virtKeyVal = DOM_VK_RIGHT;
+- break;
+- case Qt::Key_Up:
+- m_virtKeyVal = DOM_VK_UP;
+- break;
+- case Qt::Key_Down:
+- m_virtKeyVal = DOM_VK_DOWN;
+- break;
+- case Qt::Key_Next:
+- m_virtKeyVal = DOM_VK_PAGE_DOWN;
+- break;
+- case Qt::Key_Prior:
+- m_virtKeyVal = DOM_VK_PAGE_UP;
+- break;
+- case Qt::Key_F1:
+- m_virtKeyVal = DOM_VK_F1;
+- break;
+- case Qt::Key_F2:
+- m_virtKeyVal = DOM_VK_F2;
+- break;
+- case Qt::Key_F3:
+- m_virtKeyVal = DOM_VK_F3;
+- break;
+- case Qt::Key_F4:
+- m_virtKeyVal = DOM_VK_F4;
+- break;
+- case Qt::Key_F5:
+- m_virtKeyVal = DOM_VK_F5;
+- break;
+- case Qt::Key_F6:
+- m_virtKeyVal = DOM_VK_F6;
+- break;
+- case Qt::Key_F7:
+- m_virtKeyVal = DOM_VK_F7;
+- break;
+- case Qt::Key_F8:
+- m_virtKeyVal = DOM_VK_F8;
+- break;
+- case Qt::Key_F9:
+- m_virtKeyVal = DOM_VK_F9;
+- break;
+- case Qt::Key_F10:
+- m_virtKeyVal = DOM_VK_F10;
+- break;
+- case Qt::Key_F11:
+- m_virtKeyVal = DOM_VK_F11;
+- break;
+- case Qt::Key_F12:
+- m_virtKeyVal = DOM_VK_F12;
+- break;
+- case Qt::Key_F13:
+- m_virtKeyVal = DOM_VK_F13;
+- break;
+- case Qt::Key_F14:
+- m_virtKeyVal = DOM_VK_F14;
+- break;
+- case Qt::Key_F15:
+- m_virtKeyVal = DOM_VK_F15;
+- break;
+- case Qt::Key_F16:
+- m_virtKeyVal = DOM_VK_F16;
+- break;
+- case Qt::Key_F17:
+- m_virtKeyVal = DOM_VK_F17;
+- break;
+- case Qt::Key_F18:
+- m_virtKeyVal = DOM_VK_F18;
+- break;
+- case Qt::Key_F19:
+- m_virtKeyVal = DOM_VK_F19;
+- break;
+- case Qt::Key_F20:
+- m_virtKeyVal = DOM_VK_F20;
+- break;
+- case Qt::Key_F21:
+- m_virtKeyVal = DOM_VK_F21;
+- break;
+- case Qt::Key_F22:
+- m_virtKeyVal = DOM_VK_F22;
+- break;
+- case Qt::Key_F23:
+- m_virtKeyVal = DOM_VK_F23;
+- break;
+- case Qt::Key_F24:
+- m_virtKeyVal = DOM_VK_F24;
+- break;
+- default:
+- m_virtKeyVal = DOM_VK_UNDEFINED;
+- break;
+- }
++#define MAKE_TRANSLATOR(name,L,R,MR,table) static IDTranslator<L,R,MR>* s_##name; \
++ static IDTranslator<L,R,MR>* name() { if (!s_##name) s_##name = new IDTranslator<L,R,MR>(table); \
++ return s_##name; }
+
+- // m_keyVal should contain the unicode value
+- // of the pressed key if available.
+- if (m_virtKeyVal == DOM_VK_UNDEFINED && !key->text().isEmpty())
+- m_keyVal = key->text().unicode()[0];
++//---------------------------------------------------------------------------------------------
+
+- // m_numPad = ???
++/* Mapping between special Qt keycodes and virtual DOM codes */
++IDTranslator<unsigned, unsigned, unsigned>::Info virtKeyToQtKeyTable[] =
++{
++ {KeyEventBaseImpl::DOM_VK_ENTER, Qt::Key_Enter},
++ {KeyEventBaseImpl::DOM_VK_ENTER, Qt::Key_Return},
++ {KeyEventBaseImpl::DOM_VK_NUM_LOCK, Qt::Key_NumLock},
++ {KeyEventBaseImpl::DOM_VK_RIGHT_ALT, Qt::Key_Alt},
++ {KeyEventBaseImpl::DOM_VK_LEFT_CONTROL, Qt::Key_Control},
++ {KeyEventBaseImpl::DOM_VK_LEFT_SHIFT, Qt::Key_Shift},
++ {KeyEventBaseImpl::DOM_VK_META, Qt::Key_Meta},
++ {KeyEventBaseImpl::DOM_VK_CAPS_LOCK, Qt::Key_CapsLock},
++ {KeyEventBaseImpl::DOM_VK_DELETE, Qt::Key_Delete},
++ {KeyEventBaseImpl::DOM_VK_END, Qt::Key_End},
++ {KeyEventBaseImpl::DOM_VK_ESCAPE, Qt::Key_Escape},
++ {KeyEventBaseImpl::DOM_VK_HOME, Qt::Key_Home},
++ {KeyEventBaseImpl::DOM_VK_PAUSE, Qt::Key_Pause},
++ {KeyEventBaseImpl::DOM_VK_PRINTSCREEN, Qt::Key_Print},
++ {KeyEventBaseImpl::DOM_VK_SCROLL_LOCK, Qt::Key_ScrollLock},
++ {KeyEventBaseImpl::DOM_VK_LEFT, Qt::Key_Left},
++ {KeyEventBaseImpl::DOM_VK_RIGHT, Qt::Key_Right},
++ {KeyEventBaseImpl::DOM_VK_UP, Qt::Key_Up},
++ {KeyEventBaseImpl::DOM_VK_DOWN, Qt::Key_Down},
++ {KeyEventBaseImpl::DOM_VK_PAGE_DOWN, Qt::Key_Next},
++ {KeyEventBaseImpl::DOM_VK_PAGE_UP, Qt::Key_Prior},
++ {KeyEventBaseImpl::DOM_VK_F1, Qt::Key_F1},
++ {KeyEventBaseImpl::DOM_VK_F2, Qt::Key_F2},
++ {KeyEventBaseImpl::DOM_VK_F3, Qt::Key_F3},
++ {KeyEventBaseImpl::DOM_VK_F4, Qt::Key_F4},
++ {KeyEventBaseImpl::DOM_VK_F5, Qt::Key_F5},
++ {KeyEventBaseImpl::DOM_VK_F6, Qt::Key_F6},
++ {KeyEventBaseImpl::DOM_VK_F7, Qt::Key_F7},
++ {KeyEventBaseImpl::DOM_VK_F8, Qt::Key_F8},
++ {KeyEventBaseImpl::DOM_VK_F9, Qt::Key_F9},
++ {KeyEventBaseImpl::DOM_VK_F10, Qt::Key_F10},
++ {KeyEventBaseImpl::DOM_VK_F11, Qt::Key_F11},
++ {KeyEventBaseImpl::DOM_VK_F12, Qt::Key_F12},
++ {KeyEventBaseImpl::DOM_VK_F13, Qt::Key_F13},
++ {KeyEventBaseImpl::DOM_VK_F14, Qt::Key_F14},
++ {KeyEventBaseImpl::DOM_VK_F15, Qt::Key_F15},
++ {KeyEventBaseImpl::DOM_VK_F16, Qt::Key_F16},
++ {KeyEventBaseImpl::DOM_VK_F17, Qt::Key_F17},
++ {KeyEventBaseImpl::DOM_VK_F18, Qt::Key_F18},
++ {KeyEventBaseImpl::DOM_VK_F19, Qt::Key_F19},
++ {KeyEventBaseImpl::DOM_VK_F20, Qt::Key_F20},
++ {KeyEventBaseImpl::DOM_VK_F21, Qt::Key_F21},
++ {KeyEventBaseImpl::DOM_VK_F22, Qt::Key_F22},
++ {KeyEventBaseImpl::DOM_VK_F23, Qt::Key_F23},
++ {KeyEventBaseImpl::DOM_VK_F24, Qt::Key_F24},
++ {0, 0}
++};
+
+- // key->state returns enum ButtonState, which is ShiftButton, ControlButton and AltButton or'ed together.
+- m_modifier = key->state();
++MAKE_TRANSLATOR(virtKeyToQtKey, unsigned, unsigned, unsigned, virtKeyToQtKeyTable)
+
+- // key->text() returns the unicode sequence as a QString
+- m_outputString = DOMString(key->text());
++KeyEventBaseImpl::KeyEventBaseImpl(EventId id, bool canBubbleArg, bool cancelableArg, AbstractViewImpl *viewArg,
++ QKeyEvent *key) :
++ UIEventImpl(id, canBubbleArg, cancelableArg, viewArg, 0)
++{
++ m_synthetic = false;
++
++ //Here, we need to map Qt's internal info to browser-style info.
++ m_keyEvent = new QKeyEvent(key->type(), key->key(), key->ascii(), key->state(), key->text(), key->isAutoRepeat(), key->count() );
++
++ m_detail = key->count();
++ m_keyVal = key->ascii();
++ m_virtKeyVal = virtKeyToQtKey()->toLeft(key->key());
++
++ // m_keyVal should contain the unicode value
++ // of the pressed key if available.
++ if (m_virtKeyVal == DOM_VK_UNDEFINED && !key->text().isEmpty())
++ m_keyVal = key->text().unicode()[0];
++
++ // key->state returns enum ButtonState, which is ShiftButton, ControlButton and AltButton or'ed together.
++ m_modifier = key->state();
+ }
+
+-TextEventImpl::TextEventImpl(EventId _id,
+- bool canBubbleArg,
+- bool cancelableArg,
+- AbstractViewImpl *viewArg,
+- unsigned short detailArg,
+- DOMString &outputStringArg,
+- unsigned long keyValArg,
+- unsigned long virtKeyValArg,
+- bool inputGeneratedArg,
+- bool numPadArg)
+- : UIEventImpl(_id,canBubbleArg,cancelableArg,viewArg,detailArg)
++KeyEventBaseImpl::~KeyEventBaseImpl()
+ {
+- m_keyEvent = 0;
+- m_keyVal = keyValArg;
+- m_virtKeyVal = virtKeyValArg;
+- m_inputGenerated = inputGeneratedArg;
+- m_outputString = outputStringArg;
+- m_numPad = numPadArg;
+- m_modifier = 0;
++ delete m_keyEvent;
+ }
+
+-TextEventImpl::~TextEventImpl()
++void KeyEventBaseImpl::initKeyBaseEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ unsigned long keyValArg,
++ unsigned long virtKeyValArg,
++ unsigned long modifiersArg)
+ {
++ m_synthetic = true;
+ delete m_keyEvent;
++ m_keyEvent = 0;
++ initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, 1);
++ m_virtKeyVal = virtKeyValArg;
++ m_keyVal = keyValArg;
++ m_modifier = modifiersArg;
+ }
+
+-bool TextEventImpl::checkModifier(unsigned long modifierArg)
++bool KeyEventBaseImpl::checkModifier(unsigned long modifierArg)
+ {
+ return ((m_modifier & modifierArg) == modifierArg);
+ }
+
+-void TextEventImpl::initTextEvent(const DOMString &typeArg,
+- bool canBubbleArg,
+- bool cancelableArg,
+- const AbstractView &viewArg,
+- long detailArg,
+- const DOMString &outputStringArg,
+- unsigned long keyValArg,
+- unsigned long virtKeyValArg,
+- bool inputGeneratedArg,
+- bool numPadArg)
++void KeyEventBaseImpl::initModifier(unsigned long modifierArg,
++ bool valueArg)
+ {
+- UIEventImpl::initUIEvent(typeArg, canBubbleArg, cancelableArg, viewArg, detailArg);
+-
+- m_outputString = outputStringArg;
+- m_keyVal = keyValArg;
+- m_virtKeyVal = virtKeyValArg;
+- m_inputGenerated = inputGeneratedArg;
+- m_numPad = numPadArg;
+-}
+-
+-void TextEventImpl::initModifier(unsigned long modifierArg,
+- bool valueArg)
+-{
+ if (valueArg)
+ m_modifier |= modifierArg;
+ else
+ m_modifier &= (modifierArg ^ 0xFFFFFFFF);
+ }
+
+-int TextEventImpl::keyCode() const
++void KeyEventBaseImpl::buildQKeyEvent() const
+ {
+- if (!m_keyEvent)
+- return 0;
++ delete m_keyEvent;
+
+- if (m_virtKeyVal != DOM_VK_UNDEFINED) {
+- return m_virtKeyVal;
+- } else {
+- int c = charCode();
+- if (c != 0) {
+- return QChar(c).upper().unicode();
+- } else {
+- c = m_keyEvent->key();
+- if (c == Qt::Key_unknown)
+- kdDebug( 6020 ) << "Unknown key" << endl;
+- return c;
+- }
++ assert(m_synthetic);
++ //IMPORTANT: we ignore Ctrl, Alt, and Meta modifers on purpose.
++ //this is to prevent a website from synthesizing something like Ctrl-V
++ //and stealing contents of the user's clipboard.
++ unsigned modifiers = 0;
++ if (m_modifier & Qt::ShiftButton)
++ modifiers |= Qt::ShiftButton;
++
++ int key = 0;
++ int ascii = 0;
++ QString text;
++ if (m_virtKeyVal)
++ key = virtKeyToQtKey()->toRight(m_virtKeyVal);
++ if (!key) {
++ ascii = m_keyVal; //###?
++ key = m_keyVal;
++ text = QChar(key);
+ }
++
++ //Neuter F keys as well.
++ if (key >= Qt::Key_F1 && key <= Qt::Key_F35)
++ key = Qt::Key_ScrollLock;
++
++ m_keyEvent = new QKeyEvent(id() == KEYUP_EVENT ? QEvent::KeyRelease : QEvent::KeyPress,
++ key, ascii, modifiers, text);
+ }
+
+-int TextEventImpl::charCode() const
++//------------------------------------------------------------------------------
++
++
++static const IDTranslator<QCString, unsigned, const char*>::Info keyIdentifiersToVirtKeysTable[] = {
++ {"Alt", KeyEventBaseImpl::DOM_VK_LEFT_ALT},
++ {"Control", KeyEventBaseImpl::DOM_VK_LEFT_CONTROL},
++ {"Shift", KeyEventBaseImpl::DOM_VK_LEFT_SHIFT},
++ {"Meta", KeyEventBaseImpl::DOM_VK_META},
++ {"\0x08", KeyEventBaseImpl::DOM_VK_SPACE}, //1-char virt!
++ {"CapsLock", KeyEventBaseImpl::DOM_VK_CAPS_LOCK},
++ {"\x7F", KeyEventBaseImpl::DOM_VK_DELETE}, //1-char virt!
++ {"End", KeyEventBaseImpl::DOM_VK_END},
++ {"Enter", KeyEventBaseImpl::DOM_VK_ENTER},
++ {"\x1b", KeyEventBaseImpl::DOM_VK_ESCAPE}, //1-char virt!
++ {"Home", KeyEventBaseImpl::DOM_VK_HOME},
++ {"NumLock", KeyEventBaseImpl::DOM_VK_NUM_LOCK},
++ {"Pause", KeyEventBaseImpl::DOM_VK_PAUSE},
++ {"PrintScreen", KeyEventBaseImpl::DOM_VK_PRINTSCREEN},
++ {"Scroll", KeyEventBaseImpl::DOM_VK_SCROLL_LOCK},
++ {" ", KeyEventBaseImpl::DOM_VK_SPACE}, //1-char virt!
++ {"\t", KeyEventBaseImpl::DOM_VK_TAB}, //1-char virt!
++ {"Left", KeyEventBaseImpl::DOM_VK_LEFT},
++ {"Left", KeyEventBaseImpl::DOM_VK_LEFT},
++ {"Right", KeyEventBaseImpl::DOM_VK_RIGHT},
++ {"Up", KeyEventBaseImpl::DOM_VK_UP},
++ {"Down", KeyEventBaseImpl::DOM_VK_DOWN},
++ {"PageDown", KeyEventBaseImpl::DOM_VK_PAGE_DOWN},
++ {"PageUp", KeyEventBaseImpl::DOM_VK_PAGE_UP},
++ {"F1", KeyEventBaseImpl::DOM_VK_F1},
++ {"F2", KeyEventBaseImpl::DOM_VK_F2},
++ {"F3", KeyEventBaseImpl::DOM_VK_F3},
++ {"F4", KeyEventBaseImpl::DOM_VK_F4},
++ {"F5", KeyEventBaseImpl::DOM_VK_F5},
++ {"F6", KeyEventBaseImpl::DOM_VK_F6},
++ {"F7", KeyEventBaseImpl::DOM_VK_F7},
++ {"F8", KeyEventBaseImpl::DOM_VK_F8},
++ {"F9", KeyEventBaseImpl::DOM_VK_F9},
++ {"F10", KeyEventBaseImpl::DOM_VK_F10},
++ {"F11", KeyEventBaseImpl::DOM_VK_F11},
++ {"F12", KeyEventBaseImpl::DOM_VK_F12},
++ {"F13", KeyEventBaseImpl::DOM_VK_F13},
++ {"F14", KeyEventBaseImpl::DOM_VK_F14},
++ {"F15", KeyEventBaseImpl::DOM_VK_F15},
++ {"F16", KeyEventBaseImpl::DOM_VK_F16},
++ {"F17", KeyEventBaseImpl::DOM_VK_F17},
++ {"F18", KeyEventBaseImpl::DOM_VK_F18},
++ {"F19", KeyEventBaseImpl::DOM_VK_F19},
++ {"F20", KeyEventBaseImpl::DOM_VK_F20},
++ {"F21", KeyEventBaseImpl::DOM_VK_F21},
++ {"F22", KeyEventBaseImpl::DOM_VK_F22},
++ {"F23", KeyEventBaseImpl::DOM_VK_F23},
++ {"F24", KeyEventBaseImpl::DOM_VK_F24},
++ {0, 0}
++};
++
++MAKE_TRANSLATOR(keyIdentifiersToVirtKeys, QCString, unsigned, const char*, keyIdentifiersToVirtKeysTable)
++
++/** These are the modifiers we currently support */
++static const IDTranslator<QCString, unsigned, const char*>::Info keyModifiersToCodeTable[] = {
++ {"Alt", Qt::AltButton},
++ {"Control", Qt::ControlButton},
++ {"Shift", Qt::ShiftButton},
++ {"Meta", Qt::MetaButton},
++ {0, 0}
++};
++
++MAKE_TRANSLATOR(keyModifiersToCode, QCString, unsigned, const char*, keyModifiersToCodeTable)
++
++KeyboardEventImpl::KeyboardEventImpl() : m_keyLocation(DOM_KEY_LOCATION_STANDARD)
++{}
++
++DOMString KeyboardEventImpl::keyIdentifier() const
+ {
+- if (!m_keyEvent)
+- return 0;
++ if (unsigned special = virtKeyVal())
++ if (const char* id = keyIdentifiersToVirtKeys()->toLeft(special))
++ return QString::fromLatin1(id);
+
+- if (m_outputString.length() != 1)
+- return 0;
++ if (unsigned unicode = keyVal())
++ return QString(QChar(unicode));
+
+- return m_outputString[0].unicode();
++ return "Unidentified";
+ }
+
++bool KeyboardEventImpl::getModifierState (const DOMString& keyIdentifierArg) const
++{
++ unsigned mask = keyModifiersToCode()->toRight(keyIdentifierArg.string().latin1());
++ return m_modifier & mask;
++}
+
+-bool TextEventImpl::isTextEvent() const
++bool KeyboardEventImpl::isKeyboardEvent() const
+ {
+ return true;
+ }
+
++void KeyboardEventImpl::initKeyboardEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ const DOMString &keyIdentifierArg,
++ unsigned long keyLocationArg,
++ const DOMString& modifiersList)
++{
++ unsigned keyVal = 0;
++ unsigned virtKeyVal = 0;
++
++ m_keyLocation = keyLocationArg;
++
++ //Figure out the code information from the key identifier.
++ if (keyIdentifierArg.length() == 1) {
++ //Likely to be normal unicode id, unless it's one of the few
++ //special values.
++ unsigned short code = keyIdentifierArg.unicode()[0].unicode();
++ if (code > 0x20 && code != 0x7F)
++ keyVal = code;
++ }
++
++ if (!keyVal) //One of special keys, likely.
++ virtKeyVal = keyIdentifiersToVirtKeys()->toRight(keyIdentifierArg.string().latin1());
++
++ //Process modifier list.
++ QStringList mods =
++ QStringList::split(' ',
++ modifiersList.string().stripWhiteSpace().simplifyWhiteSpace());
++
++ unsigned modifiers = 0;
++ for (QStringList::iterator i = mods.begin(); i != mods.end(); ++i)
++ if (unsigned mask = keyModifiersToCode()->toRight((*i).latin1()))
++ modifiers |= mask;
++
++ initKeyBaseEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
++ keyVal, virtKeyVal, modifiers);
++}
++
++KeyboardEventImpl::KeyboardEventImpl(QKeyEvent* key, DOM::AbstractViewImpl* view) :
++ KeyEventBaseImpl(KEYDOWN_EVENT, true, true, view, key)
++{
++ if (key->type() == QEvent::KeyRelease)
++ m_id = KEYUP_EVENT;
++
++ //Try to put something reasonable in location...
++ //we don't know direction, so guess left
++ m_keyLocation = DOM_KEY_LOCATION_STANDARD;
++ switch (m_virtKeyVal) {
++ case DOM_VK_LEFT_ALT:
++ case DOM_VK_LEFT_SHIFT:
++ case DOM_VK_LEFT_CONTROL:
++ case DOM_VK_META:
++ m_keyLocation = DOM_KEY_LOCATION_LEFT;
++ }
++}
++
++int KeyboardEventImpl::keyCode() const
++{
++ //Keycode on key events always identifies the -key- and not the input,
++ //so e.g. 'a' will get 'A'
++ if (m_virtKeyVal != DOM_VK_UNDEFINED)
++ return m_virtKeyVal;
++ else
++ return QChar((unsigned short)m_keyVal).upper().unicode();
++}
++
++int KeyboardEventImpl::charCode() const
++{
++ //IE doesn't support charCode at all, and mozilla returns 0
++ //on key events. So return 0 here
++ return 0;
++}
++
++
+ // -----------------------------------------------------------------------------
++TextEventImpl::TextEventImpl()
++{}
+
++bool TextEventImpl::isTextInputEvent() const
++{
++ return true;
++}
++
++TextEventImpl::TextEventImpl(QKeyEvent* key, DOM::AbstractViewImpl* view) :
++ KeyEventBaseImpl(KEYPRESS_EVENT, true, true, view, key)
++{
++ m_outputString = key->text();
++}
++
++void TextEventImpl::initTextEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ const DOMString& text)
++{
++ m_outputString = text;
++
++ //See whether we can get a key out of this.
++ unsigned keyCode = 0;
++ if (text.length() == 1)
++ keyCode = text.unicode()[0].unicode();
++ initKeyBaseEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
++ keyCode, 0, 0);
++}
++
++int TextEventImpl::keyCode() const
++{
++ //Mozilla returns 0 here unless this is a non-unicode key.
++ //IE stuffs everything here, and so we try to match it..
++ if (m_keyVal)
++ return m_keyVal;
++ return m_virtKeyVal;
++}
++
++int TextEventImpl::charCode() const
++{
++ //On text events, in Mozilla charCode is 0 for non-unicode keys,
++ //and the unicode key otherwise... IE doesn't support this.
++ if (m_virtKeyVal)
++ return 0;
++ return m_keyVal;
++}
++
++
++// -----------------------------------------------------------------------------
+ MutationEventImpl::MutationEventImpl()
+ {
+ m_relatedNode = 0;
+--- khtml/xml/dom2_eventsimpl.h (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/xml/dom2_eventsimpl.h (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -79,12 +79,11 @@
+ // keyboard events
+ KEYDOWN_EVENT,
+ KEYUP_EVENT,
++ KEYPRESS_EVENT, //Mostly corresponds to DOM3 textInput event.
+ // khtml events (not part of DOM)
+ KHTML_ECMA_DBLCLICK_EVENT, // for html ondblclick
+ KHTML_ECMA_CLICK_EVENT, // for html onclick
+ KHTML_DRAGDROP_EVENT,
+- KHTML_ERROR_EVENT,
+- KEYPRESS_EVENT,
+ KHTML_MOVE_EVENT,
+ // XMLHttpRequest events
+ KHTML_READYSTATECHANGE_EVENT
+@@ -114,7 +113,9 @@
+ virtual bool isUIEvent() const;
+ virtual bool isMouseEvent() const;
+ virtual bool isMutationEvent() const;
+- virtual bool isTextEvent() const;
++ virtual bool isTextInputEvent() const;
++ virtual bool isKeyboardEvent() const;
++ bool isKeyRelatedEvent() const { return isTextInputEvent() || isKeyboardEvent(); }
+
+ bool propagationStopped() const { return m_propagationStopped; }
+ bool defaultPrevented() const { return m_defaultPrevented; }
+@@ -251,24 +252,8 @@
+ };
+
+
+-class TextEventImpl : public UIEventImpl {
++class KeyEventBaseImpl : public UIEventImpl {
+ public:
+- TextEventImpl();
+- TextEventImpl(EventId _id,
+- bool canBubbleArg,
+- bool cancelableArg,
+- AbstractViewImpl *viewArg,
+- unsigned short detailArg,
+- DOMString &outputStringArg,
+- unsigned long keyValArg,
+- unsigned long virtKeyValArg,
+- bool inputGeneratedArg,
+- bool numPadArg);
+-
+- TextEventImpl(QKeyEvent *key, bool keypress, AbstractViewImpl *view);
+-
+- virtual ~TextEventImpl();
+-
+ // VirtualKeyCode
+ enum KeyCodes {
+ DOM_VK_UNDEFINED = 0x0,
+@@ -324,44 +309,134 @@
+ DOM_VK_F24 = 0xF00B
+ };
+
+- void initTextEvent(const DOMString &typeArg,
+- bool canBubbleArg,
+- bool cancelableArg,
+- const AbstractView &viewArg,
+- long detailArg,
+- const DOMString &outputStringArg,
+- unsigned long keyValArg,
+- unsigned long virtKeyValArg,
+- bool inputGeneratedArg,
+- bool numPadArg);
++ void initKeyBaseEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ unsigned long keyVal,
++ unsigned long virtKeyVal,
++ unsigned long modifiers);
++
++ bool ctrlKey() const { return m_modifier & Qt::ControlButton; }
++ bool shiftKey() const { return m_modifier & Qt::ShiftButton; }
++ bool altKey() const { return m_modifier & Qt::AltButton; }
++ bool metaKey() const { return m_modifier & Qt::MetaButton; }
++
++ bool inputGenerated() const { return m_virtKeyVal == 0; }
++ unsigned long keyVal() const { return m_keyVal; }
++ unsigned long virtKeyVal() const { return m_virtKeyVal; }
++
++ QKeyEvent *qKeyEvent() const { if (!m_keyEvent) buildQKeyEvent(); return m_keyEvent; }
++
++ //Legacy key stuff...
++ virtual int keyCode() const = 0;
++ virtual int charCode() const = 0;
++
++ //### KDE4: remove these 2
+ void initModifier(unsigned long modifierArg, bool valueArg);
+-
+ bool checkModifier(unsigned long modifierArg);
+
+- //Attributes:
+- bool inputGenerated() const { return m_inputGenerated; }
+- unsigned long keyVal() const { return m_keyVal; }
+- unsigned long virtKeyVal() const { return m_virtKeyVal; }
+- bool numPad() const { return m_numPad; }
+- DOMString outputString() const { return m_outputString; }
++ ~KeyEventBaseImpl();
++
++ //Returns true if the event was synthesized by client use of DOM
++ bool isSynthetic() const { return m_synthetic; }
++protected:
++ KeyEventBaseImpl(): m_keyEvent(0), m_keyVal(0), m_virtKeyVal(0), m_modifier(0), m_synthetic(false)
++ { m_detail = 0; }
++
++ KeyEventBaseImpl(EventId id,
++ bool canBubbleArg,
++ bool cancelableArg,
++ AbstractViewImpl *viewArg,
++ QKeyEvent *key);
++
++
++ mutable QKeyEvent *m_keyEvent;
++ unsigned long m_keyVal; //Unicode key value
++ unsigned long m_virtKeyVal; //Virtual key value for keys like arrows, Fn, etc.
++
++ // bitfield containing state of modifiers. not part of the dom.
++ unsigned long m_modifier;
++
++ bool m_synthetic;
++
++ void buildQKeyEvent() const; //Construct a Qt key event from m_keyVal/m_virtKeyVal
++};
++
++class TextEventImpl : public KeyEventBaseImpl {
++public:
++ TextEventImpl();
++
++ TextEventImpl(QKeyEvent* key, DOM::AbstractViewImpl* view);
++
++ void initTextEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ const DOMString& text);
++
++ virtual bool isTextInputEvent() const;
++
++ //Legacy key stuff...
+ int keyCode() const;
+ int charCode() const;
+
+- QKeyEvent *qKeyEvent() const { return m_keyEvent; }
++ DOMString data() const { return m_outputString; }
++private:
++ DOMString m_outputString;
++};
+
+- virtual bool isTextEvent() const;
++class KeyboardEventImpl : public KeyEventBaseImpl {
++public:
++ KeyboardEventImpl();
++ KeyboardEventImpl(QKeyEvent* key, DOM::AbstractViewImpl* view);
+
++ virtual bool isKeyboardEvent() const;
++
++ enum KeyLocation {
++ DOM_KEY_LOCATION_STANDARD = 0x00,
++ DOM_KEY_LOCATION_LEFT = 0x01,
++ DOM_KEY_LOCATION_RIGHT = 0x02,
++ DOM_KEY_LOCATION_NUMPAD = 0x03
++ };
++
++ //Legacy key stuff...
++ int keyCode() const;
++ int charCode() const;
++
++ DOMString keyIdentifier() const;
++ unsigned long keyLocation() const { return m_keyLocation; }
++
++ bool getModifierState(const DOMString& keyIdentifierArg) const;
++
++ void initKeyboardEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ const DOMString &keyIdentifierArg,
++ unsigned long keyLocationArg,
++ const DOMString& modifiersList);
++
++ //### KDE4: remove this, it's only for compatibility with
++ //the old TextEvent wrapper
++ void initKeyboardEvent(const DOMString &typeArg,
++ bool canBubbleArg,
++ bool cancelableArg,
++ const AbstractView &viewArg,
++ unsigned long keyVal,
++ unsigned long virtKeyVal,
++ unsigned long modifiers,
++ unsigned long keyLocationArg) {
++ initKeyBaseEvent(typeArg, canBubbleArg, cancelableArg, viewArg,
++ keyVal, virtKeyVal, modifiers);
++ m_keyLocation = keyLocationArg;
++ }
+ private:
+- QKeyEvent *m_keyEvent;
+- unsigned long m_keyVal;
+- unsigned long m_virtKeyVal;
+- DOMString m_outputString;
+- bool m_numPad;
+- bool m_inputGenerated;
+- // bitfield containing state of modifiers. not part of the dom.
+- unsigned long m_modifier;
++ unsigned long m_keyLocation;
+ };
+
++
++
+ class MutationEventImpl : public EventImpl {
+ // ### fire these during parsing (if necessary)
+ public:
+--- khtml/xml/dom_docimpl.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ khtml/xml/dom_docimpl.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -2276,15 +2276,18 @@
+
+ EventImpl *DocumentImpl::createEvent(const DOMString &eventType, int &exceptioncode)
+ {
+- if (eventType == "UIEvents")
++ if (eventType == "UIEvents" || eventType == "UIEvent")
+ return new UIEventImpl();
+- else if (eventType == "MouseEvents")
++ else if (eventType == "MouseEvents" || eventType == "MouseEvent")
+ return new MouseEventImpl();
+- else if (eventType == "TextEvents")
++ else if (eventType == "TextEvent")
+ return new TextEventImpl();
+- else if (eventType == "MutationEvents")
++ else if (eventType == "KeyboardEvent")
++ return new KeyboardEventImpl();
++ else if (eventType == "MutationEvents" || eventType == "MutationEvent")
+ return new MutationEventImpl();
+- else if (eventType == "HTMLEvents" || eventType == "Events")
++ else if (eventType == "HTMLEvents" || eventType == "Events" ||
++ eventType == "HTMLEvent" || eventType == "Event")
+ return new EventImpl();
+ else {
+ exceptioncode = DOMException::NOT_SUPPORTED_ERR;
+--- kdoctools/customization/et/entities/underLGPL.docbook (.../tags/KDE/3.5.1/kdelibs) (revision 0)
++++ kdoctools/customization/et/entities/underLGPL.docbook (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -0,0 +1,3 @@
++<para>Käesolev programm on litsenseeritud vastavalt <ulink
++url="common/lgpl-license.html">GNU Vähem Üldise Avaliku Litsentsi</ulink>
++tingimustele.</para>
+--- kdoctools/customization/et/entities/install-intro.docbook (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdoctools/customization/et/entities/install-intro.docbook (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -1,4 +1,4 @@
+ <!-- requires that packagename is defined in the documentation prologue -->
+ <para>&kappname; on osa &kde; projektist &kde-http;.</para>
+
+-<para>&kappname; asub paketis &package; &kde; projekti peamisel &FTP; saidis &kde-ftp;.</para>
++<para>&kappname; asub paketis &package; &kde; projekti peamises &FTP; saidis &kde-ftp;.</para>
+--- kdoctools/customization/et/lang.entities (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdoctools/customization/et/lang.entities (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -12,6 +12,8 @@
+ <!-- Licence links -->
+ <!ENTITY underGPL PUBLIC "-//KDE//DOCUMENT GPL Licence Declaration//ET"
+ "entities/underGPL.docbook" ><!-- level: para -->
++<!ENTITY underLGPL PUBLIC "-//KDE//DOCUMENT LGPL Licence Declaration//ET"
++ "entities/underLGPL.docbook" ><!-- level: para -->
+ <!ENTITY underFDL PUBLIC "-//KDE//DOCUMENT FDL Licence Declaration//ET"
+ "entities/underFDL.docbook" ><!-- level: para -->
+ <!ENTITY underBSDLicense PUBLIC "-//KDE//DOCUMENT BSD Licence Declaration//ET"
+--- kdeprint/kprintpreview.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdeprint/kprintpreview.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -257,10 +257,11 @@
+ dlg.openFile(file);
+ return dlg.exec();
+ }
+- else
++ else
++ {
+ // do nothing at that point: try to use the other way around by
+ // using an external PS viewer if possible
+- ;
++ }
+ }
+
+ // Either the PS viewer component was not found, or an external
+--- kdeui/kactionclasses.cpp (.../tags/KDE/3.5.1/kdelibs) (revision 502693)
++++ kdeui/kactionclasses.cpp (.../branches/KDE/3.5/kdelibs) (revision 502693)
+@@ -34,6 +34,7 @@
+ #include <qobjectlist.h>
+ #include <qwhatsthis.h>
+ #include <qtimer.h>
++#include <qfile.h>
+
+ #include <dcopclient.h>
+ #include <dcopref.h>
+@@ -1187,6 +1188,11 @@
+ key = QString( "File%1" ).arg( i );
+ value = config->readPathEntry( key );
+ url = KURL::fromPathOrURL( value );
++
++ // Don't restore if file doesn't exist anymore
++ if (url.isLocalFile() && !QFile::exists(url.path()))
++ continue;
++
+ nameKey = QString( "Name%1" ).arg( i );
+ nameValue = config->readPathEntry( nameKey, url.fileName() );
+ title = nameValue + " [" + value + "]";
More information about the pkg-kde-commits
mailing list