commonproc.cpp

医学图象处理系统

			}
			cVal.UnlockBuffer();
			return true;
		}
	}
	return false;
}*/

bool CIni::GetValue(const char * cSection, const char * cItem, CString &cVal)
{
	int idx = FindSection(cSection);
	if (idx >= 0)
	{
		if (FindItem(idx+1, cItem, cVal) > 0)
			return true;
	}
	return false;
}

bool CIni::GetValue(const char * cSection, const char * cItem, double &dbVal)
{
	int idx = FindSection(cSection);
	if (idx >= 0)
	{
		CString csVal;
		if (FindItem(idx+1, cItem, csVal) > 0)
		{
			dbVal =  atof(csVal);
			return true;
		}
	}
	return false;
}

bool CIni::GetValue(const char * cSection, const char * cItem, float &fVal)
{
	int idx = FindSection(cSection);
	if (idx >= 0)
	{
		CString csVal;
		if (FindItem(idx+1, cItem, csVal) > 0)
		{
			fVal = (float) atof(csVal);
			return true;
		}
	}
	return false;
}

bool CIni::GetValue(const char * cSection, const char * cItem, long &lVal)
{
	int idx = FindSection(cSection);
	if (idx >= 0)
	{
		CString csVal;
		if (FindItem(idx+1, cItem, csVal) > 0)
		{
			lVal = (long) atol(csVal);
			return true;
		}
	}
	return false;
}

bool CIni::GetValue(const char * cSection, const char * cItem, int &iVal)
{
	int idx = FindSection(cSection);
	if (idx >= 0)
	{
		CString csVal;
		if (FindItem(idx+1, cItem, csVal) > 0)
		{
			iVal = (int) atoi(csVal);
			return true;
		}
	}
	return false;
}



bool CIni::GetValue(const char * cSection, const char * cItem, CRect &rcVal)
{
	int idx = InsertSection(cSection);
	if (idx >= 0)
	{
		CString csVal;
		if (FindItem(idx+1, cItem, csVal) > 0)
		{
			char * pt = csVal.LockBuffer();
			int pf, t = 0, l = 0, r = 0, b = 0;
			pf = sscanf(csVal, "RECT(%d,%d,%d,%d)", &l, &t, &r, &b);
			ASSERT(pf == 4);
			csVal.UnlockBuffer();
			rcVal.SetRect(l, t, r, b);
			return true;
		}
	}
	return false;
}

