calibrationdlg.cpp

ccp

// calibrationDlg.cpp : implementation file
//

#include "stdafx.h"
#include "calibration.h"
#include "calibrationDlg.h"

#include "canape.h"
#include "canape_i.c"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// static variables

static CComPtr<IApplication>        pApplication;
static CComPtr<IDevices>            pDevices;
static CComPtr<IDevice>             pDevice;
static CComPtr<ICalibrationObjects> pCalibrationObjects;

// end static variables
/////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDD_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CCalibrationDlg dialog

CCalibrationDlg::CCalibrationDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CCalibrationDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CCalibrationDlg)
	m_WorkDir = _T("");
	m_Database = _T("");
	m_Driver = _T("");
	m_Devicename = _T("");
	m_Channel = 0;
	m_Value = 0.0;
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CCalibrationDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CCalibrationDlg)
	DDX_Control(pDX, IDC_LISTOBJECTS, m_Objects);
	DDX_Text(pDX, IDC_EDIT_WORKDIR, m_WorkDir);
	DDX_Text(pDX, IDC_EDIT_DB, m_Database);
	DDX_Text(pDX, IDC_EDIT_DRIVER, m_Driver);
	DDX_Text(pDX, IDC_EDIT_NAME, m_Devicename);
	DDX_Text(pDX, IDC_EDIT_CHANNEL, m_Channel);
	DDV_MinMaxUInt(pDX, m_Channel, 1, 4);
	DDX_Text(pDX, IDC_EDIT_VALUE, m_Value);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CCalibrationDlg, CDialog)
	//{{AFX_MSG_MAP(CCalibrationDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDSTARTCANAPE, OnStartCanape)
	ON_BN_CLICKED(IDSTOPCANAPE, OnStopCanape)
	ON_BN_CLICKED(IDSELECTOBJECTS, OnSelectObjects)
	ON_LBN_SELCHANGE(IDC_LISTOBJECTS, OnSelchangeListobjects)
	ON_BN_CLICKED(IDCLEAROBJECTS, OnClearobjects)
	ON_BN_CLICKED(IDCREAD, OnRead)
	ON_BN_CLICKED(IDCWRITE, OnWrite)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CCalibrationDlg message handlers

BOOL CCalibrationDlg::OnInitDialog()
{
  CDialog::OnInitDialog();

  // Add "About..." menu item to system menu.

  // IDM_ABOUTBOX must be in the system command range.
  ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
  ASSERT(IDM_ABOUTBOX < 0xF000);

  CMenu* pSysMenu = GetSystemMenu(FALSE);
  if (pSysMenu != NULL)
  {
	  CString strAboutMenu;
	  strAboutMenu.LoadString(IDS_ABOUTBOX);
	  if (!strAboutMenu.IsEmpty())
	  {
		  pSysMenu->AppendMenu(MF_SEPARATOR);
		  pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
	  }
  }

  // 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

  // get working directory from registry
  HKEY phk = 0;
  unsigned char pData[256];
  unsigned long len = sizeof(pData) - 1;
  unsigned long t = 0;

  CString CANapePath(_T("c:\\Programme\\CANape"));

  long res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\VECTOR\\CANape", 0, KEY_READ, &phk);
  if (res == ERROR_SUCCESS) {
      res = RegQueryValueEx(phk, "Path", 0, &t, pData, &len);
      if (res == ERROR_SUCCESS) {
        if (pData[len-2] == '@') {
          pData[len-2] = 0;
        }
        CANapePath = CString(pData);
      }
  }  

  // initialize variables
  m_WorkDir    = CANapePath + _T("\\CCPsim");
  m_Database   = _T("CCPsim.a2l");
  m_Devicename = _T("CCPsim");
  m_Driver     = _T("CCP");
  m_Channel    = 1;

  ((CButton*)GetDlgItem(IDC_RADIOCAL))->SetCheck(BST_CHECKED);

  EnableWindows(false);
  UpdateData(FALSE);

  // Initialize the COM library 
  CoInitialize(NULL);

  HRESULT hr = CoCreateInstance( CLSID_Application, 
                                        NULL, 
                                        CLSCTX_SERVER, 
                                        IID_IApplication,
                                        ( void**)&pApplication);

  return TRUE;  // return TRUE  unless you set the focus to a control
}

void CCalibrationDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
  if ((nID & 0xFFF0) == IDM_ABOUTBOX)
  {
    CAboutDlg dlgAbout;
    dlgAbout.DoModal();
  }
  else
  {
    CDialog::OnSysCommand(nID, lParam);
  }
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CCalibrationDlg::OnPaint() 
{
  if (IsIconic())
  {
    CPaintDC dc(this); // device context for painting

    SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

    // Center icon in client rectangle
    int cxIcon = GetSystemMetrics(SM_CXICON);
    int cyIcon = GetSystemMetrics(SM_CYICON);
    CRect rect;
    GetClientRect(&rect);
    int x = (rect.Width() - cxIcon + 1) / 2;
    int y = (rect.Height() - cyIcon + 1) / 2;

    // Draw the icon
    dc.DrawIcon(x, y, m_hIcon);
  }
  else
  {
    CDialog::OnPaint();
  }
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CCalibrationDlg::OnQueryDragIcon()
{
  return (HCURSOR) m_hIcon;
}


void CCalibrationDlg::OnStartCanape() 
{
  UpdateData();

  if (pApplication) { 	
    
    CComBSTR bstr(m_WorkDir);
    HRESULT hr = pApplication->Open(bstr, 0);

    if (FAILED(hr)) {
      MessageBox(_T("Could not open CANape"), _T("Error"), MB_OK);
      return;
    }

    if (!pDevices) {

      CComPtr<IDispatch> pDispatch;

      hr = pApplication->get_Devices( &pDispatch);
      ASSERT( SUCCEEDED( hr));

      hr = pDispatch->QueryInterface( IID_IDevices, ( void**)&pDevices);
      ASSERT( SUCCEEDED( hr));
    }

    if (pDevices && !pDevice) {
      
      CComBSTR name(m_Devicename);
      CComBSTR db(m_Database);
      CComBSTR driver(m_Driver);
      LONG     channel(m_Channel);
      hr = pDevices->Add(name, db, driver, channel, &pDevice);

      if (FAILED(hr)) {
        MessageBox(_T("Could not add device "), _T("Error"), MB_OK);
        return;
      }

      CComPtr<IDispatch> pDispatch;
      HRESULT hr = pDevice->get_CalibrationObjects( &pDispatch);
      ASSERT( SUCCEEDED( hr));

      hr = pDispatch->QueryInterface( IID_ICalibrationObjects, ( void**)&pCalibrationObjects);
      ASSERT( SUCCEEDED( hr));

    }

  }

}


void CCalibrationDlg::OnStopCanape() 
{
  if (pDevices) {
    pDevices->Clear();
    pCalibrationObjects = 0;
    pDevice = 0;
  }

  if (pApplication)
    pApplication->Quit();

  m_Objects.ResetContent();
  EnableWindows(false);
  UpdateData(false);
}


void CCalibrationDlg::OnSelectObjects() 
{

  if (pCalibrationObjects) {
    
    CComBSTR type;

    if ( ((CButton*)GetDlgItem(IDC_RADIOCAL))->GetCheck() == BST_CHECKED ) {
      type = CComBSTR("OTT_CALIBRATE");
    } else {
      type = CComBSTR("OTT_MEASURE");
    };

    HRESULT hr = pCalibrationObjects->Add(type);

    if (FAILED(hr)) {
      MessageBox(_T("Could not add calibration objects "), _T("Error"), MB_OK);
      return;
    }

    CComBSTR name;
    LONG     count;
    hr = pCalibrationObjects->get_Count(&count);
    
    if (SUCCEEDED(hr)) {
      m_Objects.ResetContent();
      for (int i=1; i<=count; i++) {
        CComPtr<ICalibrationObject> pCalibrationObject;
        CComVariant var;
        var.vt = VT_I4;
        var.lVal = i;
        hr = pCalibrationObjects->get_Item(var, &pCalibrationObject);
        if (SUCCEEDED(hr)) {
          if (pCalibrationObject) {
            hr = pCalibrationObject->get_Name(&name);
            if (SUCCEEDED(hr)) {
              m_Objects.AddString(CString(name));
            }
          }
        } else {
          MessageBox(_T("Could not get calibration object "), _T("Error"), MB_OK);
          return;
        }
      }
      UpdateData(false);
    }

  }

}


void CCalibrationDlg::OnClearobjects() 
{

  if (pCalibrationObjects) {
    
    HRESULT hr = pCalibrationObjects->Clear();
    if (SUCCEEDED(hr)) {
      m_Objects.ResetContent();
      EnableWindows(false);

    } else {
      MessageBox(_T("Could not clear calibration object list "), _T("Error"), MB_OK);
      return;
    }

    UpdateData(false);
  }

}


void CCalibrationDlg::OnSelchangeListobjects() 
{
  OnRead();
}


void CCalibrationDlg::OnRead() 
{
  if (pCalibrationObjects) {
    
    CComPtr<ICalibrationObject> pCalibrationObject;
    char curSel[256];
    m_Objects.GetText(m_Objects.GetCurSel(), curSel);
    CComVariant var;
    var.vt = VT_BSTR;
    var.bstrVal = CComBSTR(curSel);
    HRESULT hr = pCalibrationObjects->get_Item(var, &pCalibrationObject);
    if (SUCCEEDED(hr)) {
      if (pCalibrationObject) {
        CComVariant value;
        hr = pCalibrationObject->Read(&value);
        if (SUCCEEDED(hr)) {

          //just display single values
          if (value.vt == 0x2005) {
            EnableWindows(false);
       
          } else {
            EnableWindows(true);
            m_Value = value.dblVal;
          }
        }
      }
    } else {
      MessageBox(_T("Could not get calibration object "), _T("Error"), MB_OK);
      return;
    }

    UpdateData(false);
  }
}


void CCalibrationDlg::OnWrite() 
{
  double oldValue = m_Value;
  UpdateData();

  if (pCalibrationObjects) {
    
    CComPtr<ICalibrationObject> pCalibrationObject;
    char curSel[256];
    m_Objects.GetText(m_Objects.GetCurSel(), curSel);
    CComVariant var;
    var.vt = VT_BSTR;
    var.bstrVal = CComBSTR(curSel);
    HRESULT hr = pCalibrationObjects->get_Item(var, &pCalibrationObject);
    if (SUCCEEDED(hr)) {
      if (pCalibrationObject) {
        CComVariant value;
        value.vt = VT_R8;
        value.dblVal = m_Value;
        hr = pCalibrationObject->put_Value(value);
        if (SUCCEEDED(hr)) {
          hr = pCalibrationObject->Write();
        }
        if (FAILED(hr)) {
          MessageBox(_T("Could not write value "), _T("Error"), MB_OK);
          m_Value = oldValue;
        }
      }
    } else {
      MessageBox(_T("Could not get calibration object "), _T("Error"), MB_OK);
      return;
    }
  }

  UpdateData(false);
}


void CCalibrationDlg::EnableWindows(bool enable)
{
  CWnd*       wnd;

  wnd = GetDlgItem(IDCREAD);
  if (wnd) wnd->EnableWindow(enable);
  wnd = GetDlgItem(IDCWRITE);
  if (wnd) wnd->EnableWindow(enable);
  wnd = GetDlgItem(IDC_EDIT_VALUE);
  if (wnd) wnd->EnableWindow(enable);
}