What are "gtk+", "glade",
and "MinGW"?

Gtk+ is
a free cross-platform graphical toolkit. When you develop
software using gtk+, it
is possible to write a single program which works almost without
change on various computer platforms like Linux, Mac OS X, and
Windows. In order to compile a program that depends on
gtk+, you therefore have
to have the necessary gtk+ development environment
installed on your computer.

With that said, though, one must deal with the fact that the
gtk+ developers provide
little advice as to how
to use gtk+ on
Windows. It turns out not to be difficult, but it helps to
have it explained. I assume in advance that you
already have some experience at compiling C-language programs; if
you don't, you probably are going to need to acquire some (or to
bring in a friend with some experience), before using any of the
stuff I'm going to say.

Glade is free software
that helps you rapidly create a gtk+ program, and to easily design a
user interface. While there are other ways to create
gtk+ applications, using
glade is a very common
method for doing so. You can find out more about
glade at glade.gnome.org.

MinGW is a free Win32
port of the GNU gcc C/C++
compiler.

P.S.: After figuring out most of the stuff in this howto
(and writing it), I discovered a site devoted to Win32 ports of
gtk+ and glade: wingtk.sourceforge.net.
You may want to check it out if my remarks below don't meet your
needs.

Gtk+ 1 or gtk+ 2?

I will discuss only the newer
gtk+ 2, rather than the
older gtk+ 1. The
newer version has more features and results in software that's
simply visually more attractive. However, using version 2
does limit you in some ways: For example, at present
(10/25/03) the Mac OS X port is version 1 only. I assume
that most of what I say below can be adapted easily to
gtk+ 1, but I don't care
to explore the possibilties myself.

How To Install gtk+ 2 for
Developing in Windows

Download a bunch of stuff.
You're going to need both gtk+ itself, as ported to
Win32, and a suitable C-language compiler. In
parentheses I show the specific software versions I
have used, but presumably later versions will work just
as well. (In fact, since the time this section
was written, I have used later versions
of most of these libraries. Forgive me for not
providing exact links, but as you can imagine, these
are likely to change so often that I would have a tough
time keeping them up to date.)

Install MinGW. This is simply
a matter of running the exe file you downloaded above,
and answering the prompts. For the sake of
argument, I'm going to assume that you have used the
installation directory c:\mingw.

Install all of the zipfiles you downloaded
above. Unzip them under c:\mingw. After
doing so, you should see directories such as
c:\mingw\bin, c:\mingw\usr, c:\mingw\etc, and so
on.

Move the file(s) libatk*.dll from c:\mingw\lib to
c:\mingw\bin.

Install Msys. Again, this is
just running the exe file and following the
prompts. It doesn't really matter what
install-directory you use, but at the end you will be
prompted to tell which directory MinGW was installed
under. (The answer will be c:/mingw.)

If you're reading this HOWTO because you just want
to compile Virtual AGC programs, then you can return to
the Virtual AGC
download page now.

"Command Line" Compilation of gtk+ Programs in Windows

The Msys Development Environment

Let's suppose you
have a gtk+ application
you want to compile for Windows.

The trick to compiling such programs is to use Msys. After installing
Msys, you should have
noticed the creation of an Msys icon on your desktop.
Clicking on the Msys icon
opens up a window with a command-line environment inside
it. However, this command-line environment is not the "DOS
Prompt" normally available under Windows; rather, it is a
Linux-style command-line environment using what is known as the
sh shell.

The point of working with Msys is that it helps you to
build the executable
Win32 programs. However, Msys is not itself needed for
running these programs
after they're built. In particular, you can deploy or
distribute the executables to computers which don't themselves
have Msys installed on
them.

When working with Msys,
you will be doing all of your work within your "home"
directory. The home directory is a Linux concept that
doesn't actually exist in Windows, and I'm not sure exactly how
Msys chooses which
particular directory it uses. (In other words, it will be
different on your computer than on my computer.)

Getting Source Code

By some means you have go put the
source-code you need into the Msys home directory. Perhaps
you've developed it directly using a Win32 port of glade; perhaps you've developed in
Linux and have copied the source code; perhaps you've downloaded
it from the web. It doesn't really matter, as long as it
ends up in the home directory.

The easiest way to get files into or out of your Msys home directory is to use the
"cp" command from within the Msys environment. For example,
here are two sample commands, one of which copies the directory
c:\DirA into the home directory, and one of which copies the DirB
subdirectory to the root directory of the c: drive.

cp -a c:/DirA .
cp -a DirB c:/

(Use the command "cp --help" to get more info on how to use the
"cp" command.)

For simplicity, I'll assume below that the code was developed
using glade, and resides
in a sub-directory of the home directory named according to the
way the project was named when it was created in glade. On the other hand, if
the source code is in the form of a "tarball", all of the
standard tarball-unpacking utilities like tar, gzip, and bzip2 are available within the
Msys working
environment.

Adapting Linux Source Code to Win32

