Articles   Members Online:
-Article/Tip Search
-News Group Search over 21 Million news group articles.
-Delphi/Pascal
-CBuilder/C++
-C#Builder/C#
-JBuilder/Java
-Kylix
Member Area
-Home
-Account Center
-Top 10 NEW!!
-Submit Article/Tip
-Forums Upgraded!!
-My Articles
-Edit Information
-Login/Logout
-Become a Member
-Why sign up!
-Newsletter
-Chat Online!
-Indexes NEW!!
Employment
-Build your resume
-Find a job
-Post a job
-Resume Search
Contacts
-Contacts
-Feedbacks
-Link to us
-Privacy/Disclaimer
Embarcadero
Visit Embarcadero
Embarcadero Community
JEDI
Links
Long-running processes Turn on/off line numbers in source code. Switch to Orginial background IDE or DSP color Comment or reply to this aritlce/tip for discussion. Bookmark this article to my favorite article(s). Print this article
15-Aug-05
Category
N/A
Language
Delphi All Versions
Views
136
User Rating
No Votes
# Votes
0
Replies
0
Publisher:
Crann, Ian
Reference URL:
			1   {
2     When writing a program where the processing takes a long time to
3     complete, it is useful to provide the user with an indication of 
4     progress and allow him to interrupt the processing.  Examples of 
5     this are programs which perform long calculations or search
6     a large database.  This tip shows one way of achieving this using
7     Windows messages and the application idle event.  To use this
8     approach, it must be possible to break down the processing into 
9     smaller chunks (for example, searching 500 records at a time).
10  
11    The code below shows how this was done for an application which did 
12    a very large number of calculations (about a billion).  The code has
13    been simplified to make the principle clearer.
14  
15     - A user message identifier is required.
16  } 
17    const
18      kTestRH = WM_USER +  9;
19  {
20     - The form included the following controls and event handlers.
21  }
22    type TzfTest = class (TForm)
23         ...
24        zbTRH  : TButton;            //  Start button.
25        zbC    : TButton;            //  Cancel button.
26        zntSR  : TEdit;              //  Progress text box.
27        zaeE   : TApplicationEvents;
28         ...
29      //  Application idle event.
30        procedure zaeE_I  (    Sender : TObject; 
31                           var Done   : boolean);
32      //  Start button click event.
33        procedure zbTRH_K (    Sender : TObject);
34      //  Cancel button click event.
35        procedure zbC_K   (    Sender : TObject);
36         ...
37  {
38     - The form also included the following methods and variables.
39  }
40      private
41        iSR  : integer;              //  Starting number.
42        iER  : integer;              //  Ending number.
43        iLim : integer;              //  Number of calculations in a chunk.
44        iAct : boolean;              //  Processing active flag.
45         ...
46        procedure mhProcRH (var pMsg : TMessage); message kTestRH;
47  {
48     - The method which starts the processing sets up the variables
49       and posts a user-defined Windows message.  This is done in 
50       the Start button's click event.
51  }
52    procedure TzfTest.zbTRH_K (Sender : TObject);
53      begin
54        iSR  := -500000000;          //  Starting value.
55        iER  :=  500000000;          //  Ending value.
56        iLim :=      10000;          //  Number of calculations in a "chunk".
57        iAct := true;                //  Set the "active" flag.
58        PostMessage (Handle,
59                     kTestRH,        //  User-defined message.
60                     0,
61                     0)
62      end;
63  {
64     - The message handling method performs a chunk of processing, then
65       updates the progress indicator and tests whether to end.
66  }
67    procedure TzfTest.mhProcRH (var pMsg : TMessage);
68      var
69        wCount : integer;
70      begin
71        if iAct then
72          begin
73            wCount := 0;
74            while (wCount < iLim) and (iSR <= iER) do
75              begin
76                 ...                   //  Perform one calculation.
77                Inc (wCount);
78                Inc (iSR)
79              end;
80            zntSR.Text := IntToStr (iSR);  //  Update the progress indicator.
81            if iSR >= iER then         //  If finished, clear the flag.
82              iAct := false          
83          end
84      end;
85  {
86     - Once all the Windows and VCL activity to update the progress indicator 
87       has completed, the application idle event is called.  This checks
88       whether processing is complete, and posts another message if not.
89  }
90    procedure TzfTest.zaeE_I (    Sender : TObject;
91                              var Done   : boolean);
92      begin
93        if iAct then                 //  If more processing required ...
94          PostMessage (Handle,       //   ... request another chunk.
95                       kTestRH,
96                       0,
97                       0)
98      end;
99  {
100    - The Cancel button allows the user to interrupt the processing.  This
101      has the following click event method.  If the user clicks the button
102      then the "active" flag is reset, so the idle event will no longer post
103      messages to the message processing event.
104 }
105   procedure TzfTest.zbC_K (Sender : TObject);
106     begin
107       iAct := false
108     end;
109 {
110   This approach could be enhanced as follows:
111    - Change the cursor (to crAppStart, perhaps) while processing is active.
112    - Disable the Start button (and other controls on the form) while processing 
113      is active.
114    - Instead of using a Cancel button, have a key press event on the form
115      so that the user can "Press Esc to cancel".
116    - Make the number of calculations in a chunk variable by the user.
117    - Have the program determine the number of calculations dynamically by
118      setting an initial value, measuring how long the first chunk takes, and
119      then adjusting the value so that subsequent chunks takes a fixed time.
120    - If the long-running process is searching a file or a database, then the
121      start and end values (iSR and iER) are not needed.  You would need some
122      other way of indicating progress (perhaps the key of the last record
123      examined), and also code at the end to clean up (close the file or the
124      query cursor).
125 }


			
Vote: How useful do you find this Article/Tip?
Bad Excellent
1 2 3 4 5 6 7 8 9 10

 

Advertisement
Share this page
Advertisement
Download from Google

Copyright © Mendozi Enterprises LLC