bool CIni::GetValue(const char * cSection, const char * cItem, CPoint &ptVal)
{
	int idx = InsertSection(cSection);
	if (idx >= 0)
	{
		CString csVal;
		if (FindItem(idx+1, cItem, csVal) > 0)
		{
			char * pt = csVal.LockBuffer();
			int pf, x = 0, y = 0;
			pf = sscanf(csVal, "POINT(%d,%d)", &x, &y);
			ASSERT(pf == 2);
			csVal.UnlockBuffer();
			ptVal.x = x;
			ptVal.y = y;
			return true;
		}
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////
// CProgressDlg dialog
CProgressDlg::CProgressDlg(UINT nCaptionID)
{
	m_nCaptionID = CG_IDS_PROGRESS_CAPTION;
	if (nCaptionID != 0)
		m_nCaptionID = nCaptionID;

    m_bCancel=FALSE;
    m_nLower=0;
    m_nUpper=100;
    m_nStep=10;
    //{{AFX_DATA_INIT(CProgressDlg)
    // NOTE: the ClassWizard will add member initialization here
    //}}AFX_DATA_INIT
    m_bParentDisabled = FALSE;
}

CProgressDlg::~CProgressDlg()
{
    if(m_hWnd!=NULL)
      DestroyWindow();
}

BOOL CProgressDlg::DestroyWindow()
{
    ReEnableParent();
    return CDialog::DestroyWindow();
}

void CProgressDlg::ReEnableParent()
{
    if(m_bParentDisabled && (m_pParentWnd!=NULL))
      m_pParentWnd->EnableWindow(TRUE);
    m_bParentDisabled=FALSE;
}

BOOL CProgressDlg::Create(CWnd *pParent)
{
    // Get the true parent of the dialog
    m_pParentWnd = CWnd::GetSafeOwner(pParent);

    // m_bParentDisabled is used to re-enable the parent window
    // when the dialog is destroyed. So we don't want to set
    // it to TRUE unless the parent was already enabled.

    if((m_pParentWnd!=NULL) && m_pParentWnd->IsWindowEnabled())
    {
      m_pParentWnd->EnableWindow(FALSE);
      m_bParentDisabled = TRUE;
    }

    if(!CDialog::Create(CProgressDlg::IDD,pParent))
    {
      ReEnableParent();
      return FALSE;
    }

    return TRUE;
}

void CProgressDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CProgressDlg)
    DDX_Control(pDX, CG_IDC_PROGDLG_PROGRESS, m_Progress);
    //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CProgressDlg, CDialog)
    //{{AFX_MSG_MAP(CProgressDlg)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

void CProgressDlg::SetStatus(LPCTSTR lpszMessage)
{
    ASSERT(m_hWnd); // Don't call this _before_ the dialog has
                    // been created. Can be called from OnInitDialog
    CWnd *pWndStatus = GetDlgItem(CG_IDC_PROGDLG_STATUS);
    // Verify that the static text control exists
    ASSERT(pWndStatus!=NULL);
    pWndStatus->SetWindowText(lpszMessage);
}

void CProgressDlg::OnCancel()
{
    m_bCancel=TRUE;
}

void CProgressDlg::SetRange(int nLower,int nUpper)
{
    m_nLower = nLower;
    m_nUpper = nUpper;
    m_Progress.SetRange(nLower,nUpper);
}
  
int CProgressDlg::SetPos(int nPos)
{
    PumpMessages();
    int iResult = m_Progress.SetPos(nPos);
    UpdatePercent(nPos);
    return iResult;
}

int CProgressDlg::SetStep(int nStep)
{
    m_nStep = nStep; // Store for later use in calculating percentage
    return m_Progress.SetStep(nStep);
}

int CProgressDlg::OffsetPos(int nPos)
{
    PumpMessages();
    int iResult = m_Progress.OffsetPos(nPos);
    UpdatePercent(iResult+nPos);
    return iResult;
}

int CProgressDlg::StepIt()
{
    PumpMessages();
    int iResult = m_Progress.StepIt();
    UpdatePercent(iResult+m_nStep);
    return iResult;
}

void CProgressDlg::PumpMessages()
{
    // Must call Create() before using the dialog
    ASSERT(m_hWnd!=NULL);

    MSG msg;
    // Handle dialog messages
    while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    {
      if(!IsDialogMessage(&msg))
      {
        TranslateMessage(&msg);
        DispatchMessage(&msg);  
      }
    }
}

BOOL CProgressDlg::CheckCancelButton()
{
    // Process all pending messages
    PumpMessages();

    // Reset m_bCancel to FALSE so that
    // CheckCancelButton returns FALSE until the user
    // clicks Cancel again. This will allow you to call
    // CheckCancelButton and still continue the operation.
    // If m_bCancel stayed TRUE, then the next call to
    // CheckCancelButton would always return TRUE

    BOOL bResult = m_bCancel;
    m_bCancel = FALSE;

    return bResult;
}

void CProgressDlg::UpdatePercent(int nNewPos)
{
    CWnd *pWndPercent = GetDlgItem(CG_IDC_PROGDLG_PERCENT);
    int nPercent;
    
    int nDivisor = m_nUpper - m_nLower;
    ASSERT(nDivisor>0);  // m_nLower should be smaller than m_nUpper

    int nDividend = (nNewPos - m_nLower);
    ASSERT(nDividend>=0);   // Current position should be greater than m_nLower

    nPercent = nDividend * 100 / nDivisor;

    // Since the Progress Control wraps, we will wrap the percentage
    // along with it. However, don't reset 100% back to 0%
    if(nPercent!=100)
      nPercent %= 100;

    // Display the percentage
    CString strBuf;
    strBuf.Format(_T("%d%c"),nPercent,_T('%'));

	CString strCur; // get current percentage
    pWndPercent->GetWindowText(strCur);

	if (strCur != strBuf)
		pWndPercent->SetWindowText(strBuf);
}
    
/////////////////////////////////////////////////////////////////////////////
// CProgressDlg message handlers

BOOL CProgressDlg::OnInitDialog() 
{
    CDialog::OnInitDialog();
    m_Progress.SetRange(m_nLower,m_nUpper);
    m_Progress.SetStep(m_nStep);
    m_Progress.SetPos(m_nLower);

	CString strCaption;
	VERIFY(strCaption.LoadString(m_nCaptionID));
    SetWindowText(strCaption);

    return TRUE;  
}

CString	GetNextSerialFilename(CString Filename)
{
	CString ReturnString = Filename;
	int count = Filename.GetLength();
	int StartPos = count-4;
	if(Filename.GetAt(StartPos)!='.')
	{
		AfxMessageBox("wrong in filename!");
		return "haha";
	}
	BOOL ok = FALSE;
	BYTE tChar;
    while(!ok)
	{
		StartPos--;
		if(StartPos<=0) ok = TRUE;
		tChar = Filename.GetAt(StartPos) - '0';
		if(tChar>=0&&tChar<9)
		{
			tChar = tChar + 1 + '0';
			ReturnString.SetAt(StartPos,tChar);
			ok = TRUE;
		}
		else
		{
			if(tChar==9)
				ReturnString.SetAt(StartPos,'0');
			else
				ok = TRUE;
		}
	}	
	return ReturnString;
}
CString	GetPrevSerialFilename(CString Filename)
{
	CString ReturnString = Filename;
	int count = Filename.GetLength();
	int StartPos = count-4;
	if(Filename.GetAt(StartPos)!='.')
	{
		AfxMessageBox("wrong in filename!");
		return "haha";
	}
	BOOL ok = FALSE;
	BYTE tChar;
    while(!ok)
	{
		StartPos--;
		if(StartPos<=0) ok = TRUE;
		tChar = Filename.GetAt(StartPos) - '0';
		if(tChar>0&&tChar<=9)
		{
			tChar = tChar - 1 + '0';
			ReturnString.SetAt(StartPos,tChar);
			ok = TRUE;
		}
		else
		{
			if(tChar==0)
				ReturnString.SetAt(StartPos,'9');
			else
				ok = TRUE;
		}
	}	
	return ReturnString;
}

CString GetNameformFullPathName(CString FullPathName)
{	
	int	count1 = FullPathName.ReverseFind('\\');
	int	count2 = FullPathName.GetLength();
	count2 -= (count1 + 1);
	CString RV= "", FileName;
	FileName = FullPathName.Right(count2);
	if( count2 > 4 )
	{
		RV = FileName.Left(count2- 4);
	}
	return RV;
}

CString GetCurrentDirectory()
{
	int	drive = _getdrive();
	char path[256];
	_getdcwd(drive,path,256);
	return path;
}

BOOL IsExistFile(CString Filename)
{
	struct _finddata_t c_file;    
	long hFile;
	 
	if( (hFile = _findfirst(Filename, &c_file )) != -1L )
		return TRUE;
	else
		return FALSE;
}

BOOL FindNextFile(CString &Filename)
{
	int count1 = Filename.ReverseFind('\\');
	//TRACE("The Filename is %s\n",Filename);
	CString Path = Filename.Left(count1+1);
	CString FileExtname = Path + "*" + Filename.Right(4);
	//TRACE("The FileExtname is %s\n",FileExtname);
	CString LastFilename ;

	struct _finddata_t c_file;    
	long hFile;
	BOOL OK = FALSE;
	 
	if( (hFile = _findfirst(FileExtname, &c_file )) != -1L )
	{
		LastFilename = Path + c_file.name;	
		//TRACE("next image filename is %s\n",LastFilename);
		while( _findnext( hFile, &c_file ) == 0 )            
		{
			if(LastFilename == Filename) OK=TRUE;
			if(OK)
			{
				Filename = Path + c_file.name;
				return TRUE;
			}
			LastFilename = Path + c_file.name;			
		}		 
	}
	_findclose( hFile );  
	return FALSE;
}

BOOL FindPrevFile(CString &Filename)
{
	int count1 = Filename.ReverseFind('\\');
	//TRACE("The Filename is %s\n",Filename);
	CString Path = Filename.Left(count1+1);
	CString FileExtname = Path + "*" + Filename.Right(4);
	//TRACE("The FileExtname is %s\n",FileExtname);
	CString LastFilename ;

	struct _finddata_t c_file;    
	long hFile;
	BOOL OK = FALSE;