Customer Reviews

Cross-Platform GUI Programming with wxWidgets

5 star:		(7)
4 star:		(11)
3 star:		(3)
2 star:		(4)
1 star:		(1)

 

 

"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.

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.

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.

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???

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.

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.

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 reasonably 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.

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.

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.