C / C++ / MFC

cagespear4-Jul-08 1:23

cagespear

4-Jul-08 1:23

for the xtra '0' - Looks like I am already sleepy Sleepy | :zzz:

cagespear4-Jul-08 1:53

cagespear

4-Jul-08 1:53

Have put the timers now before leaving for weekend, hope eveything works good when I come back on Monday Smile | :)

CPallini4-Jul-08 1:41

4-Jul-08 1:41

Well, since the Elapse argument of the SetTimer can take a maximum of USER_TIMER_MAXIMUM (i.e. on my system, 0x7FFFFFFF milliseconds, that is about 25 days) I'm happy with it.
Moreover it isn't such a difficult task to make longer intervals using shorter ones.
Smile | :)

If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.

This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke

[My articles]

cagespear4-Jul-08 1:51

cagespear

4-Jul-08 1:51

I hear you. I can make small timers, kill them and do 'settimer' repeatedly, but then being a lazy programmer - was thinking of skipping them and just have a one-shot timer Big Grin | :-D

-Amit

CPallini4-Jul-08 2:01

4-Jul-08 2:01

cagespear wrote:
I can make small timers, kill them and do 'settimer' repeatedly

Counting isn't an option for you, is it?

cagespear wrote:
but then being a lazy programmer

No. It isn't an option.
Big Grin | :-D

MANISH RASTOGI4-Jul-08 2:09

MANISH RASTOGI

4-Jul-08 2:09

You can store datetime when application starts. Set some timer interval and read cureent time each time when receive WM_TIMER message. If the difference between application starting time and current time matches your requirement, take desired action.

Yves4-Jul-08 4:57

Yves

4-Jul-08 4:57

With this small class you can create a timer up to 1193 Hours

#pragma once<br />
<br />
#include <string><br />
<br />
typedef void (*TIMER_PROC)(UINT idEvent, void* obj);<br />
<br />
class CTimer  <br />
{<br />
public:<br />
   enum eTIME_TYPE<br />
   {<br />
      eONE_SHOT,<br />
      ePERIOIDIC<br />
   };<br />
<br />
public:<br />
   //--CONSTRUCTOR-------------------------------------<br />
	CTimer(eTIME_TYPE _eType, DWORD _dWaitPeriod, TIMER_PROC _pFunct, LPVOID _pSegment);<br />
   //--DESTRUCTOR--------------------------------------<br />
	virtual ~CTimer();<br />
<br />
public:<br />
   //--PUBLIC METHODS----------------------------------<br />
   inline const char*    GetErrorMessage(){ return m_szError.c_str(); }<br />
   UINT  Start();<br />
   void  Stop();<br />
   bool  SetPeriod(DWORD _dwVal);<br />
   eTIME_TYPE   TimerType() { return m_eTimerType; }<br />
   UINT  GetTimerID();<br />
<br />
protected:<br />
   //--PROTECTED ATTRIBUTES----------------------------<br />
   TIMER_PROC     m_pCALLBACKFUN;<br />
   void*          m_pSegm;<br />
   eTIME_TYPE     m_eTimerType;<br />
   DWORD          m_WaitPeriod;<br />
   DWORD          m_ThreadID;<br />
   HANDLE         m_hQuitEvent;<br />
   HANDLE         m_hThread;<br />
   HANDLE         m_hAdvisorThread;<br />
   HANDLE         m_hAdvise;<br />
   HANDLE         m_hQuitAdvisor;<br />
   std::string    m_szError;<br />
<br />
private:<br />
   //--PRIVATE METHODS---------------------------------<br />
   static void TimerThread(void* _pParam);<br />
   static void AdvisorThread(void* _pParam);<br />
};

The implementation

