// Calculates tab's elements, based on its width and height.
// Generates a GraphicsPath, which is used for painting the tab, etc.
bool Reshape(int dx, int dy) {
dx--;
if (width == dx && height == dy)
return false;
width = dx; height = dy;
GraphicsPath shape;
// define tab's body
int c = int((float)height * 0.6f + 0.5f); // size of bounding square for the arc
shape.AddArc(0, 0, c, c, 180.0f, 90.0f);
shape.AddArc(width - c, 0, c, c, 270.0f, 90.0f);
shape.AddLine(width, height, 0, height);
shape.CloseFigure();
shape.SetMarker();
// define "x"'s circle
c = height > 17 ? 14 : int((float)height * 0.78f + 0.5f); // size of bounding square for the circle
Point p(width - c - 3, (height - c) / 2); // circle's position
shape.AddEllipse(p.X, p.Y, c, c);
shape.SetMarker();
// define "x"
int o = int((float)c * 0.286f + 0.5f); // "x"'s offset
shape.AddLine(p.X+o, p.Y+o, p.X+c-o, p.Y+c-o);
shape.StartFigure();
shape.AddLine(p.X+c-o, p.Y+o, p.X+o, p.Y+c-o);
shape.SetMarker();
delete data;
data = new PathData();
shape.GetPathData(data);
return true;
}
// Calculates tab's elements, based on its width and height.
// Generates a GraphicsPath, which is used for painting the tab, etc.
bool Reshape(int dx, int dy) {
dx--;
if (width == dx && height == dy)
return false;
width = dx;
height = dy;
GraphicsPath shape;
// define tab's body
shape.AddRectangle(Rect(0, 0, width, height));
shape.SetMarker();
// define "x"'s circle
int c = int((float)height * 0.78f + 0.5f); // size of bounding square for the circle
int maxC = DpiScaleX(hwnd, 17);
if (height > maxC) {
c = DpiScaleX(hwnd, 17);
}
Point p(width - c - DpiScaleX(hwnd, 3), (height - c) / 2); // circle's position
shape.AddEllipse(p.X, p.Y, c, c);
shape.SetMarker();
// define "x"
int o = int((float)c * 0.286f + 0.5f); // "x"'s offset
shape.AddLine(p.X + o, p.Y + o, p.X + c - o, p.Y + c - o);
shape.StartFigure();
shape.AddLine(p.X + c - o, p.Y + o, p.X + o, p.Y + c - o);
shape.SetMarker();
delete data;
data = new PathData();
shape.GetPathData(data);
return true;
}
void IGTabBar::drawTab (HDC hdc, UINT nSize, bool bSelected, bool bOver, const wchar_t *pcwTitle)
{
Graphics graphics (hdc);
Color colBackground (Color (GetRValue (m_cBackGround), GetGValue (m_cBackGround), GetBValue (m_cBackGround)));
SolidBrush solBrushBackground (colBackground);
graphics.FillRectangle (&solBrushBackground, Rect (0, 0, nSize, BUTTON_HEIGHT - 1));
SolidBrush solBrushTab (bSelected ? IGTAB_COLORBACKGND : IGTAB_COLOR_UNSELECTED);
GraphicsPath pathBorder;
pathBorder.StartFigure();
pathBorder.AddArc (Rect (0, 0, IGTAB_CORNERDIAM, IGTAB_CORNERDIAM), 180.0f, 90.0f);
pathBorder.AddArc (Rect (nSize - IGTAB_CORNERDIAM, 0, IGTAB_CORNERDIAM, IGTAB_CORNERDIAM), -90.0f, 90.0f);
pathBorder.AddLine (Point (nSize, BUTTON_HEIGHT + (bSelected ? 1 : 0)), Point (0, BUTTON_HEIGHT + (bSelected ? 1 : 0)));
graphics.FillPath (&solBrushTab, &pathBorder);
if (bOver)
{
PathGradientBrush pthGrBrush (&pathBorder);
pthGrBrush.SetCenterPoint (PointF (0.7f * (float)nSize,
0.3f * (float)BUTTON_HEIGHT));
pthGrBrush.SetCenterColor (IGTAB_COLOR_FRAMEIN);
Color colors[] = {IGTAB_COLOR_FRAMEOUT};
int count = 1;
pthGrBrush.SetSurroundColors (colors, &count);
graphics.FillPath (&pthGrBrush, &pathBorder);
}
FontFamily fontFamily(L"Times New Roman");
Font font(&fontFamily, 16, FontStyleRegular, UnitPixel);
PointF pointF(20.0f, 5.0f);
SolidBrush solidFontBrush (bSelected ? IGTAB_COLOR_FONTENABLED : IGTAB_COLOR_FONTDISABLED);
StringFormat format(StringFormat::GenericDefault());
format.SetAlignment (StringAlignmentCenter);
graphics.DrawString (pcwTitle, -1, &font, RectF (0.0f, 0.0f, (float)nSize, (float)BUTTON_HEIGHT),
&format, &solidFontBrush);
Pen penBorder (IGTAB_COLORBORDER, 1);
GraphicsPath pathBorderOut;
pathBorderOut.StartFigure();
pathBorderOut.AddArc (Rect (0, 0, IGTAB_CORNERDIAM + 1, IGTAB_CORNERDIAM + 1), 180.0f, 90.0f);
pathBorderOut.AddArc (Rect (nSize - IGTAB_CORNERDIAM - 2, 0, IGTAB_CORNERDIAM + 1, IGTAB_CORNERDIAM + 1), -90.0f, 90.0f);
pathBorderOut.AddLine (Point (nSize - 1, BUTTON_HEIGHT + (bSelected ? 1 : 0)), Point (0, BUTTON_HEIGHT + (bSelected ? 1 : 0)));
pathBorderOut.CloseFigure();
graphics.DrawPath (&penBorder, &pathBorderOut);
}
void DrawItemShape::setRegion(const std::list<IDataLine*>& lines)
{
GraphicsPath path;
path.StartFigure();
for(auto itter = m_lines.begin();itter != m_lines.end() ; itter++ )
{
(*itter)->getPath(path);
}
path.CloseFigure();
m_region = std::shared_ptr<Region>(new Region(&path));
}
GraphicsPath *GraphicsPathFromPathData(const char *s)
{
VecSegmented<SvgPathInstr> instr;
if (!ParseSvgPathData(s, instr))
return nullptr;
GraphicsPath *gp = ::new GraphicsPath();
PointF prevEnd(0.f, 0.f);
for (SvgPathInstr& i : instr) {
PathInstrType type = i.type;
// convert relative coordinates to absolute based on end position of
// previous element
// TODO: support the rest of instructions
if (MoveRel == type) {
RelPointToAbs(prevEnd, i.v);
type = MoveAbs;
} else if (LineToRel == type) {
RelPointToAbs(prevEnd, i.v);
type = LineToAbs;
} else if (HLineRel == type) {
RelXToAbs(prevEnd, i.v);
type = HLineAbs;
} else if (VLineRel == type) {
RelYToAbs(prevEnd, i.v);
type = VLineAbs;
}
if (MoveAbs == type) {
PointF p(i.v[0], i.v[1]);
prevEnd = p;
gp->StartFigure();
} else if (LineToAbs == type) {
PointF p(i.v[0], i.v[1]);
gp->AddLine(prevEnd, p);
prevEnd = p;
} else if (HLineAbs == type) {
PointF p(prevEnd);
p.X = i.v[0];
gp->AddLine(prevEnd, p);
prevEnd = p;
} else if (VLineAbs == type) {
PointF p(prevEnd);
p.Y = i.v[0];
gp->AddLine(prevEnd, p);
prevEnd = p;
} else if ((Close == type) || (Close2 == type)) {
gp->CloseFigure();
} else {
CrashIf(true);
}
}
return gp;
}
void DrawItemShape::OnPaint( Graphics &g )
{
if(isChangeRegion())
{
ResetRegion();
}
auto region = getRegion();
SolidBrush brush(DrawTools::ColorNormal);
if (m_isFillPath)
{
if (StateNormal == m_state)
{
g.FillRegion(&brush, region.get());
}
else if (StateHovered == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorHovered), region.get());
}
else if (StateDisable == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorDisable), region.get());
}
else if (StateDown == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorDown), region.get());
}
else if (StateError == m_state)
{
g.FillRegion(&SolidBrush(DrawTools::ColorError), region.get());
}
else
{
g.FillRegion(&SolidBrush(m_fillColor), region.get());
}
}
if (m_isDrawPath)
{
GraphicsPath path;
path.StartFigure();
for(auto itter = m_lines.begin();itter != m_lines.end() ; itter++ )
{
(*itter)->getPath(path);
}
path.CloseFigure();
g.DrawPath(&Pen(m_drawColor),&path);
}
}
/*
* Converts specified int array into GraphicsPath object
*/
static inline GraphicsPath *createGraphicsPath(JNIEnv *env, jfloatArray jpath, jint len, jint winding)
{
jfloat *path = (jfloat *)malloc(sizeof(jfloat)*len);
env->GetFloatArrayRegion(jpath, 0, len, path);
GraphicsPath *res = new GraphicsPath((winding == java_awt_geom_PathIterator_WIND_EVEN_ODD)?FillModeAlternate:FillModeWinding);
float x1 = 0;
float y1 = 0;
float mx = 0;
float my = 0;
for (int i = 0; i < len; i++) {
int seg = (int)path[i];
switch (seg) {
case java_awt_geom_PathIterator_SEG_MOVETO:
res->StartFigure();
x1 = path[i+1];
y1 = path[i+2];
mx = path[i+1];
my = path[i+2];
i += 2;
break;
case java_awt_geom_PathIterator_SEG_LINETO:
res->AddLine(x1, y1, path[i+1], path[i+2]);
x1 = path[i+1];
y1 = path[i+2];
i += 2;
break;
case java_awt_geom_PathIterator_SEG_CLOSE:
res->AddLine(x1, y1, mx, my);
x1 = mx;
y1 = my;
res->CloseFigure();
break;
}
}
free(path);
return res;
}
virtual void onDraw(HDC hdc)
{
Graphics graphics(hdc);
USmartDC dc(hdc);
huys::URectL rect;
this->getClientRect(rect);
//
LinearGradientBrush lgb(Point(0, 0), Point(rect.right(), rect.bottom()), Color::Blue, Color::Green);
//
graphics.FillRectangle(&lgb, 0, 0, rect.right(), rect.bottom());
//
Pen pen(Color(255, 255, 255, 255));
graphics.DrawLine(&pen, 0, 0, 200, 100);
//
Pen blackPen(Color(255, 255, 0, 0), 5);
graphics.DrawRectangle(&blackPen, 290, 100, 100, 50);
//
Pen blackPen2(Color(255, 0, 0, 0), 1);
Pen greenPen(Color(255, 0, 255, 0), 10);
greenPen.SetAlignment(PenAlignmentCenter);
// Draw the line with the wide green pen.
graphics.DrawLine(&greenPen, 310, 100, 400, 50);
// Draw the same line with the thin black pen.
graphics.DrawLine(&blackPen2, 310, 100, 400, 50);
greenPen.SetAlignment(PenAlignmentInset);
// Draw the rectangle with the wide green pen.
graphics.DrawRectangle(&greenPen, 510, 100, 50, 50);
// Draw the same rectangle with the thin black pen.
graphics.DrawRectangle(&blackPen2, 510, 100, 50, 50);
//
SolidBrush solidBrush(Color(255, 255, 0, 0));
graphics.FillEllipse(&solidBrush, 0, 0, 100, 60);
//
SolidBrush brush(Color(255, 0, 0, 255));
FontFamily fontFamily(L"Times New Roman");
Font font(&fontFamily, 24, FontStyleRegular, UnitPixel);
PointF pointF(10.0f, 20.0f);
graphics.DrawString(L"Hello World!", -1, &font, pointF, &brush);
GraphicsPath path;
Pen penJoin(Color(255, 0, 0, 255), 8);
path.StartFigure();
path.AddLine(Point(50, 200), Point(100, 200));
path.AddLine(Point(100, 200), Point(100, 250));
penJoin.SetLineJoin(LineJoinBevel);
graphics.DrawPath(&penJoin, &path);
pen.SetStartCap(LineCapArrowAnchor);
pen.SetEndCap(LineCapRoundAnchor);
graphics.DrawLine(&pen, 20, 175, 300, 175);
REAL dashValues[4] = {5, 2, 15, 4};
Pen blackPen3(Color(255, 0, 0, 0), 2);
blackPen3.SetDashPattern(dashValues, 4);
graphics.DrawLine(&blackPen3, Point(5, 225), Point(405, 225));
Image image(L"Texture.jpg");
TextureBrush tBrush(&image);
Pen texturedPen(&tBrush, 30);
graphics.DrawImage(&image, 499, 366, image.GetWidth(), image.GetHeight());
graphics.DrawEllipse(&texturedPen, 600, 220, 200, 100);
Pen opaquePen(Color(255, 0, 0, 255), 15);
Pen semiTransPen(Color(128, 0, 0, 255), 15);
graphics.DrawLine(&opaquePen, 480, 380, 640, 380);
graphics.DrawLine(&semiTransPen, 480, 400, 640, 400);
graphics.SetCompositingQuality(CompositingQualityGammaCorrected);
graphics.DrawLine(&semiTransPen, 480, 420, 640, 420);
LinearGradientBrush linGrBrush(
Point(0, 10),
Point(200, 10),
Color(255, 255, 0, 0), // opaque red
Color(255, 0, 0, 255)); // opaque blue
Pen penx(&linGrBrush);
graphics.DrawLine(&penx, 0, 410, 200, 410);
graphics.FillEllipse(&linGrBrush, 20, 360, 200, 400);
graphics.FillRectangle(&linGrBrush, 30, 355, 200, 400);
Point points[] =
{
Point(0, 0), Point(100, 200), Point(200, 0), Point(300, 200), Point(400, 00)
};
//
for (int i = 0; i < 4; i++)
{
graphics.DrawLine(&Pen(Color::White, 3), points[i], points[i + 1]);
}
//
graphics.DrawCurve(&Pen(Color::Red, 3), points, 5);
}
/*
** Draws the meter on the double buffer
**
*/
bool MeterSegmentedLine::Draw(Gfx::Canvas& canvas)
{
int maxSize = m_DataWidth;
if (!Meter::Draw(canvas) || maxSize <= 0) return false;
Gdiplus::Graphics& graphics = canvas.BeginGdiplusContext();
double maxValue = 0.0;
int counter = 0;
// Find the maximum value
if (m_Autoscale)
{
double newValue = 0;
counter = 0;
for (auto i = m_AllValues.cbegin(); i != m_AllValues.cend(); ++i)
{
double scale = m_ScaleValues[counter];
for (auto j = (*i).cbegin(); j != (*i).cend(); ++j)
{
double val = (*j) * scale;
newValue = max(newValue, val);
}
++counter;
}
// Scale the value up to nearest power of 2
if (newValue > DBL_MAX / 2.0)
{
maxValue = DBL_MAX;
}
else
{
maxValue = 2.0;
while (maxValue < newValue)
{
maxValue *= 2.0;
}
}
}
else
{
for (auto i = m_Measures.cbegin(); i != m_Measures.cend(); ++i)
{
double val = (*i)->GetMaxValue();
maxValue = max(maxValue, val);
}
if (maxValue == 0.0)
{
maxValue = 1.0;
}
}
Gdiplus::Rect meterRect = GetMeterRectPadding();
// Draw all the lines
const REAL H = meterRect.Height - 1.0f;
counter = 0;
auto pointsBuffer = m_Points.cbegin();
for (auto i = m_AllValues.cbegin(); i != m_AllValues.cend(); ++i)
{
// Draw a line
REAL Y, oldY;
const double scale = m_ScaleValues[counter] * H / maxValue;
int pos = m_CurrentPos;
auto calcY = [&](REAL& _y, REAL stepSize, int currPos) //TODO: move this lambda elsewhere
{
_y = 0;
switch (m_CurveFitMethod)
{
//first value
case 0: _y = (REAL)((*i)[currPos]);
break;
//maximum value
case 1: for (int ind = 0; ind < stepSize; ind++)
_y = max(_y, (REAL)((*i)[(currPos + ind) % m_DataWidth]));
break;
//arithmetic mean
case 2: for (int ind = 0; ind < stepSize; ind++)
_y += (REAL)((*i)[(currPos + ind) % m_DataWidth]);
_y /= stepSize;
break;
default: _y = (REAL)((*i)[currPos]);
}
_y *= scale;
_y = min(_y, H);
_y = max(_y, 0.0f);
_y = meterRect.Y + (H - _y);
};
// Cache all lines
GraphicsPath path;
int segmentInd = 0,
step,
divider;
//compute y values
step = m_SegmentDividers[m_SegmentDividers.size() - 1];
divider = m_Segments.size() > 0 ? m_W - m_Segments[m_Segments.size() - 1] : m_W;
for (int j = 0; j < m_W; ++j)
{
calcY(Y, step, pos - pos % step);
(*pointsBuffer)[j] = Y;
if (segmentInd < m_Segments.size() && j >= divider)
{
segmentInd++;
step = m_SegmentDividers[m_SegmentDividers.size() - segmentInd - 1];
divider = segmentInd != m_Segments.size() ? m_W - m_Segments[m_Segments.size() - segmentInd - 1] : m_W;
}
pos += step;
pos %= m_DataWidth;
}
//draw y values
segmentInd = 0;
divider = m_Segments.size() > 0 ? m_W - m_Segments[m_Segments.size() - segmentInd - 1] : m_W;
if (!m_GraphStartLeft)
{
for (int j = 1; j < m_W; ++j)
{
if (segmentInd < m_Segments.size() && j >= divider)
{
segmentInd++;
path.SetMarker();
path.StartFigure();
divider = segmentInd != m_Segments.size() ? m_W - m_Segments[m_Segments.size() - segmentInd - 1] : m_W;
}
path.AddLine((REAL)(meterRect.X + j - 1), (*pointsBuffer)[j - 1], (REAL)(meterRect.X + j), (*pointsBuffer)[j]);
}
}
else
{
for (int j = 1; j < m_W; ++j)
{
if (segmentInd < m_Segments.size() && j >= divider)
{
segmentInd++;
path.SetMarker();
path.StartFigure();
divider = segmentInd != m_Segments.size() ? m_W - m_Segments[m_Segments.size() - segmentInd - 1] : m_W;
}
path.AddLine((REAL)(meterRect.X + meterRect.Width - j), (*pointsBuffer)[j - 1], (REAL)(meterRect.X + meterRect.Width - j - 1), (*pointsBuffer)[j]);
}
}
// Draw cached lines
GraphicsPathIterator pathIter(&path);
GraphicsPath subPath;
for (auto color = m_Colors[counter].rbegin(); color != m_Colors[counter].rend(); ++color)
{
pathIter.NextMarker(&subPath);
Pen pen(*color, (REAL)m_LineWidth);
pen.SetLineJoin(LineJoinRound);
graphics.DrawPath(&pen, &subPath);
}
++counter;
++pointsBuffer;
}
canvas.EndGdiplusContext();
return true;
}