import this

If you are curious and don’t have a python shell near to you: Python PEP-20/

There is no need to install any plugins (no Flash, no 3rd party Javascript needed) and it’s completely asynchronous (it does not slow down your page in any condition).

Please test it (either on usersnap.com or directly here in the lower right corner) and feel free to request a free private beta account!

The HP 1810G-24 switch does not support Counter64-types for octet counters. This post introduces a middleware to fetch the Counter32-types fast enough to build a software Counter64 object to display the correct bandwidth in a munin graph.

The OIDs we need for this are defined in the IF-MIB (I really like the Cisco SNMP Object Navigator for quick OID <=> Name conversion):

IF-MIB::ifInOctets.1 (1.3.6.1.2.1.2.2.1.10.1)
and
IF-MIB::ifOutOctets.1 (1.3.6.1.2.1.2.2.1.16.1)

Unfortunately, this values are of the SNMP type Counter32, that means they overflow every 4GB (or, at full gigabit load, approximately every 34 seconds). Fortunately, there are OIDs in a Counter64 variant:

IF-MIB::ifHCInOctets.1 (1.3.6.1.2.1.31.1.1.1.6.1)
and
IF-MIB::ifHCOutOctets.1 (1.3.6.1.2.1.31.1.1.1.10.1)

Like stated before, the HP1810G-24 (even with the newest firmware P2.2) does not support Counter64 objects.

However, our munin graphing fetches the values every 5 minutes (that means, only one overflow is allowed in this time period – just below 8 GB traffic in 5 minutes, otherwise aliasing occurs).

To support the full bandwith, we have to fetch the values at least every 34/2 = 17 seconds (according to the Nyquist-Shannon sampling theorem) and detect overflows ourselves. An overflow occurs, if the last value was larger than the current value, because packet counters are usually monotonic functions.

That means: No overflow – just add the difference from the current value to the last value to the counter. Overflow – add the maximum number, decreased by the difference of the last value and the current value.

This script “switch_getcounters.py” fetches the SNMP values every 10 seconds and accumulates the counters in an external csv file. This csv file will be used instead of real SNMP GETs in the munin plugin.

#!/usr/bin/python

from pysnmp.entity.rfc3413.oneliner import cmdgen

import csv, time

name = 'hpswitch'
community = 'public'

SLEEPTIME=10
FILENAME="/tmp/switching.csv"
PORTCOUNT=24

portstatus = []
try:
    infile = file(FILENAME, "rb")
    csvread = csv.reader(infile)
    for row in csvread:
        portstatus.append({"cur_in": int(row[1]),
                            "cur_out": int(row[2]),
                            "last_in": int(row[3]),
                            "last_out": int(row[4]) })
    infile.close()
    if len(portstatus) < PORTCOUNT:
        for i in range(PORTCOUNT-len(portstatus)):
            portstatus.append({"cur_in": 0, "cur_out": 0,
                                "last_in": 0, "last_out": 0 })
except:
    portstatus = []
    for i in range(PORTCOUNT):
        portstatus.append({"cur_in": 0, "cur_out": 0,
                            "last_in": 0, "last_out": 0 })

def getBulk(host, community, oid):
    oid = tuple(map(int, oid.strip('.').split('.')))
    errorIndication, errorStatus, \
    errorIndex, varBindTable = cmdgen.CommandGenerator().bulkCmd(
        cmdgen.CommunityData('hpswitch', 'public'),
        cmdgen.UdpTransportTarget(('hpswitch', 161)),
        0, PORTCOUNT,
        oid
        )
    data = []
    if errorIndication:
        print errorIndication
    else:
        if errorStatus:
            print '%s at %s\n' % (
                errorStatus.prettyPrint(),
                errorIndex and varBinds[int(errorIndex)-1] or '?'
                )
        else:
            for varBindTableRow in varBindTable:

                for name, val in varBindTableRow:
                    data.append(int(val))
    return data

outfile = file(FILENAME, "wb")

csvwrite = csv.writer(outfile)
INT_MAX = 4294967295L

