bool GiGraphics::beginPaint(GiCanvas* canvas, const RECT_2D& clipBox)
{
if (!canvas || m_impl->canvas || isStopping()) {
return false;
}
m_impl->canvas = canvas;
m_impl->ctxused = 0;
m_impl->stopping = 0;
float phase = fabsf(m_impl->phase);
m_impl->phase = (phase < 1e4f ? phase + 0.5f : 0.5f) * (m_impl->phase > 0 ? 1.f : -1.f);
if (m_impl->lastZoomTimes != xf().getZoomTimes()) {
m_impl->zoomChanged();
m_impl->lastZoomTimes = xf().getZoomTimes();
}
m_impl->clipBox0 = clipBox;
if (Box2d(clipBox).isEmpty()) {
xf().getWndRect().get(m_impl->clipBox0);
}
m_impl->clipBox = m_impl->clipBox0;
m_impl->rectDraw = m_impl->clipBox0;
m_impl->rectDraw.inflate(GiGraphicsImpl::CLIP_INFLATE);
m_impl->rectDrawM = Box2d(m_impl->rectDraw) * xf().displayToModel();
m_impl->rectDrawMaxM = xf().getWndRectM();
m_impl->rectDrawW = m_impl->rectDrawM * xf().modelToWorld();
m_impl->rectDrawMaxW = m_impl->rectDrawMaxM * xf().modelToWorld();
return true;
}
bool GiGraphics::setClipWorld(const Box2d& rectWorld)
{
bool ret = false;
if (isDrawing() && !rectWorld.isEmpty())
{
Box2d box (rectWorld * xf().worldToDisplay());
box.intersectWith(Box2d(m_impl->clipBox0));
if (!box.isEmpty(Tol(1, 0)))
{
if (box != Box2d(m_impl->clipBox))
{
box.get(m_impl->clipBox);
m_impl->rectDraw = box;
m_impl->rectDraw.inflate(GiGraphicsImpl::CLIP_INFLATE);
m_impl->rectDrawM = m_impl->rectDraw * xf().displayToModel();
m_impl->rectDrawW = m_impl->rectDrawM * xf().modelToWorld();
SafeCall(m_impl->canvas, _clipBoxChanged(m_impl->clipBox));
}
ret = true;
}
}
return ret;
}
bool GiGraphics::setClipBox(const RECT_2D& rc)
{
if (m_impl->drawRefcnt < 1)
return false;
bool ret = false;
Box2d rect;
if (!rect.intersectWith(Box2d(rc), Box2d(m_impl->clipBox0)).isEmpty())
{
if (rect != Box2d(m_impl->clipBox))
{
rect.get(m_impl->clipBox);
m_impl->rectDraw.set(Box2d(rc));
m_impl->rectDraw.inflate(GiGraphicsImpl::CLIP_INFLATE);
m_impl->rectDrawM = m_impl->rectDraw * xf().displayToModel();
m_impl->rectDrawW = m_impl->rectDrawM * xf().modelToWorld();
SafeCall(m_impl->canvas, clipRect(m_impl->clipBox.left, m_impl->clipBox.top,
m_impl->clipBox.width(),
m_impl->clipBox.height()));
}
ret = true;
}
return ret;
}
bool GiGraphics::beginPaint(GiCanvas* canvas, const RECT_2D& clipBox)
{
if (!canvas || m_impl->canvas || m_impl->drawRefcnt > 0) {
return false;
}
m_impl->canvas = canvas;
m_impl->ctxused = 0;
m_impl->stopping = 0;
giInterlockedIncrement(&m_impl->drawRefcnt);
if (m_impl->lastZoomTimes != xf().getZoomTimes()) {
m_impl->zoomChanged();
m_impl->lastZoomTimes = xf().getZoomTimes();
}
m_impl->clipBox0 = clipBox;
if (Box2d(clipBox).isEmpty()) {
(xf().getWndRectW() * xf().worldToDisplay()).get(m_impl->clipBox0);
}
m_impl->clipBox = m_impl->clipBox0;
m_impl->rectDraw = m_impl->clipBox0;
m_impl->rectDraw.inflate(GiGraphicsImpl::CLIP_INFLATE);
m_impl->rectDrawM = Box2d(m_impl->rectDraw) * xf().displayToModel();
m_impl->rectDrawMaxM = xf().getWndRectM();
m_impl->rectDrawW = m_impl->rectDrawM * xf().modelToWorld();
m_impl->rectDrawMaxW = m_impl->rectDrawMaxM * xf().modelToWorld();
return true;
}
bool GiCanvasGdi::drawImage(long hmWidth, long hmHeight, HBITMAP hbitmap,
const Box2d& rectW, bool fast)
{
BOOL ret = FALSE;
HDC hdc = m_draw->getDrawDC();
if (hdc != NULL && hmWidth > 0 && hmHeight > 0 && hbitmap != NULL
&& m_owner->getClipWorld().isIntersect(Box2d(rectW, true)))
{
RECT_2D clipBox;
RECT rc, rcDraw, rcFrom;
// rc: 整个图像对应的显示坐标区域
(rectW * xf().worldToDisplay()).get(rc);
// rcDraw: 图像经剪裁后的可显示部分
Box2d(gs()->getClipBox(clipBox)).get(rcFrom);
if (!IntersectRect(&rcDraw, &rc, &rcFrom))
return false;
long width, height; // pixel units
width = MulDiv(hmWidth, GetDeviceCaps(hdc, LOGPIXELSX), 2540);
height = MulDiv(hmHeight, GetDeviceCaps(hdc, LOGPIXELSY), 2540);
// rcFrom: rcDraw在原始图像上对应的图像范围
rcFrom.left = MulDiv(rcDraw.left - rc.left, width, rc.right - rc.left);
rcFrom.top = MulDiv(rcDraw.top - rc.top, height, rc.bottom - rc.top);
rcFrom.right = MulDiv(rcDraw.right - rc.left, width, rc.right - rc.left);
rcFrom.bottom = MulDiv(rcDraw.bottom - rc.top, height, rc.bottom - rc.top);
// 根据rectW正负决定是否颠倒显示图像
if (rectW.xmin > rectW.xmax)
mgSwap(rcDraw.left, rcDraw.right);
if (rectW.ymin > rectW.ymax)
mgSwap(rcDraw.top, rcDraw.bottom);
GiCompatibleDC memDC (hdc);
if (memDC == NULL)
return false;
KGDIObject bmp (memDC, hbitmap, false);
KGDIObject brush (hdc, ::GetStockObject(NULL_BRUSH), false);
int nBltMode = (!fast || m_owner->isPrint()) ? HALFTONE : COLORONCOLOR;
int nOldMode = ::SetStretchBltMode(hdc, nBltMode);
::SetBrushOrgEx(hdc, rcDraw.left % 8, rcDraw.top % 8, NULL);
ret = ::StretchBlt(hdc,
rcDraw.left, rcDraw.top,
rcDraw.right - rcDraw.left,
rcDraw.bottom - rcDraw.top,
memDC,
rcFrom.left, rcFrom.top,
rcFrom.right - rcFrom.left,
rcFrom.bottom - rcFrom.top,
SRCCOPY);
::SetStretchBltMode(hdc, nOldMode);
}
return ret ? true : false;
}
bool GiGraphics::drawBeziers(const GiContext* ctx, int count,
const Point2d* points, bool closed, bool modelUnit)
{
if (count < 4 || !points || isStopping())
return false;
if (count > 0x2000)
count = 0x2000;
count = 1 + (count - 1) / 3 * 3;
bool ret = false;
vector<Point2d> pxpoints;
vector<Point2d> pointBuf;
int i, j, n, si, ei;
Point2d * pxs;
Matrix2d matD(S2D(xf(), modelUnit));
const Box2d extent (count, points); // 模型坐标范围
if (!DRAW_RECT(m_impl, modelUnit).isIntersect(extent)) // 全部在显示区域外
return false;
if (closed) {
pxpoints.resize(count);
pxs = &pxpoints.front();
for (i = 0; i < count; i++)
pxs[i] = points[i] * matD;
ret = rawBeziers(ctx, pxs, count, closed);
}
else if (DRAW_MAXR(m_impl, modelUnit).contains(extent)) { // 全部在显示区域内
pxpoints.resize(count);
pxs = &pxpoints.front();
for (i = 0; i < count; i++)
pxs[i] = points[i] * matD;
ret = rawBeziers(ctx, pxs, count);
} else {
pointBuf.resize(count);
for (i = 0; i < count; i++) // 转换到像素坐标
pointBuf[i] = points[i] * matD;
Point2d* pts = &pointBuf.front();
for (i = 0; i + 3 < count;) {
for (; i + 3 < count && !m_impl->rectDraw.isIntersect(Box2d(4, &pts[i])); i += 3) ;
si = ei = i;
for (; i + 3 < count && m_impl->rectDraw.isIntersect(Box2d(4, &pts[i])); i += 3)
ei = i + 3;
if (ei > si) {
n = ei - si + 1;
pxpoints.resize(n);
pxs = &pxpoints.front();
for (j=0; j<n; j++)
pxs[j] = pts[si + j];
ret = rawBeziers(ctx, pxs, n);
}
}
}
return ret;
}
float MgEllipse::_hitTest(const Point2d& pt, float tol, MgHitResult& res) const
{
if (isCircle()) {
Point2d pt1(getCenter()), pt2(pt);
crossCircle(pt1, pt2, this);
float d1 = pt.distanceTo(pt1);
float d2 = pt.distanceTo(pt2);
res.nearpt = d1 < d2 ? pt1 : pt2;
return mgMin(d1, d2);
}
float distMin = _FLT_MAX;
const Box2d rect (pt, 2 * tol, 2 * tol);
Point2d ptTemp;
for (int i = 0; i < 4; i++) {
if (rect.isIntersect(Box2d(4, _bzpts + 3 * i))) {
mgnear::nearestOnBezier(pt, _bzpts + 3 * i, ptTemp);
float dist = pt.distanceTo(ptTemp);
if (dist <= tol && dist < distMin) {
distMin = dist;
res.nearpt = ptTemp;
res.segment = i;
}
}
}
return distMin;
}
MgShape* MgCmdManagerImpl::addImageShape(const MgMotion* sender,
const char* name, float width, float height)
{
if (!name || *name == 0 || width < 1 || height < 1)
return NULL;
Vector2d size(Vector2d(width, height) * sender->view->xform()->displayToWorld());
while (fabsf(size.x) > 200.f || fabsf(size.y) > 200.f) {
size *= 0.95f;
}
Box2d rect(sender->view->xform()->getWndRectW() + Vector2d(10.f, -10.f));
rect = Box2d(rect.leftTop(), rect.leftTop() + size);
rect *= sender->view->xform()->worldToModel();
MgShapeT<MgImageShape> shape;
MgImageShape* imagesp = (MgImageShape*)shape.shape();
shape.context()->setLineStyle(kGiLineNull); // 默认没有边框
shape.context()->setFillColor(GiColor::White()); // 设为实填充，避免在中心无法点中
imagesp->setName(name);
imagesp->setRect2P(rect.leftTop(), rect.rightBottom());
MgShapesLock locker(MgShapesLock::Add, sender->view);
if (sender->view->shapeWillAdded(&shape)) {
MgShape* newsp = sender->view->shapes()->addShape(shape);
sender->view->shapeAdded(newsp);
sender->view->setNewShapeID(newsp->getID());
sender->view->cancel(sender);
return newsp;
}
return NULL;
}
float MgEllipse::_hitTest(const Point2d& pt, float tol,
Point2d& nearpt, int& segment) const
{
float distMin = _FLT_MAX;
const Box2d rect (pt, 2 * tol, 2 * tol);
Point2d ptTemp;
segment = -1;
for (int i = 0; i < 4; i++)
{
if (rect.isIntersect(Box2d(4, _bzpts + 3 * i)))
{
mgNearestOnBezier(pt, _bzpts + 3 * i, ptTemp);
float dist = pt.distanceTo(ptTemp);
if (dist <= tol && dist < distMin)
{
distMin = dist;
nearpt = ptTemp;
segment = i;
}
}
}
return distMin;
}
Box2d GiTransform::setWorldLimits(const Box2d& rect)
{
Box2d ret = m_impl->rectLimitsW;
m_impl->rectLimitsW = rect.isEmpty() ? Box2d(Point2d::kOrigin(), 2e5f, 2e5f) : rect;
m_impl->rectLimitsW.normalize();
return ret;
}
inline
Box2d
Circle2d::bounds() const {
return Box2d(
Interval(centerPoint().x() - radius(), centerPoint().x() + radius()),
Interval(centerPoint().y() - radius(), centerPoint().y() + radius())
);
}
bool GiCoreView::zoomToModel(float x, float y, float w, float h)
{
Box2d rect(Box2d(x, y, x + w, y + h) * impl->xform()->modelToWorld());
bool ret = impl->xform()->zoomTo(rect);
if (ret) {
impl->regenAll();
}
return ret;
}
void MgEllipse::setRadius(float rx, float ry)
{
rx = fabs(rx);
rx = fabs(ry);
if (rx < _MGZERO)
rx = rx;
setRect(Box2d(getCenter(), rx * 2, ry * 2), getAngle());
}
bool drawHandle(GiGraphics* gs, const Point2d& pnt, bool hotdot)
{
GiContext ctx(0, GiColor::Black(), kGiLineSolid,
GiColor(240, 240, 240, hotdot ? 200 : 128));
bool old = gs->setAntiAliasMode(false);
gs->drawRect(&ctx, Box2d(pnt, gs->xf().displayToModel(hotdot ? 3.f : 1.5f, true), 0));
gs->setAntiAliasMode(old);
return true;
}
bool GiCanvasGdipImpl::drawImage(G::Bitmap* pBmp, const Box2d& rectW, bool fast)
{
RECT_2D rc, rcDraw, rcFrom;
Box2d rect;
float width = (float)pBmp->GetWidth();
float height = (float)pBmp->GetHeight();
// rc: 整个图像对应的显示坐标区域
(rectW * gs()->xf().worldToDisplay()).get(rc);
// rcDraw: 图像经剪裁后的可显示部分
gs()->getClipBox(rcDraw);
if (rect.intersectWith(Box2d(rc), Box2d(rcDraw)).isEmpty())
return false;
rect.get(rcDraw);
// rcFrom: rcDraw在原始图像上对应的图像范围
rcFrom.left = (rcDraw.left - rc.left) * width / (rc.right - rc.left);
rcFrom.top = (rcDraw.top - rc.top) * height / (rc.bottom - rc.top);
rcFrom.right = (rcDraw.right - rc.left) * width / (rc.right - rc.left);
rcFrom.bottom = (rcDraw.bottom - rc.top) * height / (rc.bottom - rc.top);
// 根据rectW正负决定是否颠倒显示图像
if (rectW.xmin > rectW.xmax)
mgSwap(rcDraw.left, rcDraw.right);
if (rectW.ymin > rectW.ymax)
mgSwap(rcDraw.top, rcDraw.bottom);
G::InterpolationMode nOldMode = getDrawGs()->GetInterpolationMode();
getDrawGs()->SetInterpolationMode( (!fast || gs()->isPrint())
? G::InterpolationModeBilinear : G::InterpolationModeLowQuality);
G::Status ret = getDrawGs()->DrawImage(pBmp,
G::RectF(rcDraw.left, rcDraw.top,
rcDraw.right - rcDraw.left,
rcDraw.bottom - rcDraw.top),
rcFrom.left, rcFrom.top,
rcFrom.right - rcFrom.left,
rcFrom.bottom - rcFrom.top,
G::UnitPixel);
getDrawGs()->SetInterpolationMode(nOldMode);
return G::Ok == ret;
}
bool GiGraphics::drawBeziers(const GiContext* ctx, int count,
const Point2d* points, bool modelUnit)
{
if (m_impl->drawRefcnt == 0 || count < 4 || points == NULL)
return false;
GiLock lock (&m_impl->drawRefcnt);
if (count > 0x2000)
count = 0x2000;
count = 1 + (count - 1) / 3 * 3;
bool ret = false;
vector<Point2d> pxpoints;
vector<Point2d> pointBuf;
int i, j, n, si, ei;
Point2d * pxs;
Matrix2d matD(S2D(xf(), modelUnit));
const Box2d extent (count, points); // 模型坐标范围
if (!DRAW_RECT(m_impl, modelUnit).isIntersect(extent)) // 全部在显示区域外
return false;
if (DRAW_MAXR(m_impl, modelUnit).contains(extent)) // 全部在显示区域内
{
pxpoints.resize(count);
pxs = &pxpoints.front();
for (i = 0; i < count; i++)
pxs[i] = points[i] * matD;
ret = rawBeziers(ctx, pxs, count);
}
else
{
pointBuf.resize(count);
for (i = 0; i < count; i++) // 转换到像素坐标
pointBuf[i] = points[i] * matD;
Point2d* pts = &pointBuf.front();
si = ei = 0;
for (i = 3; i < count; i += 3)
{
for ( ; i < count
&& m_impl->rectDraw.isIntersect(Box2d(4, &pts[ei])); i += 3)
ei = i;
n = ei - si + 1;
if (n > 1)
{
pxpoints.resize(n);
pxs = &pxpoints.front();
for (j=0; j<n; j++)
pxs[j] = pts[si + j];
ret = rawBeziers(ctx, pxs, n);
}
si = ei = i;
}
}
return ret;
}
void CScrollShapeView::OnZoomed()
{
CRandomShapeView::OnZoomed();
Box2d rect;
// m_rcLimits: 极限范围对应的坐标范围, 像素
rect = m_shapes->getExtent() * m_graph->xf.modelToDisplay();
rect.inflate(1, 1);
rect.get(m_rcLimits);
// m_rcScrWnd: 当前窗口对应的坐标范围, 像素
rect = Box2d(m_graph->xf.getCenterW(),
m_graph->xf.getWidth() / m_graph->xf.getWorldToDisplayX(),
m_graph->xf.getHeight() / m_graph->xf.getWorldToDisplayY());
rect *= m_graph->xf.worldToDisplay();
rect.get(m_rcScrWnd);
// 以m_rcLimits左上角为原点调整m_rcScrWnd和m_rcLimits
::OffsetRect(&m_rcScrWnd, -m_rcLimits.left, -m_rcLimits.top);
::OffsetRect(&m_rcLimits, -m_rcLimits.left, -m_rcLimits.top);
// 避免m_rcScrWnd部分超出m_rcLimits
::UnionRect(&m_rcLimits, &m_rcLimits, &m_rcScrWnd);
SCROLLINFO si;
si.cbSize = sizeof(si);
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
si.nMin = 0;
if (m_rcLimits.right - m_rcLimits.left > m_rcScrWnd.right - m_rcScrWnd.left)
{
si.nMax = max(1, m_rcLimits.right - m_rcLimits.left);
si.nPage = m_rcScrWnd.right - m_rcScrWnd.left;
si.nPos = m_rcScrWnd.left;
::EnableScrollBar(m_hWnd, SB_HORZ, ESB_ENABLE_BOTH);
::SetScrollInfo(m_hWnd, SB_HORZ, &si, TRUE);
}
else
{
::EnableScrollBar(m_hWnd, SB_HORZ, ESB_DISABLE_BOTH);
}
if (m_rcLimits.bottom - m_rcLimits.top > m_rcScrWnd.bottom - m_rcScrWnd.top)
{
si.nMax = max(1, m_rcLimits.bottom - m_rcLimits.top);
si.nPage = m_rcScrWnd.bottom - m_rcScrWnd.top;
si.nPos = m_rcScrWnd.top;
::EnableScrollBar(m_hWnd, SB_VERT, ESB_ENABLE_BOTH);
::SetScrollInfo(m_hWnd, SB_VERT, &si, TRUE);
}
else
{
::EnableScrollBar(m_hWnd, SB_VERT, ESB_DISABLE_BOTH);
}
}
void GiCanvasGdi::clearWindow()
{
if (!m_owner->isPrint() && m_owner->isDrawing())
{
RECT rc;
RECT_2D clipBox;
Box2d(gs()->getClipBox(clipBox)).get(rc);
ExtTextOut(m_draw->getDrawDC(), 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL);
}
}
virtual bool processLine(int, int&, const Point2d& startpt, const Point2d& endpt) {
if (box.contains(Box2d(startpt, endpt))
&& mglnrel::cross2Line(startpt, endpt, a, b, tmpcross)) {
dist = tmpcross.distanceTo(box.center());
if (mindist > dist) {
mindist = dist;
crosspt = tmpcross;
}
}
return true;
}
bool GiCanvasGdip::drawGdipImage(LPVOID pBmp, const Box2d& rectW, bool fast)
{
bool ret = false;
if (m_draw->getDrawGs() != NULL && pBmp != NULL
&& gs()->getClipWorld().isIntersect(Box2d(rectW, true)))
{
ret = m_draw->drawImage((G::Bitmap*)pBmp, rectW, fast);
}
return ret;
}
bool GiCanvasGdi::beginPaint(HDC hdc, HDC attribDC, bool buffered, bool overlay)
{
bool ret = (NULL == m_draw->m_hdc)
&& GiCanvasWin::beginPaint(hdc, attribDC, buffered, overlay);
if (!ret)
return false;
buffered = buffered && !m_owner->isPrint();
m_draw->m_hdc = hdc;
GdiCachedBmp oldDrawing;
if (buffered && overlay)
oldDrawing.saveCachedBitmap(m_draw, hdc);
if (buffered)
{
if ((m_draw->m_buffDC = ::CreateCompatibleDC(hdc)) != NULL)
{
RECT rc;
RECT_2D clipBox;
Box2d(gs()->getClipBox(clipBox)).get(rc);
m_draw->m_buffBmp = ::CreateCompatibleBitmap(hdc,
rc.right - rc.left, rc.bottom - rc.top);
if (m_draw->m_buffBmp == NULL)
{
::DeleteDC(m_draw->m_buffDC);
m_draw->m_buffDC = NULL;
}
else
{
::OffsetViewportOrgEx(m_draw->m_buffDC, -rc.left, -rc.top, NULL);
m_draw->m_buffOldBmp = ::SelectObject(
m_draw->m_buffDC, m_draw->m_buffBmp);
::SetBrushOrgEx(m_draw->m_buffDC, rc.left % 8, rc.top % 8, NULL);
::IntersectClipRect(m_draw->m_buffDC,
rc.left, rc.top, rc.right, rc.bottom);
::SetBkColor(m_draw->m_buffDC, ::GetBkColor(hdc));
}
}
oldDrawing.draw(m_draw, m_draw->m_buffDC);
}
::SetBkMode(m_draw->getDrawDC(), TRANSPARENT);
// 设置折线斜接连接的最小夹角为60度
::SetMiterLimit(m_draw->getDrawDC(),
static_cast<float>(1.0 / sin(_M_PI_6)), NULL);
return ret;
}
bool MgParallel::_hitTestBox(const Box2d& rect) const
{
if (!__super::_hitTestBox(rect))
return false;
for (int i = 0; i < 4; i++) {
if (Box2d(_points[i], _points[(i + 1) % 4]).isIntersect(rect))
return true;
}
return false;
}
bool MgDiamond::_hitTestBox(const Box2d& rect) const
{
if (!__super::_hitTestBox(rect))
return false;
for (int i = 0; i < 3; i++) {
if (Box2d(_getHandlePoint(i), _getHandlePoint(i + 1)).isIntersect(rect))
return true;
}
return false;
}
bool MgBaseRect::_hitTestBox(const Box2d& rect) const
{
if (!__super::_hitTestBox(rect))
return false;
for (int i = 0; i < 3; i++) {
if (Box2d(_points[i], _points[i + 1]).isIntersect(rect))
return true;
}
return false;
}
bool MgBaseLines::_hitTestBox(const Box2d& rect) const
{
if (!__super::_hitTestBox(rect))
return false;
for (UInt32 i = 0; i + 1 < _count; i++) {
if (Box2d(_points[i], _points[i + 1]).isIntersect(rect))
return true;
}
return _count < 2;
}
void GiGraphics::_beginPaint(const RECT2D& clipBox)
{
if (m_impl->lastZoomTimes != xf().getZoomTimes())
{
m_impl->zoomChanged();
m_impl->lastZoomTimes = xf().getZoomTimes();
}
giInterlockedIncrement(&m_impl->drawRefcnt);
if (!Box2d(clipBox).isEmpty())
{
m_impl->clipBox0 = clipBox;
m_impl->clipBox = clipBox;
m_impl->rectDraw = Box2d(clipBox);
m_impl->rectDraw.inflate(GiGraphicsImpl::CLIP_INFLATE);
m_impl->rectDrawM = m_impl->rectDraw * xf().displayToModel();
m_impl->rectDrawMaxM = Box2d(0, 0, xf().getWidth(), xf().getHeight()) * xf().displayToModel();
m_impl->rectDrawW = m_impl->rectDrawM * xf().modelToWorld();
m_impl->rectDrawMaxW = m_impl->rectDrawMaxM * xf().modelToWorld();
}
}
bool GiGraphics::drawLine(const GiContext* ctx, const Point2d& startPt,
const Point2d& endPt, bool modelUnit)
{
if (!DRAW_RECT(m_impl, modelUnit).isIntersect(Box2d(startPt, endPt)))
return false;
Point2d pts[2] = { startPt * S2D(xf(), modelUnit), endPt * S2D(xf(), modelUnit) };
if (!mglnrel::clipLine(pts[0], pts[1], m_impl->rectDraw))
return false;
return rawLine(ctx, pts[0].x, pts[0].y, pts[1].x, pts[1].y);
}
float MgRoundRect::_hitTest(const Point2d& pt, float tol,
Point2d& nearpt, Int32& segment) const
{
float dist;
if (isOrtho())
{
dist = mgRoundRectHit(Box2d(_points[0], _points[2]), _rx, _ry, pt, tol, nearpt, segment);
}
else
{
Matrix2d mat(Matrix2d::rotation(getAngle(), getCenter()));
Box2d rect(Box2d(pt, 2 * tol, 2 * tol) * mat.inverse());
dist = mgRoundRectHit(getRect(), _rx, _ry,
rect.center(), rect.width(), nearpt, segment);
if (dist < 1e10)
nearpt *= mat;
}
return dist;
}
bool MgBaseRect::_setHandlePoint(UInt32 index, const Point2d& pt, float)
{
if (index < 4 && getFlag(kMgSquare)) {
Point2d basept(getCenter());
Point2d pt2(pt * Matrix2d::rotation(-getAngle(), basept));
setRect(basept * 2.f - pt2.asVector(), pt2, getAngle(), basept);
}
else {
Point2d pt2(pt * Matrix2d::rotation(-getAngle(), getCenter()));
Box2d rect(getRect());
mgMoveRectHandle(rect, index, pt2);
if (getFlag(kMgSquare) && (4 == index || 6 == index)) {
rect = Box2d(rect.center(), rect.height(), rect.height());
}
else if (getFlag(kMgSquare)) {
rect = Box2d(rect.center(), rect.width(), rect.width());
}
setRect(rect.leftTop(), rect.rightBottom(), getAngle(), getCenter());
}
update();
return true;
}
bool MgCmdManagerImpl::cancel(const MgMotion* sender)
{
clearSnap();
int actions[] = { 0 };
sender->view->showContextActions(0, actions, Box2d(), NULL);
CMDS::iterator it = _cmds.find(_cmdname);
if (it != _cmds.end()) {
return it->second->cancel(sender);
}
return false;
}
