As a book for learning a topic, this one is wanting. It doesn't develop the numerous code snippets into whole programs, leaving the reader uncertain how they actually work. It states much, explains little. As others have pointed out, there are many books on related programming topics that do a good job of bringing a novice or modestly experienced programmer up to speed - one must be a well versed programmer to benefit from this book.

The book itself is the only one on this matter. It is well written with tons of examples. I would consider this book as a must for those who are writing the
Cross-Platform GUI using open source libs. The book came very fast and in a perfect condition. I would highly recommend buying books from this seller.

This book is very complete.
It explains the basics and all the way through the most complex capabilities of the wxWidgets library.
The CD included contains tons of useful code and additional utilities.
Very good product - I recommend it.

The definitive book on wxWindows (now wxWidgets). This can be found online but I do like the printed books better.

Covers mostly everything a novice (to wxWidgets) needs to get started on multi-platform applications.

Good reference books seem to be hard to come by lately. Good reference books give you insight and a fuller understanding of the inner workings of whatever their subject matter might be. This is not the case of this book.

You need "Cross-Platform GUI Programming with wxWidgets" only because the standard wxWidgets documentation is so very crude (no one to blame there, except each and every one of us for not contributing better documentation) and because its source code (as well as part of the core development team, I dare add) is so unfriendly to tools like Doxygen. Smart's book is what the wxWidgets online documentation would have been in a perfect world. No more and no less. The author has done a good job compiling and explaining with sample code the basic usage of most wxWidgets components, but you will not emerge a wxWidgets guru after reading this book. For example, just half a page is dedicated to explaining the by no means trivial wxObject class.

You will be disappointed if you are expecting a mind-opening book, the likes of Petzold's classic "Programming Windows", or Prosise's "Programming MFC", or Wall's "Programming Perl" (just to name a few excellent books from a time when the pace of technology was slower and authors still had time to put together great tutorial/reference works), but having a book like this is probably better than no book at all and buying it is a way to support the project, after all.

Good reference books seem to be hard to come by lately. Good reference books give you insight and a fuller understanding of the inner workings of whatever their subject matter might be. This is not the case of this book.

You need "Cross-Platform GUI Programming with wxWidgets" only because the standard wxWidgets documentation is so very crude (no one to blame there, except each and every one of us for not contributing better documentation) and because its source code (as well as part of the core development team, I dare add) is so unfriendly to tools like Doxygen. Smart's book is what the wxWidgets online documentation would have been in a perfect world. No more and no less. The author has done a good job compiling and explaining with sample code the basic usage of most wxWidgets components, but you will not emerge a wxWidgets guru after reading this book.

You will be disappointed if you are expecting a mind-opening book, the likes of Petzold's classic "Programming Windows", or Prosise's "Programming MFC", or Wall's "Programming Perl" (just to name a few excellent books from a time when the pace of technology was slower and authors still had time to put together great tutorial/reference works), but a book like this is definitely better than nothing. And it's not like if you have a choice: do a search at Amazon for "wxWidgets" and see for yourself!

This is the only wxWidgets book so far so it's not like you have many choices! I read this book twice and then the official documentation and I still use this book as a reference sometimes. This book has a TON of errata though so the next release hopefully they are more careful with editing...

I highly recommend getting this book if you want to learn wxWidgets and cross-platform application writing!

I have found this book extremely helpful in getting started on my first project with wxWidgets. It is easy to read and is written in a straight forward manor. It explains the concepts behind wxWidgets and covers the basics pretty well. My only criticism is that if something is hard to do, the book may give a hint on how to get started, but does not have many complex examples.

It covered alot of things, but I thought it was a little bit too vague. I would of rather liked to see more coding then words explaining the coding. A complete script for example would of been nice instead of just code snippets.

It covered alot of things, but I thought it was a little bit too vague. I would of rather liked to see more coding then words explaining the coding. A complete script for example would of been nice instead of just code snippets.

Looking at the Table of Contents we find a good start: (1) Introduction, and (2) Getting Started. Then we go in a direction I find illogical: (3) Event Handling, (4) Window Basics, (5) Drawing and Printing, (6) Handling Input, and (7) Window Layout Using Sizers. I believe that a better order would have been (4), (7), (3), (6), (5).

