//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
//
// 
// GEANT4 Visualization Manager - John Allison 02/Jan/1996.

inline void G4VisManager::Initialize () {
  Initialise ();
}

inline G4bool G4VisManager::IsEnabled () const{
  return GetConcreteInstance();
}

inline const std::vector<G4VisManager::UserVisAction>&
G4VisManager::GetRunDurationUserVisActions () const {
  return fRunDurationUserVisActions;
}

inline const std::vector<G4VisManager::UserVisAction>&
G4VisManager::GetEndOfEventUserVisActions () const {
  return fEndOfEventUserVisActions;
}

inline const std::vector<G4VisManager::UserVisAction>&
G4VisManager::GetEndOfRunUserVisActions () const {
  return fEndOfRunUserVisActions;
}

inline const std::map<G4VUserVisAction*,G4VisExtent>&
G4VisManager::GetUserVisActionExtents () const {
  return fUserVisActionExtents;
}

inline G4VSceneHandler* G4VisManager::GetCurrentSceneHandler () const {
  return fpSceneHandler;
}

inline G4VViewer* G4VisManager::GetCurrentViewer () const {
  return fpViewer;
}

inline G4Scene* G4VisManager::GetCurrentScene () const {
  return fpScene;
}

inline const G4SceneHandlerList&
G4VisManager::GetAvailableSceneHandlers () const {
  return fAvailableSceneHandlers;
}

inline const G4SceneList& G4VisManager::GetSceneList () const {
  return fSceneList;
}

inline G4VGraphicsSystem*
G4VisManager::GetCurrentGraphicsSystem () const {
  return fpGraphicsSystem;
}

inline G4bool G4VisManager::GetTransientsDrawnThisEvent() const {
  return fTransientsDrawnThisEvent;
}

inline G4bool G4VisManager::GetTransientsDrawnThisRun() const {
  return fTransientsDrawnThisRun;
}

inline G4bool G4VisManager::GetDrawEventOnlyIfToBeKept() const {
  return fDrawEventOnlyIfToBeKept;
}

inline const G4Event* G4VisManager::GetRequestedEvent() const {
  return fpRequestedEvent;
}

inline G4int G4VisManager::GetNKeepRequests () const {
  return fNKeepRequests;
}

inline G4bool G4VisManager::GetReviewingKeptEvents() const {
  return fReviewingKeptEvents;
}

inline G4bool G4VisManager::GetAbortReviewKeptEvents() const {
  return fAbortReviewKeptEvents;
}

inline G4bool G4VisManager::GetReviewingPlots() const {
  return fReviewingPlots;
}

inline G4bool G4VisManager::GetAbortReviewPlots() const {
  return fAbortReviewPlots;
}

inline const G4ViewParameters& G4VisManager::GetDefaultViewParameters() const {
  return fDefaultViewParameters;
}

#ifdef G4MULTITHREADED

inline G4int G4VisManager::GetMaxEventQueueSize() const {
  return fMaxEventQueueSize;
}

inline G4bool G4VisManager::GetWaitOnEventQueueFull () const {
  return fWaitOnEventQueueFull;
}

#endif

inline const G4String& G4VisManager::GetDefaultGraphicsSystemName () const {
  return fDefaultGraphicsSystemName;
}

inline const G4String& G4VisManager::GetDefaultXGeometryString () const {
  return fDefaultXGeometryString;
}

inline const G4String& G4VisManager::GetDefaultGraphicsSystemBasis () const {
  return fDefaultGraphicsSystemBasis;
}

inline const G4String& G4VisManager::GetDefaultXGeometryStringBasis () const {
  return fDefaultXGeometryStringBasis;
}

inline G4SceneList& G4VisManager::SetSceneList () {
  return fSceneList;
}

inline G4SceneHandlerList& G4VisManager::SetAvailableSceneHandlers () {
  return fAvailableSceneHandlers;
}

inline void G4VisManager::SetVerboseLevel (G4VisManager::Verbosity verbosity) {
  fVerbosity = verbosity;
}

inline void G4VisManager::SetEventRefreshing (G4bool eventRefreshing) {
  fEventRefreshing = eventRefreshing;
}

inline void G4VisManager::RegisterMessenger(G4UImessenger* msgr)
{
  fMessengerList.push_back(msgr);
}

inline void G4VisManager::SetTransientsDrawnThisRun (G4bool b) {
  fTransientsDrawnThisRun = b;
}

inline void G4VisManager::SetTransientsDrawnThisEvent (G4bool b) {
  fTransientsDrawnThisEvent = b;
}

inline void G4VisManager::SetDrawEventOnlyIfToBeKept (G4bool b) {
  fDrawEventOnlyIfToBeKept = b;
}

inline void G4VisManager::SetRequestedEvent (const G4Event* event) {
  fpRequestedEvent = event;
}

inline void G4VisManager::SetReviewingKeptEvents (G4bool reveiwing) {
  fReviewingKeptEvents = reveiwing;
}

inline void G4VisManager::SetAbortReviewKeptEvents (G4bool abort) {
  fAbortReviewKeptEvents = abort;
}

inline void G4VisManager::SetReviewingPlots (G4bool reveiwing) {
  fReviewingPlots = reveiwing;
}

inline void G4VisManager::SetAbortReviewPlots (G4bool abort) {
  fAbortReviewPlots = abort;
}

inline void G4VisManager::SetDefaultViewParameters
(const G4ViewParameters& vp) {
  fDefaultViewParameters = vp;
}

#ifdef G4MULTITHREADED

inline void G4VisManager::SetMaxEventQueueSize (G4int size) {
  fMaxEventQueueSize = size;
}

inline void G4VisManager::SetWaitOnEventQueueFull (G4bool wait) {
  fWaitOnEventQueueFull = wait;
}

#endif

inline void G4VisManager::SetDefaultGraphicsSystemName (const G4String& name) {
  fDefaultGraphicsSystemName = name;
}

inline void G4VisManager::SetDefaultXGeometryString (const G4String& string) {
  fDefaultXGeometryString = string;
}

inline void G4VisManager::SetDefaultGraphicsSystemBasis (const G4String& basis) {
  fDefaultGraphicsSystemBasis = basis;
}

inline void G4VisManager::SetDefaultXGeometryStringBasis (const G4String& basis) {
  fDefaultXGeometryStringBasis = basis;
}