vclmetafileprocessor2d.cxx (64b14621) | vclmetafileprocessor2d.cxx (ff9ad81e) |
---|---|
1/************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance --- 782 unchanged lines hidden (view full) --- 791 // svtools/source/graphic/grfmgr.cxx 792 const basegfx::B2DRange aCurrentRange( 793 aTranslate.getX(), aTranslate.getY(), 794 aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY()); 795 const Rectangle aCurrentRect( 796 sal_Int32(floor(aCurrentRange.getMinX())), sal_Int32(floor(aCurrentRange.getMinY())), 797 sal_Int32(ceil(aCurrentRange.getMaxX())), sal_Int32(ceil(aCurrentRange.getMaxY()))); 798 const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr(); | 1/************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance --- 782 unchanged lines hidden (view full) --- 791 // svtools/source/graphic/grfmgr.cxx 792 const basegfx::B2DRange aCurrentRange( 793 aTranslate.getX(), aTranslate.getY(), 794 aTranslate.getX() + aScale.getX(), aTranslate.getY() + aScale.getY()); 795 const Rectangle aCurrentRect( 796 sal_Int32(floor(aCurrentRange.getMinX())), sal_Int32(floor(aCurrentRange.getMinY())), 797 sal_Int32(ceil(aCurrentRange.getMaxX())), sal_Int32(ceil(aCurrentRange.getMaxY()))); 798 const GraphicAttr& rAttr = rGraphicPrimitive.getGraphicAttr(); |
799 Rectangle aCropRect; | |
800 | 799 |
800 // #123295# As described below this is the expanded, uncropped region 801 // and needs to be given in any case, especially when no cropping it is 802 // equal to the current rect. To make clear: normally the uncropped region 803 // (aka the aCropRect) is bigger than the CurrentRect. Or in other words: 804 // The current rect is the object area. This internal crop definition is 805 // somewhat crude, but used (and defined in graphic-dependent units what 806 // leads to even more problems, percentages would have been better). All 807 // in all this is a place that makes clear that a pure PDF export which does 808 // not use Metafile and the associated hacks (like this one) but is based on 809 // Primitves and uses a Primitive Renderer would be the better choice for 810 // the future. 811 Rectangle aCropRect(aCurrentRect); 812 |
|
801 if(rAttr.IsCropped()) 802 { 803 // calculate scalings between real image size and logic object size. This 804 // is necessary since the crop values are relative to original bitmap size 805 double fFactorX(1.0); 806 double fFactorY(1.0); 807 808 { --- 621 unchanged lines hidden (view full) --- 1430 // Do use decomposition; encapsulate with SvtGraphicFill 1431 impStartSvtGraphicFill(pSvtGraphicFill); 1432 process(rCandidate.get2DDecomposition(getViewInformation2D())); 1433 impEndSvtGraphicFill(pSvtGraphicFill); 1434 } 1435 1436 break; 1437 } | 813 if(rAttr.IsCropped()) 814 { 815 // calculate scalings between real image size and logic object size. This 816 // is necessary since the crop values are relative to original bitmap size 817 double fFactorX(1.0); 818 double fFactorY(1.0); 819 820 { --- 621 unchanged lines hidden (view full) --- 1442 // Do use decomposition; encapsulate with SvtGraphicFill 1443 impStartSvtGraphicFill(pSvtGraphicFill); 1444 process(rCandidate.get2DDecomposition(getViewInformation2D())); 1445 impEndSvtGraphicFill(pSvtGraphicFill); 1446 } 1447 1448 break; 1449 } |
1438 case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D : 1439 { 1440 // need to handle PolyPolygonHatchPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END 1441 const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate = static_cast< const primitive2d::PolyPolygonHatchPrimitive2D& >(rCandidate); 1442 const attribute::FillHatchAttribute& rFillHatchAttribute = rHatchCandidate.getFillHatch(); 1443 basegfx::B2DPolyPolygon aLocalPolyPolygon(rHatchCandidate.getB2DPolyPolygon()); | 1450 case PRIMITIVE2D_ID_POLYPOLYGONHATCHPRIMITIVE2D : 1451 { 1452 // need to handle PolyPolygonHatchPrimitive2D here to support XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END 1453 const primitive2d::PolyPolygonHatchPrimitive2D& rHatchCandidate = static_cast< const primitive2d::PolyPolygonHatchPrimitive2D& >(rCandidate); 1454 const attribute::FillHatchAttribute& rFillHatchAttribute = rHatchCandidate.getFillHatch(); 1455 basegfx::B2DPolyPolygon aLocalPolyPolygon(rHatchCandidate.getB2DPolyPolygon()); |
1444 | 1456 |
1445 if(aLocalPolyPolygon.getB2DRange() != rHatchCandidate.getDefinitionRange()) 1446 { 1447 // the range which defines the hatch is different from the range of the 1448 // geometry (used for writer frames). This cannot be done calling vcl, thus use 1449 // decomposition here 1450 process(rCandidate.get2DDecomposition(getViewInformation2D())); 1451 break; 1452 } 1453 | |
1454 // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points 1455 // per polygon. Split polygon until there are less than that 1456 while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon)) 1457 ; 1458 | 1457 // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points 1458 // per polygon. Split polygon until there are less than that 1459 while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon)) 1460 ; 1461 |
1459 if(rFillHatchAttribute.isFillBackground()) 1460 { 1461 // with fixing #i111954# (see below) the possible background 1462 // fill of a hatched object was lost.Generate a background fill 1463 // primitive and render it 1464 const primitive2d::Primitive2DReference xBackground( 1465 new primitive2d::PolyPolygonColorPrimitive2D( 1466 aLocalPolyPolygon, 1467 rHatchCandidate.getBackgroundColor())); 1468 1469 process(primitive2d::Primitive2DSequence(&xBackground, 1)); 1470 } | 1462 if(rFillHatchAttribute.isFillBackground()) 1463 { 1464 // with fixing #i111954# (see below) the possible background 1465 // fill of a hatched object was lost.Generate a background fill 1466 // primitive and render it 1467 const primitive2d::Primitive2DReference xBackground( 1468 new primitive2d::PolyPolygonColorPrimitive2D( 1469 aLocalPolyPolygon, 1470 rHatchCandidate.getBackgroundColor())); 1471 1472 process(primitive2d::Primitive2DSequence(&xBackground, 1)); 1473 } |
1471 1472 SvtGraphicFill* pSvtGraphicFill = 0; | 1474 1475 SvtGraphicFill* pSvtGraphicFill = 0; |
1473 aLocalPolyPolygon.transform(maCurrentTransformation); | 1476 aLocalPolyPolygon.transform(maCurrentTransformation); |
1474 | 1477 |
1475 if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count()) 1476 { 1477 // re-create a VCL hatch as base data 1478 SvtGraphicFill::HatchType eHatch(SvtGraphicFill::hatchSingle); | 1478 if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count()) 1479 { 1480 // re-create a VCL hatch as base data 1481 SvtGraphicFill::HatchType eHatch(SvtGraphicFill::hatchSingle); |
1479 | 1482 |
1480 switch(rFillHatchAttribute.getStyle()) 1481 { 1482 default: // attribute::HATCHSTYLE_SINGLE : 1483 { 1484 eHatch = SvtGraphicFill::hatchSingle; 1485 break; 1486 } 1487 case attribute::HATCHSTYLE_DOUBLE : 1488 { 1489 eHatch = SvtGraphicFill::hatchDouble; 1490 break; 1491 } 1492 case attribute::HATCHSTYLE_TRIPLE : 1493 { 1494 eHatch = SvtGraphicFill::hatchTriple; 1495 break; 1496 } 1497 } | 1483 switch(rFillHatchAttribute.getStyle()) 1484 { 1485 default: // attribute::HATCHSTYLE_SINGLE : 1486 { 1487 eHatch = SvtGraphicFill::hatchSingle; 1488 break; 1489 } 1490 case attribute::HATCHSTYLE_DOUBLE : 1491 { 1492 eHatch = SvtGraphicFill::hatchDouble; 1493 break; 1494 } 1495 case attribute::HATCHSTYLE_TRIPLE : 1496 { 1497 eHatch = SvtGraphicFill::hatchTriple; 1498 break; 1499 } 1500 } |
1498 | 1501 |
1499 SvtGraphicFill::Transform aTransform; 1500 1501 // scale 1502 aTransform.matrix[0] *= rFillHatchAttribute.getDistance(); 1503 aTransform.matrix[4] *= rFillHatchAttribute.getDistance(); | 1502 SvtGraphicFill::Transform aTransform; 1503 1504 // scale 1505 aTransform.matrix[0] *= rFillHatchAttribute.getDistance(); 1506 aTransform.matrix[4] *= rFillHatchAttribute.getDistance(); |
1504 | 1507 |
1505 // rotate (was never correct in impgrfll anyways, use correct angle now) 1506 aTransform.matrix[0] *= cos(rFillHatchAttribute.getAngle()); 1507 aTransform.matrix[1] *= -sin(rFillHatchAttribute.getAngle()); 1508 aTransform.matrix[3] *= sin(rFillHatchAttribute.getAngle()); 1509 aTransform.matrix[4] *= cos(rFillHatchAttribute.getAngle()); 1510 1511 pSvtGraphicFill = new SvtGraphicFill( 1512 PolyPolygon(aLocalPolyPolygon), 1513 Color(), 1514 0.0, 1515 SvtGraphicFill::fillEvenOdd, 1516 SvtGraphicFill::fillHatch, 1517 aTransform, 1518 false, 1519 eHatch, 1520 Color(rFillHatchAttribute.getColor()), 1521 SvtGraphicFill::gradientLinear, 1522 Color(), 1523 Color(), 1524 0, 1525 Graphic()); 1526 } | 1508 // rotate (was never correct in impgrfll anyways, use correct angle now) 1509 aTransform.matrix[0] *= cos(rFillHatchAttribute.getAngle()); 1510 aTransform.matrix[1] *= -sin(rFillHatchAttribute.getAngle()); 1511 aTransform.matrix[3] *= sin(rFillHatchAttribute.getAngle()); 1512 aTransform.matrix[4] *= cos(rFillHatchAttribute.getAngle()); 1513 1514 pSvtGraphicFill = new SvtGraphicFill( 1515 PolyPolygon(aLocalPolyPolygon), 1516 Color(), 1517 0.0, 1518 SvtGraphicFill::fillEvenOdd, 1519 SvtGraphicFill::fillHatch, 1520 aTransform, 1521 false, 1522 eHatch, 1523 Color(rFillHatchAttribute.getColor()), 1524 SvtGraphicFill::gradientLinear, 1525 Color(), 1526 Color(), 1527 0, 1528 Graphic()); 1529 } |
1527 | 1530 |
1528 // Do use decomposition; encapsulate with SvtGraphicFill 1529 impStartSvtGraphicFill(pSvtGraphicFill); | 1531 // Do use decomposition; encapsulate with SvtGraphicFill 1532 impStartSvtGraphicFill(pSvtGraphicFill); |
1530 1531 // #i111954# do NOT use decomposition, but use direct VCL-command | 1533 1534 // #i111954# do NOT use decomposition, but use direct VCL-command |
1532 // process(rCandidate.get2DDecomposition(getViewInformation2D())); 1533 const PolyPolygon aToolsPolyPolygon(aLocalPolyPolygon); | 1535 // process(rCandidate.get2DDecomposition(getViewInformation2D())); 1536 const PolyPolygon aToolsPolyPolygon(aLocalPolyPolygon); |
1534 const HatchStyle aHatchStyle( 1535 attribute::HATCHSTYLE_SINGLE == rFillHatchAttribute.getStyle() ? HATCH_SINGLE : 1536 attribute::HATCHSTYLE_DOUBLE == rFillHatchAttribute.getStyle() ? HATCH_DOUBLE : 1537 HATCH_TRIPLE); 1538 1539 mpOutputDevice->DrawHatch(aToolsPolyPolygon, 1540 Hatch(aHatchStyle, 1541 Color(rFillHatchAttribute.getColor()), 1542 basegfx::fround(rFillHatchAttribute.getDistance()), 1543 basegfx::fround(rFillHatchAttribute.getAngle() / F_PI1800))); 1544 1545 impEndSvtGraphicFill(pSvtGraphicFill); 1546 | 1537 const HatchStyle aHatchStyle( 1538 attribute::HATCHSTYLE_SINGLE == rFillHatchAttribute.getStyle() ? HATCH_SINGLE : 1539 attribute::HATCHSTYLE_DOUBLE == rFillHatchAttribute.getStyle() ? HATCH_DOUBLE : 1540 HATCH_TRIPLE); 1541 1542 mpOutputDevice->DrawHatch(aToolsPolyPolygon, 1543 Hatch(aHatchStyle, 1544 Color(rFillHatchAttribute.getColor()), 1545 basegfx::fround(rFillHatchAttribute.getDistance()), 1546 basegfx::fround(rFillHatchAttribute.getAngle() / F_PI1800))); 1547 1548 impEndSvtGraphicFill(pSvtGraphicFill); 1549 |
1547 break; 1548 } 1549 case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D : | 1550 break; 1551 } 1552 case PRIMITIVE2D_ID_POLYPOLYGONGRADIENTPRIMITIVE2D : |
1550 { 1551 basegfx::B2DVector aScale, aTranslate; 1552 double fRotate, fShearX; 1553 1554 maCurrentTransformation.decompose(aScale, aTranslate, fRotate, fShearX); 1555 1556 if(!basegfx::fTools::equalZero(fRotate) || !basegfx::fTools::equalZero(fShearX)) 1557 { --- 10 unchanged lines hidden (view full) --- 1568 // These will need more space and time, but the result will be as if the Gradient 1569 // was rotated with the object. 1570 // This mechanism is used by all exporters still not using Primtives (e.g. Print, 1571 // Slideshow, Export rto PDF, export to Picture, ...) but relying on Metafile 1572 // transfers. One more reason to *change* these to primitives. 1573 // BTW: One more example how useful the principles of primitives are; the decomposition 1574 // is by definition a simpler, maybe more expensive representation of the same content. 1575 process(rCandidate.get2DDecomposition(getViewInformation2D())); | 1553 { 1554 basegfx::B2DVector aScale, aTranslate; 1555 double fRotate, fShearX; 1556 1557 maCurrentTransformation.decompose(aScale, aTranslate, fRotate, fShearX); 1558 1559 if(!basegfx::fTools::equalZero(fRotate) || !basegfx::fTools::equalZero(fShearX)) 1560 { --- 10 unchanged lines hidden (view full) --- 1571 // These will need more space and time, but the result will be as if the Gradient 1572 // was rotated with the object. 1573 // This mechanism is used by all exporters still not using Primtives (e.g. Print, 1574 // Slideshow, Export rto PDF, export to Picture, ...) but relying on Metafile 1575 // transfers. One more reason to *change* these to primitives. 1576 // BTW: One more example how useful the principles of primitives are; the decomposition 1577 // is by definition a simpler, maybe more expensive representation of the same content. 1578 process(rCandidate.get2DDecomposition(getViewInformation2D())); |
1576 break; | |
1577 } | 1579 } |
1578 1579 const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate = static_cast< const primitive2d::PolyPolygonGradientPrimitive2D& >(rCandidate); 1580 basegfx::B2DPolyPolygon aLocalPolyPolygon(rGradientCandidate.getB2DPolyPolygon()); 1581 1582 if(aLocalPolyPolygon.getB2DRange() != rGradientCandidate.getDefinitionRange()) | 1580 else |
1583 { | 1581 { |
1584 // the range which defines the gradient is different from the range of the 1585 // geometry (used for writer frames). This cannot be done calling vcl, thus use 1586 // decomposition here 1587 process(rCandidate.get2DDecomposition(getViewInformation2D())); 1588 break; 1589 } | 1582 const primitive2d::PolyPolygonGradientPrimitive2D& rGradientCandidate = static_cast< const primitive2d::PolyPolygonGradientPrimitive2D& >(rCandidate); 1583 basegfx::B2DPolyPolygon aLocalPolyPolygon(rGradientCandidate.getB2DPolyPolygon()); |
1590 | 1584 |
1591 // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points 1592 // per polygon. Split polygon until there are less than that 1593 while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon)) 1594 ; | 1585 // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points 1586 // per polygon. Split polygon until there are less than that 1587 while(fillPolyPolygonNeededToBeSplit(aLocalPolyPolygon)) 1588 ; |
1595 | 1589 |
1596 // for support of MetaCommentActions of the form XGRAD_SEQ_BEGIN, XGRAD_SEQ_END 1597 // it is safest to use the VCL OutputDevice::DrawGradient method which creates those. 1598 // re-create a VCL-gradient from FillGradientPrimitive2D and the needed tools PolyPolygon 1599 Gradient aVCLGradient; 1600 impConvertFillGradientAttributeToVCLGradient(aVCLGradient, rGradientCandidate.getFillGradient(), false); 1601 aLocalPolyPolygon.transform(maCurrentTransformation); | 1590 // for support of MetaCommentActions of the form XGRAD_SEQ_BEGIN, XGRAD_SEQ_END 1591 // it is safest to use the VCL OutputDevice::DrawGradient method which creates those. 1592 // re-create a VCL-gradient from FillGradientPrimitive2D and the needed tools PolyPolygon 1593 Gradient aVCLGradient; 1594 impConvertFillGradientAttributeToVCLGradient(aVCLGradient, rGradientCandidate.getFillGradient(), false); 1595 aLocalPolyPolygon.transform(maCurrentTransformation); |
1602 | 1596 |
1603 // #i82145# ATM VCL printing of gradients using curved shapes does not work, 1604 // i submitted the bug with the given ID to THB. When that task is fixed it is 1605 // necessary to again remove this subdivision since it decreases possible 1606 // printing quality (not even resolution-dependent for now). THB will tell 1607 // me when that task is fixed in the master 1608 const PolyPolygon aToolsPolyPolygon(basegfx::tools::adaptiveSubdivideByAngle(aLocalPolyPolygon)); | 1597 // #i82145# ATM VCL printing of gradients using curved shapes does not work, 1598 // i submitted the bug with the given ID to THB. When that task is fixed it is 1599 // necessary to again remove this subdivision since it decreases possible 1600 // printing quality (not even resolution-dependent for now). THB will tell 1601 // me when that task is fixed in the master 1602 const PolyPolygon aToolsPolyPolygon(basegfx::tools::adaptiveSubdivideByAngle(aLocalPolyPolygon)); |
1609 | 1603 |
1610 // XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support 1611 SvtGraphicFill* pSvtGraphicFill = 0; | 1604 // XPATHFILL_SEQ_BEGIN/XPATHFILL_SEQ_END support 1605 SvtGraphicFill* pSvtGraphicFill = 0; |
1612 | 1606 |
1613 if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count()) 1614 { 1615 // setup gradient stuff like in like in impgrfll 1616 SvtGraphicFill::GradientType eGrad(SvtGraphicFill::gradientLinear); | 1607 if(!mnSvtGraphicFillCount && aLocalPolyPolygon.count()) 1608 { 1609 // setup gradient stuff like in like in impgrfll 1610 SvtGraphicFill::GradientType eGrad(SvtGraphicFill::gradientLinear); |
1617 | 1611 |
1618 switch(aVCLGradient.GetStyle()) 1619 { 1620 default : // GRADIENT_LINEAR: 1621 case GRADIENT_AXIAL: 1622 eGrad = SvtGraphicFill::gradientLinear; 1623 break; 1624 case GRADIENT_RADIAL: 1625 case GRADIENT_ELLIPTICAL: 1626 eGrad = SvtGraphicFill::gradientRadial; 1627 break; 1628 case GRADIENT_SQUARE: 1629 case GRADIENT_RECT: 1630 eGrad = SvtGraphicFill::gradientRectangular; 1631 break; 1632 } 1633 1634 pSvtGraphicFill = new SvtGraphicFill( 1635 aToolsPolyPolygon, 1636 Color(), 1637 0.0, 1638 SvtGraphicFill::fillEvenOdd, 1639 SvtGraphicFill::fillGradient, 1640 SvtGraphicFill::Transform(), 1641 false, 1642 SvtGraphicFill::hatchSingle, 1643 Color(), 1644 eGrad, 1645 aVCLGradient.GetStartColor(), 1646 aVCLGradient.GetEndColor(), 1647 aVCLGradient.GetSteps(), 1648 Graphic()); | 1612 switch(aVCLGradient.GetStyle()) 1613 { 1614 default : // GRADIENT_LINEAR: 1615 case GRADIENT_AXIAL: 1616 eGrad = SvtGraphicFill::gradientLinear; 1617 break; 1618 case GRADIENT_RADIAL: 1619 case GRADIENT_ELLIPTICAL: 1620 eGrad = SvtGraphicFill::gradientRadial; 1621 break; 1622 case GRADIENT_SQUARE: 1623 case GRADIENT_RECT: 1624 eGrad = SvtGraphicFill::gradientRectangular; 1625 break; 1626 } 1627 1628 pSvtGraphicFill = new SvtGraphicFill( 1629 aToolsPolyPolygon, 1630 Color(), 1631 0.0, 1632 SvtGraphicFill::fillEvenOdd, 1633 SvtGraphicFill::fillGradient, 1634 SvtGraphicFill::Transform(), 1635 false, 1636 SvtGraphicFill::hatchSingle, 1637 Color(), 1638 eGrad, 1639 aVCLGradient.GetStartColor(), 1640 aVCLGradient.GetEndColor(), 1641 aVCLGradient.GetSteps(), 1642 Graphic()); 1643 } 1644 1645 // call VCL directly; encapsulate with SvtGraphicFill 1646 impStartSvtGraphicFill(pSvtGraphicFill); 1647 mpOutputDevice->DrawGradient(aToolsPolyPolygon, aVCLGradient); 1648 impEndSvtGraphicFill(pSvtGraphicFill); |
1649 } 1650 | 1649 } 1650 |
1651 // call VCL directly; encapsulate with SvtGraphicFill 1652 impStartSvtGraphicFill(pSvtGraphicFill); 1653 mpOutputDevice->DrawGradient(aToolsPolyPolygon, aVCLGradient); 1654 impEndSvtGraphicFill(pSvtGraphicFill); 1655 | |
1656 break; 1657 } 1658 case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D : 1659 { 1660 const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate)); 1661 basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon()); 1662 1663 // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points --- 491 unchanged lines hidden --- | 1651 break; 1652 } 1653 case PRIMITIVE2D_ID_POLYPOLYGONCOLORPRIMITIVE2D : 1654 { 1655 const primitive2d::PolyPolygonColorPrimitive2D& rPolygonCandidate(static_cast< const primitive2d::PolyPolygonColorPrimitive2D& >(rCandidate)); 1656 basegfx::B2DPolyPolygon aLocalPolyPolygon(rPolygonCandidate.getB2DPolyPolygon()); 1657 1658 // #i112245# Metafiles use tools Polygon and are not able to have more than 65535 points --- 491 unchanged lines hidden --- |