void CFileBrowserListCtrl::GetSelection(CDWordArray& SelIdx) const
{
int selcnt = GetSelectedCount();
SelIdx.SetSize(selcnt);
POSITION pos = GetFirstSelectedItemPosition();
for (int i = 0; i < selcnt; i++)
SelIdx[i] = GetNextSelectedItem(pos);
}
CDWordArray * GetRegistryDWordArray(HKEY root, const CString &var)
{
CString path;
DWORD len;
DWORD type;
path.LoadString(IDS_PROGRAM_ROOT);
CString name;
makePath(path, var, name);
HKEY key;
LONG result = ::RegOpenKey(root, path, &key);
if(result != ERROR_SUCCESS)
{ /* failed */
::SetLastError(result);
return NULL;
} /* failed */
result = ::RegQueryValueEx(key, name, 0, &type, NULL, &len);
if(result != ERROR_SUCCESS)
{ /* failed */
::SetLastError((DWORD)result);
::RegCloseKey(key);
return NULL;
} /* failed */
CDWordArray * data = new CDWordArray;
DWORD count = len / sizeof(DWORD);
data->SetSize((int)count); // preallocate the array data
result = ::RegQueryValueEx(key, name, 0, &type, (LPBYTE)&(*data)[0], &len);
if(result != ERROR_SUCCESS)
{ /* failed */
::RegCloseKey(key);
::SetLastError((DWORD)result);
delete data;
return NULL;
} /* failed */
::RegCloseKey(key);
if(type != REG_BINARY)
{ /* wrong type */
::SetLastError(ERROR_INVALID_DATA);
delete data;
return NULL;
} /* wrong type */
return data;
}
BOOL CBCGPRegistry::Write(LPCTSTR pszKey, LPPOINT& lpPoint)
{
if (m_bReadOnly)
{
ASSERT (FALSE);
return FALSE;
}
ASSERT(m_hKey);
BYTE* pData = NULL;
DWORD dwLen = 0;
{
CMemFile file(32);
CArchive ar(&file, CArchive::store);
CDWordArray dwcArray;
dwcArray.SetSize(2);
dwcArray.SetAt(0, lpPoint->x);
dwcArray.SetAt(1, lpPoint->y);
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
dwLen = (DWORD) file.GetLength();
pData = file.Detach();
}
ASSERT(pData != NULL && dwLen > 0);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
pData, dwLen);
m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_POINT;
if (pData != NULL)
{
free(pData);
pData = NULL;
}
if(lReturn == ERROR_SUCCESS)
return TRUE;
return FALSE;
}
BOOL CRegistry::Read(LPCTSTR pszKey, LPPOINT& lpPoint)
{
ASSERT(m_hKey);
const int iMaxChars = 20;
CDWordArray dwcArray;
DWORD dwType;
DWORD dwData = iMaxChars;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);
LONG lReturn = RegQueryValueEx(m_hKey, pszKey, NULL, &dwType,
byData, &dwData);
if(lReturn == ERROR_SUCCESS && dwType == REG_BINARY)
{
ASSERT(dwData < iMaxChars);
CMemFile file(byData, dwData);
CArchive ar(&file, CArchive::load);
ar.m_bForceFlat = FALSE;
ASSERT(ar.IsLoading());
ASSERT(dwcArray.IsSerializable());
dwcArray.RemoveAll();
dwcArray.SetSize(5);
dwcArray.Serialize(ar);
ar.Close();
file.Close();
lpPoint->x = dwcArray.GetAt(0);
lpPoint->y = dwcArray.GetAt(1);
}
m_Info.lMessage = lReturn;
m_Info.dwType = REG_POINT;
m_Info.dwSize = sizeof(POINT);
if(byData)
{
free(byData);
byData = NULL;
}
if(lReturn == ERROR_SUCCESS)
return TRUE;
return FALSE;
}
BOOL CRegistry::Write(LPCTSTR pszKey, LPPOINT& lpPoint)
{
if (m_bReadOnly)
{
ASSERT (FALSE);
return FALSE;
}
ASSERT(m_hKey);
const int iMaxChars = 20;
CDWordArray dwcArray;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);
dwcArray.SetSize(5);
dwcArray.SetAt(0, lpPoint->x);
dwcArray.SetAt(1, lpPoint->y);
CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
const DWORD dwLen = (DWORD) file.GetLength();
ASSERT(dwLen < iMaxChars);
LONG lReturn = RegSetValueEx(m_hKey, pszKey, 0, REG_BINARY,
file.Detach(), dwLen);
m_Info.lMessage = lReturn;
m_Info.dwSize = dwLen;
m_Info.dwType = REG_POINT;
if(byData)
{
free(byData);
byData = NULL;
}
if(lReturn == ERROR_SUCCESS)
return TRUE;
return FALSE;
}
int CTDCTaskListCtrl::GetSelectedTaskIDs(CDWordArray& aTaskIDs, DWORD& dwFocusedTaskID) const
{
aTaskIDs.RemoveAll();
aTaskIDs.SetSize(m_lcTasks.GetSelectedCount());
int nCount = 0;
POSITION pos = m_lcTasks.GetFirstSelectedItemPosition();
while (pos)
{
int nItem = m_lcTasks.GetNextSelectedItem(pos);
aTaskIDs[nCount] = m_lcTasks.GetItemData(nItem);
nCount++;
}
dwFocusedTaskID = GetFocusedListTaskID();
ASSERT((!aTaskIDs.GetSize() && (dwFocusedTaskID == 0)) || (Misc::FindT(aTaskIDs, dwFocusedTaskID) >= 0));
return aTaskIDs.GetSize();
}
//***************************************************************************************
BOOL CBCGPXMLSettings::Read(LPCTSTR pszKey, LPPOINT& lpPoint)
{
BOOL bSucess = FALSE;
BYTE* pData = NULL;
UINT uDataSize;
if (!Read (pszKey, &pData, &uDataSize))
{
ASSERT (pData == NULL);
return FALSE;
}
ASSERT (pData != NULL);
try
{
CMemFile file (pData, uDataSize);
CArchive ar (&file, CArchive::load);
CDWordArray dwcArray;
dwcArray.SetSize(5);
dwcArray.Serialize (ar);
lpPoint->x = dwcArray.GetAt(0);
lpPoint->y = dwcArray.GetAt(1);
bSucess = TRUE;
}
catch (CMemoryException* pEx)
{
pEx->Delete ();
TRACE(_T("Memory exception in CBCGPXMLSettings::Read ()!\n"));
}
catch (CArchiveException* pEx)
{
pEx->Delete ();
TRACE(_T("CArchiveException exception in CBCGPXMLSettings::Read ()!\n"));
}
return TRUE;
}
//***************************************************************************************
BOOL CBCGPXMLSettings::Write(LPCTSTR pszKey, LPPOINT& lpPoint)
{
if (m_bReadOnly)
{
ASSERT (FALSE);
return FALSE;
}
const int iMaxChars = 20;
CDWordArray dwcArray;
BYTE* byData = (BYTE*)::calloc(iMaxChars, sizeof(TCHAR));
ASSERT(byData);
dwcArray.SetSize(5);
dwcArray.SetAt(0, lpPoint->x);
dwcArray.SetAt(1, lpPoint->y);
CMemFile file(byData, iMaxChars, 16);
CArchive ar(&file, CArchive::store);
ASSERT(dwcArray.IsSerializable());
dwcArray.Serialize(ar);
ar.Close();
#if _MSC_VER >= 1300
ULONGLONG dwLen = file.GetLength ();
#else
const DWORD dwLen = file.GetLength ();
#endif
LPBYTE lpbData = file.Detach ();
BOOL bRes = Write (pszKey, lpbData, (UINT) dwLen);
if(byData)
{
free(byData);
byData = NULL;
}
return bRes;
}
BOOL CBCGPRegistry::Read (LPCTSTR pszKey, CDWordArray& dwcArray)
{
dwcArray.RemoveAll ();
dwcArray.SetSize (0);
return Read (pszKey, (CObject&) dwcArray);
}
void AFXAPI AfxDumpStack(DWORD dwTarget /* = AFX_STACK_DUMP_TARGET_DEFAULT */)
{
CTraceClipboardData clipboardData(dwTarget);
clipboardData.SendOut("=== begin AfxDumpStack output ===\r\n");
CDWordArray adwAddress;
HANDLE hProcess = ::GetCurrentProcess();
if (SymInitialize(hProcess, NULL, FALSE))
{
// force undecorated names to get params
DWORD dw = SymGetOptions();
dw &= ~SYMOPT_UNDNAME;
SymSetOptions(dw);
HANDLE hThread = ::GetCurrentThread();
CONTEXT threadContext;
threadContext.ContextFlags = CONTEXT_FULL;
if (::GetThreadContext(hThread, &threadContext))
{
STACKFRAME stackFrame;
memset(&stackFrame, 0, sizeof(stackFrame));
stackFrame.AddrPC.Mode = AddrModeFlat;
DWORD dwMachType;
#if defined(_M_IX86)
dwMachType = IMAGE_FILE_MACHINE_I386;
// program counter, stack pointer, and frame pointer
stackFrame.AddrPC.Offset = threadContext.Eip;
stackFrame.AddrStack.Offset = threadContext.Esp;
stackFrame.AddrStack.Mode = AddrModeFlat;
stackFrame.AddrFrame.Offset = threadContext.Ebp;
stackFrame.AddrFrame.Mode = AddrModeFlat;
#elif defined(_M_MRX000)
// only program counter
dwMachType = IMAGE_FILE_MACHINE_R4000;
stackFrame.AddrPC. Offset = treadContext.Fir;
#elif defined(_M_ALPHA)
// only program counter
dwMachType = IMAGE_FILE_MACHINE_ALPHA;
stackFrame.AddrPC.Offset = (unsigned long) threadContext.Fir;
#elif defined(_M_PPC)
// only program counter
dwMachType = IMAGE_FILE_MACHINE_POWERPC;
stackFrame.AddrPC.Offset = threadContext.Iar;
#elif
#error("Unknown Target Machine");
#endif
adwAddress.SetSize(0, 16);
int nFrame;
for (nFrame = 0; nFrame < 1024; nFrame++)
{
if (!StackWalk(dwMachType, hProcess, hProcess,
&stackFrame, &threadContext, NULL,
FunctionTableAccess, GetModuleBase, NULL))
{
break;
}
adwAddress.SetAtGrow(nFrame, stackFrame.AddrPC.Offset);
}
}
}
else
{
DWORD dw = GetLastError();
char sz[100];
wsprintfA(sz,
"AfxDumpStack Error: IMAGEHLP.DLL wasn't found. "
"GetLastError() returned 0x%8.8X\r\n", dw);
clipboardData.SendOut(sz);
}
// dump it out now
int nAddress;
int cAddresses = adwAddress.GetSize();
for (nAddress = 0; nAddress < cAddresses; nAddress++)
{
SYMBOL_INFO info;
DWORD dwAddress = adwAddress[nAddress];
char sz[20];
wsprintfA(sz, "%8.8X: ", dwAddress);
clipboardData.SendOut(sz);
if (ResolveSymbol(hProcess, dwAddress, info))
{
clipboardData.SendOut(info.szModule);
clipboardData.SendOut(info.szSymbol);
}
else
clipboardData.SendOut("symbol not found");
clipboardData.SendOut("\r\n");
}
clipboardData.SendOut("=== end AfxDumpStack() output ===\r\n");
}
void CBCGPPlannerViewMulti::AdjustLayout (CDC* /*pDC*/, const CRect& rectClient)
{
if (IsCurrentTimeVisible ())
{
StartTimer (FALSE);
}
else
{
StopTimer (FALSE);
}
m_nHeaderHeight = 2;
m_nHeaderAllDayHeight = 1;
const int nMinuts = CBCGPPlannerView::GetTimeDeltaInMinuts (GetTimeDelta ());
const int nCount = GetViewHours() * 60 / nMinuts;
m_rectTimeBar = rectClient;
m_rectTimeBar.right = m_rectTimeBar.left + (long)(m_nRowHeight * (nMinuts == 60 ? 2.5 : 3.0)) + 5;
m_rectApps.left = m_rectTimeBar.right;
{
// finding allday or multiday events
const int nDays = GetViewDuration ();
CDWordArray arDays;
arDays.SetSize (nDays);
COleDateTime dtS = GetDateStart ();
XBCGPAppointmentArray& arQueryApps = GetQueryedAppointments ();
XBCGPAppointmentArray& arDragApps = GetDragedAppointments ();
BOOL bDragDrop = IsDragDrop ();
DROPEFFECT dragEffect = GetDragEffect ();
BOOL bDragMatch = IsCaptureMatched ();
bDragDrop = !bDragDrop ||
(bDragDrop && ((dragEffect & DROPEFFECT_COPY) == DROPEFFECT_COPY && bDragMatch) ||
!bDragMatch);
bDragDrop = bDragDrop && arDragApps.GetSize ();
DWORD maxCount = 0;
for (int nRes = 0; nRes < m_Resources.GetSize (); nRes++)
{
UINT nResourceID = m_Resources[nRes].m_ResourceID;
for (int nApp = 0; nApp < 2; nApp++)
{
if (!bDragDrop && nApp == 0)
{
continue;
}
XBCGPAppointmentArray& arApps = nApp == 0 ? arDragApps : arQueryApps;
int nStartIndex = 0;
int i = 0;
for (i = 0; i < arApps.GetSize (); i++)
{
const CBCGPAppointment* pApp = arApps[i];
if (pApp != NULL && pApp->GetResourceID () == nResourceID)
{
nStartIndex = i;
break;
}
}
for (i = nStartIndex; i < (int)arApps.GetSize (); i++)
{
const CBCGPAppointment* pApp = arApps[i];
if (pApp == NULL)
{
continue;
}
ASSERT_VALID (pApp);
if (pApp->GetResourceID () != nResourceID)
{
break;
}
if (pApp->IsAllDay () || pApp->IsMultiDay ())
{
if (nDays > 1)
{
COleDateTime dtStart = pApp->GetStart ();
COleDateTime dtFinish = pApp->GetFinish ();
dtStart = COleDateTime (dtStart.GetYear (), dtStart.GetMonth (), dtStart.GetDay (),
0, 0, 0);
if (pApp->IsAllDay ())
{
dtFinish += COleDateTimeSpan (1, 0, 0, 0);
}
else if (pApp->GetFinish ().GetHour () != 0 ||
pApp->GetFinish ().GetMinute () != 0)
{
dtFinish = COleDateTime (dtFinish.GetYear (), dtFinish.GetMonth (), dtFinish.GetDay (),
0, 0, 0);
dtFinish += COleDateTimeSpan (1, 0, 0, 0);
}
if (dtStart < dtS)
{
dtStart = dtS;
}
COleDateTimeSpan span (dtFinish - dtStart);
int nStart = (dtStart - dtS).GetDays ();
int nEnd = nStart + span.GetDays ();
if (nEnd > (int) nDays)
{
nEnd = (int) nDays;
}
for (int j = nStart; j < nEnd; j++)
{
arDays[j] = arDays[j] + 1;
}
}
else
{
arDays[0] = arDays[0] + 1;
}
}
}
}
for (int i = 0; i < nDays; i++)
{
if (maxCount < arDays[i])
{
maxCount = arDays[i];
}
arDays[i] = 0;
}
}
if (maxCount > 0)
{
m_nHeaderAllDayHeight = maxCount;
}
}
int nRow = rectClient.Height () /
(nCount + m_nHeaderHeight + m_nHeaderAllDayHeight);
int nOldRowHeight = m_nRowHeight;
if (nRow > m_nRowHeight)
{
m_nRowHeight = nRow;
}
const int nRowHeightPadding = m_nRowHeight + s_HeaderAllDayPadding;
int nHeaderAllDayCount = m_nHeaderAllDayHeight;
m_nHeaderHeight *= m_nRowHeight;
m_nHeaderAllDayHeight *= nRowHeightPadding;
m_rectApps.top += m_nHeaderHeight;
m_nHeaderScrollTotal = 0;
m_nHeaderScrollPage = 1;
if (GetPlanner()->IsHeaderScrollingEnabled() &&
nHeaderAllDayCount > 0 && m_nHeaderAllDayHeight > m_rectApps.Height () / 2)
{
m_nHeaderAllDayHeight = min(m_rectApps.Height () / (nRowHeightPadding * 2), nHeaderAllDayCount);
if (m_nHeaderAllDayHeight == 0)
{
m_nHeaderAllDayHeight = 1;
}
if (m_nHeaderAllDayHeight != nHeaderAllDayCount)
{
m_nHeaderScrollTotal = nHeaderAllDayCount - 1;
m_nHeaderScrollPage = m_nHeaderAllDayHeight;
}
m_nHeaderAllDayHeight *= nRowHeightPadding;
}
nRow = (m_rectApps.Height () - m_nHeaderAllDayHeight) / nCount;
if (nRow > nOldRowHeight)
{
m_nRowHeight = nRow;
}
int delta = m_rectApps.Height () - m_nHeaderAllDayHeight;
if (delta < 0)
{
m_nHeaderAllDayHeight = m_rectApps.Height ();
}
else
{
int nc = (int)(delta / m_nRowHeight);
if (nc >= nCount)
{
m_nHeaderAllDayHeight = m_rectApps.Height () - nCount * m_nRowHeight;
}
else
{
m_nHeaderAllDayHeight += delta - nc * m_nRowHeight;
}
}
m_rectApps.top += m_nHeaderAllDayHeight;
AdjustScrollSizes ();
// correct selection
COleDateTime sel1 (GetSelectionStart ());
COleDateTime sel2 (GetSelectionEnd ());
SetSelection (sel1, sel2, FALSE);
}
