//
/// 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 DrawDisabledButton(TDC& dc, const TRect& rc)
{
// create a monochrome memory DC
//
TMemoryDC ddc;
TBitmap bmp(ddc, rc.Width(), rc.Height());
ddc.SelectObject(bmp);
// build a mask
//
ddc.PatBlt(0, 0, rc.Width(), rc.Height(), WHITENESS);
dc.SetBkColor(TColor::Sys3dFace);
ddc.BitBlt(0, 0, rc.Width(), rc.Height(), dc, rc.left, rc.top, SRCCOPY);
dc.SetBkColor(TColor::Sys3dHilight);
ddc.BitBlt(0, 0, rc.Width(), rc.Height(), dc, rc.left, rc.top, SRCPAINT);
// Copy the image from the toolbar into the memory DC
// and draw it (grayed) back into the toolbar.
//
dc.FillRect(rc, TBrush(TColor::Sys3dFace));
dc.SetBkColor(RGB(0, 0, 0));
dc.SetTextColor(RGB(255, 255, 255));
TBrush brShadow(TColor::Sys3dShadow);
TBrush brHilight(TColor::Sys3dHilight);
dc.SelectObject(brHilight);
dc.BitBlt(rc.left+1, rc.top+1, rc.Width(), rc.Height(), ddc, 0, 0, 0x00E20746L);
dc.SelectObject(brShadow);
dc.BitBlt(rc.left, rc.top, rc.Width(), rc.Height(), ddc, 0, 0, 0x00E20746L);
// reset DCs
//
dc.RestoreBrush();
dc.RestoreBrush();
ddc.RestoreBitmap();
}
void TSensorView::ColumnViewer(TDC& dc,PSHORTREAL pData)
{
m_xSize = m_nDimSize[0];
m_ySize = m_nDimSize[1];
m_yAdd = (int) (500L * m_ySize / m_xSize / 2);
dc.SetWindowExt(TSize(m_xSize * 2 + m_ySize,500 + m_yAdd));
Grid3D(dc);
TBrush brGray(SYSCOLOR(COLOR_BTNFACE)),
brWhite(SYSCOLOR(COLOR_BTNHIGHLIGHT)),
brDark(SYSCOLOR(COLOR_BTNSHADOW));
for (int y = 0; y < m_nDimSize[1]; y++)
for (int x = 0; x < m_nDimSize[0]; x++)
{
SHORTREAL r = pData[x + (LONGINT) m_nDimSize[0] * y];
TPoint pt[4] =
{
Project2D(x,y+1,r),
Project2D(x+1,y+1,r),
Project2D(x+1,y,r),
Project2D(x,y,r)
};
dc.SelectObject(brWhite);
POLY(dc,pt,4);
SHORTREAL r2 = y == m_nDimSize[1]-1
? 0
: pData[x + (LONGINT) m_nDimSize[0] * (y+1)];
if(r2 < r)
{
pt[2] = Project2D(x+1,y+1,r2);
pt[3] = Project2D(x,y+1,r2);
dc.SelectObject(brGray);
POLY(dc,pt,4);
}
r2 = x == m_nDimSize[0]-1 ? 0
: pData[x+1 + (LONGINT) m_nDimSize[0] * y];
if (r2 < r)
{
pt[0] = Project2D(x+1,y,r);
pt[2] = Project2D(x+1,y+1,r2);
pt[3] = Project2D(x+1,y,r2);
dc.SelectObject(brDark);
POLY(dc,pt,4);
}
}
dc.RestoreBrush();
}
//
/// 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;
}
void npredictMDIChild::Paint ( TDC& dc , BOOL , TRect& )
{
int i, j, n, b, row, col, rstart, rstop, cstart, cstop, prevcol ;
int xlab_height, xlab_width, ylab_height, ylab_width, wide ;
int xlab_lw, xlab_rw, tick_height, font_height, r0, r1, c0 ;
double xscale, yscale, xtickscale, ytickscale, *sig, val ;
double x, xfac ;
char msg[256] ;
TRect rect ;
SIZE size ;
TColor bkgnd, *lines ;
TBrush *brush ;
TPen *pen, *second_pen ;
TFont *font ;
n = istop - istart + 1 ;
sig = signal->sig ;
dc.SetMapMode ( MM_TEXT ) ;
dc.SetROP2 ( R2_COPYPEN ) ;
dc.SetBkMode ( OPAQUE ) ;
bkgnd = dc.GetNearestColor ( TColor ( background_color ) ) ;
dc.SetBkColor ( bkgnd ) ;
GetClientRect ( rect ) ;
b = rect.bottom ; // We use origin at bottom, so b-y adapts to Windows
/*
Paint the background
*/
brush = new TBrush ( bkgnd ) ;
dc.SelectObject ( *brush ) ;
pen = new TPen ( bkgnd ) ;
dc.SelectObject ( *pen ) ;
dc.Rectangle ( rect ) ;
dc.RestoreBrush () ;
delete brush ;
dc.RestorePen () ;
delete pen ;
/*
Setup main drawing pen and secondary pen for hash lines
*/
lines = new TColor ( 0 , 0 , 0 ) ;
pen = new TPen ( *lines , 1 , PS_SOLID ) ;
second_pen = new TPen ( *lines , 1 , PS_DASH ) ;
/*
Compute the maximum height and width of the axis tick labels.
This lets us position the graph optimally.
*/
xlab_height = xlab_width = ylab_height = ylab_width = xlab_lw = xlab_rw = 0 ;
font_height = rect.bottom / 20 ;
if (rect.right / 24 < font_height)
font_height = rect.right / 24 ;
if (font_height < 8)
font_height = 0 ;
if (font_height) {
font = new TFont ( "Helvetica" , font_height ) ;
dc.SelectObject ( *font ) ;
for (i=0 ; i<xnticks ; i++) {
sprintf ( msg , "%*.*lf", xndigits, xnfrac, xmin + i * xdif ) ;
GetTextExtentPoint ( dc , msg , strlen(msg) , &size ) ;
if (! i)
xlab_lw = size.cx ; // Width of leftmost x label
if (i == xnticks-1)
xlab_rw = size.cx ; // And rightmost x label
if (size.cx > xlab_width)
xlab_width = size.cx ;
if (size.cy > xlab_height)
xlab_height = size.cy ;
}
for (i=0 ; i<ynticks ; i++) {
sprintf ( msg , "%*.*lf", yndigits, ynfrac, ymin + i * ydif ) ;
GetTextExtentPoint ( dc , msg , strlen(msg) , &size ) ;
if (size.cx > ylab_width)
ylab_width = size.cx ;
if (size.cy > ylab_height)
ylab_height = size.cy ;
}
tick_height = xlab_height / 2 ;
}
else {
tick_height = rect.bottom / 64 + 2 ;
font = NULL ;
}
/*
Last check on label display. Are X-axis labels to wide?
*/
if ((xlab_width * xnticks) > (3 * rect.right / 4)) {
font_height = 0 ;
xlab_height = xlab_width = ylab_height = ylab_width = 0 ;
xlab_lw = xlab_rw = 0 ;
tick_height = rect.bottom / 64 + 2 ;
if (font != NULL) {
dc.RestoreFont () ;
delete font ;
font = NULL ;
}
}
/*
Compute the graph extent based on these label metrics
*/
rstart = tick_height + xlab_height + 1 ; // Ticks, X tick labels
rstop = rect.bottom - ylab_height/2 - 2 ; // Top half of topmost label
if (xlab_lw / 2 > ylab_width) // If left half of X label biggest
cstart = xlab_lw / 2 + 1 ; // Use it for offset
else
cstart = ylab_width + 2 ; // Otherwise Y labels determine it
cstop = rect.right - xlab_rw / 2 - 2 ; // Leave room for rightmost label
/*
Compute scales for data and ticks
*/
xscale = (double) (cstop - cstart) / (xmax - xmin) ;
xfac = (rightx - leftx) / (n-1) ;
yscale = (double) (rstop - rstart) / (ymax - ymin) ;
xtickscale = (double) (cstop-cstart) / (double) (xnticks-1) ;
ytickscale = (double) (rstop-rstart) / (double) (ynticks-1) ;
/*
Outline the graph, draw ticks, and write their labels
*/
dc.SelectObject ( *pen ) ;
dc.MoveTo ( cstart , b-rstart ) ;
dc.LineTo ( cstop , b-rstart ) ;
dc.LineTo ( cstop , b-rstop ) ;
dc.LineTo ( cstart , b-rstop ) ;
dc.LineTo ( cstart , b-rstart ) ;
dc.RestorePen () ;
for (i=0 ; i<ynticks ; i++) { /* Y ticks */
row = rstart + i * ytickscale + 0.5 ;
if (i && (i < ynticks-1)) { // Horizontal interior lines
dc.SelectObject ( *second_pen ) ;
dc.MoveTo ( cstart , b-row ) ;
dc.LineTo ( cstop , b-row ) ;
dc.RestorePen () ;
}
if (font_height) {
sprintf ( msg , "%*.*lf", yndigits, ynfrac, ymin + i * ydif ) ;
rect.bottom = b - (row - ylab_height / 2) ;
rect.top = rect.bottom - ylab_height - 1 ;
rect.right = cstart - 1 ;
rect.left = rect.right - ylab_width - 1 ;
dc.SelectObject ( *pen ) ;
dc.DrawText ( msg , -1 , rect , DT_SINGLELINE | DT_BOTTOM | DT_RIGHT );
dc.RestorePen () ;
}
}
dc.SelectObject ( *pen ) ;
prevcol = 0 ;
for (i=0 ; i<xnticks ; i++) { /* X ticks */
col = cstart + i * xtickscale + 0.5 ;
dc.MoveTo ( col , b-rstart ) ;
dc.LineTo ( col , b-(rstart - tick_height) ) ;
if (i) { /* Make an additional, unlabeled tick between main ones */
dc.MoveTo ( (col + prevcol) / 2 , b-rstart ) ;
dc.LineTo ( (col + prevcol) / 2 , b-(rstart - tick_height/2) ) ;
}
prevcol = col ;
if (font_height) {
sprintf ( msg , "%*.*lf", xndigits, xnfrac, xmin + i * xdif ) ;
while (*msg == ' ') // Remove leading blanks
strcpy ( msg , msg+1 ) ;
rect.top = b - (rstart - tick_height) ;
rect.bottom = rect.top + xlab_height - 1 ;
rect.right = col + xlab_width / 2 ;
rect.left = rect.right - xlab_width - 1 ;
dc.DrawText ( msg , -1 , rect , DT_SINGLELINE | DT_BOTTOM | DT_CENTER);
}
}
dc.RestorePen () ;
if (font_height) {
dc.RestoreFont () ;
delete font ;
}
/*
Draw the graph
*/
if ((signal->type == DataSignal) || (signal->type == SpectrumSignal)
|| (signal->type == SpectrumDevSignal)) {
if ((command_id == ID_PRED_DISPLAY_CONFIDENCE) && // Draw confidence first
(signal->known_n <= istop)) { // If visible
delete second_pen ; // No longer needed for hash lines, so use for
second_pen = new TPen ( *lines , 1 , PS_DOT ) ; // Confidence lines
dc.SelectObject ( *second_pen ) ;
i = signal->known_n - 1 ;
if (i >= istart)
r0 = rstart + (int) ((sig[i] - ymin) * yscale) ;
else {
i = istart ;
j = i - signal->known_n ;
if (signal->mult_conf)
val = sig[i] * signal->intervals[2*j] ;
else
val = sig[i] + signal->intervals[2*j] ;
r0 = rstart + (int) ((val - ymin) * yscale + 0.5) ;
}
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
x = (i - istart) * xfac + leftx ;
c0 = cstart + (int) (xscale * (x-xmin) + 0.5) ;
dc.MoveTo ( c0 , r0 ) ;
for (i=i+1 ; i<signal->known_n+signal->npred ; i++) {
if (i > istop)
break ;
j = i - signal->known_n ;
if (signal->mult_conf)
val = sig[i] * signal->intervals[2*j] ;
else
val = sig[i] + signal->intervals[2*j] ;
r0 = rstart + (int) ((val - ymin) * yscale + 0.5) ;
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
x = (i - istart) * xfac + leftx ;
c0 = cstart + (int) (xscale * (x-xmin) + 0.5) ;
dc.LineTo ( c0 , r0 ) ;
}
i = signal->known_n - 1 ;
if (i >= istart)
r0 = rstart + (int) ((sig[i] - ymin) * yscale) ;
else {
i = istart ;
j = i - signal->known_n ;
if (signal->mult_conf)
val = sig[i] * signal->intervals[2*j] ;
else
val = sig[i] + signal->intervals[2*j] ;
r0 = rstart + (int) ((val - ymin) * yscale + 0.5) ;
}
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
x = (i - istart) * xfac + leftx ;
c0 = cstart + (int) (xscale * (x-xmin) + 0.5) ;
dc.MoveTo ( c0 , r0 ) ;
for (i=signal->known_n ; i<signal->known_n+signal->npred ; i++) {
if (i > istop)
break ;
j = i - signal->known_n ;
if (signal->mult_conf)
val = sig[i] * signal->intervals[2*j+1] ;
else
val = sig[i] + signal->intervals[2*j+1] ;
r0 = rstart + (int) ((val - ymin) * yscale + 0.5) ;
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
x = (i - istart) * xfac + leftx ;
c0 = cstart + (int) (xscale * (x-xmin) + 0.5) ;
dc.LineTo ( c0 , r0 ) ;
}
dc.RestorePen () ;
}
if (signal->type == SpectrumDevSignal) {
delete second_pen ; // No longer needed for hash lines, so use for
second_pen = new TPen ( *lines , 1 , PS_DOT ) ; // Confidence lines
dc.SelectObject ( *second_pen ) ;
row = rstart + (int) ((corrlim - ymin) * yscale + 0.5) ; // Confidence
if ((row >= rstart) && (row <= rstop)) {
dc.MoveTo ( cstart , b-row ) ;
dc.LineTo ( cstop , b-row ) ;
}
row = rstart + (int) ((-corrlim - ymin) * yscale + 0.5) ; // Confidence
if ((row >= rstart) && (row <= rstop)) {
dc.MoveTo ( cstart , b-row ) ;
dc.LineTo ( cstop , b-row ) ;
}
dc.RestorePen () ;
}
dc.SelectObject ( *pen ) ;
r0 = rstart + (int) ((sig[istart] - ymin) * yscale) ;
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
x = leftx ;
c0 = cstart + (int) (xscale * (x-xmin) + 0.5) ;
dc.MoveTo ( c0 , r0 ) ;
for (i=istart+1 ; i<=istop ; i++) {
r0 = rstart + (int) ((sig[i] - ymin) * yscale + 0.5) ;
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
x = (i - istart) * xfac + leftx ;
c0 = cstart + (int) (xscale * (x-xmin) + 0.5) ;
dc.LineTo ( c0 , r0 ) ;
}
dc.RestorePen () ;
} // If DataSignal or SpectrumSignal
else if (signal->type == CorrelationSignal) {
delete second_pen ; // No longer needed for hash lines, so use for
second_pen = new TPen ( *lines , 1 , PS_DOT ) ; // Confidence lines
dc.SelectObject ( *second_pen ) ;
row = rstart + (int) ((corrlim - ymin) * yscale + 0.5) ; // Confidence
if ((row >= rstart) && (row <= rstop)) {
dc.MoveTo ( cstart , b-row ) ;
dc.LineTo ( cstop , b-row ) ;
}
row = rstart + (int) ((-corrlim - ymin) * yscale + 0.5) ; // Confidence
if ((row >= rstart) && (row <= rstop)) {
dc.MoveTo ( cstart , b-row ) ;
dc.LineTo ( cstop , b-row ) ;
}
dc.RestorePen () ;
wide = (cstop - cstart) / n ;
r0 = rstart + (int) ((0.0 - ymin) * yscale + 0.5) ;
for (i=0 ; i<ynticks ; i++) { // Search all horizontal ticks
row = rstart + i * ytickscale + 0.5 ; // Because rounding error
if (abs ( r0 - row ) <= 1) { // Might make 0 off by one
r0 = row ; // Which looks ugly
break ;
}
}
if (r0 < rstart)
r0 = rstart ;
if (r0 > rstop)
r0 = rstop ;
r0 = b - r0 ;
dc.SelectObject ( *pen ) ;
for (i=0 ; i<n ; i++) {
c0 = cstart + (int) (xscale * (i+1) + 0.5) ;
r1 = rstart + (int) ((sig[i] - ymin) * yscale + 0.5) ;
if (r1 < rstart)
r1 = rstart ;
if (r1 > rstop)
r1 = rstop ;
r1 = b - r1 ;
dc.MoveTo ( c0 , r0 ) ;
dc.LineTo ( c0 , r1 ) ;
if (wide && (c0 > cstart)) {
dc.MoveTo ( c0-1 , r0 ) ;
dc.LineTo ( c0-1 , r1 ) ;
}
if (wide && (c0 < cstop)) {
dc.MoveTo ( c0+1 , r0 ) ;
dc.LineTo ( c0+1 , r1 ) ;
}
if ((wide > 9) && (c0 > cstart+1)) {
dc.MoveTo ( c0-2 , r0 ) ;
dc.LineTo ( c0-2 , r1 ) ;
}
if ((wide > 9) && (c0 < cstop-1)) {
dc.MoveTo ( c0+2 , r0 ) ;
dc.LineTo ( c0+2 , r1 ) ;
}
}
dc.RestorePen () ;
}
delete pen ;
delete second_pen ;
delete lines ;
}
