#import "BasicVTKView.h"

#import "vtkRenderer.h"
#import "vtkRenderWindow.h"
#import "vtkRenderWindowInteractor.h"
#import "vtkCocoaRenderWindowInteractor.h"
#import "vtkCocoaRenderWindow.h"

@implementation BasicVTKView

// designated initializer
- (id)initWithFrame:(NSRect)frame
{
  self = [super initWithFrame:frame];
  if (self)
    {
    // nothing to do... add something if you need to
    }

  return self;
}

- (void)dealloc
{
  [self cleanUpVTKSupport];
  [super dealloc];
}

// We are going to over ride the super class here to do some last minute
// setups. We need to do this because if we initialize in the constructor or
// even later, in say an NSDocument's windowControllerDidLoadNib, then
// we will get a warning about "Invalid Drawable" because the OpenGL Context
// is trying to be set and rendered into an NSView that most likely is not
// on screen yet. This is a way to defer that initialization until the NSWindow
// that contains our NSView subclass is actually on screen and ready to be drawn.
- (void)drawRect:(NSRect)theRect
{
  // Check for a valid vtkWindowInteractor and then initialize it. Technically we
  // do not need to do this, but what happens is that the window that contains
  // this object will not immediately render it so you end up with a big empty
  // space in your gui where this NSView subclass should be. This may or may
  // not be what is wanted. If you allow this code then what you end up with is the
  // typical empty black OpenGL view which seems more 'correct' or at least is
  // more soothing to the eye.
  vtkRenderWindowInteractor* theRenWinInt = [self getInteractor];
  if (theRenWinInt && (theRenWinInt->GetInitialized() == NO))
    {
    theRenWinInt->Initialize();
    }

  // Let the vtkCocoaGLView do its regular drawing
  [super drawRect:theRect];
}

- (void)initializeVTKSupport
{
  // The usual vtk object creation
  vtkRenderer* ren = vtkRenderer::New();
  vtkRenderWindow* renWin = vtkRenderWindow::New();
  vtkRenderWindowInteractor* renWinInt = vtkRenderWindowInteractor::New();

  // The cast should never fail, but we do it anyway, as
  // it's more correct to do so.
  vtkCocoaRenderWindow* cocoaRenWin = vtkCocoaRenderWindow::SafeDownCast(renWin);

  if (ren && cocoaRenWin && renWinInt)
    {
    // This is special to our usage of vtk.  To prevent vtk
    // from creating an NSWindow and NSView automatically (its
    // default behaviour) we tell vtk that they exist already.
    // The APIs names are a bit misleading, due to the cross
    // platform nature of vtk, but this usage is correct.
    cocoaRenWin->SetRootWindow([self window]);
    cocoaRenWin->SetWindowId(self);

    // The usual vtk connections
    cocoaRenWin->AddRenderer(ren);
    renWinInt->SetRenderWindow(cocoaRenWin);

    // This is special to our usage of vtk.  vtkCocoaGLView
    // keeps track of the renderWindow, and has a get
    // accessor if you ever need it.
    [self setVTKRenderWindow:cocoaRenWin];

    // Likewise, BasicVTKView keeps track of the renderer
    [self setRenderer:ren];
    }
}

- (void)cleanUpVTKSupport
{
  vtkRenderer* ren = [self getRenderer];
  vtkRenderWindow* renWin = [self getVTKRenderWindow];
  vtkRenderWindowInteractor* renWinInt = [self getInteractor];

  if (ren)
    {
    ren->Delete();
    }
  if (renWin)
    {
    renWin->Delete();
    }
  if (renWinInt)
    {
    renWinInt->Delete();
    }
  [self setRenderer:NULL];
  [self setVTKRenderWindow:NULL];

  // There is no setter accessor for the render window
  // interactor, that's ok.
}

- (vtkRenderer*)getRenderer
{
  return renderer;
}

- (void)setRenderer:(vtkRenderer*)theRenderer
{
  renderer = theRenderer;
}

@end
