home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / LordLucifer / win32asm / tutorials / edit_tut.txt < prev    next >
Encoding:
Text File  |  2000-05-25  |  11.2 KB  |  262 lines
  1. Edit Controls
  2. -------------------------------------------------------------------------------
  3. by lord lucifer
  4. March 14, 1999
  5.  
  6.  
  7. Introduction:
  8. -------------------------------------------------------------------------------
  9. A control is a child window an application uses in with another window to 
  10. perform simple input and output tasks. Controls are most often used within
  11. dialog boxes, but they can also be used in other windows. An edit control is a 
  12. rectangular control window typically used in a dialog box to permit the user 
  13. to enter and edit text from the keyboard. 
  14.  
  15. This article will show how to easily create a simple text editor by using an 
  16. edit control.  The control itself provides most of the needed functionality,
  17. and only a small amount of actual code is needed.
  18.  
  19. In order make sure the common controls library is loaded, so that you can use
  20. them, you should call the InitCommonControls function.
  21.  
  22. An edit control can send notification messages to its parent window in the 
  23. form of WM_COMMAND messages. A parent window can send messages to an edit 
  24. control in a dialog box by calling the SendDlgItemMessage function.
  25.  
  26.  
  27. Files and Tools:
  28. -------------------------------------------------------------------------------
  29. Here are some things you will need to use this tutorial....
  30.      MASM (Get the MASM32 package)
  31.      Borlands MAKE (if you wish to use my makefile)
  32.      Borlands BRCC32 (i dont know why, but i still use borland resource compiler)
  33.      Borlands H2ASH (not really necessary... easy way to convert .h to .inc)
  34.      The source code (lordlucifer.cjb.net/tutorials/edit_tut.zip)
  35.      Win32 API reference
  36.      
  37.           
  38. WinMain
  39. -------------------------------------------------------------------------------
  40. This function is where the execution effectively begins... It initializes the
  41. various window controls, files, and keyboard accelerators.
  42.  
  43. Keyboard accelerators are basically keyboard shortcuts to menu items.  To use
  44. accelerators, an accelerator table is created as a resource, in the following
  45. basic form:
  46.  
  47. acceltablename ACCELERATORS
  48. {
  49.     event, idvalue, [type] [options]
  50.     ...
  51. }
  52.  
  53. event        corresponds to the key to be used.  It can be of the form "c", an 
  54.         integer value representing a char, or a virtual-key value.
  55. idvalue        integer which specifies the ID
  56. type        specifies VIRTKEY or ASCII
  57. options        NOINVERT, ALT, SHIFT, CONTROL
  58.  
  59.  
  60. WinMain is also the home of the message loop.  Here, the GetMessage function 
  61. grabs the next message from the message queue.  The TranslateAccelerator 
  62. function then checks the message to see if it is an accelerator.  If it is, 
  63. it handles the message.  If not, execution is passed to the TranslateMessage 
  64. and DispatchMessage functions which sends the message to the appropriate
  65. window procedure.
  66.  
  67. The message loop is broken when GetMessage retrieves the WM_QUIT message.
  68.  
  69.      
  70.      
  71. InitWindow
  72. -------------------------------------------------------------------------------
  73. This function creates and shows the main application window.
  74.  
  75. To create a window, first you must register a window class for that window.  
  76. This is done by filling in a WNDCLASSEX structure and passing it to the 
  77. RegisterClassEx function.  Then the CreateWindowEx function is called, using
  78. the newly created window class to create and show the window.
  79.  
  80.  
  81.      
  82. InitEditControl
  83. -------------------------------------------------------------------------------
  84. This procedure initializes the Edit control and sizes it to fit inside the main
  85. window.  
  86.  
  87. All edit controls belong to the window class "EDIT".  This class name is 
  88. specified in the call to CreateWindowEx.  With common controls, you do not
  89. define and register your own class, you use the pre-defined window classes,
  90. defined in the commctrl.dll.
  91.     
  92. The edit window can have a variety of styles.  In addition to the standard 
  93. window styles, the edit control has sever additional styles:
  94.     ES_MULTILINE: control can have more than one line (default is 1 line only)
  95.     ES_AUTOVSCROLL, ES_AUTOHSCROLL: If the text to be displayed exceeds the 
  96.         size of the window, these flags tell the control to automatically 
  97.         scroll the text into view
  98.     ES_LEFT, ES_CENTER, ES_RIGHT: These set the text alignment, and apply only
  99.         to multiline edit controls.
  100.     ES_LOWERCASE, ES_UPPERCASE: Sets the text to all lowercase or uppercase
  101.         characters, respectively.
  102.     ES_OEMCONVERT: Converts the text into a specific character set.
  103.     ES_NUMBER: Limits text input to numbers only.
  104.     ES_NOHIDESEL: Specifies the selected text is not hidden when the control
  105.         loses focus.
  106.     ES_READONLY: Makes the text read-only.
  107.     ES_PASSWORD: Displays all characters as * (or other user defined character)
  108.     ES_WANTRETURN: Specifies that a return is inserted when the enter key is
  109.         pressed, for multiline controls only.
  110.     
  111.     
  112.     
  113.     
  114. InitFile
  115. -------------------------------------------------------------------------------    
  116. In this function, I get the command line arguments, and if a file is specified,
  117. it is loaded into the editor.  If no file is specified, the editor begins with
  118. a new document.
  119.  
  120. To get the command line arguments, I have created another function called
  121. GetCommandLineArgs.  This uses the GetCommandLine API function to get the 
  122. entire command line.  I then parse the string to get the arguments only.  If
  123. the program is called with no arguments, the command line is returned from
  124. GetCommandLine as a string.  If it has arguments, or is called from a directory
  125. with spaces, the command line is returned as a string with the full exe's 
  126. path in quotes, and with the arguments following.
  127.  
  128.  
  129.  
  130. MainWndProc
  131. -------------------------------------------------------------------------------
  132. This function is the window procedure for the main application window.  This is
  133. specified in the lpfnWndProc member of the WNDCLASSEX struct, which is passed
  134. to the RegisterClassEx function.  This is a callback function, called by
  135. windows and requiring the following form:
  136.  
  137. MainWndProc proc hWnd:DWORD, uMsg:DWORD, wParam:DWORD, lParam:DWORD 
  138. ...
  139. MainWndProc endp
  140.  
  141. The hWnd parameter specifies the window handle that the message is sent to.
  142. uMsg specifies the message sent.  wParam and lParam have varying meanings, 
  143. depending on which message is being sent.
  144.  
  145. The window procedure is responsible for handling all of the messages sent to the
  146. application window.  Here, the editing functionality, menu commands, window 
  147. re-sizing and window termination are handled here. 
  148.  
  149. I only handle the messages which I need for this application.  All other 
  150. messages are passed to the DefWindowProc API function, so they are properly 
  151. dealt with and not lost. 
  152.  
  153. The WM_DESTROY message should always be handled.  This message is sent when
  154. the application window is closed.  The handler then calls the PostQuitMessage
  155. API function, which is used to terminate the application.  Failure to call 
  156. this will result in the window disappearing but the application remaining in
  157. memory.
  158.  
  159. The WM_COMMAND message is sent whenever a menu item is chosen, or an accelerator
  160. key is pressed.  The values of lParam and wParam for the WM_COMMAND are:
  161.     wNotifyCode = HIWORD(wParam) : notification code 
  162.     wID         = LOWORD(wParam) : item, control, or accelerator identifier 
  163.     hwndCtl     = lParam         : handle of control which message is from
  164.  
  165. The WM_COMMAND handler is where all of the interface to the edit control
  166. occurs.  
  167.  
  168.  
  169.  
  170. Edit Control Messages
  171. -------------------------------------------------------------------------------
  172. EM_SETSEL is used to set the selection in the edit control. wParam is the 
  173. starting character position of the selection, and lParam is the ending position.
  174. If wParam = 0 and lParam = -1, all the text is selected.  If wParam = -1, no 
  175. text is selected (or a previous selection is de-selected).
  176.  
  177. EM_SETMODIFY sets or clears the modified flag of the edit control.  This flag
  178. indicated whether the text has changed. wParam specified the true/false value to
  179. set the modified flag to. This is automatically set when the text is first 
  180. changed. The EM_GETMODIFY message can be used to retrieve the modified flag.
  181.  
  182. WM_COPY, WM_CUT, WM_PASTE, WM_CLEAR these messages affect the currently 
  183. selected text, and perform their respective actions. For each, the wParam and
  184. lParam parameters are set to 0.
  185.  
  186. EM_UNDO is used to undo the last edit operation.  A second call to WM_UNDO will
  187. undo the undo...
  188.  
  189. There are many other edit control messages which you can use (I am just too 
  190. lazy to write about them all...)  For further reading, consult the API 
  191. reference...
  192.  
  193.  
  194.  
  195. EditOpenFile / FileOpen
  196. -------------------------------------------------------------------------------
  197. These functions are used to open a file, and load it into the edit control.
  198.  
  199. EditOpenFile first calls the GetOpenFileName API function to get the filename
  200. to open.  For this function, you must first fill the OPENFILENAME structure,
  201. which contains the information needed to initialize the Open common dialog box.
  202. The GetOpenFilaName function returns TRUE if a file was selected, FALSE 
  203. otherwise.  The selected file is returned in the lpstrFile member of the
  204. OPENFILENAME structure.
  205.  
  206. This filename is then passed to the FileOpen function, which actually opens
  207. the file, and puts it into the edit controls text buffer.  It begins by 
  208. opening the file with the CreateFile API, using the OPEN_EXISTING parameter.
  209. Next, the file size is determined, so it is known how many bytes to allocate to
  210. store it.  The memory buffer is allocated using the HeapAlloc API function, and
  211. Read File is used to copy the contents of the file into the newly created 
  212. buffer.  This buffer is then copied to the edit control, by sending it the 
  213. WM_SETTEXT message. This function ends by closing the file, and releasing the
  214. memory buffer.
  215.  
  216.  
  217.  
  218. EditSaveFile / FileSave
  219. -------------------------------------------------------------------------------
  220. These functions are very similar to their open counterparts, the only 
  221. differences being, instead of reading from the file and writing to the edit
  222. control, it is saved to the file and read from the control.
  223.  
  224.  
  225.  
  226. ConfirmOperation
  227. -------------------------------------------------------------------------------
  228. This is a simple utility function which i use to confirm that the user really
  229. wants to do what he says...
  230.  
  231. The function checks to see if the edit control has been modified, and if so, it
  232. shows a yes/no message box.  This is done by using the MessageBox API with the
  233. MB_YESNO option.  It then returns IDYES if the user chooses yes (or the control 
  234. has not been modified), or IDNO, if the user chooses no.
  235.  
  236.  
  237.  
  238. SetTitle
  239. -------------------------------------------------------------------------------
  240. This is another utility function which sets the application title to show the
  241. filename of the file currently being edited, or Untitled for a new file.
  242.  
  243. To do this, it sends the WM_SETTEXT message to the main application window, with
  244. the new title as the lParam.
  245.  
  246.  
  247.  
  248. Conclusion
  249. -------------------------------------------------------------------------------
  250. Hmm.. this turned out to be not much of a tutorial on edit controls... as I 
  251. have added a lot of non-edit control related code in an attempt to prevent the
  252. example program from being a completely useless app... Instead it is only a 
  253. mostly useless app...
  254.  
  255. Of course, for a detailed description of Edit Controls, read the Windows API 
  256. reference.
  257.  
  258.  
  259. -------------------------------------------------------------------------------
  260. Copyright (C) 1999 by Lucifer
  261. lord-lucifer@usa.net
  262.