void ChunkedUpdateDrawingArea::display()
{
ASSERT(!m_isWaitingForUpdate);
if (m_paintingIsSuspended)
return;
if (m_dirtyRect.isEmpty())
return;
// Layout if necessary.
m_webPage->layoutIfNeeded();
IntRect dirtyRect = m_dirtyRect;
m_dirtyRect = IntRect();
// Create a new UpdateChunk and paint into it.
UpdateChunk updateChunk(dirtyRect);
paintIntoUpdateChunk(&updateChunk);
WebProcess::shared().connection()->send(DrawingAreaProxyMessage::Update, m_webPage->pageID(), CoreIPC::In(updateChunk));
m_isWaitingForUpdate = true;
m_displayTimer.stop();
}
void ChunkedUpdateDrawingArea::setSize(const IntSize& viewSize)
{
ASSERT_ARG(viewSize, !viewSize.isEmpty());
// We don't want to wait for an update until we display.
m_isWaitingForUpdate = false;
m_webPage->setSize(viewSize);
// Layout if necessary.
m_webPage->layoutIfNeeded();
if (m_paintingIsSuspended) {
ASSERT(!m_displayTimer.isActive());
// Painting is suspended, just send back an empty update chunk.
WebProcess::shared().connection()->send(DrawingAreaProxyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(UpdateChunk()));
return;
}
// Create a new UpdateChunk and paint into it.
UpdateChunk updateChunk(IntRect(0, 0, viewSize.width(), viewSize.height()));
paintIntoUpdateChunk(&updateChunk);
m_displayTimer.stop();
WebProcess::shared().connection()->send(DrawingAreaProxyMessage::DidSetSize, m_webPage->pageID(), CoreIPC::In(updateChunk));
}
void TiledDrawingArea::updateTile(int tileID, const IntRect& dirtyRect, float scale)
{
m_webPage->layoutIfNeeded();
UpdateChunk updateChunk(dirtyRect);
paintIntoUpdateChunk(&updateChunk, scale);
unsigned pendingUpdateCount = m_pendingUpdates.size();
WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::TileUpdated, m_webPage->pageID(), CoreIPC::In(tileID, updateChunk, scale, pendingUpdateCount));
}
void Map::update(float playerX, float playerZ)
{
//int x = (int)((int)(playerX > 0.0f ? playerX : playerX - (float)CHUNK_WIDTH) / (float)CHUNK_WIDTH);
//int z = (int)((int)(playerZ > 0.0f ? playerZ : playerZ - (float)CHUNK_DEPTH) / (float)CHUNK_DEPTH);
int x = (int)((int)(playerX > 0.0f ? playerX + 0.5f : (playerX + 0.5f) - (float)CHUNK_WIDTH) / CHUNK_WIDTH);
int z = (int)((int)(playerZ > 0.0f ? playerZ + 0.5f : (playerZ + 0.5f) - (float)CHUNK_DEPTH) / CHUNK_DEPTH);
for (int xx = -1; xx <= 1; xx++)
{
for (int zz = -1; zz <= 1; zz++)
{
updateChunk(x + xx, z + zz);
}
}
}
void TiledDrawingArea::didReceiveMessage(CoreIPC::Connection*, CoreIPC::MessageID messageID, CoreIPC::ArgumentDecoder* arguments)
{
switch (messageID.get<DrawingAreaLegacyMessage::Kind>()) {
case DrawingAreaLegacyMessage::SetSize: {
IntSize size;
if (!arguments->decode(CoreIPC::Out(size)))
return;
setSize(size);
break;
}
case DrawingAreaLegacyMessage::SuspendPainting:
suspendPainting();
break;
case DrawingAreaLegacyMessage::ResumePainting:
resumePainting();
break;
case DrawingAreaLegacyMessage::CancelTileUpdate: {
int tileID;
if (!arguments->decode(CoreIPC::Out(tileID)))
return;
UpdateMap::iterator it = m_pendingUpdates.find(tileID);
if (it != m_pendingUpdates.end()) {
m_pendingUpdates.remove(it);
if (m_pendingUpdates.isEmpty()) {
WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::AllTileUpdatesProcessed, m_webPage->pageID(), CoreIPC::In());
m_tileUpdateTimer.stop();
}
}
break;
}
case DrawingAreaLegacyMessage::RequestTileUpdate: {
TileUpdate update;
if (!arguments->decode(CoreIPC::Out(update.tileID, update.dirtyRect, update.scale)))
return;
UpdateMap::iterator it = m_pendingUpdates.find(update.tileID);
if (it != m_pendingUpdates.end())
it->second.dirtyRect.unite(update.dirtyRect);
else {
m_pendingUpdates.add(update.tileID, update);
if (!m_tileUpdateTimer.isActive())
m_tileUpdateTimer.startOneShot(0);
}
break;
}
case DrawingAreaLegacyMessage::TakeSnapshot: {
IntSize targetSize;
IntRect contentsRect;
if (!arguments->decode(CoreIPC::Out(targetSize, contentsRect)))
return;
m_webPage->layoutIfNeeded();
contentsRect.intersect(IntRect(IntPoint::zero(), m_webPage->mainFrame()->coreFrame()->view()->contentsSize()));
float targetScale = float(targetSize.width()) / contentsRect.width();
UpdateChunk updateChunk(IntRect(IntPoint(contentsRect.x() * targetScale, contentsRect.y() * targetScale), targetSize));
paintIntoUpdateChunk(&updateChunk, targetScale);
WebProcess::shared().connection()->send(DrawingAreaProxyLegacyMessage::SnapshotTaken, m_webPage->pageID(), CoreIPC::In(updateChunk));
break;
}
default:
ASSERT_NOT_REACHED();
break;
}
}
void DrawEnv::activateState(State *pNewState,
StateOverride *pNewStateOverride)
{
if(pNewState != NULL)
{
StateChunk *pNewChunk = pNewState->getChunk(State::FullStateIndex);
if(_pActiveState != NULL)
{
StateChunk *pActiveChunk =
_pActiveState->getChunk(State::FullStateIndex);
if(pNewChunk != NULL && pActiveChunk != NULL)
{
FullStateChunk *pFullChunk =
dynamic_cast<FullStateChunk *>(pNewChunk);
OSG_ASSERT(pFullChunk != NULL);
pFullChunk->changeFrom( this,
pNewState,
pNewStateOverride,
_pActiveState,
_pActiveStateOverride);
++_uiNumStateChanges;
_pActiveState = pNewState;
_pActiveStateOverride = pNewStateOverride;
}
else if(pNewChunk != NULL && pActiveChunk == NULL)
{
FullStateChunk *pFullChunk =
dynamic_cast<FullStateChunk *>(pNewChunk);
OSG_ASSERT(pFullChunk != NULL);
if(_pActiveStateOverride != NULL)
{
deactivate(_pActiveState, _pActiveStateOverride);
}
else
{
deactivate(_pActiveState);
}
pFullChunk->activate(this, pNewState, pNewStateOverride);
++_uiNumStateChanges;
_pActiveState = pNewState;
_pActiveStateOverride = pNewStateOverride;
}
else if(pNewChunk == NULL && pActiveChunk != NULL)
{
FullStateChunk *pFullChunk =
dynamic_cast<FullStateChunk *>(pActiveChunk);
OSG_ASSERT(pFullChunk != NULL);
pFullChunk->deactivate(this,
_pActiveState, _pActiveStateOverride);
if(pNewStateOverride != NULL)
{
activate(pNewState, pNewStateOverride);
}
else
{
activate(pNewState);
}
_pActiveState = pNewState;
_pActiveStateOverride = pNewStateOverride;
}
else
{
if(pNewState != _pActiveState ||
pNewStateOverride != _pActiveStateOverride )
{
if(pNewStateOverride != NULL)
{
if(_pActiveStateOverride != NULL)
{
changeTo( pNewState, pNewStateOverride,
_pActiveState, _pActiveStateOverride);
}
else
{
changeTo( pNewState, pNewStateOverride,
_pActiveState );
}
}
else if(_pActiveStateOverride != NULL)
{
changeTo( pNewState,
_pActiveState,
_pActiveStateOverride);
}
else
{
changeTo(pNewState, _pActiveState);
}
_pActiveState = pNewState;
_pActiveStateOverride = pNewStateOverride;
}
else
{
if(_pActiveStateOverride != NULL)
{
updateChunk(_pActiveState,
_pActiveStateOverride);
}
else
{
updateChunk(_pActiveState);
}
}
}
}
else
{
if(pNewChunk != NULL)
{
FullStateChunk *pFullChunk =
dynamic_cast<FullStateChunk *>(pNewChunk);
OSG_ASSERT(pFullChunk != NULL);
pFullChunk->activate(this, pNewState, pNewStateOverride);
++_uiNumStateChanges;
}
else
{
if(pNewStateOverride != NULL)
{
activate(pNewState, pNewStateOverride);
}
else
{
activate(pNewState);
}
}
_pActiveState = pNewState;
_pActiveStateOverride = pNewStateOverride;
}
}
}
