From 039ac92480a09266146fc5b0c9ec67a32a2565ad Mon Sep 17 00:00:00 2001 From: saurabhb17 Date: Wed, 26 Feb 2020 16:04:40 +0530 Subject: Added secondary files --- common/common_plotDXF_functions.cpp | 815 ++++++++++++++++++++++++++++++++++++ 1 file changed, 815 insertions(+) create mode 100644 common/common_plotDXF_functions.cpp (limited to 'common/common_plotDXF_functions.cpp') diff --git a/common/common_plotDXF_functions.cpp b/common/common_plotDXF_functions.cpp new file mode 100644 index 0000000..5544ab1 --- /dev/null +++ b/common/common_plotDXF_functions.cpp @@ -0,0 +1,815 @@ +/** + * @file common_plotDXF_functions.cpp + * @brief KiCad: Common plot DXF Routines. + */ +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 2015 KiCad Developers, see CHANGELOG.TXT for contributors. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, you may find one here: + * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html + * or you may search the http://www.gnu.org website for the version 2 license, + * or you may write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * Oblique angle for DXF native text + * (I don't remember if 15 degrees is the ISO value... it looks nice anyway) + */ +static const double DXF_OBLIQUE_ANGLE = 15; + +/** + * Set the scale/position for the DXF plot + * The DXF engine doesn't support line widths and mirroring. The output + * coordinate system is in the first quadrant (in mm) + */ +void DXF_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil, + double aScale, bool aMirror ) +{ + plotOffset = aOffset; + plotScale = aScale; + + /* DXF paper is 'virtual' so there is no need of a paper size. + Also this way we can handle the aux origin which can be useful + (for example when aligning to a mechanical drawing) */ + paperSize.x = 0; + paperSize.y = 0; + + /* Like paper size DXF units are abstract too. Anyway there is a + * system variable (MEASUREMENT) which will be set to 1 to indicate + * metric units */ + m_IUsPerDecimil = aIusPerDecimil; + iuPerDeviceUnit = 1.0 / aIusPerDecimil; // Gives a DXF in decimils + iuPerDeviceUnit *= 0.00254; // ... now in mm + + SetDefaultLineWidth( 0 ); // No line width on DXF + m_plotMirror = false; // No mirroring on DXF + m_currentColor = BLACK; +} + +/** + * Opens the DXF plot with a skeleton header + */ +bool DXF_PLOTTER::StartPlot() +{ + wxASSERT( outputFile ); + + // DXF HEADER - Boilerplate + // Defines the minimum for drawing i.e. the angle system and the + // continuous linetype + fputs( " 0\n" + "SECTION\n" + " 2\n" + "HEADER\n" + " 9\n" + "$ANGBASE\n" + " 50\n" + "0.0\n" + " 9\n" + "$ANGDIR\n" + " 70\n" + " 1\n" + " 9\n" + "$MEASUREMENT\n" + " 70\n" + "0\n" + " 0\n" // This means 'metric units' + "ENDSEC\n" + " 0\n" + "SECTION\n" + " 2\n" + "TABLES\n" + " 0\n" + "TABLE\n" + " 2\n" + "LTYPE\n" + " 70\n" + "1\n" + " 0\n" + "LTYPE\n" + " 2\n" + "CONTINUOUS\n" + " 70\n" + "0\n" + " 3\n" + "Solid line\n" + " 72\n" + "65\n" + " 73\n" + "0\n" + " 40\n" + "0.0\n" + " 0\n" + "ENDTAB\n", + outputFile ); + + // Text styles table + // Defines 4 text styles, one for each bold/italic combination + fputs( " 0\n" + "TABLE\n" + " 2\n" + "STYLE\n" + " 70\n" + "4\n", outputFile ); + + static const char *style_name[4] = {"KICAD", "KICADB", "KICADI", "KICADBI"}; + for(int i = 0; i < 4; i++ ) + { + fprintf( outputFile, + " 0\n" + "STYLE\n" + " 2\n" + "%s\n" // Style name + " 70\n" + "0\n" // Standard flags + " 40\n" + "0\n" // Non-fixed height text + " 41\n" + "1\n" // Width factor (base) + " 42\n" + "1\n" // Last height (mandatory) + " 50\n" + "%g\n" // Oblique angle + " 71\n" + "0\n" // Generation flags (default) + " 3\n" + // The standard ISO font (when kicad is build with it + // the dxf text in acad matches *perfectly*) + "isocp.shx\n", // Font name (when not bigfont) + // Apply a 15 degree angle to italic text + style_name[i], i < 2 ? 0 : DXF_OBLIQUE_ANGLE ); + } + + + // Layer table - one layer per color + fprintf( outputFile, + " 0\n" + "ENDTAB\n" + " 0\n" + "TABLE\n" + " 2\n" + "LAYER\n" + " 70\n" + "%d\n", NBCOLORS ); + + /* The layer/colors palette. The acad/DXF palette is divided in 3 zones: + + - The primary colors (1 - 9) + - An HSV zone (10-250, 5 values x 2 saturations x 10 hues + - Greys (251 - 255) + + There is *no* black... the white does it on paper, usually, and + anyway it depends on the plotter configuration, since DXF colors + are meant to be logical only (they represent *both* line color and + width); later version with plot styles only complicate the matter! + + As usual, brown and magenta/purple are difficult to place since + they are actually variations of other colors. + */ + static const struct { + const char *name; + int color; + } dxf_layer[NBCOLORS] = { + { "BLACK", 7 }, // In DXF, color 7 is *both* white and black! + { "GRAY1", 251 }, + { "GRAY2", 8 }, + { "GRAY3", 9 }, + { "WHITE", 7 }, + { "LYELLOW", 51 }, + { "BLUE1", 178 }, + { "GREEN1", 98 }, + { "CYAN1", 138 }, + { "RED1", 18 }, + { "MAGENTA1", 228 }, + { "BROWN1", 58 }, + { "BLUE2", 5 }, + { "GREEN2", 3 }, + { "CYAN2", 4 }, + { "RED2", 1 }, + { "MAGENTA2", 6 }, + { "BROWN2", 54 }, + { "BLUE3", 171 }, + { "GREEN3", 91 }, + { "CYAN3", 131 }, + { "RED3", 11 }, + { "MAGENTA3", 221 }, + { "YELLOW3", 2 }, + { "BLUE4", 5 }, + { "GREEN4", 3 }, + { "CYAN4", 4 }, + { "RED4", 1 }, + { "MAGENTA4", 6 }, + { "YELLOW4", 2 } + }; + + for( EDA_COLOR_T i = BLACK; i < NBCOLORS; i = NextColor(i) ) + { + fprintf( outputFile, + " 0\n" + "LAYER\n" + " 2\n" + "%s\n" // Layer name + " 70\n" + "0\n" // Standard flags + " 62\n" + "%d\n" // Color number + " 6\n" + "CONTINUOUS\n",// Linetype name + dxf_layer[i].name, dxf_layer[i].color ); + } + + // End of layer table, begin entities + fputs( " 0\n" + "ENDTAB\n" + " 0\n" + "ENDSEC\n" + " 0\n" + "SECTION\n" + " 2\n" + "ENTITIES\n", outputFile ); + + return true; +} + + +bool DXF_PLOTTER::EndPlot() +{ + wxASSERT( outputFile ); + + // DXF FOOTER + fputs( " 0\n" + "ENDSEC\n" + " 0\n" + "EOF\n", outputFile ); + fclose( outputFile ); + outputFile = NULL; + + return true; +} + + +/** + * The DXF exporter handles 'colors' as layers... + */ +void DXF_PLOTTER::SetColor( EDA_COLOR_T color ) +{ + if( ( color >= 0 && colorMode ) + || ( color == BLACK ) + || ( color == WHITE ) ) + { + m_currentColor = color; + } + else + m_currentColor = BLACK; +} + +/** + * DXF rectangle: fill not supported + */ +void DXF_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width ) +{ + MoveTo( p1 ); + LineTo( wxPoint( p1.x, p2.y ) ); + LineTo( wxPoint( p2.x, p2.y ) ); + LineTo( wxPoint( p2.x, p1.y ) ); + FinishTo( wxPoint( p1.x, p1.y ) ); +} + + +/** + * DXF circle: full functionality; it even does 'fills' drawing a + * circle with a dual-arc polyline wide as the radius. + * + * I could use this trick to do other filled primitives + */ +void DXF_PLOTTER::Circle( const wxPoint& centre, int diameter, FILL_T fill, int width ) +{ + wxASSERT( outputFile ); + double radius = userToDeviceSize( diameter / 2 ); + DPOINT centre_dev = userToDeviceCoordinates( centre ); + if( radius > 0 ) + { + wxString cname( ColorGetName( m_currentColor ) ); + if (!fill) + { + fprintf( outputFile, "0\nCIRCLE\n8\n%s\n10\n%g\n20\n%g\n40\n%g\n", + TO_UTF8( cname ), + centre_dev.x, centre_dev.y, radius ); + } + if (fill == FILLED_SHAPE) + { + double r = radius*0.5; + fprintf( outputFile, "0\nPOLYLINE\n"); + fprintf( outputFile, "8\n%s\n66\n1\n70\n1\n", TO_UTF8( cname )); + fprintf( outputFile, "40\n%g\n41\n%g\n", radius, radius); + fprintf( outputFile, "0\nVERTEX\n8\n%s\n", TO_UTF8( cname )); + fprintf( outputFile, "10\n%g\n 20\n%g\n42\n1.0\n", + centre_dev.x-r, centre_dev.y ); + fprintf( outputFile, "0\nVERTEX\n8\n%s\n", TO_UTF8( cname )); + fprintf( outputFile, "10\n%g\n 20\n%g\n42\n1.0\n", + centre_dev.x+r, centre_dev.y ); + fprintf( outputFile, "0\nSEQEND\n"); + } + } +} + + +/** + * DXF polygon: doesn't fill it but at least it close the filled ones + * DXF does not know thick outline. + * It does not know thhick segments, therefore filled polygons with thick outline + * are converted to inflated polygon by aWidth/2 + */ +void DXF_PLOTTER::PlotPoly( const std::vector& aCornerList, + FILL_T aFill, int aWidth) +{ + if( aCornerList.size() <= 1 ) + return; + + unsigned last = aCornerList.size() - 1; + + // Plot outlines with lines (thickness = 0) to define the polygon + if( aWidth <= 0 ) + { + MoveTo( aCornerList[0] ); + + for( unsigned ii = 1; ii < aCornerList.size(); ii++ ) + LineTo( aCornerList[ii] ); + + // Close polygon if 'fill' requested + if( aFill ) + { + if( aCornerList[last] != aCornerList[0] ) + LineTo( aCornerList[0] ); + } + + PenFinish(); + + return; + } + + + // if the polygon outline has thickness, and is not filled + // (i.e. is a polyline) plot outlines with thick segments + if( aWidth > 0 && !aFill ) + { + MoveTo( aCornerList[0] ); + + for( unsigned ii = 1; ii < aCornerList.size(); ii++ ) + ThickSegment( aCornerList[ii-1], aCornerList[ii], + aWidth, FILLED ); + + return; + } + + // The polygon outline has thickness, and is filled + // Build and plot the polygon which contains the initial + // polygon and its thick outline + SHAPE_POLY_SET bufferOutline; + SHAPE_POLY_SET bufferPolybase; + const int circleToSegmentsCount = 16; + + bufferPolybase.NewOutline(); + + // enter outline as polygon: + for( unsigned ii = 1; ii < aCornerList.size(); ii++ ) + { + TransformRoundedEndsSegmentToPolygon( bufferOutline, + aCornerList[ii-1], aCornerList[ii], circleToSegmentsCount, aWidth ); + } + + // enter the initial polygon: + for( unsigned ii = 0; ii < aCornerList.size(); ii++ ) + { + bufferPolybase.Append( aCornerList[ii] ); + } + + // Merge polygons to build the polygon which contains the initial + // polygon and its thick outline + + bufferPolybase.BooleanAdd( bufferOutline ); // create the outline which contains thick outline + bufferPolybase.Fracture(); + + + if( bufferPolybase.OutlineCount() < 1 ) // should not happen + return; + + const SHAPE_LINE_CHAIN& path = bufferPolybase.COutline( 0 ); + + if( path.PointCount() < 2 ) // should not happen + return; + + // Now, output the final polygon to DXF file: + last = path.PointCount() - 1; + VECTOR2I point = path.CPoint( 0 ); + + wxPoint startPoint( point.x, point.y ); + MoveTo( startPoint ); + + for( int ii = 1; ii < path.PointCount(); ii++ ) + { + point = path.CPoint( ii ); + LineTo( wxPoint( point.x, point.y ) ); + } + + // Close polygon, if needed + point = path.CPoint( last ); + wxPoint endPoint( point.x, point.y ); + + if( endPoint != startPoint ) + LineTo( startPoint ); + + PenFinish(); +} + + +void DXF_PLOTTER::PenTo( const wxPoint& pos, char plume ) +{ + wxASSERT( outputFile ); + if( plume == 'Z' ) + { + return; + } + DPOINT pos_dev = userToDeviceCoordinates( pos ); + DPOINT pen_lastpos_dev = userToDeviceCoordinates( penLastpos ); + + if( penLastpos != pos && plume == 'D' ) + { + // DXF LINE + wxString cname( ColorGetName( m_currentColor ) ); + fprintf( outputFile, "0\nLINE\n8\n%s\n10\n%g\n20\n%g\n11\n%g\n21\n%g\n", + TO_UTF8( cname ), + pen_lastpos_dev.x, pen_lastpos_dev.y, pos_dev.x, pos_dev.y ); + } + penLastpos = pos; +} + + +/** + * Dashed lines are not (yet) supported by DXF_PLOTTER + */ +void DXF_PLOTTER::SetDash( bool dashed ) +{ + // NOP for now +} + + +void DXF_PLOTTER::ThickSegment( const wxPoint& aStart, const wxPoint& aEnd, int aWidth, + EDA_DRAW_MODE_T aPlotMode ) +{ + MoveTo( aStart ); + FinishTo( aEnd ); +} + +/* Plot an arc in DXF format + * Filling is not supported + */ +void DXF_PLOTTER::Arc( const wxPoint& centre, double StAngle, double EndAngle, int radius, + FILL_T fill, int width ) +{ + wxASSERT( outputFile ); + + if( radius <= 0 ) + return; + + // In DXF, arcs are drawn CCW. + // In Kicad, arcs are CW or CCW + // If StAngle > EndAngle, it is CW. So transform it to CCW + if( StAngle > EndAngle ) + { + std::swap( StAngle, EndAngle ); + } + + DPOINT centre_dev = userToDeviceCoordinates( centre ); + double radius_dev = userToDeviceSize( radius ); + + // Emit a DXF ARC entity + wxString cname( ColorGetName( m_currentColor ) ); + fprintf( outputFile, + "0\nARC\n8\n%s\n10\n%g\n20\n%g\n40\n%g\n50\n%g\n51\n%g\n", + TO_UTF8( cname ), + centre_dev.x, centre_dev.y, radius_dev, + StAngle / 10.0, EndAngle / 10.0 ); +} + +/** + * DXF oval pad: always done in sketch mode + */ +void DXF_PLOTTER::FlashPadOval( const wxPoint& pos, const wxSize& aSize, double orient, + EDA_DRAW_MODE_T trace_mode ) +{ + wxSize size( aSize ); + + /* The chip is reduced to an oval tablet with size.y > size.x + * (Oval vertical orientation 0) */ + if( size.x > size.y ) + { + std::swap( size.x, size.y ); + orient = AddAngles( orient, 900 ); + } + + sketchOval( pos, size, orient, -1 ); +} + + +/** + * DXF round pad: always done in sketch mode; it could be filled but it isn't + * pretty if other kinds of pad aren't... + */ +void DXF_PLOTTER::FlashPadCircle( const wxPoint& pos, int diametre, + EDA_DRAW_MODE_T trace_mode ) +{ + Circle( pos, diametre, NO_FILL ); +} + + +/** + * DXF rectangular pad: alwayd done in sketch mode + */ +void DXF_PLOTTER::FlashPadRect( const wxPoint& pos, const wxSize& padsize, + double orient, EDA_DRAW_MODE_T trace_mode ) +{ + wxASSERT( outputFile ); + wxSize size; + int ox, oy, fx, fy; + + size.x = padsize.x / 2; + size.y = padsize.y / 2; + + if( size.x < 0 ) + size.x = 0; + if( size.y < 0 ) + size.y = 0; + + // If a dimension is zero, the trace is reduced to 1 line + if( size.x == 0 ) + { + ox = pos.x; + oy = pos.y - size.y; + RotatePoint( &ox, &oy, pos.x, pos.y, orient ); + fx = pos.x; + fy = pos.y + size.y; + RotatePoint( &fx, &fy, pos.x, pos.y, orient ); + MoveTo( wxPoint( ox, oy ) ); + FinishTo( wxPoint( fx, fy ) ); + return; + } + if( size.y == 0 ) + { + ox = pos.x - size.x; + oy = pos.y; + RotatePoint( &ox, &oy, pos.x, pos.y, orient ); + fx = pos.x + size.x; + fy = pos.y; + RotatePoint( &fx, &fy, pos.x, pos.y, orient ); + MoveTo( wxPoint( ox, oy ) ); + FinishTo( wxPoint( fx, fy ) ); + return; + } + + ox = pos.x - size.x; + oy = pos.y - size.y; + RotatePoint( &ox, &oy, pos.x, pos.y, orient ); + MoveTo( wxPoint( ox, oy ) ); + + fx = pos.x - size.x; + fy = pos.y + size.y; + RotatePoint( &fx, &fy, pos.x, pos.y, orient ); + LineTo( wxPoint( fx, fy ) ); + + fx = pos.x + size.x; + fy = pos.y + size.y; + RotatePoint( &fx, &fy, pos.x, pos.y, orient ); + LineTo( wxPoint( fx, fy ) ); + + fx = pos.x + size.x; + fy = pos.y - size.y; + RotatePoint( &fx, &fy, pos.x, pos.y, orient ); + LineTo( wxPoint( fx, fy ) ); + + FinishTo( wxPoint( ox, oy ) ); +} + + +/** + * DXF trapezoidal pad: only sketch mode is supported + */ +void DXF_PLOTTER::FlashPadTrapez( const wxPoint& aPadPos, const wxPoint *aCorners, + double aPadOrient, EDA_DRAW_MODE_T aTrace_Mode ) +{ + wxPoint coord[4]; /* coord actual corners of a trapezoidal trace */ + + for( int ii = 0; ii < 4; ii++ ) + { + coord[ii] = aCorners[ii]; + RotatePoint( &coord[ii], aPadOrient ); + coord[ii] += aPadPos; + } + + // Plot edge: + MoveTo( coord[0] ); + LineTo( coord[1] ); + LineTo( coord[2] ); + LineTo( coord[3] ); + FinishTo( coord[0] ); +} + +/** + * Checks if a given string contains non-ASCII characters. + * FIXME: the performance of this code is really poor, but in this case it can be + * acceptable because the plot operation is not called very often. + * @param string String to check + * @return true if it contains some non-ASCII character, false if all characters are + * inside ASCII range (<=255). + */ +bool containsNonAsciiChars( const wxString& string ) +{ + for( unsigned i = 0; i < string.length(); i++ ) + { + wchar_t ch = string[i]; + if( ch > 255 ) + return true; + } + return false; +} + +void DXF_PLOTTER::Text( const wxPoint& aPos, + enum EDA_COLOR_T aColor, + const wxString& aText, + double aOrient, + const wxSize& aSize, + enum EDA_TEXT_HJUSTIFY_T aH_justify, + enum EDA_TEXT_VJUSTIFY_T aV_justify, + int aWidth, + bool aItalic, + bool aBold, + bool aMultilineAllowed ) +{ + // Fix me: see how to use DXF text mode for multiline texts + if( aMultilineAllowed && !aText.Contains( wxT( "\n" ) ) ) + aMultilineAllowed = false; // the text has only one line. + + if( textAsLines || containsNonAsciiChars( aText ) || aMultilineAllowed ) + { + // output text as graphics. + // Perhaps multiline texts could be handled as DXF text entity + // but I do not want spend time about this (JPC) + PLOTTER::Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, + aWidth, aItalic, aBold, aMultilineAllowed ); + } + else + { + /* Emit text as a text entity. This loses formatting and shape but it's + more useful as a CAD object */ + DPOINT origin_dev = userToDeviceCoordinates( aPos ); + SetColor( aColor ); + wxString cname( ColorGetName( m_currentColor ) ); + DPOINT size_dev = userToDeviceSize( aSize ); + int h_code = 0, v_code = 0; + switch( aH_justify ) + { + case GR_TEXT_HJUSTIFY_LEFT: + h_code = 0; + break; + case GR_TEXT_HJUSTIFY_CENTER: + h_code = 1; + break; + case GR_TEXT_HJUSTIFY_RIGHT: + h_code = 2; + break; + } + switch( aV_justify ) + { + case GR_TEXT_VJUSTIFY_TOP: + v_code = 3; + break; + case GR_TEXT_VJUSTIFY_CENTER: + v_code = 2; + break; + case GR_TEXT_VJUSTIFY_BOTTOM: + v_code = 1; + break; + } + + // Position, size, rotation and alignment + // The two alignment point usages is somewhat idiot (see the DXF ref) + // Anyway since we don't use the fit/aligned options, they're the same + fprintf( outputFile, + " 0\n" + "TEXT\n" + " 7\n" + "%s\n" // Text style + " 8\n" + "%s\n" // Layer name + " 10\n" + "%g\n" // First point X + " 11\n" + "%g\n" // Second point X + " 20\n" + "%g\n" // First point Y + " 21\n" + "%g\n" // Second point Y + " 40\n" + "%g\n" // Text height + " 41\n" + "%g\n" // Width factor + " 50\n" + "%g\n" // Rotation + " 51\n" + "%g\n" // Oblique angle + " 71\n" + "%d\n" // Mirror flags + " 72\n" + "%d\n" // H alignment + " 73\n" + "%d\n", // V alignment + aBold ? (aItalic ? "KICADBI" : "KICADB") + : (aItalic ? "KICADI" : "KICAD"), + TO_UTF8( cname ), + origin_dev.x, origin_dev.x, + origin_dev.y, origin_dev.y, + size_dev.y, fabs( size_dev.x / size_dev.y ), + aOrient / 10.0, + aItalic ? DXF_OBLIQUE_ANGLE : 0, + size_dev.x < 0 ? 2 : 0, // X mirror flag + h_code, v_code ); + + /* There are two issue in emitting the text: + - Our overline character (~) must be converted to the appropriate + control sequence %%O or %%o + - Text encoding in DXF is more or less unspecified since depends on + the DXF declared version, the acad version reading it *and* some + system variables to be put in the header handled only by newer acads + Also before R15 unicode simply is not supported (you need to use + bigfonts which are a massive PITA). Common denominator solution: + use Latin1 (and however someone could choke on it, anyway). Sorry + for the extended latin people. If somewant want to try fixing this + recent version seems to use UTF-8 (and not UCS2 like the rest of + Windows) + + XXX Actually there is a *third* issue: older DXF formats are limited + to 255 bytes records (it was later raised to 2048); since I'm lazy + and text so long is not probable I just don't implement this rule. + If someone is interested in fixing this, you have to emit the first + partial lines with group code 3 (max 250 bytes each) and then finish + with a group code 1 (less than 250 bytes). The DXF refs explains it + in no more details... + */ + + bool overlining = false; + fputs( " 1\n", outputFile ); + for( unsigned i = 0; i < aText.length(); i++ ) + { + /* Here I do a bad thing: writing the output one byte at a time! + but today I'm lazy and I have no idea on how to coerce a Unicode + wxString to spit out latin1 encoded text ... + + Atleast stdio is *supposed* to do output buffering, so there is + hope is not too slow */ + wchar_t ch = aText[i]; + if( ch > 255 ) + { + // I can't encode this... + putc( '?', outputFile ); + } + else + { + if( ch == '~' ) + { + // Handle the overline toggle + fputs( overlining ? "%%o" : "%%O", outputFile ); + overlining = !overlining; + } + else + { + putc( ch, outputFile ); + } + } + } + putc( '\n', outputFile ); + } +} + -- cgit