mirror of
https://github.com/OpenFOAM/ThirdParty-6.git
synced 2025-12-08 06:57:43 +00:00
341 lines
11 KiB
C++
341 lines
11 KiB
C++
/*=========================================================================
|
|
|
|
Program: ParaView
|
|
Module: pqRenderViewBase.cxx
|
|
|
|
Copyright (c) 2005,2006 Sandia Corporation, Kitware Inc.
|
|
All rights reserved.
|
|
|
|
ParaView is a free software; you can redistribute it and/or modify it
|
|
under the terms of the ParaView license version 1.2.
|
|
|
|
See License_v1.2.txt for the full ParaView license.
|
|
A copy of this license can be obtained by contacting
|
|
Kitware Inc.
|
|
28 Corporate Drive
|
|
Clifton Park, NY 12065
|
|
USA
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
========================================================================*/
|
|
#include "pqRenderViewBase.h"
|
|
|
|
// Server Manager Includes.
|
|
#include "vtkErrorCode.h"
|
|
#include "vtkEventQtSlotConnect.h"
|
|
#include "vtkImageData.h"
|
|
#include "vtkProcessModule.h"
|
|
#include "vtkPVDataInformation.h"
|
|
#include "vtkPVXMLElement.h"
|
|
#include "vtkRenderWindow.h"
|
|
#include "vtkSMDoubleVectorProperty.h"
|
|
#include "vtkSMProperty.h"
|
|
#include "vtkSMPropertyHelper.h"
|
|
#include "vtkSMRenderViewProxy.h"
|
|
#include "vtkSMSessionProxyManager.h"
|
|
#include "vtkSMSourceProxy.h"
|
|
#include "vtkSMViewProxyInteractorHelper.h"
|
|
|
|
// Qt Includes.
|
|
#include <QList>
|
|
#include <QMainWindow>
|
|
#include <QMap>
|
|
#include <QMapIterator>
|
|
#include <QMenu>
|
|
#include <QMouseEvent>
|
|
#include <QPoint>
|
|
#include <QPointer>
|
|
#include <QStatusBar>
|
|
#include <QtDebug>
|
|
|
|
// ParaView Includes.
|
|
#include "pqApplicationCore.h"
|
|
#include "pqCoreUtilities.h"
|
|
#include "pqImageUtil.h"
|
|
#include "pqOutputPort.h"
|
|
#include "pqPipelineSource.h"
|
|
#include "pqQVTKWidget.h"
|
|
#include "pqServer.h"
|
|
#include "pqServerManagerModel.h"
|
|
#include "pqSettings.h"
|
|
#include "pqTimer.h"
|
|
#include "pqRenderView.h"
|
|
|
|
#include <string>
|
|
|
|
class pqRenderViewBase::pqInternal
|
|
{
|
|
public:
|
|
QPoint MouseOrigin;
|
|
bool IsInteractiveDelayActive;
|
|
double TimeLeftBeforeFullResolution;
|
|
|
|
pqInternal()
|
|
{
|
|
}
|
|
~pqInternal()
|
|
{
|
|
}
|
|
|
|
void writeToStatusBar(const char* txt)
|
|
{
|
|
QMainWindow *mainWindow = qobject_cast<QMainWindow *>(pqCoreUtilities::mainWidget());
|
|
if(mainWindow)
|
|
{
|
|
mainWindow->statusBar()->showMessage(txt);
|
|
}
|
|
}
|
|
|
|
void startInteractiveRenderDelay(double timeLeft)
|
|
{
|
|
this->IsInteractiveDelayActive = true;
|
|
this->TimeLeftBeforeFullResolution = timeLeft;
|
|
tick();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void interactiveRenderDelayTimeOut()
|
|
{
|
|
this->IsInteractiveDelayActive = false;
|
|
tick();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void tick()
|
|
{
|
|
if(this->IsInteractiveDelayActive)
|
|
{
|
|
QString txt = "Full resolution render in: ";
|
|
txt += QString::number(this->TimeLeftBeforeFullResolution);
|
|
txt += " s";
|
|
this->writeToStatusBar( txt.toLatin1().data() );
|
|
this->TimeLeftBeforeFullResolution -= 0.1;
|
|
}
|
|
else
|
|
{
|
|
this->writeToStatusBar("");
|
|
}
|
|
}
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
pqRenderViewBase::pqRenderViewBase(
|
|
const QString& type,
|
|
const QString& group,
|
|
const QString& name,
|
|
vtkSMViewProxy* renViewProxy,
|
|
pqServer* server,
|
|
QObject* _parent/*=NULL*/):
|
|
Superclass(type, group, name, renViewProxy, server, _parent)
|
|
{
|
|
this->Internal = new pqRenderViewBase::pqInternal();
|
|
this->InteractiveDelayUpdateTimer = new pqTimer(this);
|
|
this->AllowCaching = true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
pqRenderViewBase::~pqRenderViewBase()
|
|
{
|
|
delete this->Internal;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
QWidget* pqRenderViewBase::createWidget()
|
|
{
|
|
pqQVTKWidget* vtkwidget = new pqQVTKWidget();
|
|
vtkwidget->setViewProxy(this->getProxy());
|
|
|
|
// do image caching for performance
|
|
// For now, we are doing this only on Apple because it can render
|
|
// and capture a frame buffer even when it is obstructred by a
|
|
// window. This does not work as well on other platforms.
|
|
|
|
#if defined(__APPLE__)
|
|
if (this->AllowCaching)
|
|
{
|
|
// Don't override the caching flag here. It is set correctly by
|
|
// pqQVTKWidget. I don't know why this explicit marking cached dirty was
|
|
// done. But in case it's needed for streaming view, I am letting it be.
|
|
// vtkwidget->setAutomaticImageCacheEnabled(true);
|
|
|
|
// help the QVTKWidget know when to clear the cache
|
|
this->getConnector()->Connect(
|
|
this->getProxy(), vtkCommand::ModifiedEvent,
|
|
vtkwidget, SLOT(markCachedImageAsDirty()));
|
|
}
|
|
#endif
|
|
|
|
vtkwidget->setContextMenuPolicy(Qt::NoContextMenu);
|
|
vtkwidget->installEventFilter(this);
|
|
return vtkwidget;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::initialize()
|
|
{
|
|
this->Superclass::initialize();
|
|
|
|
// The render module needs to obtain client side objects
|
|
// for the RenderWindow etc. to initialize the QVTKWidget
|
|
// correctly. It cannot do this unless the underlying proxy
|
|
// has been created. Since any pqProxy should never call
|
|
// UpdateVTKObjects() on itself in the constructor, we
|
|
// do the following.
|
|
vtkSMProxy* proxy = this->getProxy();
|
|
if (!proxy->GetObjectsCreated())
|
|
{
|
|
// Wait till first UpdateVTKObjects() call on the render module.
|
|
// Under usual circumstances, after UpdateVTKObjects() the
|
|
// render module objects will be created.
|
|
this->getConnector()->Connect(proxy, vtkCommand::UpdateEvent,
|
|
this, SLOT(initializeAfterObjectsCreated()));
|
|
}
|
|
else
|
|
{
|
|
this->initializeAfterObjectsCreated();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::initializeAfterObjectsCreated()
|
|
{
|
|
// Attach Qt Signal to VTK interactor Delay event
|
|
vtkSMRenderViewProxy* renderViewProxy;
|
|
renderViewProxy = vtkSMRenderViewProxy::SafeDownCast(this->getProxy());
|
|
if( renderViewProxy != NULL )
|
|
{
|
|
vtkSMViewProxyInteractorHelper* helper = renderViewProxy->GetInteractorHelper();
|
|
Q_ASSERT(helper);
|
|
vtkEventQtSlotConnect* cntor = this->getConnector();
|
|
cntor->Connect(helper, vtkCommand::CreateTimerEvent, this, SLOT(beginDelayInteractiveRender()));
|
|
cntor->Connect(helper, vtkCommand::DestroyTimerEvent, this, SLOT(endDelayInteractiveRender()));
|
|
cntor->Connect(helper, vtkCommand::TimerEvent, this, SLOT(endDelayInteractiveRender()));
|
|
|
|
this->InteractiveDelayUpdateTimer->setSingleShot(false);
|
|
QObject::connect( this->InteractiveDelayUpdateTimer,
|
|
SIGNAL(timeout()),
|
|
this,
|
|
SLOT(updateStatusMessage()));
|
|
}
|
|
|
|
// when PV_NO_OFFSCREEN_SCREENSHOTS is set, by default, we disable offscreen
|
|
// screenshots.
|
|
vtkSMProxy* proxy = this->getProxy();
|
|
if (getenv("PV_NO_OFFSCREEN_SCREENSHOTS"))
|
|
{
|
|
vtkSMPropertyHelper(proxy, "UseOffscreenRenderingForScreenshots", /*quiet*/true).Set(0);
|
|
}
|
|
proxy->UpdateVTKObjects();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::resetDisplay()
|
|
{
|
|
this->resetCamera();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool pqRenderViewBase::eventFilter(QObject* caller, QEvent* e)
|
|
{
|
|
if (e->type() == QEvent::MouseButtonPress)
|
|
{
|
|
QMouseEvent* me = static_cast<QMouseEvent*>(e);
|
|
if (me->button() & Qt::RightButton)
|
|
{
|
|
this->Internal->MouseOrigin = me->pos();
|
|
}
|
|
}
|
|
else if (e->type() == QEvent::MouseMove &&
|
|
!this->Internal->MouseOrigin.isNull())
|
|
{
|
|
QPoint newPos = static_cast<QMouseEvent*>(e)->pos();
|
|
QPoint delta = newPos - this->Internal->MouseOrigin;
|
|
if(delta.manhattanLength() < 3)
|
|
{
|
|
this->Internal->MouseOrigin = QPoint();
|
|
}
|
|
}
|
|
else if (e->type() == QEvent::MouseButtonRelease)
|
|
{
|
|
QMouseEvent* me = static_cast<QMouseEvent*>(e);
|
|
if (me->button() & Qt::RightButton && !this->Internal->MouseOrigin.isNull())
|
|
{
|
|
QPoint newPos = static_cast<QMouseEvent*>(e)->pos();
|
|
QPoint delta = newPos - this->Internal->MouseOrigin;
|
|
if (delta.manhattanLength() < 3 && qobject_cast<QWidget*>(caller))
|
|
{
|
|
QList<QAction*> actions = this->widget()->actions();
|
|
if (!actions.isEmpty())
|
|
{
|
|
QMenu* menu = new QMenu(this->widget());
|
|
menu->setAttribute(Qt::WA_DeleteOnClose);
|
|
menu->addActions(actions);
|
|
menu->popup(qobject_cast<QWidget*>(caller)->mapToGlobal(newPos));
|
|
}
|
|
}
|
|
this->Internal->MouseOrigin = QPoint();
|
|
}
|
|
}
|
|
|
|
return Superclass::eventFilter(caller, e);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::setStereo(int mode)
|
|
{
|
|
QList<pqView*> views =
|
|
pqApplicationCore::instance()->getServerManagerModel()->findItems<pqView*>();
|
|
foreach (pqView* view, views)
|
|
{
|
|
vtkSMProxy* viewProxy = view->getProxy();
|
|
if (mode >= VTK_STEREO_CRYSTAL_EYES &&
|
|
mode <= VTK_STEREO_SPLITVIEWPORT_HORIZONTAL)
|
|
{
|
|
vtkSMPropertyHelper(viewProxy, "StereoType", /*quiet*/true).Set(mode);
|
|
vtkSMPropertyHelper(viewProxy, "StereoRender", /*quiet*/true).Set(1);
|
|
}
|
|
else
|
|
{
|
|
vtkSMPropertyHelper(viewProxy, "StereoRender", /*quiet*/true).Set(0);
|
|
}
|
|
viewProxy->UpdateVTKObjects();
|
|
if (mode != 0)
|
|
{
|
|
view->forceRender();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::beginDelayInteractiveRender()
|
|
{
|
|
vtkSMDoubleVectorProperty *prop =
|
|
vtkSMDoubleVectorProperty::SafeDownCast(
|
|
this->getProxy()->GetProperty("NonInteractiveRenderDelay"));
|
|
double value = prop ? static_cast<double>(prop->GetElement(0)) : 0;
|
|
this->Internal->startInteractiveRenderDelay(value);
|
|
this->InteractiveDelayUpdateTimer->start(100);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::endDelayInteractiveRender()
|
|
{
|
|
this->Internal->interactiveRenderDelayTimeOut();
|
|
this->InteractiveDelayUpdateTimer->stop();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
void pqRenderViewBase::updateStatusMessage()
|
|
{
|
|
this->Internal->tick();
|
|
}
|