From 684d98eccaa136d467667274c443ec04704f8cd0 Mon Sep 17 00:00:00 2001 From: jean-pierre charras Date: Thu, 3 May 2012 21:08:14 +0200 Subject: [PATCH] Add missing files --- common/common_plotPDF_functions.cpp | 774 ++++++++++++ .../dialogs/dialog_plot_schematic_PDF.cpp | 309 +++++ .../dialog_plot_schematic_PDF_base.cpp | 104 ++ .../dialog_plot_schematic_PDF_base.fbp | 1041 +++++++++++++++++ .../dialogs/dialog_plot_schematic_PDF_base.h | 63 + 5 files changed, 2291 insertions(+) create mode 100644 common/common_plotPDF_functions.cpp create mode 100644 eeschema/dialogs/dialog_plot_schematic_PDF.cpp create mode 100644 eeschema/dialogs/dialog_plot_schematic_PDF_base.cpp create mode 100644 eeschema/dialogs/dialog_plot_schematic_PDF_base.fbp create mode 100644 eeschema/dialogs/dialog_plot_schematic_PDF_base.h diff --git a/common/common_plotPDF_functions.cpp b/common/common_plotPDF_functions.cpp new file mode 100644 index 0000000000..56027fc7ba --- /dev/null +++ b/common/common_plotPDF_functions.cpp @@ -0,0 +1,774 @@ +/** + * @file common_plotPDF_functions.cpp + * @brief Kicad: Common plot PDF Routines + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void PDF_PLOTTER::SetPageSettings( const PAGE_INFO& aPageSettings ) +{ + wxASSERT( !workFile ); + pageInfo = aPageSettings; +} + +void PDF_PLOTTER::SetViewport( const wxPoint& aOffset, double aIusPerDecimil, + double aScale, bool aMirror ) +{ + wxASSERT( !workFile ); + plotMirror = aMirror; + plotOffset = aOffset; + plotScale = aScale; + + // The CTM is set to 1 user unit per decimil + iuPerDeviceUnit = 1.0 / aIusPerDecimil; + + /* The paper size in this engined is handled page by page + Look in the StartPage function */ +} + + +/** + * Pen width setting for PDF. Since the specs *explicitly* says that a 0 + * width is a bad thing to use (since it results in 1 pixel traces), we + * convert such requests to the default width (like -1) + */ +void PDF_PLOTTER::SetCurrentLineWidth( int width ) +{ + wxASSERT( workFile ); + int pen_width; + + if( width > 0 ) + pen_width = width; + else + pen_width = defaultPenWidth; + + if( pen_width != currentPenWidth ) + fprintf( workFile, "%g w\n", + userToDeviceSize( pen_width ) ); + + currentPenWidth = pen_width; +} + + +/** + * PDF supports colors fully. It actually has distinct fill and pen colors, + * but we set both at the same time. + * + * XXX Keeping them divided could result in a minor optimization in + * eeschema filled shapes, but would propagate to all the other plot + * engines. Also arcs are filled as pies but only the arc is stroked so + * it would be difficult to handle anyway. + */ +void PDF_PLOTTER::emitSetRGBColor( double r, double g, double b ) +{ + wxASSERT( workFile ); + fprintf( workFile, "%g %g %g rg %g %g %g RG\n", + r, g, b, r, g, b ); +} + +/** + * PDF supports dashed lines + */ +void PDF_PLOTTER::SetDash( bool dashed ) +{ + wxASSERT( workFile ); + if( dashed ) + fputs( "[200] 100 d\n", workFile ); + else + fputs( "[] 0 d\n", workFile ); +} + + +/** + * Rectangles in PDF. Supported by the native operator + */ +void PDF_PLOTTER::Rect( const wxPoint& p1, const wxPoint& p2, FILL_T fill, int width ) +{ + wxASSERT( workFile ); + DPOINT p1_dev = userToDeviceCoordinates( p1 ); + DPOINT p2_dev = userToDeviceCoordinates( p2 ); + + SetCurrentLineWidth( width ); + fprintf( workFile, "%g %g %g %g re %c\n", p1_dev.x, p1_dev.y, + p2_dev.x - p1_dev.x, p2_dev.y - p1_dev.y, + fill == NO_FILL ? 'S' : 'B' ); +} + + +/** + * Circle drawing for PDF. They're approximated by curves, but fill is supported + */ +void PDF_PLOTTER::Circle( const wxPoint& pos, int diametre, FILL_T aFill, int width ) +{ + wxASSERT( workFile ); + DPOINT pos_dev = userToDeviceCoordinates( pos ); + double radius = userToDeviceSize( diametre / 2.0 ); + + /* OK. Here's a trick. PDF doesn't support circles or circular angles, that's + a fact. You'll have to do with cubic beziers. These *can't* represent + circular arcs (NURBS can, beziers don't). But there is a widely known + approximation which is really good */ + + SetCurrentLineWidth( width ); + double magic = radius * 0.551784; // You don't want to know where this come from + + // This is the convex hull for the bezier approximated circle + fprintf( workFile, "%g %g m " + "%g %g %g %g %g %g c " + "%g %g %g %g %g %g c " + "%g %g %g %g %g %g c " + "%g %g %g %g %g %g c %c\n", + pos_dev.x - radius, pos_dev.y, + + pos_dev.x - radius, pos_dev.y + magic, + pos_dev.x - magic, pos_dev.y + radius, + pos_dev.x, pos_dev.y + radius, + + pos_dev.x + magic, pos_dev.y + radius, + pos_dev.x + radius, pos_dev.y + magic, + pos_dev.x + radius, pos_dev.y, + + pos_dev.x + radius, pos_dev.y - magic, + pos_dev.x + magic, pos_dev.y - radius, + pos_dev.x, pos_dev.y - radius, + + pos_dev.x - magic, pos_dev.y - radius, + pos_dev.x - radius, pos_dev.y - magic, + pos_dev.x - radius, pos_dev.y, + + aFill == NO_FILL ? 's' : 'b' ); +} + + +/** + * The PDF engine can't directly plot arcs, it uses the base emulation. + * So no filled arcs (not a great loss... ) + */ +void PDF_PLOTTER::Arc( const wxPoint& centre, int StAngle, int EndAngle, int radius, + FILL_T fill, int width ) +{ + wxASSERT( workFile ); + if( radius <= 0 ) + return; + + /* Arcs are not so easily approximated by beziers (in the general case), + so we approximate them in the old way */ + wxPoint start, end; + const int delta = 50; // increment (in 0.1 degrees) to draw circles + + if( StAngle > EndAngle ) + EXCHG( StAngle, EndAngle ); + + SetCurrentLineWidth( width ); + + // Usual trig arc plotting routine... + double alpha = DEG2RAD( StAngle / 10.0 ); + start.x = centre.x + (int) ( radius * cos( -alpha ) ); + start.y = centre.y + (int) ( radius * sin( -alpha ) ); + DPOINT pos_dev = userToDeviceCoordinates( start ); + fprintf( workFile, "%g %g m ", pos_dev.x, pos_dev.y ); + for( int ii = StAngle + delta; ii < EndAngle; ii += delta ) + { + alpha = DEG2RAD( ii / 10.0 ); + end.x = centre.x + (int) ( radius * cos( -alpha ) ); + end.y = centre.y + (int) ( radius * sin( -alpha ) ); + pos_dev = userToDeviceCoordinates( end ); + fprintf( workFile, "%g %g l ", pos_dev.x, pos_dev.y ); + } + + alpha = DEG2RAD( EndAngle / 10.0 ); + end.x = centre.x + (int) ( radius * cos( -alpha ) ); + end.y = centre.y + (int) ( radius * sin( -alpha ) ); + pos_dev = userToDeviceCoordinates( end ); + fprintf( workFile, "%g %g l ", pos_dev.x, pos_dev.y ); + + // The arc is drawn... if not filled we stroke it, otherwise we finish + // closing the pie at the center + if( fill == NO_FILL ) + { + fputs( "S\n", workFile ); + } + else + { + pos_dev = userToDeviceCoordinates( centre ); + fprintf( workFile, "%g %g l b\n", pos_dev.x, pos_dev.y ); + } +} + + +/** + * Polygon plotting for PDF. Everything is supported + */ +void PDF_PLOTTER::PlotPoly( const std::vector< wxPoint >& aCornerList, + FILL_T aFill, int aWidth ) +{ + wxASSERT( workFile ); + if( aCornerList.size() <= 1 ) + return; + + SetCurrentLineWidth( aWidth ); + + DPOINT pos = userToDeviceCoordinates( aCornerList[0] ); + fprintf( workFile, "%g %g m\n", pos.x, pos.y ); + + for( unsigned ii = 1; ii < aCornerList.size(); ii++ ) + { + pos = userToDeviceCoordinates( aCornerList[ii] ); + fprintf( workFile, "%g %g l\n", pos.x, pos.y ); + } + + // Close path and stroke(/fill) + fprintf( workFile, "%c\n", aFill == NO_FILL ? 'S' : 'b' ); +} + + +void PDF_PLOTTER::PenTo( const wxPoint& pos, char plume ) +{ + wxASSERT( workFile ); + if( plume == 'Z' ) + { + if( penState != 'Z' ) + { + fputs( "S\n", workFile ); + penState = 'Z'; + penLastpos.x = -1; + penLastpos.y = -1; + } + return; + } + + if( penState != plume || pos != penLastpos ) + { + DPOINT pos_dev = userToDeviceCoordinates( pos ); + fprintf( workFile, "%g %g %c\n", + pos_dev.x, pos_dev.y, + ( plume=='D' ) ? 'l' : 'm' ); + } + penState = plume; + penLastpos = pos; +} + +/** + * PDF images are handles as inline, not XObject streams... + */ +void PDF_PLOTTER::PlotImage( const wxImage & aImage, const wxPoint& aPos, + double aScaleFactor ) +{ + wxASSERT( workFile ); + wxSize pix_size( aImage.GetWidth(), aImage.GetHeight() ); + + // Requested size (in IUs) + DPOINT drawsize( aScaleFactor * pix_size.x, + aScaleFactor * pix_size.y ); + + // calculate the bitmap start position + wxPoint start( aPos.x - drawsize.x / 2, + aPos.y + drawsize.y / 2); + + DPOINT dev_start = userToDeviceCoordinates( start ); + + /* PDF has an uhm... simplified coordinate system handling. There is + *one* operator to do everything (the PS concat equivalent). At least + they kept the matrix stack to save restore environments. Also images + are always emitted at the origin with a size of 1x1 user units. + What we need to do is: + 1) save the CTM end estabilish the new one + 2) plot the image + 3) restore the CTM + 4) profit + */ + fprintf( workFile, "q %g 0 0 %g %g %g cm\n", // Step 1 + userToDeviceSize( drawsize.x ), + userToDeviceSize( drawsize.y ), + dev_start.x, dev_start.y ); + + /* An inline image is a cross between a dictionary and a stream. + A real ugly construct (compared with the elegance of the PDF + format). Also it accepts some 'abbreviations', which is stupid + since the content stream is usually compressed anyway... */ + fprintf( workFile, + "BI\n" + " /BPC 8\n" + " /CS %s\n" + " /W %d\n" + " /H %d\n" + "ID\n", colorMode ? "/RGB" : "/G", pix_size.x, pix_size.y ); + + /* Here comes the stream (in binary!). I *could* have hex or ascii84 + encoded it, but who cares? I'll go through zlib anyway */ + for( int y = 0; y < pix_size.y; y++ ) + { + for( int x = 0; x < pix_size.x; x++ ) + { + unsigned char r = aImage.GetRed( x, y ) & 0xFF; + unsigned char g = aImage.GetGreen( x, y ) & 0xFF; + unsigned char b = aImage.GetBlue( x, y ) & 0xFF; + // As usual these days, stdio buffering has to suffeeeeerrrr + if( colorMode ) + { + putc( r, workFile ); + putc( g, workFile ); + putc( b, workFile ); + } + else + { + // Grayscale conversion + putc( (r + g + b) / 3, workFile ); + } + } + } + + fputs( "EI Q\n", workFile ); // Finish step 2 and do step 3 +} + + +/** + * Allocate a new handle in the table of the PDF object. The + * handle must be completed using startPdfObject. It's an in-RAM operation + * only, no output is done. + */ +int PDF_PLOTTER::allocPdfObject() +{ + xrefTable.push_back( 0 ); + return xrefTable.size() - 1; +} + + +/** + * Open a new PDF object and returns the handle if the parameter is -1. + * Otherwise fill in the xref entry for the passed object + */ +int PDF_PLOTTER::startPdfObject(int handle) +{ + wxASSERT( outputFile ); + wxASSERT( !workFile ); + if( handle < 0) + handle = allocPdfObject(); + + xrefTable[handle] = ftell( outputFile ); + fprintf( outputFile, "%d 0 obj\n", handle ); + return handle; +} + + +/** + * Close the current PDF object + */ +void PDF_PLOTTER::closePdfObject() +{ + wxASSERT( outputFile ); + wxASSERT( !workFile ); + fputs( "endobj\n", outputFile ); +} + + +/** + * Starts a PDF stream (for the page). Returns the object handle opened + * Pass -1 (default) for a fresh object. Especially from PDF 1.5 streams + * can contain a lot of things, but for the moment we only handle page + * content. + */ +int PDF_PLOTTER::startPdfStream(int handle) +{ + wxASSERT( outputFile ); + wxASSERT( !workFile ); + handle = startPdfObject( handle ); + + // This is guaranteed to be handle+1 but needs to be allocated since + // you could allocate more object during stream preparation + streamLengthHandle = allocPdfObject(); + fprintf( outputFile, + "<< /Length %d 0 R /Filter /FlateDecode >>\n" // Length is deferred + "stream\n", handle + 1 ); + + // Open a temporary file to accumulate the stream + workFilename = filename + wxT(".tmp"); + workFile = wxFopen( workFilename, wxT( "w+b" )); + wxASSERT( workFile ); + return handle; +} + + +/** + * Finish the current PDF stream (writes the deferred length, too) + * XXX the compression code is not very elegant... is slurps the + * whole stream in RAM, allocates an output buffer of the same size + * and try to FLATE it. Asserts if it couldn't... enhancements are + * welcome but for now it simply works + */ +void PDF_PLOTTER::closePdfStream() +{ + wxASSERT( workFile ); + + // Ask for the stream length + int stream_len = ftell( workFile ); + + // Now we do a trick: rewind the file, read in the page stream and FLATE it + fseek( workFile, 0, SEEK_SET ); + unsigned char *inbuf = new unsigned char[stream_len]; + + int rc = fread( inbuf, 1, stream_len, workFile ); + wxASSERT( rc == stream_len ); + + // We have done with the temporary file, junk it + fclose( workFile ); + workFile = 0; + ::wxRemoveFile( workFilename ); + + z_stream zstrm; + zstrm.zalloc = NULL; + zstrm.zfree = NULL; + zstrm.opaque = NULL; + + /* Somewhat standard parameters to compress in FLATE. The PDF spec is + misleading, it says it wants a FLATE stream but it really want a ZLIB + stream! (a FLATE stream would be generated with -15 instead of 15) */ + rc = deflateInit2( &zstrm, Z_BEST_COMPRESSION, Z_DEFLATED, 15, + 8, Z_DEFAULT_STRATEGY ); + wxASSERT( rc == Z_OK ); + zstrm.avail_in = stream_len; + zstrm.next_in = inbuf; + + // PDF streams are very compactable, we trust it doesn't expand + unsigned char *outbuf = new unsigned char[stream_len]; + zstrm.avail_out = stream_len; + zstrm.next_out = outbuf; + + // Do a full in-memory compaction + rc = deflate( &zstrm, Z_FINISH ); + wxASSERT( rc == Z_STREAM_END ); + + // Now write the packed stream on the main file and free memory + stream_len -= zstrm.avail_out; + fwrite( outbuf, 1, stream_len, outputFile ); + + delete[] inbuf; + delete[] outbuf; + fputs( "endstream\n", outputFile ); + closePdfObject(); + + // Writing the deferred length as an indirect object + startPdfObject( streamLengthHandle ); + fprintf( outputFile, "%d\n", stream_len ); + closePdfObject(); +} + +/** + * Starts a new page in the PDF document + */ +void PDF_PLOTTER::StartPage() +{ + wxASSERT( outputFile ); + wxASSERT( !workFile ); + + // Compute the paper size in IUs + paperSize = pageInfo.GetSizeMils(); + paperSize.x *= 10.0 / iuPerDeviceUnit; + paperSize.y *= 10.0 / iuPerDeviceUnit; + SetDefaultLineWidth( 100 / iuPerDeviceUnit ); // arbitrary default + + // Open the content stream; the page object will go later + pageStreamHandle = startPdfStream(); + + /* Now, until ClosePage *everything* must be wrote in workFile, to be + compressed later in closePdfStream */ + + // Default graphic settings (coordinate system, default color and line style) + fprintf( workFile, + "%g 0 0 %g 0 0 cm 1 J 1 j 0 0 0 rg 0 0 0 RG %g w\n", + 0.0072 * plotScaleAdjX, 0.0072 * plotScaleAdjY, + userToDeviceSize( defaultPenWidth ) ); +} + +/** + * Close the current page in the PDF document (and emit its compressed stream) + */ +void PDF_PLOTTER::ClosePage() +{ + wxASSERT( workFile ); + + // Close the page stream (and compress it) + closePdfStream(); + + // Emit the page object and put it in the page list for later + pageHandles.push_back( startPdfObject() ); + + /* Page size is in 1/72 of inch (default user space units) + Works like the bbox in postscript but there is no need for + swapping the sizes, since PDF doesn't require a portrait page. + We use the MediaBox but PDF has lots of other less used boxes + to use */ + + const double BIGPTsPERMIL = 0.072; + wxSize psPaperSize = pageInfo.GetSizeMils(); + + fprintf( outputFile, + "<<\n" + "/Type /Page\n" + "/Parent %d 0 R\n" + "/Resources <<\n" + " /ProcSet [/PDF /Text /ImageC /ImageB]\n" + " /Font %d 0 R >>\n" + "/MediaBox [0 0 %d %d]\n" + "/Contents %d 0 R\n" + ">>\n", + pageTreeHandle, + fontResDictHandle, + int( ceil( psPaperSize.x * BIGPTsPERMIL ) ), + int( ceil( psPaperSize.y * BIGPTsPERMIL ) ), + pageStreamHandle ); + closePdfObject(); + + // Mark the page stream as idle + pageStreamHandle = 0; +} + +/** + * The PDF engine supports multiple pages; the first one is opened + * 'for free' the following are to be closed and reopened. Between + * each page parameters can be set + */ +bool PDF_PLOTTER::StartPlot( FILE* fout ) +{ + wxASSERT( !outputFile ); + + outputFile = fout; + + // First things first: the customary null object + xrefTable.clear(); + xrefTable.push_back( 0 ); + + /* The header (that's easy!). The second line is binary junk required + to make the file binary from the beginning (the important thing is + that they must have the bit 7 set) */ + fputs( "%PDF-1.5\n%\200\201\202\203\n", outputFile ); + + /* Allocate an entry for the page tree root, it will go in every page + parent entry */ + pageTreeHandle = allocPdfObject(); + + /* In the same way, the font resource dictionary is used by every page + (it *could* be inherited via the Pages tree */ + fontResDictHandle = allocPdfObject(); + + /* Now, the PDF is read from the end, (more or less)... so we start + with the page stream for page 1. Other more important stuff is written + at the end */ + StartPage(); + return true; +} + + +bool PDF_PLOTTER::EndPlot() +{ + wxASSERT( outputFile ); + + // Close the current page (often the only one) + ClosePage(); + + /* We need to declare the resources we're using (fonts in particular) + The useful standard one is the Helvetica family. Adding external fonts + is *very* involved! */ + struct { + const char *psname; + const char *rsname; + int font_handle; + } fontdefs[4] = { + { "/Helvetica", "/KicadFont", 0 }, + { "/Helvetica-Oblique", "/KicadFontI", 0 }, + { "/Helvetica-Bold", "/KicadFontB", 0 }, + { "/Helvetica-BoldOblique", "/KicadFontBI", 0 } + }; + + /* Declare the font resources. Since they're builtin fonts, no descriptors (yay!) + We'll need metrics anyway to do any aligment (these are in the shared with + the postscript engine) */ + for( int i = 0; i < 4; i++ ) + { + fontdefs[i].font_handle = startPdfObject(); + fprintf( outputFile, + "<< /BaseFont %s\n" + " /Type /Font\n" + " /Subtype /Type1\n" + + /* Adobe is so Mac-based that the nearest thing to Latin1 is + the Windows ANSI encoding! */ + " /Encoding /WinAnsiEncoding\n" + ">>\n", + fontdefs[i].psname ); + closePdfObject(); + } + + // Named font dictionary (was allocated, now we emit it) + startPdfObject( fontResDictHandle ); + fputs( "<<\n", outputFile ); + for( int i = 0; i < 4; i++ ) + { + fprintf( outputFile, " %s %d 0 R\n", + fontdefs[i].rsname, fontdefs[i].font_handle ); + } + fputs( ">>\n", outputFile ); + closePdfObject(); + + /* The page tree: it's a B-tree but luckily we only have few pages! + So we use just an array... The handle was allocated at the beginning, + now we instantiate the corresponding object */ + startPdfObject( pageTreeHandle ); + fputs( "<<\n" + "/Type /Pages\n" + "/Kids [\n", outputFile ); + + for( unsigned i = 0; i < pageHandles.size(); i++ ) + fprintf( outputFile, "%d 0 R\n", pageHandles[i] ); + + fprintf( outputFile, + "]\n" + "/Count %ld\n" + ">>\n", (long) pageHandles.size() ); + closePdfObject(); + + + // The info dictionary + int infoDictHandle = startPdfObject(); + char date_buf[250]; + time_t ltime = time( NULL ); + strftime( date_buf, 250, "D:%Y%m%d%H%M%S", + localtime( <ime ) ); + fprintf( outputFile, + "<<\n" + "/Producer (KiCAD PDF)\n" + "/CreationDate (%s)\n" + "/Creator (%s)\n" + "/Title (%s)\n" + "/Trapped false\n", + date_buf, + TO_UTF8( creator ), + TO_UTF8( filename ) ); + + fputs( ">>\n", outputFile ); + closePdfObject(); + + // The catalog, at last + int catalogHandle = startPdfObject(); + fprintf( outputFile, + "<<\n" + "/Type /Catalog\n" + "/Pages %d 0 R\n" + "/Version /1.5\n" + "/PageMode /UseNone\n" + "/PageLayout /SinglePage\n" + ">>\n", pageTreeHandle ); + closePdfObject(); + + /* Emit the xref table (format is crucial to the byte, each entry must + be 20 bytes long, and object zero must be done in that way). Also + the offset must be kept along for the trailer */ + long xref_start = ftell( outputFile ); + fprintf( outputFile, + "xref\n" + "0 %ld\n" + "0000000000 65535 f \n", (long) xrefTable.size() ); + for( unsigned i = 1; i < xrefTable.size(); i++ ) + { + fprintf( outputFile, "%010ld 00000 n \n", xrefTable[i] ); + } + + // Done the xref, go for the trailer + fprintf( outputFile, + "trailer\n" + "<< /Size %lu /Root %d 0 R /Info %d 0 R >>\n" + "startxref\n" + "%ld\n" // The offset we saved before + "%%EOF\n", + (unsigned long) xrefTable.size(), catalogHandle, infoDictHandle, xref_start ); + + fclose( outputFile ); + outputFile = NULL; + + return true; +} + +void PDF_PLOTTER::Text( const wxPoint& aPos, + enum EDA_COLOR_T aColor, + const wxString& aText, + int aOrient, + const wxSize& aSize, + enum EDA_TEXT_HJUSTIFY_T aH_justify, + enum EDA_TEXT_VJUSTIFY_T aV_justify, + int aWidth, + bool aItalic, + bool aBold ) +{ + // Emit native PDF text (if requested) + if( psTextMode != PSTEXTMODE_STROKE ) + { + const char *fontname = aItalic ? (aBold ? "/KicadFontBI" : "/KicadFontI") + : (aBold ? "/KicadFontB" : "/KicadFont"); + + // Compute the copious tranformation parameters + double ctm_a, ctm_b, ctm_c, ctm_d, ctm_e, ctm_f; + double wideningFactor, heightFactor; + computeTextParameters( aPos, aText, aOrient, aSize, aH_justify, + aV_justify, aWidth, aItalic, aBold, + &wideningFactor, &ctm_a, &ctm_b, &ctm_c, + &ctm_d, &ctm_e, &ctm_f, &heightFactor ); + + SetColor( aColor ); + SetCurrentLineWidth( aWidth ); + + /* We use the full CTM instead of the text matrix because the same + coordinate system will be used for the overlining. Also the %f + for the trig part of the matrix to avoid %g going in exponential + format (which is not supported) + Rendermode 0 shows the text, rendermode 3 is invisible */ + fprintf( workFile, "q %f %f %f %f %g %g cm BT %s %g Tf %d Tr %g Tz ", + ctm_a, ctm_b, ctm_c, ctm_d, ctm_e, ctm_f, + fontname, heightFactor, + (psTextMode == PSTEXTMODE_NATIVE) ? 0 : 3, + wideningFactor * 100 ); + + // The text must be escaped correctly + fputsPostscriptString( workFile, aText ); + fputs( " Tj ET\n", workFile ); + + /* We are still in text coordinates, plot the overbars (if we're + * not doing phantom text) */ + if( psTextMode == PSTEXTMODE_NATIVE ) + { + std::vector pos_pairs; + postscriptOverlinePositions( aText, aSize.x, aItalic, aBold, &pos_pairs ); + int overbar_y = KiROUND( aSize.y * 1.1 ); + for( unsigned i = 0; i < pos_pairs.size(); i += 2) + { + /* This is a nontrivial situation: we are *not* in the user + coordinate system, so the userToDeviceCoordinates function + can't be used! Strange as it may seem, the userToDeviceSize + is the right function to use here... */ + DPOINT dev_from = userToDeviceSize( wxSize( pos_pairs[i], overbar_y ) ); + DPOINT dev_to = userToDeviceSize( wxSize( pos_pairs[i + 1], overbar_y ) ); + fprintf( workFile, "%g %g m %g %g l ", + dev_from.x, dev_from.y, dev_to.x, dev_to.y ); + } + } + + // Stroke and restore the CTM + fputs( "S Q\n", workFile ); + } + + // Plot the stroked text (if requested) + if( psTextMode != PSTEXTMODE_NATIVE ) + { + PLOTTER::Text( aPos, aColor, aText, aOrient, aSize, aH_justify, aV_justify, + aWidth, aItalic, aBold ); + } +} + diff --git a/eeschema/dialogs/dialog_plot_schematic_PDF.cpp b/eeschema/dialogs/dialog_plot_schematic_PDF.cpp new file mode 100644 index 0000000000..c33b7ed50f --- /dev/null +++ b/eeschema/dialogs/dialog_plot_schematic_PDF.cpp @@ -0,0 +1,309 @@ +/** @file dialog_plot_schematic_PDF.cpp + */ + +/* + * This program source code file is part of KiCad, a free EDA CAD application. + * + * Copyright (C) 1992-2010 Jean-Pierre Charras +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + + +enum PageFormatReq { + PAGE_SIZE_AUTO, + PAGE_SIZE_A4, + PAGE_SIZE_A +}; + +#include + +class DIALOG_PLOT_SCHEMATIC_PDF : public DIALOG_PLOT_SCHEMATIC_PDF_BASE +{ +private: + SCH_EDIT_FRAME* m_Parent; + +public: + + /// Constructors + DIALOG_PLOT_SCHEMATIC_PDF( SCH_EDIT_FRAME* parent ); + +private: + static bool m_plotColorOpt; + static int m_pageSizeSelect; + static bool m_plot_Sheet_Ref; + bool m_select_PlotAll; +private: + void OnPlotCurrent( wxCommandEvent& event ); + void OnPlotAll( wxCommandEvent& event ); + void OnCancelClick( wxCommandEvent& event ); + + void initDlg(); + void initOptVars(); + void createPDFFile(); + void plotOneSheet( PDF_PLOTTER *plotter, SCH_SCREEN* screen ); + void plotSetupPage( PDF_PLOTTER *plotter, SCH_SCREEN* screen ); +}; + +// static members (static to remember last state): +bool DIALOG_PLOT_SCHEMATIC_PDF::m_plotColorOpt = false; +int DIALOG_PLOT_SCHEMATIC_PDF::m_pageSizeSelect = PAGE_SIZE_AUTO; +bool DIALOG_PLOT_SCHEMATIC_PDF::m_plot_Sheet_Ref = true; + + +void SCH_EDIT_FRAME::ToPlot_PDF( wxCommandEvent& event ) +{ + DIALOG_PLOT_SCHEMATIC_PDF dlg( this ); + + dlg.ShowModal(); +} + + +DIALOG_PLOT_SCHEMATIC_PDF::DIALOG_PLOT_SCHEMATIC_PDF( SCH_EDIT_FRAME* parent ) : + DIALOG_PLOT_SCHEMATIC_PDF_BASE( parent ) +{ + m_Parent = parent; + m_select_PlotAll = false; + initDlg(); + + GetSizer()->SetSizeHints( this ); + Centre(); + m_buttonPlotAll->SetDefault(); +} + + +/*! + * Control creation for DIALOG_PLOT_SCHEMATIC_PDF + */ + +void DIALOG_PLOT_SCHEMATIC_PDF::initDlg() +{ + SetFocus(); // make the ESC work + + // Set options + m_SizeOption->SetSelection( m_pageSizeSelect ); + m_PlotPDFColorOption->SetSelection( m_plotColorOpt ? 1 : 0 ); + m_Plot_Sheet_Ref_Ctrl->SetValue( m_plot_Sheet_Ref ); + + AddUnitSymbol( *m_defaultLineWidthTitle, g_UserUnit ); + PutValueInLocalUnits( *m_DefaultLineSizeCtrl, g_DrawDefaultLineThickness ); +} + + +/*! + * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BUTTON + */ + +void DIALOG_PLOT_SCHEMATIC_PDF::OnPlotCurrent( wxCommandEvent& event ) +{ + m_select_PlotAll = false; + + initOptVars(); + createPDFFile(); + m_MsgBox->AppendText( wxT( "*****\n" ) ); +} + + +/*! + * wxEVT_COMMAND_BUTTON_CLICKED event handler for ID_BUTTON1 + */ + +void DIALOG_PLOT_SCHEMATIC_PDF::OnPlotAll( wxCommandEvent& event ) +{ + m_select_PlotAll = true; + + initOptVars(); + createPDFFile(); + m_MsgBox->AppendText( wxT( "*****\n" ) ); +} + + +/*! + * wxEVT_COMMAND_BUTTON_CLICKED event handler for wxID_CANCEL + */ + +void DIALOG_PLOT_SCHEMATIC_PDF::OnCancelClick( wxCommandEvent& event ) +{ + initOptVars(); + EndModal( 0 ); +} + + +void DIALOG_PLOT_SCHEMATIC_PDF::initOptVars() +{ + m_plot_Sheet_Ref = m_Plot_Sheet_Ref_Ctrl->GetValue(); + m_plotColorOpt = m_PlotPDFColorOption->GetSelection(); + m_pageSizeSelect = m_SizeOption->GetSelection(); + g_DrawDefaultLineThickness = ReturnValueFromTextCtrl( *m_DefaultLineSizeCtrl ); + + if( g_DrawDefaultLineThickness < 1 ) + g_DrawDefaultLineThickness = 1; +} + + +void DIALOG_PLOT_SCHEMATIC_PDF::createPDFFile() +{ + SCH_SCREEN* screen = m_Parent->GetScreen(); + SCH_SHEET_PATH* sheetpath; + SCH_SHEET_PATH oldsheetpath = m_Parent->GetCurrentSheet(); // sheetpath is saved here + wxPoint plot_offset; + + /* When printing all pages, the printed page is not the current page. In + * complex hierarchies, we must update component references and others + * parameters in the given printed SCH_SCREEN, accordint to the sheet path + * because in complex hierarchies a SCH_SCREEN (a drawing ) is shared + * between many sheets and component references depend on the actual sheet + * path used + */ + SCH_SHEET_LIST SheetList( NULL ); + + sheetpath = SheetList.GetFirst(); + + // Allocate the plotter and set the job level parameter + PDF_PLOTTER* plotter = new PDF_PLOTTER(); + plotter->SetDefaultLineWidth( g_DrawDefaultLineThickness ); + plotter->SetColorMode( m_plotColorOpt ); + plotter->SetCreator( wxT( "Eeschema-PDF" ) ); + plotter->SetPsTextMode( PSTEXTMODE_PHANTOM ); + + + // First page handling is different + bool first_page = true; + + do + { + // Step over the schematic hierarchy + if( m_select_PlotAll ) + { + SCH_SHEET_PATH list; + if( list.BuildSheetPathInfoFromSheetPathValue( sheetpath->Path() ) ) + { + m_Parent->SetCurrentSheet( list ); + m_Parent->GetCurrentSheet().UpdateAllScreenReferences(); + m_Parent->SetSheetNumberAndCount(); + screen = m_Parent->GetCurrentSheet().LastScreen(); + } + else // Should not happen + wxASSERT( 0 ); + + sheetpath = SheetList.GetNext(); + } + + if( first_page ) { + wxString msg; + wxString plotFileName = m_Parent->GetUniqueFilenameForCurrentSheet() + + wxT( ".pdf" ); + msg.Printf( _( "Plot: %s " ), GetChars( plotFileName ) ); + m_MsgBox->AppendText( msg ); + + FILE* output_file = wxFopen( plotFileName, wxT( "wb" ) ); + + if( output_file == NULL ) + { + msg = wxT( "\n** " ); + msg += _( "Unable to create " ) + plotFileName + wxT( " **\n" ); + m_MsgBox->AppendText( msg ); + wxBell(); + return; + } + // Open the plotter and do the first page + SetLocaleTo_C_standard(); + plotter->SetFilename( plotFileName ); + plotSetupPage( plotter, screen ); + plotter->StartPlot( output_file ); + first_page = false; + } + else + { + /* For the following pages you need to close the (finished) page, + reconfigure, and then start a new one */ + plotter->ClosePage(); + plotSetupPage( plotter, screen ); + plotter->StartPage(); + } + plotOneSheet( plotter, screen ); + } while (m_select_PlotAll && sheetpath ); + + // Everything done, close the plot and restore the environment + plotter->EndPlot(); + delete plotter; + SetLocaleTo_Default(); + + // Restore the previous sheet + m_Parent->SetCurrentSheet( oldsheetpath ); + m_Parent->GetCurrentSheet().UpdateAllScreenReferences(); + m_Parent->SetSheetNumberAndCount(); +} + +void DIALOG_PLOT_SCHEMATIC_PDF::plotSetupPage( PDF_PLOTTER* plotter, + SCH_SCREEN* screen) +{ + PAGE_INFO plotPage; // page size selected to plot + // Considerations on page size and scaling requests + PAGE_INFO actualPage = screen->GetPageSettings(); // page size selected in schematic + switch( m_pageSizeSelect ) + { + case PAGE_SIZE_A: + plotPage.SetType( wxT( "A" ) ); + plotPage.SetPortrait( actualPage.IsPortrait() ); + break; + + case PAGE_SIZE_A4: + plotPage.SetType( wxT( "A4" ) ); + plotPage.SetPortrait( actualPage.IsPortrait() ); + break; + + case PAGE_SIZE_AUTO: + default: + plotPage = actualPage; + break; + } + + double scalex = (double) plotPage.GetWidthMils() / actualPage.GetWidthMils(); + double scaley = (double) plotPage.GetHeightMils() / actualPage.GetHeightMils(); + double scale = MIN( scalex, scaley ); + plotter->SetViewport( wxPoint( 0, 0 ), IU_PER_DECIMILS, scale, 0 ); + plotter->SetPageSettings( plotPage ); +} + +void DIALOG_PLOT_SCHEMATIC_PDF::plotOneSheet( PDF_PLOTTER* plotter, + SCH_SCREEN* screen ) +{ + if( m_plot_Sheet_Ref ) + { + plotter->SetColor( BLACK ); + m_Parent->PlotWorkSheet( plotter, screen ); + } + + screen->Plot( plotter ); +} + diff --git a/eeschema/dialogs/dialog_plot_schematic_PDF_base.cpp b/eeschema/dialogs/dialog_plot_schematic_PDF_base.cpp new file mode 100644 index 0000000000..2a4d39d6f5 --- /dev/null +++ b/eeschema/dialogs/dialog_plot_schematic_PDF_base.cpp @@ -0,0 +1,104 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Nov 17 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#include "dialog_plot_schematic_PDF_base.h" + +/////////////////////////////////////////////////////////////////////////// + +DIALOG_PLOT_SCHEMATIC_PDF_BASE::DIALOG_PLOT_SCHEMATIC_PDF_BASE( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style ) +{ + this->SetSizeHints( wxDefaultSize, wxDefaultSize ); + + wxBoxSizer* bmainSizer; + bmainSizer = new wxBoxSizer( wxVERTICAL ); + + wxBoxSizer* bupperSizer; + bupperSizer = new wxBoxSizer( wxHORIZONTAL ); + + wxString m_SizeOptionChoices[] = { _("Schematic size"), _("Force size A4"), _("Force size A") }; + int m_SizeOptionNChoices = sizeof( m_SizeOptionChoices ) / sizeof( wxString ); + m_SizeOption = new wxRadioBox( this, wxID_ANY, _("Plot Page Size:"), wxDefaultPosition, wxDefaultSize, m_SizeOptionNChoices, m_SizeOptionChoices, 1, wxRA_SPECIFY_COLS ); + m_SizeOption->SetSelection( 0 ); + bupperSizer->Add( m_SizeOption, 1, wxALL, 5 ); + + + bupperSizer->Add( 10, 10, 0, wxEXPAND, 5 ); + + wxBoxSizer* sbSizerMiddle; + sbSizerMiddle = new wxBoxSizer( wxVERTICAL ); + + wxString m_PlotPDFColorOptionChoices[] = { _("B/W"), _("Color") }; + int m_PlotPDFColorOptionNChoices = sizeof( m_PlotPDFColorOptionChoices ) / sizeof( wxString ); + m_PlotPDFColorOption = new wxRadioBox( this, wxID_ANY, _("Plot Mode:"), wxDefaultPosition, wxDefaultSize, m_PlotPDFColorOptionNChoices, m_PlotPDFColorOptionChoices, 1, wxRA_SPECIFY_COLS ); + m_PlotPDFColorOption->SetSelection( 0 ); + sbSizerMiddle->Add( m_PlotPDFColorOption, 0, wxALL|wxEXPAND, 5 ); + + m_Plot_Sheet_Ref_Ctrl = new wxCheckBox( this, wxID_ANY, _("Print page references"), wxDefaultPosition, wxDefaultSize, 0 ); + m_Plot_Sheet_Ref_Ctrl->SetValue(true); + sbSizerMiddle->Add( m_Plot_Sheet_Ref_Ctrl, 0, wxALL|wxEXPAND, 5 ); + + bupperSizer->Add( sbSizerMiddle, 1, wxEXPAND, 5 ); + + + bupperSizer->Add( 10, 10, 0, wxEXPAND, 5 ); + + wxBoxSizer* bbuttonsSizer; + bbuttonsSizer = new wxBoxSizer( wxVERTICAL ); + + m_buttonPlotPage = new wxButton( this, wxID_ANY, _("&Plot Page"), wxDefaultPosition, wxDefaultSize, 0 ); + bbuttonsSizer->Add( m_buttonPlotPage, 0, wxALL|wxEXPAND, 5 ); + + m_buttonPlotAll = new wxButton( this, wxID_ANY, _("Plot A&LL"), wxDefaultPosition, wxDefaultSize, 0 ); + bbuttonsSizer->Add( m_buttonPlotAll, 0, wxALL|wxEXPAND, 5 ); + + m_buttonClose = new wxButton( this, wxID_CANCEL, _("Close"), wxDefaultPosition, wxDefaultSize, 0 ); + bbuttonsSizer->Add( m_buttonClose, 0, wxALL|wxEXPAND, 5 ); + + bupperSizer->Add( bbuttonsSizer, 0, wxALIGN_CENTER_VERTICAL, 5 ); + + bmainSizer->Add( bupperSizer, 0, wxEXPAND, 5 ); + + wxBoxSizer* bSizerLineWidth; + bSizerLineWidth = new wxBoxSizer( wxHORIZONTAL ); + + m_defaultLineWidthTitle = new wxStaticText( this, wxID_ANY, _("Default line width:"), wxDefaultPosition, wxDefaultSize, 0 ); + m_defaultLineWidthTitle->Wrap( -1 ); + bSizerLineWidth->Add( m_defaultLineWidthTitle, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 ); + + m_DefaultLineSizeCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 ); + bSizerLineWidth->Add( m_DefaultLineSizeCtrl, 1, wxTOP|wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 ); + + bmainSizer->Add( bSizerLineWidth, 0, wxEXPAND, 5 ); + + m_staticText1 = new wxStaticText( this, wxID_ANY, _("Messages :"), wxDefaultPosition, wxDefaultSize, 0 ); + m_staticText1->Wrap( -1 ); + bmainSizer->Add( m_staticText1, 0, wxTOP|wxRIGHT|wxLEFT, 5 ); + + m_MsgBox = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_READONLY ); + m_MsgBox->SetMinSize( wxSize( -1,150 ) ); + + bmainSizer->Add( m_MsgBox, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 ); + + this->SetSizer( bmainSizer ); + this->Layout(); + + this->Centre( wxBOTH ); + + // Connect Events + m_buttonPlotPage->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PLOT_SCHEMATIC_PDF_BASE::OnPlotCurrent ), NULL, this ); + m_buttonPlotAll->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PLOT_SCHEMATIC_PDF_BASE::OnPlotAll ), NULL, this ); + m_buttonClose->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PLOT_SCHEMATIC_PDF_BASE::OnCancelClick ), NULL, this ); +} + +DIALOG_PLOT_SCHEMATIC_PDF_BASE::~DIALOG_PLOT_SCHEMATIC_PDF_BASE() +{ + // Disconnect Events + m_buttonPlotPage->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PLOT_SCHEMATIC_PDF_BASE::OnPlotCurrent ), NULL, this ); + m_buttonPlotAll->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PLOT_SCHEMATIC_PDF_BASE::OnPlotAll ), NULL, this ); + m_buttonClose->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( DIALOG_PLOT_SCHEMATIC_PDF_BASE::OnCancelClick ), NULL, this ); + +} diff --git a/eeschema/dialogs/dialog_plot_schematic_PDF_base.fbp b/eeschema/dialogs/dialog_plot_schematic_PDF_base.fbp new file mode 100644 index 0000000000..2136619e1d --- /dev/null +++ b/eeschema/dialogs/dialog_plot_schematic_PDF_base.fbp @@ -0,0 +1,1041 @@ + + + + + + C++ + 1 + source_name + 0 + UTF-8 + connect + dialog_plot_schematic_PDF_base + 1000 + none + 1 + dialog_plot_schematic_PDF + + . + + 1 + 1 + 0 + 0 + + 1 + 1 + 1 + 1 + 0 + + + + 1 + wxBOTH + 0 + 1 + + 1 + 0 + Dock + 0 + Left + 1 + impl_virtual + + + 1 + + 0 + 0 + wxID_ANY + + 0 + + 0 + + 1 + DIALOG_PLOT_SCHEMATIC_PDF_BASE + 1 + + + 1 + + + Resizable + + 1 + 387,365 + wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER + + Plot PDF + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + bmainSizer + wxVERTICAL + none + + 5 + wxEXPAND + 0 + + + bupperSizer + wxHORIZONTAL + none + + 5 + wxALL + 1 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + "Schematic size" "Force size A4" "Force size A" + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + Plot Page Size: + + 1 + 0 + + 0 + + 1 + m_SizeOption + 1 + + + protected + 1 + + + Resizable + + 0 + 1 + + wxRA_SPECIFY_COLS + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxEXPAND + 0 + + 10 + protected + 10 + + + + 5 + wxEXPAND + 1 + + + sbSizerMiddle + wxVERTICAL + none + + 5 + wxALL|wxEXPAND + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + "B/W" "Color" + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + Plot Mode: + + 1 + 0 + + 0 + + 1 + m_PlotPDFColorOption + 1 + + + protected + 1 + + + Resizable + + 0 + 1 + + wxRA_SPECIFY_COLS + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL|wxEXPAND + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + Print page references + + 0 + + 0 + + 1 + m_Plot_Sheet_Ref_Ctrl + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxEXPAND + 0 + + 10 + protected + 10 + + + + 5 + wxALIGN_CENTER_VERTICAL + 0 + + + bbuttonsSizer + wxVERTICAL + none + + 5 + wxALL|wxEXPAND + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + &Plot Page + + 0 + + 0 + + 1 + m_buttonPlotPage + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + OnPlotCurrent + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL|wxEXPAND + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + Plot A&LL + + 0 + + 0 + + 1 + m_buttonPlotAll + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + OnPlotAll + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxALL|wxEXPAND + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_CANCEL + Close + + 0 + + 0 + + 1 + m_buttonClose + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + OnCancelClick + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxEXPAND + 0 + + + bSizerLineWidth + wxHORIZONTAL + none + + 5 + wxALIGN_CENTER_VERTICAL|wxALL + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + Default line width: + + 0 + + 0 + + 1 + m_defaultLineWidthTitle + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + -1 + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxTOP|wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL + 1 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + + 0 + + 0 + 0 + + 1 + m_DefaultLineSizeCtrl + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxTOP|wxRIGHT|wxLEFT + 0 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + Messages : + + 0 + + 0 + + 1 + m_staticText1 + 1 + + + protected + 1 + + + Resizable + + 1 + + + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + -1 + + + + + + + + + + + + + + + + + + + + + + + + + + + 5 + wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT + 1 + + 1 + 1 + 1 + 1 + + + + 1 + 0 + 1 + + 1 + 0 + Dock + 0 + Left + 1 + + 1 + + 0 + 0 + wxID_ANY + + 0 + + 0 + 0 + -1,150 + 1 + m_MsgBox + 1 + + + protected + 1 + + + Resizable + + 1 + + wxTE_MULTILINE|wxTE_READONLY + + 0 + + + wxFILTER_NONE + wxDefaultValidator + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/eeschema/dialogs/dialog_plot_schematic_PDF_base.h b/eeschema/dialogs/dialog_plot_schematic_PDF_base.h new file mode 100644 index 0000000000..dc015e42d0 --- /dev/null +++ b/eeschema/dialogs/dialog_plot_schematic_PDF_base.h @@ -0,0 +1,63 @@ +/////////////////////////////////////////////////////////////////////////// +// C++ code generated with wxFormBuilder (version Nov 17 2010) +// http://www.wxformbuilder.org/ +// +// PLEASE DO "NOT" EDIT THIS FILE! +/////////////////////////////////////////////////////////////////////////// + +#ifndef __dialog_plot_schematic_PDF_base__ +#define __dialog_plot_schematic_PDF_base__ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/////////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////////////// +/// Class DIALOG_PLOT_SCHEMATIC_PDF_BASE +/////////////////////////////////////////////////////////////////////////////// +class DIALOG_PLOT_SCHEMATIC_PDF_BASE : public wxDialog +{ + private: + + protected: + wxRadioBox* m_SizeOption; + + wxRadioBox* m_PlotPDFColorOption; + wxCheckBox* m_Plot_Sheet_Ref_Ctrl; + + wxButton* m_buttonPlotPage; + wxButton* m_buttonPlotAll; + wxButton* m_buttonClose; + wxStaticText* m_defaultLineWidthTitle; + wxTextCtrl* m_DefaultLineSizeCtrl; + wxStaticText* m_staticText1; + wxTextCtrl* m_MsgBox; + + // Virtual event handlers, overide them in your derived class + virtual void OnPlotCurrent( wxCommandEvent& event ) { event.Skip(); } + virtual void OnPlotAll( wxCommandEvent& event ) { event.Skip(); } + virtual void OnCancelClick( wxCommandEvent& event ) { event.Skip(); } + + + public: + + DIALOG_PLOT_SCHEMATIC_PDF_BASE( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("Plot PDF"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( 387,365 ), long style = wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER ); + ~DIALOG_PLOT_SCHEMATIC_PDF_BASE(); + +}; + +#endif //__dialog_plot_schematic_PDF_base__