eventview.cpp

一个modbus协议的opc server

        return;
    
    // Create an event and add to pending event list.  Wrap with exception
    // handler in case of memory allocation propbles (not too likely).
    try
    {
        // Instantiate a new CKEvent object to contain information about
        // this event:
        CKEvent *pEvent = new CKEvent (lpszMessage, eType);
        
        // Check for room in the pending events list.  If we are out of
        // room, allocate larger block of memory and transfer existing
        // events to it.
        if (m_cnPendingEvents == m_cnPendingAllocEvents)
        {
            // Create a pointer to a new pending events array:
            CKEvent **p;
            
            // Allocate memory for the new array/list large enough for 
            // existing events plus room for new ones. (This is an array
            // of pointers to CKEvent objects.)
            p = new CKEvent * [m_cnPendingAllocEvents + GROWEVENTS];
            
            // Transfer existing events to the new memory and free memory
            // used by old list:
            if (m_cnPendingEvents)
            {
                memcpy (p, m_pPendingEventList, m_cnPendingEvents * sizeof (m_pPendingEventList[0]));
                delete [] m_pPendingEventList;
            }
            
            // Reset pointer to pending event list to give new memory area:
            m_pPendingEventList = p;
            
            // Increment size of memory allocated for new pending event list:
            m_cnPendingAllocEvents += GROWEVENTS;
        }
        
        // Add the item to the event list and increment the pending events
        // counter:
        m_pPendingEventList [m_cnPendingEvents++] = pEvent;
    }
    
    catch (...)
    {
        TRACE (_T("OTC: Exception handler invoked adding an event to the log\n"));
    }
}

// **************************************************************************
// AddEvent ()
//
// Description:
//	Places an event in list control
//
// Parameters:
//  CKEvent		*pEvent		Pointer to event object
//
// Returns:
//  bool - true if success.
// **************************************************************************
bool CEventView::AddEvent (CKEvent *pEvent)
{
    // Create a list view item structure:
    LV_ITEM lvi;
    
    // Get reference to list view's list control:
    CListCtrl &cList = GetListCtrl ();
    
    // Fill the list view item structure:
    
    // Item props we will fill (text, parameter, image):
    lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
    
    // No sub items:
    lvi.iSubItem = 0;
    
    // Defer to OnGetDispInfo () to get image:
    lvi.iImage = I_IMAGECALLBACK;
    
    // Defer to OnGetDispInfo () to get text:
    lvi.pszText = LPSTR_TEXTCALLBACK;
    
    // Set item number:
    lvi.iItem = cList.GetItemCount ();
    
    // We will use the list view item parameter to contain a pointer to
    // the associated CKEvent object.  The CKEvent object contains
    // contains information about the event.
    lvi.lParam = (LPARAM)pEvent;
    
    ASSERT (pEvent != NULL);
    
    // Insert the new item into list control:
    int nIndex = cList.InsertItem (&lvi);
    
    // If auto scroll flag is set, and new item's index is good, then force
    // list control to scroll if necessary to show new item:
    if (m_bAutoScroll && nIndex != -1)
        cList.EnsureVisible (nIndex, false);
    
    // If new item's index is -1 there was a problem, so return false
    // to indicate this.  Else return true to indicate success:
    return (nIndex != -1);
}