Due to the libraries use of MACROs (which are not well described within the text), many other issues arise. One of which is variable visibility. C/C++ scope is simple, but due to wxWidget's use of MACROs the accessing of variables can become difficult. There is a validation class which has only two type of validators, one for text and a generic one which does no validating at all. Those validators can also handle data transfer, but the transfer happens on an "OK" event back to the widget which is being destroyed. Useful?

Otherwise a decent introduction to the language and its promises. Good luck with more support from on-line documents and the mailing list! I have not found the answers/support that I seek.

I found this book to be very usefull in guiding me into developing with wxWidgets. It covers a lot of the major aspects one would need to develop professional cross-platform applications with wxWidgets.

I don't have many complaints as far as how the book was authored or put together, but I will admit i've experienced better readings in my day. I'm giving it a 4 star rating because I think wxWidgets is a open-source cross-platform framework at its best, overall the documentation and support is great.

So if you're considering learning wxWidgets this is the definately worth the money to get you on your way.

For someone first learning wxWidgets, this book is an excellent starting point. It clearly explains each part of the library, from the windowing system right down to the threading and socket layers. In addition, the numerous examples allow the programmer to quicky get up to speed on the concepts presented in each section. The book's only weakness is that it is not a comprehensive reference guide, and must be supplemented by the online help files during everyday programming. For someone just starting out or needing a refresher course on the capabilities of wxWidgets, this is an excellent book.

Provides a rapid introduction to wxWidgets with detailed explanations of how to get apps up and running. Follows up with chapters that get into multithreading and sockets and again provides code examples that work fine.

My only reason for not giving 5 stars is that the author pushes a commercial program "DialogBlocks" pretty hard as opposed to a fully open source implementation.

A very good book. Analytical and Comprehensive. Even if you are a novice in programming the author achieves to make you understand how to develop apps with wxWidgets. Experienced programmers will find it useful for its great span of advanced subjects. All given in a well presented package. A must have. Support the Open Source Application Foundation.

The Good:

This is (currently) the only book on wxWidgets (formerly wxWindows). The book is packed with information. All of it relevant, all of it covering as much as they could cram into one book and not make it into a tome so heavy that you couldn't lift it. As a reference book it excels in that it does present everything you need in order to get up and running.

The Bad:

As a reference book - it is not as well laid out as many of the other reference books I've read and/or bought. Many of the standard methods to present data are not used. That is to say: In most reference books a section is well delineated whereas in this book the terms and explanations for those terms are not separated in such a way that it is obvious to the reader that they have stopped talking about one subject and begun another. For example:

Page 121:


Use Check to toggle a check or radio item on or off, passing the menu item identifier and a boolean value. Use IsChecked to get the checked status.
Delete deletes a menu item specified by identifier or by wxMenuItem pointer....


In other books the above would appear as:


Check Used to toggle a check or radio item on or off,
passing the menu item identifier and a
boolean value.

Example: ......

IsChecked Used to get the checked status.

Example: .......

Delete This deletes a menu item specified by an identifier
or by the wxMenuItem pointer....


And so on...

This isn't a big complaint but it does make the book hard to read sometimes. Especially when you have thirty or forty specialized words. You wind up hunting for where the words are that you need in order to do anything. Which is why other companies developed the above method to layout specialized words you had to know.

The ugly:

I haven't finished reading the book but I did skim through the rest of it. The bad is broken up into two things: size, helpfulness. Here they are:

Helpfulness: The book is very through in going through every special word but they really do not provide full examples of how to use the various words. That is to say that there are code snippets but not complete code. What this equates to is that there isn't a complete example of how to link everything together anywhere in the book. So you are expected to know how to do this. Yet, even with DialogBlocks you wind up going "How do I make my About dialog show up?" Because there just isn't an example on how to do this. Even the Acme example which comes with DialogBlocks doesn't show you how to do this simple task. Instead, the reader is left to flounder UNTIL you find out how to go to the mailing list. (And I have a pet peevee about that.) With PHPBBS et al being out there, (not to mention SourceForge.net) it would be better if they set up a BBS to handle such things as example programs. With a mailing list the information scrolls by and is eventually lost if it isn't reposted. With a BBS you set up an area to handle the FAQs, put in a few examples of how to use DialogBlocks, have a "Q&A" or "Bug" area, and most importantly - if something is posted that really is important - you can just move it over to a permanent location such as the FAQ so the information isn't lost.

