setnode.com

Mouse wheel events, event filters, and QScrollArea

richardwb — Sun, 12 Sep 2010 18:21:00 -0700

Let’s say you have a QScrollArea which contains some custom widget. Now, although this widget itself has no use for mouse wheel events, when it’s in your QScrollArea you’d really like for it to grow and shrink in response to the wheel. Or maybe you’d just like to map vertical wheel events to horizontal scrolling, since you know the widget will never need vertical scrollbars.

The biggest problem here is that QScrollArea accepts wheel events (this isn’t strictly true, as you’ll soon see). Events propagate from the child up to the parent until someone accepts the event, and this means that QScrollArea will prevent wheel events from getting to your own code (again, this isn’t strictly true).

Reading the documentation it’s clear that you’d either want to subclass QScrollArea or use event filters. Since you don’t need to subclass QScrollArea for any other reason, using event filters sounds like a reasonable approach. You’ll set up an event filter that forces wheel events to be ignored and install it on the QScrollArea. That way, it’ll propagate up to your containing widget.

So you’d adjust your containing widget like so:

class MyWidget : public QObject
{
    public:
        // ...

        bool eventFilter(QObject* /*obj*/, QEvent* evt)
        {
            if (evt->type() == QEvent::Wheel)
            {
                // ignore the event (this effectively 
                // makes it "skip" one object)
                evt->ignore();
            }
            // return false to continue event propagation
            // for all events
            return false;
        }

    protected:
        void wheelEvent(QWheelEvent* event)
        {
            // your own custom stuff
            // ...
            // if you handle the event and don't want it to
            // propagate any further, accept it:
            event->accept();
        }
};

And then you’d use it like so:

QScrollArea* scrollArea = new QScrollArea(parent);
scrollArea->setWidget(someWidget);
// assuming that 'this' is MyWidget
scrollArea->installEventFilter(this);

This doesn’t work. Instead, what you need to do is installEventFilter() on QScrollArea’s viewport:

scrollArea->viewport()->installEventFilter(this);

In fact, QScrollArea is not the one that is accepting wheel events. It’s the viewport that is doing all of that. By installing an event filter on the viewport, the wheel events will continue to propagate up the tree.

Logitech G500 Gaming Mouse - Impressions

richardwb — Sat, 22 May 2010 16:06:00 -0700

Got a Logitech G500 mouse recently and I thought I'd just quickly note my impressions of the mouse and its associated software. First, some background on my previous (non-throwaway) mice to give an idea of what I've used before:

Logitech MX1000: a wireless mouse that had little to no lag in my particular environment, in contrast to:
Logitech MX Revolution: the wireless mouse Logitech sent me as a replacement for the MX1000 above; had two wheels, one of which had a free spinning mode; unfortunately had terrible interference problems for me and was essentially unusable
Razer DeathAdder: a wired mouse with a great shape, just wish it had more buttons
Purchased the Logitech G500 because my Razer mouse was double-clicking sporadically and developed a flaky scroll wheel (scrolling down would sometimes scroll up)

I don't have much to say about the mouse itself that hasn't already been said on the internet -- it feels good in the hand and has plenty of buttons. I'm going to focus on the part I found more interesting, the on-board memory.

Now, one problem with most of these mice is that while the left, right, middle, and two side buttons (Mouse4 and Mouse5) are supported natively by Windows, any additional buttons on them require the appropriate drivers to be installed. This isn't necessarily bad in itself, but I always liked the idea of a mouse that just works, fully functional, without requiring any drivers. The DeathAdder added on-board memory to avoid this issue, so you could do things like save a macro to Mouse5 and bring it to another computer and have that macro available. Unfortunately, it only had five buttons, all of which already have standard functions, so I never found a good use for this feature. However, the on-board memory did let you save your mouse DPI settings, which was somewhat useful.

The G500 also has on-board memory, but this time it also has the spare buttons to make it worthwhile. In addition to the five standard buttons, the G500 has one extra side button, two DPI buttons, a left wheel tilt and a right wheel tilt. All of these are programmable and, as long as you stick to commands that can be sent by a keyboard or a mouse (including standard media keys like volume and playback controls), will work on any computer without drivers. It apparently does this by acting as several human interface devices, including a keyboard and a mouse:

It's pretty interesting assigning a keystroke like 'A' to a side button or having your DPI buttons control the system's volume. After setting my bindings up I uninstalled the SetPoint software and still have a fully working mouse. Neat.

Accessing a Git repository with TortoiseHg on Windows

richardwb — Fri, 09 Apr 2010 10:31:00 -0700

If you're using Hg and you want to get hold of a Git repository there is an extension, hg-git, that lets you do this.

On Windows the installation process for this hasn't always been the easiest, as you needed to first install the dulwich Python library (which I always seemed to have trouble doing) and then hg-git. The TortoiseHg guys have made this a lot easier in recent versions of TortoiseHg, as they now include the dulwich libraries.

So, step by step:

You'll need TortoiseHg 0.9.3 or later. Get the latest version.
Bring up a command line and enter this line to clone the latest hg-git to your desired directory (this is "installing" hg-git). I'll use D:\TortoiseHg\hg-git in this example.
```
> hg clone http://bitbucket.org/durin42/hg-git/ D:\TortoiseHg\hg-git
```
Open up your user-specific Mercurial.ini. The location of this file may change occasionally, read the Mercurial docs if you have trouble finding it.
On Windows Vista and Windows 7 this file is typically located at:
```
C:\Users\YourUsername\Mercurial.ini
```
while on Windows XP you'll find it at:
```
C:\Documents and Settings\YourUsername\Mercurial.ini
```
Alternatively, bring up the Windows "Run" dialog and enter:
```
%USERPROFILE%\Mercurial.ini
```
which will work on all recent Windows platforms.
Navigate down to the [extensions] section and add this line to that section:
```
hggit = D:\TortoiseHg\hg-git
```
Where D:\TortoiseHg\hg-git is the directory you cloned hg-git to earlier. This line may already exist or may be commented out with a semicolon, in that case just remove the semicolon and update the directory.

Now you can clone a Git repository like so:

> hg clone git://github.com/richhickey/clojure.git D:\TargetDirectory

The result is you'll have a Mercurial enabled repository at D:\TargetDirectory. You can push, pull, and generally treat it as an Hg repository. Try
```
> hg help hggit
```

for additional help and information, or check the HgGit page on the Mercurial wiki.

Great Boost Documentation

richardwb — Sat, 03 Apr 2010 18:20:00 -0700

I found out from the Life of Andrew blog that there is a new source for Boost information available. It's a Creative Commons licensed book covering a wide range of Boost libraries, some of which are usually under-represented documentation-wise (looking at you, ASIO). It was originally written in German by Boris Schäling, but Andreas Masur has translated it into English for those of us who aren't so culturally adapted.

A brief skim of the book gives an extremely promising impression and I think it'll be one of the first resources I point newcomers to Boost to in the future.

Simplify signals and slots connections with unique connections in Qt 4.6

richardwb — Tue, 12 Jan 2010 14:43:00 -0800

Somehow there's absolutely no mention of this in the What's New in Qt 4.6 summary, but one of my favorite new features in Qt 4.6 is a surprisingly simple one: the Qt::UniqueConnection connection type.

The default connection type for connect() is Qt::AutoConnection, which sets up either a direct or queued connection depending on whether the signaling object and receiving slot are in the same thread or not. This connection type allows you to connect a particular signal/slot pair multiple times (so emitting a signal once could call a slot twice) which has caught me on a number of occasions.

This is really simple to work around: you can add some bookkeeping to keep track of that particular connection or you can use disconnect() where appropriate to maintain 0 or 1 connections. The new Qt::UniqueConnection connection type, on the other hand, lets you be sure that a connection is made only once. It's not something you always need, but when you do, it lets you keep your code a bit cleaner.

One caveat is that Qt::UniqueConnection makes a unique Qt::AutoConnection, meaning you don't have the ability to explicitly specify a unique queued connection, for example. In a case like that you will have to keep track of the connections yourself, as before.

Qt 4.6 has prebuilt binaries for Visual Studio

richardwb — Wed, 02 Dec 2009 12:42:00 -0800

I've just found out that Qt 4.6 actually includes prebuilt LGPL binaries for Visual Studio 2008, so there's little reason to spend time building Qt unless you need to use some other version of Visual Studio.

The prebuilt binaries are downloadable from here. Alternatively, you can visit the Qt download page, choose LGPL, and look on the right hand side of the page for the download link.

I highly recommend using the prebuilt libraries, as you will save a tremendous amount of time (it takes hours to build Qt). After you finish downloading and installing the libraries, install the Visual Studio add-in to make it easier to handle the custom build steps for moc and ui files.

