/* -*- c++ -*-
 *
 */

// VTK Common
#include "vtkCommand.h"
#include "vtkProp.h"
#include "vtkSmartPointer.h"
// VTK Imaging
#include "vtkImageCanvasSource2D.h"
// VTK Graphics
#include "vtkPlaneSource.h"
// VTK Rendering
#include "vtkPropPicker.h"
#include "vtkImageMapper.h"
#include "vtkPolyDataMapper2D.h"
#include "vtkActor2D.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"


class vtkPickerObserver : public vtkCommand
{
public:
  static vtkPickerObserver* New() { return new vtkPickerObserver(); }

  void SetPicker(vtkAbstractPropPicker* a) { m_picker = a; }

  void Execute(vtkObject* caller, unsigned long event, void*)
    {
      vtkRenderWindowInteractor* interactor =
        vtkRenderWindowInteractor::SafeDownCast(caller);

      int pos[2];

      interactor->GetEventPosition(pos);

      vtkRenderer* renderer = interactor->FindPokedRenderer(pos[0], pos[1]);
      vtkProp* prop = NULL;

      if ( m_picker->Pick(pos[0], pos[1], 0, renderer) &&
           (prop = m_picker->GetViewProp()) != NULL )
        {
        double* s = m_picker->GetSelectionPoint();

        cerr << m_picker->GetClassName() << " (" << m_picker
             << ") picked " << prop->GetClassName() << " (" << prop
             << ") at ( " << s[0] << ", " << s[1] << ", " << s[2] << " )"
             << endl;
        }
    }

protected:
  vtkPickerObserver() {}
  ~vtkPickerObserver() {}

private:
  vtkSmartPointer<vtkAbstractPropPicker> m_picker;
};


int
main (int argc, char* argv[])
{
  if (argc < 2)
    {
    cerr << "Usage: " << argv[0] << " <position>\n"
         << "\n"
         << "positions:\n"
         << "\t\t3   2\n"
         << "\t\t  4  \n"
         << "\t\t0   1\n"
         << endl;
    return 1;
    }

  int propPosition = atoi(argv[1]);

  if (propPosition < 0 || propPosition > 4)
    {
    cerr << "Error: Invalid position index: " << propPosition << endl;
    return 1;
    }

  int w1 = 256;
  int h1 = 256;
  int w2 = 64;
  int h2 = 64;

  vtkRenderWindow* renderWindow = vtkRenderWindow::New();
  renderWindow->SetSize(w1, h1);

  vtkRenderer* renderer0 = vtkRenderer::New();
  renderWindow->AddRenderer(renderer0);
  renderer0->Delete();

  vtkRenderWindowInteractor* interactor = vtkRenderWindowInteractor::New();
  interactor->SetRenderWindow(renderWindow);
  renderWindow->Delete();

  vtkPickerObserver* observer1 = vtkPickerObserver::New();
  vtkPropPicker* picker1 = vtkPropPicker::New();
  observer1->SetPicker(picker1);
  picker1->Delete();

  (void) interactor->AddObserver(vtkCommand::LeftButtonPressEvent, observer1);
  observer1->Delete();

#if 1
  vtkImageCanvasSource2D* imageSource = vtkImageCanvasSource2D::New();
  imageSource->SetScalarTypeToUnsignedChar();
  imageSource->SetExtent(0,w2-1, 0,h2-1, 0,0);
  imageSource->SetDrawColor(128);
  imageSource->FillBox(0,w2-1, 0,h2-1);

  vtkImageMapper* mapper2D = vtkImageMapper::New();
  mapper2D->SetInput(imageSource->GetOutput());
  mapper2D->SetColorWindow(255);
  mapper2D->SetColorLevel(128);
  imageSource->Delete();
#else
  vtkPlaneSource* planeSource = vtkPlaneSource::New();
  planeSource->SetOrigin(0, 0, 0);
  planeSource->SetPoint1(0, h2, 0);
  planeSource->SetPoint2(w2, 0,  0);

  vtkPolyDataMapper2D* mapper2D = vtkPolyDataMapper2D::New();
  mapper2D->SetInput(planeSource->GetOutput());
  planeSource->Delete();
#endif

  vtkActor2D* actor2D = vtkActor2D::New();
  actor2D->SetMapper(mapper2D);
  mapper2D->Delete();

  renderer0->AddViewProp(actor2D);
  actor2D->Delete();

  cerr << "Position index: " << propPosition << endl;

  float px1 = 0;
  float py1 = 0;

  switch (propPosition)
    {
    case 0:
      break;
    case 1:
      px1 = w1-w2-1;
      break;
    case 2:
      px1 = w1-w2-1;
      py1 = h1-h2-1;
      break;
    case 3:
      py1 = h1-h2-1;
      break;
    case 4:
      px1 = w1/2.f-w2/2.f-1;
      py1 = h1/2.f-h2/2.f-1;
      break;
    }

  actor2D->SetPosition(px1, py1);

  interactor->Initialize();
  interactor->Start(); 

  interactor->Delete();

  return 0;
}