void CEventView::OnTimer(UINT nIDEvent) 
{
    // Process according to timer event type:
    switch (nIDEvent)
    {
        // This is the view maitenance timer event type we defined:
    case UPDATE_EVENTPANE_EVENT:
        {
            // Create a CSafeLock to make this object thread safe.  Our critical
            // section gets locked here, and will automatically be unlocked when the
            // CSafeLock goes out of scope.
            CSafeLock sf (&m_csLog);
            
            // Get reference to list view's list control:
            CListCtrl &cList = GetListCtrl ();
            
            // Create a scratch pointer to event object:
            CKEvent *pEvent = NULL;
            int nIndex = 0;
            
            // If we have pending event we will be adding to view, postpone
            // redrawing until we are done.  This will make things go faster
            // and look smoother.
            if (m_cnPendingEvents)
                cList.SetRedraw (false);
            
            // Process all event in pending events list:
            while (nIndex < m_cnPendingEvents)
            {
                // Get next event in pending events list:
                pEvent = m_pPendingEventList [nIndex];
                ASSERT (pEvent != NULL);
                
                // Invalidate pending event:
                m_pPendingEventList [nIndex++] = NULL;
                
                // If we have reached the self-imposed limit of displayable
                // events then remove the first one in list control to make
                // room:
                if (m_cnEvents == MAXEVENTS)
                {
                    // Delete first item in list (FIFO):
                    cList.DeleteItem (0);
                    
                    // Delete the associated event object:
                    delete m_pEventList [0];
                    
                    // Scroll events up one notch:
                    memcpy (m_pEventList, &m_pEventList[1], (m_cnEvents - 1) * sizeof (m_pEventList[0]));
                    
                    // Decrement the number of events:
                    --m_cnEvents;
                }
                
                // Check for room in the events list.  If we are out of
                // room, allocate larger block of memory and transfer
                // existing events to it.
                else if (m_cnEvents == m_cnAllocEvents)
                {
                    // Create a pointer to new events array:
                    CKEvent **p;
                    
                    // Allocate memory for the new array/list large enough
                    // for existing events plus room for new ones. (This is
                    // an array of pointers to CKEvent objects.)
                    p = new CKEvent * [m_cnAllocEvents + GROWEVENTS];
                    
                    // Transfer existing events to the new memory and free
                    // memory used by old list:
                    if (m_cnEvents)
                    {
                        memcpy (p, m_pEventList, m_cnEvents * sizeof (m_pEventList[0]));
                        delete [] m_pEventList;
                    }
                    
                    // Reset pointer to event list to give new memory area:
                    m_pEventList = p;
                    
                    // Increment size of memory allocated for new event list:
                    m_cnAllocEvents += GROWEVENTS;
                }
                
                // Add the item to the event list and increment index for next
                // item in pending events list:
                m_pEventList[m_cnEvents++] = pEvent;
                
                // Add the item to the list control:
                AddEvent (pEvent);
            }
            
            // We should have processed all items in pending event list.
            // If there were pending items, we need to reset pending
            // event counter to zero, restore the list control redraw flag,
            // and invalidate the list control to force a redraw.
            if (m_cnPendingEvents)
            {
                m_cnPendingEvents = 0;
                cList.SetRedraw (true);
                cList.Invalidate ();
            }
        }
        break;
        
        // Perform default processing for all other timer event types:
    default:
        CListView::OnTimer (nIDEvent);
        break;
        }
}

void CEventView::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
    // Switch views on TAB:
    if (nChar == VK_TAB)
    {
        // Post a change view message to main window:
        //AfxGetMainWnd ()->PostMessage (UM_CHANGEVIEW, 0, (LPARAM)this);
        
        // Return now so default processing does not occur:
        return;
    }
    
    // Show context menu on SPACEBAR:
    else if (nChar == VK_SPACE)
    {
        // Initialize item index to -1, to indicate no item selected:
        int nItem = -1;
        
        // Get reference to list control:
        CListCtrl &cList = GetListCtrl ();
        
        // Get the first selected item:
        nItem = cList.GetNextItem (-1, LVNI_ALL | LVNI_SELECTED);
        
        // Get a sensible rectangular region to place the context menu in:
        CRect rc;
        
        // If there is a selected item, use its rectangle:
        if (nItem >= 0)
        {
            // Force the list control to scroll if necessary to show 
            // selected item:
            cList.EnsureVisible (nItem, false);
            
            // Get the item's rectangle:
            cList.GetItemRect (nItem, &rc, LVIR_LABEL);
        }
        
        // Otherwise use the window's rectangle:
        else
        {
            // Get the window's rectangle:
            GetWindowRect (&rc);
            
            // Must convert dimensions returned by GetWindowRect():
            ScreenToClient (&rc);
        }
        
        // Compute coordinates of the rectangle's center:
        rc.left = (rc.left + rc.right) / 2;
        rc.top = (rc.top + rc.bottom) / 2;
        
        // Display our context menu at rectangle's center.  No point in
        // reinventing the wheel, use the code already developed for right
        // mouse down events to do this:
        OnRButtonDown (0, CPoint (rc.left, rc.top));
        
        // Return now so default processing does not occur:
        return;
    }
    
    // Perform default processing for all other characters:
    CListView::OnChar (nChar, nRepCnt, nFlags);
}

void CEventView::OnViewClear() 
{
	// TODO: Add your command handler code here
	// Create a CSafeLock to make this object thread safe.  Our critical
    // section gets locked here, and will automatically be unlocked when the
    // CSafeLock goes out of scope.
    CSafeLock sf (&m_csLog);
    
    // Postpone any redrawing until we are done.  This will make things 
    // go faster and look smoother.
    SetRedraw (false);
    
    // Delete all items in list control:
    GetListCtrl ().DeleteAllItems ();
    
    // Delete any CKEvent objects associated with deleted list control items:
    for (int i = 0; i < m_cnEvents; i++)
    {
        delete m_pEventList [i];
        m_pEventList [i] = NULL;
    }
    
    // Reset event count to zero:
    m_cnEvents = 0;
    
    // Now allow view to redraw:
    SetRedraw (true);
}

void CEventView::OnViewErroronly() 
{
    // Create a CSafeLock to make this object thread safe.  Our critical
    // section gets locked here, and will automatically be unlocked when the
    // CSafeLock goes out of scope.
    CSafeLock sf (&m_csLog);
    
    // Toggle the log errors only flag:
    m_bLogErrorsOnly = m_bLogErrorsOnly ? false : true;	
}