This week’s heaviest contributions were Antonio’s directional navigation and Benjamin’s scrolling optimization for pages with fixed positioned elements.

• Antonio landed his work for spatial navigation, making it possible to navigate through links and widgets with the cursor keys. The long list of patches also includes layout test coverage, DRT support and a flag in QWebSettings for toggling the feature (18662).
• Holger fixed a bug where non-animated gifs were animated (35955).
• Robert added support for running caret browsing layout tests in the Qt DRT (35593).
• Chang fixed a bug with parsing CSS colors (22150).
• The network state notifier JS API is now enabled when compiling the trunk against Qt 4.7 (35983).
• Support for accelerated compositing is now enabled by default, when using QGraphicsWebView (35866).
• Benjamin implemented an optimization to avoid full frame renderings when scrolling pages with fixed positioned elements. If there are only a few of these elements present, then most of the pixels are still blitted (33150).
• Jesus added a fullscreen mode to QtLauncher (35755).
• Zoltan continues to spread the use of FastMallocBase to increase the coverage of custom allocators (35857, 35855).
• Jedrzej fixed two QtScript issues (35577, 35577).
• Diego fixed a bunch of failing layout tests with access key modifiers (35993).
• Props to Chang and the Szeged developers for keeping up with layout test updates

Note that I’m only listing changes here that actually landed in the trunk. There’s quite a bit more work going on behind the scenes and in bugzilla.

All these changes are also included in this week’s experimental build, for Linux, Mac, Windows, Symbian and Maemo5.

Several of the Trolls are right now in Manaus (Brasil) at the Bossa Conference 2010 and we’re having a great time. The conference is hosted by INDt here in Brasil, and the topics covering Qt directly are:

• QML
• QtWebkit
• Next generation widgets, and
• Shipping Qt apps on Symbian

but there are also talks about KDE, Ubuntu, Maemo etc.

In my talk I’m explaining how to go from nothing to having your own Qt app on the Ovi Store. So for that purpose I created a little app wich is a “mobilized” touch version of our old Tetrix example. See image below. It’s not fantastic in any way, but I thought it might be interesting for some to install it on their phone and try it out.

There are two ways of getting this app on your phone: Method 1: (recommended) Install Qt 4.6.2 (Symbian) Install BossaTetrix (normal version) Method 2: (experimental) Install BossaTetrix (Smart Installer version) Note: Version 2 is not stable and I’ve had limited success with it. The Nokia Smart Installer is still in beta! - so if you just want something that works, go for Method 1.

My current highscore is Score: 529 Level: 2. Post your score as a comment

Oh and btw, my app is not in the OVI store yet- As I said, the Nokia Smart Installer is still in beta and the OVI site still needs some changes before Qt apps can be uploaded, but we’re one step closer, and I now basically know the whole complete process involved.

Twitter feed about the conference here.

It’s been a more quiet week. Here are the highlights:

• Robert implemented support for private browsing in PluginViewQt (33180).
• Jedrzej continued upstreaming QtScript API and bug fixing in it (34843, 34850, 35387).
• Andreas hooked up QNetworkReplyHandler to Qt 4.7’s support for the HTTP OPTION verb (34647).
• Jarkko, Nicholas, Kim and Noam fixed various bugs in the MediaElement backend, the accelerated compositing support and WebGL to Qt mapping.
• Diego continued improving layout test coverave with the Qt DRT (35694, 35255).
• Holger tweaked performance by avoiding unnecessary calls to QFont::detach (35569).
• Jocelyn and Tor Arne fixes various issues with the build system (forwarding headers, shadow builds without build-webkit but only qmake)

In addtion we have now a weekly build and we’ve started another round of API review.

QtWebKit is a part of Qt and we’ve always released them together. With a rapidly growing development community we’d like to decouple QtWebKit from Qt’s releases. It is a project on its own, it’s developed as part of the WebKit project and therefore deserves its own release. We’re going to call the first standalone release simply QtWebKit 2.0.

What does a standalone release mean?

We want to make QtWebKit release available to anyone using Qt, as a source package to install into your existing Qt installation. QtWebKit 2.0 is going to work with Qt 4.6 and 4.7. We will continue to ship QtWebKit in the src/3rdparty/webkit directory in Qt releases, too. It will simply contain the latest stable release. Inside of Qt this will be covered by commercial support.

In the near future we are going to create the release branch and aim for a final 2.0 release in May. I’m going to post future updates about the releasing and branching to our development mailing list webkit-qt@lists.webkit.org.

Looots of things happened while I was on vacation :). Among other things a new backend for audio/video elements using the Qt Multimedia framework and initial work on WebGL support.

