//
/// Paints a 2-color single pixel-thick frame. Bevel corners get their own color.
//
void
TUIBorder::PaintFrameC(TDC& dc, const TRect& fr, uint flags, const TColor& tlColor, const TColor& brColor, const TColor& bcColor)
{
if (flags & (Top | Left)) {
TBrush brsh(tlColor);
dc.SelectObject(brsh);
if (flags & Top) {
dc.PatBlt(fr.left, fr.top, fr.Width()-2, 1);
dc.SetPixel(fr.right-1, fr.top, bcColor);
}
if (flags & Left)
dc.PatBlt(fr.left, fr.top+1, 1, fr.Height()-2);
dc.RestoreBrush();
}
if (flags & (Bottom | Right)) {
TBrush brsh(brColor);
dc.SelectObject(brsh);
if (flags & Bottom) {
dc.SetPixel(fr.left, fr.bottom-1, bcColor);
dc.PatBlt(fr.left+1, fr.bottom-1, fr.Width(), 1);
}
if (flags & Right)
dc.PatBlt(fr.right-1, fr.top, 1, fr.Height()-1);
dc.RestoreBrush();
}
}
void CCJKShapeLine::DrawArrow(QPainter *painter, ArrowTypeFlag arrowType, const QPointF &p, const QPointF &p1, const QPointF &p2, qreal arrowSize)
{
CJK_D(CCJKShapeLine);
QPen pen = d->pen;
pen.setStyle(Qt::SolidLine);
pen.setJoinStyle(Qt::MiterJoin);
painter->setPen(pen);
switch (arrowType)
{
case ArrowArc:
{
QPainterPath path;
path.moveTo(p1);
path.lineTo(p);
path.lineTo(p2);
QPointF c = QPointF((p1.x() + p2.x() + p.x()) / 3, (p1.y() + p2.y() + p.y()) / 3);
path.quadTo(c, p1);
painter->drawPath(path);
}
break;
case ArrowLine:
{
QBrush brsh(Qt::NoBrush);
painter->setBrush(brsh);
pen.setCapStyle(Qt::SquareCap);
QPainterPath path;
path.moveTo(p1);
path.lineTo(p);
path.lineTo(p2);
painter->drawPath(path);
}
break;
case ArrowCircle:
{
painter->drawEllipse(p, arrowSize / 2, arrowSize / 2);
}
break;
case ArrowTriangle:
default:
{
QPolygonF arrowHead;
arrowHead << p << p1 << p2;
painter->drawPolygon(arrowHead);
break;
}
}
painter->setBrush(d->brush);
painter->setPen(d->pen);
}
void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern)
{
Q_ASSERT(painter);
SurfaceImpl &si = static_cast<SurfaceImpl &>(surfacePattern);
QPixmap *pm = static_cast<QPixmap *>(si.pd);
if (pm)
{
QBrush brsh(Qt::black, *pm);
painter->setPen(Qt::NoPen);
painter->setBrush(brsh);
painter->drawRect(rc.left, rc.top, rc.right - rc.left,
rc.bottom - rc.top);
}
else
FillRectangle(rc, ColourAllocated(0));
}
void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern)
{
Q_ASSERT(painter);
SurfaceImpl &si = static_cast<SurfaceImpl &>(surfacePattern);
QPixmap *pm = static_cast<QPixmap *>(si.pd);
if (pm)
{
QBrush brsh(Qt::black, *pm);
painter->setPen(Qt::NoPen);
painter->setBrush(brsh);
drawRect(rc);
}
else
{
FillRectangle(rc, ColourDesired(0));
}
}
void CCJKShapeLinkNode::Paint(QPainter *painter)
{
CJK_D(CCJKShapeLinkNode);
BeginPaint(painter);
QRectF tmpRect = BoundingRect();
QBrush brsh(Qt::NoBrush);
painter->setBrush(brsh);
QPen pen(Qt::red);
pen.setWidthF(1);
pen.setJoinStyle(Qt::MiterJoin);
pen.setCapStyle(Qt::RoundCap);
painter->setPen(pen);
painter->drawEllipse(tmpRect);
painter->drawLine(tmpRect.topLeft(), tmpRect.bottomRight());
painter->drawLine(tmpRect.topRight(), tmpRect.bottomLeft());
if (d->tracker == TTTouch)
{
painter->drawRect(tmpRect);
}
EndPaint(painter);
}
//
/// This is a static function that performs the actual drawing of edges for a
/// UIBorder or an external client. It uses the system ::DrawEdge if available.
//
bool
TUIBorder::DrawEdge(TDC& dc, const TRect& frame, uint edge, uint flags)
{
static int hasDrawEdge = true;
// Try once to see if the API call is available. If not, do ourselves.
//
if (hasDrawEdge) {
if (::DrawEdge(dc, (LPRECT)&frame, edge, flags))
return true;
if (::GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
hasDrawEdge = false;
else
return false;
}
// ::DrawEdge is not available, do the drawing ourselves
//
TRect f(frame); // working frame rectangle
// If mono is set, draw a thin, flat, black (windowFrame) frame
//
if (flags & Mono) {
if (edge & EdgeOuter) {
PaintFrame(dc, f, flags, TColor::SysWindowFrame, TColor::SysWindowFrame);
f.Inflate(-1,-1);
}
if (flags & Fill) { // !CQ repeated code--nest else?
TBrush brsh(TColor::SysWindow);
dc.SelectObject(brsh);
dc.PatBlt(f);
dc.RestoreBrush();
}
return true;
}
// If flat is set, draw a thin, flat, shadow frame
//
if (flags & Flat) {
if (edge & EdgeOuter) {
PaintFrame(dc, f, flags, TColor::Sys3dShadow, TColor::Sys3dShadow);
f.Inflate(-1,-1);
}
if (flags & Fill) { // !CQ repeated code--nest else?
TBrush brsh(TColor::Sys3dFace);
dc.SelectObject(brsh);
dc.PatBlt(f);
dc.RestoreBrush();
}
return true;
}
// Draw outer edge if indicated, adjusting rect afterwards
//
if (edge & EdgeOuter) {
static TColor tlColors[] = {
TColor::Sys3dLight, // EdgeRaised
TColor::Sys3dHilight, // EdgeRaised + Soft
TColor::Sys3dShadow, // EdgeSunken
TColor::Sys3dDkShadow, // EdgeSunken + Soft
};
static TColor brColors[] = {
TColor::Sys3dDkShadow, // EdgeRaised
TColor::Sys3dDkShadow, // EdgeRaised + Soft
TColor::Sys3dHilight, // EdgeSunken
TColor::Sys3dHilight, // EdgeSunken + Soft
};
int ci = ((edge & SunkenOuter) ? 2 : 0) | ((flags & Soft) ? 1 : 0);
PaintFrame(dc, f, flags, tlColors[ci], brColors[ci]);
f.Inflate(-1,-1);
}
// Draw inner edge if indicated, adjusting rect afterwards
//
if (edge & EdgeInner) {
static TColor tlColors[] = {
TColor::Sys3dHilight, // EdgeRaised
TColor::Sys3dLight, // EdgeRaised + Soft
TColor::Sys3dDkShadow, // EdgeSunken
TColor::Sys3dShadow, // EdgeSunken + Soft
};
static TColor brColors[] = {
TColor::Sys3dShadow, // EdgeRaised
TColor::Sys3dShadow, // EdgeRaised + Soft
TColor::Sys3dLight, // EdgeSunken
TColor::Sys3dLight, // EdgeSunken + Soft
};
int ci = ((edge & SunkenOuter) ? 2 : 0) | ((flags & Soft) ? 1 : 0);
PaintFrame(dc, f, flags, tlColors[ci], brColors[ci]);
f.Inflate(-1,-1);
}
// Fill interior if indicated
//
if (flags & Fill) {
TBrush brsh(TColor::Sys3dFace);
dc.SelectObject(brsh);
dc.PatBlt(f);
dc.RestoreBrush();
}
// !CQ not really usefull since frame is not returned
// if (flags & Adjust)
// frame = f;
return true;
}