WINBASEAPI DWORD WINAPI GetEnvironmentVariable(LPCTSTR lpName,
                                                LPTSTR lpBuffer, 
                                                DWORD nSize)

The getEnv method calls GetEnvironmentVariable to fill in the StringBuffer value with the value of the environment variable passed in by name. If the return value is 0, the environment variable doesn't exist and null is returned. If the return value is larger than the capacity (not the length) of the StringBuffer, the buffer is resized to the required capacity and the call is retried. Finally, the StringBuffer's value (its content) is returned as a String.
It is interesting to note that the auto keyword in the J/Direct import statement affects not only the lpName parameter when the function is called, but also the contents of the lpBuffer return value when the function returns. On Windows NT, the value is already expressed in Unicode, so no translation occurs. On Windows 95, the lpBuffer StringBuffer is translated from ANSI to Unicode automatically.

How do I pass a structure to a DLL function when I'm using J/Direct?

To declare a structure in J/Direct, you place a @dll.struct tag before a class declaration. The data members of the class are then mapped, in the order they occur, onto the structure. As shown in Figure 3, a POINT structure declared in this way is passed transparently to the GetCursorPos function, which takes a Win32® POINT structure. Since both structures contain 32-bit integers, the translation between Java Object and native structure is quite simple. But as you'll see in my answer to the next question, the VM's mapping job is not always so trivial.
The @dll.struct tag is necessary for two reasons. First, it directs the VM to prevent the garbage collector from moving instances of the given class while in a J/Direct-native call. Second, it guarantees a precise layout of data members (which is important to native code). In fact, the @dll.struct tag has a special modifer, pack, that allows you to set structure alignment (also known as structure packing) to 1, 2, 4, or 8-byte boundaries. The default, 8, is generally correct in Win32.

Can a J/Direct structure contain a nested structure or a fixed-length buffer?

Yes. Nested structures are handled transparently by the VM. All you have to do is declare the nested member at the right point and the VM will insert it there. Both the containing structure and the contained structure have to be marked with the @dll.struct tag.

     /** @dll.struct() */    
     class POINT 
     {       
         int x;
         int y;
     }
 
     /** @dll.struct() */
     class MSG 
     {       
         public int hwnd;
         public int message;
         public int wParam;
         public int lParam;
         public int time;
         public POINT pt;    
     }

     struct OSVERSIONINFO
     {
         DWORD dwOSVersionInfoSize;
         DWORD dwMajorVersion;
         DWORD dwMinorVersion;
         DWORD dwBuildNumber;
         DWORD dwPlatformId;
         TCHAR szCSDVersion[128];
     };

Yes! The WinJava application I wrote (see Figure 6) registers a window class, creates a top-level window, and then drops into a good old Win32 message dispatch loop—all thanks to J/Direct.
The WinJava sample application ties together all of the J/Direct features I've discussed in this column. It also demonstrates two additional features. The first is the use of @dll.import on an entire class. In the main WinJava class, I declare a tag marking the class as @dll.import("USER32",auto). This is simply shorthand for "import all static native methods in this class from user32.dll." This saves quite a bit of typing.
The second new concept is brought into play when the WinJava window class is registered. In Figure 5, my callback was only in use for the duration of the native call. Since a window class continues to use the WNDPROC callback long after the class has been registered, you need to make sure that the WNDPROC doesn't get moved or reclaimed by the garbage collector in the meantime. I do this by allocating a root handle to the WNDPROC object (in this case, WinJavaWndProc) using com.ms.dll.Root.alloc, and then specifying the address of that object (determined by com.ms.dll.DllLib.addrOf) as the lpfnWndProc member of the WNDCLASSEX structure.