void RenderBoxWrap::frameEntered(float _time)
{
if (mNodeForSync && mSceneManagerForSync) {
if (mSyncTime > SYNC_TIMEOUT) {
if (!checkSceneNode(mSceneManagerForSync->getRootSceneNode(), mNodeForSync)) {
MYGUI_LOG(Error, "scene node " << mNodeForSync << " was deleted");
mNodeForSync = nullptr;
mSceneManagerForSync = nullptr;
return;
}
bool update = false;
if(mNode->getChild(0)->getPosition() != Ogre::Vector3::ZERO)
{
update = true;
}
//System::Console::WriteLine("_frameEntered");
synchronizeSceneNode((Ogre::SceneNode*)mNode->getChild(0), mNodeForSync);
mNode->getChild(0)->setPosition(Ogre::Vector3::ZERO);
mNode->getChild(0)->setOrientation(Ogre::Quaternion::IDENTITY);
if(update)
{
updateViewport();
}
mSyncTime = 0.0f;
}
mSyncTime += _time;
}
if (mAutoRotation && !mLeftPressed) {
// коррекци¤ под левосторонюю систему координат с осью Z направленную вверх
#ifdef LEFT_HANDED_CS_UP_Z
mNode->roll(Ogre::Radian(Ogre::Degree(_time * mRotationSpeed)));
#else
mNode->yaw(Ogre::Radian(Ogre::Degree(_time * mRotationSpeed)));
#endif
}
if (nullptr != mEntityState) {
mEntityState->addTime(_time);
}
if (mCurrentScale != mScale) {
if (mCurrentScale > mScale) {
mCurrentScale -= _time * 0.7f;
if (mCurrentScale < mScale) mCurrentScale = mScale;
}
else {
mCurrentScale += _time * 0.7f;
if (mCurrentScale > mScale) mCurrentScale = mScale;
}
updateViewport();
}
}
/**
* @brief This method has been reimplemented. It manages the following actions:
* - Column resizing
* - Header button
*
* @param[in] event Mouse event
*
* @return Nothing.
*/
void AbstractTableView::mouseReleaseEvent(QMouseEvent* event)
{
if((event->buttons() & Qt::LeftButton) == 0)
{
if(mGuiState == AbstractTableView::ResizeColumnState)
{
mGuiState = AbstractTableView::NoState;
}
else if(mGuiState == AbstractTableView::HeaderButtonPressed)
{
if(mColumnList[mHeader.activeButtonIndex].header.isMouseOver == true)
{
//qDebug() << "Button " << mHeader.activeButtonIndex << "has been released.";
emit headerButtonReleased(mHeader.activeButtonIndex);
}
mGuiState = AbstractTableView::NoState;
}
else
{
QWidget::mouseReleaseEvent(event);
}
// Release all buttons
for(int i = 0; i < getColumnCount(); i++)
{
mColumnList[i].header.isPressed = false;
}
updateViewport();
}
}
void CC3Layer::onContentSizeChanged()
{
updateViewport();
if ( !getContentSize().equals( CCDirector::sharedDirector()->getWinSize() ) )
setShouldTrackViewSize( false );
}
void Window::setSize(int width, int height) {
//Set the size of the window
SDL_SetWindowSize(w, width, height);
this->width = width;
this->height = height;
updateViewport();
}
//----------------------------------------------------------------------------
// clear
//----------------------------------------------------------------------------
void ReportPieChart::clear()
{
hideDisplayLabel();
mModel->setRowCount( 0 );
mDataList.clear();
updateViewport();
} // ReportPieChart::clear
void Viewer::mouseReleaseEvent(QMouseEvent* event) {
if (vpDrag && mode == Mode::VIEWPORT) {
vpDragEnd[0] = event->x();
vpDragEnd[1] = event->y();
updateViewport(vpDragStart, vpDragEnd);
}
}
void GLWidget::paintGL()
{
updateAnimation();
updateViewport();
drawCatmullRomSpline();
drawControlPoints();
drawSelectedPoint();
}
void SDLFrontend::onWindowResize ()
{
int w, h;
SDL_GetWindowSize(_window, &w, &h);
_width = w;
_height = h;
updateViewport(0, 0, getWidth(), getHeight());
}
void Viewer::resetView() {
boxModel.reset();
boxGnomon.reset();
viewPoint.reset();
near = DEFAULT_NEAR;
far = DEFAULT_FAR;
fov = DEFAULT_FOV;
updateViewport(DEFAULT_VP1, DEFAULT_VP2);
}
ImageUI::ImageUI( ImageProcessor* ip, QWidget* parent, Qt::WFlags f )
: QWidget( parent, f ), image_processor( ip ), enabled( true )
{
// When image changed in image processor update view
connect( image_processor, SIGNAL(changed()),
this, SLOT(updateViewport()) );
setAttribute( Qt::WA_OpaquePaintEvent );
}
void Graphic::Renderer::init(Settings const& settings) {
// Register to the Event manager
Event::Manager::getInstance().registerProvider(this);
// Let platform-specific code create OpenGL context
createContext(settings);
// Init and configure OpenGL context
# if !defined OS_IOS
GLenum error = glewInit();
if (error != GLEW_OK) {
throw new Graphic::Exception(std::string("Glew init failed: ")
+ reinterpret_cast<const char*>(glewGetErrorString(error)));
}
# endif
// Enable depth test
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
// Enable blending and antialiasing
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
# if defined GL_POLYGON_SMOOTH
if (_antialiasingLevel > 0)
glEnable(GL_POLYGON_SMOOTH);
# endif
// Background color
glClearColor(0.f, 0.f, 0.f, 1.f);
// Update the OpenGL viewport (platform-specific)
updateViewport();
// Create and fill OpenGL Buffers
_vertexesBuffer = new Bufferf(Bufferf::VertexArray);
_textureCoordsBuffer = new Bufferf(Bufferf::VertexArray);
_indexesBuffer = new Bufferui(Bufferui::ElementArray);
_fillVertexesBuffer();
// Fill the texture coords buffer, used to draw sceneries
_fillTextureCoordsBuffer(2, 1);
_fillIndexesBuffer();
// Create the shader
_shaderProgram = new ShaderProgram(vertexShader, fragmentShader);
_shaderProgram->use();
// Retrieve shader variables locations
_shaderProgram->registerAttributeLocation("position");
_vertexPositionLocation = _shaderProgram->getAttributeLocation("position");
_vertexTextureCoordsLocation = _shaderProgram->getAttributeLocation("textureCoords");
_worldMatrixLocation = _shaderProgram->getUniformLocation("worldMatrix");
_transformationMatrixLocation = _shaderProgram->getUniformLocation("transformationMatrix");
_textureSamplerLocation = _shaderProgram->getUniformLocation("textureSampler");
_opacityLocation = _shaderProgram->getUniformLocation("opacity");
}
/** Draw the 3D scene with the specified drawing visitor. */
void CC3Layer::drawSceneWithVisitor( CC3NodeDrawingVisitor* visitor )
{
// Ensure the visitor uses the surface manager of this layer
visitor->setSurfaceManager( getSurfaceManager() );
if (m_shouldAlwaysUpdateViewport)
updateViewport();
getCC3Scene()->drawSceneWithVisitor( visitor );
}
// добавл¤ет ?сцен?объект, старый удал¤етьс¤
void RenderBoxScene::injectObject(const Ogre::String& _meshName, const Ogre::Vector3 & _position, const Ogre::Quaternion & _orientation, const Ogre::Vector3 & _scale)
{
clearScene();
static size_t num = 0;
mEntity = mScene->createEntity(MyGUI::utility::toString(this, "_RenderBoxMesh_", _meshName, num++), _meshName);
Ogre::SceneNode * node = mNode->createChildSceneNode(_position, _orientation);
node->attachObject(mEntity);
updateViewport();
}
void RenderBoxScene::injectObject( Ogre::Entity* pEnt, const Ogre::Vector3 & _position /*= Ogre::Vector3::ZERO*/, const Ogre::Quaternion & _orientation /*= Ogre::Quaternion::IDENTITY*/, const Ogre::Vector3 & _scale /*= Ogre::Vector3::UNIT_SCALE*/ )
{
clearScene();
static size_t num = 0;
mEntity = pEnt->clone(pEnt->getName() + "_render_obj_of_gui");
Ogre::SceneNode * node = mNode->createChildSceneNode(_position, _orientation);
node->attachObject(mEntity);
updateViewport();
}
//----------------------------------------------------------------------------//
void OgreRenderTarget::activate()
{
if (!d_matrixValid)
updateMatrix();
if (!d_viewportValid)
updateViewport();
d_renderSystem._setViewport(d_viewport);
d_renderSystem._setProjectionMatrix(d_matrix);
d_renderSystem._setViewMatrix(Ogre::Matrix4::IDENTITY);
}
// добавл¤ет в сцену объект, старый удал¤етьс¤
void RenderBoxWrap::injectObject(const Ogre::String& _meshName, const Ogre::Vector3 & _position, const Ogre::Quaternion & _orientation, const Ogre::Vector3 & _scale)
{
static size_t num = 0;
Ogre::Entity * entity = mScene->createEntity(MyGUI::utility::toString(this, "_RenderBoxMesh_", _meshName, num++), _meshName);
Ogre::SceneNode * node = mNode->createChildSceneNode(_position, _orientation);
node->attachObject(entity);
mVectorEntity.push_back(entity);
if (mEntity == nullptr) mEntity = entity;
updateViewport();
}
void CC3Layer::setSurfaceManager( CC3SceneDrawingSurfaceManager* surfaceManager )
{
/*CC3Assert([surfaceManager isKindOfClass: self.surfaceManagerClass],
@"The surface manager must be a type of %@", self.surfaceManagerClass);*/
if (surfaceManager == m_pSurfaceManager)
return;
CC_SAFE_RELEASE( m_pSurfaceManager );
CC_SAFE_RETAIN( surfaceManager );
m_pSurfaceManager = surfaceManager;
updateViewport();
}
StandardPLPanel::StandardPLPanel( PlaylistWidget *_parent,
intf_thread_t *_p_intf,
playlist_item_t *p_root,
PLSelector *_p_selector,
VLCModel *_p_model )
: QWidget( _parent ),
model( _p_model ),
p_intf( _p_intf ),
p_selector( _p_selector )
{
viewStack = new QStackedLayout( this );
viewStack->setSpacing( 0 ); viewStack->setMargin( 0 );
setMinimumWidth( 300 );
iconView = NULL;
treeView = NULL;
listView = NULL;
picFlowView = NULL;
currentRootIndexPLId = -1;
lastActivatedPLItemId = -1;
QList<QString> frames;
frames << ":/util/wait1";
frames << ":/util/wait2";
frames << ":/util/wait3";
frames << ":/util/wait4";
spinnerAnimation = new PixmapAnimator( this, frames );
CONNECT( spinnerAnimation, pixmapReady( const QPixmap & ), this, updateViewport() );
/* Saved Settings */
int i_savedViewMode = getSettings()->value( "Playlist/view-mode", TREE_VIEW ).toInt();
QFont font = QApplication::font();
font.setPointSize( font.pointSize() + getSettings()->value( "Playlist/zoom", 0 ).toInt() );
model->setData( QModelIndex(), font, Qt::FontRole );
showView( i_savedViewMode );
DCONNECT( THEMIM, leafBecameParent( int ),
this, browseInto( int ) );
CONNECT( model, currentIndexChanged( const QModelIndex& ),
this, handleExpansion( const QModelIndex& ) );
CONNECT( model, rootIndexChanged(), this, browseInto() );
setRootItem( p_root, false );
}
void Window::handleEvent(SDL_Event evnt)
{
switch (evnt.window.event) {
case SDL_WINDOWEVENT_SIZE_CHANGED:
m_Width = evnt.window.data1;
m_Height = evnt.window.data2;
updateViewport();
break;
case SDL_WINDOWEVENT_CLOSE:
open = false;
break;
default:
break;
}
}
//----------------------------------------------------------------------------//
void OgreTextureTarget::clear()
{
if (!d_viewportValid)
updateViewport();
Ogre::Viewport* const saved_vp = d_renderSystem._getViewport();
d_renderSystem._setViewport(d_viewport);
d_renderSystem.clearFrameBuffer(Ogre::FBT_COLOUR,
Ogre::ColourValue(0, 0, 0, 0));
#if OGRE_VERSION < 0x10800
if (saved_vp)
d_renderSystem._setViewport(saved_vp);
#else
d_renderSystem._setViewport(saved_vp);
#endif
}
/**
* @brief This method has been reimplemented. It manages the following actions:
* - Column resizing
* - Header button
*
* @param[in] event Mouse event
*
* @return Nothing.
*/
void AbstractTableView::mousePressEvent(QMouseEvent* event)
{
if(((event->buttons() & Qt::LeftButton) != 0) && ((event->buttons() & Qt::RightButton) == 0))
{
if(mColResizeData.splitHandle == true)
{
int wColIndex = getColumnIndexFromX(event->x());
int wStartPos = getColumnPosition(wColIndex); // Position X of the start of column
mGuiState = AbstractTableView::ResizeColumnState;
if(event->x() <= (wStartPos + 2))
{
mColResizeData.index = wColIndex - 1;
}
else
{
mColResizeData.index = wColIndex;
}
mColResizeData.lastPosX = event->x();
}
else if(mHeader.isVisible && getColumnCount() && (event->y() <= getHeaderHeight()) && (event->y() >= 0))
{
int wColIndex = getColumnIndexFromX(event->x());
//qDebug() << "Button " << wColIndex << "has been pressed.";
emit headerButtonPressed(wColIndex);
mColumnList[wColIndex].header.isPressed = true;
mColumnList[wColIndex].header.isMouseOver = true;
mHeader.activeButtonIndex = wColIndex;
mGuiState = AbstractTableView::HeaderButtonPressed;
updateViewport();
}
}
//QWidget::mousePressEvent(event);
}
void RenderBoxWrap::injectSceneNode(Ogre::SceneManager * _manager, Ogre::SceneNode* _sceneNode)
{
// очищаем
clearScene();
mSceneManagerForSync = _manager;
// проверка сцен нода на валидность
if (!checkSceneNode(_manager->getRootSceneNode(), _sceneNode)) {
MYGUI_LOG(Error, "scene node " << _sceneNode << " was deleted");
return;
}
Ogre::SceneNode * node = mNode->createChildSceneNode();
synchronizeSceneNode(node, _sceneNode);
mNodeForSync = _sceneNode;
updateViewport();
}
//----------------------------------------------------------------------------
// Update Chart
//----------------------------------------------------------------------------
void ReportPieChart::updateChart()
{
mModel->setRowCount( mDataList.size() );
if( mDataList.size() > 0 )
{
// Sort data items
switch( mSortType )
{
case SORT_BY_BALANCE_DESCENDING:
qSort( mDataList.begin(), mDataList.end(), pieDataSortByBalanceDescending );
break;
case SORT_BY_NAME_ASCENDING:
qSort( mDataList.begin(), mDataList.end(), pieDataSortByNameAscending );
break;
}
const int colorRange = COLOR_RANGE;
int step = qMin( MAX_COLOR_STEP, (colorRange / mDataList.size()) );
QColor baseColor = BASE_COLOR.toHsv();
int h = baseColor.hue();
int s = baseColor.saturation();
int v = baseColor.value();
for (int i = 0; i < mDataList.size(); ++i)
{
QColor secondaryLabelColor = ( mDataList[i].mValue > 0 ) ? QColor(Qt::darkGreen) : QColor(Qt::red);
QColor nextColor;
int newH = (h + step*i)%colorRange;
nextColor.setHsv( newH, s, v );
QString valueStr = Transaction::getAmountText( mDataList[i].mValue );
mModel->setData( mModel->index(i,(int)PieView::COLUMN_LABEL), mDataList[i].mName );
mModel->setData( mModel->index(i,(int)PieView::COLUMN_LABEL), nextColor, Qt::DecorationRole );
mModel->setData( mModel->index(i,(int)PieView::COLUMN_VALUE), qAbs(mDataList[i].mValue) );
mModel->setData( mModel->index(i,(int)PieView::COLUMN_SEC_LABEL), valueStr );
mModel->setData( mModel->index(i,(int)PieView::COLUMN_SEC_LABEL), secondaryLabelColor, Qt::DecorationRole );
}
}
updateViewport();
} // ReportPieChart::updateChart
void LayerTreeHostProxy::pushUpdateToQueue(PassOwnPtr<LayerTreeMessageToRenderer> message)
{
m_messagesToRenderer.append(message);
updateViewport();
}
void LayerTreeHostProxy::didFireViewportUpdateTimer(Timer<LayerTreeHostProxy>*)
{
updateViewport();
}
/** Invoked automatically either from onEnter, or if new scene attached and layer is running. */
void CC3Layer::openCC3Scene()
{
updateViewport(); // Set the camera viewport
getCC3Scene()->open(); // Open the scene
}
void CC3Layer::setPosition( const CCPoint& newPosition )
{
super::setPosition( newPosition );
updateViewport();
}
void CC3Layer::setScaleY( float newScaleY )
{
super::setScaleY( newScaleY );
updateViewport();
}
void CC3Layer::setScaleX( float newScaleX )
{
super::setScaleX( newScaleX );
updateViewport();
}
void CC3Layer::setScale( float s )
{
super::setScale( s );
updateViewport();
}
