busview.cpp

BCAM 1394 Driver

              {
                m_TreeView.SetItemText(hItem, pDevice->Info.ModelName());
              }
            }
            CATCH_REPORT();
          }
        }
        else
        {
          if ( m_CameraManager.GetCurrentDevice() == NULL )
          {
            // The camera manager could not open the device and no other device has been previously 
            // selected, so select the root item
            m_TreeView.SelectItem(m_RootItem);
          }
          
          if ( error != E_DEVICE_ALREADY_OPENED )
          {
            // update the device list, perhaps there are inconsistencies
            UpdateDeviceList();
          }
        }
      }
    }
    else
    {
      // inform the camera manager that currently now device is selected
      m_CameraManager.CurrentDeviceChanged(NULL);
    }
  } CATCH_REPORT();
  
  return 0;
}
  
//------------------------------------------------------------------------------
// LRESULT CBusView::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
// Author: M.Albrech
// Date: 
//------------------------------------------------------------------------------
/**
 * Called when the window is to be destroyed. 
 *
 * \param     uMsg
 * \param     wParam
 * \param     lParam
 * \param     bHandled
 * \return    0
 *
 */
//------------------------------------------------------------------------------
LRESULT CBusView::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
 
  try
  {
    NodeMap_t::iterator pEntry;
    for ( pEntry = m_NodeMap.begin(); pEntry != m_NodeMap.end(); ++pEntry )
    {
      delete pEntry->second;
    }
    
  }
  catch ( BcamException& )
  { /* NOP */ }
  
  bHandled = false;
  return 0;
}


///////////////////////////////////////////////////////////////////////////////////////////////////////
// Handling of removal / arrival of new devices

//------------------------------------------------------------------------------
// void CBusView::AddNode(CString devName, GUID guid)
// Author: 
//------------------------------------------------------------------------------
/**
 * Add a new node to the bus view. Let the camera manager create a new camera object. 
 * Try to restore the settings of a camera object from the registry
 *
 * \param     devName Device name of the new device
 * \param     guid Device's interface GUID
 * \return    void
 *
 */
//------------------------------------------------------------------------------
void CBusView::AddNode(CString devName, GUID guid)
{
  devName.MakeUpper();

  CBusNode *pNode;
  CString ModelName = UNABLE_TO_OPEN;

  if ( ContainsNode(devName) )
  {
    RemoveNode(devName);
  }

  if ( IsEqualGUID(guid, GUID_FILE_DEVICE_BCAM_1394) )
  {
    // add a BCAM device
    CCamera* pCamera;
    try
    {
      m_CameraManager.AddDevice(devName, m_hWnd);
      pCamera = m_CameraManager.GetDevice(devName);
      assert ( pCamera != NULL );

      // try to open camera and to read model name
      try
      {
        pCamera->Activate();
        ModelName = pCamera->Info.ModelName();
        if ( m_MainFrame.m_fRestoreCameraSettings )
        {
          // try to restore the camera's settings
          try
          {
            pCamera->RestoreConfiguration(Bcam::CRegistryPropertyBag::Open(APPLICATION_KEY + pCamera->Info.NodeId() + "\\Device"));
          }
          catch ( BcamException& e)
          {
            if ( e.Error() != BCAM_E_BAG_DOES_NOT_EXIST )
              ReportError(e);
          }
        }
      }
      catch(...) 
      { /* NOP */ }
      try
      {
        pCamera->Deactivate();
      }
      catch(...)
      { /* NOP */ }

      pNode = new CBcamBusNode(devName);
      if ( pNode == NULL )
        throw BcamException(ERROR_OUTOFMEMORY, "CBusView::AddNode()");
    }
    CATCH_REPORT();

    HTREEITEM hItem = m_TreeView.InsertItem(ModelName, 1, 1, m_RootItem, TVI_LAST);
    m_TreeView.Expand(m_RootItem);
    m_NodeMap[hItem] = pNode;
  }
  else
    // other devices not yet handled 
    assert(false);
}