Size: The book on wxWidgets tries to cover too much area. Like books on Windows, X11, Unix, Macintosh, and others - it needs to be broken up. The author himself says that there was too much to cover in wxWidgets to get it all into the book. They should have, at that point, sat back and gone "Maybe we should break it up into smaller books." They would have been right to do so. By trying to cram so much information into one book they have made it hard to read and they sacrificed putting complete examples by just providing snippets. This is not to say that EVERY SINGLE COMMAND has to have a complete code example. But each command should have at least a one line example of how to use it and a complete example should be given at the end of each chapter on how to use these commands. Nothing big - just something. Like maybe build each section of a complete program in each chapter and then give the entire program at the end of the book.

I found this book pretty disappointing. It covers very little more than the online manual and most of the examples are total cop outs. They either tell you to just review the example that comes with wxWidgets or offers a really terse example that more than likely doesn't really show anything.

For example, I was really hoping that this book would show me how to print a custom drawn window (or even something like a listview). Instead its printing example show how to use the high level functions, but then says that the developer needs to add most of the real printing logic to their own code themselves (and of course shows not even the slightest example of this). Gee, thanks a lot!

All in all, I saw nothing new in this book that I haven't read on their website. The author makes a point that this book is not a reference, but I have to add that it isn't much of a "here's how to do this" book either. It's more of a PR book showing the merits of wxWidgets and an intro book for novices who don't have access to their website, rather than a useful example or reference book to help out those already using this library.

I love the wxWidgets book. Informative, well outlined, and with an excellent index with plenty of information for new wx programmers or people who has been using wx for awhile.

I had written several wxWidgets apps prior to buying the book, but have learned many new techniques to improve my newer programs and have a better understanding of how the wx API works; the docs are not always clear.

My only complaint is a lack of XRC information. It is barely touched upon though I find it crucial for any program requiring more than an extremely basic GUI. No one wants to integrate C++ code generated by other programs into their code-base. None of the programs are ever likely to generate code that conforms to your coding style, but with XRC, you can compile your GUI code into an array and never worry about it.

The one plus in XRC though was its discussion of the wxrc compiler which I hadn't known about before the book. This was a big help in removing my XRC files from my app distributions, which are problematic in cross-platform development. Now that I can compile them into my code, things are much nicer and easier.

If you are looking for help with XRC and XRC only, avoid this book. Otherwise, buy it quickly. You won't be disappointed.

The surprising aspect of the book is that it is the only book devoted to wxWidgets, though the latter has been around since 92. One might have expected other texts by now. Perhaps this suggests that wxWidgets is not that heavily used? Or maybe since it was all open source, it lacked an advertising budget. So unlike Java or C#/.NET, there was no corporate sponsor to underwrite books on it.

Anyhow, this text shows wxWidgets to be a complete graphics system. Portable across all major current operating systems. All the [remaining] unixes and linux. Plus Microsoft's operating systems. And don't forget the Mac or the PalmOS.

A reader might immediately ask, why not just use Java, instead of C++ and wxWidgets? Well, it comes back to the efficiency issue. Java excels on the server side of web applications. But the authors explain that there is still a performance penalty compared to C++, which compiles down to native binaries. They also point out that the graphics approach in wxWidgets is to use the native widgets whenever possible. This produces UIs that the user in those operating systems will be familiar with. Whereas Java tends to go with non-native widgets.

The length of the book reflects the reality that any comprehensive graphics system these days has to cover a lot of ground. Drag and drop, internationalisation, multithreading, dialogs and much more.

In programming complexity, it seems simpler than the XWindows toolkit, which was wretchedly awful to learn.

This is, in my opinion, a great and much-needed book on wxWidgets. To date it is the only one. The preface says, and I agree, that it is "accessible to developers with a variety of experience and backgrounds". That said, there will be a steep learning curve for people with limited relevant experience (particularly of C++). Such readers will require further support, from people, ideally both in person and from Internet resources such as comp.soft-sys.wxwindows.

For experienced programmers, even those with experience of wxWidgets, the book will be very useful to learn aspects that they have not yet explored.

The book is also invaluable as a reference text, for its links to related projects and software, and the resources on the CD.

wxWidgets is an application framework for developers who want to develop very good-looking applications for Linux, Windows or Mac. The fact that your application can be re-compiled for any of the three operating systems is definetly an attractive plus. My development is mainly for Linux, and when I first ran accross wxWidgets, I was amazed at how quickly I could get a simple application going in under an hour. Compiling the library is as easy as issuing a few commands from a terminal window, changing to the samples directory, and running make under the minimal sample directory.

