std::string FileManager::fixPath(const std::string& path)
{
auto fixed = path;
replaceSeparators(fixed);
optimizePath(fixed);
return fixed;
}
nsresult
txXPathOptimizer::optimize(Expr* aInExpr, Expr** aOutExpr)
{
*aOutExpr = nullptr;
nsresult rv = NS_OK;
// First check if the expression will produce the same result
// under any context.
Expr::ExprType exprType = aInExpr->getType();
if (exprType != Expr::LITERAL_EXPR &&
!aInExpr->isSensitiveTo(Expr::ANY_CONTEXT)) {
nsRefPtr<txResultRecycler> recycler = new txResultRecycler;
txEarlyEvalContext context(recycler);
nsRefPtr<txAExprResult> exprRes;
// Don't throw if this fails since it could be that the expression
// is or contains an error-expression.
rv = aInExpr->evaluate(&context, getter_AddRefs(exprRes));
if (NS_SUCCEEDED(rv)) {
*aOutExpr = new txLiteralExpr(exprRes);
}
return NS_OK;
}
// Then optimize sub expressions
uint32_t i = 0;
Expr* subExpr;
while ((subExpr = aInExpr->getSubExprAt(i))) {
Expr* newExpr = nullptr;
rv = optimize(subExpr, &newExpr);
NS_ENSURE_SUCCESS(rv, rv);
if (newExpr) {
delete subExpr;
aInExpr->setSubExprAt(i, newExpr);
}
++i;
}
// Finally see if current expression can be optimized
switch (exprType) {
case Expr::LOCATIONSTEP_EXPR:
return optimizeStep(aInExpr, aOutExpr);
case Expr::PATH_EXPR:
return optimizePath(aInExpr, aOutExpr);
case Expr::UNION_EXPR:
return optimizeUnion(aInExpr, aOutExpr);
default:
break;
}
return NS_OK;
}
void LinePolygonsCrossings::getCombingPath(CombPath& combPath)
{
if (shorterThen(endPoint - startPoint, Comb::max_comb_distance_ignored) || !lineSegmentCollidesWithBoundary())
{
//We're not crossing any boundaries. So skip the comb generation.
combPath.push_back(startPoint);
combPath.push_back(endPoint);
return;
}
calcScanlineCrossings();
CombPath basicPath;
getBasicCombingPath(basicPath);
optimizePath(basicPath, combPath);
}
static void optimizeNode(fz_node *node) {
if (!node) {
return;
}
switch (node->kind) {
case FZ_NIMAGE: optimizeImage((fz_imagenode*)node); break;
case FZ_NMETA: optimizeMeta((fz_metanode*)node); break;
case FZ_NOVER: optimizeOver((fz_overnode*)node); break;
case FZ_NMASK: optimizeMask((fz_masknode*)node); break;
case FZ_NBLEND: optimizeBlend((fz_blendnode*)node); break;
case FZ_NTRANSFORM: optimizeTransform((fz_transformnode*)node); break;
case FZ_NCOLOR: optimizeSolid((fz_solidnode*)node); break;
case FZ_NPATH: optimizePath((fz_pathnode*)node); break;
case FZ_NTEXT: optimizeText((fz_textnode*)node); break;
case FZ_NSHADE: optimizeShade((fz_shadenode*)node); break;
case FZ_NLINK: optimizeLink((fz_linknode*)node); break;
}
}
bool Comb::optimizePaths(Point startPoint, std::vector<std::vector<Point>>& basicCombPaths, std::vector<std::vector<Point>>& combPaths)
{
Point current_point = startPoint;
bool first = true;
for (std::vector<Point>& basicCombPath : basicCombPaths)
{
if (!first)
{
current_point = basicCombPath[0]; // TODO: don't cause the first point to get doubled
}
first = false;
combPaths.emplace_back();
std::vector<Point>& combPath = combPaths.back();
bool succeeded = optimizePath(current_point, basicCombPath, combPath);
if (!succeeded)
{
return false;
}
}
return true;
}
bool Comb::calc(Point startPoint, Point endPoint, std::vector<Point>& combPoints)
{
if (shorterThen(endPoint - startPoint, MM2INT(1.5)))
return true;
bool addEndpoint = false;
//Check if we are inside the comb boundaries
if (!boundary.inside(startPoint))
{
if (!moveInside(&startPoint)) //If we fail to move the point inside the comb boundary we need to retract.
return false;
combPoints.push_back(startPoint);
}
if (!boundary.inside(endPoint))
{
if (!moveInside(&endPoint)) //If we fail to move the point inside the comb boundary we need to retract.
return false;
addEndpoint = true;
}
//Check if we are crossing any boundaries, and pre-calculate some values.
if (!lineSegmentCollidesWithBoundary(startPoint, endPoint))
{
//We're not crossing any boundaries. So skip the comb generation.
if (!addEndpoint && combPoints.size() == 0) //Only skip if we didn't move the start and end point.
return true;
}
//Calculate the minimum and maximum positions where we cross the comb boundary
calcMinMax();
std::vector<Point> pointList;
getBasicCombingPath(endPoint, pointList);
bool succeeded = optimizePath(startPoint, pointList, combPoints);
if (addEndpoint)
combPoints.push_back(endPoint);
return succeeded;
}
bool LinePolygonsCrossings::getCombingPath(CombPath& combPath, int64_t max_comb_distance_ignored, bool fail_on_unavoidable_obstacles)
{
if (shorterThen(endPoint - startPoint, max_comb_distance_ignored) || !lineSegmentCollidesWithBoundary())
{
//We're not crossing any boundaries. So skip the comb generation.
combPath.push_back(startPoint);
combPath.push_back(endPoint);
return true;
}
bool success = calcScanlineCrossings(fail_on_unavoidable_obstacles);
if (!success)
{
return false;
}
CombPath basicPath;
getBasicCombingPath(basicPath);
optimizePath(basicPath, combPath);
// combPath = basicPath; // uncomment to disable comb path optimization
return true;
}