//------------------------------------------------------------------------------
// bool CBusView::ContainsNode(CString devName)
// Author: 
//------------------------------------------------------------------------------
/**
 * Determines of the map already contains a node for devName
 *
 * \param     devName  The device's name
 * \return    true, if a node for devName already exists
 *
 */
//------------------------------------------------------------------------------
bool CBusView::ContainsNode(CString devName)
{
  devName.MakeUpper();
  NodeMap_t::iterator pEntry;
  for ( pEntry = m_NodeMap.begin(); pEntry != m_NodeMap.end(); ++pEntry )
  {
    if ( pEntry->second->DeviceName() == devName )
    {
      return true;
    }
  }
  return false;
}


//------------------------------------------------------------------------------
// void CBusView::RemoveNode(CString devName)
// Author: 
//------------------------------------------------------------------------------
/**
 * Remove the node for a specific device from the tree view
 *
 * \param     devName  The device's name
 * \return    void
 *
 */
//------------------------------------------------------------------------------
void CBusView::RemoveNode(CString devName)
{
  devName.MakeUpper();
  NodeMap_t::iterator pEntry;
  for ( pEntry = m_NodeMap.begin(); pEntry != m_NodeMap.end(); ++pEntry )
  {
    if ( pEntry->second->DeviceName() == devName )
    {
      m_TreeView.DeleteItem(pEntry->first);
      // destroy node
      delete pEntry->second;
      // remove node from map
      m_NodeMap.erase(pEntry);
      if ( m_TreeView.GetCount() == 0 )
      {
        // The last device is removed, notify rest of the world.
        // This notification is necessary because removing the last device will not cause
        // TVN_SELCHANGED notification
        m_CameraManager.CurrentDeviceChanged(NULL);
      }
      m_MainFrame.DeviceRemoved(devName);

      break;
    }
  }
}


void CBusView::UpdateDeviceList()
{
  list<CString> devices = CBcam::DeviceNames();
  list<CString>::iterator deviceName;

  // check if each device of the device list is in the bus view's map
  for ( deviceName = devices.begin(); deviceName != devices.end(); ++deviceName)
  {
    if ( ! ContainsNode(*deviceName) )
      AddNode(*deviceName, GUID_FILE_DEVICE_BCAM_1394);
  }

  // check if each bcam node in the device tree is contained in the current device list
  NodeMap_t::iterator pEntry;
  for ( pEntry = m_NodeMap.begin(); pEntry != m_NodeMap.end(); ++pEntry )
  {
    bool found = false;
    for ( deviceName = devices.begin(); deviceName != devices.end(); ++deviceName)
    {
      if ( deviceName->CompareNoCase(pEntry->second->DeviceName()) == 0 )
      {
        found = true;
        break;
      }
    }
    if ( ! found )
    {
      RemoveNode(pEntry->second->DeviceName());
    }
  }
}

      


////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Public member functions
//

//------------------------------------------------------------------------------
// void CBusView::CurrentDeviceChanged(CCamera* pCamera)
// Author: 
//------------------------------------------------------------------------------
/**
 * To be called if another device is to be selected (e.g. the user actiates an image 
 * child window associated with a camera device which isn't selected in the tree view
 *
 * \param     pCamera Pointer to the camera device
 * \return    void
 *
 */
//------------------------------------------------------------------------------
void CBusView::CurrentDeviceChanged(CCamera* pCamera)
{
  if ( ! pCamera )
    return;
  CString DeviceName = pCamera->Info.DeviceName();

  NodeMap_t::iterator it;
  for ( it = m_NodeMap.begin(); it != m_NodeMap.end(); ++it )
  {
    if ( it->second->DeviceName() == DeviceName )
    {
      m_TreeView.SelectItem(it->first);
      break;
    }
  }
}


////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Protected / private member functions
//

//------------------------------------------------------------------------------
// void CBusView::ReportError(BcamException& e) 
// Author: 
//------------------------------------------------------------------------------
/**
 * Shows an error message
 *
 * \param     e Reference to a BcamException
 * \return    void
 *
 */
//------------------------------------------------------------------------------
void CBusView::ReportError(BcamException& e) 
{
  m_MainFrame.ReportError(e);
}