Wine Definitions take #3 -final ?

[Tom Wickline]

I would like to thank everyone who has helped so far on this.
If you see something out of pace please comment on it. If everything
looks good ill send a patch to alexandre in a couple days after everyone 
has
had time to look this over.

Tom

--------------------------- 2003/02/03

-- = files that are listed in this Doc but are not installed on my system.
*  = files are in this Doc and on my system
@  = files that are on my system but not in the Doc
#  = files that are not in the Doc or on my System ( wineboot ) will be 
in future releases ?


-- dosmod : Deleted as of Jan 2001.

-- fnt2bdf  : Discussed on Wine-Devel ( practically obsolete )

@ notepad : The windows Notepad replacement

@ progman : A program Manager for WINE.

@ regedit : A command-line tool to edit your registry or for important a 
windows registry to Wine.

@ regsvr32 : A program to register/unregister .DLL's and .OCX files. 
Only works on those dlls that can
self-register.

@ uninstaller: A program to uninstall installed Windows programs. Like 
the Add/Remove Program in the windows control panel.

@ wcmd :  Wine's command line interpreter a cmd.exe replacement.

@ widl : Wine IDL compiler compiles (MS-RPC and DCOM) Interface 
Definition Language files (into
something useful for compiling Wine and Winelib apps, similar to wmc and 
wrc). Should also be able to generate typelibs (someday).

* wine :  The main Wine executable. This program will load a Windows 
binary and run it, relying upon the Wine shared object libraries.

# wineboot : This program is executed on startup of the first wine 
process of a particular user.
wineboot won't automatically run when needed. Currently you have to 
manually run it after you install something.
A list of what it currently does.

         * wininit.ini processing
         * registry RenameFiles entries
         * RunServices* / RunOnce* / Run registry keys


-- winebootup : Now wineboot......

* winebuild : Winebuild is a tool used for building Winelib applications 
(and by Wine itself) to allow a developer to compile a .spec file into a 
.spec.c file.

* wineclipserv : The Wine Clipboard Server is a standalone XLib 
application whose purpose is to manage the X selection when Wine exits.

@ wineconsole : The purpose of wineconsole is to render the output of 
CUI programs
it does so either thru a window (called the USER32 backend) or by using 
an existing unix shell (called the curses backend)
the first backend is triggered when the app programmatically opens a 
console (AllocConsole)
the second one is triggered on startup by using wineconsole myapp.exe 
instead of wine myapp.exe on the command line

* winedbg : A application making use of the debugging API to allow 
debugging of Wine or Winelib applications as well as Wine itself (kernel 
and all DLLs).

@ winedump : Dumps the imports and exports of NE and PE (Portable 
Executable) files. DLL (included in wine tree).

@ winefile : A clone of the win3x filemanager.

@ winegcc/wineg++: Wrappers for gcc/g++ respectively, to make them 
behave as MinGW's gcc. Used for porting apps over to winelib.

* winelauncher : A wine wrapper shell script that intelligently handles 
wine invocation by informing the user about what's going on, among other 
things. To be found in tools/ directory. Use of this wrapper script 
instead of directly using wine is strongly encouraged, as it not only 
improves the user interface, but also adds important functionality to 
wine, such as session bootup/startup actions. If you intend to use this 
script, then you might want to rename the wine executable to e.g. 
wine.bin and winelauncher to wine. the WINECONFDIR/config file.

@ winemaker : Winemaker is a perl script which is designed to help you 
bootstrap the conversion of your Windows projects to Winelib. In order 
to do thisit will go analyze your code, fixing the issues listed above 
and generate autoconf-based Makefiles.

@ winemine :  A clone of "Windows Minesweeper" a demo WineLib app.

@ winepath :  A tool for converting between Windows paths and Unix paths 
(useful for shell scripts ans such).

* wineserver : The Wine server is the process that manages resources, 
coordinates threads, and provides synchronization and interprocess 
communication primitives to Wine processes.

-- winesetup : This is a Tcl/Tk based front end that provides a user 
friendly tool to edit and configure the WINECONFDIR/config file.

* wineshelllink : This shell script can be called by Wine in order to 
propagate Desktop icon and menu creation requests out to a GNOME or KDE 
(or other Window Managers).

@ winewrap : Takes care of linking winelib applications. Linking with 
winelib is a complex process, winewrap makes it simple.

@ winhelp : When Windows (at least 3.0, but it may well have appeared in 
2.0) was launched, a help system was designed. Help information is 
stored in .hlp files, and was viewed with winhelp.exe (16 bit application).
When Windows 95 was launched, the same help system still existed (even 
it grew in complexity), and help was viewed by a 32 bit application 
(winhlp32.exe). Those help files (.hlp) are in fact generated by a 
specific build system, starting from RTF files, with some very styles to 
define the specific portions (pages, links...).
When an application requires a specific help page to be displayed, it 
calls an API (WinHelp), specifying the name of the help file, and a 
information about what needs to be displayed (hence the context 
sensitive help).
When the Internet wave was clear to the MS folks, they moved the help 
system architecture to HTML files (replacing the RTF sources). That are 
the .CHM files (basically, compressed HTML files and their embedded 
information - images, metafiles...), which are normally displayed by an 
OCX (which basically decompress the right files and ask IWebBrowser to 
display them).hh.exe (which is now the .CHM viewer) is just a wrapper to 
that OCX.

* wmc : Wine Message Compiler it allows Windows message files to be 
compiled into a format usable by Wine.

* wrc : Wine Resource Compiler. It allows Winelib programmers (and Wine 
itself) to compile Windows style resource files into a form usable by Wine.