2/10/92

	SPLASHSCREEN DEMO

	Files:   Splash.pas - splashscreen unit source
	            Splash.res - splashscreen bitmap resource
	            Zwindow.pas - generic demo program
	            Zilch.res -resource file for Zwindow.pas
	            Splash.txt - this file  
		
	This small project grew out of looking at the TPW bitmap that
	pops up every time you start the program. It is my understanding
	that Object Graphics has a method that creates this type of splash-
	screen, but rather than buy a library to accomplish this, I hacked
	around until I came up with something that worked. The result is 
	the unit contained in SPLASH.PAS, which pops up a borderless
	bitmap window for ten seconds when your program starts. The 
	window is modeless to the extent that it does not halt tasks in 
	other currently executing programs, but greys out the parent 
	program and does not allow the user to close it for the ten 
	seconds it is onscreen. If the user clicked on the greyed parent
	program, he could actually access it while the splashscreen is 
	visible, but the fact that the parent program appears inactive
	would discourage most users from doing so. This is probably
	not very memory efficient(as a sizable bitmap resource has 
	to be loaded into memory every time the parent program
	executes) but it is quite slick and professional looking and is 
	ideal for a shareware announcement. I have to mention that it
	drives me crazy that some shareware programmers use timed 
	system modal dialog boxes that bring ALL Windows processes 
	to a halt while their announcement displays. A few times I have
	loaded these programs while downloading remote data or in the
	midst of DDE processes and have lost data (it doesn't exactly 
	make me want to run for my checkbook and register their programs).
	I think this splashscreen method is much more considerate of your
	end user.

	ABOUT ZWINDOW.PAS
	This is a generic TWindow descendent that does nothing except display the
	splashscreen. It has a menu with an exit command and an about dialog. I
	included this program as a demo of how to add the splashscreen object to
	your existing programs.  Since the splashscreen is a parentless popup 
	window, the only way you can keep it from being overlapped by the parent 
	window is to call it in between the TApplication.Init and .Run methods :
	           
		var
                                  ZApp : ZilchApp;

                                begin
                                    ZApp.Init('ZilchApp');
  	{this inits the splashscreen object}
                                  Application^.MakeWindow(New(PPicWindow, Init(nil, ws_Popup 
		      or ws_visible and not ws_OverlappedWindow)));
                                   ZApp.Run;
                                   ZApp.Done;
                               end.	
	The NIL statement in the splashscreen's init method registers it as a 
	parentless popup that technically is owned by the application but can act 
	independently of it. A normal child window would have a "@self" statement
	in that position. The _ws parameters define it's behavior and appearance
	and are described (in not very much detail) in the TPW Programmer's Ref. 
	              Note: I have tried dozens of combinations of _ws parameters and
	this was the only one that gave me the desired results. I hope some of you
	will fool around with this a little more- if you come up with other settings
	that work, please let me know.
	Other than this init statement, all you have to do to use the splashscreen
	in your program is to add it to your USES clause.

	ABOUT SPLASH.PAS

	{TPicWindow}
	TPicWindow.Init(AParent : PWindowsObject; AStyle : LongInt);
                 Begin
	    TWindow.Init(AParent,'');
 	    with Attr do
  	    begin
    	        Style := AStyle;
   	        X := 110; Y := 100; W := 390; H := 255;
  	end;
  	hOpenBmp := LoadBitmap(HInstance,id_OpenBmp);
	End;

	The TpicWindow constructor contains other parmeters that affect
	it's appearance. Using the AStyle:LongInt parameter allows you
	to access a child window's ws_style field to change it's width, height, 
	(W,H) and the location at which it will open(X,Y).  When you change 
	the bitmap resource, be sure to change W and H to the dimensions 
	of the new bitmap. The final statement loads the bitmap itself. 	
	

	{WM_Timer}
	procedure TpicWindow.WMTimer;
		Begin
  		   DeleteObject(hOpenBmp);
  		   KillTimer(hWindow, timer_ID);
		   TWindow.CloseWindow;
		End;

	 TPicWindow initializes  a timer  in it's Setup Window method:
	
  		SetTimer(hWindow, timer_ID, 10000, nil);
	The third parameter( 10000 ) represents 10000 milleseconds, roughly 10
	seconds.  By using this statement, you can execute a function when 
	Windows returns a WM_Timer message to the window( hWindow) at
	the interval (10000) stated in SetTimer. Here, it closes TPicWindow,
	deletes the bitmap resource and and kills the timer itself (The timer is
	a global resource that will continue to take up memory if not deleted):
		
	Paint
	The paint method is an abbreviated version of the one contained in
	TWindow that can display bitmaps of up to 16 colors. A 256 color 
	bitmap would not display properly here because of the lack of a 
	palette handling method.

	Changing the Bitmap-this must be done on the .res file itself with
	a resource editor. If you rename the resource, you also have to 
	change the id_bitmap statement.

	Note : The GetWindowClass and GetClassName functions are 
	included for compatibility with the Windows MDI interface. They
	are not needed for non-MDI apps like the sample program.

	Enjoy

	Scott Hanrahan[70144,3033]

	P.S. -to give credit where due, I would like to mention two books that
	have been a great help to me in this and other projects: Turbo Pascal
	for Windows 3.0 Programming by Tom Swan, and Programming
	Windows by Charles Petzold