void CGenethonDoc::writeToReport(CString& output) {
if (m_pTextView == NULL) {
((CMainFrame *)(AfxGetApp()->m_pMainWnd))->OpenTextView();
}
else {
m_pTextView->GetParentFrame()->ActivateFrame();
m_pTextView->Invalidate();
}
CMemFile* memFile = new CMemFile();
//serialize object into the pData
// char* cBuff = new char[128];
// sprintf_s(cBuff, 128, "%s", "Test test test test test test\n");
memFile->Write(output, output.GetLength());
memFile->SeekToBegin();
// txtFile->Open(PathName, CFile::modeRead);
// CArchive archive(&txtFile, CArchive::load);
// SerializeRaw( archive );
m_pTextView->LoadMemfile(memFile);
memFile->Close();
delete memFile;
}
DWORD SupFileSubtitleProvider::ThreadProc()
{
CFile f;
if (!f.Open(m_fname, CFile::modeRead|CFile::typeBinary|CFile::shareDenyNone)) {
return 1;
}
f.SeekToBegin();
CMemFile sub;
sub.SetLength(f.GetLength());
sub.SeekToBegin();
int len;
BYTE buff[65536];
while ((len = f.Read(buff, sizeof(buff))) > 0) {
sub.Write(buff, len);
}
sub.SeekToBegin();
WORD sync = 0;
USHORT size = 0;
REFERENCE_TIME rtStart = 0;
CAutoLock cAutoLock(&m_csCritSec);
while (sub.GetPosition() < (sub.GetLength() - 10)) {
sync = (WORD)ReadByte(&sub, 2);
if (sync == 'PG') {
rtStart = UINT64(ReadByte(&sub, 4) * (1000 / 9));
sub.Seek(4 + 1, CFile::current); // rtStop + Segment type
size = ReadByte(&sub, 2) + 3; // Segment size
sub.Seek(-3, CFile::current);
sub.Read(buff, size);
m_pSub->ParseSample(buff, size, rtStart, 0);
} else {
break;
}
}
sub.Close();
return 0;
}
CMapMgrDoc::CMapMgrDoc() {
// TODO: add one-time construction code here
HRSRC hRes = ::FindResource( AfxGetResourceHandle(), "HIST_UNCOMPR", "COLORPARAM" );
if( NULL != hRes ) {
HGLOBAL hMem = ::LoadResource( AfxGetResourceHandle(), hRes );
DWORD dwSize = ::SizeofResource( AfxGetResourceHandle(), hRes );
HPBYTE pData = (HPBYTE) ::LockResource( hMem );
CMemFile memFile;
memFile.Write( (LPVOID) pData, dwSize );
memFile.SeekToBegin();
CArchive ar( &memFile, CArchive::load );
WORD v; // Version
ar >> v;
m_listOfFilters.Serialize( ar );
UnlockResource( hMem );
FreeResource( hMem );
}
void CFTPProtocolOutput::WriteLine(const CString& cszLine, COLORREF crText)
{
if( m_hWnd )
{
CHARFORMAT cf;
cf.dwMask = CFM_BOLD|CFM_COLOR;
cf.dwEffects = CFE_BOLD;
cf.crTextColor = crText;
CMemFile mf;
mf.Write(nsHelper::CCnv::ConvertToString(tstring(cszLine)).c_str(), cszLine.GetLength());
mf.SeekToBegin();
SetSelectionCharFormat(cf);
EDITSTREAM es;
es.dwCookie = reinterpret_cast<DWORD_PTR>(&mf);
es.pfnCallback = CFTPProtocolOutput::ProtocolStreamInCallback;
StreamIn(SF_TEXT|SFF_SELECTION, es);
SetSel(-1, -1);
LineScroll(1);
}
}
//****************************************************************************************
BOOL CBCGPGridSerializeManager::PrepareDataFromSelection ()
{
ASSERT (m_pOwnerGrid != NULL);
CleanUp ();
if (m_pOwnerGrid != NULL)
{
m_nLastColumn = m_pOwnerGrid->GetColumnsInfo ().GetColumnCount (TRUE) - 1;
m_nLastRow = m_pOwnerGrid->GetTotalRowCount () - 1;
}
if (m_ClipboardFormatType == CF_Rows)
{
if (!m_pOwnerGrid->NormalizeSelectionList ())
{
return FALSE;
}
}
//---------------------
// Calculate min offset
//---------------------
int i = 0;
CBCGPGridItemID idOffset (-1, -1);
for (i = 0; i < m_pOwnerGrid->GetSelectionCount (); i++)
{
CBCGPGridRange rangeIndex, rangeOrder;
if (m_pOwnerGrid->GetSelection (i, rangeIndex) &&
IndexToOrder (rangeIndex, rangeOrder))
{
const int nRow = (rangeOrder.m_nTop != -1) ? rangeOrder.m_nTop: 0;
const int nCol = (rangeOrder.m_nLeft != -1) ? rangeOrder.m_nLeft: 0;
if (idOffset.m_nRow == -1 || nRow <= idOffset.m_nRow)
{
idOffset.m_nRow = nRow;
}
if (idOffset.m_nColumn == -1 || nCol <= idOffset.m_nColumn)
{
idOffset.m_nColumn = nCol;
}
if (idOffset.m_nRow == -1 ||
idOffset.m_nRow == 0 && idOffset.m_nRow == m_nLastRow)
{
m_bWholeColSelected = TRUE;
}
if (idOffset.m_nColumn == -1 ||
idOffset.m_nColumn == 0 && idOffset.m_nColumn == m_nLastColumn)
{
m_bWholeRowSelected = TRUE;
}
}
}
if (idOffset.m_nRow == -1)
{
idOffset.m_nRow = 0;
}
if (idOffset.m_nColumn == -1)
{
idOffset.m_nColumn = 0;
}
ASSERT (idOffset.m_nRow >= 0);
ASSERT (idOffset.m_nColumn >= 0);
m_idRangesOffset = idOffset;
//------------------------------
// Prepare serialized selection:
//------------------------------
for (i = 0; i < m_pOwnerGrid->GetSelectionCount (); i++)
{
CBCGPGridRange rangeIndex, rangeOrder;
if (m_pOwnerGrid->GetSelection (i, rangeIndex) &&
IndexToOrder (rangeIndex, rangeOrder))
{
const int nRowOffset = (rangeOrder.m_nTop != -1) ? rangeOrder.m_nTop - m_idRangesOffset.m_nRow: 0;
const int nColOffset = (rangeOrder.m_nLeft != -1) ? rangeOrder.m_nLeft - m_idRangesOffset.m_nColumn: 0;
CBCGPGridRange rangeRelative (
nColOffset,
nRowOffset,
nColOffset + (rangeOrder.m_nRight - rangeOrder.m_nLeft),
nRowOffset + (rangeOrder.m_nBottom - rangeOrder.m_nTop));
try
{
CMemFile f;
CArchive archive (&f, CArchive::store | CArchive::bNoFlushOnDelete);
if (m_ClipboardFormatType == CF_Items)
{
WriteItemsToArchive (archive, rangeOrder);
}
else if (m_ClipboardFormatType == CF_Rows)
{
WriteRowsToArchive (archive, rangeOrder);
}
archive.Close ();
if (f.GetLength () <= 0)
{
return FALSE;
}
UINT cbSize = (UINT)f.GetLength ();
BYTE* pData = new BYTE[cbSize];
if (NULL == pData)
{
delete [] pData;
return FALSE;
}
f.SeekToBegin ();
if (f.Read (pData, cbSize) != cbSize)
{
delete [] pData;
return FALSE;
}
AddRange (rangeRelative, cbSize, pData);
}
catch (CFileException* pEx)
{
TRACE(_T("CBCGPGridSerializeManager::PrepareDataFromSelection. File exception\r\n"));
pEx->Delete ();
return FALSE;
}
catch (CException* e)
{
TRACE(_T("CBCGPGridSerializeManager::PrepareDataFromSelection. Exception\r\n"));
e->Delete ();
return FALSE;
}
}
}
return TRUE;
}
//*********************************************************************************
static void openSnapshotTestSectrion()
{
CTBSection xCurrentUser;
xCurrentUser.Open(&CTBSection::tbRootSection, "CurrentUser");
CTBSection xSnapshotTest;
xSnapshotTest.Open(&xCurrentUser, "SnapshotTest", TBOPEN_MODE_SNAPSHOT);
CString strName;
DWORD dwType = 0;
int nTop = 0;
BOOL more = xSnapshotTest.GetFirstItem(strName, dwType);
while(more)
{
TEST_VERIFY((dwType == TBVTYPE_LONGBINARY) == (strName == "Blob1"));
TEST_VERIFY((dwType == TBVTYPE_SECTION) == (strName == "Section1"));
if(dwType != TBVTYPE_LONGBINARY && dwType != TBVTYPE_SECTION)
{
CTBValue value;
CString prefix;
long index = 0;
sscanf(strName, "%s %d", prefix.GetBuffer(10), &index);
if(prefix == "Name")
{
if(nTop < index) nTop = index;
TEST_VERIFY(dwType == TBVTYPE_TEXT);
xSnapshotTest.GetValue(strName, &value);
TEST_VERIFY(strcmp(value.m_pValue->data.text, "Name") == 0);
}
else if(prefix == "Age")
{
if(nTop < index) nTop = index;
TEST_VERIFY(dwType == TBVTYPE_INTEGER);
xSnapshotTest.GetValue(strName, &value);
TEST_VERIFY(value.m_pValue->data.int32 == index);
}
}
more = xSnapshotTest.GetNextItem(strName, dwType);
}
TEST_VERIFY(nTop == 199);
CTBSection xSection1;
xSection1.Open(&xSnapshotTest, "Section1");
xSection1.Close();
//--------------------------------------------------------------
CMemFile memFile;
xSnapshotTest.GetLongBinary("Blob1", &memFile);
memFile.SeekToBegin();
for(int i = 0; i < 64; ++i)
{
BYTE buff[1024] = {0};
BYTE buff2[1024] = {0};
memset(buff2, i, sizeof(buff2));
memFile.Read(buff, sizeof(buff));
TEST_VERIFY(memcmp(buff, buff2, 1024) == 0);
}
//--------------------------------------------------------------
TEST_VERIFY(memFile.GetPosition() == memFile.GetLength());
xSnapshotTest.Close();
}
