
 // -*- C++ -*-

 namespace Kite {

 /*! \class        NegociateWindow
  *  \brief        Perform the routing, main RoutingEvent manager.
  *
  *                This object perform the routing. That is creates all the
  *                initial RoutingEvent, load them into the queue and then
  *                process the queue until it is empty, that is, the routing
  *                is finished.
  *
  *                This object is the owner of the RoutingEventQueue,
  *                RoutingEventHistory and RoutingEventLoop used all troughout
  *                RoutingEvent and SegmentFsm.
  */

 //! \enum         NegociateWindow::Stage
 //!               The state under which the router is operating.

 //! \var          NegociateWindow::Negociation
 //!               The normal mode, priority negociation with ripup.

 //! \var          NegociateWindow::Packing
 //!               Try to find a better placement for segment but just by
 //!               looking for other fully free spaces. No ripup is performed.


 //! \function     NegociateWindow::create ( KiteEngine* kite );
 //!               The publicly avalaible contructor. Route the whole are defined
 //!               by the Kite associated Cell abutment box.

 //! \function     void  NegociateWindow::destroy ();
 //!               The publicly avalaible destructor.

 //! \function     bool  NegociateWindow::isInterrupted () const;
 //! \sreturn      \true if the NegociateWindow has received an interrupt request.

 //! \function     KiteEngine* NegociateWindow::getKiteEngine () const;
 //! \sreturn      The associated KiteEngine.

 //! \function     Hurricane::Cell* NegociateWindow::getCell () const;
 //! \sreturn      The associated Cell.

 //! \function     const Katabatic::GCellVector& NegociateWindow::getGCells () const;
 //! \sreturn      A Copy of the vector of GCell from KatabaticEngine. The vector
 //!               is copied but not the GCell themselves (shallow copy).

 //! \function     RoutingEventQueue& NegociateWindow::getEventQueue ();
 //! \sreturn      The RoutingEventQueue.

 //! \function     RoutingEventHistory& NegociateWindow::getEventHistory ();
 //! \sreturn      The RoutingEventHistory.

 //! \function     RoutingEventLoop& NegociateWindow::getEventLoop ();
 //! \sreturn      The RoutingEventLoop.

 //! \function     Stage  NegociateWindow::getStage () const;
 //! \sreturn      The stage (NegicateWindow::Stage) into which the NegociateWindow is running.

 //! \function     void  NegociateWindow::setGCells ( const Katabatic::GCellVector& v );
 //!               Sets the GCell vector from KatabaticEngine (perform a shallow copy).

 //! \function     void  NegociateWindow::setInterrupt ( bool state );
 //!               Sets or unset the interruption flag.

 //! \function     void  NegociateWindow::setStage ( Stage stage );
 //!               Set the stage (NegociateWindow::Stage) under which we are running.

 //! \function     double  NegociateWindow::computeWirelength ();
 //!               Compute the total wirelength of the circuit. It is not completly
 //!               accurate because overlaps are not took into accounts.

 //! \function     TrackElement* NegociateWindow::createTrackSegment ( AutoSegment*, unsigned int flags );
 //!               Build a TrackSegment from the Katabatic::AutoSegment. If \c flags contains
 //!               Kite::KtLoadingStage then assume that we are in the initial loading stage
 //!               (constructor).

 //! \function     void  NegociateWindow::addRoutingEvent ( TrackElement*, unsigned int level );
 //!               Create a new RoutingEvent from TrackElement (if it doesn't already exists)
 //!               and insert it into the queue with priority \c level.

 //! \function     void  NegociateWindow::rescheduleEvent ( RoutingEvent*, unsigned int level );
 //!               Reschedule an event into the queue, with priority \c level.

 //! \function     void  NegociateWindow::run ( int slowMotion=0 ); 
 //!               Perform the routing.
 //!
 //!               \red{\c slowMotion is not implemented yet.}

 //! \function     void  NegociateWindow::printStatistics () const
 //!               Display some statistics about the routing, compute the internal
 //!               complete statistics.

 }
