/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkDefaultPainter.cxx

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/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 notice for more information.

=========================================================================*/
#include "vtkDefaultPainter.h"

#include "vtkActor.h"
#include "vtkClipPlanesPainter.h"
#include "vtkCoincidentTopologyResolutionPainter.h"
#include "vtkCompositePainter.h"
#include "vtkDisplayListPainter.h"
#include "vtkGarbageCollector.h"
#include "vtkLightingPainter.h"
#include "vtkObjectFactory.h"
#include "vtkPolyData.h"
#include "vtkProperty.h"
#include "vtkRepresentationPainter.h"
#include "vtkScalarsToColorsPainter.h"

vtkStandardNewMacro(vtkDefaultPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, DefaultPainterDelegate, vtkPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, ScalarsToColorsPainter,
  vtkScalarsToColorsPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, ClipPlanesPainter,
  vtkClipPlanesPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, DisplayListPainter,
  vtkDisplayListPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, CompositePainter, vtkCompositePainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, CoincidentTopologyResolutionPainter,
  vtkCoincidentTopologyResolutionPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, LightingPainter, vtkLightingPainter);
vtkCxxSetObjectMacro(vtkDefaultPainter, RepresentationPainter, vtkRepresentationPainter);
//-----------------------------------------------------------------------------
vtkDefaultPainter::vtkDefaultPainter()
{
  this->ScalarsToColorsPainter = 0;
  this->ClipPlanesPainter = 0;
  this->DisplayListPainter = 0;
  this->CompositePainter = 0;
  this->CoincidentTopologyResolutionPainter = 0;
  this->LightingPainter = 0;
  this->RepresentationPainter = 0;
  this->DefaultPainterDelegate = 0;

  vtkScalarsToColorsPainter* scp = vtkScalarsToColorsPainter::New();
  this->SetScalarsToColorsPainter(scp);
  scp->Delete();

  vtkClipPlanesPainter* cp = vtkClipPlanesPainter::New();
  this->SetClipPlanesPainter(cp);
  cp->Delete();

  vtkDisplayListPainter* dlp = vtkDisplayListPainter::New();
  this->SetDisplayListPainter(dlp);
  dlp->Delete();

  vtkCompositePainter* cpp = vtkCompositePainter::New();
  this->SetCompositePainter(cpp);
  cpp->Delete();

  vtkCoincidentTopologyResolutionPainter* ctrp =
    vtkCoincidentTopologyResolutionPainter::New();
  this->SetCoincidentTopologyResolutionPainter(ctrp);
  ctrp->Delete();

  vtkLightingPainter* lp = vtkLightingPainter::New();
  this->SetLightingPainter(lp);
  lp->Delete();

  vtkRepresentationPainter* vp = vtkRepresentationPainter::New();
  this->SetRepresentationPainter(vp);
  vp->Delete();
}

//-----------------------------------------------------------------------------
vtkDefaultPainter::~vtkDefaultPainter()
{
  this->SetScalarsToColorsPainter(0);
  this->SetClipPlanesPainter(0);
  this->SetDisplayListPainter(0);
  this->SetCompositePainter(0);
  this->SetCoincidentTopologyResolutionPainter(0);
  this->SetLightingPainter(0);
  this->SetRepresentationPainter(0);
  this->SetDefaultPainterDelegate(0);
}

//-----------------------------------------------------------------------------
void vtkDefaultPainter::BuildPainterChain()
{
  vtkPainter* headPainter = 0;
  vtkPainter* prevPainter = 0;
  vtkPainter* painter = 0;

  painter = this->GetScalarsToColorsPainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  painter = this->GetClipPlanesPainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  painter = this->GetDisplayListPainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  // We are always putting in the composite painter since it does not have any
  // significant overhead for non-composite datasets.
  painter = this->GetCompositePainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  painter = this->GetLightingPainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  painter = this->GetRepresentationPainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  painter = this->GetCoincidentTopologyResolutionPainter();
  if (painter)
  {
    if (prevPainter)
    {
      prevPainter->SetDelegatePainter(painter);
    }
    prevPainter = painter;
    headPainter = (headPainter)? headPainter : painter;
  }

  // this will set in internal delegate painter.
  this->Superclass::SetDelegatePainter(headPainter);
  if (prevPainter)
  {
    prevPainter->SetDelegatePainter(this->DefaultPainterDelegate);
  }
}
//-----------------------------------------------------------------------------
void vtkDefaultPainter::Render(vtkRenderer* renderer, vtkActor* actor,
                               unsigned long typeflags, bool forceCompileOnly)
{
  if (this->ChainBuildTime < this->MTime)
  {
    this->BuildPainterChain();
    this->ChainBuildTime.Modified();
  }
  this->Superclass::Render(renderer, actor, typeflags,forceCompileOnly);
}