Bear in mind that developing applications is not for complete beginners. You should know C/C++ already, and be reasonably familiar with your OS and compiler. That way, following the examples given in the book, and reading the source code from wxWidgets samples directory, can get you up and running in a minimum of time. I came from a C background, but I had a reasonably complicated inter-airport messaging system for a local goverment authority working in two weeks, with the help of a serial communications library contributed by another wxWidgets user.

The book comes with a CD full of useful tools and community contributions. I have yet to see, in my 30+ years of programming and project management, a framework as complete as wxWidgets. The support from other users is extraordinary, and you can often be talking to the original developers who are more than willing to help you get going. The fact that it is open source ensures this fantastic library will always be improving.

This book is something I was awaiting for a long time. It is definetly worth the price (and then some).

I really liked this book. I have been packing it to and from work to home just about everyday because I'm working on a project at home as well. It makes an excellent reference although I wish some sections were a little longer, like the sizer section. This book isn't for someone brand new to C++ but it is great for someone who knows the basics of C++ like pointers, inheritance, classes and the like. You don't need to know how to use templates, do callbacks, do slot mechanisms, or the STL. I do suggest paying strong attention to the Hello World sample and acquaint yourself with the event table macro system and the basic wxwidget controls like button, checkboxes, text boxes, and the wxstring class. I have been working for a little while with wxwidgets, trudging through the online help and with some help from GUI builders like wx-dev-cpp (free) and dialogblocks (from the author at a very reasonable price). The book helps a lot and the index and TOC are well arranged. The CD contains a lot of extra software, but I would skip trying to learn command line compilers and use a GUI IDE to start with, and wx-dev-cpp (just look on google) pulls all this together for you so you don't have to try and figure out ANYTHING other than wxwidgets; I like taking things in babysteps instead of diving into the maelstrom of setting up a complete environment. Overall this book will serve you well if you are entering the world wxWidgets, despite a wart or two here or there.

Like was already stated in another review, the section covering how to set the library with compilers is bad. It also shows that wxwidgets is not ready for prime-time. Too many hours are wasted just setting it up.

Other then that the book itself is pretty decent, but it assumes too much. First off, the book claims that a novice could use this book while learning C++. Not likely. There are too many liberties taken, like putting the first example program in a single file. How is a novice supposed to know what goes in what header file? There is no excuse for poor programming practices, ever.

I think the book is easy to read, and is well laid out. I am not a novice, but not yet a professional. I am an honor student in my senior year of my computer science program, specializing in network security and real-time systems. I am more then competant in assembly, c, c++ and java. The book seems to be written for someone of my experiance, but that goes against their claim of who the book is for. To the people who say this book is not for beginners, you are correct. However, the stated audience of the book is novice to professional. That always sends up red flags, you try to write to everyone and most of your audience will be left out at one point or another.

A key part missing is how to make .exes reasonably small, while keeping them efficient. wxWidgets creates some of the biggest executables you can imagine. The first example program compiles to 2.4 MB as a debug exe and with .vs .net set to compile for size, the release exe is 800KB!!! That is insane, and another sign that wxwidgets is not ready for prime-time. There are ways around it, but the book doesn't really mention the problem or how to fix it. I think the fact that the creator of the library also wrote the book, is the reason negatives about the library and how to overcome them was left out. It is hard to be honestly critical of your own work.

Overall, the book needs a lot more polish and attention to detail. Too many assumptions about what the reader might or might not know makes it an uneven read. To be fair, the co-author Kevin Hock, admitted that maybe the sections on setting it up was not focused in its goal on the main wxWidgets message boards. Another bonus is that he answers question on the message board, which is pretty impressive. So obviously the authors care about the book and subject, so the odds of a revision cleaning up all the problems in the book are pretty good. If you need to learn a cross-platform GUI library, I would recommend this book over QT, even though the QT book is superior.

Finding a decent cross-platform GUI library is rough. There are two main libraries, for C++. QT, very slick and polished, and is small and efficient. A bit harder to learn then wxWidgets and unless you want to be forced to release your work as open source, you will have to pay around $1600 for the library, stupidly expensive. wxWidgets, easy to learn, but very primitive. Besides the other problems already stated, the library does not play nice with IDE's. With each new project you create, you have to manually tell the compiler where to find the necessary .h and .lib files, and other settings. An approved workaround is make a copy of a prior project, so you have all the settings. That is inexcusable and screams of unprofessionalism. It is free and you can release your work however you like with no royalties. Given the differences, and the superiority of QT, I would still recommend this book and the wxWidgets library. Having the freedom to do what you like with your creation is a bonus that can not be overstated. Also Trolltech has proven itself to be greedy and arrogant. For $1600, you can get a lot of professional programming tools, that does far more then what QT offers, and can do what you like with your creations.