//--FILE INCLUDES--------------------------------------------------------<br />
#include <windows.h> <br />
#include "Timer.h"<br />
<br />
<br />
//!--CONSTRUCTOR-----------------------------------------------------------<br />
//<br />
//  Method Name:  CTimer(..., ...., ...)<br />
//<br />
/*!<br />
    Notes         Constructor.<br />
*/<br />
//-------------------------------------------------------------------------<br />
CTimer::CTimer(eTIME_TYPE _eType, DWORD _dWaitPeriod, TIMER_PROC _pFunct, LPVOID _pSegment)<br />
{<br />
   m_pCALLBACKFUN = NULL;<br />
   m_pSegm = NULL;<br />
   m_eTimerType = _eType;<br />
   m_WaitPeriod = _dWaitPeriod;<br />
   if( m_WaitPeriod == 0 )<br />
      m_WaitPeriod = 1;<br />
   m_hThread = m_hAdvisorThread = NULL;<br />
   m_ThreadID=0;<br />
   m_pCALLBACKFUN = _pFunct;<br />
   m_pSegm = _pSegment;<br />
   m_hQuitEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);<br />
   m_hQuitAdvisor = ::CreateEvent(NULL, TRUE, FALSE, NULL);<br />
   m_hAdvise =  ::CreateEvent(NULL, FALSE, FALSE, NULL);<br />
   m_hAdvisorThread = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)AdvisorThread, this, 0, 0);<br />
}<br />
<br />
<br />
//!--DESTRUCTOR-------------------------------------------------------------<br />
//<br />
// Method Name:  ~CTimer()<br />
//<br />
/*!<br />
<br />
   Notes         Destructor. Clean-up<br />
*/			<br />
//--------------------------------------------------------------------------<br />
CTimer::~CTimer()<br />
{<br />
   try<br />
   {<br />
      Stop();<br />
      ::SetEvent(m_hQuitAdvisor);<br />
      if( m_hAdvisorThread )<br />
      {<br />
        switch( ::WaitForSingleObject(m_hAdvisorThread, 200) )<br />
        {<br />
         case WAIT_TIMEOUT:<br />
            // No Response close anyway.<br />
            ::TerminateThread(m_hAdvisorThread, 0);<br />
            ::CloseHandle(m_hAdvisorThread);<br />
            m_hAdvisorThread = NULL;<br />
            break;<br />
         }<br />
      }<br />
      if( m_hQuitAdvisor != INVALID_HANDLE_VALUE )<br />
         ::CloseHandle(m_hQuitAdvisor);<br />
   }<br />
   catch(...)<br />
   {}<br />
}<br />
<br />
<br />
///////////////////////////////////////////////////////////////////////////<br />
//                         Private Functions<br />
///////////////////////////////////////////////////////////////////////////<br />
<br />
<br />
//-METHOD IMPLEMENTATION----------------------------------------------------<br />
//<br />
// Method Name:   AdvisorThread<br />
//<br />
/*!Access:        Private<br />
<br />
   Parameters<br />
<br />
   IN             Description<br />
<br />
   <void*>        As usual.<br />
<br />
   OUT            Description<br />
<br />
   <None><br />
<br />
   Notes:         We advise Parent Here.<br />
                  If by mistake the parent keep Hand on CallBack<br />
                  it would stuck the thread. But here even if this happened<br />
                  the class would still working.<br />
                  The best is to use a WatchDog ... at this moment don't want to.<br />
*/<br />
//--------------------------------------------------------------------------<br />
void CTimer::AdvisorThread(void* _pParam)<br />
{<br />
   CTimer* me = (CTimer*)_pParam;<br />
   bool bContinue = true;<br />
   HANDLE  hEvent[2];<br />
   hEvent[0] = me->m_hQuitAdvisor;<br />
   hEvent[1] = me->m_hAdvise;<br />
<br />
   while( bContinue )<br />
   {<br />
      DWORD dw = ::WaitForMultipleObjects(2, hEvent, FALSE, INFINITE);<br />
      switch(dw)<br />
      {<br />
      case WAIT_OBJECT_0 + 0:<br />
         bContinue =false;<br />
         break;<br />
      case WAIT_OBJECT_0 + 1:<br />
         if( me->m_pCALLBACKFUN )<br />
            me->m_pCALLBACKFUN(me->m_ThreadID, me->m_pSegm);<br />
         break;<br />
      }<br />
   }<br />
   ::CloseHandle(me->m_hAdvisorThread);<br />
   me->m_hAdvisorThread = NULL;<br />
}<br />
<br />
<br />
//-METHOD IMPLEMENTATION----------------------------------------------------<br />
//<br />
// Method Name:   TimerThread<br />
//<br />
/*!Access:        Private<br />
<br />
   Parameters<br />
<br />
   IN             Description<br />
<br />
   <void*>        As usual.<br />
<br />
   OUT            Description<br />
<br />
   <None><br />
<br />
   Notes:         <br />
*/<br />
//--------------------------------------------------------------------------<br />
void CTimer::TimerThread(void* _pParam)<br />
{<br />
   CTimer* me = (CTimer*)_pParam;<br />
   bool bContinue = true;<br />
<br />
   while( bContinue )<br />
   {<br />
      switch ( ::WaitForSingleObject(me->m_hQuitEvent, me->m_WaitPeriod))<br />
      {<br />
         case WAIT_OBJECT_0:<br />
            bContinue = false;<br />
            break;<br />
         case WAIT_TIMEOUT:<br />
            if( me->m_eTimerType == eONE_SHOT )<br />
               ::SetEvent(me->m_hQuitEvent);<br />
            ::SetEvent(me->m_hAdvise);<br />
            break;<br />
      }//end switch<br />
   }//end while<br />
   ::CloseHandle(me->m_hThread);<br />
   me->m_hThread = NULL;<br />
}<br />
<br />
<br />
///////////////////////////////////////////////////////////////////////////<br />
//                         Public Functions<br />
///////////////////////////////////////////////////////////////////////////<br />
<br />
<br />
<br />
//-METHOD IMPLEMENTATION----------------------------------------------------<br />
//<br />
// Method Name:   Start<br />
//<br />
/*!Access:        Public<br />
<br />
   Parameters<br />
<br />
   IN             Description<br />
<br />
   <None><br />
<br />
   OUT            Description<br />
<br />
   <UINT>         Return a unique identifier.<br />
<br />
   Notes:         Start The Process Timer<br />
*/<br />
//--------------------------------------------------------------------------<br />
UINT CTimer::Start()<br />
{<br />
   if( m_hThread == NULL )<br />
   {<br />
     ::ResetEvent(m_hQuitEvent);<br />
      m_hThread = ::CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)TimerThread, this,<br />
				                     0, &m_ThreadID);<br />
   }<br />
   return m_ThreadID;<br />
}<br />
<br />
<br />
//-METHOD IMPLEMENTATION----------------------------------------------------<br />
//<br />
// Method Name:   Stop<br />
//<br />
/*!Access:        Public<br />
<br />
   Parameters<br />
<br />
   IN             Description<br />
<br />
   <None><br />
<br />
   OUT            Description<br />
<br />
   <None><br />
<br />
   Notes:         Stop Timer ...<br />
*/<br />
//--------------------------------------------------------------------------<br />
void  CTimer::Stop()<br />
{<br />
   ::SetEvent(m_hQuitEvent);<br />
   DWORD dWaitMax = m_WaitPeriod * 2;<br />
   if( dWaitMax == 0 )<br />
      dWaitMax = 500;<br />
<br />
   if( m_hThread )<br />
   {<br />
     switch( ::WaitForSingleObject(m_hThread, dWaitMax) )<br />
     {<br />
      case WAIT_TIMEOUT:<br />
         // No Response close anyway.<br />
         ::TerminateThread(m_hThread, 0);<br />
         ::CloseHandle(m_hThread);<br />
         m_hThread = NULL;<br />
         break;<br />
      }<br />
   }<br />
   m_ThreadID =0;<br />
}<br />
<br />
<br />
//-METHOD IMPLEMENTATION----------------------------------------------------<br />
//<br />
// Method Name:   SetPeriod<br />
//<br />
/*!Access:        Public<br />
<br />
   Parameters<br />
<br />
   IN             Description<br />
<br />
   <DWORD>        New periode Value<br />
<br />
   OUT            Description<br />
<br />
   <bool>         true if succeeded.<br />
<br />
   Notes:         Use it if Timer is not Working.<br />
*/<br />
//--------------------------------------------------------------------------<br />
bool  CTimer::SetPeriod(DWORD _dwVal)<br />
{<br />
   if( m_hThread )<br />
   {<br />
      m_szError = "Thread is working..could not set.";<br />
      return false;<br />
   }<br />
   m_WaitPeriod = _dwVal;<br />
   return true;<br />
}<br />
<br />
<br />
UINT  CTimer::GetTimerID()<br />
{<br />
   return m_ThreadID;<br />
}<br />