//-----------------------------------------------------------------------------
void vtkDefaultPainter::ReleaseGraphicsResources(vtkWindow *window)
{
  if (this->DefaultPainterDelegate)
  {
    this->DefaultPainterDelegate->ReleaseGraphicsResources(window);
  }
  if (this->ScalarsToColorsPainter)
  {
    this->ScalarsToColorsPainter->ReleaseGraphicsResources(window);
  }
  this->Superclass::ReleaseGraphicsResources(window);
}

//-----------------------------------------------------------------------------
void vtkDefaultPainter::SetDelegatePainter(vtkPainter* painter)
{
  this->SetDefaultPainterDelegate(painter);
}

//-----------------------------------------------------------------------------
void vtkDefaultPainter::ReportReferences(vtkGarbageCollector* collector)
{
  this->Superclass::ReportReferences(collector);
  vtkGarbageCollectorReport(collector, this->ScalarsToColorsPainter,
    "ScalarsToColors Painter");
  vtkGarbageCollectorReport(collector, this->DisplayListPainter,
    "DisplayListPainter");
  vtkGarbageCollectorReport(collector, this->ClipPlanesPainter,
    "ClipPlanes Painter");
  vtkGarbageCollectorReport(collector, this->CompositePainter,
    "Composite Painter");
  vtkGarbageCollectorReport(collector,
    this->CoincidentTopologyResolutionPainter,
    "CoincidentTopologyResolution Painter");
  vtkGarbageCollectorReport(collector, this->LightingPainter,
    "Lighting Painter");
  vtkGarbageCollectorReport(collector, this->RepresentationPainter,
    "Wireframe Painter");
  vtkGarbageCollectorReport(collector, this->DefaultPainterDelegate,
    "DefaultPainter Delegate");
}

//-------------------------------------------------------------------------
void vtkDefaultPainter::UpdateBounds(double bounds[6])
{
  // need the superclass to start with the first painter in the chain
  vtkPainter *painter = this->Superclass::GetDelegatePainter();

  if( painter )
  {
    // delegate the task of updating the bounds
    painter->UpdateBounds(bounds);
  }
  else
  {
    // no painter in the chain. let's build the chain if needed.
    if (this->ChainBuildTime < this->MTime)
    {
      // build the chain of painters
      this->BuildPainterChain();
      this->ChainBuildTime.Modified();
    }

    // try again to get the first painter in the chain
    painter = this->Superclass::GetDelegatePainter();

    if( painter )
    {
      //delegate the task of updating the bounds
      painter->UpdateBounds(bounds);
    }
  }
}

//-----------------------------------------------------------------------------
void vtkDefaultPainter::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);

  os << indent << "ScalarsToColorsPainter: " ;
  if (this->ScalarsToColorsPainter)
  {
    os << endl ;
    this->ScalarsToColorsPainter->PrintSelf(os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }

  os << indent << "ClipPlanesPainter: " ;
  if (this->ClipPlanesPainter)
  {
    os << endl ;
    this->ClipPlanesPainter->PrintSelf(os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }

   os << indent << "DisplayListPainter: " ;
  if (this->DisplayListPainter)
  {
    os << endl;
    this->DisplayListPainter->PrintSelf(
      os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }

  os << indent << "CompositePainter: ";
  if (this->CompositePainter)
  {
    os << endl;
    this->CompositePainter->PrintSelf(os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }

  os << indent << "CoincidentTopologyResolutionPainter: " ;
  if (this->CoincidentTopologyResolutionPainter)
  {
    os << endl;
    this->CoincidentTopologyResolutionPainter->PrintSelf(
      os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }

  os << indent << "LightingPainter: " ;
  if (this->LightingPainter)
  {
    os << endl ;
    this->LightingPainter->PrintSelf(os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }

  os << indent << "RepresentationPainter: " ;
  if (this->RepresentationPainter)
  {
    os << endl ;
    this->RepresentationPainter->PrintSelf(os, indent.GetNextIndent());
  }
  else
  {
    os << "(none)" << endl;
  }
}