{

Scaler( wxDC * dc, double xScale, double yScale )

{

m_dc = dc;

if ( m_dc )

{

dc->GetLogicalScale( &m_xScaleOld, &m_yScaleOld );

dc->SetLogicalScale( xScale, yScale );

}

}

~Scaler( )

{

if ( m_dc )

m_dc->SetLogicalScale( m_xScaleOld, m_yScaleOld );

}

wxDC *m_dc;

double m_xScaleOld;

double m_yScaleOld;

{

OriginChanger( wxDC * dc, wxCoord xOrigin, wxCoord yOrigin )

{

m_dc = dc;

if ( m_dc )

{

dc->GetLogicalOrigin( &m_xOriginOld, &m_yOriginOld );

dc->SetLogicalOrigin( xOrigin, yOrigin );

}

}

~OriginChanger( )

{

if ( m_dc )

m_dc->SetLogicalOrigin( m_xOriginOld, m_yOriginOld );

}

wxDC *m_dc;

wxCoord m_xOriginOld;

wxCoord m_yOriginOld;

{

DrawingObjectsChanger( wxDC *dc, const wxPen &pen, const wxBrush &brush )

{

m_dc = dc;

if ( m_dc )

{

m_pen = dc->GetPen();

m_brush = dc->GetBrush();

dc->SetPen( pen );

dc->SetBrush( brush );

}

}

~DrawingObjectsChanger()

{

if ( m_dc )

{

m_dc->SetPen( m_pen );

m_dc->SetBrush( m_brush );

}

}

wxDC *m_dc;

wxPen m_pen;

wxBrush m_brush;

{

TextObjectsChanger( wxDC *dc, const wxFont &font, const wxColour &textForeground, const wxColour &textBackground )

{

m_dc = dc;

if ( m_dc )

{

m_font = dc->GetFont();

m_textForeground = dc->GetTextForeground();

m_textBackground = dc->GetTextBackground();

dc->SetTextForeground( textForeground );

dc->SetTextBackground( textBackground );

dc->SetFont( font );

}

}

TextObjectsChanger( wxDC *dc, const wxFont &font )

{

m_dc = dc;

if ( m_dc )

{

m_font = dc->GetFont();

m_textForeground = dc->GetTextForeground();

m_textBackground = dc->GetTextBackground();

dc->SetFont( font );

}

}

~TextObjectsChanger()

{

if ( m_dc )

{

m_dc->SetTextForeground( m_textForeground );

m_dc->SetTextBackground( m_textBackground );

m_dc->SetFont( m_font );

}

}

wxDC *m_dc;

wxFont m_font;

wxColour m_textForeground;

wxColour m_textBackground;

{

Clipper( wxDC * dc, const wxRect &rect )

{

m_dc = dc;

m_clipEverything = true;

if ( m_dc )

{

dc->GetClippingBox( m_boxOld );

wxRect newRect = rect;

m_clipEverything = !( newRect.Intersects( m_boxOld )

|| ( m_boxOld.width == 0 && m_boxOld.height == 0 ) );

if ( m_clipEverything )

dc->SetClippingRegion( wxRect( -1, -1, 1, 1 ) ); //not sure if this works

else

dc->SetClippingRegion( rect );

}

}

~Clipper( )

{

if ( m_dc )

{

m_dc->DestroyClippingRegion();

m_dc->SetClippingRegion( wxRect( 0, 0, 0, 0 ) );

m_dc->DestroyClippingRegion();

if ( m_boxOld.width != 0 && m_boxOld.height != 0 )

m_dc->SetClippingRegion( m_boxOld );

}

}

bool isEverythingClipped()

{

return m_clipEverything;

}

wxDC *m_dc;

wxRect m_boxOld;

bool m_clipEverything;

{

Rand()

{

#ifdef WIN32

rand_s( &m_seed );

#else

std::fstream fin( "/dev/random", std::ios::in );

fin.read( (char *) ( &m_seed ), sizeof ( m_seed ) );

fin.close();

#endif

}

Rand( unsigned int seed )

{

m_seed = seed;

}

unsigned int operator()()

{

unsigned int next = m_seed;

int result;

next *= 1103515245;

next += 12345;

result = (unsigned int) ( next / max ) % 2048;

next *= 1103515245;

next += 12345;

result <<= 10;

result ^= (unsigned int) ( next / max ) % 1024;

next *= 1103515245;

next += 12345;

result <<= 10;

result ^= (unsigned int) ( next / max ) % 1024;

m_seed = next;

return result;

}

static const unsigned int max = 65536;

unsigned int m_seed;

{

unsigned char plFontFamily, plFontStyle, plFontWeight;

plP_fci2hex( fci, &plFontFamily, PL_FCI_FAMILY );

plP_fci2hex( fci, &plFontStyle, PL_FCI_STYLE );

plP_fci2hex( fci, &plFontWeight, PL_FCI_WEIGHT );

family = fontFamilyLookup[plFontFamily];

style = fontStyleLookup[plFontStyle];

weight = fontWeightLookup[plFontWeight];

pt = ROUND( scaledFontSize );

{

//set m_prevScaledFontSize to a nan to ensure testing the prev values

//always gives false

m_prevFci = 0;

m_prevScaledFontSize = std::numeric_limits<PLFLT>::quiet_NaN();

m_prevUnderlined = false;

m_lastWasCached = false;

{

if ( m_prevFci == fci && m_prevScaledFontSize == scaledFontSize

&& m_prevUnderlined == underlined )

{

m_lastWasCached = true;

return m_prevFont;

}

m_prevFci = fci;

m_prevScaledFontSize = scaledFontSize;

m_prevUnderlined = underlined;

m_lastWasCached = false;

wxFontFamily family;

int style;

int weight;

int pt;

plFontToWxFontParameters( fci, scaledFontSize, family, style, weight, pt );

return m_prevFont = wxFont( pt, family, style, weight, underlined, wxEmptyString, wxFONTENCODING_DEFAULT );

: m_plplotEdgeLength( PLFLT( SHRT_MAX ) )

{

m_fixedAspect = false;

m_lineSpacing = 1.0;

m_dc = NULL;

m_prevSingleCharString = 0;

m_prevSingleCharStringWidth = 0;

m_prevSingleCharStringHeight = 0;

if ( mfo )

strcpy( m_mfo, mfo );

else

//assume we will be outputting to the default

//memory map until we are given a dc to draw to

#ifdef WXPLVIEWER_DEBUG

strcpy( m_mfo, "plplotMemoryMap" );

#else

strcpy( m_mfo, "plplotMemoryMap??????????" );

#endif

// be verbose and write out debug messages

#ifdef _DEBUG

pls->verbose = 1;

pls->debug = 1;

#endif

pls->color = 1; // Is a color device

pls->dev_flush = 1; // Handles flushes

pls->dev_fill0 = 1; // Can handle solid fills

pls->dev_fill1 = 0; // Can't handle pattern fills

pls->dev_dash = 0;

pls->dev_clear = 1; // driver supports clear

pls->plbuf_write = 1; // use the plot buffer!

pls->termin = ( strlen( m_mfo ) ) > 0 ? 0 : 1; // interactive device unless we are writing to memory - pretty sure this is an unused option though

pls->graphx = GRAPHICS_MODE; // This indicates this is a graphics driver. PLPlot with therefore cal pltext() before outputting text, however we currently have not implemented catching that text.

if ( text )

{

pls->dev_text = 1; // want to draw text

pls->dev_unicode = 1; // want unicode

if ( hrshsym )

pls->dev_hrshsym = 1;

}

// Set up physical limits of plotting device in plplot internal units

// we just tell plplot we are the maximum plint in both dimensions

//which gives us the best resolution

plP_setphy( (PLINT) 0, (PLINT) SHRT_MAX,

(PLINT) 0, (PLINT) SHRT_MAX );

// set dpi and page size defaults

// the user might have already set this with plspage

// so check first

if ( !plsc->pageset )

c_plspage( 90, 90, 900, 675, 0, 0 );

//check dpi is non-zero otherwise we get infinities in some calcualtions

//and ridiculous numbers in others

if ( pls->xdpi == 0.0 || pls->ydpi == 0 )

{

if ( pls->xdpi == 0.0 && pls->ydpi == 0 )

c_plspage( 90, 90, 0, 0, 0, 0 );

else

{

PLFLT dpi = MAX( pls->xdpi, pls->ydpi );

pls->xdpi = dpi;

pls->ydpi = dpi;

}

}

m_localBufferPosition = 0;

SetSize( pls, plsc->xlength, plsc->ylength );

if ( pls->dev_data )

SetDC( pls, (wxDC *) pls->dev_data );

else

SetupMemoryMap();

//this must be the absolute last thing that is done

//so that if an exception is thrown pls->dev remains as NULL

pls->dev = (void *) this;

{

if ( !m_dc && pls->nopause )

TransmitBuffer( pls, transmissionClose );

{

if ( !m_dc )

return;

Clipper clipper( m_dc, GetClipRegion().GetBox() );

Scaler scaler( m_dc, 1.0 / m_scale, 1.0 / m_scale );

DrawingObjectsChanger drawingObjectsChanger( m_dc, m_pen, m_brush );

m_dc->DrawLine( (wxCoord) ( m_xAspect * x1a ), (wxCoord) ( m_yAspect * ( m_plplotEdgeLength - y1a ) ),

(wxCoord) ( m_xAspect * x2a ), (wxCoord) ( m_yAspect * ( m_plplotEdgeLength - y2a ) ) );

{

if ( !m_dc )

return;

Clipper clipper( m_dc, GetClipRegion().GetBox() );

Scaler scaler( m_dc, 1.0 / m_scale, 1.0 / m_scale );

DrawingObjectsChanger drawingObjectsChanger( m_dc, m_pen, m_brush );

for ( PLINT i = 1; i < npts; i++ )

m_dc->DrawLine( m_xAspect * xa[i - 1], m_yAspect * ( m_plplotEdgeLength - ya[i - 1] ),

m_xAspect * xa[i], m_yAspect * ( m_plplotEdgeLength - ya[i] ) );

{

if ( !m_dc )

return;

x1 = x1 < 0 ? 0 : x1;

x2 = x2 < 0 ? m_plplotEdgeLength : x2;

y1 = y1 < 0 ? 0 : y1;

y2 = y2 < 0 ? m_plplotEdgeLength : y2;

PLINT x = MIN( x1, x2 );

PLINT y = MIN( y1, y2 );

PLINT width = abs( x1 - x2 );

PLINT height = abs( y1 - y2 );

if ( width > 0 && height > 0 )

{

PLINT r, g, b;

PLFLT a;

plgcolbga( &r, &g, &b, &a );

wxColour bgColour( r, g, b, a * 255 );

DrawingObjectsChanger changer( m_dc, wxPen( bgColour, 0 ), wxBrush( bgColour ) );

m_dc->DrawRectangle( x, y, width, height );

}

{

if ( !m_dc )

return;

//edge the polygon with a 0.5 pixel line to avoid seams. This is a

//bit of a bodge really but this is a difficult problem

wxPen edgePen( m_brush.GetColour(), m_scale, wxSOLID );

DrawingObjectsChanger changer( m_dc, edgePen, m_brush );

//DrawingObjectsChanger changer(m_dc, wxNullPen, m_brush );

Scaler scaler( m_dc, 1.0 / m_scale, 1.0 / m_scale );

wxPoint *points = new wxPoint[pls->dev_npts];

wxCoord xoffset = 0;

wxCoord yoffset = 0;

for ( int i = 0; i < pls->dev_npts; i++ )

{

points[i].x = (int) ( m_xAspect * pls->dev_x[i] );

points[i].y = (int) ( m_yAspect * ( m_plplotEdgeLength - pls->dev_y[i] ) );

}

if ( pls->dev_eofill )

{

m_dc->DrawPolygon( pls->dev_npts, points, xoffset, yoffset, wxODDEVEN_RULE );

}

else

{

m_dc->DrawPolygon( pls->dev_npts, points, xoffset, yoffset, wxWINDING_RULE );

}

delete[] points;

{

PLFLT width = ( pls->width > 0.0 ? pls->width : 1.0 ) * m_scale;

m_pen = wxPen( wxColour( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b,

pls->curcolor.a * 255 ), width, wxSOLID );

{

PLFLT width = ( pls->width > 0.0 ? pls->width : 1.0 ) * m_scale;

m_pen = wxPen( wxColour( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b,

pls->curcolor.a * 255 ), width, wxSOLID );

m_brush = wxBrush( wxColour( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b,

pls->curcolor.a * 255 ) );

{

if ( m_outputMemoryMap.isValid() )

throw( "wxPLDevice::SetDC The DC must be set before initialisation. The device is outputting to a separate viewer" );

m_dc = dc; // Add the dc to the device

m_useDcTextTransform = false;

m_gc = NULL;

if ( m_dc )

{

#if wxVERSION_NUMBER >= 2902

m_useDcTextTransform = m_dc->CanUseTransformMatrix();

#endif

//If we don't have wxDC tranforms we can use the

//underlying wxGCDC if this is a wxGCDC

if ( !m_useDcTextTransform )

{

//check to see if m_dc is a wxGCDC by using RTTI

wxGCDC *gcdc = NULL;

try

{

//put this in a try block as I'm not sure if it will throw if

//RTTI is switched off

gcdc = dynamic_cast< wxGCDC* >( m_dc );

}

catch ( ... )

{

}

if ( gcdc )

m_gc = gcdc->GetGraphicsContext();

}

strcpy( m_mfo, "" );

SetSize( pls, m_width, m_height ); //call with our current size to set the scaling

pls->has_string_length = 1; // Driver supports string length calculations, if we have a dc to draw on

}

else

{

pls->has_string_length = 0; //if we have no device to draw on we cannot check string size

}

{

if ( superscriptLevel == 0 )

return 0;

else

{

PLFLT fontScale = pow( 0.8, abs( superscriptLevel ) );

if ( superscriptLevel > 0 )

return getTextOffset( superscriptLevel - 1, baseFontSize ) + baseFontSize * fontScale / 2.;

else

return getTextOffset( superscriptLevel + 1, baseFontSize ) - baseFontSize * fontScale * 0.8 / 2.;

}

{

if ( !m_dc && drawText )

return;

char utf8_string[m_max_string_length];

char utf8[5];

memset( utf8_string, '\0', m_max_string_length );

// Get PLplot escape character

char plplotEsc;

plgesc( &plplotEsc );

//Reset the size metrics

m_textWidth = 0;

m_textHeight = 0;

m_superscriptHeight = 0;

m_subscriptDepth = 0;

int i = 0;

while ( i < ucs4Len )

{

if ( ucs4[i] < PL_FCI_MARK ) // not a font change

{

if ( ucs4[i] != (PLUNICODE) plplotEsc ) // a character to display

{

ucs4_to_utf8( ucs4[i], utf8 );

strncat( utf8_string, utf8,

sizeof ( utf8_string ) - strlen( utf8_string ) - 1 );

i++;

continue;

}

i++;

if ( ucs4[i] == (PLUNICODE) plplotEsc ) // a escape character to display

{

ucs4_to_utf8( ucs4[i], utf8 );

strncat( utf8_string, utf8,

sizeof ( utf8_string ) - strlen( utf8_string ) - 1 );

i++;

continue;

}

else

{

if ( ucs4[i] == (PLUNICODE) 'u' ) // Superscript

{ // draw string so far

PLFLT fontScale = pow( 0.8, abs( superscriptLevel ) );

PLFLT yOffset = getTextOffset( superscriptLevel, baseFontSize ) * m_yScale;

DrawTextSection( utf8_string, baseFontSize * fontScale, yOffset, underlined, drawText );

++superscriptLevel;

fontScale = pow( 0.8, abs( superscriptLevel ) );

if ( m_dc )

m_dc->SetFont( m_fontGrabber.GetFont( m_fci, baseFontSize * fontScale, underlined ) );

}

if ( ucs4[i] == (PLUNICODE) 'd' ) // Subscript

{ // draw string so far

PLFLT fontScale = pow( 0.8, abs( superscriptLevel ) );

PLFLT yOffset = getTextOffset( superscriptLevel, baseFontSize ) * m_yScale;

DrawTextSection( utf8_string, baseFontSize * fontScale, yOffset, underlined, drawText );

--superscriptLevel;

fontScale = pow( 0.8, abs( superscriptLevel ) );

if ( m_dc )

m_dc->SetFont( m_fontGrabber.GetFont( m_fci, baseFontSize * fontScale, underlined ) );

}

if ( ucs4[i] == (PLUNICODE) '-' ) // underline

{ // draw string so far

PLFLT fontScale = pow( 0.8, abs( superscriptLevel ) );

PLFLT yOffset = getTextOffset( superscriptLevel, baseFontSize ) * m_yScale;

DrawTextSection( utf8_string, baseFontSize * fontScale, yOffset, underlined, drawText );

underlined = !underlined;

if ( m_dc )

m_dc->SetFont( m_fontGrabber.GetFont( m_fci, baseFontSize * fontScale, underlined ) );

}

if ( ucs4[i] == (PLUNICODE) '+' ) // overline

{ // not implemented yet

}

i++;

}

}

else // a font change

{

// draw string so far

PLFLT fontScale = pow( 0.8, abs( superscriptLevel ) );

PLFLT yOffset = getTextOffset( superscriptLevel, baseFontSize ) * m_yScale;

DrawTextSection( utf8_string, baseFontSize * fontScale, yOffset, underlined, drawText );

// get new font

m_fci = ucs4[i];

if ( m_dc )

m_dc->SetFont( m_fontGrabber.GetFont( m_fci, baseFontSize * fontScale, underlined ) );

i++;

}

}

//we have reached the end of the string. Draw the remainder.

PLFLT fontScale = pow( 0.8, abs( superscriptLevel ) );

PLFLT yOffset = getTextOffset( superscriptLevel, baseFontSize ) * m_yScale;

DrawTextSection( utf8_string, baseFontSize * fontScale, yOffset, underlined, drawText );

{

if ( !m_dc && drawText )

return;

wxCoord w, h, d, l;

wxString str = wxString::FromUTF8( utf8_string );

//wxString str( wxConvUTF8.cMB2WC( utf8_string ), *wxConvCurrent );

if ( m_dc )

m_dc->GetTextExtent( str, &w, &h, &d, &l );

if ( !m_dc && m_outputMemoryMap.isValid() )

{

MemoryMapHeader *header = (MemoryMapHeader *) ( m_outputMemoryMap.getBuffer() );

header->textSizeInfo.written = false;

plFontToWxFontParameters( m_fci, scaledFontSize, header->textSizeInfo.family, header->textSizeInfo.style,

header->textSizeInfo.weight, header->textSizeInfo.pt );

header->textSizeInfo.underlined = underlined;

bool gotResponse = false;

TransmitBuffer( NULL, transmissionRequestTextSize );

size_t counter = 0;

while ( !gotResponse && counter < 1000 )

{

gotResponse = header->textSizeInfo.written;

++counter;

wxMilliSleep( 1 );

}

if ( counter == 1000 )

plwarn( "Failed to get text size from wxPLViewer - timeout" );

w = header->textSizeInfo.width;

h = header->textSizeInfo.height;

}

if ( drawText )

{

//if we are using wxDC transforms or the wxGC, then the transformations

//have already been applied

if ( m_gc )

m_gc->DrawText( str, m_textWidth, -yOffset / m_yScale );

else if ( m_useDcTextTransform )

m_dc->DrawText( str, m_textWidth, -yOffset / m_yScale );

else

{

//If we are stuck with a wxDC that has no transformation abilities then

// all we can really do is rotate the text - this is a bit of a poor state

// really, but to be honest it is better than defaulting to hershey for all

// text

if ( m_rotation == 0 )

m_dc->DrawRotatedText( str, (wxCoord) ( m_posX + m_textWidth ),

(wxCoord) ( m_height - (wxCoord) ( m_posY + yOffset / m_yScale ) ),

m_rotation * 180.0 / M_PI );

else

m_dc->DrawRotatedText( str,

(wxCoord) ( m_posX - yOffset / m_yScale * sin( m_rotation ) + m_textWidth * cos( m_rotation ) ),

(wxCoord) ( m_height - (wxCoord) ( m_posY + yOffset * cos( m_rotation ) / m_yScale ) - m_textWidth * sin( m_rotation ) ),

m_rotation * 180.0 / M_PI );

}

}

m_textWidth += w;

//keep track of the height of superscript text, the depth of subscript

//text and the height of regular text

if ( yOffset > 0.0001 )

{

//determine the height the text would have if it were full size

double currentOffset = yOffset;

double currentHeight = h;

while ( currentOffset > 0.0001 )

{

currentOffset -= m_yScale * scaledFontSize / 2.;

currentHeight *= 1.25;

}

m_textHeight = (wxCoord) m_textHeight > ( currentHeight )

? m_textHeight

: currentHeight;

//work out the height including superscript

m_superscriptHeight = m_superscriptHeight > ( currentHeight + yOffset / m_yScale )

? m_superscriptHeight

: static_cast<int>( ( currentHeight + yOffset / m_yScale ) );

}

else if ( yOffset < -0.0001 )

{

//determine the height the text would have if it were full size

double currentOffset = yOffset;

double currentHeight = h;

double currentDepth = d;

while ( currentOffset < -0.0001 )

{

currentOffset += m_yScale * scaledFontSize * 1.25 / 2.;

currentHeight *= 1.25;

currentDepth *= 1.25;

}

m_textHeight = (wxCoord) m_textHeight > currentHeight ? m_textHeight : currentHeight;

//work out the additional depth for subscript note an assumption has been made

//that the font size of (non-superscript and non-subscript) text is the same

//along a line. Currently there is no escape to change font size mid string

//so this should be fine

m_subscriptDepth = (wxCoord) m_subscriptDepth > ( ( -yOffset / m_yScale + h + d ) - ( currentDepth + m_textHeight ) )

? m_subscriptDepth

: ( ( -yOffset / m_yScale + h + d ) - ( currentDepth + m_textHeight ) );

m_subscriptDepth = m_subscriptDepth > 0 ? m_subscriptDepth : 0;

}

else

m_textHeight = (wxCoord) m_textHeight > ( h ) ? m_textHeight : h;

memset( utf8_string, '\0', m_max_string_length );

{

if ( !m_dc && !m_outputMemoryMap.isValid() )

return;

m_textWidth = 0;

m_textHeight = 0;

m_textDescent = 0;

m_textLeading = 0;

//for text, work in native coordinates, partly to avoid rewriting existing code

//but also because we should get better text hinting for screen display I think.

//The scaler object sets the scale to the new value until it is destroyed

//when this function exits.

Scaler scaler( m_dc, 1.0, 1.0 );

//Also move the origin so the text region buts up to the dc top, not the bottom

OriginChanger originChanger( m_dc, 0, wxCoord( m_height - m_plplotEdgeLength / m_yScale ) );

// Check that we got unicode, warning message and return if not

if ( args->unicode_array_len == 0 )

{

printf( "Non unicode string passed to the wxWidgets driver, ignoring\n" );

return;

}

// Check that unicode string isn't longer then the max we allow

if ( args->unicode_array_len >= 500 )

{

printf( "Sorry, the wxWidgets drivers only handles strings of length < %d\n", 500 );

return;

}

// Calculate the font size (in pt)

// Plplot saves it in mm (bizarre units!)

PLFLT baseFontSize = pls->chrht * 72.0 / 25.4;

// Use PLplot core routine to get the corners of the clipping rectangle

PLINT rcx[4], rcy[4];

difilt_clip( rcx, rcy );

wxPoint cpoints[4];

for ( int i = 0; i < 4; i++ )

{

cpoints[i].x = rcx[i] / m_xScale;

cpoints[i].y = m_height - rcy[i] / m_yScale;

}

Clipper clipper( m_dc, wxRegion( 4, cpoints ).GetBox() );

PLUNICODE *lineStart = args->unicode_array;

int lineLen = 0;

bool lineFeed = false;

bool carriageReturn = false;

wxCoord paraHeight = 0;

// Get the curent font

PLINT superscriptLevel = 0;

bool underlined = 0;

plgfci( &m_fci );

//set the font up, we use a textObjectChanger here so that the font returns

//to its original value on exit

TextObjectsChanger textObjectsChanger( m_dc, m_fontGrabber.GetFont( m_fci, baseFontSize, underlined ),

wxColour( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a * 255 ),

wxColour( pls->curcolor.r, pls->curcolor.g, pls->curcolor.b, pls->curcolor.a * 255 ) );

bool lastFontWasCached = m_fontGrabber.lastWasCached();

//draw each line of text individually and record the width of the paragraph

wxCoord paragraphWidth = 0;

while ( lineStart != args->unicode_array + args->unicode_array_len )

{

//remember the text parameters so they can be restored

double lineStartSuperscriptLevel = superscriptLevel;

PLUNICODE lineStartFci = m_fci;

bool lineStartUnderlined = underlined;

while ( lineStart + lineLen != args->unicode_array + args->unicode_array_len

&& *( lineStart + lineLen ) != (PLUNICODE) '\n' )

{

lineLen++;

}

//set line feed for the beginning of this line and

//carriage return for the end

lineFeed = carriageReturn;

carriageReturn = lineStart + lineLen != args->unicode_array + args->unicode_array_len

&& *( lineStart + lineLen ) == (PLUNICODE) ( '\n' );

if ( lineFeed )