Qt 4.6 is out, compiling it with MSVC

richardwb — Wed, 02 Dec 2009 01:39:00 -0800

Qt 4.6 has been released (with some new features) so I've taken the opportunity to make sure my instructions on how to compile Qt with Visual Studio are still accurate. The additional steps on how to take advantage of your multi-core processor (using jom) still work, as well.

[Edit: Qt 4.6 actually has prebuilt binaries/libraries for Visual Studio 2008, which is preferable to spending hours building Qt]

I've made a note in the article but I'll repeat it here because it's a major time-saver: you should delete, from your Qt folder, these instances of mocinclude.tmp:

\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\release_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\release_shared\mocinclude.tmp

Deleting the first two mocinclude.tmp files will prevent a LNK2019 error while building Webkit, while deleting the last two (which are new in Qt 4.6, as far as I can tell) will prevent an Error: Unknown interface while trying to build qscriptextensionplugin.h.

An update on building Boost with MSVC (still with dual/quad/multi-core action)

richardwb — Thu, 19 Nov 2009 02:05:00 -0800

I've noticed that in recent versions of Boost (1.39.0 and newer) there is a way to do a "Simplified Build from Source" if you're using Microsoft Visual Studio. Here are the steps as I like to write them:

Download the latest version of Boost and extract it to some location (we'll assume D:\Boost\), making sure to maintain the directory structure.
In a command prompt, navigate to your Boost library folder (D:\Boost\boost_1_41_0\) and then use this command, which builds your very own copy of Boost Jam (a build system):
```
> bootstrap
```
Now, in the same command prompt, enter this command, where N is the number of processors/cores you have available for compiling (for example, -j4 if you have a quad-core processor):
```
> bjam.exe -jN
```
Wait.
After the build completes you will have a stage subdirectory (D:\Boost\boost_1_41_0\stage\) which will contain a lib subdirectory, containing the compiled libraries.

This simplified process removes the need to get a copy of Boost Jam, which, as trivial as it sounds, really does make a big difference to the friendliness of the entire procedure. It also reduces the number of necessary arguments to zero (or one, if you consider multi-core a necessity), although there are some situations where you may still need the older arguments (in which case I refer you to my previous entry on the subject).

SteveStreeting.com's great series of articles about distributed version control systems

richardwb — Sat, 07 Nov 2009 00:43:00 -0800

Steve Streeting (the man behind OGRE, a 3D graphics engine) has been writing about his experiments with distributed version control systems, particularly Mercurial and Git. In particular, his latest blog post contains a summary of his experiences with the two version control systems and is probably the most in-depth article I've read on the topic.

The most interesting portions of the article (and his prior posts) are the ones which talk directly about managing the OGRE source within each of the two DVCSs. OGRE is not a small project and it's very illuminating to read about what parts of a (distributed) version control system are important to a larger project, as this is stuff you may not personally experience until it's too late to change your mind.

For my own personal projects I use Subversion (TortoiseSVN is a great piece of software) and I'm not in any particular rush to switch over to a DVCS just yet. It's simple, straightforward and fits well with my workflow. For larger projects, especially ones where you're collaborating with people across the Internet, I'd give some serious thought to using a DVCS and reading about other people's experiences is extremely helpful.

[Edit: I ended up switching about a year after this post to Mercurial for my personal projects.]

Windows Sidebar Gadgets

richardwb — Mon, 12 Oct 2009 11:57:00 -0700

Windows Vista and Windows 7 provides what they call Windows (Sidebar) Gadgets (the Sidebar moniker is removed in Windows 7). These gadgets do the same thing as similar products from Yahoo (formerly known as Konfabulator) and Apple (the Dashboard), providing small amounts of functionality and information within easy reach.

The Windows Live Gallery is a perfect example of how not to make a download center. If you take a look at the Sidebar gadgets category, most are of rather poor quality, and a fair number of the good ones use plagiarized skins and/or code.

There's no community presence on a site like that, and without a community to help deter poor behavior I think the free-for-all atmosphere makes it hard for the good submissions to float to the top. deviantART is a great example of a site that does the right stuff; their Sidebar gadgets section is cleaner and easier to use.

Anyway, I bring this up because there are some gadgets on ~~The Hobby Lounge~~ which you won't find on deviantART and unfortunately exist in a plagiarized state on the Windows Live Gallery. I was in the process of updating some of my older gadgets from this site and it took me a surprisingly long time to find the website again, even though I knew exactly what I was looking for. My google-fu is usually pretty decent so I figure I'll make a note of it here for myself and maybe help them get noticed a bit more.

[Edit: The Hobby Lounge is now unfortunately defunct.]

Optimization switches and Visual Studio 2008

richardwb — Fri, 02 Oct 2009 15:29:00 -0700

In a previous entry I noted that you generally do not need to micromanage your optimization switches.

However, in Visual Studio 2008 (both with and without SP1) there is a bug where the default optimization switch, /O2, is not applied even when shown in the IDE under Configuration Properties->C/C++->Optimization.

This happens when you select <inherit from parent or project defaults>. Instead, you want to explicitly set Maximize Speed (/O2) (it will show up in bold when explicitly set). You should also verify that the /O2 flag is being applied by viewing the command line (Configuration Properties->C/C++->Command Line).

There is more about this bug on Microsoft Connect, where it's also noted that this bug will be fixed in Visual Studio 2010.

Right-click context menus with Qt

richardwb — Thu, 23 Jul 2009 20:47:00 -0700

Getting right-clicks to popup a context menu is pretty straightforward in Qt. There are just a couple of things to watch out for...

First, there are several ways to tell Qt you want a context menu. One approach is to subclass the widget and override the QWidget::contextMenuEvent() event handler. However, I think the easiest approach is to call setContextMenuPolicy(Qt::CustomContextMenu) on the widget you want, and then connect the customContextMenuRequested() signal to the appropriate slot:

// myWidget is any QWidget-derived class
myWidget->setContextMenuPolicy(Qt::CustomContextMenu);
connect(myWidget, SIGNAL(customContextMenuRequested(const QPoint&)),
    this, SLOT(ShowContextMenu(const QPoint&)));

Next, note that the const QPoint& pos parameter in the customContextMenuRequested() signal is normally in widget coordinates. However, also note that classes which inherit from QAbstractScrollArea¹ instead use the coordinates of their viewport(). Either way, you will need to map these coordinates to global coordinates using mapToGlobal().

Finally, simply either popup() or exec() your QMenu. Remember that popup() is non-blocking, so if you wish to use that, make sure your QMenu is created on the heap (or some other way of guaranteeing that the QMenu's lifetime outlasts the scope of the function)!

void MyClass::ShowContextMenu(const QPoint& pos) // this is a slot
{
    // for most widgets
    QPoint globalPos = myWidget->mapToGlobal(pos);
    // for QAbstractScrollArea and derived classes you would use:
    // QPoint globalPos = myWidget->viewport()->mapToGlobal(pos);

    QMenu myMenu;
    myMenu.addAction("Menu Item 1");
    // ...

    QAction* selectedItem = myMenu.exec(globalPos);
    if (selectedItem)
    {
        // something was chosen, do stuff
    }
    else
    {
        // nothing was chosen
    }
}

Examples include QTreeWidget, QTreeView, QListWidget, QListView, QTableWidget, QTableView, QTextEdit, QPlainTextEdit, and QMdiArea. ↩

Consolas is a poor choice for web use

richardwb — Mon, 06 Jul 2009 15:22:00 -0700

Consolas, with ClearType enabled, is a gorgeous font, and is my preferred monospaced font. However, take a look at it without ClearType (there's a sample image on the linked Wikipedia article)---those jaggies hurt.

That's why you shouldn't define Consolas in your style sheets. You can't know/assume that everyone who views your webpage will have ClearType on (or at least some form of font-smoothing), and those who don't have it enabled will suffer through text that looks as though it were drawn freehand with a mouse.

Instead, unless you are going for a specific effect such as trying to mimic old terminals, keep your font-family for <pre> and <code> elements short and to the point. I personally use

font-family: "Lucida Console", "Monaco", "DejaVu Sans Mono", monospace;

which is usually enough to keep Courier (+ New) out of the way. If someone is missing all of these fonts they'll likely have a decent enough substitute.

Compile Qt 4.5 for Visual Studio, using your multi-core processor

richardwb — Thu, 25 Jun 2009 20:28:00 -0700

If you want to use Qt 4.5 with Visual Studio you'll need to compile it yourself. The instructions are simple, and fairly well documented on various blogs and websites. Essentially: (read steps 7 and on for multi-threading information)

[Edit: These steps still apply for Qt 4.6, but Qt 4.6 actually has prebuilt binaries/libraries for Visual Studio 2008 which I highly suggest looking at instead]

This step is important. You will potentially save some time by deleting these mocinclude.tmp files:
```
\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\3rdparty\webkit\WebCore\tmp\moc\release_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\debug_shared\mocinclude.tmp
\Qt\2009.05\qt\src\script\tmp\moc\release_shared\mocinclude.tmp
```
Deleting the first two mocinclude.tmp files will prevent a LNK2019 error from building Webkit, while deleting the last two (which are present in Qt 4.6) will prevent Error: Unknown interface from occurring while trying to build qscriptextensionplugin.h. If you're missing any of them don't fret, it's actually a good thing.
Using a Visual Studio Command Prompt, navigate to your Qt folder (I'll use D:\Coding\Qt\2009.05 in this example).
Go to the Qt folder inside there (e.g. D:\Coding\Qt\2009.05\qt). It's the one that contains configure.exe.
Enter the following command, changing win32-msvc2008 to win32-msvc2005 if necessary.
```
> configure -opensource -shared -ltcg -no-qt3support -platform win32-msvc2008
```
What this does is fairly self explanatory. The -shared switch will make sure that Qt is configured for dynamic linking (even though that's usually the default option there's no guarantee). We need to specify the -ltcg switch to turn on Link Time Code Generation. LTCG is off by default since, in combination with a statically built Qt, it will make linking very slow for any projects that use Qt. However, if we configure Qt for dynamic linking this won't be an issue.
You can add or remove switches as desired (try configure help) but I find most of the defaults suitable. Sure, you may not need OpenGL (or SQL or Phonon or...) support right now, but it's a separate module anyway and you're already compiling the rest of Qt.
All you need to do now is run nmake...but wait.
Do you have a dual-core or quad-core processor or can take advantage of multi-threaded compilation? Get the jom tool instead. There's some info about jom in this Qt Labs Blogs article. You can download the latest version of jom from ftp://ftp.qt.nokia.com/jom/ (jom.zip should be just fine).
Use jom by simply unzipping and running it in the same directory as configure (which is still the same as before, D:\Coding\Qt\2009.05\qt).
```
> jom
```
Happily build Qt much faster. For example, on my machine (a Core 2 Quad) it took an hour for the build to complete.
Unless you really enjoy manually handling custom build steps, don't forget to get the Qt Visual Studio Add-In. After installing it make sure that it's aware of the location of your Qt installation (Qt->Qt Options) and then use File->New->Project... and select one of the Qt templates to get started.

#include Guidelines

richardwb — Mon, 22 Jun 2009 19:20:00 -0700

This is mostly for my own reference, but here are some of the guidelines I like to follow when it comes to #includes in C++. Given foo.cpp and foo.h:

foo.h should include everything it mentions and no more. For example, if you use boost::random in the implementation, don't #include <boost/random.hpp> in foo.h.
foo.cpp should also include everything it mentions and no more.
foo.cpp's first include should be #include "foo.h".
Precompiled headers, if used, should be specified in foo.cpp only and will need to be the first #include (#include "foo.h" will then be the second).
Except for the above two exceptions, the order I like to follow for #includes is:
1. Headers from your own project (generally of the form #include "baz.h")
2. Headers from non-standard libraries (such as Qt)
3. Standard libraries (I include Boost in here because I use it so pervasively)
4. Platform headers (like #include <windows.h>)
Within each of the above groups try to alphabetically order the #includes if at all possible.
Forward declare whenever you can get away with it.

The difference between Qt::Key_Enter and Qt::Key_Return

richardwb — Wed, 10 Jun 2009 10:48:00 -0700

It's specified in the documentation, though in a slightly subtle manner. Essentially, Qt::Key_Enter is the keypad Enter, while Qt::Key_Return is the "regular" Enter, the one which you normally use while typing.

Visual Studio 2010 sounds pretty neat so far

richardwb — Tue, 09 Jun 2009 10:04:00 -0700

I'm a very big fan of the Visual Studio IDE (I think it's the best around, for any platform). However, Microsoft has historically put less of a emphasis on the C++ portion and the past couple of versions have had only minor bullet points on the C++ side.

I think they've wizened up a bit and the next Visual C++, 2010, has some notable improvements in store (C++0x support, for one). They've also put a lot of work into completely reworking their C++ IntelliSense engine. There's not much for me to say, really, as they have a great blog. I'll just highlight some of the articles I found the most interesting, which coincidentally all focus on IntelliSense:

Qt: staticMetaObject is not a member of...

richardwb — Fri, 29 May 2009 21:11:00 -0700

Just got this error message while compiling a tiny class that derives from QTreeWidgetItem:

error C2039: 'staticMetaObject' : is not a member of 'QTreeWidgetItem'

What this is saying is that QTreeWidgetItem does not inherit from QObject, meaning that your own, singly-inherited class also does not inherit from QObject. Inheriting from QObject is one of the prerequisites to using the Q_OBJECT macro, which, if you're anything like me, you automatically insert into any Qt GUI related class.

If you're not using any of the meta object stuff in your subclass, such as signals/slots or properties, just take out the Q_OBJECT macro. If you need to use signals and slots, you'll need to make your subclass multiply-inherit from QObject as well. If you take this route, remember that "Multiple Inheritance Requires QObject to Be First", otherwise you'll get either the same error as above, or something along the lines of "YourClass inherits from two QObject subclasses" from the moc.

Captchas shouldn't be the default defense against bots

richardwb — Thu, 21 May 2009 15:17:00 -0700

Captchas are useful to prevent bots or similarly automated activities from occurring. However, they're not perfect and many of them can be broken with a targeted attack. In a sort of arms race fashion, captchas get more and more intricate, but some take this a bit too far and aren't really even human solvable.

In any case, large sites have to have some way to separate bots from humans, and captchas may be the only solution. It's still an arms race, but at least the large sites have the resources to throw at it.

What about the small sites? Your blog about your cat? Your forum for fellow gum-chewers? Do you really need (or want) a captcha for these types of sites? Unfortunately, what happens is a crawler stumbles upon your site, notices it uses some popular blog or forum application it knows about, and attempts to register so it can subsequently flood your site with spam. If you use a popular application, such as phpBB3 (for the sake of argument), once the generic, built-in captcha gets broken, all non-customized phpBB3 sites are vulnerable. So a spammer just needs to try to break this one particular captcha and suddenly they've unlocked the ability to spam millions of forums. It provides the volume that spammers need to make spam work.

What I suggest instead is that the default mode of operation for a forum (or any application, really) should be to ask a simple question upon registration, with both the answer and question provided by the person who is running the site:

Q: What is my cat's name?
A: Fluffy

Q: Which of the following is a brand of gum? Oreos, Jellybeans, Trident, Snickers
A: Trident

Incidentally, yes/no type questions should be disallowed, as the answers ('yes' and 'no') would be common enough to automate.

Now, spamming your forum requires actual human intervention. Obviously this sort of approach will fail if you have a large or popular site, but if you own such a site you already know you have to take more steps to protect your site.

One potential problem is I could see lists of questions/answers being hand-generated and passed around, but this could be mitigated by expiring questions/answers after some time. If you're feeling particularly clever you could even flag the old answer as being a 'bot-answer', which might work well in concert with an Akismet type service:

Q: How old is my cat?
A: Fluffy (hello, bot!)

Anyway, I feel that captchas are a bit of dead end in terms of anti-spam measures for small sites. Small sites are not typical targets for spammers, as the reward is not worth the effort. However, if all these small sites are protected by the same captcha, breaking that captcha gives that spammer access to (small-sites × millions), which is worth the effort.

More thoughts on Qt 4.5

richardwb — Thu, 07 May 2009 16:35:00 -0700

I've been using Qt 4.5 for a couple more weeks now and I've had a few more thoughts on the framework.

I don't know if I could handle using the plain Win32 API for GUI ever again
Even with Qt's "parent handles the deletion of its children" memory management system it's still easier to use (and reason about) shared_ptr or another smart pointer, as long as you're not working with widgets or similar GUI elements. If you're working with GUI elements, Qt's memory management works perfectly and makes sense.
You can assume that any addWidget()-like function will take ownership unless explicitly stated otherwise. I still wish they would just say straight out that "this function takes ownership".
In my opinion the documentation would be much improved for newcomers if they had a "Qt Best Practices" section. You can get a sense of how things should be structured if you look at their sample programs, but there's a lot to go through.
Other than those two nitpicks, the documentation is consistently quite good.
I would suggest that you avoid using the Qt containers and instead favor the standard C++ containers whenever possible. There's less to learn, and most C++ programmers will have a firm grasp of the containers in the std namespace. Some Qt functions do return QStringList or some other Qt container, in which case you may as well just leave it in the container you get it in.
On the other hand, if you're going to use Qt, you may as well use QString everywhere. It's used extensively through the Qt framework, so you won't be able to avoid it. It's a pretty decent string library anyway, with plenty of useful functions, and it handles Unicode cleanly in my experience.
QTextEdit isn't particularly performant, particularly when you resize it and it has to perform lots of word wrap calculations. Use QPlainTextEdit if you can.

A really quick boost::random guide

richardwb — Wed, 06 May 2009 20:03:00 -0700

This is a really short and quick guide on how to use boost::random. The best place to start is, as always, the documentation, but Boost also provides a simple sample program that covers the library in a good "how to get started" fashion.

What I'm about to write here is even shorter and less detailed -- it's just the basic code needed to generate some random numbers.

// Initialize a random number generator.
// Boost provides a bunch of these, note that some of them are not meant
// for direct user usage and you should instead use a specialization (for 
// example, don't use linear_congruential and use minstd_rand or 
// minstd_rand0 instead)

// This constructor seeds the generator with the current time.
// As mentioned in Boost's sample program, time(0) is not a great seed,
// but you can probably get away with it for most situations.
// Consider using more precise timers such as gettimeofday on *nix or
// GetTickCount/timeGetTime/QueryPerformanceCounter on Windows.
boost::mt19937 randGen(std::time(0));

// Now we set up a distribution. Boost provides a bunch of these as well.
// This is the preferred way to generate numbers in a certain range.
// In this example we initialize a uniform distribution between 0 and the max
// value that an unsigned char can hold (255 for most architectures)
boost::uniform_int<> uInt8Dist(0, std::numeric_limits<unsigned char>::max());

// Finally, declare a variate_generator which maps the random number
// generator and the distribution together. This variate_generator
// is usable like a function call.
boost::variate_generator< boost::mt19937&, boost::uniform_int<> > 
    GetRand(randGen, uInt8Dist);

// Generate a random number
int aRandomNumber = GetRand();

Namespaces are one honking great idea

richardwb — Wed, 29 Apr 2009 09:17:00 -0700

The title of this post comes from the last line of The Zen of Python.

It applies to C++ too: namespaces are great. Namespaces let the Boost folks contain all sorts of widely varying libraries without having to worry about naming collisions in user code. Namespaces let you mix multiple libraries easily and safely. Namespaces let you group sets of related free functions together, without needing a class. Namespaces also let you work around one thing I've always found a bit unusual with enums: the way they don't have their own scope.

enum ValidValues
{
    Value1,
    Value2
};

This ends up declaring Value1 and Value2 in the underlying scope. What I like to do is wrap the enum in a namespace:

namespace ValidValues
{
    enum Enum
    {
        Value1,
        Value2
    };
}

This sticks Value1 and Value2 in the ValidValues namespace. The only disadvantage is declaring a variable of this enum type gets a bit silly and inconsistent. For example:

ValidValues var = Value1; // error, ValidValues is a namespace, Value1 is undefined
ValidValues::Enum var = Value1; // error, Value1 is undefined
ValidValues::Enum var = ValidValues::Value1; // okay

This is yet another area where C++0x will offer its own solution, in this case, strongly typed enumerations.

Right aligning a button in a QToolBar

richardwb — Thu, 23 Apr 2009 08:32:00 -0700

Sometimes you will want to add a right-aligned button to a QToolBar. The first thing that probably comes to mind is to add a QSpacerItem to the toolbar, but that won't work as QSpacerItem is not a child of QWidget, so you can't use the addWidget() member of QToolBar. Instead, make a basic QWidget, set its sizePolicy to Expanding, and add that widget to your QToolBar. For example:

QWidget* spacer = new QWidget();
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// toolBar is a pointer to an existing toolbar
toolBar->addWidget(spacer);
toolBar->addAction("Right-aligned button");

If you end up using a lot of these spacers you could even create a subclass.

Qt 4.5

richardwb — Mon, 20 Apr 2009 09:16:00 -0700

Qt is a well known cross platform framework. It's probably most well known as the framework on which KDE is written.

Anyway, over the weekend I experimented with it a bit, and in terms of C++ GUI development it's a breath of fresh air. It approaches the ease of use of the .net GUI facilities, which is great for a language with no built in introspection abilities. The "moc" preprocessor that Qt requires (that lets them do things such as signals and slots) you to run on your source files is still a bit weird, but it's really not as bad as it seems.

The Qt framework is also impressively comprehensive, making it very easy to code applications directly against Qt, instead of coding against a particular OS or a particular compiler.

The style of the framework itself is more traditional than the common notion of modern C++, having more of an emphasis on subclassing and overriding virtual functions than on generic algorithms. The memory management system is definitely foreign: they encourage you to allocate on the heap, yet there are very few delete statements. The way it works is that QObjects (Qt's base class) accept a pointer to a parent in their constructor, which makes that particular QObject a child of the parent. When the parent is deleted, it takes care of deleting all its children. It's a change from RAII, for sure.

It also takes a couple of hours to compile Visual Studio compatible versions of the various components, so don't do it as a last minute thing.

Porting a Winsock application to Linux...select(2) is not as simple as MSDN makes it seem

richardwb — Fri, 10 Apr 2009 17:54:00 -0700

I'm in the middle of porting bits of a Winsock application to Linux. Luckily when I first wrote the networking bits I had made an effort to write it in a somewhat cross platform manner. As a result, I stuck to select(), send(), recv(), and all the other function calls that Winsock provides that are close to the Berkeley socket interface. Things go pretty smoothly, although for some reason there's this really weird pause when connecting that didn't exist before...

Finally I hit a point where, for some reason, I couldn't establish a connection to the server and it just times out. That's really strange, so I threw good old debug statements all over the place and find out that this select() call is not doing much of a select:

if (select(0, &rdset, &wtset, &errset, &tv) > 0)

Notice the 0? MSDN states that it is:

nfds
Ignored. The nfds parameter is included only for compatibility with Berkeley sockets.

Then I check the equivalent docs on the Linux side of things:

nfds is the highest-numbered file descriptor in any of the three sets, plus 1.

Well, if I set nfds to 0, select() won't be doing very much selecting! Windows has FD_SETSIZE at 64 by default, and it ignores nfds and just checks whatever descriptors are in the fd_sets that you pass to it. Linux considers sockets and files the same thing, and thus has a much higher FD_SETSIZE (1024 and 4096 seem to be common). You don't want select() checking 4096 descriptors, so you set nfds to the highest file descriptor you want it to check, plus one. (As an aside, setting nfds to FD_SETSIZE is a bad idea.)

if (select(my_socket + 1, &rdset, &wtset, &errset, &tv) > 0)

Where my_socket is an appropriate file descriptor (such as the one returned by socket()). This works just fine in Windows too, since it ignores the nfds parameter.

Armed with this newfound knowledge, I go and fix all the other select() statements in my code, which ends up fixing the weird pause as well. Effectively, without a proper nfds value, select() just acts as a timer and blocks until the specified amount of time has elapsed.

All AJAX sites need a fancy indeterminate progress indicator...

richardwb — Sun, 05 Apr 2009 20:22:00 -0700

Ajaxload is a neat little site that generates those throbbers/spinning wheels that are in vogue nowadays. Your website/application won't be complete without one, after all.

PNG has a well designed magic number (or FourCC)

richardwb — Fri, 03 Apr 2009 17:20:00 -0700

Even with all the XML floating around, binary formats still have their place. It's good practice to place an identifier at the beginning of the binary file, so that the file type can be determined even in the absence of a proper file extension.

The simplest route to take is to just stuff some plain text there:

[M Y F I L E][rest of file]

However, consider following the design of the PNG magic number, described in detail in the PNG book. With some really neat design they are able to quickly detect some common forms of corruption caused by an incompatible transfer mechanism. In that case your identifier may look like:

[\211 M Y F I L E \r \n \032 \n][rest of file]

With an identifier like this many common forms of transfer corruption can be quickly identified, and you can spit out a simple "corrupt file" message instead of trying to read a broken file.

Don't forget about copy constructors and the copy assignment operator

richardwb — Fri, 03 Apr 2009 12:30:00 -0700

Something that I've always found handy to do is to decide, right away, what the copy semantics of a particular class are. Generally it turns out that it makes no sense (or is a lot of work) to allow copying, in which case the standard approach is to define the copy constructor and assignment operator as private.

An alternative approach and one that I think is a bit more self-documenting, is to inherit from boost::noncopyable. This achieves the same effect and makes it immediately obvious that the class will not allow copying.

class MyClass : boost::noncopyable { };

The most correct way to use boost::noncopyable is to inherit it privately, since inheriting it publicly could let people do really funny stuff like:

void stuff(const boost::noncopyable& obj);

(more details here)

A RapidXML gotcha

richardwb — Thu, 26 Mar 2009 13:00:00 -0700

I just spent a couple of hours trying to track down why I was seemingly losing data values while modifying nodes in the DOM. It's spelled out in the documentation, but it definitely threw me for a loop (I would consider this behavior surprising). Basically, RapidXML gives you the ability to assign/modify the value of a node and it also likes to create data nodes when you parse a document. When printing, the data node takes precedence over the value.

When you create a document from scratch this likely won't bite you, but when you parse an existing document and neglect to supply the parse_no_data_nodes flag, the parser creates data nodes. If you try to update your values with the value() function, it works just fine (and you can even pull it back out without any problems), but when you use the print() function, the data node (which you haven't updated) will show up instead.

What made this even more difficult to track down was how value() will return the first data node it finds if there isn't a value yet, so it really does seem like you have a value already. I've updated my prior RapidXML entry to include the parse_no_data_nodes flag, which may save someone some time down the road.

shared_ptr is great...but sometimes auto_ptr is actually better!

richardwb — Sat, 21 Mar 2009 18:04:00 -0700

Modern C++ programming benefits greatly from smart pointers. Smart pointers automate the error-prone process of making sure you have a matching number of new and delete statements. There's even one included in the C++ standard library: std::auto_ptr.

It's not a true general purpose smart pointer, however. For one, it has somewhat unusual transfer-of-ownership semantics:

std::auto_ptr<MyClass> a(new MyClass());
std::auto_ptr<MyClass> b = a;
// a now points to nothing!

This also makes it dangerous to use in containers, as described in Using auto_ptr Effectively. On the other hand, shared_ptr (which will be available in the next C++ standard, C++0x, and is now available in the Boost libraries) is a reference counting smart pointer. It keeps track of the number of references to a particular object, and when there are no more references, it deletes the object. This is safe to use in containers. In fact, you can use shared_ptr pretty much everywhere and you will never have to worry about manually releasing memory again (cycles and threading are pretty much the only major problems).

However, while shared_ptr is a great general purpose smart pointer, auto_ptr has its uses. If you have a function that involves transfer-of-ownership semantics (whether receiving or giving), why not use the smart pointer that perfectly captures those requirements? The 'sources' (creates and then gives away ownership) and 'sinks' (takes ownership) described in the Using auto_ptr Effectively article is a prime example of this. Instead of using comments to specify that the caller of a function must manage the lifetime of the returned object, auto_ptr forces them to manage it (and if they don't, it'll clean itself up anyway). shared_ptr will likely work just as well, but it doesn't capture the semantics.

Another noteworthy reason to use auto_ptr when the semantics are suitable is that while auto_ptr can give away ownership to shared_ptr, shared_ptr cannot give away ownership to auto_ptr or another smart pointer (there is no release() function in shared_ptr).

auto_ptr is on its way to deprecation, but we haven't even seen C++0x yet, so I wouldn't worry too much about it. Its replacement, unique_ptr, will have the same transfer-of-ownership semantics, just implemented in a much safer way, so it'd be worth the effort to get used to using the right smart pointer for the job.

Speaking of which, do you know what scoped_ptr is?

Don't spend time micromanaging optimization options in Visual C++

richardwb — Sat, 14 Mar 2009 14:37:00 -0700

It's surprisingly common to see people ask what the best Visual C++ optimization options are for their C++ code.

The best answer is to profile and benchmark.

Failing that, it's pretty simple. Use /O2 to optimize for speed, and /O1 to optimize for size. That's (almost) it. If you have a large program you will probably benefit more from optimizing for size:

Generally speaking, small applications should be compiled with /O2, and large applications should be compiled with /O1 because very large applications can end up putting a lot of stress on the instruction cache of the processor, and this can lead to worse performance. To minimize this, use /O1 to reduce the amount of "code bloat" introduced by the optimizer from certain transformations such a loop unrolling or selection of larger, faster sequences of code. [MSDN]

But what about Enable Intrinsic Functions (/Oi), Omit Frame Pointers (/Oy), etc.?

Check out the documentation for /O2 and /O1:

/O1 (Minimize Size) : Equivalent to /Og /Os /Oy /Ob2 /Gs /GF /Gy
/O2 (Maximize Speed) : Equivalent to /Og /Oi /Ot /Oy /Ob2 /Gs /GF /Gy

They are already all specified. Yes, the property pages say Disabled or No, but what they really mean is Default.

The only general optimization I'm aware of that doesn't fall in this category is Whole Program Optimization (/GL), which also requires Link Time Code Generation (/LTCG).

Finally, what about Full Optimization (/Ox)?

In general, /O2 should be preferred over /Ox and /O1 over /Oxs. [MSDN]

[Edit: Note that there is an IDE bug in Visual Studio 2008 which may affect whether or not optimizations are applied. I write more about it here.]

Several compilation options I use with C++ projects in Visual Studio

richardwb — Thu, 12 Mar 2009 16:39:00 -0700

These are compilation options that I typically enable for any C++ projects in Visual Studio. They should go in the project's property settings, under Configuration Properties->C/C++->Command Line, in the Additional options textbox. They are listed here exactly as they should be entered in that box (equal signs and all).

/MP : This enables multi-process compilation, which can provide a significant speed boost on the multi-core processor you likely have in your development (or build) machine. As the MSDN documentation states, it is not compatible with the Enable Minimal Rebuild option, which, depending on the situation, may negate any performance advantage this switch has. Disabling minimal rebuild is not as bad as it sounds¹ and in my projects I've found that using /MP confers a significant improvement in compilation time. You definitely want to enable it for Release builds, at least. Reference.
/D_CRT_SECURE_NO_WARNINGS : This switch disables the warnings that Visual Studio spits out if you use any of the C RunTime functions that Microsoft has provided secure replacements for (such as strncpy). This isn't necessarily a bad idea, but their safe functions are not part of the standard and are thus non-portable. Reference.
/D_SCL_SECURE_NO_WARNINGS : Just like the switch above, only for the Standard C++ Library (anything in the std namespace). Reference.
/D_SECURE_SCL=0 : Disables checked iterators. Disabling this feature can improve performance when using iterators, at the expense of less protection against unsafe iterator use. Generally there isn't too much of a performance difference (a Visual C++ lead states that they measured about a 6% difference in this feedback / bug page) so it may be worth leaving it on most of the time. Reference.

Note that /D_CRT_SECURE_NO_WARNINGS and /D_SCL_SECURE_NO_WARNINGS are /D_CRT_SECURE_NO_DEPRECATE and /D_SCL_SECURE_NO_DEPRECATE, respectively, in versions prior to Visual Studio 2008.

Disabling Minimal Rebuild does not mean that the whole project gets rebuilt every time, just that Visual Studio uses a "was this .cpp/.h modified?" approach instead of trying to determine if the exact changes you made warrant a recompile. ↩

Stop wasting time stepping into functions you don't care about in Microsoft Visual Studio (C++)

richardwb — Mon, 09 Mar 2009 17:58:00 -0700

The Visual Studio debugger is amazingly useful. However, you soon learn to sigh the moment you come into contact with something like this:

boost::scoped_ptr<Startup> dlg(
    new Startup(settings->GetWindowPosition()));

You want to step into the Startup constructor, but there is a lot of stuff in your way.

First you will step into shared_ptr::operator-> (did I mention that settings was a shared_ptr?).
Then you will step into GetWindowPosition().
Then into operator new.
And then into your Startup constructor. Yes!
And finally you'll finish with the scoped_ptr constructor if you so choose.

If you've done this a lot you've probably gotten really good at the Step Out shortcut (Shift-F11).

Well, here are two alternatives!

First, while program execution is paused, right-click anywhere in the source window and look for the Step Into Specific item. You can select any of these functions to instantly step inside.

Alternatively, there is a special undocumented (and unsupported) registry key that you can use to specify functions that you always want to skip. Navigate to HKLM\SOFTWARE\Microsoft\VisualStudio\9.0\NativeDE\StepOver (users of a 64-bit variant of Windows will want to check HKLM\SOFTWARE\Wow6432Node\Microsoft\... instead) and add some string values like this example:

Name: 50 (priority, higher values have greater priority)
Value: std\:\:.*=NoStepInto

Name: 60
Value: operator new=NoStepInto

Name: 70
Value: boost\:\:.*=NoStepInto

The backslashes are necessary because : (colon) is a special character in Visual Studio regex. You sometimes see two backslashes used in other examples, this is only necessary if you are directly editing a .reg file (which I don't recommend). These rules will adjust the behaviour of the Step-Into command and make it skip anything from the std or boost namespaces, as well as the basic operator new. It will still step into an overloaded operator new, so don't fear. There are more details on this blog post, as well as microsoft.public.vsnet.debugging.

One more thing: you can combine these two approaches. Say that you've added a skip for the entire boost namespace, but you decide you really want to take a peek inside one particular line and see exactly what is happening to your parameters. Pause execution on that line, and then right-click and use Step Into Specific. This is still the same list as before and it works the same as before, regardless of any NoStepInto rules.

Boost.Thread triggers warning C4103 in Microsoft Visual Studio

richardwb — Mon, 02 Mar 2009 17:28:00 -0800

Got a whole mess of warnings when I moved some of my includes around, particularly this one: #include <boost/thread.hpp>

abi_prefix.hpp(19) : warning C4103: 
'd:\\boost\\boost_1_38_0\\boost\\config\\abi_prefix.hpp' : 
alignment changed after including header, may be due to missing 
#pragma pack(pop)

Some experimentation reveals that including thread.hpp before winsock2.h triggers all these warnings. The simple solution is to just move #include <boost/thread.hpp> down below #include <winsock2.h>.

Building Boost (now with dual/quad/multi-core action!)

richardwb — Mon, 02 Mar 2009 16:27:00 -0800

Update: More recent versions of Boost (1.39.0 and later) have a simpler build process, which I've written about here.

Steps to build the non-header-only Boost libraries on Windows, such as Boost.Thread and Boost.Regex, using Microsoft Visual Studio:

Download the latest version of Boost and extract it to some location, say, D:\Boost\, making sure to maintain the directory structure
Download the latest version of Boost Jam (you want the ntx86 binaries) and extract it to some location (probably the same as above), again making sure to maintain the directory structure
Your directory structure should now consist of D:\Boost\boost_1_38_0\ and D:\Boost\boost-jam-3.1.17-1-ntx86\
Make sure you have lots of hard drive space (at least 5GB)
In a command prompt, navigate to your Boost library folder (D:\Boost\boost_1_38_0\) and then use this command (read further down if you want details about what these arguments are doing):
```
> ..\boost-jam-3.1.17-1-ntx86\bjam.exe --toolset=msvc --build-type=complete stage
```
If you have a dual/quad/many-core processor or can otherwise take advantage of parallel jobs, also add the -jN switch, where N is the number of jobs to run at a time (e.g. bjam.exe -j4 --toolset=msvc).
And wait. This will take a very long time.
After it completes you will have a stage subdirectory (D:\Boost\boost_1_38_0\stage\) which will contain a lib subdirectory, containing the compiled libraries. You may move these anywhere you wish.
You will also have a bin.v2 subdirectory which was used for temporary files. You may delete this folder to reclaim some hard drive space.

More details:

--toolset=msvc : tells Boost Jam to compile with Microsoft Visual Studio.

--build-type=complete : notes that you want every possible combination built (Debug/Release, Multi/Single threaded, Static/Shared).

stage : a build target which builds the compiled libraries to the stage directory (which you can set with --stagedir=<STAGEDIR>). Contrast this with the install target, which builds the compiled libraries, but also copies the header-only libraries to a particular location. This is generally an unnecessary step since you've already extracted the Boost headers somewhere already. Look inside the Jamroot file inside your Boost folder for more details.

Quick notes on how to use RapidXML

richardwb — Fri, 27 Feb 2009 21:11:00 -0800

There's a C++ XML library called RapidXML which is perfect for most non-enterprise uses of XML. I wouldn't call this a tutorial, but I hope this ends up helping someone. The documentation isn't very explicit on how to output an XML declaration, for example.

How to create your XML from scratch and then output this XML into a string, with an XML declaration:

<?xml version="1.0" encoding="utf-8"?>
<rootnode version="1.0" type="example">
  <childnode/>
</rootnode>

using namespace rapidxml;

xml_document<> doc;

// xml declaration
xml_node<>* decl = doc.allocate_node(node_declaration);
decl->append_attribute(doc.allocate_attribute("version", "1.0"));
decl->append_attribute(doc.allocate_attribute("encoding", "utf-8"));
doc.append_node(decl);

// root node
xml_node<>* root = doc.allocate_node(node_element, "rootnode");
root->append_attribute(doc.allocate_attribute("version", "1.0"));
root->append_attribute(doc.allocate_attribute("type", "example"));
doc.append_node(root);

// child node
xml_node<>* child = doc.allocate_node(node_element, "childnode");
root->append_node(child);

std::string xml_as_string;
// watch for name collisions here, print() is a very common function name!
print(std::back_inserter(xml_as_string), doc);
// xml_as_string now contains the XML in string form, indented
// (in all its angle bracket glory)

std::string xml_no_indent;
// print_no_indenting is the only flag that print() knows about
print(std::back_inserter(xml_no_indent), doc, print_no_indenting);
// xml_no_indent now contains non-indented XML

Parsing and traversing an XML document like this one:

<?xml version="1.0" encoding="utf-8"?>
<rootnode version="1.0" type="example">
  <childnode entry="1">
    <evendeepernode attr1="cat" attr2="dog"/>
    <evendeepernode attr1="lion" attr2="wolf"/>
  </childnode>
  <childnode entry="2">
  </childnode>
</rootnode>

void traverse_xml(const std::string& input_xml)
{
    // (input_xml contains the above XML)

    // make a safe-to-modify copy of input_xml
    // (you should never modify the contents of an std::string directly)
    vector<char> xml_copy(input_xml.begin(), input_xml.end());
    xml_copy.push_back('\0');

    // only use xml_copy from here on!
    xml_document<> doc;
    // we are choosing to parse the XML declaration
    // parse_no_data_nodes prevents RapidXML from using the somewhat surprising
    // behavior of having both values and data nodes, and having data nodes take
    // precedence over values when printing
    // >>> note that this will skip parsing of CDATA nodes <<<
    doc.parse<parse_declaration_node | parse_no_data_nodes>(&xml_copy[0]);

    // alternatively, use one of the two commented lines below to parse CDATA nodes, 
    // but please note the above caveat about surprising interactions between 
    // values and data nodes (also read http://www.setnode.com/blog/a-rapidxml-gotcha/)
    // if you use one of these two declarations try to use data nodes exclusively and
    // avoid using value()
    //doc.parse<parse_declaration_node>(&xml_copy[0]); // just get the XML declaration
    //doc.parse<parse_full>(&xml_copy[0]); // parses everything (slowest)

    // since we have parsed the XML declaration, it is the first node
    // (otherwise the first node would be our root node)
    string encoding = doc.first_node()->first_attribute("encoding")->value();
    // encoding == "utf-8"

    // we didn't keep track of our previous traversal, so let's start again
    // we can match nodes by name, skipping the xml declaration entirely
    xml_node<>* cur_node = doc.first_node("rootnode");
    string rootnode_type = cur_node->first_attribute("type")->value();
    // rootnode_type == "example"

    // go straight to the first evendeepernode
    cur_node = cur_node->first_node("childnode")->first_node("evendeepernode");
    string attr2 = cur_node->first_attribute("attr2")->value();
    // attr2 == "dog"

    // and then to the second evendeepernode
    cur_node = cur_node->next_sibling("evendeepernode");
    attr2 = cur_node->first_attribute("attr2")->value();
    // now attr2 == "wolf"
}

[Edit: Thanks to Michele Tavella for catching a silly bug on my part!]
[Edit: Thanks to Wei for noting that parse_no_data_nodes will skip over CDATA nodes]
[Edit: Thanks to remo for catching a typo]

Thanks for the comments everyone! I'm glad to help out where I can, but please do note that I check this blog rather infrequently at this point in time and will often not respond for days, if not weeks. If you have a question to which you need an answer within a reasonable time frame, I'd recommend using Stack Overflow. On the other hand, if you have corrections and/or suggestions, please continue to leave them here and I'll address them as they come up. Thanks again!

Remember that users do not read!

richardwb — Wed, 25 Feb 2009 14:42:00 -0800

Users do not read anything they are not interested in. This is well known and mentioned by many others.

You might not agree, or think that only a small percentage of users don't read. After all, you read. You love to read! Unfortunately, you don't count. You're a programmer, you better love reading!

I had absorbed this information before, but there is a definite difference between knowledge and experience. A couple of weeks ago I witnessed first-hand evidence that users do not read. I introduced a friend (who is the same age as I am and computer literate, uses Facebook and instant messaging, comfortable with Microsoft Office, etc.) to a computer game. This game, like most casual games nowadays, has a friendly tutorial, with large (~48pt) colorful fonts and a very gradual learning curve. The first thing the tutorial does is put up five lines of text which is maybe two sentences worth of information. All five lines are promptly ignored and the cursor heads straight for the "Next" button.

Well, that's okay, there's nothing important in that dialog anyway.

Next; next; next. The next three dialogs are skipped. The last dialog happens to contain important information on the more subtle points of the game.

This starts to drive me nuts, as I always eagerly soak up any bits of information a game throws at me. I want to play it to the best of my ability, after all. It hit me then: my friend just wanted to play and have fun. These dialogs were getting in the way! However, the game is entirely possible to play and enjoy without knowing every little intricate detail --- it's a 'casual' game after all.

All good software is like this. You should be able to dive in and use the program without reading anything. Your power users---the ones who use your program everyday---will know it's advantageous to learn as many shortcuts and tips as possible, so they can complete their tasks faster. They are the ones who might end up reading the information you throw at them (though it's still not a certainty). Your occasional user, on the other hand, wants to get their task done as soon as possible, because they have other things to do. You may assume they will not read anything you throw at them that is over two sentences long.

The most surprising thing to me was that those game dialogs were not close to being long. They were well under the "typical-users-see-nothing-past-this-word" limit and they still didn't get read. To me that implies that the only words you can assume will always get read are the words on the buttons themselves. Is your software still usable if all your explanatory text is missing?

Perhaps, since users read the text on buttons, you could somehow associate explanatory text with a button? I suspect the new Task Dialogs in Windows Vista were developed with this in mind: they use massive buttons and associate explanatory text with a button. It's unfortunate that they weren't introduced earlier, as the main reason you so often see simple "Yes / No" or "OK / Cancel" dialogs in Windows applications is they are really simple to code:

MessageBox(hWnd, "Isn't this easy?", "Yet Another Windows Application", MB_YESNO);

A task dialog type affair (pre-Vista), on the other hand, requires separate templates for each dialog or creating an indirect dialog (on the fly, with lots of simple but tedious math). Both of these approaches take infinitely longer to write.

If you really care about usability, though, perhaps it's time well spent.

lighttpd tips

richardwb — Mon, 09 Feb 2009 16:32:00 -0800

lighttpd is a web server that is optimized for speed. It is particularly adept at serving static content. Since most web hosts provide Apache and most web applications assume you are running on Apache (which is why web hosts provide Apache and why web applications assume you use Apache and why web hosts provide Apache and ...) it can take a bit more effort to find lighttpd documentation.

Some little things that I have picked up for lighttpd:

lighttpd version:

> lighttpd -v

lighttpd version and supported features: (note: that is a capital V)

> lighttpd -V

Using Apache to forward requests to lighttpd? Lighttpd will see that all incoming requests have the IP of the Apache proxy. There is a module mod_extforward which will extract a real IP from the X-Forwarded-For header. Add these lines in the appropriate locations to your lighttpd.conf file:

server.modules = (
    ...                      # (other modules)
    "mod_extforward",        # change x-forwarded-for IPs into real IPs, 
                             # load after mod_accesslog
)
extforward.forwarder = (
    "127.0.0.1" => "trust"   # where 127.0.0.1 is the IP address of the proxy
)

You can use variables in lighttpd.conf:

server.username = "myusername"                  # lighttpd configuration option
var.basedir = "/users/home/" + server.username  # declares a variable called <em>basedir</em>
server.document-root = basedir + "/www/"        # equal to <em>/users/home/myusername/www/</em>

Set a different server.document-root depending on the host:

$HTTP["host"] == "www.example.org" {
    server.document-root = basedir + "/www/www.example.org/"  # basedir is our variable
}

Redirect people to a single canonical web address (in this example http://example.org/blog/candy-is-yummy will redirect to http://www.example.org/blog/candy-is-yummy):

# make sure to include the mod_redirect module
$HTTP["host"] == "example.org" {                 # if host matches "example.org" then...
    url.redirect = (                             #   if the URL matches ^/(.*)$
        "^/(.*)$" => "http://www.example.org/$1" #   redirect to http://www.example.org/$1
    )                                            #   where $1 is what was captured by the
}                                                #   the parenthesis (.*)

^/(.*)$ is an example of a regular expression. Specifically, lighttpd uses PCRE. Instead of equality, ==, you can also test for inequality with !=. If you want to use regular expressions in the match conditional, you can use =~ and !~ for equality and inequality respectively (this is useful for paths):

# make sure to include the mod_access module
$HTTP["host"] == "www.example.org" {
    server.document-root = basedir + "/www/www.example.org/"

    $HTTP["url"] =~ "^/private/" {  # if url starts with /private then...
        url.access-deny = ("")      #   deny access to URLs that end with ""
    }                               #   (i.e. deny access to all URLs)
}

If you use the regexp conditionals remember that many symbols have a special meaning. The '.' (period) is a common example, as it has the special meaning of "match any single character". You can escape it by prepending a backslash: '\.'

What is duck typing?

richardwb — Tue, 27 Jan 2009 14:12:00 -0800

I found that when I started dabbling in Python that it was a bit hard to get a grasp on what duck typing actually is. You hear that it achieves polymorphism without inheritance, but that really explains very little. I have a C++/Java/C# background and it took a bit of time before that wonderful epiphany came, where all of a sudden I seemed to get a good grasp on what the concept actually is.

From the Duck typing article on Wikipedia we find that the term comes from the phrase "If it walks like a duck and quacks like a duck, I would call it a duck."

That makes perfect sense now, but it definitely didn't help further my understanding when I first came across it.

Perhaps the best way to explain would be with some code. I'm using Java here because it's wordy enough that it's understandable even if you don't know the syntax. For this "real world" example we will be designing that ever so classic "real world application of object oriented programming": the hierarchy of vehicles.

So suppose we have an existing Driver class that will drive our vehicles for us, as long as we provide the gas(), brake(), turnLeft() and turnRight() methods. In Java this would likely be expressed as an interface:

public interface IDriveable {
    public void gas();
    public void brake();
    public void turnLeft();
    public void turnRight();
}

And then we would have a class that implements that interface, for example:

public class Car implements IDriveable {
    public void gas() {
        System.out.println("Vroom vroom");
    }
    public void brake() {
        System.out.println("Screeeechhhh!");
    }
    public void turnLeft() {
        System.out.println("Left");
    }
    public void turnRight() {
        System.out.println("Right");
    }
}

And the Driver class would be similar to:

public class Driver {
    public void drive(IDriveable vehicle) {
        vehicle.gas();
        vehicle.turnLeft();
        vehicle.brake();
    }
}

And the main class:

public class Start {
    public static void main(String[] args) {
        Car c = new Car();
        Driver d = new Driver();
        d.drive(c);
    }
}

Sample output:

Vroom vroom
Left
Screeeechhhh!

This is standard OOP stuff, where as long as our class implements the IDriveable interface, it'll be driveable by the Driver class. If the class does not implement that interface, the code will not even compile.

If we bring duck typing into the picture, things change. Instead of having a defined interface (IDriveable) which must be implemented, all we require is that a given class implements the specific methods needed. There is no strict interface. In Python our code would look like:

class Car:
    def gas(self):
        print "Vroom vroom"
    def brake(self):
        print "Screeeechhhh!"
    def turnLeft(self):
        print "Left"
    def turnRight(self):
        print "Right"

class Driver:
    def drive(self, vehicle):
        vehicle.gas()
        vehicle.turnLeft()
        vehicle.brake()

c = Car()
d = Driver()
d.drive(c)

Which produces the same output as above.

Let's add a new class to the Python code:

class Pencil:
    def gas(self):
        print "Scribble scribble"
    def turnLeft(self):
        print "Left pencil turn?"
    # note that turnRight is missing!
    def brake(self):
        print "PUT YOUR PENCILS DOWN"

Although Pencil having these methods makes absolutely no sense, we could pass this to the drive() method and there will be no errors. Yep, even though Pencil doesn't implement turnRight(), because turnRight() is never called, all this code will run, error free!

We have a Pencil that can gas(), turnLeft(), and brake(), just like a Car. What is the difference between them, as far as this code is concerned? None!

This is what duck typing is. If a class acts like another class, it can substitute for that class. There's no need for there to be strictly defined relationships between classes.

MapVirtualKey(), GetKeyNameText(), and a story of how to get proper names for the arrow keys

richardwb — Sat, 20 Dec 2008 14:50:00 -0800

So let's say you are currently storing and using virtual key codes to handle keyboard input for a game. You decide to let your users customize their keys, so you go ahead and write some key configuration code. This requires that you map virtual key codes to key names.

Luckily, Windows provides some functions that do exactly what you want! Essentially you use MapVirtualKey() to get a scancode for that key and then pass that scancode (left-shifted by 16) into GetKeyNameText().

Some minutes later you finish your code and you go to test it. You hit the A key and you see 'A'. The 5 key outputs '5'. Even the Backspace key outputs 'Backspace'. It works as expected.

Then you hit one of the arrow keys and your code spits out 'Num 8'. It's right yet it's wrong.

Michael Kaplan has a blog entry that describes a recent update to the MapVirtualKeyEx() call:

MAPVK_VK_TO_VSC_EX:

Windows Vista and later: The uCode parameter is a virtual-key code and is translated into a scan code. If it is a virtual-key code that does not distinguish between left- and right-hand keys, the left-hand scan code is returned. If the scan code is an extended scan code, the high byte of the uCode value can contain either 0xe0 or 0xe1 to specify the extended scan code. If there is no translation, the function returns 0.

Unfortunately this doesn't help much as Windows XP is still used by a majority of users. However, this does imply that the current MapVirtualKey[Ex]() call does not specify the extended scan code. So if we just set the extended bit for some characters we may end up with a function similar to this:

std::string GetKeyName(unsigned int virtualKey)
{
    unsigned int scanCode = MapVirtualKey(virtualKey, MAPVK_VK_TO_VSC);

    // because MapVirtualKey strips the extended bit for some keys
    switch (virtualKey)
    {
        case VK_LEFT: case VK_UP: case VK_RIGHT: case VK_DOWN: // arrow keys
        case VK_PRIOR: case VK_NEXT: // page up and page down
        case VK_END: case VK_HOME:
        case VK_INSERT: case VK_DELETE:
        case VK_DIVIDE: // numpad slash
        case VK_NUMLOCK:
        {
            scanCode |= 0x100; // set extended bit
            break;
        }
    }

    char keyName[50];
    if (GetKeyNameText(scanCode &lt;&lt; 16, keyName, sizeof(keyName)) != 0)
    {
        return keyName;
    }
    else
    {
        return "[Error]";
    }
}

std::map access violation (or not)

richardwb — Sat, 11 Oct 2008 18:42:00 -0700

I just spent some time tracking down this fun little bug:

I use a mix of std::map and Boost.Function to reduce the ugliness of the Windows message loop. Everything is working just fine, until I make a couple of changes and all of a sudden one of my std::maps is throwing an exception in the destructor:

Access violation reading location 0xccccccd4.

In this code in xtree:

#if _HAS_ITERATOR_DEBUGGING
    void _Orphan_ptr(_Myt& _Cont, _Nodeptr _Ptr) const
    {       // orphan iterators with specified node pointers
        _Lockit _Lock(_LOCK_DEBUG);
        const_iterator **_Pnext = (const_iterator **)&_Cont._Myfirstiter;
        while (*_Pnext != 0)
        {
            if ((*_Pnext)->_Ptr == _Myhead
                || _Ptr != 0 && (*_Pnext)->_Ptr != _Ptr)
            {
                _Pnext = (const_iterator **)&(*_Pnext)->_Mynextiter;
            }
            else
            {       // orphan the iterator
                (*_Pnext)->_Mycont = 0;
                *_Pnext = (const_iterator *)(*_Pnext)->_Mynextiter;
            }
        }
    }
#endif /* _HAS_ITERATOR_DEBUGGING */

Of course, that is suspiciously close to 0xcccccccc, which is used by the debugging runtimes to mark uninitalized stack. (This will be important later.) In any case I go through the usual debugging motions, making sure I'm not putting anything funny into my map container and that values inside the container are what they should be.

So, what was the cause of this bug? It was a result of the change I was making earlier; this is the original code:

LVITEM itemText;
ZeroMemory(&itemText, sizeof(itemText));
itemText.cchTextMax = MAX_PATH;
char buff[MAX_PATH];
itemText.pszText = buff;
SendMessage(listViewHandle, LVM_GETITEMTEXT, index, reinterpret_cast<LPARAM>(&itemText));

And I changed it to use the ListView_GetItemText macro, which is far more succinct:

char itemText[MAX_PATH];
ListView_GetItemText(listViewHandle, index, 0, itemText, _countof(itemText));

No problem yet, right? Ready for the punchline?

I left this line in at the bottom:

SendMessage(listViewHandle, LVM_GETITEMTEXT, index, reinterpret_cast<LPARAM>(&itemText));

For those lucky folks who aren't familiar with all the wonderful intricacies of Windows programming:

SendMessage() is a magical "do all" function that sends a message to a particular window, with WPARAM and LPARAM values tagging along. In this case, we're sending a message of LVM_GETITEMTEXT to the control denoted by listViewHandle. The MSDN documentation for LVM_GETITEMTEXT states that it wants WPARAM and LPARAM to be:

WPARAM : iItem - Index of the list-view item

LPARAM : pitem - Pointer to an LVITEM structure.

My LPARAM, itemText, is no longer an LVITEM structure (it is now a char array of size MAX_PATH). There is absolutely no way that the LVM_GETITEMTEXT code can know that I've made a colossal (yet tiny!) mistake, so I assume that it dutifully casts itemText into an LVITEM structure and does the right stuff with horrendously wrong data. Tada, stack corrupted.

Notice that the source of this bug appears nowhere near an std::map. It is, in fact, in a different function (and a different class and a different file...) entirely! This is why memory corruption errors are one of the most feared bugs around.

Conclusion: if std::map is dying in clear() (or ever, frankly), you may very well be doing something bad, memory wise.

Proctors in Calgary

richardwb — Tue, 11 Jul 2006 16:24:00 -0700

"Proctor" is the fancy word for those people who administer exams and tests. If you're taking distance education courses, you may need to find one. I had to find a proctor a year ago to make up for an exam I missed, and it took some time to figure out how to even begin. (A search for "calgary proctors" did not bring up very much...)

I finally found some information on proctors by calling the librarians at the Castell Central Library. So...my tip for finding a proctor is to call the library in your city.

In case there are any other Calgarians who need a proctor, here’s some information on proctors from 2005, along with per exam proctor fees:

Athabasca University	(403) 263-6465	$40
University of Calgary	(403) 220-5524	$80
SAIT	(403) 210-4283	$50
Rocky Mountain College	(403) 284-5100	$20

Linksys BEFSR81 disconnects

richardwb — Tue, 11 Jul 2006 12:46:00 -0700

For the longest time I had this constant problem with my router, a Linksys BEFSR81 (the 8-port version of the BEFSR41) constantly disconnecting the computers connected to it. It wasn’t the Internet connection going down, since I had a computer that was directly connected to the modem as well, and it never had any problems.

So of course when troubleshooting something like a router, you go and get the latest firmware. No luck there. I also tried resetting the router, restoring default settings, changing the ports used on the back, and so on.

Finally, I tried giving one computer DMZ access (I’m not forgetting about the security concerns raised by doing this). It worked. No more disconnections for that computer, and for now, I’m satisfied.

Posting this in case it comes in handy for anyone else experiencing disconnection problems.

[2008 Addendum: The only real solution to this problem is to get a better router. The BEFSR81 is at least 7 years old now.]

University of Waterloo cheers

richardwb — Sun, 30 Apr 2006 17:23:00 -0700

Here are some cheers from the University of Waterloo Math orientation (which I went through 4 years ago). These include such classics as Math Rocks, The Biggest Tie, How's the Tie, and Water Water Water. I'm not sure why, but my personal favorite is The Biggest Tie.

Math Rocks

M-A
M-A-T
M-A-T-H
Math Rocks!

Say it loud
Say it big
Let it boil in your blood, feel it zag as you zig
We survive
All the knocks
We have pride when we cheer and we think Math Rocks!

One group chants the first verse while the other group chants the second verse, at the same time. The chants should converge on the phrase "Math Rocks!".

The Biggest Tie

The biggest tie
I ever saw
Was hanging from
The MC wall

I looked at it
And then I knew
I wanted to be
A Mathie too

I stole the tie
It made me laugh
Because it's true
That I love Math

And so began
My new journey
To be part of
Math faculty

My school is sweet
SWEET LIKE A FOX!
Because I know
UW Math Rocks

Sung to the tune and style of The Littlest Worm, The Princess Pat, or I Met a Bear.

Water Water Water

Water water water!
Loo loo loo!
Water water water!
Loo loo loo!
Water!
Loo!
Water!
Loo!
Water water water!
Loo loo loo!

One group (typically the orientation leaders) starts the cheer by yelling "Water water water!". The other group then replies with "Loo loo loo!". It continues in this fashion until the end of the cheer.

There are more Math cheers in the ~~Math Handbook~~ Math Orientation 2008 guide.