while True:
    start = time.time()
    inOct = getBulk(name, community, "1.3.6.1.2.1.2.2.1.10")[:PORTCOUNT]
    outOct = getBulk(name, community, "1.3.6.1.2.1.2.2.1.16")[:PORTCOUNT]
    outfile.seek(0)

    for i in range(len(inOct)):

        if portstatus[i]["last_in"] > inOct[i]:
            #overflow
            #print "overflow in at %s from %s to %s" % (i, portstatus[i]["last_in"], inOct[i])
            portstatus[i]["cur_in"] += INT_MAX - (portstatus[i]["last_in"] - inOct[i])
        else:
            portstatus[i]["cur_in"] += inOct[i] - portstatus[i]["last_in"]

        if portstatus[i]["last_out"] > outOct[i]:
            #overflow
            #print "overflow out at %s from %s to %s" % (i, portstatus[i]["last_out"], outOct[i])
            portstatus[i]["cur_out"] += INT_MAX - (portstatus[i]["last_out"] - outOct[i])
        else:
            portstatus[i]["cur_out"] += outOct[i] - portstatus[i]["last_out"]

        portstatus[i]["last_in"] = inOct[i]
        portstatus[i]["last_out"] = outOct[i]

        csvwrite.writerow([i+1, portstatus[i]["cur_in"],
                                portstatus[i]["cur_out"],
                                portstatus[i]["last_in"],
                                portstatus[i]["last_out"] ])

    outfile.flush()
    stop = time.time()
    sleep = SLEEPTIME - (stop-start)
    if sleep > 0:
        time.sleep(sleep)

outfile.close()

The resulting csv file can be used for every graphing tool you can imagine. The new counters last at least 5 minutes .
For the full munin-example, I just re-used the Perl snmp__if_ plugin for autoconfiguration, but replaced the value-code with an external call to “readsnmp” which converts the snmp value into the munin format.

snmp__if_ (remove the prints for recv. and send.):

print `/usr/share/munin/plugins/readsnmp $iface`

readsnmp

#!/usr/bin/python
import csv, sys

FILENAME="/tmp/switching.csv"
try:
    infile = file(FILENAME, "rb")
    csvread = csv.reader(infile)
except:
    print "recv.value U"
    print "send.value U"
    sys.exit(1)

#munin_args = sys.argv[0].split("_")
iface = 1
try:
    if len(sys.argv) > 1:
        iface = int(sys.argv[1])
except:
    pass

i=0
out = False
for row in csvread:
    i+=1
    if i != iface:
        continue

    out = True
    print "recv.value %s" % row[1]
    print "send.value %s" % row[2]

if not out:
    print "recv.value U"
    print "send.value U"

Our nice new munin chart:

Correct bandwidth display

Please note – if you have a switch with proper Counter64-support, just forget this workaround.
Hope this helps for other HP1810G users,
Gregor

In general a benchmark works as follows: The program gets the start time and iterates a problem for a fixed (or dynamic sized) count. After the iterations, the end time is used to calculate the computations per second:
#of calculations / (end – start).

I started to evaluate VM solutions by using a very high level benchmark – the V8 JavaScript benchmark, because we want to use the virtual machines for automated client side testing, and therefore JavaScript performance matters. Those benchmarks are a little less synthetic than “SpecINT” ones, but still can be used just for comparison.

Just for reference, my current workstation with an Intel(R) Core(TM)2 Duo CPU E8400 @ 3.00GHz and Chrome 13.0.782.112:

Ubuntu 10.04 / C2D 3GHz / Chrome 13

In the next step I checked the performance of KVM (on Proxmox VE 1.8 with Kernel 2.6.35):

WinXP / i7-2600k 3.7GHz / Chrome 13

Ok, the processor is somewhat newer, therefore the virtualized value is higher than my native. Let’s compare it to VirtualBox (I use it for Desktops):

WinXp / C2D 3GHz / Chrome 13

Whoops? I could imagine ways how virtualized environments are faster than natives (because of IO and command reordering), but that’s nearly unbelievable. Another machine showed the same behavior:

WinXP / Xeon 2.83 GHz / Chrome 13

But wait. Remember the first paragraph of my blog post? Time is relative. If the local time inside the VM is wrong relative to other observed time stamps, the whole benchmark result is void.

We need an external time source to verify this assumption. This small python script checks the local time (in a very naive way) against a NTP server, please install “ntplib” first (easy_install ntplib).

import ntplib
import time
c = ntplib.NTPClient()

RUNS = 5

for SLEEPTIME in xrange(1, 6):
    for i in xrange(RUNS):
        print "Checking sleeptime %s (run %i/%i)" % (SLEEPTIME, i+1, RUNS)
        start_r = c.request('europe.pool.ntp.org', version=3).tx_time
        start_l = time.time()
        time.sleep(SLEEPTIME)
        end_l = time.time()
        end_r = c.request('europe.pool.ntp.org', version=3).tx_time

        diff_l = ((end_l - start_l) - SLEEPTIME)*1000
        diff_r = ((end_r - start_r) - SLEEPTIME)*1000

        print "Diff local: \t\t%20.4f ms\nDiff remote: \t\t%20.4f ms" % (diff_l, diff_r)

