home *** CD-ROM | disk | FTP | other *** search
/ Windoware / WINDOWARE_1_6.iso / source / cppwin10 / readme.doc < prev    next >
Text File  |  1991-01-11  |  17KB  |  468 lines
  1.  
  2.  
  3. Windows/Zortech C++ Classes Version 1.0 01/11/91
  4. Comptech Software Inc.
  5. Keith Murray
  6. 16013 Saddlestring Dr.
  7. Tampa, FL 33618
  8. Compuserve 71601,3673
  9. (813)962-3908
  10.  
  11. This document and all software included with it are Copyright (c) 1991 
  12. Comptech Software Inc. All rights are reserved. This software is not in 
  13. the public domain. It is released through an brilliant system known and 
  14. shareware. It allows you the customer to try a product before you buy 
  15. it. It also helps keep the publishers costs down by allowing a cheaper 
  16. method for distribution. The publisher can then pass these savings on to 
  17. you by supplying a superior product and a reasonable price. If you find 
  18. this product useful and continue using it, please send $35. For this you
  19. will receive full source code. This shareware product is full featured. 
  20. The libraries supplied are compiled for small model Zortech C++ v2.1.
  21. They were compiled with the following options:
  22.  
  23.     ztc  -a -g -c -br -ms -W -DMSW -DLINTARGS
  24.  
  25. The following is a list of files included:
  26. README.DOC        This file
  27. WINS.LIB        The library of classes
  28. CBUFFER.HPP        CBuffer class header file
  29. CWIND.HPP        CWind class header file
  30. CDLG.HPP        CDlg class header file
  31. CDLGABT.HPP        CDlgAbout class header file
  32. CSELPRN.HPP        CSelPrnterDlg class header file
  33. CAPPL.HPP        CAppl class header file
  34. COPENDLG.HPP        COpenDlg class header file
  35. COPENDLG.H        COpenDlg dialog #defines
  36. CSELPRN.H        CSelPrnterDlg dialog #defines
  37. MENUDEF.H        Menu #defines for example program
  38. COPENDLG.DLG        COpenDlg dialog template
  39. CSELPRN.DLG        CSelPrnterDlg dialog template
  40. EXHPP.EXE        .HPP Extractor
  41. EXHPP.C         .HPP Extractor source
  42. TEST.CPP        Main program used in the example
  43. TEST.DLG        Dialog templates used in example program
  44. TEST.DEF        Definition file for example program
  45. TEST.RC         Resource file for example program
  46. TEST.MK         Make file for example
  47. TEST.ICO        Icon for example program.
  48. CDLG1.CPP        Example CDlg super class
  49. CDLG1.HPP        Example CDlg super class header file
  50. CWIND1.CPP        Test CWind super class used in the example
  51. CWIND1.HPP        Test CWind super class header file
  52.  
  53. To build the example program:
  54.     
  55.     C:\>make -ftest.mk
  56.  
  57. The test program creates a main window that has an "EDIT" class and a 
  58. "BUTTON" class object. Clicking on the button increases the number on 
  59. the button. The edit class allows you to type in text. This programming 
  60. example could easily be expanded to be a full text editor by supplying 
  61. code for the Open, Save, Save As, New and Print menu options.
  62.  
  63.  
  64. These classes simplify the creation of Windows 3.0 applications by using 
  65. an object oriented method. Anyone who has done a Windows application 
  66. using C will find this method much easier. The skeleton of an 
  67. application takes a program of 10 lines instead of the several hundred 
  68. needed when using C.
  69.  
  70. The following is a list of classes and .CPP files.
  71.  
  72.      Class         .CPP File
  73.      --------         -------------
  74.      CAppl         CAPPL.CPP
  75.      CBuffer         CBUFFER.CPP
  76.      CWind         CWIND.CPP
  77.      CDlg         CDLG.CPP
  78.      CDlgAbout         CDLGABT.CPP
  79.      COpenDlg         COPENDLG.CPP
  80.      CSelPrnterDlg   CSELPRN.CPP
  81.  
  82. CAppl (CAPPL.CPP)
  83. This class is the Application class. There is only one of these classes 
  84. in a program. It is created in WinMain() as follows:
  85.  
  86. ---------------------------  Start  --------------------------------
  87. /***
  88.     The main part of a Windows program is WinMain().
  89. ***/
  90. int PASCAL WinMain(HANDLE hInst, HANDLE hPrev, LPSTR cmdln, int cmd)
  91. {
  92.     CWind *pWind;
  93.     int x;
  94.  
  95.         // Create the Topmost window.
  96.     pWind = new CWind(hInst, hPrev);
  97.         // Create the application class
  98.     gAppl = new CAppl(hInst, hPrev, pWind->GetHWnd());
  99.         // Run the application
  100.     x = gAppl->Run();
  101.  
  102.         // Delete the application class    
  103.     delete gAppl;
  104.         // Delete the top window.
  105.     delete pWind;
  106.  
  107.     return x;
  108. }
  109. ---------------------------  End  ----------------------------------
  110.  
  111. This is the simplest application. It creates a Window class 'CWind'. The 
  112. application class, 'CAppl' is created by passing the handle to the 
  113. instance, the previous instance and the handle to the applications main 
  114. window. After being constructed, the 'Run' method is called which 
  115. handles doing the message loop and dispatching messages to the correct 
  116. window. It also handles any modeless dialogs that may be opened later in 
  117. the application.
  118.  
  119. If the application uses menus the method 'SetAppMenu' is called before 
  120. 'Run':
  121.  
  122. ---------------------------  Start  --------------------------------
  123.                 // Set Application menu
  124.     gAppl->SetAppMenu("APPMENU");
  125. ---------------------------  End  ----------------------------------
  126.  
  127. If the application has an icon it wants to be used when made ICONIC, use 
  128. the 'SetAppIcon' method before 'Run':
  129.  
  130. ---------------------------  Start  --------------------------------
  131.         // Set Application icon
  132.     gAppl->SetAppIcon("PROGICON");
  133. ---------------------------  End  ----------------------------------
  134.  
  135. The following is a list of methods available:
  136. CAppl(HANDLE hI, HANDLE hP, HWND hWnd);
  137.     Constructor for the object.
  138.  
  139. WORD Run();
  140.     Run the application until a WM_QUIT message is received.
  141.  
  142. HANDLE    GetInst(void);
  143.     Return the handle of the instance of the application.
  144.  
  145. HANDLE    GetPrevInst(void);
  146.     Return the handle of the previous instance of the application.
  147.  
  148. BOOL SetAppIcon(LPSTR pIconName);
  149.     Set the icon of the application to the icon with the name 
  150.     pointed to by 'pIconName'.
  151.  
  152. BOOL SetAppMenu(LPSTR pMenuName);
  153.     Set the menu of the application to the menu with the name 
  154.     pointed to by 'pMenuName'.
  155.  
  156. BOOL SetAccelerator(LPSTR pAccelName);
  157.     Set the accelerator of the application to the accelerator with 
  158.     the name pointed to by 'pAccelName'.
  159.  
  160. void EnableMenu(WORD wItem)
  161.     Enable the menu item with the id of 'wItem'.
  162.  
  163. void DisableMenu(WORD wItem)
  164.     Disable the menu item with the id of 'wItem'.
  165.         
  166. void GrayMenu(WORD wItem)
  167.     Gray the menu item with the id of 'wItem'.
  168.         
  169. void CheckMenu(WORD wItem)
  170.     Check the menu item with the id of 'wItem'.
  171.  
  172. void UnCheckMenu(WORD wItem)
  173.     Uncheck the menu item with the id of 'wItem'.
  174.  
  175. void InsertMenuItem(WORD wPos, WORD wFlags, WORD wItem, LPSTR pText)
  176.     Insert a menu item using wPos, wFlags, wItem and pText. See the 
  177.     Windows SDK manual for the meaning of these parameters.
  178.  
  179. void AppendMenuItem(WORD wFlags, WORD wItem, LPSTR pText)
  180.     Append a menu item using wPos, wFlags, wItem and pText. See the 
  181.     Windows SDK manual for the meaning of these parameters.
  182.  
  183. void DeleteMenuItem(WORD wPos, WORD wFlags)
  184.     Delete a menu item using wPos and wFlags. This allows menu items 
  185.     to be deleted using a menu id or position.
  186.  
  187. HWND hTopWin;
  188.     Handle to the topmost window for the application.
  189.  
  190. HMENU ApplMenu;
  191.     Handle to the menu for the application.
  192.  
  193.  
  194. CBuffer (CBUFFER.CPP)
  195. The 'CBuffer' class is used internally by 'CAppl' to handle the list of 
  196. modeless dialog boxes. It can also be used to handle a list of fixed 
  197. length objects. The following methods are available:
  198.  
  199. CBuffer(WORD nItemSize);
  200.     Construct a CBuffer object with an item size of 'nItemSize'.
  201.  
  202. BOOL AppendItem(LPVOID lpItem);
  203.     Append an item to the end of the list.
  204.  
  205. BOOL DeleteItem(WORD Index);
  206.     Delete the item with index 'Index' from the list. All items 
  207.     after the indexed item are moved down one position.
  208.  
  209. BOOL GetItem(LPVOID lpItem, WORD Index);
  210.     Move a copy of the data with index 'Index' into the buffer 
  211.     pointed to by lpItem.
  212.  
  213. void DoForEach(CALLBACK lpFunc, LONG lParam);
  214.     Call a function passing a pointer to each item in the list. The 
  215.     callback function is defined as:
  216.         int FAR PASCAL CallFn(LPVOID, LONG);
  217.     The 'lParam' variable is passed unchanged to the callback 
  218.     function.
  219.  
  220. WORD GetItemCount(void);
  221.     Return the number of items in the list.
  222.  
  223. CWind (CWIND.CPP)
  224. This class defines a top most or child window class. This is an abstract 
  225. class, you must define your own window class based upon this class. You 
  226. will want to at least override the DoPaint() method and maybe more.
  227.  
  228. The following is a list of methods available for the CWind class:
  229.  
  230. CWind(HANDLE hInst, HANDLE hPrevInst);
  231.     Constructor for creating a topmost window. A class created using 
  232.     this constructor should only be created once.
  233.  
  234. CWind(CWind *pParent, LPSTR lpClass, LPSTR lpCaption, DWORD dwStyle,
  235.             int x, int y, int width, int height, int Id);
  236.     Create a CWind class for a child window. If 'lpClass' is NULL, 
  237.     the normal 'Base' class is used. You can create a child window 
  238.     of another class such as 'BUTTON' or 'LISTBOX'. The CWind object 
  239.     created will be a subclass of the control and the object will 
  240.     receive the messages before the control.
  241.  
  242. HANDLE GetHWnd(void);
  243.     Return the window handle for the window associated with the 
  244.     CWind class.
  245.  
  246. HDC GetWndDC(void);
  247.     Get a DC for the window.
  248.  
  249. void ReleaseWndDC(HDC hDC);
  250.     Release a DC for the window.
  251.  
  252. void GetWndClientRect(LPRECT lpRect);
  253.     Get the client rectangle for the window.
  254.  
  255. void GetWndRect(LPRECT lpRect);
  256.     Get the windows rectangle. This includes any title bar, menu bar 
  257.     or border.
  258.  
  259. void SetWndText(LPSTR lpTitle);
  260.     Set the window's title.
  261.  
  262. void Show(void);
  263.     Show the window.
  264.  
  265. void Hide(void);
  266.     Hide the window.
  267.  
  268. void Move(int x, int y, int width, int height, BOOL bRepaint);
  269.     Move the window to a new location.
  270.  
  271. void Center(void);
  272.     Center the window inside the screen.
  273.  
  274. virtual void UpdateMenus(void);
  275.     This virtual function is called whenever a mouse down message is 
  276.     received and the mouse is in the menu bar. It allows the CWind 
  277.     object to change the status of the menu items before the menu's 
  278.     drop down.
  279.  
  280. virtual void SetupDC(HDC hDC);
  281.     This virtual function allows the CWind class to setup the DC 
  282.     before the GetWndDC() method returns. You can change the map 
  283.     mode, default colors, etc..
  284.  
  285. virtual LONG DoDefault(unsigned Message, WORD wParam, LONG lParam);
  286.     This virtual function is the default message handler. If the 
  287.     CWind object can not handle the message, this method is called.
  288.  
  289. virtual LONG DoCommand(WORD wMenuId, LONG lParam);
  290.     This virtual method handles the WM_COMMAND message. It would be 
  291.     overridden to handle menu options selected by the user.
  292.  
  293. virtual LONG DoCreate(LPCREATESTRUCT lpCreate);
  294.     This virtual method is called whenever the WM_CREATE message is 
  295.     received.
  296.  
  297. virtual LONG DoDestroy(void);
  298.     This virtual function handles the WM_DESTROY message.
  299.  
  300. virtual LONG DoKillFocus(HWND hNewWnd);
  301.     This virtual function handles the WM_KILLFOCUS message. The 
  302.     windows is about to lose the input focus.
  303.  
  304. virtual LONG DoPaint(void);
  305.     This virtual function handles the WM_PAINT message. This method 
  306.     would be overridden to repaint the screen as necessary.
  307.  
  308. virtual LONG DoSetFocus(HWND hOldWnd);
  309.     This virtual function handles the WM_SETFOCUS message;
  310.  
  311. virtual LONG DoSize(WORD wCmd, LPPOINT lpPoint);
  312.     This virtual function handles the WM_SIZE message.
  313.  
  314. virtual LONG DoSysCommand(WORD wCmd, LPPOINT lpPoint);
  315.     This virtual function handles the WM_SYSCOMMAND message. It 
  316.     should be overridden to handle any menu commands selected from 
  317.     the system menu.
  318.  
  319. virtual LONG DoMouseDown(unsigned Message, WORD wParam, LPPOINT lpPoint);
  320.     This virtual function handles the mouse down event.
  321.  
  322. virtual LONG DoMouseUp(unsigned Message, WORD wParam, LPPOINT lpPoint);
  323.     This virtual function handles the mouse up event.
  324.  
  325. virtual LONG DoMouseMove(WORD wParam, LPPOINT lpPoint)
  326.     This virtual function handles the mouse move event.
  327.  
  328. CDlg (CDLG.CPP)
  329. The CDlg class handles modal dialogs. This is an abstract class similar 
  330. to the CWind class. You will want to override the DoInitDialog and 
  331. DoCommand methods. See the CDlgAbout class for additional details.
  332.  
  333. The following methods are available from the CDlg class:
  334.  
  335. virtual BOOL FAR PASCAL Go(HWND hDlg, unsigned Message,
  336.             WORD wParam, LONG lParam);
  337.     This virtual method does the CASE statement to branch off to the 
  338.     various virtual functions. It most likely will not be overridden.
  339.  
  340. virtual BOOL DoInitDialog(WORD nFocusID, LONG lParam);
  341.     This virtual method handles initializing the dialog. Override to 
  342.     setup the dialog accordingly.
  343.  
  344. virtual BOOL DoCommand(WORD ControlID, LONG lParam);
  345.     This virtual method handles the WM_COMMAND message received. 
  346.     Override to handle the messages received from the controls in 
  347.     the dialog.
  348.  
  349. virtual BOOL DoDefault(unsigned Message, WORD wParam, LONG lParam);
  350.     This virtual method handles any messages that are not handled by 
  351.     the CDlg class.
  352.  
  353. int DoDialog(HANDLE hInst, LPSTR lpDlgName, HWND hParent, LONG lParam);
  354.     Do the dialog. Pass the handle to the application instance, a 
  355.     pointer to the dialog template name, the parent's window handle 
  356.     and a LONG parameter that is passed to the DoInitDialog method.
  357.  
  358.  
  359. void Center(void);
  360.     Center the dialog within the screen.
  361.  
  362. CDlgAbout (CDLGABT.CPP)
  363. The CDlgAbout class is a super class of the CDlg class. It defines an 
  364. About dialog that has one button labeled OK. Normally you will not have 
  365. to subclass this object. It automatically looks in the applications 
  366. resources for the dialog called "ABOUT_BOX" and uses it. The dialog 
  367. remains until a button is pressed that sends a IDOK value.
  368.  
  369. The following methods are available from the CDlgAbout class:
  370.  
  371. void DoAboutBox(HANDLE hInst, HWND hParent);
  372.     Do the dialog. It passes "ABOUT_BOX" as the name of the dialog 
  373.     to show and 0l and the LONG parameter to the DoDialog() method.
  374.  
  375. BOOL DoInitDialog(WORD nFocusID, LONG lParam);
  376.     This is an overridden method of the CDlg class. It centers the 
  377.     dialog in on the screen and returns.
  378.  
  379. BOOL DoCommand(WORD ControlID, LONG lParam);
  380.     This is an overridden method of the CDlg class. It watches for a 
  381.     IDOK ControlID and then closes ends the dialog.
  382.  
  383. Example of use:
  384. ---------------------------  Start  --------------------------------
  385.         CDlgAbout *pDlgAbout;
  386.  
  387.     pDlgAbout = new CDlgAbout;
  388.     pDlgAbout->DoAboutBox(WhInstance, WhWnd);
  389.     delete pDlgAbout;
  390. ---------------------------  End  ----------------------------------
  391.  
  392. COpenDlg (COPENDLG.CPP)
  393. This class implements an Open File dialog. You can specify the default 
  394. extension to show in the list box and whether the file name entered must 
  395. exist. This class is a superclass of the CDlg class.
  396.  
  397. The dialog template "OPEN_DLG" is defined in the COPENDLG.RC and 
  398. #defines for the controls are defined in COPENDLG.H.
  399.  
  400. The following methods are available from the CDlgAbout class:
  401.  
  402. COpenDlg(LPSTR lpExt, BOOL bFExist);
  403.     This is the constructor to be used when creating the object. 
  404.     lpExt is a pointer to the default extension. bFExist is TRUE if 
  405.     the file must exist.
  406.  
  407. BOOL DoInitDialog(WORD nFocusID, LONG lParam);
  408.     This is an overridden virtual function to handle initializing the 
  409.     dialog.
  410.  
  411. BOOL DoCommand(WORD ControlID, LONG lParam);
  412.     This is an overridden virtual function to handle the control's 
  413.     messages.
  414.  
  415. void GetFileName(LPSTR lpName);
  416.     This method returns the file name selected. Call this method 
  417.     before destroying the object.
  418.  
  419. Example of use:
  420. ---------------------------  Start  --------------------------------
  421.         COpenDlg *pOpenDlg;
  422.  
  423.     pOpenDlg = new COpenDlg((LPSTR)"*.cpp", TRUE);
  424.     pOpenDlg->DoDialog(WhInstance, "OPEN_DLG", WhWnd, 0l);
  425.     pOpenDlg->GetFileName((LPSTR)FileName);
  426.     delete pOpenDlg;
  427. ---------------------------  End  ----------------------------------
  428.  
  429. CSelPrnterDlg (CSELPRN.CPP)
  430. This class presents the user with a select printer dialog. The user can 
  431. select a printer and this class finds the correct driver and port name.
  432.  
  433. The variables CSelPrnterDlg::szDevice, CSelPrnterDlg::szDriver and
  434. CSelPrnterDlg::szPort are static and can be accessed after the object 
  435. has been destroyed.
  436.  
  437. The dialog template "SELPRN_DLG" is defined in the CSELPRN.RC and 
  438. #defines for the controls are defined in CSELPRN.H.
  439.  
  440. Example of use:            
  441. ---------------------------  Start  --------------------------------
  442.         CSelPrnterDlg *pSelPrn;
  443.  
  444.         pSelPrn = new CSelPrnterDlg;
  445.     pSelPrn->DoDialog(WhInstance, "SELPRN_DLG", WhWnd, 0l);
  446.     delete pSelPrn;
  447. ---------------------------  End  ----------------------------------
  448.  
  449.  
  450. EXHPP.EXE
  451. This program allows the programmer to have the .HPP file embedded inside 
  452. the .CPP file. One the most irritating things I found about programming 
  453. in C++ was the idea that for each class you had two files, the .CPP code 
  454. and .HPP header file. By putting codes in the .CPP file, the EXHPP.EXE 
  455. program can extract a .HPP file. The running of the EXHPP.EXE file can 
  456. even be automated in MAKE. By adding the following rule, any .OBJ file 
  457. that relies on a .HPP file will have the .HPP file extracted:
  458.  
  459. .cpp.hpp:
  460.     exhpp $*.cpp
  461.  
  462. If EXHPP.EXE is run, it extracts the .HPP portion and compares it with 
  463. an existing HPP file. If they are the same, the old file is left alone 
  464. so no MAKE dependencies will be triggered. If they are different, the 
  465. new .HPP file is saved.
  466.  
  467.  
  468.