David Crow4-Jul-08 11:38

David Crow

4-Jul-08 11:38

cagespear wrote:
...I need to take some action at lets say - 24 hours after the app has opened.

What if you created a scheduled task?

"Love people and use things, not love things and use people." - Unknown

"To have a respect for ourselves guides our morals; to have deference for others governs our manners." - Laurence Sterne

file writing help

projectip4-Jul-08 0:38

projectip

4-Jul-08 0:38

I have a dialog based application.In this I have a button which takes the value in a textbox and adds it to a combobox.I have to enter values in three textboxes.All these values have to be written into a file.
I have writen the code as follows:

GetDlgItemText(IDC_EDIT1,str1);<br />
GetDlgItemText(IDC_EDIT1,str2);<br />
GetDlgItemText(IDC_EDIT1,str3);<br />
fstream f;<br />
f.open("myfile.txt",ios::in|ios::out);<br />
f.write(str1,str1.length());

When i open the file to view the contents,its not written properly.Also I want to append the details each time I enter values in the textboxes.

CPallini4-Jul-08 0:56

4-Jul-08 0:56

How str1, str2, str3 are declared.
What values were assigned to such variables?
What is written inside the file, insted?
Smile | :)

projectip4-Jul-08 8:55

projectip

4-Jul-08 8:55

All of str1,str2 and str3 are CString variables.the str3 im using is the name of a camera.appending is not done properly.file contents are not written properly...

CPallini4-Jul-08 23:23

4-Jul-08 23:23

How can we help you if you are so reluctant to provide meaningful info?
Smile | :)

KarstenK4-Jul-08 0:57

KarstenK

4-Jul-08 0:57

You wrote only the first string. What isnt properly?

Read the docs to fstream. This is really beginners stuff. D'Oh! | :doh:

Greetings from Germany

vineeshV4-Jul-08 2:02

vineeshV

4-Jul-08 2:02

try this
change the fopen as

f.open(myfile.txt",ios::in|ios::out|ios::app);

vineesh