void ClientLayerManager::BeginTransactionWithTarget(gfxContext* aTarget) { mInTransaction = true; mTransactionStart = TimeStamp::Now(); #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG(("[----- BeginTransaction")); Log(); #endif NS_ASSERTION(!InTransaction(), "Nested transactions not allowed"); mPhase = PHASE_CONSTRUCTION; NS_ABORT_IF_FALSE(mKeepAlive.IsEmpty(), "uncommitted txn?"); nsRefPtr<gfxContext> targetContext = aTarget; // If the last transaction was incomplete (a failed DoEmptyTransaction), // don't signal a new transaction to ShadowLayerForwarder. Carry on adding // to the previous transaction. dom::ScreenOrientation orientation; if (dom::TabChild* window = mWidget->GetOwningTabChild()) { orientation = window->GetOrientation(); } else { hal::ScreenConfiguration currentConfig; hal::GetCurrentScreenConfiguration(¤tConfig); orientation = currentConfig.orientation(); } nsIntRect targetBounds = mWidget->GetNaturalBounds(); targetBounds.x = targetBounds.y = 0; mForwarder->BeginTransaction(targetBounds, mTargetRotation, orientation); // If we're drawing on behalf of a context with async pan/zoom // enabled, then the entire buffer of painted layers might be // composited (including resampling) asynchronously before we get // a chance to repaint, so we have to ensure that it's all valid // and not rotated. if (mWidget) { if (dom::TabChild* window = mWidget->GetOwningTabChild()) { mCompositorMightResample = window->IsAsyncPanZoomEnabled(); } } // If we have a non-default target, we need to let our shadow manager draw // to it. This will happen at the end of the transaction. if (aTarget && XRE_GetProcessType() == GeckoProcessType_Default) { mShadowTarget = aTarget; } else { NS_ASSERTION(!aTarget, "Content-process ClientLayerManager::BeginTransactionWithTarget not supported"); } // If this is a new paint, increment the paint sequence number. if (!mIsRepeatTransaction && gfxPrefs::APZTestLoggingEnabled()) { ++mPaintSequenceNumber; mApzTestData.StartNewPaint(mPaintSequenceNumber); } }
void ClientLayerManager::BeginTransactionWithTarget(gfxContext* aTarget) { mInTransaction = true; #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG(("[----- BeginTransaction")); Log(); #endif NS_ASSERTION(!InTransaction(), "Nested transactions not allowed"); mPhase = PHASE_CONSTRUCTION; NS_ABORT_IF_FALSE(mKeepAlive.IsEmpty(), "uncommitted txn?"); nsRefPtr<gfxContext> targetContext = aTarget; // If the last transaction was incomplete (a failed DoEmptyTransaction), // don't signal a new transaction to ShadowLayerForwarder. Carry on adding // to the previous transaction. ScreenOrientation orientation; if (TabChild* window = mWidget->GetOwningTabChild()) { orientation = window->GetOrientation(); } else { hal::ScreenConfiguration currentConfig; hal::GetCurrentScreenConfiguration(¤tConfig); orientation = currentConfig.orientation(); } nsIntRect clientBounds; mWidget->GetClientBounds(clientBounds); clientBounds.x = clientBounds.y = 0; ShadowLayerForwarder::BeginTransaction(mTargetBounds, mTargetRotation, clientBounds, orientation); // If we're drawing on behalf of a context with async pan/zoom // enabled, then the entire buffer of thebes layers might be // composited (including resampling) asynchronously before we get // a chance to repaint, so we have to ensure that it's all valid // and not rotated. if (mWidget) { if (TabChild* window = mWidget->GetOwningTabChild()) { mCompositorMightResample = window->IsAsyncPanZoomEnabled(); } } // If we have a non-default target, we need to let our shadow manager draw // to it. This will happen at the end of the transaction. if (aTarget && XRE_GetProcessType() == GeckoProcessType_Default) { mShadowTarget = aTarget; } }
bool WheelBlockState::ShouldAcceptNewEvent() const { if (!InTransaction()) { // If we're not in a transaction, start a new one. return false; } RefPtr<AsyncPanZoomController> apzc = GetTargetApzc(); if (apzc->IsDestroyed()) { return false; } return true; }
wxXmlNode *Project::CreateVD(const wxString &vdFullPath, bool mkpath) { wxXmlNode *oldVd = GetVirtualDir(vdFullPath); if ( oldVd ) { // VD already exist return oldVd; } wxStringTokenizer tkz(vdFullPath, wxT(":")); wxXmlNode *parent = m_doc.GetRoot(); size_t count = tkz.CountTokens(); for (size_t i=0; i<count-1; i++) { wxString token = tkz.NextToken(); wxXmlNode *p = XmlUtils::FindNodeByName(parent, wxT("VirtualDirectory"), token); if ( !p ) { if ( mkpath ) { //add the node p = new wxXmlNode(parent, wxXML_ELEMENT_NODE, wxT("VirtualDirectory")); p->AddProperty(wxT("Name"), token); } else { return NULL; } } parent = p; } wxXmlNode *node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("VirtualDirectory")); node->AddProperty(wxT("Name"), tkz.GetNextToken()); parent->AddChild(node); //if not in transaction save the changes if (!InTransaction()) { SaveXmlFile(); } // cache the result m_vdCache[vdFullPath] = node; return node; }
void WheelBlockState::OnMouseMove(const ScreenIntPoint& aPoint) { MOZ_ASSERT(InTransaction()); if (!GetTargetApzc()->Contains(aPoint)) { EndTransaction(); return; } if (mLastMouseMove.IsNull()) { // If the cursor is moving inside the frame, and it is more than the // ignoremovedelay time since the last scroll operation, we record // this as the most recent mouse movement. TimeStamp now = TimeStamp::Now(); TimeDuration duration = now - mLastEventTime; if (duration.ToMilliseconds() >= gfxPrefs::MouseWheelIgnoreMoveDelayMs()) { mLastMouseMove = now; } } }
bool WheelBlockState::MaybeTimeout(const ScrollWheelInput& aEvent) { MOZ_ASSERT(InTransaction()); if (MaybeTimeout(aEvent.mTimeStamp)) { return true; } if (!mLastMouseMove.IsNull()) { // If there's a recent mouse movement, we can time out the transaction early. TimeDuration duration = TimeStamp::Now() - mLastMouseMove; if (duration.ToMilliseconds() >= gfxPrefs::MouseWheelIgnoreMoveDelayMs()) { TBS_LOG("%p wheel transaction timed out after mouse move\n", this); EndTransaction(); return true; } } return false; }
bool WheelBlockState::MaybeTimeout(const TimeStamp& aTimeStamp) { MOZ_ASSERT(InTransaction()); // End the transaction if the event occurred > 1.5s after the most recently // seen wheel event. TimeDuration duration = aTimeStamp - mLastEventTime; if (duration.ToMilliseconds() < gfxPrefs::MouseWheelTransactionTimeoutMs()) { return false; } TBS_LOG("%p wheel transaction timed out\n", this); if (gfxPrefs::MouseScrollTestingEnabled()) { RefPtr<AsyncPanZoomController> apzc = GetTargetApzc(); apzc->NotifyMozMouseScrollEvent(NS_LITERAL_STRING("MozMouseScrollTransactionTimeout")); } EndTransaction(); return true; }
void WheelBlockState::Update(ScrollWheelInput& aEvent) { // We might not be in a transaction if the block never started in a // transaction - for example, if nothing was scrollable. if (!InTransaction()) { return; } // The current "scroll series" is a like a sub-transaction. It has a separate // timeout of 80ms. Since we need to compute wheel deltas at different phases // of a transaction (for example, when it is updated, and later when the // event action is taken), we affix the scroll series counter to the event. // This makes GetScrollWheelDelta() consistent. if (!mLastEventTime.IsNull() && (aEvent.mTimeStamp - mLastEventTime).ToMilliseconds() > kScrollSeriesTimeoutMs) { mScrollSeriesCounter = 0; } aEvent.mScrollSeriesNumber = ++mScrollSeriesCounter; // If we can't scroll in the direction of the wheel event, we don't update // the last move time. This allows us to timeout a transaction even if the // mouse isn't moving. // // We skip this check if the target is not yet confirmed, so that when it is // confirmed, we don't timeout the transaction. RefPtr<AsyncPanZoomController> apzc = GetTargetApzc(); if (IsTargetConfirmed() && !apzc->CanScroll(aEvent)) { return; } // Update the time of the last known good event, and reset the mouse move // time to null. This will reset the delays on both the general transaction // timeout and the mouse-move-in-frame timeout. mLastEventTime = aEvent.mTimeStamp; mLastMouseMove = TimeStamp(); }
bool Project::FastAddFile(const wxString& fileName, const wxString& virtualDir) { wxXmlNode *vd = GetVirtualDir(virtualDir); if ( !vd ) { return false; } // Convert the file path to be relative to // the project path DirSaver ds; ::wxSetWorkingDirectory(m_fileName.GetPath()); wxFileName tmp(fileName); tmp.MakeRelativeTo(m_fileName.GetPath()); wxXmlNode *node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("File")); node->AddProperty(wxT("Name"), tmp.GetFullPath(wxPATH_UNIX)); vd->AddChild(node); if (!InTransaction()) { SaveXmlFile(); } SetModified(true); return true; }
void ClientLayerManager::BeginTransactionWithTarget(gfxContext* aTarget) { mInTransaction = true; mTransactionStart = TimeStamp::Now(); #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG(("[----- BeginTransaction")); Log(); #endif NS_ASSERTION(!InTransaction(), "Nested transactions not allowed"); mPhase = PHASE_CONSTRUCTION; MOZ_ASSERT(mKeepAlive.IsEmpty(), "uncommitted txn?"); RefPtr<gfxContext> targetContext = aTarget; // If the last transaction was incomplete (a failed DoEmptyTransaction), // don't signal a new transaction to ShadowLayerForwarder. Carry on adding // to the previous transaction. dom::ScreenOrientationInternal orientation; if (dom::TabChild* window = mWidget->GetOwningTabChild()) { orientation = window->GetOrientation(); } else { hal::ScreenConfiguration currentConfig; hal::GetCurrentScreenConfiguration(¤tConfig); orientation = currentConfig.orientation(); } LayoutDeviceIntRect targetBounds = mWidget->GetNaturalBounds(); targetBounds.x = targetBounds.y = 0; mForwarder->BeginTransaction(targetBounds.ToUnknownRect(), mTargetRotation, orientation); // If we're drawing on behalf of a context with async pan/zoom // enabled, then the entire buffer of painted layers might be // composited (including resampling) asynchronously before we get // a chance to repaint, so we have to ensure that it's all valid // and not rotated. // // Desktop does not support async zoom yet, so we ignore this for those // platforms. #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_GONK) || defined(MOZ_WIDGET_UIKIT) if (mWidget && mWidget->GetOwningTabChild()) { mCompositorMightResample = AsyncPanZoomEnabled(); } #endif // If we have a non-default target, we need to let our shadow manager draw // to it. This will happen at the end of the transaction. if (aTarget && XRE_IsParentProcess()) { mShadowTarget = aTarget; } else { NS_ASSERTION(!aTarget, "Content-process ClientLayerManager::BeginTransactionWithTarget not supported"); } // If this is a new paint, increment the paint sequence number. if (!mIsRepeatTransaction) { // Increment the paint sequence number even if test logging isn't // enabled in this process; it may be enabled in the parent process, // and the parent process expects unique sequence numbers. ++mPaintSequenceNumber; if (gfxPrefs::APZTestLoggingEnabled()) { mApzTestData.StartNewPaint(mPaintSequenceNumber); } } }
bool ClientLayerManager::BeginTransactionWithTarget(gfxContext* aTarget) { // Wait for any previous async paints to complete before starting to paint again. GetCompositorBridgeChild()->FlushAsyncPaints(); MOZ_ASSERT(mForwarder, "ClientLayerManager::BeginTransaction without forwarder"); if (!mForwarder->IPCOpen()) { gfxCriticalNote << "ClientLayerManager::BeginTransaction with IPC channel down. GPU process may have died."; return false; } if (XRE_IsContentProcess() && mForwarder->DeviceCanReset() && mDeviceResetSequenceNumber != CompositorBridgeChild::Get()->DeviceResetSequenceNumber()) { // The compositor has informed this process that a device reset occurred, // but it has not finished informing each TabChild of its new // TextureFactoryIdentifier. Until then, it's illegal to paint. Note that // it is also illegal to request a new TIF synchronously, because we're // not guaranteed the UI process has finished acquiring new compositors // for each widget. // // Note that we only do this for accelerated backends, since we do not // perform resets on basic compositors. gfxCriticalNote << "Discarding a paint since a device reset has not yet been acknowledged."; return false; } mInTransaction = true; mTransactionStart = TimeStamp::Now(); #ifdef MOZ_LAYERS_HAVE_LOG MOZ_LAYERS_LOG(("[----- BeginTransaction")); Log(); #endif NS_ASSERTION(!InTransaction(), "Nested transactions not allowed"); mPhase = PHASE_CONSTRUCTION; MOZ_ASSERT(mKeepAlive.IsEmpty(), "uncommitted txn?"); // If the last transaction was incomplete (a failed DoEmptyTransaction), // don't signal a new transaction to ShadowLayerForwarder. Carry on adding // to the previous transaction. dom::ScreenOrientationInternal orientation; if (dom::TabChild* window = mWidget->GetOwningTabChild()) { orientation = window->GetOrientation(); } else { hal::ScreenConfiguration currentConfig; hal::GetCurrentScreenConfiguration(¤tConfig); orientation = currentConfig.orientation(); } LayoutDeviceIntRect targetBounds = mWidget->GetNaturalBounds(); targetBounds.x = targetBounds.y = 0; mForwarder->BeginTransaction(targetBounds.ToUnknownRect(), mTargetRotation, orientation); // If we're drawing on behalf of a context with async pan/zoom // enabled, then the entire buffer of painted layers might be // composited (including resampling) asynchronously before we get // a chance to repaint, so we have to ensure that it's all valid // and not rotated. // // Desktop does not support async zoom yet, so we ignore this for those // platforms. #if defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_UIKIT) if (mWidget && mWidget->GetOwningTabChild()) { mCompositorMightResample = AsyncPanZoomEnabled(); } #endif // If we have a non-default target, we need to let our shadow manager draw // to it. This will happen at the end of the transaction. if (aTarget && XRE_IsParentProcess()) { mShadowTarget = aTarget; } else { NS_ASSERTION(!aTarget, "Content-process ClientLayerManager::BeginTransactionWithTarget not supported"); } // If this is a new paint, increment the paint sequence number. if (!mIsRepeatTransaction) { // Increment the paint sequence number even if test logging isn't // enabled in this process; it may be enabled in the parent process, // and the parent process expects unique sequence numbers. ++mPaintSequenceNumber; if (gfxPrefs::APZTestLoggingEnabled()) { mApzTestData.StartNewPaint(mPaintSequenceNumber); } } return true; }