The script fetches the remote time, the local time, waits some delay, gets the local time ant the remote time again. The difference from the sleeping time is the timing jitter (on WinXP inside VirtualBox 3.2.12 r68302 on a Ubuntu Host):

C:\Python27>python time_check.py
Checking sleeptime 1 (run 1/5)
Diff local:                         211.9999 ms
Diff remote:                         78.0435 ms
Checking sleeptime 1 (run 2/5)
Diff local:                         326.0000 ms
Diff remote:                         72.0148 ms
Checking sleeptime 1 (run 3/5)
Diff local:                         332.9999 ms
Diff remote:                         88.6126 ms
Checking sleeptime 1 (run 4/5)
Diff local:                         332.0000 ms
Diff remote:                        131.6137 ms
Checking sleeptime 1 (run 5/5)
Diff local:                         332.9999 ms
Diff remote:                        136.8995 ms
Checking sleeptime 2 (run 1/5)
Diff local:                         666.0001 ms
Diff remote:                        121.3775 ms
Checking sleeptime 2 (run 2/5)
Diff local:                         665.0002 ms
Diff remote:                         93.9560 ms
Checking sleeptime 2 (run 3/5)
Diff local:                         758.9998 ms
Diff remote:                        180.7289 ms
Checking sleeptime 2 (run 4/5)
Diff local:                         932.9998 ms
Diff remote:                         79.1984 ms
Checking sleeptime 2 (run 5/5)
Diff local:                         931.9999 ms
Diff remote:                         94.8648 ms
Checking sleeptime 3 (run 1/5)
Diff local:                        1399.0002 ms
Diff remote:                        112.0291 ms
Checking sleeptime 3 (run 2/5)
Diff local:                        1440.0001 ms
Diff remote:                        160.9039 ms
Checking sleeptime 3 (run 3/5)
Diff local:                        1507.0000 ms
Diff remote:                        111.6266 ms
Checking sleeptime 3 (run 4/5)
Diff local:                        1507.0000 ms
Diff remote:                        129.6673 ms
Checking sleeptime 3 (run 5/5)
Diff local:                        1506.0000 ms
Diff remote:                         91.3072 ms
Checking sleeptime 4 (run 1/5)
Diff local:                        2009.0001 ms
Diff remote:                        144.1569 ms
Checking sleeptime 4 (run 2/5)
Diff local:                        2009.0001 ms
Diff remote:                        129.6859 ms
Checking sleeptime 4 (run 3/5)
Diff local:                        2009.0001 ms
Diff remote:                        112.1640 ms
Checking sleeptime 4 (run 4/5)
Diff local:                        2008.0001 ms
Diff remote:                        134.4972 ms
Checking sleeptime 4 (run 5/5)
Diff local:                        2007.9999 ms
Diff remote:                        115.3836 ms
Checking sleeptime 5 (run 1/5)
Diff local:                        2511.0002 ms
Diff remote:                        179.2526 ms
Checking sleeptime 5 (run 2/5)
Diff local:                        2510.9999 ms
Diff remote:                        136.1961 ms
Checking sleeptime 5 (run 3/5)
Diff local:                        2510.9999 ms
Diff remote:                        206.5678 ms
Checking sleeptime 5 (run 4/5)
Diff local:                        2510.9999 ms
Diff remote:                        155.1700 ms
Checking sleeptime 5 (run 5/5)
Diff local:                        2511.0002 ms
Diff remote:                        360.1360 ms

On some runs (for example after a clean reboot) the local time diffs are in the order of milliseconds (you will notice this order on native machines, too) – the time jitter is dependent on the overall machine load.

I know the time sync is a hard problem for virtualization layers (See the VMWare-Whitepaper on Timekeeping) because most classic schedulers (read: all which are not tickless) use timer interrupts, which are somewhat artificial on virtualized environments. Because of this, external clock synchronization with the host system is needed – you should really disable NTP inside the client, because the external sync is a hard reset of clocks, while NTP tries to adjust the ticking speed (for more information, continue reading this excellent thread on stack overflow: Resolve drifting time inside VMWare).

At least I know that reliable benchmarking inside an VM is not easy. But for the next benchmarking, I should find another reference than time (for example space or external timing sources).

Regards,
Gregor

