🚀 go-pugleaf

Tommy wrote:

>1. completly size of all bytes which need to be copy (size)
>2. size of already copied bytes (already_copied)
>3. percent of already copied size (CGauge2->Progress)
>
>QueryPerformanceCounter(&start_ticks);
>QueryPerformanceFrequency(&frequenz);
>dir_create(ESource->Text,ETarget->Text);
>
>Now I have a Timer in my applcation which clocks echt second.
>
>void __fastcall TForm1::Timer1Timer(TObject *Sender)
>{
>   rest = size-already_copied;
>   QueryPerformanceCounter(&ende_ticks);
>   tick_diff = ((double) ende_ticks.QuadPart - (double)
>start_ticks.QuadPart)  frequenz.QuadPart;
>   if (already_copied > 0)

>   LRestdauer->Caption = int(double((double)rest/(double)already_copied) *
>(double)tick_diff) + " s";

TIP: When writing math fomulas with a lot of casting, it's often
prudent to add a coment showing the math without all the fluff.
So:
	(Remaining / Copied) * Elapsed
Yep, that's the math, all right.
But, you can do it with integers if you rearange things:
	(Remaining * Elapsed) / Copied
Added benefit, if Elpased is in 1/1000's second, RemainingTime will be
also. So you can define your precision by how precise ElapsedTime is.


>Any Idea why this to not works. Is there perhabs a better way to get the
>seconds which are need till the process is finished?

Way too complicated.
Aren't you using CopyFileEx() ?  The Callback happens fairly often
(more than once per second on my system), so no Timer needed.
And the Performance Counter isn't needed either. You aren't doing
multimedia or guideance systems.  System Time is accurate enough for
this job.

 Use GetSystemTimeAsFileTime()
The 64bit result is 10 million per second, so divide by 10 million to
get seconds:

	GetSystemTimeAsFileTime( &ftNow );
	ElapsedSeconds = ( ftNow - ftStart ) / 10000000uint64;
You have to do some fiddling to get the FILETIMEs into UINT64s so you
can subtract them

Now, I wanted to use FILETIME to figure out how many
hours:minutes:seconds were left, so I didn't divide Elapsed by 10
million. But, it doesn't take too many Gigs on a slow connection to
overflow when you are multiplying by 10 million per second.
    Talking Gigs * 10millions, it will take a total of
    4Gigs * 400(10millions) to overflow the uint64.
To avoid Overflow, I ballparked a figure of 10,000 which gives me
400Gigs remaining after 40,000 seconds, and still leaves me with
elapsed acuracy of 1/1000 second (important in the early stages of the
copy)
	(  (Remaining * (Elapsed/10000)) / Copied  )*10000
	FileTimeToSystemTime( &ftRemaining, &SystemTime );
	Display SystemTime as Hours:Minutes:Seconds