This book was co-authored by the creator of wxwidgets (Julian Smart). This raises the spector of a great deal of promise and peril. Promise because as the creator, he knows his creation better than most and so can lead you through the more arcane sidestreets, peril because as the creator he is too close to his creation and can assume his readers know his creation too well and thereby make many assumption, so explanation becomes about 'reminding' not exposition. He navigates these waters reaosnably well.

The CD contains a great deal of useful software (but don't expect too much accessible guidance on how to use it with wxwidgets-> particularly the open source software-> minGW, open watcom, etc...which is very ironic! since we are using open source because it is open source and wxwidgets is open source...but there seems to be little attempt at really working say minGW studio and wxwidgets together, event though minGW studio was built with wxwdigets-> minGW studio even contains a option to make a wxwidgets projects ->but that doesn't work. Left hand and the right hand aren't working toegther too well so it seems...but I digress)

However be aware that you may need to be familiar with the ins and out of you respective compiler to use wxwidgets. Compare this with C++ GUI Programming with Qt 3(isbn: 0131240722) and you'll notice an obvious difference. The QT book provides first up a walk through of how to compile not only their examples but your own. You are told how to set paths, how to build, etc. This book shows you how to compile their samples, but leaves you hanging with you own (perhaps we are supposed to modiy theirs??). They do talk about visual studios (old and .net -> ironic for an open source project and which begs the question, if I had those, why the hell would I use wxwidgets for GUI programming??? particularly when I can use QT or Kdevelop on linux as well? Though Trolltech seemingly has ended the honeypot usage of QT and is charging for it for windows development-> hence we're looking at wxwidgets instead I assume). So you will need to be well versed in the arcana of your compiler and know about makefiles and workspaces and so forth. DOn't expect too much useful guidance here. Now this can be frustrating because if you're looking to use wxwidgets you're probably wanting to make something, so you want to get into it and not have to troll thorugh masses of documentation to get compilage of your work. Prepare for documentation-> which, if you're like me, means you'll persist for a couple of hours and then think to hell with this...Which is disappointing because it taints this forever. Of course if you're a tinkerer, then this could be fun...in a masochistic sort of way...I'm not a tinkerer, and I don't like wasting time playing around with compilers and software...I want immediate functionality-> install and use. This does not give me that I'm afraid.

Personally I don't think this book is ready for prime time (a novice should be able to pick it up and get started with a minimum of fuss. I think it does need to clean up the whole compiling mess (and a serious mess it is: they seem to forget the truism: you try to be all things to everybody, you end up being nothing to anyone). The contents are great but they need to take a look at the QT book (from the same bruce perens series!!!!) and see how to document the process of building a project and compiling it.

Therein lies the problem: I have never used wxwdigets so I am a novice to its particular idiosyncracies. I am not a novice programmer-> having done the java, c, c++, c# thing for quite some years. However...this book does need to be more friendly toward those of us who use programming tools for a purpose, not because we don't have a life or treat a tool as the end in itself rather than a means to something else (i've got better things to do then have to wade through compiler documentation to get something to function as it should-> that's somebody else's job)...I fail to see how this (the timewasting and inefficiencies to get functionality out of it) makes me more productive and therefore would influence my choice to pursue wxwidgets???

"Cross-Platform GUI Programming with wxWidgets" from Bruce Perens' "Open Source Series" is the first and only book covering cross platform development using wxWidgets. wxWidgets is "a first-class, open source response to the need for portability in an increasingly heterogeneous computing world". It is a very mature library with over 13 years of active development behind it. Although primarily a C++ library, wxWidgets has language bindings for Python, Perl, Basic, Lua, JavaScript, Java, Ruby, Eiffel, C#, Haskell, and Euphoria and many of the techniques taught in this book could easily be adapted to any of these languages (provided you can read and understand C++). The authors--Julian Smart, Kevin Hock, and Stefan Csomor--are three of the primary developers of wxWidgets with Julian being the founder of wxWidgets.

