///////////////////////////////////////////////////////////////
// TLevelProgressDialog
// --------------------
//
void DrawIconicGauge(TDC &dc, int yPosition, int Width, int Height, int Value)
{
TBrush BleueBrush(TColor(0,0,255));
TPen BleuePen (TColor(0,0,255));
// TBrush GrayBrush (TColor(200,200,200));
TPen WhitePen (TColor(255,255,255));
TPen GrayPen (TColor(100,100,100));
// TPen GrayPen (TColor(0,0,0));
// Draw upper left white border
dc.SelectObject(GrayPen);
dc.MoveTo(0, yPosition + Height - 1);
dc.LineTo(0, yPosition);
dc.LineTo(Width - 1, yPosition);
// Draw lower right border
dc.SelectObject(WhitePen);
dc.LineTo(Width - 1, yPosition + Height - 1);
dc.LineTo(0, yPosition + Height - 1);
// Draw gauge
dc.SelectObject(BleueBrush);
dc.SelectObject(BleuePen);
dc.Rectangle(1, yPosition + 1, (Width - 1) * Value / 100, yPosition + Height - 1);
dc.RestoreObjects();
}
//
/// Paints a maximize box on the tiny caption bar.
//
void
TTinyCaption::PaintMaxBox(TDC& dc, TRect& boxRect, bool pressed)
{
// Fill the box with light gray & draw bevel if possible
//
PaintButton(dc, boxRect, pressed);
if (pressed)
boxRect.Offset(1,1);
// Down triangle
//
int bh = boxRect.Height();
int bw = boxRect.Width();
if (IsZoomed()) {
TPoint begPt = boxRect.BottomLeft().OffsetBy((bw+1)/4, -bh*3/8);
TPoint endPt = begPt.OffsetBy((bw+1)/2, 0);
while (begPt.x < endPt.x) {
dc.MoveTo(begPt);
dc.LineTo(endPt);
begPt.Offset(1,1);
endPt.Offset(-1,1);
}
}
// Up triangle
//
{
TPoint begPt = boxRect.TopLeft().OffsetBy((bw+1)/4, IsZoomed() ? bh*3/8 : bh*2/3);
TPoint endPt = begPt.OffsetBy((bw+1)/2, 0);
while (begPt.x < endPt.x) {
dc.MoveTo(begPt);
dc.LineTo(endPt);
begPt.Offset(1, -1);
endPt.Offset(-1, -1);
}
}
}
//
/// Puts the font into the device context and calls PaintGadgets.
///
/// Respond to virtual TWindow Paint call. Call our own virtual PaintGadgets
/// to actually perform the painting of the gadgets
//
void
TGadgetWindow::Paint(TDC& dc, bool erase, TRect& rect)
{
if (IsBackgroundThemed())
{
TThemePart part(GetHandle(), (LPCWSTR) L"REBAR", 0, 0);
part.DrawBackground(dc, GetClientRect(), rect);
erase = false;
}
dc.SelectObject(*Font);
PaintGadgets(dc, erase, rect);
#if defined(__TRACE) || defined(__WARN)
// Highlight the tools of this gadgetwindow for debugging purposes.
// Especially useful for docking windows which undergo internal state
// changes
//
TProfile iniFile(_T("Diagnostics"), _T(OWL_INI));
bool useDiagColor = iniFile.GetInt(_T("DiagToolbarBorders")) != 0;
if (useDiagColor && Tooltip && Tooltip->IsWindow()) {
uint count = Tooltip->GetToolCount();
if (count) {
TPen redPen(TColor(0xff, 0, 0));
dc.SelectObject(redPen);
TToolInfo ti;
while (count) {
if (Tooltip->EnumTools(--count, ti)) {
dc.MoveTo(ti.rect.left, ti.rect.top);
dc.LineTo(ti.rect.right,ti.rect.top);
dc.LineTo(ti.rect.right,ti.rect.bottom);
dc.LineTo(ti.rect.left, ti.rect.bottom);
dc.LineTo(ti.rect.left, ti.rect.top);
}
}
dc.RestorePen();
}
}
#endif
}
//
/// Paints a minimize box on the tiny caption bar.
//
void
TTinyCaption::PaintMinBox(TDC& dc, TRect& boxRect, bool pressed)
{
// Fill the box with light gray & draw bevel if possible
//
PaintButton(dc, boxRect, pressed);
if (pressed)
boxRect.Offset(1,1);
int bh = boxRect.Height();
int bw = boxRect.Width();
TPoint begPt = boxRect.TopLeft().OffsetBy((bw+1)/4, (bh+2)/3);
TPoint endPt = begPt.OffsetBy((bw+1)/2,0);
while (begPt.x < endPt.x) {
dc.MoveTo(begPt);
dc.LineTo(endPt);
begPt.Offset(1,1);
endPt.Offset(-1,1);
}
}
////////////////////////////////////////////////////////////
// TBitmap256Control
// -----------------
// Display bitmap in DC
void TBitmap256Control::DisplayBitmap (TDC& dc, TRect &rect)
{
// Display a cross if no bitmap
if ( pDIBInfo == 0 )
{
dc.SelectObject(TPen(TColor::LtGray));
dc.MoveTo (0, 0);
dc.LineTo (MaxWidth, MaxHeight);
dc.MoveTo (0, MaxHeight);
dc.LineTo (MaxWidth, 0);
dc.SetTextAlign(TA_CENTER);
dc.SetTextColor(TColor::White);
dc.SetBkColor(TColor::Black);
char tmp[40];
if ( BitmapName[0] != '\0' && BitmapName[0] != '-' )
wsprintf (tmp, "No picture (%s)", BitmapName);
else
wsprintf (tmp, "No picture");
dc.TextOut (MaxWidth / 2, MaxHeight / 2 - 6, tmp);
return;
}
assert (pBitmapPalette != NULL);
// pBitmapPalette->UnrealizeObject();
dc.SelectObject (*pBitmapPalette);
dc.RealizePalette();
dc.SetStretchBltMode (COLORONCOLOR);
#if 1
TRect ZoomRect;
ZoomRect.left = rect.left;
ZoomRect.top = rect.top;
ZoomRect.right = rect.right;
ZoomRect.bottom = rect.bottom;
// Convert the rect. size to a rect in the sprite
rect.left /= ZoomFactor;
rect.top /= ZoomFactor;
rect.right /= ZoomFactor;
rect.bottom /= ZoomFactor;
TRect DIBRect;
DIBRect.left = rect.left;
DIBRect.top = BitmapYSize - rect.bottom; // DIBs are Y inversed
DIBRect.right = DIBRect.left + rect.Width();
DIBRect.bottom = DIBRect.top + rect.Height();
dc.StretchDIBits (ZoomRect,
DIBRect,
pDIBits, *pDIBInfo,
DIB_PAL_COLORS, SRCCOPY);
#else
// Create memory DC and display bitmap
TMemoryDC mdc (dc);
mdc.SelectObject (*pBitmapPalette);
mdc.SelectObject (*pBitmap);
dc.StretchBlt(0, 0, ZoomXSize, ZoomYSize,
mdc,
0, 0, BitmapXSize, BitmapYSize,
SRCCOPY);
// Restore GDI objects
mdc.RestoreBitmap();
mdc.RestorePalette();
#endif
dc.RestorePalette();
}
void TFuncSpecView::Paint(TDC& dc, bool erase, TRect& rect)
{
TSwitchMinApp* theApp = TYPESAFE_DOWNCAST(GetApplication(), TSwitchMinApp);
if (theApp) {
// Only paint if we're printing and we have something to paint, otherwise do nothing.
//
if (theApp->Printing && theApp->Printer && !rect.IsEmpty()) {
// Use pageSize to get the size of the window to render into. For a Window it's the client area,
// for a printer it's the printer DC dimensions and for print preview it's the layout window.
//
TSize pageSize(rect.right - rect.left, rect.bottom - rect.top);
TPrintDialog::TData& printerData = theApp->Printer->GetSetup();
// Get area we can draw in
TRect drawingArea(swdoc->PaintHeader(dc, rect, "", 0, 0, false), rect.BottomRight());
TEXTMETRIC tm;
dc.SelectObject(TFont("Arial", -12));
if (!dc.GetTextMetrics(tm)) {
dc.SelectObject(TFont("Arial", -12));
dc.GetTextMetrics(tm);
}
int fHeight=tm.tmHeight+tm.tmExternalLeading;
unsigned long inputs=swdoc->GetSystem()->GetInputs();
XPosVector xpos;
uint divider;
char* data;
Print_CreateWidths(xpos, divider, dc);
if (xpos.back().x < rect.Size().cx) { // put space in structure to stretch across page
uint spacing=(rect.Size().cx - xpos.back().x)/(xpos.size()+1);
uint space_inc=spacing;
for(XPosVector::size_type i=0; i<xpos.size(); i++) {
if (i==inputs) { // after inputs section, increase divider
divider += space_inc;
space_inc += spacing;
}
xpos[i].x += space_inc;
space_inc += spacing;
}
}
data=new char[xpos.size()];
unsigned long PagesDown=1+pow(2,inputs)/( (drawingArea.Size().cy/fHeight) - 2); // 2 lines for header and horz divider
unsigned long PagesAcross=1+xpos.back().x/drawingArea.Size().cx;
unsigned long Pages=1+PagesDown*PagesAcross;
// Compute the number of pages to print.
//
printerData.MinPage = 1;
printerData.MaxPage = Pages;
int fromPage = printerData.FromPage == -1 ? 1 : printerData.FromPage;
int toPage = printerData.ToPage == -1 ? 1 : printerData.ToPage;
int currentPage = fromPage;
TPoint p;
dc.SelectObject(TPen(TColor::Black));
while (currentPage <= toPage) {
swdoc->PaintHeader(dc, rect, "Specification", currentPage, Pages, true);
if (currentPage==1) Print_Summary(dc, drawingArea);
else {
// Calculate origin of line by page number
// x
int col=((currentPage-2) ) % PagesAcross;
p.x=drawingArea.left - col * drawingArea.Size().cx;
// y
int row=floor((currentPage-2)/PagesAcross);
p.y=drawingArea.top/* - row * drawingArea.Size().cy*/;
// Calculate starting and ending input states
CELL_TYPE state, stateEnd;
state=(row*(drawingArea.Size().cy-fHeight))/fHeight;
stateEnd=state+(drawingArea.Size().cy-fHeight)/fHeight;
if (stateEnd >= (pow(2,inputs)-1) ) stateEnd=pow(2,inputs)-1;
//
// Draw header and lines
// Vertical
if ( ((p.x+divider) > drawingArea.left) && ((p.x+divider)<drawingArea.right) ) {
dc.MoveTo(p.x+divider, p.y);
dc.LineTo(p.x+divider, p.y+((stateEnd-state)+3)*fHeight);
}
// Labels
for(XPosVector::size_type i=0; i<xpos.size(); i++)
dc.TextOut(TPoint(xpos[i].x, p.y), xpos[i].s.c_str());
p.y += fHeight;
// Horizontal
dc.MoveTo(drawingArea.left, p.y + fHeight/2);
dc.LineTo(p.x+xpos.back().x, p.y + fHeight/2);
p.y += fHeight;
//
// Draw each line
while(state <= stateEnd) {
Print_GenerateLine(data, state);
Print_Line(dc, p, xpos, data);
p.y += fHeight;
state++;
}
}
currentPage++;
}
delete[] data;
}
else {
// INSERT>> Normal painting code goes here.
wTabs->InvalidateRect(rect, erase);
}
}
}
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 ;
}
