RE: Source code for gtk-demo

["Sai Korada" <sai korada xilinx com>]

Thanks for explaining with so much patience. Let me clearly tell you
what are all the methods I've tried.

1. Identified the set of DLLs of GTK+ which are required to be installed
on target machine for the application to run. Initially I created a
batch file which prepends this path to the system path. All is fine, but
as expected, it leaves a console window.

2. As per some suggestion given in the mailing list, I've tried to use
start/B myapplication.exe after setting the path. But it seems Win XP
doesn't like this start/B funda.

3. I've tried to set the system path through getenv(), putenv() before
calling gtk_init(), which for some reason(I couldn't understand why?),
though setting the path, is terminating the application immediately it
sees gtk_init().

4. Tried to use SetDLLDirectory, but same is the case with this also.

5. As a final attempt I've started packaging my application with
InstallShield, which has two options, either it will search for DLLs
dynamically after running the application or statically. In either way,
it is unable to identify certain DLLs such as gtk_pango...etc.

Now can you help me how can solve the issue. One more thing is I tried
linking with -mwindows too, but when I'm executing my application
through .bat file, it doesn't serve the purpose. 

I was searching on google groups for any combination, but unfortunately
I'm left unsuccessful. Please try to help me in any possible way, I'll
be more than happy.

Thanks
Sai.

By the way I'm not "devilsclaw".




-----Original Message-----
From: gtk-app-devel-list-bounces gnome org
[mailto:gtk-app-devel-list-bounces gnome org] On Behalf Of Tor Lillqvist
Sent: Thursday, December 07, 2006 2:52 PM
To: gtk-app-devel-list gnome org
Subject: Re: Source code for gtk-demo

Sai Korada writes:
> Can anyone guide me to source code for gtk-demo application.

Fetch GTK+ sources, ftp://ftp.gtk.org/pub/gtk/v2.10/gtk+-2.10.6.tar.gz
, look in the demos/gtk-demo folder.

> Actually I want to know what is the entry point for a GUI
> application (like int main() for ordinary applications).

> Whenever an application is created using int main(), it leaves a
black
> console window open, that just looks as ugly as possible. 

Sigh, I mailed messages about these issues to this very list just a
couple of days ago. (Are you the same person as "devilsclaw"?) Check
the archives. Anyway, I'll reiterate...

Firstly, you should mention right away that you are talking about
Windows issues, so that people who aren't interested in Windows
won't wonder what the heck you are talking about. You did know that
the distinction between "GUI" and "console" applications is a
peculiarity in Windows only, didn't you?

Anyway, you are confusing two things here. Whether the (C/C++ level)
entry point is main() or WinMain() is irrelevant from the Windows
operating system's point of view. Windows executables of course don't
even need to be written in C or C++, so they don't necessarily even
have had anything called main() or WinMain() in their source code. The
operating system doesn't know or care what language the executable is
written in.

The *real* entry point of an executable is the one that the
AddressOfEntryPoint field in the "optional" PE header (which isn't
optional for executable images) specifies. (See
http://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx )

For an app written in C or C++, that real entry point is in an object
linked in (statically) from the C library. It's definitely not main()
or WinMain(). It's that startup code that calls the user-written
main() (or WinMain()) function.

The distinction between GUI and console apps is from the Wndows
operating system's point of view only a question of whether the
Subsystem field in the optional PE header has the value
IMAGE_SUBSYSTEM_WINDOWS_GUI (2) or IMAGE_SUBSYSTEM_WINDOWS_CUI (3).

That decides how Windows starts the executable, whether it opens a
console window for it (if it doesn't inherit one from its parent) or
not. (If the exectuable is run with a console window, the standard
input/output/error handles are attached to it, unless the
CreateProcess() call asked for other assignments.)

Just by changing that field in an executable you can switch it from
being a GUI app to a console app and back. Whether it has a main() or
WinMain() (or whether it was written in C or C++ at all) is irrelevant
from the operating system's point of view. Also, the GUI/console
distinction has no relation to whether the app actually creates and
shows any windows and has a GUI or not.

Now then, what confuses you is that the Microsoft C/C++ compilers and
IDE enforce the *convention* that when creating a GUI application, it
should have a user-written WinMain(), and when creating a console
application, it should have a main(). The GNU compilers and tools, for
instance, don't enforce this.

> When running gtk-demo, I could realize that it doesn't even start a
> black console window. Any hint on how this can be done. 

Are you sure? The gtk-demo.exe distributed as part of the official
Windows gtk+ development packages on ftp.gtk.org is linked as a
console application. Are you running gtk-demo from a command prompt in
a console window? In that case console apps don't open any new console
windows, but use the one they are started from.

> I've been trying all the methods, but unfortunately nothing seems
> to work as expected.

What methods have you been trying?

To create a GUI executable, you can do it several ways:

1) If using Microsoft tools: Write standard C code with main() and
  none of this WinMain() crap, let your tools create a console
  executable, and only then when you are ready to ship it, use the
  editbin command to switch the subsystem field in the header. editbin
  is part of the Microsoft tools.

        editbin /subsystem:windows yourapp.exe

2) If using Microsoft tools: Tell the tools that you want to create a
  GUI executable, and write a WinMain() then. If you want, you can
  have WinMain() just call a main() function, in that way your code is
  more portable. (You can get at the parameters to pass to main() by
  using __argc and __argv, which are declared in stdlib.h.)

3) If using GNU tools, just add -mwindows to the linking command
  line. You can still write your code with just a main().

4) Some other combination.

In addition to the above, there is the additional convention that if
one writes an "UNICODE" application, instead of main() and WinMain()
one has wmain() or wWinMain().

You should really have a look at for instance the crtexe.c source file
in the Platform SDK. That is the source from which the object files as
used by the Microsoft tools to contain the actual entry point of an
executable is compiled. (Different variants for GUI/console and
"ANSI"/"UNICODE" apps.)

As you notice from the above, nothing GTK+-specific is mentioned. The
above knowledge is something "C/C++" programmers who claim they know
Windows could be supposed to be familiar with, for chrissake.

--tml

_______________________________________________
gtk-app-devel-list mailing list
gtk-app-devel-list gnome org
http://mail.gnome.org/mailman/listinfo/gtk-app-devel-list