Before I get into the actual review, please note that this book is for people who have a decent grasp of C++. You won't need to know advanced features such as templates and exceptions but having a decent understanding of memory management, pointer logic, OOP, and inheritance is highly recommended. You will not learn C++ while reading this book as it forgoes detailing language features that are used. Having an understanding of event based programming would be useful but is not required. I'd also like to note that I (the reviewer) have over two years of full-time, professional experience with wxWidgets and am an occasional patch contributor.

The book starts off at a fairly fast pace. I was worried they were glossing over too many details but many things I felt were lacking were covered in sufficient detail in later sections. It does not baby your intellect like far too many programming books do in the first few sections. There is a full, working GUI application within the first 20 pages (and you don't see actual code until page 16. The coverage of Event Handling is complete although the coverage of the difference between Command events and regular events could have used a bit more detail.

Windows are covered shortly thereafter and the coverage was basic but essential and with the sheer size of the base window class, this is all you can really ask for. Every noteworthy issue seems to be covered (as well as a couple I didn't know about). I recommend anyone reading Chapter 4 have the wxWidgets' documentation open to the wxWindow class while reading. The book covers nearly all of the window types you'd ever use and has specialized details on each.

All of the basic (and several of the advanced) controls are covered in a similar fashion to the wxWindow section which I consider enough to get by as well as give you a nice overview of what you have in your toolbox to work with while designing. Menus, Toolbars, and Statusbars are given enough pages to get you going and cover most application's needs.

Drawing is covered in excellent detail with many "gotch'a" that I hit while learning wxWidgets explained and solutions provided. The Printing architecture itself is a bit lacking in necessary examples. 3D graphics using wxGLCanvas is given a brief cameo but no real coverage but if you know OpenGL, this short coverage is enough to get you going.

User Input through the keyboard, mouse, or joystick is covered but only small examples are given. The systems themselves are well designed though so picking up on any missing details should be easy.

Sizers are finally covered in chapter 7. Personally, I think they should have been covered way earlier (before controls were covered in-depth). Sizers are such an integral part of GUI design and are almost always the biggest hurdle people hit learning wxWidgets (taken from both my personal learning experience as well as my observation while helping out in the wxWidgets' forum and IRC channel). They receive more of a reference style coverage rather than a tutorial which I feel is the most disappointing part of this book (look up the sizer introduction by Brian Victor for a nice, example packed introduction to sizers which compliments the coverage in the book quite well).

The section on standard dialogs is complete and adequate while maintaining brevity. The "Writing Custom Dialogs" (chapter 9) was nice as it showed how to write a dialog that covered a wide range of platforms (including Smartphones). The often mentioned XRC resource system is covered in short detail but it should be enough to get someone interested in using XRC off the ground.

Working with images has a nice section dedicated to it. The standard datatypes section gives lots of pointers and tips which I wish I had when I was learning wxWidgets. wxDateTime has so many considerations to take into account and I don't hold it against the authors for only covering a few of the most prominent.

The wxWidgets' Filesystem section gives plenty to get people started with handling the intricacies of working with files in a cross platform way.

I enjoyed the section in Internationalization and learned a few things I didn't know about. It also covered Unicode in much more detail than the official wxWidget's manual ever does.

Multithreading is a complicated issue and though the book's coverage is decent, you'll definitely want to refer to another source if you plan on using something as potentially dangerous and complicated as multithreading (particularly when used in a event based GUI system).

Socket programming with wxWidgets has a decent number of pages dedicated to it and it was all new to me. Unless you are doing some complicated socket work, I'd say the book covers enough to get a nice, cross platform socket system going.

One of the best sections was the chapter on using wxWidgets' Document/View architecture. The wxWidget's manual is a bit lacking in describing the roles of all the various classes and when I was trying to decipher it for myself I vowed to not let anyone else suffer through trying to figure it all out (I have a half written tutorial to prove it ;)). Now, with this book out, no one will have to spend all of the time I spent learning to take advantage of this powerful and time saving system.

Appendix A covers installing and building wxWidgets (another major hiccup for new users). I recommend reading and following this before even beginning to read sections that cover actual coding. Appendix E has a lot of nice references to community provided classes, many of which I use myself regularly.

wxWidgets is a powerful system which had--until this book came out--a steep learning curve and a lack of useful resources for learning. Apart from the sizers chapter, I have no major complaints and anything I've noted should be considered minor. This book is long overdue and it is shocking that a library as powerful as this one went so long without one. You'll leave this book with a good understanding of this wonderfully encompassing and powerful library.