/*public*/
Geometry*
BufferOp::getResultGeometry(double nDistance)
{
distance=nDistance;
computeGeometry();
return resultGeometry;
}
// -----------------------------------------------------------------
// Name : setText
// -----------------------------------------------------------------
void guiLabel::setText(string sText)
{
if (sText == m_sText) {
return;
}
m_sText = sText;
computeGeometry();
}
void Layer::clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
float red, float green, float blue, float alpha) const
{
RenderEngine& engine(mFlinger->getRenderEngine());
computeGeometry(hw, mMesh);
engine.setupFillWithColor(red, green, blue, alpha);
engine.drawMesh(mMesh);
}
// -----------------------------------------------------------------
// Name : setMainDocument
// -----------------------------------------------------------------
void guiTabbedFrame::setMainDocument(guiDocument * pDoc)
{
if (m_pDoc != pDoc)
{
m_pDoc = pDoc;
computeGeometry();
}
}
// -----------------------------------------------------------------
// Name : init
// -----------------------------------------------------------------
void guiLabel::init(string sText, FontId fontId, Color textColor, string sCpntId, int xPxl, int yPxl, int wPxl, int hPxl)
{
guiComponent::init(sCpntId, xPxl, yPxl, wPxl, hPxl);
m_FontId = fontId;
setDiffuseColor(textColor);
m_iBoxWidth = wPxl;
m_sText = sText;
computeGeometry();
}
// -----------------------------------------------------------------
// Name : init
// -----------------------------------------------------------------
void guiTabbedFrame::init(Texture ** pTabTexs, FontId fontId, int xdecal, FramePosition positionType, FrameFitBehavior widthFit, FrameFitBehavior heightFit, int iMaxWidth, int iMaxHeight, Texture ** pMainTexs, string sCpntId, int xPxl, int yPxl, int wPxl, int hPxl)
{
int iSelTabHeight = pTabTexs[0]->getHeight();
guiFrame::init(positionType, widthFit, heightFit, 0, iSelTabHeight, iMaxWidth, iMaxHeight, pMainTexs, sCpntId, xPxl, yPxl, wPxl, hPxl);
memcpy(m_pTexList, pTabTexs, 6 * sizeof(Texture*));
m_FontId = fontId;
m_iXPanelDecal = xdecal;
computeGeometry();
}
void LayerDim::onDraw(const sp<const DisplayDevice>& hw,
const Region& /* clip */, bool useIdentityTransform) const
{
const State& s(getDrawingState());
if (s.alpha>0) {
Mesh mesh(Mesh::TRIANGLE_FAN, 4, 2);
computeGeometry(hw, mesh, useIdentityTransform);
RenderEngine& engine(mFlinger->getRenderEngine());
engine.setupDimLayerBlending(s.alpha);
engine.drawMesh(mesh);
engine.disableBlending();
}
}
void LayerBase::clearWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip,
GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) const
{
const uint32_t fbHeight = hw->getHeight();
glColor4f(red,green,blue,alpha);
glDisable(GL_TEXTURE_EXTERNAL_OES);
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
LayerMesh mesh;
computeGeometry(hw, &mesh);
glVertexPointer(2, GL_FLOAT, 0, mesh.getVertices());
glDrawArrays(GL_TRIANGLE_FAN, 0, mesh.getVertexCount());
}
void Layer::drawWithOpenGL(
const sp<const DisplayDevice>& hw, const Region& clip) const {
const uint32_t fbHeight = hw->getHeight();
const State& s(getDrawingState());
computeGeometry(hw, mMesh);
/*
* NOTE: the way we compute the texture coordinates here produces
* different results than when we take the HWC path -- in the later case
* the "source crop" is rounded to texel boundaries.
* This can produce significantly different results when the texture
* is scaled by a large amount.
*
* The GL code below is more logical (imho), and the difference with
* HWC is due to a limitation of the HWC API to integers -- a question
* is suspend is whether we should ignore this problem or revert to
* GL composition when a buffer scaling is applied (maybe with some
* minimal value)? Or, we could make GL behave like HWC -- but this feel
* like more of a hack.
*/
const Rect win(computeBounds());
float left = float(win.left) / float(s.active.w);
float top = float(win.top) / float(s.active.h);
float right = float(win.right) / float(s.active.w);
float bottom = float(win.bottom) / float(s.active.h);
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
Mesh::VertexArray<vec2> texCoords(mMesh.getTexCoordArray<vec2>());
texCoords[0] = vec2(left, 1.0f - top);
texCoords[1] = vec2(left, 1.0f - bottom);
texCoords[2] = vec2(right, 1.0f - bottom);
texCoords[3] = vec2(right, 1.0f - top);
RenderEngine& engine(mFlinger->getRenderEngine());
engine.setDither(needsDithering());
engine.setupLayerBlending(mPremultipliedAlpha, isOpaque(), s.alpha);
engine.drawMesh(mMesh);
engine.disableBlending();
}
void IntersectionObservation::computeIntersectionObservations(double timestamp)
{
// Pre-oilpan, there will be a delay between the time when the target Element gets deleted
// (because its ref count dropped to zero) and when this IntersectionObservation gets
// deleted (during the next gc run, because the target Element is the only thing keeping
// the IntersectionObservation alive). During that interval, we need to check that m_target
// hasn't been cleared.
Element* targetElement = target();
if (!targetElement || !isActive())
return;
LayoutObject* targetLayoutObject = targetElement->layoutObject();
// TODO(szager): Support SVG
if (!targetLayoutObject || (!targetLayoutObject->isBox() && !targetLayoutObject->isInline()))
return;
IntersectionGeometry geometry;
if (!computeGeometry(geometry))
return;
float intersectionArea = geometry.intersectionRect.size().width().toFloat() * geometry.intersectionRect.size().height().toFloat();
float targetArea = geometry.targetRect.size().width().toFloat() * geometry.targetRect.size().height().toFloat();
if (!targetArea)
return;
float newVisibleRatio = intersectionArea / targetArea;
unsigned newThresholdIndex = observer().firstThresholdGreaterThan(newVisibleRatio);
if (m_lastThresholdIndex != newThresholdIndex) {
IntersectionObserverEntry* newEntry = new IntersectionObserverEntry(
timestamp / 1000.0,
pixelSnappedIntRect(geometry.targetRect),
pixelSnappedIntRect(geometry.rootRect),
pixelSnappedIntRect(geometry.intersectionRect),
targetElement);
observer().enqueueIntersectionObserverEntry(*newEntry);
}
setLastThresholdIndex(newThresholdIndex);
}
void LayerBase::drawWithOpenGL(const sp<const DisplayDevice>& hw, const Region& clip) const
{
const uint32_t fbHeight = hw->getHeight();
const State& s(drawingState());
GLenum src = mPremultipliedAlpha ? GL_ONE : GL_SRC_ALPHA;
if (CC_UNLIKELY(s.alpha < 0xFF)) {
const GLfloat alpha = s.alpha * (1.0f/255.0f);
if (mPremultipliedAlpha) {
glColor4f(alpha, alpha, alpha, alpha);
} else {
glColor4f(1, 1, 1, alpha);
}
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
} else {
glColor4f(1, 1, 1, 1);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (!isOpaque()) {
glEnable(GL_BLEND);
glBlendFunc(src, GL_ONE_MINUS_SRC_ALPHA);
} else {
glDisable(GL_BLEND);
}
}
LayerMesh mesh;
computeGeometry(hw, &mesh);
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
struct TexCoords {
GLfloat u;
GLfloat v;
};
Rect win(s.active.w, s.active.h);
if (!s.active.crop.isEmpty()) {
win.intersect(s.active.crop, &win);
}
GLfloat left = GLfloat(win.left) / GLfloat(s.active.w);
GLfloat top = GLfloat(win.top) / GLfloat(s.active.h);
GLfloat right = GLfloat(win.right) / GLfloat(s.active.w);
GLfloat bottom = GLfloat(win.bottom) / GLfloat(s.active.h);
TexCoords texCoords[4];
texCoords[0].u = left;
texCoords[0].v = top;
texCoords[1].u = left;
texCoords[1].v = bottom;
texCoords[2].u = right;
texCoords[2].v = bottom;
texCoords[3].u = right;
texCoords[3].v = top;
for (int i = 0; i < 4; i++) {
texCoords[i].v = 1.0f - texCoords[i].v;
}
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glVertexPointer(2, GL_FLOAT, 0, mesh.getVertices());
glDrawArrays(GL_TRIANGLE_FAN, 0, mesh.getVertexCount());
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisable(GL_BLEND);
}
void
SVGStylable::computeGeometryForDrawing(svgl::Context * svglContext, svgl::GLInfo* glinfo)
{
computeGeometry(svglContext, glinfo);
}
// -----------------------------------------------------------------
// Name : setBoxWidth
// -----------------------------------------------------------------
void guiLabel::setBoxWidth(int iWidth)
{
m_iBoxWidth = iWidth;
computeGeometry();
}
// -----------------------------------------------------------------
// Name : attachDocument
// -----------------------------------------------------------------
void guiTabbedFrame::attachDocument(guiDocument * pDoc, FrameFitBehavior OldWidthFit, FrameFitBehavior OldHeightFit)
{
guiFrame::setDocument(pDoc);
m_pDocumentsList.push_front(new guiTabbedFrame_Document(pDoc, OldWidthFit, OldHeightFit, m_FontId));
computeGeometry();
}
void
OverlayOp::computeOverlay(int opCode)
//throw(TopologyException *)
{
// copy points from input Geometries.
// This ensures that any Point geometries
// in the input are considered for inclusion in the result set
copyPoints(0);
copyPoints(1);
// node the input Geometries
delete (*arg)[0]->computeSelfNodes(li,false);
delete (*arg)[1]->computeSelfNodes(li,false);
#if DEBUG
cerr<<"OverlayOp::computeOverlay: computed SelfNodes"<<endl;
#endif
// compute intersections between edges of the two input geometries
delete (*arg)[0]->computeEdgeIntersections((*arg)[1],li,true);
#if DEBUG
cerr<<"OverlayOp::computeOverlay: computed EdgeIntersections"<<endl;
cerr<<"OverlayOp::computeOverlay: li: "<<li->toString()<<endl;
#endif
vector<Edge*> baseSplitEdges;
(*arg)[0]->computeSplitEdges(&baseSplitEdges);
(*arg)[1]->computeSplitEdges(&baseSplitEdges);
// add the noded edges to this result graph
insertUniqueEdges(&baseSplitEdges);
computeLabelsFromDepths();
replaceCollapsedEdges();
//Debug.println(edgeList);
// debugging only
//NodingValidator nv = new NodingValidator(edgeList.getEdges());
//nv.checkValid();
graph->addEdges(edgeList->getEdges());
// this can throw TopologyException *
computeLabelling();
//Debug.printWatch();
labelIncompleteNodes();
//Debug.printWatch();
//nodeMap.print(System.out);
/*
* The ordering of building the result Geometries is important.
* Areas must be built before lines, which must be built
* before points.
* This is so that lines which are covered by areas are not
* included explicitly, and similarly for points.
*/
findResultAreaEdges(opCode);
cancelDuplicateResultEdges();
PolygonBuilder polyBuilder(geomFact,cga);
// might throw a TopologyException *
polyBuilder.add(graph);
vector<Geometry*> *gv=polyBuilder.getPolygons();
size_t gvSize=gv->size();
resultPolyList=new vector<Polygon*>(gvSize);
for(size_t i=0; i<gvSize; ++i) {
(*resultPolyList)[i]=(Polygon*)(*gv)[i];
}
delete gv;
LineBuilder lineBuilder(this,geomFact,ptLocator);
resultLineList=lineBuilder.build(opCode);
PointBuilder pointBuilder(this,geomFact,ptLocator);
resultPointList=pointBuilder.build(opCode);
// gather the results from all calculations into a single
// Geometry for the result set
resultGeom=computeGeometry(resultPointList,resultLineList,resultPolyList);
#if USE_ELEVATION_MATRIX
elevationMatrix->elevate(resultGeom);
#endif // USE_ELEVATION_MATRIX
}