• Antti implemented a QGraphicsWebView::resizesToContents property (34885).
• Robert added Web Inspector support to the Qt DRT, adding another 27 more tests (33096).
• Jedrzej fixed QScriptValue::toIntXXX methods (34847).
• Noam implemented support for passing QWebElement objects though JavaScript (34901) and fixed a Canvas clipping bug in GraphicsContextQt (r32405).
• Ariya implemented QWebFrame::scrollToAnchor (29856).
• Yael fixed a bug with SVGs not being rendered when used as background-image from a data URI (33630).
• Noam fixed support for perspective and 3D transforms with the Qt implementation of GraphicsLayer (34960).
• Diego fixed Qt DRT issues (35131, 34955).
• Andras added support for text zooming to Qt DRT’s EventSender (35159).
• Nicholas implemented a new backend for Video and Audio elements based on the Qt Multimedia Framework (34631).
• Afterwards Noam connected this new backend to the Qt GraphicsLayer implementation, to allow the QGraphicsVideoItem of the MediaControl to become part of the GraphicsLayer’s scene (35276).
• Laszlo made the Qt DRT compile on Symbian (31589).
• Jesus removed QGVLauncher from the tree. It’s all been merged now into WebKitTools/QtLauncher (35292).
• Jarkko landed a first version of WebGL support for the Qt build (35153).
• Jocelyn and Lars created a script that allows a build of the combined WebKit sources on Symbian, allowing us to work around bugs in the toolchain and finally create debug builds for arm with rvct (https://lists.webkit.org/pipermail/webkit-qt/2010-February/000149.html).

This week’s highlights include bugfixes, performance improvements and much improved layout test coverage

• Noam fixed bugs with the GraphicsLayerQt implementation used for accelerated compositing during animations (34681, 34761).
• Yael implemented support for window.showModalDialog (25585, 34755).
• Jedrzej continued on improving and completing QScriptValue (34575, 34592, 34749, 34793).
• Diego implemented pageNumberForElementById() in the Qt DRT, which makes us pass 10 more layout tests (34777)!
• Ariya (welcome back on webkit hacking!) implemented a mapping from image interpolation quality to QPixmap transform types 34629). Sometimes WebKit can determine that a faster but lower quality scaling algorithm may be used for drawing images, and that’s now passed down to QPainter.
• Afterwards he continued on speeding up clipping operatings by using a faster method with QPainter to determine the combined clip region (32375). Also we use a few less cycles in constructing QBrush objects by re-using an existing object when setting the stroke color (34874).
• On Friday Diego implemented LayoutTestController::dumpFrameLoadCallbacks() in the Qt Drt, adding another 9 more new passing tests (34702).
• Chang re-enabled support for the app cache in the Qt DRT, adding 33 more passing tests out of 43 (34713).
• In QtLauncher it’s now possible to toggle the use of QGraphicsView as well as accelerated compositing via the menu at run-time (34844, r54654).
• Janne found a workaround for a bug with isNan on Symbian (34170).

Hello!

I’m late this week, sorry

• Diego continued implementing missing Qt DRT functionality (34418).
• Andreas fixed the themeing code to always use the windows style on Maemo 5 (34376).
• Noam added an FPS counter to QGVLauncher (34450).
• Andreas fixed a bug with escaping HTML tags with JavaScript alerts/notifications (34429).
• Noam continued optimizing QGraphicsLayerQt for smoother animations (34062).
• Ossy fixed support for pixel tests in the Qt DRT (27813).
• Jedrzej continued the QtScript implementation (34533).
• Ariya improved painting performance by eliminating unnecessary calls to the QBrush constructor (34559).
• Tor Arne used his mighty qmake skillz to generate convenience classname include header files during the build.
• Kenneth implemented frame set flattening with nice layout test coverage (32717). That’s a feature that helps with small screen web browsing, where scrollbars from frames get into the way most of the time.
• Kenneth also merged the QGraphicsView based QGVLauncher into WebKitTools/QtLauncher. You can run the launcher with “-graphicsbased” for it to use QGraphicsWebView.

P.S.: From the feedback I’m getting, I have the impression that some people find these summaries useful to get an idea of what’s going on in WebKit development. That’s my goal, improving visibility. If you have suggestions for a better location, i.e. me not using this web log to post a digest of a change log, please don’t hesitate to make suggestions :). If the majority of readers prefer these summaries via one of the existing mailing lists or a wiki page, then let me know.

Like for the other parts of Qt, having great performance is important for QtWebKit.

Traditionally, QtWebKit has been mostly used on desktop computers for advanced layouting, hybrid applications or simply to browse the web. On a modern computer, the speed of WebKit is not a problem.

The world has changed, and QtWebKit is now used on mobile phones running Maemo, Symbian or Windows CE, and it is more and more used in embedded application on various devices.

Working on what matters

To improve the performance of WebKit, we works with benchmarks. Those benchmarks are used as use cases when profiling WebKit and to evaluate the gain of our patches.

Those benchmarks and the tools are available on Gitorious, in the QtWebkit performance repository.

WebKit gives a lot of possibilities, and we try to focus our work on what matters. For the performance work, we use real webpages, and look for ways to improve WebKit in the way it is used on the Web.

How we benchmark WebKit

The performance suite has three kinds of tools:

