Re: [gtk-win32] Let's start some discussion.

["James \"Doc\" Livingston" <doclivingston gmail com>]

On Mon, 2007-05-07 at 08:19 -0500, Jerome Haltom wrote:
> I am a typical Windows developer. I work for a small business, and write
> applications for that business in the various RAD tools Windows (or
> others) have introduced over the years. I've developed in Visual Basic
> 5, 6. I've had a brief stint with Delphi. I've done very limited amounts
> of Java desktop application stuff. The last 3 years I've been doing
> nothing except for C# and .Net.

I'll start off by saying that I'm not a Windows programmer, although I
have done a few things here and there, and have done a little bit toward
trying to port a few open-source apps to Windows.


As with most of these kinds of discussions, there are several groups
that we'll have to satisfy, each with their own desires. Off the top of
my head, the ones I can think of are:

1) Windows developers, who want to use GTK et al.
2) Open-source developers, who want to port their apps to windows
3) Platform developers, who work on the libraries like GTK
4) Home users, who want to install apps they downloaded
5) Corporate users, who want to install apps on all their machines


(1) are probably interested in things working the same way as other
Windows stuff, so they don't have to use all the crazy things that they
currently would. That means Visual Studio and making it easy for them to
get the libraries installed on their customer's machines.

(2) are almost certainly going to prefer things to work like they do on
*nix, so they don't have to learn a heap of new tools just to build
their app on Windows. I'm not certain if there are restrictions on what
you do with the "express" versions of Visual Studio, but for some people
buying VS just to port something to Windows is probably out of the
question.

(3) I'm not a platform hacker, so I'm not sure exactly what they'll want
- but something stable that all the groups can use is probably good.

(4) just want the app installed so they can use it. Making them download
other installers off the 'net wouldn't be good. Shoving the library
installer into the app installer, or having it automatically download
the libraries are the usual methods I've seen.

(5) will want automatic installation and deployment, and so MSIs.



Feel free to say I don't know what any/all of the above groups want,
because I didn't think *too* hard about it, but I think having some idea
of what different people want will be important for deciding how to do
things.


> We'd need to decide on where we will install this stuff, and how.
> Traditionally our software likes to be single-rooted. That is, we choose
> a single root directory and install all versions into that one directory
> under /lib and such. If we're going to handle parallel installs of
> different versions of Gtk, which itself depends on different versions of
> pango, glib, etc, we need to make sure we can fit all of these
> combinations into one sub directory.

The obvious question here is whether we want to have libraries libraries
like glib and GTK parallel-installed. Since they have a stable API,
there shouldn't (in theory) be any problems with using Gtk 2.10 and apps
that were originally liked against 2.8. Of course like all theory, it
doesn't always equal practise and there are likely to be some issues,


> There is also the Windows linker to consider. You can only really
> append version names to the libraries: gtk-2.10.dll, for instance.
> Each application which depended on gtk-2.10.dll would only be able to
> function with gtk-2.10, no later version. Is this acceptable? It is as
> long as we get parallel installs working. There is no symlinking of
> one version to another version name.

Having parallel installs of the libraries isn't quite that easy, as
you'll get problems where the version required by a library is different
to the one required by the application or another library. One example
is the issues you get with GTypes, like when GTK_TYPE_WINDOW in one bit
of code if different to GTK_TYPE_WINDOW in another bit of code.


Consider for example Totem, which I'd been doing some work on porting to
window on-and-off (mostly off) over the past few months. Totem uses both
GTK and GStreamer, and they both use glib. What happens if GStreamer is
linked against glib 2.10 and GTK is linked against glib 2.12? If they
were parallel-installed, you'd end up with both being loaded into the
application.

The only solution I know of for this is to ensure that everything is
linked against the same version of that library, which means it isn't
parallel-installed any more (or the usual Windows practice of shipping
libraries with the app).


Cheers,

-- 
One distinguishing characteristic of BOFHen is attention deficit
disorder. Put me in front of something boring and I can find a
near-infinite number of really creative ways to bugger off. -- ADB