# UserEvent

VTKExamples/Cxx/Interaction/UserEvent

### Code

UserEvent.cxx

    #include <vtkSphereSource.h>
    #include <vtkCallbackCommand.h>
    #include <vtkCommand.h>
    #include <vtkPolyData.h>
    #include <vtkSmartPointer.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkActor.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderer.h>
    #include <vtkRenderWindowInteractor.h>

    #include "vtkTestFilter.h"

    static void CallbackFunction(vtkObject* caller,
                    long unsigned int eventId,
                    void* clientData,
                    void* callData );

    int main(int, char *[])
    {
      // Create a renderer, render window, and interactor
      vtkSmartPointer<vtkRenderer> renderer =
        vtkSmartPointer<vtkRenderer>::New();
      vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();
      renderWindow->AddRenderer(renderer);
      vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
        vtkSmartPointer<vtkRenderWindowInteractor>::New();
      renderWindowInteractor->SetRenderWindow(renderWindow);

      vtkSmartPointer<vtkTestFilter> filter =
        vtkSmartPointer<vtkTestFilter>::New();

      vtkSmartPointer<vtkCallbackCommand> callback =
        vtkSmartPointer<vtkCallbackCommand>::New();
      callback->SetCallback(CallbackFunction );
      filter->AddObserver(filter->RefreshEvent, callback);

      filter->Update();

      renderWindow->Render();
      renderWindowInteractor->Start();

      return EXIT_SUCCESS;
    }

    void CallbackFunction(vtkObject* /* caller */,
                    long unsigned int /* eventId */,
                    void* /* clientData */, void* /* callData */)
    {
      std::cout << "CallbackFunction called." << std::endl;
    }

vtkTestFilter.h

    #ifndef __vtkTestFilter_h
    #define __vtkTestFilter_h

    #include <vtkPolyDataAlgorithm.h>

    class vtkTestFilter : public vtkPolyDataAlgorithm
    {
    public:
      vtkTypeMacro(vtkTestFilter,vtkPolyDataAlgorithm);
      static vtkTestFilter *New();

      int RefreshEvent;

    protected:
      vtkTestFilter();

      int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *);

    private:
      vtkTestFilter(const vtkTestFilter&);  // Not implemented.
      void operator=(const vtkTestFilter&);  // Not implemented.

    };

    #endif

    #include <vtkObjectFactory.h>
    #include <vtkCommand.h>
    #include <vtkStreamingDemandDrivenPipeline.h>
    #include <vtkInformationVector.h>
    #include <vtkInformation.h>
    #include <vtkDataObject.h>
    #include <vtkSmartPointer.h>
    #include <vtkAppendPolyData.h>
    #include <vtkSphereSource.h>

    vtkStandardNewMacro(vtkTestFilter);

    vtkTestFilter::vtkTestFilter()
    {
      this->SetNumberOfInputPorts(0);

      this->RefreshEvent = vtkCommand::UserEvent + 1;

    }

    int vtkTestFilter::RequestData(vtkInformation *vtkNotUsed(request),
     vtkInformationVector **,
     vtkInformationVector *)
    {
      // Get the info object
    //  vtkInformation *outInfo = outputVector->GetInformationObject(0);

    //  vtkPolyData *output = vtkPolyData::SafeDownCast(
    //      outInfo->Get(vtkDataObject::DATA_OBJECT()));
      this->InvokeEvent(this->RefreshEvent, nullptr);

      return 1;
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

    project(UserEvent)

    find_package(VTK COMPONENTS
      vtkCommonCore
      vtkCommonDataModel
      vtkFiltersSources
      vtkInteractionStyle
      vtkRenderingCore
      vtkRenderingFreeType
      vtkRenderingOpenGL2 QUIET)
    if (NOT VTK_FOUND)
      message("Skipping UserEvent: ${VTK_NOT_FOUND_MESSAGE}")
      return ()
    endif()
    message (STATUS "VTK_VERSION: ${VTK_VERSION}")
    if (VTK_VERSION VERSION_LESS "8.90.0")
      # old system
      include(${VTK_USE_FILE})
      add_executable(UserEvent MACOSX_BUNDLE UserEvent.cxx )
      target_link_libraries(UserEvent PRIVATE ${VTK_LIBRARIES})
    else ()
      # include all components
      add_executable(UserEvent MACOSX_BUNDLE UserEvent.cxx )
      target_link_libraries(UserEvent PRIVATE ${VTK_LIBRARIES})
      # vtk_module_autoinit is needed
      vtk_module_autoinit(
        TARGETS UserEvent
        MODULES ${VTK_LIBRARIES}
        )
    endif ()

### Download and Build UserEvent

Click here to download UserEvent and its CMakeLists.txt file. Once the tarball UserEvent.tar has been downloaded and extracted,

    cd UserEvent/build

If VTK is installed:

    cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

    cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

    make

and run it:

    ./UserEvent

WINDOWS USERS

Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.