static bool ReduceOneMapFile( LPCTSTR lpszInFile, LPCTSTR lpszOutFile, PICTSAMPLEPARAM &fp, int level)
{
BOOL bRet;
CMemBlock memInput( Size4MB );
CMemBlock memOutput( Size2MB );
CRuntimeClass *pInRT;
CRuntimeClass *pOutRT = NULL;
CPicture *pInPict;
CPicture *pOutPict;
CFile fileInput;
CFile fileOutput;
CPictSample filter;
if( fileInput.Open( lpszInFile, CFile::modeRead | CFile::typeBinary ) ) {
pInRT = ::GetWritablePictureType( &fileInput );
if( NULL == pOutRT )
pOutRT = pInRT;
if( NULL != pInRT && NULL != ( pInPict = (CPicture*) pInRT->CreateObject() ) ) {
if( fileOutput.Open( lpszOutFile, CFile::modeReadWrite | CFile::modeCreate | CFile::typeBinary ) ) {
VERIFY( NULL != ( pOutPict = (CPicture*) pOutRT->CreateObject() ) );
if( pInPict->Attach( &fileInput ) && pInPict->ReadHeader() ) {
if( pOutPict->Attach( &fileOutput ) ) {
switch( pInPict->GetBitsPerSample() ) {
case 1 : fp.sampleParam = 0; break;
// case 8 : fp.sampleParam = level > 2 ? 3 : 0; break; // #HK050104
// case 8 : fp.sampleParam = level <= 2 ? 3 : 0; break; // #HK050120
case 8 : fp.sampleParam = 3; break; // #HK050120
}
filter.SetFilterData( &fp.p );
bRet = filter.Filter( pInPict, pOutPict );
pOutPict->Detach();
}
pInPict->Detach();
}
fileOutput.Close();
delete pOutPict;
}
delete pInPict;
}
fileInput.Close();
}
return TRUE == bRet ? 1 : 0;
}
static bool GetIntergraph( CFile& rFile, CString& rString, TOPOMAP& theMap ) {
CRuntimeClass *pRT;
bool bRet = false;
if( NULL == ( pRT = GetPictureType( &rFile ) ) );
CPicture *pPict = (CPicture*) pRT->CreateObject();
VERIFY( pPict->Attach( &rFile ) && pPict->ReadHeader() );
long X0, Y0, X1, Y1;
TAG tag270;
TAG tag33918;
GetPictInfo( pPict, X0, Y0, X1, Y1);
if( pPict->GetTag( 33918, tag33918 ) ) {
long nItems = tag33918.Count();
if( ( 4 + 64 ) == nItems ) {
IGTAG33918* pData = (IGTAG33918*) tag33918.pVal();
_ASSERTE(sizeof(theMap.m_transform.m_matrix) == sizeof(pData->dblVal) );
memcpy( theMap.m_transform.m_matrix, pData->dblVal, sizeof(theMap.m_transform.m_matrix) );
//////////////////////////////////////////////////////////////////
// Karteninformation basteln
theMap.m_sizeOfPicture.cx = X1;
theMap.m_sizeOfPicture.cy = Y1;
// GCP's: LinksUnten, RechtsUnten, RechtsOben, LinksOben
theMap.m_listOfGCP.erase( theMap.m_listOfGCP.begin(), theMap.m_listOfGCP.end() );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( ), GEOPOINT( 0, Y1, 0 ) ) );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( ), GEOPOINT( X1, Y1, 0 ) ) );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( ), GEOPOINT( X1, 0, 0 ) ) );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( ), GEOPOINT( 0, 0, 0 ) ) );
bRet = true;
}
}
delete pPict;
return bRet;
}
bool CPluginParamDlg::CreateView()
{
// create child view that contains parameter controls
CRuntimeClass *pFactory = RUNTIME_CLASS(CPluginParamView);
m_View = DYNAMIC_DOWNCAST(CPluginParamView, pFactory->CreateObject());
if (m_View == NULL) {
AfxMessageBox(IDS_PLUGIN_CANT_CREATE_VIEW);
return(FALSE);
}
CRect rView;
GetViewHolderRect(rView);
DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_BORDER;
if (!m_View->Create(NULL, NULL, dwStyle, rView, this, 0, NULL)) {
AfxMessageBox(IDS_PLUGIN_CANT_CREATE_VIEW);
return(FALSE);
}
if (!m_View->InitRows(m_PluginPath, m_SampleRate)) {
CString msg;
AfxFormatString2(msg, IDS_PLUGIN_CANT_LOAD, m_PluginPath,
CWinAppEx::GetLastErrorString());
AfxMessageBox(msg);
return(FALSE);
}
if (m_Param.GetSize())
m_View->SetParams(m_Param);
SetWindowText(CString(m_View->GetDescriptor()->Name));
return(TRUE);
}
STDMETHODIMP CPictHolder::OpenPictureFile(BSTR strPicture)
{
Close();
CString S( strPicture );
if( !m_fileOfPicture.Open( S, CFile::modeRead | CFile::typeBinary ) )
return E_FAIL;
CRuntimeClass *pRT;
CPicture *pPict = NULL;
HRESULT hr = E_FAIL;
try {
for(;;) {
if( NULL == ( pRT = GetWritablePictureType( &m_fileOfPicture ) ) )
break;
pPict = (CPicture*) pRT->CreateObject();
VERIFY( pPict->Attach( &m_fileOfPicture ) && pPict->ReadHeader() );
m_pPicture = pPict;
hr = S_OK;
break;
}
} catch(...) {
if( pPict )
delete pPict;
m_pPicture = NULL;
}
return hr;
}
static bool GetReferenced( CFile& rFile, CString& rString, TOPOMAP& theMap ) {
CRuntimeClass *pRT;
if( NULL == ( pRT = GetPictureType( &rFile ) ) );
CPicture *pPict = (CPicture*) pRT->CreateObject();
VERIFY( pPict->Attach( &rFile ) && pPict->ReadHeader() );
long X0, Y0, X1, Y1;
TAG tag270;
GetPictInfo( pPict, X0, Y0, X1, Y1);
if( pPict->GetTag( 270, tag270 ) ) {
rString = tag270.strVal();
}
delete pPict;
//////////////////////////////////////////////////////////////////
// Karteninformation basteln
theMap.m_sizeOfPicture.cx = X1;
theMap.m_sizeOfPicture.cy = Y1;
// GCP's: LinksUnten, RechtsUnten, RechtsOben, LinksOben
GEOPOINT LO, RU;
LO.X = 0; LO.Y = 0;
RU.X = 0; RU.Y = 0;
theMap.m_listOfGCP.erase( theMap.m_listOfGCP.begin(), theMap.m_listOfGCP.end() );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( LO.X, RU.Y, 0 ), GEOPOINT( 0, Y1, 0 ) ) );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( RU.X, RU.Y, 0 ), GEOPOINT( X1, Y1, 0 ) ) );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( RU.X, LO.Y, 0 ), GEOPOINT( X1, 0, 0 ) ) );
theMap.m_listOfGCP.push_back( GCP( GEOPOINT( LO.X, LO.Y, 0 ), GEOPOINT( 0, 0, 0 ) ) );
return true;
}
/////////////////////////////////////////////////////////////////////////////
// 新建OWM对象ControlBar(for Xtreme)
/////////////////////////////////////////////////////////////////////////////
BOOL CPlugIn::NewOwmControlBar()
{
if(m_pVciObj == NULL)
{
return FALSE;
}
IVciOwm* pIVciOwm = (IVciOwm*)m_pVciObj;
CMultiDocTemplate* pDocTemplate = NULL;
pIVciOwm->GetDocTemplate(&pDocTemplate);
CRuntimeClass* pCtrlBarClass = NULL;
pIVciOwm->GetRuntimeClass(4, &pCtrlBarClass);
if(!pCtrlBarClass)
return FALSE;
if(m_pControlBar)
return FALSE;
// 此处已经修改为支持Xtreme
CMainFrame* pMainFrame = (CMainFrame*)(AfxGetMainWnd());
m_pControlBar = (CControlBar*)(pCtrlBarClass->CreateObject());
// pMainFrame->EnableDockingEx(CBRS_ALIGN_ANY, CBRS_XT_FLAT);
// pMainFrame->DockControlBar( pBar );
return TRUE;
}
void CEditorRoot::SetEditTool( const CString &sEditToolName,bool bStopCurrentTool/*=true */ )
{
CEditTool *pTool = GetEditTool();
if (pTool && pTool->GetClassDesc())
{
if (stricmp(pTool->GetClassDesc()->ClassName(),sEditToolName) == 0)
return;
}
IClassDesc *pClass = this->GetClassFactory()->FindClass( sEditToolName );
if (!pClass)
{
//Warning( "Editor Tool %s not registered.",(const char*)sEditToolName );
return;
}
if (pClass->SystemClassID() != ESYSTEM_CLASS_EDITTOOL)
{
//Warning( "Class name %s is not a valid Edit Tool class.",(const char*)sEditToolName );
return;
}
CRuntimeClass *pRtClass = pClass->GetRuntimeClass();
if (pRtClass && pRtClass->IsDerivedFrom(RUNTIME_CLASS(CEditTool)))
{
CEditTool *pEditTool = (CEditTool*)pRtClass->CreateObject();
this->SetEditTool(pEditTool);
return;
}
else
{
//Warning( "Class name %s is not a valid Edit Tool class.",(const char*)sEditToolName );
return;
}
}
CObject* CXMLArchiveNode::CreateObject(const CString& className)
{
CRuntimeClass* pClass = NULL;
// First see if the CRuntimeClass object is cached
if (!m_classMap.Lookup(className, (void*&)pClass))
{
// Search app specific classes
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
for (pClass = pModuleState->m_classList; pClass != NULL; pClass = pClass->m_pNextClass)
{
if (className == pClass->m_lpszClassName)
{
m_classMap[className] = (void*&)pClass;
break;
}
}
}
if (pClass == NULL)
{
TRACE1("You did not declare the class %s DECLARE_XMLSERIAL", (const char *)className);
ASSERT(FALSE);
return NULL;
}
return pClass->CreateObject();
}
CStaticDoc* CStaticDoc::CreateNewDocument( )
{
CRuntimeClass *pDocClass = RUNTIME_CLASS(CStaticDoc);
CStaticDoc* pDocument = (CStaticDoc*)pDocClass->CreateObject();
if (pDocument == NULL)
{
TRACE1("Warning: Dynamic create of document type %hs failed.\n",
pDocClass->m_lpszClassName);
return NULL;
}
ASSERT_KINDOF(CStaticDoc, pDocument);
return pDocument;
}
BOOL CImpactChildFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
if(m_pwndImpact==NULL) {
CRuntimeClass* pRuntimeClass = RUNTIME_CLASS(CImpactForm);
CObject* pObject = pRuntimeClass->CreateObject();
ASSERT( pObject->IsKindOf(RUNTIME_CLASS(CImpactForm)));
m_pwndImpact=(CImpactForm *) pObject;
CRect rcClient;
GetClientRect(rcClient);
m_pwndImpact->Create(this,rcClient);
m_pwndImpact->ShowWindow(SW_SHOW);
}
return CMDIChildWnd::OnCreateClient(lpcs, pContext);
}
CDialogGraphDen::CDialogGraphDen(CWnd* pParent /*=NULL*/)
: CDialog(CDialogGraphDen::IDD, pParent)
{
//{{AFX_DATA_INIT(CDialogGraphDen)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
CRuntimeClass* pRuntimeClass = RUNTIME_CLASS( CGraphDView );
CObject* pObject = pRuntimeClass->CreateObject();
ASSERT( pObject->IsKindOf( RUNTIME_CLASS( CGraphDView ) ) );
m_pGDView=(CGraphDView *)pObject;
}
int CPatchBar::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CMySizingControlBar::OnCreate(lpCreateStruct) == -1)
return -1;
m_Engine = &theApp.GetEngine();
CRuntimeClass *pFactory = RUNTIME_CLASS(CPatchView);
m_View = DYNAMIC_DOWNCAST(CPatchView, pFactory->CreateObject());
DWORD dwStyle = AFX_WS_DEFAULT_VIEW;
CRect r(0, 0, 0, 0); // arbitrary initial size
if (!m_View->Create(NULL, NULL, dwStyle, r, this, IDC_PATCH_VIEW, NULL))
return -1;
m_View->m_Parent = this;
m_View->SetNotifyWnd(this);
m_View->SetAccel(NULL, theApp.GetMain());
m_View->CreateCols(COLUMNS, m_ColInfo, IDD_PATCH_ROW);
return 0;
}
int MapInfo( const int argc, const char *argv[], istream& s_in, ostream& s_out, ostream& s_err ) {
int c;
bool bRaw = false;
LPCTSTR optarg;
int optind = 1;
while( EOF != ( c = getopt( argc, argv, "rg?", optind, optarg ) ) ) {
switch( c ) {
case 'r' : bRaw = true; break;
case 'g' : setlocale( LC_ALL, _T("German") ); break;
case '?' : Usage( s_err ); return TRUE;
}
}
if( argc < optind ) {
Usage( s_err );
return FALSE;
}
CMemBlock memPict( Size4MB );
CRuntimeClass *pRT;
CPicture *pPict;
CFile fileInput;
for( ; optind < argc; optind++ ) {
if( fileInput.Open( argv[optind], CFile::modeRead | CFile::typeBinary ) ) {
pRT = ::GetPictureType( &fileInput );
if( NULL != pRT && NULL != ( pPict = (CPicture*) pRT->CreateObject() ) ) {
VERIFY( pPict->Attach( &fileInput ) && pPict->ReadHeader() );
pPict->DumpTags( s_out, bRaw );
pPict->Detach();
delete pPict;
} else {
s_err << _T("cannot determine FileType: ") << argv[optind] << endl;
}
fileInput.Close();
} else {
s_err << _T("cannot open File: ") << argv[optind] << endl;
}
}
return TRUE;
}
void CBCGPToolbarMenuButton::CopyFrom (const CBCGPToolbarButton& s)
{
CBCGPToolbarButton::CopyFrom (s);
const CBCGPToolbarMenuButton& src = (const CBCGPToolbarMenuButton&) s;
m_bDefault = src.m_bDefault;
m_bMenuOnly = src.m_bMenuOnly;
m_bIsRadio = src.m_bIsRadio;
m_pWndMessage = src.m_pWndMessage;
m_bMenuPaletteMode = src.m_bMenuPaletteMode;
m_nPaletteRows = src.m_nPaletteRows;
m_bQuickCustomMode = src.m_bQuickCustomMode;
m_bShowAtRightSide = src.m_bShowAtRightSide;
SetTearOff (src.m_uiTearOffBarID);
while (!m_listCommands.IsEmpty ())
{
delete m_listCommands.RemoveHead ();
}
for (POSITION pos = src.m_listCommands.GetHeadPosition (); pos != NULL;)
{
CBCGPToolbarMenuButton* pItem = (CBCGPToolbarMenuButton*) src.m_listCommands.GetNext (pos);
ASSERT (pItem != NULL);
ASSERT_KINDOF (CBCGPToolbarMenuButton, pItem);
CRuntimeClass* pSrcClass = pItem->GetRuntimeClass ();
ASSERT (pSrcClass != NULL);
CBCGPToolbarMenuButton* pNewItem = (CBCGPToolbarMenuButton*) pSrcClass->CreateObject ();
ASSERT (pNewItem != NULL);
ASSERT_KINDOF (CBCGPToolbarMenuButton, pNewItem);
pNewItem->CopyFrom (*pItem);
m_listCommands.AddTail (pNewItem);
}
}
CChildFrame* CChildFrame::CreateNewFrame( CStaticDoc* pStaticDoc )
{
if (pStaticDoc != NULL)
ASSERT_VALID(pStaticDoc);
// create a frame wired to the specified document
ASSERT( pStaticDoc->GetIDResource() != 0); // must have a resource ID to load from
CCreateContext context;
context.m_pCurrentFrame = NULL;
context.m_pCurrentDoc = NULL; //pStaticDoc;
context.m_pLastView = NULL;
context.m_pNewViewClass = NULL; // pViewClass if this is set, a view will be created!
context.m_pNewDocTemplate = NULL;
CRuntimeClass* pFrameClass = RUNTIME_CLASS(CChildFrame);
CChildFrame * pFrame = (CChildFrame*)pFrameClass->CreateObject();
if (pFrame == NULL)
{
TRACE1("Warning: Dynamic create of frame %hs failed.\n",
pFrameClass->m_lpszClassName);
return NULL;
}
ASSERT_KINDOF(CChildFrame, pFrame);
// create new from resource
if (!pFrame->LoadFrame( pStaticDoc->GetIDResource(),
WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, // default frame styles
AfxGetMainFrame(), &context))
{
TRACE0("Warning: Couldn't create a child frame.\n");
// frame will be deleted in PostNcDestroy cleanup
return NULL;
}
// it worked !
return pFrame;
}
CDialogPlacePart::CDialogPlacePart(CWnd* pParent /*=NULL*/,DWORD dwType /*=0*/)
: CDialog(CDialogPlacePart::IDD, pParent)
{
//{{AFX_DATA_INIT(CDialogPlacePart)
// NOTE: the ClassWizard will add member initialization here
//}}AFX_DATA_INIT
int iData=IDD;
m_dwType=dwType;
m_bFlagNew=FALSE; //clear new flag
m_bFlagHdlItemChanged=TRUE; //enables hadling of item changed event
m_bFlagHdlItemChanged1=TRUE; //disables handling of item changed event for 1 time
m_bDragging = FALSE; //for dragging operations
//Create part viewer
if(iData=IDD_PLACEPART2){
CRuntimeClass* pRuntimeClass = RUNTIME_CLASS( CPartPView );
CObject* pObject = pRuntimeClass->CreateObject();
ASSERT( pObject->IsKindOf( RUNTIME_CLASS( CPartPView ) ) );
m_pPPView=(CPartPView *)pObject;
m_pPPView->SetPlacePartDlg(this);
}
}
CWnd *CFrameWnd::CreateView( CCreateContext *pContext, UINT nID )
/***************************************************************/
{
if( pContext == NULL ) {
return( NULL );
}
CRuntimeClass *pClass = pContext->m_pNewViewClass;
if( pClass == NULL ) {
return( NULL );
}
CWnd *pView = (CWnd *)pClass->CreateObject();
if( pView == NULL ) {
return( NULL );
}
ASSERT( pView->IsKindOf( RUNTIME_CLASS( CWnd ) ) );
if( !pView->Create( NULL, NULL, AFX_WS_DEFAULT_VIEW, CRect( 0, 0, 0, 0 ),
this, nID, pContext ) ) {
return( NULL );
}
return( pView );
}
//*********************************************************************
CBCGPGridItem* CCxNDArrayDimGrid::CreateItem (int nRow, int nColumn)
{
CCxNDArrayDimItem* pItem = NULL;
CRuntimeClass* pItemRTC = NULL;
if (m_mapItemsRTC.Lookup (nColumn, pItemRTC))
{
ASSERT (pItemRTC != NULL);
pItem = DYNAMIC_DOWNCAST (CCxNDArrayDimItem, pItemRTC->CreateObject ());
}
else if (m_pDefaultItemRTC != NULL)
{
pItem = DYNAMIC_DOWNCAST (CCxNDArrayDimItem, m_pDefaultItemRTC->CreateObject ());
}
else
{
pItem = new CCxNDArrayDimItem ();
}
if (pItem == NULL)
{
ASSERT (FALSE);
return NULL;
}
ASSERT_VALID (pItem);
if (!pItem->OnCreate (nRow, nColumn))
{
delete pItem;
return NULL;
}
return pItem;
}
BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext* pContext)
{
CDocument *pDoc=NULL;
POSITION pos;
BOOL bRet = FALSE;
//create the source view for this document at this time
CRuntimeClass *prc = RUNTIME_CLASS(CSourceView);
ENSURE(prc);
m_pSrcView = (CSourceView*)prc->CreateObject();
if(m_pSrcView)
VERIFY(m_pSrcView->Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
CRect(0,0,0,0), this, AFX_IDW_PANE_LAST, NULL));
//create the doc-template view and save off a pointer to it
bRet = CFrameWnd::OnCreateClient(lpcs, pContext);
pDoc = pContext->m_pCurrentDoc;
if(bRet && pDoc)
{
pos = pDoc->GetFirstViewPosition();
pDoc->AddView(m_pSrcView);
}
else
return FALSE;
CView *pView = pDoc->GetNextView(pos);
ASSERT(pView->IsKindOf(RUNTIME_CLASS(CHTMLEdView)));
if(pView)
{
m_pWebView = (CHTMLEdView*) pView;
}
else
return FALSE;
return bRet;
}
void CTraverseBySourceExchange::OnRecvSync(const uchar * data, int /*len*/, DWORD /*ip*/, WORD /*port*/)
{
TRACE("Receive NAT Sync Request From Source Exchange!\n");
//UINT realsize=len-1;// VC-linhai[2007-08-06]:warning C4189: “realsize” : 局部变量已初始化但不引用
const uchar * realdata=data+1;
DWORD cip = *(DWORD*)(realdata);
WORD cport = *(WORD*)(realdata+4);
if(cip==0 || cport==0)
{
return;
}
const uchar * id=realdata+6;
DWORD ConnAck = 0;
memcpy(&ConnAck, id+16, 4);
TRACE("recv sync, ConnAck=%08x\n", ConnAck);
#ifdef _DEBUG
in_addr addr;
addr.s_addr = cip;
TRACE("peer addr of %02X%02X%02X%02X = %s:%d\n", id[0], id[1], id[2],id[3],
inet_ntoa(addr), ntohs(cport));
#endif
uchar myid[16];
GetMyUserHash(myid);
if(memcmp(id, myid, 16)==0)
{
_AddLogLine(false, _T("ERROR: recv myself for traversal"));
return;
}
CAsyncSocketEx * pASock=NULL;
CUpDownClient * pClient= CGlobalVariable::clientlist->FindClientByUserHash(id);
if(pClient)
{
pASock = pClient->socket;
if(! pASock)
{
CRuntimeClass * pClassSocket = RUNTIME_CLASS(CClientReqSocket);
CClientReqSocket * socket = static_cast<CClientReqSocket*>(pClassSocket->CreateObject());
socket->SetClient(pClient);
if (!socket->Create())
{
socket->Safe_Delete();
return;
}
pClient->socket = socket;
pASock = socket;
}
ASSERT(pASock);
if(! pASock)
{
return;
}
}
else
{
TRACE("\n->%s: Accept a incoming sock for %02X%02X%02X%02X\n", __FUNCTION__,
id[0],id[1],id[2],id[3]);
pASock = CGlobalVariable::natthread->GetTempASock(id);
}
m_dwClientIp = cip;
m_wClientPort = cport;
m_dwState |=NAT_S_SYNC;
SendPingPacket();
}
void CUSBLogView::OnEditPaste(void)
{
if(!IsClipboardFormatAvailable(GetApp().m_uClipboardFormat))
{
TRACE("OnEditPaste(): no suitable clipboard format available!\n");
return;
}
// we need a focused URB as well...
int nFocusedURB = m_Log.FindFocusedURB();
if(-1 == nFocusedURB)
{
nFocusedURB = 0;
}
if(!AfxGetMainWnd()->OpenClipboard())
{
TRACE("Error while opening clipboard!\n");
return;
}
// from here on, we have to close the clipboard
// before exiting this function, otherwise other
// applications might not get a chance to copy/paste
// stuff!
HANDLE hBinary = NULL;
PVOID pData = NULL;
try
{
hBinary = GetClipboardData(GetApp().m_uClipboardFormat);
if(NULL == hBinary)
{
AfxThrowNotSupportedException();
}
pData = GlobalLock(hBinary);
{
CMyMemFile memFile(pData);
CArchive ar(&memFile, CArchive::load);
DWORD dwVersion = ar.ReadCount();
if(_VERSION_DWORD_ != dwVersion)
{
AfxThrowNotSupportedException();
}
DWORD nURBCnt = ar.ReadCount();
TRACE("Pasting %d URBs...\n", nURBCnt);
CUSBLogDoc *pDoc = GetDocument();
int nInsertLocation = nFocusedURB;
while(0 < nURBCnt)
{
CRuntimeClass *pClass = ar.ReadClass();
if(!pClass->IsDerivedFrom(RUNTIME_CLASS(CURB)))
{
TRACE("unknown runtime class!\n");
AfxThrowArchiveException(CArchiveException::badClass);
}
CURB *pURB = (CURB*) pClass->CreateObject();
ASSERT(NULL != pURB);
pURB->SetChunkAllocator(&pDoc->m_arURB.m_ChunkAllocator);
pURB->Serialize(ar);
pDoc->m_arURB.InsertAt(nInsertLocation, pURB);
nInsertLocation++;
--nURBCnt;
}
pDoc->UpdateAllViews(NULL, 1);
OnEditSelectNone();
m_Log.SetFocusedURB(nFocusedURB);
}
GlobalUnlock(hBinary);
hBinary = NULL;
CloseClipboard();
}
catch(...)
{
if((NULL != pData) && (NULL != hBinary))
{
GlobalUnlock(hBinary);
}
CloseClipboard();
throw;
}
}
CSettingsPage* XPageSettings()
{
CRuntimeClass* pClass = RUNTIME_CLASS( CPlaySettingsPage );
return (CSettingsPage*)pClass->CreateObject();
}
// Command line export function
void CCommandLineExport::CommandLineExport(const CString& fileIn, const CString& fileOut, const CString& fileLog, const CString& fileDPCM)
{
// open log
bool bLog = false;
CStdioFile fLog;
if (fileLog.GetLength() > 0)
{
if(fLog.Open(fileLog, CFile::modeCreate | CFile::modeWrite | CFile::typeText, NULL))
bLog = true;
}
// create CFamiTrackerDoc for export
CRuntimeClass* pRuntimeClass = RUNTIME_CLASS(CFamiTrackerDoc);
CObject* pObject = pRuntimeClass->CreateObject();
if (pObject == NULL || !pObject->IsKindOf(RUNTIME_CLASS(CFamiTrackerDoc)))
{
if (bLog) fLog.WriteString(_T("Error: unable to create CFamiTrackerDoc\n"));
return;
}
CFamiTrackerDoc* pExportDoc = static_cast<CFamiTrackerDoc*>(pObject);
// open file
if(!pExportDoc->OnOpenDocument(fileIn))
{
if (bLog)
{
fLog.WriteString(_T("Error: unable to open document: "));
fLog.WriteString(fileIn);
fLog.WriteString(_T("\n"));
}
return;
}
if (bLog)
{
fLog.WriteString(_T("Opened: "));
fLog.WriteString(fileIn);
fLog.WriteString(_T("\n"));
}
// find extension
int nPos = fileOut.ReverseFind(TCHAR('.'));
if (nPos < 0)
{
if (bLog)
{
fLog.WriteString(_T("Error: export filename has no extension: "));
fLog.WriteString(fileOut);
fLog.WriteString(_T("\n"));
}
return;
}
CString ext = fileOut.Mid(nPos);
theApp.GetSoundGenerator()->GenerateVibratoTable(pExportDoc->GetVibratoStyle());
// export
if (0 == ext.CompareNoCase(_T(".nsf")))
{
CCompiler compiler(pExportDoc, bLog ? new CCommandLineLog(&fLog) : NULL);
compiler.ExportNSF(fileOut, pExportDoc->GetMachine() );
if (bLog)
{
fLog.WriteString(_T("\nNSF export complete.\n"));
}
return;
}
else if (0 == ext.CompareNoCase(_T(".nes")))
{
CCompiler compiler(pExportDoc, bLog ? new CCommandLineLog(&fLog) : NULL);
compiler.ExportNES(fileOut, pExportDoc->GetMachine() == PAL);
if (bLog)
{
fLog.WriteString(_T("\nNES export complete.\n"));
}
return;
}
// BIN export requires two files
else if (0 == ext.CompareNoCase(_T(".bin")))
{
CCompiler compiler(pExportDoc, bLog ? new CCommandLineLog(&fLog) : NULL);
compiler.ExportBIN(fileOut, fileDPCM);
if (bLog)
{
fLog.WriteString(_T("\nBIN export complete.\n"));
}
return;
}
else if (0 == ext.CompareNoCase(_T(".prg")))
{
CCompiler compiler(pExportDoc, bLog ? new CCommandLineLog(&fLog) : NULL);
compiler.ExportPRG(fileOut, pExportDoc->GetMachine() == PAL);
if (bLog)
{
fLog.WriteString(_T("\nPRG export complete.\n"));
}
return;
}
else if (0 == ext.CompareNoCase(_T(".asm")))
{
CCompiler compiler(pExportDoc, bLog ? new CCommandLineLog(&fLog) : NULL);
compiler.ExportASM(fileOut);
if (bLog)
{
fLog.WriteString(_T("\nASM export complete.\n"));
}
return;
}
else if (0 == ext.CompareNoCase(_T(".nsfe"))) // // //
{
CCompiler compiler(pExportDoc, bLog ? new CCommandLineLog(&fLog) : NULL);
compiler.ExportNSFE(fileOut, pExportDoc->GetMachine());
if (bLog)
{
fLog.WriteString(_T("\nNSFe export complete.\n"));
}
return;
}
else if (0 == ext.CompareNoCase(_T(".txt")))
{
CTextExport textExport;
CString result = textExport.ExportFile(fileOut, pExportDoc);
if (result.GetLength() > 0)
{
if (bLog)
{
fLog.WriteString(_T("Error: "));
fLog.WriteString(result);
fLog.WriteString(_T("\n"));
}
}
else if (bLog)
{
fLog.WriteString(_T("Exported: "));
fLog.WriteString(fileOut);
fLog.WriteString(_T("\n"));
}
return;
}
else // use first custom exporter
{
CCustomExporters* pExporters = theApp.GetCustomExporters();
if (pExporters)
{
CStringArray sNames;
pExporters->GetNames(sNames);
if (sNames.GetCount())
{
pExporters->SetCurrentExporter(sNames[0]);
CFamiTrackerDocWrapper documentWrapper(CFamiTrackerDoc::GetDoc(), 0);
bool bResult = (pExporters->GetCurrentExporter().Export(&documentWrapper, fileOut));
if (bLog)
{
fLog.WriteString(_T("Custom exporter: "));
fLog.WriteString(sNames[0]);
fLog.WriteString(_T("\n"));
fLog.WriteString(_T("Export "));
fLog.WriteString(bResult ? _T("succesful: ") : _T("failed: "));
fLog.WriteString(fileOut);
fLog.WriteString(_T("\n"));
}
return;
}
}
}
if (bLog)
{
fLog.WriteString(_T("Error: unable to find matching export extension for: "));
fLog.WriteString(fileOut);
fLog.WriteString(_T("\n"));
}
return;
}
CActiveSourceWnd::CActiveSourceWnd(void):m_pContext(NULL)
{
CRuntimeClass* pFactory = RUNTIME_CLASS(CActiveSourceView);
m_pFormView = (CActiveSourceView *)(pFactory->CreateObject());
}
BOOL CTestOutlineTextDlg::OnInitDialog()
{
CDialog::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// Initialize the scroll view
CRect rect;
GetClientRect(&rect);
CClientDC dc(this);
int PosY = 190*dc.GetDeviceCaps(LOGPIXELSY)/96;
int nMargin = 7*dc.GetDeviceCaps(LOGPIXELSY)/96;
CRect rect2(nMargin,PosY,rect.Width()-nMargin*2,rect.Height()-nMargin-PosY);
CRuntimeClass *pClass = RUNTIME_CLASS(CMyScrollView);
m_pScrollView = (CMyScrollView*)pClass->CreateObject();
m_pScrollView->Create(NULL, NULL, WS_CHILD | WS_VISIBLE, rect2, this, 10001);
m_pScrollView->ModifyStyleEx(0, WS_EX_CLIENTEDGE);
m_pScrollView->OnInitialUpdate();
m_pScrollView->SetWindowPos(
&m_staticShadowColor,
nMargin,PosY,
rect.Width()-nMargin*2,
rect.Height()-nMargin-PosY,
SWP_SHOWWINDOW);
m_pScrollView->Render(false);
// Initialize buttons
COLORREF color= RGB(64,0,64);
m_btnOutlineColor1.SetColor(color);
m_pScrollView->SetOutlineColor1(Gdiplus::Color(GetRValue(color),GetGValue(color),GetBValue(color)));
COLORREF color2= RGB(255,128,255);
m_btnOutlineColor2.SetColor(color2);
m_pScrollView->SetOutlineColor2(Gdiplus::Color(GetRValue(color2),GetGValue(color2),GetBValue(color2)));
COLORREF colorText= RGB(255, 128, 64);
m_btnTextColor.SetColor(colorText);
m_pScrollView->SetTextColor1(Gdiplus::Color(GetRValue(colorText),GetGValue(colorText),GetBValue(colorText)));
COLORREF colorText2= RGB(255,0,0);
m_btnTextColor2.SetColor(colorText2);
m_pScrollView->SetTextColor2(Gdiplus::Color(GetRValue(colorText2),GetGValue(colorText2),GetBValue(colorText2)));
m_chkGradientText.SetCheck(1);
m_pScrollView->EnableTextGradient(true);
// initialize combo.
m_cboTextEffect.AddString(_T("Single Outline"));
m_cboTextEffect.AddString(_T("Double Outline"));
m_cboTextEffect.AddString(_T("Text Glow"));
m_cboTextEffect.AddString(_T("Gradient Outline"));
m_cboTextEffect.AddString(_T("Just Outline"));
m_cboTextEffect.AddString(_T("No Outline"));
m_cboTextEffect.AddString(_T("Double Text Glow"));
m_cboTextEffect.SetCurSel(3);
m_pScrollView->SetTextEffect(GradOutline);
EnableOutline2UI(TRUE, TRUE);
m_cboTextPath.AddString(_T("GDI+"));
m_cboTextPath.AddString(_T("GDI"));
m_cboTextPath.SetCurSel(0);
m_pScrollView->SetTextPath(GdiPlus);
m_edtAngle.EnableWindow(FALSE);
m_staticAngle.EnableWindow(FALSE);
// Set the font
//LOGFONT lf;
memset(&m_lf, 0, sizeof(m_lf));
m_lf.lfHeight = -48; //-MulDiv(48, dc.GetDeviceCaps(LOGPIXELSY), 72);
m_lf.lfWeight = FW_NORMAL;
//m_lf.lfItalic = TRUE;
//m_lf.lfOrientation = 100;
//m_lf.lfEscapement = 100;
//m_lf.lfOutPrecision = OUT_TT_ONLY_PRECIS;
m_lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
m_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
m_lf.lfQuality = PROOF_QUALITY;
wcscpy_s(m_lf.lfFaceName, _T("Arial Black"));
m_edtFont.SetWindowText(_T("Arial Black, 36 Regular"));
m_pScrollView->SetLogFont(&m_lf);
m_pScrollView->SetFontSize(48);
// Set the Text
CString str = _T("TEXT DESIGNER");
m_edtText.SetWindowText(str);
m_pScrollView->SetText(str);
// Set the Alphas
m_edtOutlineAlpha1.SetWindowText(_T("255"));
m_pScrollView->SetOutlineAlpha1(255);
m_edtOutlineAlpha2.SetWindowText(_T("255"));
m_pScrollView->SetOutlineAlpha2(255);
// Set the Thickness
m_edtThickness1.SetWindowText(_T("5"));
m_pScrollView->SetOutlineThickness1(5);
m_edtThickness2.SetWindowText(_T("5"));
m_pScrollView->SetOutlineThickness2(5);
// Set Text Position
m_edtPosX.SetWindowText(_T("10"));
m_pScrollView->SetTextPosX(10);
m_edtPosY.SetWindowText(_T("10"));
m_pScrollView->SetTextPosY(10);
m_edtAngle.SetWindowText(_T("0"));
m_pScrollView->SetTextAngle(0);
// Set Shadow Properties
m_chkEnableShadow.SetCheck(1);
//m_pScrollView->SetEnableShadow(true);
OnBnClickedChkEnableShadow();
m_edtShadowAlpha.SetWindowText(_T("128"));
m_pScrollView->SetShadowAlpha(128);
m_edtShadowOffsetX.SetWindowText(_T("4"));
m_pScrollView->SetShadowOffsetX(4);
m_edtShadowOffsetY.SetWindowText(_T("4"));
m_pScrollView->SetShadowOffsetY(4);
m_btnShadowColor.SetColor(RGB(0,0,0));
m_pScrollView->SetShadowColor(Gdiplus::Color(0,0,0));
m_edtShadowThickness.SetWindowText(_T("8"));
m_pScrollView->SetShadowThickness(8);
m_chkDiffusedShadow.SetCheck(0);
OnBnClickedChkDiffusedShadow();
// PNG rendering
m_chkPngRendering.SetCheck(0);
OnBnClickedChkEnablePngRendering();
m_chkExtrudedText.SetCheck(0);
OnBnClickedChkExtrudedText();
m_chkEnableReflection.SetCheck(0);
m_chkEnableReflection.EnableWindow(FALSE);
m_pScrollView->EnableReflection(false);
m_btnReflectSettings.EnableWindow(FALSE);
m_btnSavePng.EnableWindow(FALSE);
m_btnSaveRefPng.EnableWindow(FALSE);
//m_btnFont.EnableWindow(FALSE);
m_pScrollView->Render(true);
return TRUE; // return TRUE unless you set the focus to a control
}