Exemple #1
0
// this is called after each stage of processing, in order to (if appropriate)
// copy the file from the temp directory to a user-designated location, and
// to change the result-stream that is shown to this new file, rather than to
// the original.  The benefit of that step is so that if the user asks for the
// file to be opened externally, the correct copy of the file is opened (not the
// one in the temp directory).
// nGoal is the users's goal
// nStage is the stage that we just finished (e.g. CProcessingPrefs::kSourceAna)
void CInputDoc::redirectOutputFile(int nGoal, int nStage,
								   CPathDescriptor &originalOutPath,
								   CPathDescriptor &newPath,
								   CProcessStatus *pStatus)
{
	// if we do have this flag kLeaveNonGoalsInTemp set, then only
	// continue if this stage is our final goal
	if((getProcessingPrefs()->m_dwFlags & CProcessingPrefs::kLeaveNonGoalsInTemp)
		&& nGoal!=nStage)
		return;

	originalOutPath.copyTo(newPath);


	// now find the matching result stream and change it to point to this new copy
	int nCount = m_pProcessStatus->m_pResultStreams.GetSize();
	for(int i=nCount-1; i >=0; i--)
	{
		CResultStream* p = m_pProcessStatus->m_pResultStreams.ElementAt(i);
		ASSERT(p);
		if(p->IsKindOf(RUNTIME_CLASS(CResultStreamFile)))
		{
			CResultStreamFile* pf = (CResultStreamFile*)p;
			if(	pf->getPath() == originalOutPath)
			{
				pf->setPath(newPath);
				break;
			}

		}
	}
}
// this function is called when each chunk is completed (so we can check the imported data
//  for any of our various error conditions (and use error icons if needed).
DWORD CInputDocView::OnStreamInChunkComplete
(
	AsyncLoadRichEditCtrl*  pCtrl,
	DWORD_PTR               dwCookie,
	LPCTSTR                 szBuff
)
{
	CInputDocView* pView = (CInputDocView*)dwCookie;

	// first of all, see if there was one of our error codes.
	LONG iTabIndex = ::GetWindowLong(pCtrl->GetSafeHwnd(), GWL_USERDATA);
	TC_ITEM tie;
	tie.mask = TCIF_PARAM;
	pView->m_tabCtrl.GetItem(iTabIndex,&tie);
	CResultStreamFile* pStream = (CResultStreamFile*)tie.lParam;
	if( !pStream )
	{
		ASSERT(false);
		return -1;
	}

	if( pStream->IsError(szBuff) )
	{
		switch( pStream->m_eTabLoadingIcon )
		{
		case CResultStream::kLoadingErrorIcon1:
			pStream->m_eTabLoadingIcon = CResultStream::kLoadingErrorIcon2;
			break;
		case CResultStream::kLoadingErrorIcon2:
			pStream->m_eTabLoadingIcon = CResultStream::kLoadingErrorIcon3;
			break;
		case CResultStream::kLoadingIcon1:
		case CResultStream::kLoadingIcon2:
		case CResultStream::kLoadingIcon3:
		case CResultStream::kLoadingErrorIcon3:
			pStream->m_eTabLoadingIcon = CResultStream::kLoadingErrorIcon1;
			break;
		};
	}
	else
	{
		switch( pStream->m_eTabLoadingIcon )
		{
		case CResultStream::kLoadingIcon1:
			pStream->m_eTabLoadingIcon = CResultStream::kLoadingIcon2;
			break;
		case CResultStream::kLoadingIcon2:
			pStream->m_eTabLoadingIcon = CResultStream::kLoadingIcon3;
			break;
		case CResultStream::kLoadingIcon3:
			pStream->m_eTabLoadingIcon = CResultStream::kLoadingIcon1;
			break;
		};
	}

	tie.mask = TCIF_IMAGE;
	tie.iImage = pStream->m_eTabLoadingIcon;
	pView->m_tabCtrl.SetItem(iTabIndex,&tie);

	// must invalidate the current tab so *it* get's repainted (after SetItem above, it goes away).
	pView->InvalidateCurTab();

	return 0;
}
void CInputDocView::addPanel(CResultStream* pStream, int id)
#endif
{
	CRect r;//(0,0, 100, 100);
	GetClientRect(&r);
#ifndef rde270
	// change the dimensions a little so we don't get the annoying non-repaint of m_tabCtrl
	//  when we repaint the RECtrl after a chunk has been loaded offline.
	r.top = 21;
	AsyncLoadRichEditCtrl* pEC = new AsyncLoadRichEditCtrl;
#else   // rde270
	r.top = 25;
	r.right -= 5;
	r.bottom -= 5;
	CRichEditCtrl* pEC = new CRichEditCtrl;//CPanelRichEditCtrl;//
#endif
	//	CEdit* pEC = new CEdit;
	m_pEditCtrls.Add(pEC);



	DWORD dwFlags = ECO_SAVESEL | ES_AUTOVSCROLL | ES_MULTILINE |
				ES_NOHIDESEL   | WS_BORDER | WS_VSCROLL | WS_CHILD | WS_VISIBLE | ES_WANTRETURN;

#ifndef jdhhab621
	// a hack to get a scrollbar for pc-patr.  This could be generalized or put in the user's
	// control, but not without work that seems unjustified if it's just for pcpatr.

	if (pStream->getDescriptor()->getTabLabel().Find(_T("PATR")) != -1)
		dwFlags |= WS_HSCROLL | ES_AUTOHSCROLL;
#endif // jdhhab261

	pEC->Create(dwFlags,
				(RECT&)r,
				&m_tabCtrl,
				id);

	CFont* test = pStream->getFont();
	pEC->SetFont(test);

#ifndef rde270
	// delay StreamIn until after setting up of the associated tab (because during StreamIn
	//  our callback must have the pStream which is stored in the tab's lParam member.
#else   // rde270
	// NOTE: I'm not clear on whether StreamIn is done with the stream when it returns;
	// it doesn't seem to delete it, but you'd think it would need
	// to keep it around so it can get at large files when the user
	// scrolls down; maybe not.  Why it matters is, what if the cwCOOKIE
	// member points to a CResultsStream that I've deleted?
	// For now, I'm going to go on the assumption that the whole
	// file is read right here.
	pEC->StreamIn(SF_TEXT, pStream->getEditStreamIn()); // icon may be set in here

	// Set editing flags and limit

	CInputDoc* pDoc = (CInputDoc*) GetDocument();
	if(id==kBasePanelID && pDoc->m_bBaseIsEditable)
	{
		pEC->SetReadOnly(FALSE);
		const long kMaxAddableChars = 2000;
		long l = pEC->GetTextLength() + kMaxAddableChars;
		pEC->LimitText(l);
		pEC->SetEventMask( ENM_KEYEVENTS| ENM_CHANGE );// want to know when the user changes something
	}
	else
		pEC->SetReadOnly(TRUE);
#endif  // rde270


/*	ALL THIS WAS FOR CEDIT, NOT CRICHEDIT
	EDITSTREAM es =  pStream->getEditStreamIn();
	long sz = pEC->GetLimitText()-10;
	LPTSTR buff = new char [sz+1];
	ASSERTX(buff);
	long actual;
	(es.pfnCallback)((DWORD)(pStream), (unsigned char*)buff, sz, &actual);
	buff[actual] = '\0';
	CString sOverflowMsg = pStream->getOverflowMsg();
	if(actual > sz - sOverflowMsg.GetLength())
	{
		buff[sz-sOverflowMsg.GetLength()] = '\0';
		CString s = buff;
		s += sOverflowMsg;
		pEC->SetWindowText(s);
	}
	else
		pEC->SetWindowText(buff);


	// make it close
	(es.pfnCallback)((DWORD)(pStream), (unsigned char*)buff, 0, &actual);
	delete buff;
*/

	// make the tab for this item
	TC_ITEM tie;
	tie.mask = TCIF_TEXT |TCIF_PARAM ;
	tie.lParam = (LPARAM)pStream;
	tie.pszText = (LPTSTR)  LPCTSTR(pStream->getDescriptor()->getTabLabel());
	int iconEnum = pStream->getTabIconEnum();
	if(iconEnum>=0)
	{
		tie.mask |= TCIF_IMAGE;
		tie.iImage = iconEnum;
	}

#ifndef rde270
	// save the inserted tab's index (so it can be accessed by knowing the EC).
	int nIndex = m_tabCtrl.InsertItem(99, &tie );
	::SetWindowLong(pEC->GetSafeHwnd(),GWL_USERDATA,nIndex);
	if( -1 == nIndex )
#else   // rde270
	if (-1 == m_tabCtrl.InsertItem(99, &tie ))
#endif  // rde270
	{
		ASSERTX(FALSE);
	}
	else
	{
		//CToolTipCtrl* pTip = new CToolTipCtrl;
		//pTip->Create(this); // <--- or should it be the tab bar?
		//pTip->
		CToolTipCtrl* pTip = m_tabCtrl.GetToolTips();
		ASSERT(pTip);
		CRect r;
		m_tabCtrl.GetItemRect(m_tabCtrl.GetItemCount()-1, &r);
		CString s;
		s.Format(_T("%s"), (LPCTSTR)pStream->getToolTipText());
		pTip->AddTool(&m_tabCtrl, s, &r, id);
	}

#ifndef rde270
	// moved 'StreamIn' here because we want the tab already setup for when we get the
	//  'finished-a-chunk' callback.
	// use the 'AsyncLoadRichEdit' to stream it in [load asynchronously so we don't kill
	//  the UI for minutes (on big files).]
#pragma message("If you subclass CResultStream with something besides CResultStreamFile, this'll break!")
	CResultStreamFile* pStreamFile = (CResultStreamFile*)pStream;
	// ASSERT(pStreamFile->IsKindOf(RUNTIME_CLASS(CResultStreamFile)));
	// this assert is what *should* be, but the various streams are from the processor DLLs
	//  and for some reason IsKindOf doesn't appear to work across DLL boundaries.

	pEC->StreamIn(pStreamFile->getPath(), bSyncStreamIn, CInputDocView::OnStreamInChunkComplete, (DWORD_PTR)this);

	// Set editing flags and limit
	CInputDoc* pDoc = (CInputDoc*) GetDocument();
	if(id==kBasePanelID && pDoc->m_bBaseIsEditable)
	{
		pEC->SetReadOnly(FALSE);
		const long kMaxAddableChars = 2000;
		long l = pEC->GetTextLength() + kMaxAddableChars;
		pEC->LimitText(l);
		pEC->SetEventMask( ENM_KEYEVENTS| ENM_CHANGE );// want to know when the user changes something

		// if the editable file was imported as UTF-16, then we must make it 'modified' so
		//  it'll be saved as UTF-8 before processing (Ample, et al., can deal with UTF-8,
		//  but not UTF-16).
		if(     (pEC->FileEncoding() != eUTF8)
			&&  (pEC->FileEncoding() != eAnsi) )
			GetDocument()->SetModifiedFlag();
	}
	else
		pEC->SetReadOnly(TRUE);
#endif  // rde270
}