const sp<ISurfaceTexture>& surface);
static void setDisplayLayerStack(const sp<IBinder>& token,
uint32_t layerStack);
- static void setDisplayOrientation(const sp<IBinder>& token,
- uint32_t orientation);
- static void setDisplayViewport(const sp<IBinder>& token,
- const Rect& viewport);
- static void setDisplayFrame(const sp<IBinder>& token, const Rect& frame);
+
+ /* setDisplayProjection() defines the projection of layer stacks
+ * to a given display.
+ *
+ * - orientation defines the display's orientation.
+ * - layerStackRect defines which area of the window manager coordinate
+ * space will be used.
+ * - displayRect defines where on the display will layerStackRect be
+ * mapped to. displayRect is specified post-orientation, that is
+ * it uses the orientation seen by the end-user.
+ */
+ static void setDisplayProjection(const sp<IBinder>& token,
+ uint32_t orientation,
+ const Rect& layerStackRect,
+ const Rect& displayRect);
private:
virtual void onFirstRef();
};
enum {
- eSurfaceChanged = 0x01,
- eLayerStackChanged = 0x02,
- eOrientationChanged = 0x04,
- eViewportChanged = 0x08,
- eFrameChanged = 0x10
+ eSurfaceChanged = 0x01,
+ eLayerStackChanged = 0x02,
+ eDisplayProjectionChanged = 0x04
};
uint32_t what;
void setDisplaySurface(const sp<IBinder>& token, const sp<ISurfaceTexture>& surface);
void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack);
- void setDisplayOrientation(const sp<IBinder>& token, uint32_t orientation);
- void setDisplayViewport(const sp<IBinder>& token, const Rect& viewport);
- void setDisplayFrame(const sp<IBinder>& token, const Rect& frame);
+ void setDisplayProjection(const sp<IBinder>& token,
+ uint32_t orientation,
+ const Rect& layerStackRect,
+ const Rect& displayRect);
static void closeGlobalTransaction(bool synchronous) {
Composer::getInstance().closeGlobalTransactionImpl(synchronous);
s.what |= DisplayState::eLayerStackChanged;
}
-void Composer::setDisplayOrientation(const sp<IBinder>& token,
- uint32_t orientation) {
+void Composer::setDisplayProjection(const sp<IBinder>& token,
+ uint32_t orientation,
+ const Rect& layerStackRect,
+ const Rect& displayRect) {
Mutex::Autolock _l(mLock);
DisplayState& s(getDisplayStateLocked(token));
s.orientation = orientation;
- s.what |= DisplayState::eOrientationChanged;
+ s.viewport = layerStackRect;
+ s.frame = displayRect;
+ s.what |= DisplayState::eDisplayProjectionChanged;
mForceSynchronous = true; // TODO: do we actually still need this?
}
-// FIXME: get rid of this eventually
-status_t Composer::setOrientation(int orientation) {
- sp<ISurfaceComposer> sm(ComposerService::getComposerService());
- sp<IBinder> token(sm->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain));
- Composer::setDisplayOrientation(token, orientation);
- return NO_ERROR;
-}
-
-void Composer::setDisplayViewport(const sp<IBinder>& token,
- const Rect& viewport) {
- Mutex::Autolock _l(mLock);
- DisplayState& s(getDisplayStateLocked(token));
- s.viewport = viewport;
- s.what |= DisplayState::eViewportChanged;
-}
-
-void Composer::setDisplayFrame(const sp<IBinder>& token,
- const Rect& frame) {
- Mutex::Autolock _l(mLock);
- DisplayState& s(getDisplayStateLocked(token));
- s.frame = frame;
- s.what |= DisplayState::eFrameChanged;
-}
-
// ---------------------------------------------------------------------------
SurfaceComposerClient::SurfaceComposerClient()
Composer::getInstance().setDisplayLayerStack(token, layerStack);
}
-void SurfaceComposerClient::setDisplayOrientation(const sp<IBinder>& token,
- uint32_t orientation) {
- Composer::getInstance().setDisplayOrientation(token, orientation);
-}
-
-void SurfaceComposerClient::setDisplayViewport(const sp<IBinder>& token,
- const Rect& viewport) {
- Composer::getInstance().setDisplayViewport(token, viewport);
-}
-
-void SurfaceComposerClient::setDisplayFrame(const sp<IBinder>& token,
- const Rect& frame) {
- Composer::getInstance().setDisplayFrame(token, frame);
+void SurfaceComposerClient::setDisplayProjection(const sp<IBinder>& token,
+ uint32_t orientation,
+ const Rect& layerStackRect,
+ const Rect& displayRect) {
+ Composer::getInstance().setDisplayProjection(token, orientation,
+ layerStackRect, displayRect);
}
// ----------------------------------------------------------------------------
mHwcDisplayId = mFlinger->allocateHwcDisplayId(mType);
// initialize the display orientation transform.
- DisplayDevice::setOrientation(DisplayState::eOrientationDefault);
+ setProjection(DisplayState::eOrientationDefault, mViewport, mFrame);
}
uint32_t DisplayDevice::getPageFlipCount() const {
return NO_ERROR;
}
-void DisplayDevice::setOrientation(int orientation) {
+void DisplayDevice::setProjection(int orientation,
+ const Rect& viewport, const Rect& frame) {
mOrientation = orientation;
+ mViewport = viewport;
+ mFrame = frame;
updateGeometryTransform();
}
-void DisplayDevice::setViewport(const Rect& viewport) {
- if (viewport.isValid()) {
- mViewport = viewport;
- updateGeometryTransform();
- }
-}
-
-void DisplayDevice::setFrame(const Rect& frame) {
- if (frame.isValid()) {
- mFrame = frame;
- updateGeometryTransform();
- }
-}
-
void DisplayDevice::updateGeometryTransform() {
int w = mDisplayWidth;
int h = mDisplayHeight;
Region getDirtyRegion(bool repaintEverything) const;
void setLayerStack(uint32_t stack);
- void setOrientation(int orientation);
- void setViewport(const Rect& viewport);
- void setFrame(const Rect& frame);
+ void setProjection(int orientation, const Rect& viewport, const Rect& frame);
int getOrientation() const { return mOrientation; }
const Transform& getTransform() const { return mGlobalTransform; }
if (state.layerStack != draw[i].layerStack) {
disp->setLayerStack(state.layerStack);
}
- if (state.orientation != draw[i].orientation) {
- disp->setOrientation(state.orientation);
- }
- if (state.viewport != draw[i].viewport) {
- disp->setViewport(state.viewport);
- }
- if (state.frame != draw[i].frame) {
- disp->setFrame(state.frame);
+ if ((state.orientation != draw[i].orientation)
+ || (state.viewport != draw[i].viewport)
+ || (state.frame != draw[i].frame))
+ {
+ disp->setProjection(state.orientation,
+ state.viewport, state.viewport);
}
}
}
sp<DisplayDevice> disp = new DisplayDevice(this,
state.type, display, stc, 0, mEGLConfig);
disp->setLayerStack(state.layerStack);
- disp->setOrientation(state.orientation);
- disp->setViewport(state.viewport);
- disp->setFrame(state.frame);
+ disp->setProjection(state.orientation,
+ state.viewport, state.viewport);
mDisplays.add(display, disp);
}
}
flags |= eDisplayTransactionNeeded;
}
}
- if (what & DisplayState::eOrientationChanged) {
+ if (what & DisplayState::eDisplayProjectionChanged) {
if (disp.orientation != s.orientation) {
disp.orientation = s.orientation;
flags |= eDisplayTransactionNeeded;
}
- }
- if (what & DisplayState::eFrameChanged) {
if (disp.frame != s.frame) {
disp.frame = s.frame;
flags |= eDisplayTransactionNeeded;
}
- }
- if (what & DisplayState::eViewportChanged) {
if (disp.viewport != s.viewport) {
disp.viewport = s.viewport;
flags |= eDisplayTransactionNeeded;
Vector<ComposerState> state;
Vector<DisplayState> displays;
DisplayState d;
- d.what = DisplayState::eOrientationChanged;
+ d.what = DisplayState::eDisplayProjectionChanged;
d.token = mDefaultDisplays[DisplayDevice::DISPLAY_PRIMARY];
d.orientation = DisplayState::eOrientationDefault;
displays.add(d);