There is, of
course, no guarantee that a gtk+ application developed on Linux
will actually compile and work properly in Win32, even if you
follow my instructions exactly. There's also no way
in the world I can possibly cover all of the things you might
have to adapt in your Linux source code to be compatible with
Win32 (or vice-versa).

If only generic C-library functions and gtk+ functions have been used,
there's a good chance that the program will work without much
difficulty. However, if Linux-specific functions that don't
work (or work differently) in Windows are used, then the program
probably won't compile or won't work well. For example,
accessing the RS-232 ("com ports") has a completely different API
in Linux and Windows, and can only be adapted with a lot of
effort. On the other hand, using sockets looks very similar in Linux and
Windows, but differs in certain details.

At the very least, you'll probably find that you have to make at
least a few source-code changes like the following:

#ifdef
WIN32#include
<windows.h>#endif

Compiling the Source Code

Glade enforces a build process
similar to that of many other Linux programs, in which one first
runs a script called "configure" (which creates a Makefile), then
runs "make", and then runs "make install". Unfortunately,
"configure" scripts generally depend upon programs called
autoconf and automake, which are theoretically
available in Windows, but which I've never gotten to work
properly in Msys.
Fortunately, it's reasonably easy to work out the necessary
compiler command-line switches, and therefore to do without the
configure-script.

In general, to build a gtk+/glade application in Win32, one would
run the C compiler from the Msys command prompt as follows:

Note the use of backward-quotes rather than apostrophes
above. In other words, make sure to use `pkg-config` rather
than 'pkg-config'. The NameOfExecutable is, of course, the
name you want to assign to the exe-file which is going to be
produced. The GladeProjectName is the name
assigned when the original glade project was created. For
example, these might be "MyProgram.exe" and "MyProgram",
respectively.

I'm not entirely sure, but I believe the same approach would work
for compiling non-gladegtk+ apps as well.
Some adjustment of directory names would undoubtedly be
needed.

Installing/Deploying the Executable

What is needed to
install the executable program on another computer after it has
been built? My suggestions are:

On the target computer, create the directories c:\mingw,
c:\mingw\bin, and c:\mingw\share, and add c:\mingw\bin to the
PATH.

The executable itself, following the instructions above,
has been created in GladeProjectName/src on the
development computer. I'd suggest placing it in
c:\mingw\bin on the target computer.

The MinGW/gtk+ DLLs are found in c:\mingw\bin on the
development computer. I'd suggest placing them in the
same directory on the target computer.

The pixmaps (the graphics used by the executable program)
are found in GladeProjectName/pixmaps on the
development computer. I'd suggest placing them in
c:\mingw\share\GladeProjectName\pixmaps on the
target computer.

Some Other Tools That May Help You

Glade

As I mentioned above, the most convenient (free)
way I've found to develop gtk+ applications is to use the
glade rapid-application
development software. Glade is available both for Linux and
for Win32, and the project data is interchangeable among the
Linux and Win32 versions. You can download the Win32 port
at wingtk.sourceforge.net.
At this writing (10/25/03), three separate versions of
glade are available at
that site. I'd suggest using the one labeled "Glade for
GTK+2".

RedHat Source Navigator

Personally, I find that there
are many advantages to editing my source-code trees within an
integrated development environment (IDE) like RedHat's free
Source Navigator
program. Source
Navigator has the helpful feature that it's available both
for Linux and for Windows, and hence I can use the same working
environment when I'm debugging the Win32 port as I do when I'm
writing the code in Linux. The main advantage of the IDE,
though, is that when you build the code from within the IDE and
encounter compiler errors, you can click on the error listing and
jump right to the place in the source code where the error
occurs. This is a bit of a trick when you are compiling
from the Msys
environment, but I can tell you how to do it. (I assume the
same approach will work with IDEs other than Source Navigator, but I don't really
have any specific information about it.)

Basically, when you tell Source
Navigator to build your code, it opens up a window in
which (by default) the command "make" is executed. You need
to replace the "make" command with a command that instead takes
the use of the Msys
environment into account:

Your source code would typically be in some subdirectory of your
Msys home directory, such
as /home/rburkey/TestProject/src. The command you use
in the Msys environment
to build the executable might be the complicated gcc command described above; or
perhaps you have wrapped the gcc command in a makefile --- called,
say, Makefile.Win32. So the command used by Source Navigator to build the
executable could be

Source Navigator expects
the utility cat to be
present for this to work. Fortunately, cat is installed automatically when
Msys is installed.
Just make sure that c:\msys\1.0\bin is in your PATH (or else copy
cat.exe and msys-1.0.dll to someplace which is already in your
PATH).

This approach seems to work quite well, although it does have the
annoying characteristic of opening and closing a new window (with
nothing in it) every time it invokes the compiler.

By the way, note the directions of the slashes in the command
above. The command "sh" is executed in the normal Win32
command shell, and therefore has backslashes as directory-name
delimiters. The stuff within the double-quotes, on the
other hand, is executed within the sh command shell, and therefore
expects to find forward-slashes as directory-name delimiters.