I have created a GUI-based MFC application ( VC6 ) and I want to add a
command line option that
will output something on the console ( only when the application is launched
from a console ) without having any
GUI object displayed.

Example :

C:\>myMdiApp.exe -V
myMdiApp version 1.0.0.1

C:\>

    ---- or ----

C:\>myMdiApp.exe -V > info.txt
C:\>

    ---- or ----

C:\>myMdiApp.exe                         // this will launch the application
( with MDI windows, etc... )

Thanks,

        Franck

Checkout the ProcessShellCommand function in your
application source InitInstance. The command line
arguments in an application can be controlled there.

Case 1: my application is launched without any command-line option
 => the application is launched in GUI mode ( with MDI windows, etc... ).

Case 2: my application is launched with a -V as command-line option (
myMdiApp.exe -V )
  => the application displays "myMdiApp version 1.0.0.1" and exits immediately.

| Hi,
|
|    I have created a GUI-based MFC application ( VC6 ) and I want to add a
| command line option that
| will output something on the console ( only when the application is launched
| from a console ) without having any
| GUI object displayed.
|
| Example :
|
| C:\>myMdiApp.exe -V
| myMdiApp version 1.0.0.1
|
| C:\>
|
|     ---- or ----
|
| C:\>myMdiApp.exe -V > info.txt
| C:\>
|
|     ---- or ----
|
| C:\>myMdiApp.exe                         // this will launch the application
| ( with MDI windows, etc... )
|
|
|
| Thanks,
|
|
|         Franck
|
|

Checkout the ProcessShellCommand function in your
application source InitInstance. The command line
arguments in an application can be controlled there.

One solution: have a console app that checks the command line and prints out
as above in the "-V" case. If "-V" is not present launch the separate GUI
app. In other words, make a stub console app as a front end for your GUI
app.

HTH

Jay

Compile a small console app, and call it myMdiApp.com (not .exe).  Its
job is to process the -V option and use stdout.

Compile the MDI GUI app, and call it myMdiApp.exe.  Its job is to have a
GUI.

Keep the two apps in the same directory.

If you don't give myMdiApp.com the -V option, it should retrieve
argv[0], chop the .com off, replace it with .exe, and then append all
the other arguments and pass the result to CreateProcess.

Why does this work?  When CMD.EXE and COMMAND.COM (the command
processors) process a command line that is not a built-in command, they
search the current directory and then the directories in the PATH
variable for a file with the requested name and one of these extensions:

COM
EXE
BAT
CMD (NT/2K/XP only)

CMD.EXE will then scan the directories for files with extensions in the
PATHEXT variable as well.  The scan looks for each extension before
going to the next directory.

When you type "myMdiApp {params}", the command processor finds
myMdiApp.com first, and executes it.  When myMdiApp.com replaces .com
with .exe, CreateProcess loads myMdiApp.exe from the same directory.

It's a bit of a kludge, but it's what Visual C++ does when you type
MSDEV into a command window.

--
"Eagle-eyed" Steve

The pictures they didn't want me to take:
        http://www.koolpages.com/theoddcar/
or:
        http://www.grandfathersaxe.demon.co.uk/

<snip>

The problem is that you need to control how CreateProcess
is called on the GUI app to override default behavior and
give it access to the original console. By default, GUI apps
are launched _detached_, and console apps are launched
_attached_. By the time the app is launched, the decision
has been made.

From MSDN: Platform SDK: DLLs, Processes, and Threads

"Creation of a Console...
A GUI or console process can use the CreateProcess function
to create a new console process and specify a flag to tell the
system to create a new console...
GUI processes are not attached to any console when they
are created."

This means it has _no access_ to the console of the command
processor.

"A console process is not attached to a console if the
DETACHED_PROCESS flag was specified in a call to
CreateProcess when the process was created."

Which is _not_ specified by the command processor, so
the console app is attached to the parent's console.

It's just a matter of default behavior. Console apps can
create windows, and GUI apps can allocate consoles.