• host tools: to manage the data used by the benchmarks
• tests: the benchmarks
• reductions: some benchmarks for specific components of WebKit

Let’s have a look at the tools and the tests. The full documentation of the performance suite is on the WebKit’s wiki.

Mirroring the web

For the benchmark, we do not want to access Internet directly. We want to compare the results from one run to the other, so we don’t want the pages to change arbitrarily. Using the Web for benchmarking would also create an important load on the servers.

To use real pages without going online, we create databases of web pages with the mirror application:

Those databases are snapshots of webpages at a given point in time, and they are used as input of the benchmarks.

The mirror application uses WebKit to load the pages and intercept all network requests. This means the database also includes resources that are loaded lazily via Javascript.

Using the benchmarks

There are two ways to exploit the databases with the benchmark: the online and offline modes. The difference lies in the way we provide the database’s content to the benchmarks:

In the “online mode“, we use a basic web server to serve the database over HTTP. The benchmarks use the complete stack to load pages, as they would if we were loading the page from Internet.

In the “offline mode“, the database is loaded directly by the benchmarks and is used as the source of data. In that case, the network is not involved. This mode is mostly useful for the benchmarks that do not involve the network (like measuring the rendering speed).

What is measured

The benchmark suite is still a work in progress. Currently, there are benchmarks for:

• the page loading performance (with or without rendering)
• the rendering performance
• the scrolling performance

How you can use that?

If you use WebKit, and are interested in great performance, you can use the performance suite to profile the use case you are interested in, and optimize those cases.

If you evaluate the use of WebKit for embedded, you can use the benchmark to evaluate how good WebKit performs on the hardware.

If you make patches for WebKit’s performance, have a look on how to contribute. You can also join us on IRC in #qtwebkit on freenode.

Hi!

Here’s the weekly summary of Qt related changes to WebKit trunk. Big changes include Yael’s patch for WebSockets support, the beginnings of QtScript on top of JavaScriptCore’s C API, Maemo 5 tweaks and layout test fixes:

• Janne added the necessary meta-data to make QtWebKit play nicely with Symbian backups (34077).
• I did some code cleanups in RenderThemeQt and fixed a bug with combo boxes not showing up in Maemo5 (34088).
• Holger fixed a regression in the JavaScript prompt handling (30914).
• Jedrzej landed the first files for building QtScript on top of JavaScriptCore’s C API (32565).
• Diego added history support to the Qt DRT, we now pass the http/tests/history layout tests! (34167)
• Daniel fixed a bug with the height of button elements (29564).
• Kent fixed support for ES5 style introspection with QMetaObject methods (34087).
• Yael implemented the Qt part of WebSocket support, we now pass websocket/tests in the layout tests (34180).
• Diego fixed more worker layout tests by adding support for counting worker threads in the Qt DRT (34221).
• Holger found a neat way to speed up the conversion from KURL to QUrl (33873).
• Trond fixed an endless loop in QWebPage printing (r53997).
• Kenneth fixed incorrect fonts on comboboxes on Maemo5 and Symbian (r53999).
• Andreas upstreamed Ralf and Robert’s kinetic scrolling support for QWebView using QAbstractKineticScroller (34267).
• Benjamin implemented support for the display() method in the Qt DRT (34258).
• Oswald speed up the conversion between WebCore::String and QString by avoiding QString::fromUtf16() (r54060).
• Kenneth landed a patch to disable auto-uppercasing and text prediction for password input fields (r54064).
• Kenneth also continued to clean up the QtLauncher for a future merge with QGVLauncher
• Andreas and Kenneth submitted tweaks to the look’n'feel of QtLauncher on Maemo5.

This week has been a very busy week! Here’s a list of the landed changes that affect the Qt port, in chronological order:

• Tor Arne has ported the Qt build of DumpRenderTree to run on Windows. (r53526, r53543).
• Luiz continued with cleaning up the combobox popup handling.(33418).
• Ben from the Google Team fixed a bug where touch events weren’t sent to iframes (33894).
• No’am landed support in the Qt bindings that allows passing pixmaps and images as arguments in signals/slots/properties, which can then easily be turned into image elements or data urls. (32461).
• Benjamin cleaned up the QWebPage autotest (32216).
• On Thursday we landed No’am’s implementation of GraphicsLayer. This accelerates the composition of layers with animated opacity or transform attributes, through content caching in pixmaps. Layers are mapped to QGraphicsItems with enabled CacheMode and the animation is driven by the Qt Animation Framework.The feature is disabled by default currently as it’s not stable yet, but it’s a fantastic start! (33514).
• Diego continued implementing missing functions in the Qt DRT (33945).
• Jakub fixed a crash with video elements and phonon (33842).
• Girish fixed a bug with combobox popups in transformed QGraphicsWebViews (r53703, 33887).
• Robert fixed 5 layout tests by fixing support for window.close() and window.closed() in the Qt DRT (32953).
• Kent fixed bugs with Object.getOwnPropertyDescriptor (33948, 33946).