Only in some circumstances. Over the past year, I have evolved a relatively complicated telemetry front-end C++ application that used to use ATL on Windows, into one based on wxWidgets. It now compiles and runs on Windows, OS X, Linux locally, and Linux over X. It has been an education, to put it mildly. Many concepts that work great on Windows simply don’t work in other places, and optimizing the performance for multiple platforms is a process that is STILL going on. Some of the wx operations that you’d think are being done by your graphics card are instead being translated, simulated, and translated back. So, “efficient” is a word that means different things in different contexts.
If you’re doing a lot of off-screen drawing, you MIGHT want to investigate a separate library dedicated strictly to pixel operations. It depends on how much you’re doing.
Well, to put things in perspective in this particular case, my last project (another paint tool on windows) I made with Pyglet using ndarray transformations for the tools, which all worked well except for the floodfill. On windows it takes 55 seconds for it to fill a 2000x2000 area, whereas wxPython takes 1 second for the same operation. It may provide different results under different circumstances, but I can’t help but see that as an improvement. 
You may want to give libgd a try. It’s a venerable old C drawing lib, and though it’s been updated to support ani-aliasing, alpha, etc, the old simple 8bit drawing is all still there, and robust and fast.
Thanks for mentioning it! I’ll be sure to give it a look, I can always use more API’s to play around with, heh.
If Windows is your only target, this might do the job.
Currently windows is my only target, though there may be a linux distro somewhere in the distant future. As it turns out my little array trick works pretty good, although there were a few caveats. As it turns out when drawing an image with alpha, the alpha pixels stack with previously drawn images eventually turning them into solid colors (visually anyway). So I did a dc.Clear() before each draw call but that creates seizure inducing flicker on every draw. So I went back and simulated the alpha on a solid rgb bitmap so I wouldn’t have to clear the background and that fixed the flicker, although if you paint too rapidly there’s still a noticable delay.
Somewhere between all that I also decided to try a glcontext and came across [PygletWX] to plug in a pyglet subclass of a wx.Panel. The results were actually alot better than I was expecting, and the two work pretty well together. It ended up being the better of the 3, supporting full alpha, no flicker, and a rapid draw response. I’ve attached examples of all 3 approaches in case anyone now or in the future has any interest.
Alpha-Example.zip (18 KB)