Recently we realized, there’s a single issue we can’t get warned by e-mail: The breaking of the interwebs in our office (i.e. our main router crashes or someone accidentally unplugs the red cable)

That’s why we decided be notified via text message in such a situation. Thomas Steiner, our summer intern wrote a nice script and a neat web-service which we now use to warn ourself if our office is loosing the internet connection.

We had a HUAWEI E156G mobile internet stick which is capable to send text messages.
Here’s how to detect if the stick is recognized:

dmesg | grep tty
# should yield something like:
option1 ttyUSB1: GSM modem (1-port) converter now attached to ttyUSB1

We used minicom to talk to the modem and to check, if it does what we want (you might have to set up the correct port were your modem is connected in .minirc.dlf

minicom -o
gedit .minirc.dlf

Most modems “speak” AT commands, the following links were quite useful:

http://www.developershome.com/sms/smsIntro.asp
http://nobbi.com/atgsm.html
http://www.shapeshifter.se/2008/04/30/list-of-at-commands/

Here’s the main python-snippet to send text messages:

import serial
from curses import ascii

connection = '/dev/ttyUSB0'                    # port
pin = '1234'                                   # pin

def sendSMS(message, telephoneNumber):
    """Send a SMS"""
    ser = serial.Serial(connection, 9600, timeout=5)  # open port

    ser.write('AT+CPIN="%s"\r\n' %pin)                # PIN-Code
    ser.write('AT+CMGF=1\r\n')                        # to TEXTMODE

    ser.write('AT+CMGS="%s"\r\n' %telephoneNumber)    # tel number
    ser.write(message)                                # message
    ser.write(ascii.ctrl('z'))                        # end session

sendSMS('Fire - exclamation mark - fire - exclamation mark - \
         help me - exclamation mark. 123 Cavendon Road. Looking \
         forward to hearing from you. Yours truly, Maurice Moss.',
         '+4312345678')

Since we don’t have any python on our routers, we packed this little script into a neat web-service which can now be called like:

curl http://textmachina:5555/txtmsg/send/+431234567/Message

We put this line in a nice shell script (including the necessary urlencoding for the message). This is quite handy, especially in busybox-situations.

Kudos goes to Thomas Steiner!

Prerequisites

Just install the following standard Ubuntu packages which are needed to install the 3rd party libraries:

apt-get install g++ python monodevelop libusb-1.0.0-dev \
freeglut3-dev xdotool

You can install OpenNI, Sensor Kinect and NITE by downloading them:

1. http://www.openni.org/downloadfiles/opennimodules/openni-binaries/latest-unstable/161-openni-unstable-build-for-ubuntu-10-10-x64-64-bit-v1-3-2/download
2. https://github.com/avin2/SensorKinect
3. http://www.openni.org/downloadfiles/opennimodules/openni-compliant-middleware-binaries/latest-unstable/175-primesense-nite-unstable-build-for-ubuntu-10-10-x64-64-bit-v1-4-1

In every extracted directory, just run

sudo ./install.sh

When installing NITE, you are asked by a key (you can use 0KOIk2JeIBYClPWVnMoRKn5cdY4= for evaluation purposes as written on the SensorKinect github page).

You can check your installation afterwards by starting NiViewer (located in OpenNI/Samples/Bin/Release). This will show you a depth and a color image captured from the Kinect:

One interesting demo application is the hand detection from the NITE toolkit. Without calibrating your skeleton, your hand can be tracked just by waving it a few times:

According to the NITE API such easy trackings can be written in little code. Just make sure to enable the context manager on the events “Wave” and “RaiseHand”:

XnStatus rc = XN_STATUS_OK;
// Create and initialize point tracker
g_pSessionManager = new XnVSessionManager;
rc = g_pSessionManager->Initialize(&g_Context, "Wave",
                                      "RaiseHand");
if (rc != XN_STATUS_OK)
{
    printf("Couldn't init the Session Manager: %s\n",
        xnGetStatusString(rc));
    delete g_pSessionManager;
    return rc;
}

To use your hand as input device, just instantiate a XnVSelectableSlider2D (you could also use XnVSelectableSlider1D, but then you are limited to horizontal or vertical movements).

g_pMainSliderXY = new XnVSelectableSlider2D(1,1);
g_pMainSliderXY->RegisterValueChange(NULL,
    &MainSliderXY_OnValueChange);
g_pMainSliderXY->RegisterItemSelect(NULL,
    &MainSliderXY_OnSelect);
g_pMainSliderXY->RegisterActivate(NULL,
    &MainSliderXY_OnActivate);
g_pMainSliderXY->RegisterDeactivate(NULL,
    &MainSliderXY_OnDeactivate);
g_pMainSliderXY->RegisterPrimaryPointCreate(NULL,
    &MainSliderXY_OnPrimaryCreate);
g_pMainSliderXY->RegisterPrimaryPointDestroy(NULL,
    &MainSliderXY_OnPrimaryDestroy);

Inside the MainSliderXY_OnValueChange callback you can add your gesture detection, as you get the x/y value of your tracked hand.

void XN_CALLBACK_TYPE MainSliderXY_OnValueChange(
    XnFloat fxValue, XnFloat fyValue, void* cxt)

When you have detected a gesture (for example: xValue is at least some time at value 0 or similar) you can send commands to any X11-Window you can imagine.
One small example sends a keystroke to a web browser (written in a small python wrapper script) – just make sure that the window is focused before you send a keystroke, as xdotool just generates raw Xevent keypresses.

import subprocess

BROWSER = "firefox"

def focus():
    p = subprocess.Popen(["xdotool", "search", "--name",
                    BROWSER],
        shell=False,stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        stdin=subprocess.PIPE)
    p.wait()
    out = p.stdout.read()
    idwin =	out.split("\n")[0]
    subprocess.call(["xdotool", "windowactivate",
            "%s" % idwin])

def send_command(command):
    print "sending command %s " %command
    subprocess.call(["xdotool", "key", "%s" % command ])

The Kinect is a great tool to develop natural interaction devices. I hope this low-level article clarifies the basics of using the SensorKinect library.

If you want to have a full working example, don’t hesitate to ask by email!

Hope this helps,
Gregor

http://secure.lenos.com/lenos/sencha/SenchaCon2011/agenda.htm

On my development machine nodeJS is already installed. Have a look at the NodeJS installation guide, if you want to install it yourself. Now you can write executable programs in JavaScript based on Google’s V8 engine.

I downloaded a SAX XML parser library for NodeJS (written by isaacs). It’s very easy to include it into my workspace, just add a single line to include “sax.js”. The second component I need is the file system component to read the content of the XML file.

var fs = require('fs');
var sax = require('./sax');

First thing you have to do is creating a new instance of the parser.

parser = sax.parser(strict);

The parser itself is working event driven, like almost everything in NodeJS. When you are using an event driven XML parser it’s very useful to use a state-diagram – then it’s easier to grasp which type of node you are currently visiting.

Now there are some predefined hooks which you can use to listen for events like, open tag, close tag, etc…

parser.ontext = function(t) {
   console.log('This is the text in that node: ' + t);
};

parser.onopentag = function(node) {
   //on new tag opened
};

At the end the only thing you have to do is to launch the parser process. Just read the contents of the file into a String buffer (called file_buf) and then put it to the parser library.

try {
    var file_buf = fs.readFileSync('./demistified.xml');
    parser.write(file_buf.toString('utf8')).close();
} catch(ex) {
    // keep 'em silent
}

In the event hooks you can start to build your own data structure, NodeJS is built to parse and hold a lot of complex data. In my use case I had a file with about 20MB of XML data and I extracted out of this huge amount of data, 180 data nodes within 2 seconds.

At the end if you need your internal data structure (mostly you will use array and object combinations) saved to a file you can easily use the command:

fs.writeFileSync('test.json', JSON.stringify(DataNodeSpace));

This writes the array DataNodeSpace in JSON format to the file test.json.

To modify, traverse, add properties to an array or a object in JavaScript or more in NodeJS it is very fast and easy. I was totally amazed how fast you can build a XML parser (10 lines of code) and after the (more or less complex *g*) parsing algorithm run you can transform the data elements very easy and comfortable.

I hope now you have a little overview how to parse XML files in NodeJS.

Stay tuned, in the future I will have some cool stories for you dealing with NodeJS and the cooooolest database mongoDB.

Josef

Green-IT

The decrease in demand of our family’s cider products led to the idea to produce CO2-neutral energy by using cider bio gas (CBG) technology.

Dr. Florian Dorfbauer, CEO La Gentz

Our family's apple garden

In the last year, we have planned out new biogas CHP plant with an average power of 23 Megawatt. The remainder (our data center just needs about 14 MW for today) is sold to electric distributors. We can now say, our data center is absolutely CO2-neutral.

Some photographs of our new plant (which started operating this week):

Our new 23 MW biogas plant

This gas turbine transforms gas energy into electric energy.

All those interested can visit our new plant on our open day on May, 1 2011. Please send a short e-mail for registration.

This Blog post provides an easy, step by step guide to integrate the Qt WebKit browser component into your client application.

1. step: Download and install the latest version of the Qt libraries for VS 2008 from the manufacturer’s homepage (http://qt.nokia.com/downloads/).

2. step: Run Visual Studio 2008 and create a new Qt application (e.g.: “QtWebkitApp”).

3. step: Set up the project settings as follows: Add the modules “network”, “ActiveQt Server”, “ActiveQt container” and “Webkit”. Now create the project.

4. step: Open the generated header file “qtwebkitapp.h”. Add a new class “QWebView”. In the class “QtWebkitApp”, add two slots “adjustLocation” and “changeLocation” and two member variables “QLineEdit *locationEdit” and “QWebView *view”. After that the header file should look like as follows:

#ifndef QTWEBKITAPP_H
#define QTWEBKITAPP_H

#include
#include "ui_qtwebkitapp.h"

//New class
class QWebView;

class QtWebkitApp : public QMainWindow
{
    Q_OBJECT

public:
    QtWebkitApp(QWidget *parent = 0, Qt::WFlags flags = 0);
    ~QtWebkitApp();

protected slots:
    //Event handler
    void adjustLocation();
    void changeLocation();

private:
    Ui::QtWebkitAppClass ui;
    //Address inputfield and browser view
    QLineEdit *locationEdit;
    QWebView *view;
};

#endif // QTWEBKITAPP_H

5. step: Open the generated code file “qtwebkitapp.cpp”.

6. step: Include “QtGui” and “QtWebKit”.

#include <QtGui>
#include <QtWebKit>

7. step: Add the following code to the “QtWebkitApp” constructor to create and initialize the browser view and the toolbar.

//Window title
QString titleQString = QString("La Gentz BrowserApp");
QUrl url = QUrl(QString("http://www.lagentz.com"));

//Enables the use of the platform-specific proxy settings, and only those
QNetworkProxyFactory::setUseSystemConfiguration(true);

view = new QWebView(this);
//Set attribute false to disable javascript
view->settings()->setAttribute(QWebSettings::JavascriptEnabled, true);
view->load(url);

#ifdef ENABLE_TOOLBAR
//Register callback on loadFinished event to set the address in the inputfield
connect(view, SIGNAL(loadFinished(bool)), SLOT(adjustLocation()));
locationEdit = new QLineEdit(this);
//Set the inputfield layout behaviour
locationEdit->setSizePolicy(QSizePolicy::Expanding, locationEdit->sizePolicy().verticalPolicy());
//Register callback on returnPressed event to navigate to the typed address
connect(locationEdit, SIGNAL(returnPressed()), SLOT(changeLocation()));

//Add the navigation toolbar
QToolBar *toolBar = addToolBar(tr("Navigation"));
toolBar->addAction(view->pageAction(QWebPage::Back));
toolBar->addAction(view->pageAction(QWebPage::Forward));
toolBar->addAction(view->pageAction(QWebPage::Reload));
toolBar->addAction(view->pageAction(QWebPage::Stop));
toolBar->addWidget(locationEdit);
#endif

setCentralWidget(view);
setWindowTitle(titleQString);

#ifdef WINDOW_IS_MAXIMIZED
showMaximized();
#else
//Position x, y, width and height
setGeometry(100, 100, 800, 600);
#endif

8. step: Add the callback handler function for the “loadFinished” event. The event will be triggered when the website has been loaded. Then it is necessary to update the address input field.

void QtWebkitApp::adjustLocation()
{
    //Set the address inputfield
    locationEdit->setText(view->url().toString());
}

9. step: Add the callback handler function for the “returnPressed” event. This event will be triggered when the address inputfield has the focus and <Return> is pressed. Then the browser should navigate to the entered website.

void QtWebkitApp::changeLocation()
{
    //Navigate to the entered address
    view->load(QUrl(locationEdit->text()));
    view->setFocus();
}

10. step: Compile and run the program.

11. and last step: If your browser application should be able to display images, play flash videos, etc. you have to ship plugins. You can find a list of available plugins under http://doc.qt.nokia.com/stable/plugins-howto.html -> “Static Plugins”. The plugins are located in the Qt libraries for VS 2008 install directory. Just copy them with your browser application and add the config file “qt.conf” where you specify the plugin directory. E.g.:

[Paths]
Plugins = .\\plugins

Enjoy your own browser application!
Michael

Download: Visual Studio project files + source code