Ben's Coding Log

This code gives constructor is inaccessible errors in createBar(...)  when you try to compile it:

namespace foo{ class Bar{ protected: Bar(int n); int numBars; public: friend Bar * createBar(int n); }; Bar * createBar(int n); } using namespace foo; Bar::Bar(int n) : numBars(n) { } Bar* createBar(int n){ return new Bar(n); }

The code below is the solution to the problem:

namespace foo{ class Bar{ protected: Bar(int n); int numBars; public: friend Bar * createBar(int n); }; Bar * createBar(int n); } using namespace foo; Bar::Bar(int n) : numBars(n){ } Bar* foo::createBar(int n){ return new Bar(n); }

This is acutaly the same problem as if you tried to compile the program below, but in the program below you get linker errors instead:

#include <stdio.h> namespace foo{ int bar(int n); } using namespace foo; int bar(int n){ return n + 42; } int main () { printf("%i\n",foo::bar(5)); return 0; }

The only difference in the example with classes is that it fails to compile, rather than link. It's a rather obvious bug in retrospect, but the syptoms sent me looking for typos, rather than namespace errors. The root cause of confusion is that the "using namespace foo;" line lets you remove the "foo::" from the front of the bar constructor and any bar methods, so it is reasonable (but wrong) to apply the same logic to the factory function.

So I was working with a multi-line EDIT control.  I wanted to set the tab stops to be 4 characters wide, instead of the somewhat unreasonable 8 character default. After a bit of Googleing, I learned the way to do this is by sending a EM_SETTABSTOPS message to the EDIT window.

So far so good, however the wparam and lparam for the message are a bit obtuse. The lparam is a pointer to an array of ints, and the wparam is the number of elements in the array. If you want all tabs in your control to be a constant size, you need to pass 1 for the wparam, and a pointer to an int containing the length of the tab stop for the lparam. The fact that the lparam is a pointer seems to trip people up quite a bit.

More confusing than that, though, is the units of the value pointed to by lparam. The documentation indicates that they are something called "dialog template units". A dialog template unit is linked to the size of the font, and changes whether you are talking about a horizontal distance or vertical distance. Horizontally, 1 DTU is  equal in length to 1/8 the average with of a character. Vertically, 1 DTU is 1/4 the average height of a character. [Link]

While working with the Windows API, I needed to display a child window over a parent window that was being drawn using OpenGL.

I was doing this because this was a program to assist my study of the Japanese language. I needed to be able to draw an arbitrary Unicode character, such as 私, at an arbitrary location. I also needed a text box control so I could enter text.

This was a 2D application with some continuously updated animation, and the problem I was getting was that the child window would flicker or not draw at all.

My first attempt to solve this problem was to use RedrawWindow function to try and force the child to draw over the top of parent window. This did not remove the flickering.

Finally I found the solution here: Win32 API: How to avoid flickering of basic window controls?

The solution was simply to add WS_CLIPCHILDREN to the parent window style flags when creating it.