{

// ReSharper disable once CppInconsistentNaming

pshPixel = 0,

// ReSharper disable once CppInconsistentNaming

pshEllipse = 1,

// ReSharper disable once CppInconsistentNaming

pshPolygon = 2,

// ReSharper disable once CppInconsistentNaming

pshPicture = 3,

// ReSharper disable once CppInconsistentNaming

pshCharacter = 4,

{

if (!sf) return false;

_shapefile = dynamic_cast<CShapefile*>(sf);

FILE* file = static_cast<CShapefile*>(sf)->get_File();

#ifdef USE_TIMER

CTimer tmr;

tmr.Init("c:\\mw_output.txt");

tmr.Start();

tmr.PrintTime("Before bounds");

#endif

// -------------------------------------------------------

// check bounds

// -------------------------------------------------------

double zMin, zMax;

IExtents* box = nullptr;

sf->get_Extents(&box);

box->GetBounds(&_xMin, &_yMin, &zMin, &_xMax, &_yMax, &zMax);

box->Release();

box = nullptr;

if (_xMin > _extents->right || _xMax<_extents->left || _yMin>_extents->top || _yMax < _extents->bottom)

return false;

#ifdef USE_TIMER

tmr.PrintTime("After bounds");

#endif

// --------------------------------------------------------

// reading shapefile properties

// --------------------------------------------------------

long numShapes;

VARIANT_BOOL useQTree;

VARIANT_BOOL useSpatialIndex;

VARIANT_BOOL hasSpatialIndex;

tkSelectionAppearance selectionAppearance;

_shapefile->get_SelectionAppearance(&selectionAppearance);

_shapefile->get_FastMode(&_fastMode);

_shapefile->get_ShapefileType(&_shptype);

_shapefile->get_NumShapes(&numShapes);

_shapefile->get_EditingShapes(&_isEditing);

_shapefile->get_UseQTree(&useQTree);

_shapefile->get_UseSpatialIndex(&useSpatialIndex);

_shapefile->get_HasSpatialIndex(&hasSpatialIndex);

useSpatialIndex = (useSpatialIndex && hasSpatialIndex);

// get 2D type for not checking it afterwards

_shptype = ShapeUtility::Convert2D(_shptype);

// clearing the paths

_vertexPathes.clear();

#ifdef USE_TIMER

tmr.PrintTime("Before reading drawing options");

#endif

// --------------------------------------------------------

// acquiring drawing options

// --------------------------------------------------------

// default options

IShapeDrawingOptions* iDefOpt = nullptr;

_shapefile->get_DefaultDrawingOptions(&iDefOpt);

CDrawingOptionsEx* defaultOptions = ((CShapeDrawingOptions*)iDefOpt)->get_UnderlyingOptions();

iDefOpt->Release(); iDefOpt = nullptr;

// selection options

CDrawingOptionsEx* selectionOptions = nullptr;

if (selectionAppearance == saDrawingOptions)

{

IShapeDrawingOptions* iSelOpt = nullptr;

_shapefile->get_SelectionDrawingOptions(&iSelOpt);

selectionOptions = ((CShapeDrawingOptions*)iSelOpt)->get_UnderlyingOptions();

iSelOpt->Release(); iSelOpt = nullptr;

}

else

{

// a default options will be used with drawing transparent selection on top of it

OLE_COLOR color;

unsigned char transp;

selectionOptions = defaultOptions;

_shapefile->get_SelectionColor(&color);

_shapefile->get_SelectionTransparency(&transp);

m_selectionColor = color;

m_selectionTransparency = transp;

}

// categories

IShapefileCategories* icategories = nullptr;

_shapefile->get_Categories(&icategories);

CShapefileCategories* categories = (CShapefileCategories*)icategories;

icategories->Release();

#ifdef USE_TIMER

tmr.PrintTime("Before reading drawing options");

#endif

// --------------------------------------------------------

// Settings DC/graphics options

// --------------------------------------------------------

int* qtreeResult = nullptr; // results of quad tree selection

vector<long>* selectResult = nullptr; // results of spatial index selection

int offset; // position (number) of a shape in the shapefile

// --------------------------------------------------------

// Reading from disk

// --------------------------------------------------------

if (!_isEditing)

{

if (file == nullptr)

{

CallbackHelper::AssertionFailed("Shapefile rendering: file doesn't exist.");

return false;

}

CComBSTR fname;

sf->get_Filename(&fname);

CCriticalSection* readLock = ((CShapefile*)sf)->get_ReadLock();

// reading index

USES_CONVERSION;

_sfReader = new CShapefileReader();

if (!_sfReader->ReadShapefileIndex(OLE2W(fname), file, readLock))

{

delete _sfReader;

_sfReader = nullptr;

return false;

}

// ---------------------------------------------------------

// extracting shapes from spatial index

// ---------------------------------------------------------

if (useSpatialIndex)

{

selectResult = SelectShapesFromSpatialIndex(OLE2A(fname), _extents); // TODO: use Unicode

if (!selectResult)

{

useSpatialIndex = VARIANT_FALSE;

}

else

{

numShapes = selectResult->size();

sort(selectResult->begin(), selectResult->end());

}

}

}

#ifdef USE_TIMER

tmr.PrintTime("After reading shape index");

#endif

long numCategories;

categories->get_Count(&numCategories);

std::vector<vector<int>> categoryIndices;

std::vector<vector<int>> categorySelIndices; // used for selectionAppearance == saSelectionColor only

categoryIndices.resize(numCategories + 2); // +1 = default options; +2 = selection options

categorySelIndices.resize(numCategories + 1); // +1 = default options;

// --------------------------------------------------------------

// Analyzing visibility expression

// --------------------------------------------------------------

std::vector<long> arr;

CStringW err;

bool useAll = true;

CComBSTR expr;

_shapefile->get_VisibilityExpression(&expr);

if (SysStringLen(expr) > 0)

{

CComPtr<ITable> tbl = nullptr;

_shapefile->get_Table(&tbl);

USES_CONVERSION;

if (TableHelper::Cast(tbl)->QueryCore(OLE2CW(expr), arr, err))

{

useAll = false;

}

}

// --------------------------------------------------------------

// Extracting shapes using quad tree

// --------------------------------------------------------------

if (useQTree & _isEditing)

{

int shapesCount;

IExtents* bBox = nullptr;

ComHelper::CreateExtents(&bBox);

bBox->SetBounds(_extents->left, _extents->bottom, 0, _extents->right, _extents->top, 0);

dynamic_cast<CShapefile*>(sf)->QuickQueryInEditMode(bBox, &qtreeResult, &shapesCount);

if (qtreeResult == nullptr)

{

bBox->Release(); bBox = nullptr;

goto cleaning;

}

numShapes = (long)shapesCount;

}

// --------------------------------------------------------------------

// nullify the screen size of all shapes

// the size is used to choose whether to draw labels and charts or not

// --------------------------------------------------------------------

_shapeData = _shapefile->get_ShapeVector();

if (_shptype == SHP_POLYGON || _shptype == SHP_POLYLINE)

{

int size = _shapeData->size();

for (int i = 0; i < size; i++)

{

(*_shapeData)[i]->size = 0;

(*_shapeData)[i]->isVisible(false);

}

}

else if (_shptype == SHP_POINT)

{

// Since there may be (tens of) thousands of shapes,

// I don't want to check for rotation field specifications

// and field indices on each iteration; so instead, I am

// checking once for field specification and index, and

// then iterating shapes to set rotation-specific values.

// NOTE: the following is superceded by the rotationExpression

// is a Rotation field specified ?

//if (defaultOptions->rotationField.GetLength() > 0)

//{

// long idx;

// CComBSTR bstrName(defaultOptions->rotationField);

// _shapefile->get_FieldIndexByName(bstrName, &idx);

// // iterate shapes, set rotation based on field value

// // NOTE that this uses the existing 'rotation' field,

// // and thus takes precedence over options-based rotation

// for (long i = 0; i < (long)_shapeData->size(); i++)

// {

// VARIANT rotation;

// _shapefile->get_CellValue(idx, i, &rotation);

// (*_shapeData)[i]->rotation = rotation.dblVal;

// }

//}

}

// --------------------------------------------------------------

// Building lists of shape indices for each category

// --------------------------------------------------------------

unsigned int k = 0; // position in arr of visible shapes

for (int i = 0; i < (int)numShapes; i++)

{

if (useQTree && _isEditing)

{

offset = qtreeResult[i];

}

else

{

if (!_isEditing && useSpatialIndex)

{

offset = (*selectResult)[i] - 1;

}

else

{

offset = i;

}

}

// searching the index

if (!useAll)

{

bool stop = false;

//empty list?

if (arr.size() <= 0) {

stop = true;

}

else

{

//determine if the shape is visible

while (arr[k] < offset)

{

k++;

if (k >= arr.size())

{

stop = true;

break;

}

}

}

// there can't be any visible shapes

if (stop)

{

break;

}

// missing this shape, because it complies with the expression

if (arr[k] > offset)

{

continue;

}

}

if (offset >= (int)_shapeData->size())

{

// TODO: is is possible to check that the index has the same number of shapes as shapefile?

if (!_isEditing && useSpatialIndex) {

CallbackHelper::ErrorMsg("Invalid spatial index. Index of shape is outside bounds.");

}

else {

CallbackHelper::ErrorMsg("Shapefile drawing: index of shape is outside bounds.");

}

break;

}

// whether it was hidden explicitly by user

if ((*_shapeData)[offset]->hidden()) {

continue;

}

// marking shape as visible; it may still fall out of extents but it is inefficient to test it here

(*_shapeData)[offset]->isVisible(true);

bool selected = (*_shapeData)[offset]->selected();

if (selected)

{

if (selectionAppearance == saDrawingOptions)

{

categoryIndices[numCategories + 1].push_back(offset); // selection options

}

else

{

long catIndex = (*_shapeData)[offset]->category;

if (catIndex < 0 || catIndex >= numCategories)

{

categorySelIndices[numCategories].push_back(offset); // default options

}

else

{

categorySelIndices[catIndex].push_back(offset); // category

}

}

}

else

{

long catIndex = (*_shapeData)[offset]->category;

if (catIndex < 0 || catIndex >= numCategories)

{

categoryIndices[numCategories].push_back(offset); // default options

}

else

{

categoryIndices[catIndex].push_back(offset); // category

// TODO: check whether the drawing options are different from default

}

}

}

// -----------------------------------------------------

// Drawing

// -----------------------------------------------------

CDrawingOptionsEx* options = nullptr;

#ifdef USE_TIMER

tmr.PrintTime("Before reading data");

#endif

// in some cases selected objects should be drawn first

bool selectionFirst = false;

if (_shptype == SHP_POINT || _shptype == SHP_MULTIPOINT)

{

tkCollisionMode mode;

sf->get_CollisionMode(&mode);

if (mode != AllowCollisions)

{

selectionFirst = true;

}

}

// drawing selection at the bottom

if (selectionFirst)

{

if (selectionAppearance == saSelectionColor)

{

for (int i = categorySelIndices.size() - 1; i >= 0; i--)

{

if (i == numCategories)

{

options = defaultOptions;

}

else if (i < numCategories)

{

options = ((CShapefileCategories*)categories)->get_UnderlyingOptions(i);

}

std::vector<int>* indices = &categorySelIndices[i];

this->DrawCategory(options, indices, true);

}

}

else // selection drawing options

{

options = selectionOptions;

std::vector<int>* indices = &categoryIndices[numCategories + 1];

this->DrawCategory(options, indices, false); // false: options set in the selection itself so no need to draw it on top

}

}

// drawing unselected shapes

for (int i = categoryIndices.size() - 2; i >= 0; i--)

{

if (i == numCategories)

{

options = defaultOptions;

}

else if (i < numCategories)

{

options = ((CShapefileCategories*)categories)->get_UnderlyingOptions(i);

}

else

{

CallbackHelper::AssertionFailed("Drawing options for category aren't found.");

}

std::vector<int>* indices = &categoryIndices[i];

this->DrawCategory(options, indices, false);

}

// drawing selection at the top

if (!selectionFirst)

{

if (selectionAppearance == saSelectionColor)

{

for (int i = categorySelIndices.size() - 1; i >= 0; i--)

{

if (i == numCategories)

{

options = defaultOptions;

}

else if (i < numCategories)

{

options = ((CShapefileCategories*)categories)->get_UnderlyingOptions(i);

}

std::vector<int>* indices = &categorySelIndices[i];

this->DrawCategory(options, indices, true);

}

}

else

{

options = selectionOptions;

std::vector<int>* indices = &categoryIndices[numCategories + 1];

this->DrawCategory(options, indices, false); // false: options set in the selection itself so no need to draw it on top

}

}

// drawing the vertices

for (unsigned int i = 0; i < _vertexPathes.size(); i++)

{

DrawVertices(_vertexPathes[i].path, _vertexPathes[i].options);

}

// clearing paths

for (unsigned int i = 0; i < _vertexPathes.size(); i++)

{

delete _vertexPathes[i].path;

}

#ifdef USE_TIMER

tmr.PrintTime("After drawing");

tmr.Stop();

#endif

// ------------------------------------------

// final cleaning

// ------------------------------------------

cleaning:

if (!_isEditing)

{

delete _sfReader;

_sfReader = nullptr;

}

if (useQTree)

{

// make sure it was allocated

if (qtreeResult)

{

delete[] qtreeResult;

}

}

else

{

if (useSpatialIndex && selectResult)

{

selectResult->clear();

delete selectResult;

selectResult = nullptr;

}

}

return true;

{

if (indices->size() == 0)

return;

if ((!options->visible) || (!options->fillVisible && !options->linesVisible && !options->verticesVisible))

{

return;

}

if (!options->IsVisible(this->_scale, this->_currentZoom))

return;

if (_shptype == SHP_POINT || _shptype == SHP_MULTIPOINT)

options->_shpType = tkSimpleShapeType::shpPoint;

else if (_shptype == SHP_POLYLINE)

options->_shpType = tkSimpleShapeType::shpPolyline;

else if (_shptype == SHP_POLYGON)

options->_shpType = tkSimpleShapeType::shpPolygon;

else

options->_shpType = tkSimpleShapeType::shpNone;

options->scale = this->_scale;

// ----------------------------------------------------

// auto selecting the fastest drawing mode

// for the current set of options

// ----------------------------------------------------

if (options->lineWidth == 1.0f && options->lineTransparency == 255 && options->linesVisible)

{

options->drawingMode = vdmGDIMixed;

}

else

{

options->drawingMode = vdmGDIPlus;

}

if (options->pointSymbolType == ptSymbolFontCharacter || options->pointSymbolType == ptSymbolPicture)

{

options->drawingMode = vdmGDIPlus;

}

// circles look more neat in GDI+

if (options->pointSymbolType == ptSymbolStandard && options->pointShapeType == ptShapeCircle)

{

options->drawingMode = vdmGDIPlus;

}

if (_forceGdiplus)

{

options->drawingMode = vdmGDIPlus;

}

if (_dc)

{

_dc->SetBkColor(options->fillBgColor);

if (options->fillBgTransparent)

{

_dc->SetBkMode(TRANSPARENT);

}

else

{

_dc->SetBkMode(OPAQUE);

}

}

// ------------------------------------------------

// perform drawing

// ------------------------------------------------

if (_shptype == SHP_POINT || _shptype == SHP_MULTIPOINT)

{

this->DrawPointCategory(options, indices, drawSelection);

}

else if (_shptype == SHP_POLYLINE || _shptype == SHP_POLYGON)

{

if (_shptype == SHP_POLYLINE && options->useLinePattern && options->CanUseLinePattern())

{

this->DrawLinePatternCategory(options, indices, drawSelection);

}

else

{

if (options->drawingMode == vdmGDIMixed && _shptype == SHP_POLYLINE)

{

this->DrawLineCategoryGDI(options, indices, drawSelection); // only lines are drawn here

}

else

{

this->DrawPolyCategory(options, indices, drawSelection);

}

}

}

{

long numShapes;

_shapefile->get_NumShapes(&numShapes);

visibilityMask.clear();

visibilityMask.resize(numShapes, false);

for (size_t i = 0; i < indices.size(); i++)

{

visibilityMask[indices[i]] = true;

}

{

IShapeWrapper* shp = nullptr;

tkDrawingShape pntShape;

GraphicsPath* path = nullptr;

GraphicsPath* path2 = nullptr; // for frame around character

float* data = nullptr;

Bitmap* bmPixel = nullptr;

int numPoints = 0;

int size = int(options->pointSize / 2.0);

OLE_COLOR pixelColor;

bool missingIcon = false;

if (options->pointSymbolType == ptSymbolPicture)

{

if (ImageHelper::IsEmpty(options->picture))

{

CallbackHelper::ErrorMsg("ShapeDrawingOptions.Picture is empty when icon for point is expected.");

missingIcon = true;

}

}

// creating a symbol to draw

if (options->pointSymbolType == ptSymbolStandard || missingIcon)

{

// receiving coordinates to define shape of symbol

if (options->pointSize <= 1.0)

{

pntShape = pshPixel;

pixelColor = options->linesVisible ? options->lineColor : options->fillColor;

}

else if (options->pointShapeType == ptShapeCircle)

{

pntShape = pshEllipse;

}

else

{

options->drawingMode = vdmGDIPlus; // GDI drawing will lead to rounding coordinates to integers, and distortions as a result

pntShape = pshPolygon;

// regular point rotation is set here

data = get_SimplePointShape(options->pointShapeType, options->pointSize, options->rotation, options->pointNumSides, options->pointShapeRatio, &numPoints);

if (!data)

return;

}

// GDI+ is used at least partially

if (options->drawingMode == vdmGDIPlus || options->drawingMode == vdmGDIMixed)

{

if (pntShape == pshEllipse)

{

options->InitGdiPlusBrush(&RectF(Gdiplus::REAL(-size), Gdiplus::REAL(-size), Gdiplus::REAL(options->pointSize), Gdiplus::REAL(options->pointSize)));

pntShape = pshEllipse;

path = new GraphicsPath();

path->StartFigure();

path->AddEllipse((Gdiplus::REAL)(-options->pointSize / 2.0), (Gdiplus::REAL)(-options->pointSize / 2.0), options->pointSize, options->pointSize);

path->CloseFigure();

}

else if (pntShape == pshPolygon)

{

options->InitGdiPlusBrush(&RectF(Gdiplus::REAL(-size), Gdiplus::REAL(-size), Gdiplus::REAL(options->pointSize), Gdiplus::REAL(options->pointSize)));

path = new GraphicsPath();

path->StartFigure();

path->AddLines(reinterpret_cast<Gdiplus::PointF*>(data), numPoints);

path->CloseFigure();

}

else if (pntShape == pshPixel && options->drawingMode == vdmGDIPlus)

{

bmPixel = new Bitmap(1, 1, _graphics);

long alpha = ((long)options->fillTransparency) << 24;

bmPixel->SetPixel(0, 0, Color(alpha | BGR_TO_RGB(pixelColor)));

}

}

// drawing with GDI

if (options->drawingMode == vdmGDI || options->drawingMode == vdmGDIMixed)

{

m_hdc = _graphics->GetHDC();

_dc = CDC::FromHandle(m_hdc);

if (pntShape != pshPixel)

options->InitGdiBrushAndPen(_dc);

}

}

else if (options->pointSymbolType == ptSymbolPicture)

{

options->InitGdiPlusPicture();

if (!options->bitmapPlus)

return;

pntShape = pshPicture;

}

else if (options->pointSymbolType == ptSymbolFontCharacter)

{

options->InitGdiPlusBrush(&RectF((Gdiplus::REAL)-size, (Gdiplus::REAL)-size, (Gdiplus::REAL)options->pointSize, (Gdiplus::REAL)options->pointSize));

m_hdc = _graphics->GetHDC();

_dc = CDC::FromHandle(m_hdc);

path = options->get_FontCharacterPath(_dc, false);

_graphics->ReleaseHDC(m_hdc);

_dc = nullptr;

Gdiplus::Matrix mtx;

mtx.Reset();

pntShape = pshPolygon;

}

// frame for a symbol

if (path && options->drawFrame)

{

path2 = options->GetFrameForPath(*path);

}

VARIANT_BOOL fastMode;

_shapefile->get_FastMode(&fastMode);

double x = 0, y = 0;

int shapeIndex;

tkCollisionMode collisionMode;

_shapefile->get_CollisionMode(&collisionMode);

// sorting

vector<long>* sorting;

((CShapefile*)_shapefile)->GetSorting(&sorting);

bool hasSorting = sorting != nullptr && sorting->size() > 0;

vector<bool> visibilityMask;

if (hasSorting) {

GetVisibilityMask(*indices, visibilityMask);

}

size_t numShapes = hasSorting ? visibilityMask.size() : indices->size();

for (int j = 0; j < (int)numShapes; j++)

{

if (hasSorting) {

shapeIndex = (*sorting)[j];

if (!visibilityMask[shapeIndex]) {

continue;

}

}

else {

shapeIndex = (*indices)[j];

}

// ------------------------------------------------------

// Reading point data

// ------------------------------------------------------

std::vector<PointWithId> points;

if (!_isEditing)

{

int recordLength;

char* data = _sfReader->ReadShapeData(shapeIndex, recordLength);

if (data)

{

if (_shptype == SHP_POINT)

{

x = *(double*)(data + 4); // 4 bytes on shape type

y = *(double*)(data + 12);

delete[] data;

points.push_back(PointWithId(x, y, shapeIndex));

}

else

{

PolygonData* pdata = _sfReader->ReadMultiPointData(data);

for (int i = 0; i < pdata->pointCount; i++)

{

x = pdata->points[i * 2];

y = pdata->points[i * 2 + 1];

points.push_back(PointWithId(x, y, shapeIndex));

}

delete pdata;

delete[] data;

}

}

else

continue;

}

else

{

shp = _shapefile->get_ShapeWrapper(shapeIndex);

if (!shp) continue;

for (int i = 0; i < shp->get_PointCount(); i++)

{

shp->get_PointXY(i, x, y);

points.push_back(PointWithId(x, y, shapeIndex));

}

}

for (size_t i = 0; i < points.size(); i++)

{

x = points[i].x;

y = points[i].y;

if (x > _extents->right || x < _extents->left || y > _extents->top || y < _extents->bottom) continue;

// ------------------------------------------------------

// Collision avoidance

// ------------------------------------------------------

int xInt = static_cast<int>((x - _extents->left) * _dx);

int yInt = static_cast<int>((_extents->top - y) * _dy);

// preventing point collision

if (!collisionMode == AllowCollisions)

{

CCollisionList* list = collisionMode == LocalList ? &_localCollisionList : _collisionList;

CRect* rect = nullptr;

if (options->pointSymbolType == ptSymbolPicture && options->picture != nullptr)

{

long width, height;

options->picture->get_Width(&width);

options->picture->get_Height(&height);

int wd = static_cast<int>((double)width * options->scaleX / 2.0);

int ht = static_cast<int>((double)height * options->scaleY / 2.0);

if (!options->alignIconByBottom)

{

rect = new CRect(xInt - wd, yInt - ht, xInt + wd, yInt + ht);

}

else

{

rect = new CRect(xInt - wd, yInt - ht * 2, xInt + wd, yInt);

}

}

else

{

rect = new CRect(xInt - int(options->pointSize / 2.0),

yInt - int(options->pointSize / 2.0),

xInt + int(options->pointSize / 2.0),

yInt + int(options->pointSize / 2.0));

}

if (list->HaveCollision(*rect) && _avoidCollisions)

{

delete rect;

continue;

}

else

{

(*_shapeData)[shapeIndex]->wasRendered(true);

list->AddRectangle(rect, 0, 0);

delete rect;

}

}

else

(*_shapeData)[shapeIndex]->wasRendered(true);

_shapeCount++;

// ------------------------------------------------------

// Drawing

// ------------------------------------------------------

if (pntShape == pshPixel)

{

if (drawSelection)

{

_dc->SetPixelV(xInt, yInt, m_selectionColor);

}

else

{

if (options->drawingMode == vdmGDIPlus)

{

_graphics->DrawImage(bmPixel, xInt, yInt);

}

else

{

_dc->SetPixelV(xInt, yInt, pixelColor);

}

}

(*_shapeData)[shapeIndex]->size = 1;

}

else if (pntShape == pshPicture)

{

Gdiplus::Matrix mtxInit;

_graphics->GetTransform(&mtxInit);

long width, height;

options->picture->get_Width(&width);

options->picture->get_Height(&height);

int wd = static_cast<int>((double)width * options->scaleX / 2.0);

int ht = static_cast<int>((double)height * options->scaleY / 2.0);

_graphics->TranslateTransform((float)(xInt), (float)(yInt));

// see if individual shape has a specified rotation

// (set either through shape rotation property, or from rotationExpression)

float angle = (float)((*_shapeData)[points[i].id])->rotation;

// if not set explicitly, try to grab it from category

if (angle == 0)

angle = (float)options->rotation;

// if any angle is specified, apply it

if (angle != 0)

_graphics->RotateTransform(angle);

// if reflecting

if (options->pointReflectionType != prtNone)

{

Gdiplus::Matrix flipMatrix;

// set up appropriate transformation

if (options->pointReflectionType == prtLeftToRight)

flipMatrix.SetElements(-1, 0, 0, 1, 0, 0);

else if (options->pointReflectionType == prtTopToBottom)