C / C++ / MFC

int MFC::Dialog::DoModal() 
{
    int cWC = MultiByteToWideChar(CP_ACP, 0, m_strCaption, -1, NULL, 0);
    int szBoxLen = cWC + 1;
    WCHAR *szBoxCaption = new WCHAR[szBoxLen];
// ...

int MFC::Dialog::DoModal() 
{
	//For OK and Cancel buttons??
	m_DialogTemplate.cy+=(DlgControls.size()*4);

	AddOkCancel();

	int iRet=0;
	
	//presetting for caption in the dialog....
		
	int cWC = MultiByteToWideChar(CP_ACP, 0, m_strCaption, -1, NULL, 0);
	int szBoxLen = cWC + 1;
	WCHAR *szBoxCaption = new WCHAR[szBoxLen];
	// Copy the string...
	MultiByteToWideChar(CP_ACP, 0, m_strCaption, -1, (LPWSTR) szBoxCaption, cWC);
	szBoxCaption[cWC] = 0;
	szBoxLen = (cWC) * sizeof(WCHAR);
	
	int nBufferSize =  sizeof(DLGTEMPLATE) + (2 * sizeof(WORD)) /*menu and class*/ + szBoxLen /*size of caption*/
		+ sizeof(WORD) /*fontsize*/ ;//+ nFontNameLen /*size of fontname*/;

	HLOCAL hLocal = LocalAlloc(LHND, nBufferSize);
	if (hLocal != NULL) {
		BYTE* pBuffer = (BYTE*)LocalLock(hLocal);
		if (pBuffer == NULL) {
			LocalFree(hLocal);
			AfxMessageBox(_T("D::DoModal() : LocalLock Failed"));
		}

		BYTE *pdest = pBuffer;
		// transfer DLGTEMPLATE structure to the buffer
		memcpy(pdest, &m_DialogTemplate, sizeof(DLGTEMPLATE));	// DLGTemplate
		pdest += sizeof(DLGTEMPLATE);
		*(WORD*)pdest = 0;									// no menu					-- WORD to say it is 0 bytes
		pdest += sizeof(WORD);								// Increment
		*(WORD*)(pdest + 1) = 0;							// use default window class -- WORD to say it is 0 bytes
		pdest += sizeof(WORD);								// Increment
		memcpy(pdest, szBoxCaption, szBoxLen);			// Caption
		pdest += szBoxLen;
		
		//These are the MFC functions, which do the job...
	
		InitModalIndirect((LPDLGTEMPLATE)pBuffer, m_pParentWnd);
		iRet = CDialog::DoModal();
		
		LocalUnlock(hLocal);
		LocalFree(hLocal);
		return iRet;
	}
	else {
		AfxMessageBox(_T("D::DoModal() : LocalAllock Failed"));
		return -1;
	}
}

#define TICK_EXPIRED(dwActTick, dwToTick) ((long)(dwToTick - dwActTick) <= 0)
#define TICK_ELAPSED(dwTime) TICK_EXPIRED(GetTickCount(), dwTime)

template <typename T>
class DelaySetVar
{
  CCriticalSection m_cLocalLock;
  T                m_value;

  CCriticalSection              m_cMapLock;
  volatile bool                 m_bPleaseExitNow;
  CMap<DWORD,DWORD,DWORD,DWORD> m_mapLiveThreads;

  class SetThreadParam
  {
    friend class DelaySetVar;

    DelaySetVar*      m_pcVarObject;
    const T           m_SetValue;
    DWORD             m_dwDelay;

  public:
    SetThreadParam(DelaySetVar* pcVarObject,
                   const T& set_value,
                   DWORD dwMsDelay)
      : m_pcVarObject(pcVarObject),
        m_SetValue(set_value),
        m_dwDelay(dwMsDelay) {};
  };

  static UINT AFX_CDECL ValueSetProc(void* pParam)
  {
    SetThreadParam* pSetParam = (SetThreadParam*) pParam;
    if (pSetParam) {
      DWORD dwTimeOut = GetTickCount() + pSetParam->m_dwDelay;
      while (!pSetParam->m_pcVarObject->m_bPleaseExitNow) {
        if (TICK_ELAPSED(dwTimeOut)) {
          CSingleLock cLock(&pSetParam->m_pcVarObject->m_cLocalLock, TRUE);
          pSetParam->m_pcVarObject->m_value = pSetParam->m_SetValue;
          break;
        }
        Sleep(1);
      }
      pSetParam->m_pcVarObject->ThreadEndEvent(GetCurrentThreadId());
      delete pSetParam;
    }
    return 0;
  };

  void ThreadBegEvent(DWORD dwThreadID)
  {
    CSingleLock cLock(&m_cMapLock, TRUE);
    m_mapLiveThreads.SetAt(dwThreadID, dwThreadID);
  };

  void ThreadEndEvent(DWORD dwThreadID)
  {
    CSingleLock cLock(&m_cMapLock, TRUE);
    m_mapLiveThreads.RemoveKey(dwThreadID);
  };

public:
  // Constructors do set the values without any delay
  DelaySetVar()
    : m_value(),
      m_bPleaseExitNow(false) {};

  DelaySetVar(const T& init)
    : m_value(init),
      m_bPleaseExitNow(false) {};

  // Destructor should wait for the exiting of all threads
  ~DelaySetVar()
  {
    m_bPleaseExitNow = true;
    while (true) {
      {
        CSingleLock cLock(&m_cMapLock, TRUE);
        if (!m_mapLiveThreads.GetCount()) {
          break;
        }
      }
      Sleep(1);
    }
  }

  // Access functions, must be synchronized
  // since the delayed sets are possible

  const T& GetValue() {
    CSingleLock cLock(&m_cLocalLock, TRUE);
    return m_value;
  };

  void SetValue(const T& set_value, DWORD dwMsDelay = 0)
  {
    if (!m_bPleaseExitNow) {
      if (dwMsDelay) {
        CWinThread* pcThread = ::AfxBeginThread(ValueSetProc,
                                                new SetThreadParam(this,
                                                                   set_value,
                                                                   dwMsDelay),
                                                0, CREATE_SUSPENDED);
        if (pcThread) {
          pcThread->m_bAutoDelete = true;
          ThreadBegEvent(pcThread->m_nThreadID);
          pcThread->ResumeThread();
        }
      } else {
        CSingleLock cLock(&m_cLocalLock, TRUE);
        m_value = set_value;
      }
    }
  };
};

{
  DelaySetVar<int> iVar(3);           // Init without delay
  iVar.SetValue(2, 2000);             // Set with delay
  do {
    cout << iVar.GetValue() << '\n';
  } while (3 == iVar.GetValue());
  cout << iVar.GetValue() << '\n';
  iVar.SetValue(3);                   // Set without delay
  cout << iVar.GetValue() << '\n';
  iVar.SetValue(4, 2000);             // Set with delay,
                                      // But note: iVar have to die now... :)
}

They sought it with thimbles, they sought it with care;
They pursued it with forks and hope;
They threatened its life with a railway-share;
They charmed it with smiles and soap.

modified on Thursday, September 30, 2010 6:00 AM