Logo Search packages:      
Sourcecode: blender version File versions

GHOST_EventManager.cpp

/**
 * $Id: GHOST_EventManager.cpp,v 1.4 2003/01/01 20:42:27 maarten Exp $
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */

/**

 * $Id: GHOST_EventManager.cpp,v 1.4 2003/01/01 20:42:27 maarten Exp $
 * Copyright (C) 2001 NaN Technologies B.V.
 * @author  Maarten Gribnau
 * @date    May 14, 2001
 */

#include "GHOST_EventManager.h"
#include <algorithm>
#include "GHOST_Debug.h"

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif


00049 GHOST_EventManager::GHOST_EventManager()
{
}


00054 GHOST_EventManager::~GHOST_EventManager()
{
      disposeEvents();
}


00060 GHOST_TUns32 GHOST_EventManager::getNumEvents()
{
      return (GHOST_TUns32) m_events.size();
}


00066 GHOST_TUns32 GHOST_EventManager::getNumEvents(GHOST_TEventType type)
{
      GHOST_TUns32 numEvents = 0;
      TEventStack::iterator p;
      for (p = m_events.begin(); p != m_events.end(); p++) {
            if ((*p)->getType() == type) {
                  numEvents++;
            }
      }
      return numEvents;
}


00079 GHOST_IEvent* GHOST_EventManager::peekEvent()
{
      GHOST_IEvent* event = 0;
      if (m_events.size() > 0) {
            event = m_events.back();
      }
      return event;
}


00089 GHOST_TSuccess GHOST_EventManager::pushEvent(GHOST_IEvent* event)
{
      GHOST_TSuccess success;
      GHOST_ASSERT(event, "invalid event");
      if (m_events.size() < m_events.max_size()) {
            m_events.push_front(event);
            success = GHOST_kSuccess;
      }
      else {
            success = GHOST_kFailure;
      }
      return success;
}


00104 bool GHOST_EventManager::dispatchEvent(GHOST_IEvent* event)
{
      bool handled;
      if (event) {
            handled = true;
            TConsumerVector::iterator iter;
            for (iter = m_consumers.begin(); iter != m_consumers.end(); iter++) {
                  if ((*iter)->processEvent(event)) {
                        handled = false;
                  }
            }
      }
      else {
            handled = false;
      }
      return handled;
}


00123 bool GHOST_EventManager::dispatchEvent()
{
      GHOST_IEvent* event = popEvent(); 
      bool handled = false;
      if (event) {
            handled = dispatchEvent(event);
            delete event;
      }
      return handled;
}


00135 bool GHOST_EventManager::dispatchEvents()
{
      bool handled;
      if (getNumEvents()) {
            handled = true;
            while (getNumEvents()) {
                  if (!dispatchEvent()) {
                        handled = false;
                  }
            }
      }
      else {
            handled = false;
      }
      return handled;
}


00153 GHOST_TSuccess GHOST_EventManager::addConsumer(GHOST_IEventConsumer* consumer)
{
      GHOST_TSuccess success;
      GHOST_ASSERT(consumer, "invalid consumer");
      
      // Check to see whether the consumer is already in our list
      TConsumerVector::const_iterator iter = std::find(m_consumers.begin(), m_consumers.end(), consumer);

      if (iter == m_consumers.end()) {
            // Add the consumer
            m_consumers.push_back(consumer);
            success = GHOST_kSuccess;
      }
      else {
            success = GHOST_kFailure;
      }
      return success;
}


00173 GHOST_TSuccess GHOST_EventManager::removeConsumer(GHOST_IEventConsumer* consumer)
{
      GHOST_TSuccess success;
      GHOST_ASSERT(consumer, "invalid consumer");

      // Check to see whether the consumer is in our list
      TConsumerVector::iterator iter = std::find(m_consumers.begin(), m_consumers.end(), consumer);

      if (iter != m_consumers.end()) {
            // Remove the consumer
            m_consumers.erase(iter);
            success = GHOST_kSuccess;
      }
      else {
            success = GHOST_kFailure;
      }
      return success;
}


00193 void GHOST_EventManager::removeWindowEvents(GHOST_IWindow* window)
{
      TEventStack::iterator iter;
      iter = m_events.begin();
      while (iter != m_events.end())
      {
            GHOST_IEvent* event = *iter;
            if (event->getWindow() == window)
            {
            GHOST_PRINT("GHOST_EventManager::removeWindowEvents(): removing event\n");
                  /*
                   * Found an event for this window, remove it.
                   * The iterator will become invalid.
                   */
                  delete event;
                  m_events.erase(iter);
                  iter = m_events.begin();
            }
            else
            {
                  iter++;
            }
      }
}

00218 void GHOST_EventManager::removeTypeEvents(GHOST_TEventType type, GHOST_IWindow* window)
{
      TEventStack::iterator iter;
      iter = m_events.begin();
      while (iter != m_events.end())
      {
            GHOST_IEvent* event = *iter;
            if ((event->getType() == type) && (!window || (event->getWindow() == window)))
            {
            GHOST_PRINT("GHOST_EventManager::removeTypeEvents(): removing event\n");
                  /*
                   * Found an event of this type for the window, remove it.
                   * The iterator will become invalid.
                   */
                  delete event;
                  m_events.erase(iter);
                  iter = m_events.begin();
            }
            else
            {
                  iter++;
            }
      }
}


00244 GHOST_IEvent* GHOST_EventManager::popEvent()
{
      GHOST_IEvent* event = peekEvent();
      if (event) {
            m_events.pop_back();
      }
      return event;
}


00254 void GHOST_EventManager::disposeEvents()
{
      while (m_events.size() > 0) {
            GHOST_ASSERT(m_events[0], "invalid event");
            delete m_events[0];
            m_events.pop_front();
      }
}

Generated by  Doxygen 1.6.0   Back to index