C / C++ / MFC

#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

pCombo->DeleteString(2);
pCombo->DeleteString(3);
pCombo->ShowDropDown(TRUE);

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.

//#include <windows.h>
//#pragma comment(lib, "user32.lib")

void CYourDialog::Test()
{
  CComboBox* pcBox = (CComboBox*) GetDlgItem(IDC_COMBO1);
  if (pcBox->GetSafeHwnd()) {
    pcBox->ShowDropDown(TRUE);
    
    COMBOBOXINFO sCBINFO = {0};
    sCBINFO.cbSize = sizeof(COMBOBOXINFO);
    
    if (::GetComboBoxInfo(pcBox->GetSafeHwnd(), &sCBINFO)) {
      if (sCBINFO.hwndList) {
        CWnd* pcList = CWnd::GetFromHandle(sCBINFO.hwndList);
        CRect cListRect;
        pcList->GetWindowRect(cListRect);
        cListRect.bottom -= 20;
        pcList->MoveWindow(cListRect);
      }
    }
  }
}

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.

void CYourDialog::AdjustComboBox(CComboBox* pcBox)
{
  if (pcBox->GetSafeHwnd()) {    
    COMBOBOXINFO sCBINFO = {0};
    sCBINFO.cbSize = sizeof(COMBOBOXINFO);
    if (::GetComboBoxInfo(pcBox->GetSafeHwnd(), &sCBINFO)) {
      if (sCBINFO.hwndList) {
        CWnd* pcList = CWnd::FromHandle(sCBINFO.hwndList);
        CRect cListRect;
        pcList->GetWindowRect(cListRect);
        // do not worry, the bottom will be correctly adjusted:
        cListRect.bottom = cListRect.top; 
        pcList->MoveWindow(cListRect);
      }
    }
  }
}

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.