/usr/include/InsightToolkit/Common/itkEventObject.h is in libinsighttoolkit3-dev 3.20.1-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 | /*=========================================================================
Program: Insight Segmentation & Registration Toolkit
Module: itkEventObject.h
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef __itkEventObject_h
#define __itkEventObject_h
#include "itkIndent.h"
namespace itk
{
/** \class EventObject
* \brief Abstraction of the Events used to communicating among filters
and with GUIs.
*
* EventObject provides a standard coding for sending and receiving messages
* indicating things like the initiation of processes, end of processes,
* modification of filters.
*
* EventObjects form a hierarchy similar to the itk::ExceptionObject allowing
* to factorize common events in a tree-like structure. Higher detail can
* be assigned by users by subclassing existing itk::EventObjects.
*
* EventObjects are used by itk::Command and itk::Object for implementing the
* Observer/Subject design pattern. Observers register their interest in
* particular kinds of events produced by a specific itk::Object. This
* mechanism decouples classes among them.
*
* As opposed to itk::Exception, itk::EventObject does not represent error
* states, but simply flow of information allowing to trigger actions
* as a consequence of changes occurring in state on some itk::Objects.
*
* itk::EventObject carries information in its own type, it relies on the
* appropiate use of the RTTI (Run Time Type Information).
*
* A set of standard EventObjects is defined near the end of itkEventObject.h.
*
* \sa itk::Command
* \sa itk::ExceptionObject
*
* \ingroup ITKSystemObjects
*/
class ITKCommon_EXPORT EventObject
{
public:
/** Constructor and copy constructor. Note that these functions will be
* called when children are instantiated. */
EventObject() {}
EventObject(const EventObject&){};
/** Virtual destructor needed */
virtual ~EventObject() {}
/** Create an Event of this type This method work as a Factory for
* creating events of each particular type. */
virtual EventObject* MakeObject() const=0;
/** Print Event information. This method can be overridden by
* specific Event subtypes. The default is to print out the type of
* the event. */
virtual void Print(std::ostream& os) const;
/** Return the StringName associated with the event. */
virtual const char * GetEventName(void) const=0;
/** Check if given event matches or derives from this event. */
virtual bool CheckEvent(const EventObject*) const=0;
protected:
/** Methods invoked by Print() to print information about the object
* including superclasses. Typically not called by the user (use Print()
* instead) but used in the hierarchical print process to combine the
* output of several classes. */
virtual void PrintSelf(std::ostream& os, Indent indent) const;
virtual void PrintHeader(std::ostream& os, Indent indent) const;
virtual void PrintTrailer(std::ostream& os, Indent indent) const;
private:
typedef EventObject * EventFactoryFunction();
void operator=(const EventObject&);
};
/** Generic inserter operator for EventObject and its subclasses. */
inline std::ostream& operator<<(std::ostream& os, EventObject &e)
{
(&e)->Print(os);
return os;
}
/**
* Macro for creating new Events
*/
#define itkEventMacro( classname , super ) \
/** \class classname */ \
class classname : public super { \
public: \
typedef classname Self; \
typedef super Superclass; \
classname() {} \
virtual ~classname() {} \
virtual const char * GetEventName() const { return #classname; } \
virtual bool CheckEvent(const ::itk::EventObject* e) const \
{ return dynamic_cast<const Self*>(e); } \
virtual ::itk::EventObject* MakeObject() const \
{ return new Self; } \
classname(const Self&s) :super(s){}; \
private: \
void operator=(const Self&); \
};
/**
* Define some common ITK events
*/
itkEventMacro( NoEvent , EventObject )
itkEventMacro( AnyEvent , EventObject )
itkEventMacro( DeleteEvent , AnyEvent )
itkEventMacro( StartEvent , AnyEvent )
itkEventMacro( EndEvent , AnyEvent )
itkEventMacro( ProgressEvent , AnyEvent )
itkEventMacro( ExitEvent , AnyEvent )
itkEventMacro( AbortEvent , AnyEvent )
itkEventMacro( ModifiedEvent , AnyEvent )
itkEventMacro( InitializeEvent , AnyEvent )
itkEventMacro( IterationEvent , AnyEvent )
itkEventMacro( PickEvent , AnyEvent )
itkEventMacro( StartPickEvent , PickEvent )
itkEventMacro( EndPickEvent , PickEvent )
itkEventMacro( AbortCheckEvent , PickEvent )
itkEventMacro( FunctionEvaluationIterationEvent, IterationEvent )
itkEventMacro( GradientEvaluationIterationEvent, IterationEvent )
itkEventMacro( FunctionAndGradientEvaluationIterationEvent, IterationEvent )
itkEventMacro( UserEvent , AnyEvent )
} // end namespace itk
#endif
|