void wxHtmlPrintout::CountPages()
{
wxBusyCursor wait;
int pageWidth, pageHeight, mm_w, mm_h;
float ppmm_h, ppmm_v;
GetPageSizePixels(&pageWidth, &pageHeight);
GetPageSizeMM(&mm_w, &mm_h);
ppmm_h = (float)pageWidth / mm_w;
ppmm_v = (float)pageHeight / mm_h;
int pos = 0;
m_NumPages = 0;
// m_PageBreaks[0] = 0;
m_PageBreaks.Clear();
m_PageBreaks.Add( 0);
do
{
pos = m_Renderer->Render((int)( ppmm_h * m_MarginLeft),
(int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight),
m_PageBreaks,
pos, true, INT_MAX);
m_PageBreaks.Add( pos);
if( m_PageBreaks.Count() > wxHTML_PRINT_MAX_PAGES)
{
wxMessageBox( _("HTML pagination algorithm generated more than the allowed maximum number of pages and it can't continue any longer!"),
_("Warning"), wxCANCEL | wxICON_ERROR );
break;
}
} while (pos < m_Renderer->GetTotalHeight());
}
void MunkHtmlPrintout::OnPreparePrinting()
{
int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
float ppmm_h, ppmm_v;
GetPageSizePixels(&pageWidth, &pageHeight);
GetPageSizeMM(&mm_w, &mm_h);
ppmm_h = (float)pageWidth / mm_w;
ppmm_v = (float)pageHeight / mm_h;
int ppiPrinterX, ppiPrinterY;
GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
int ppiScreenX, ppiScreenY;
GetPPIScreen(&ppiScreenX, &ppiScreenY);
wxDisplaySize(&scr_w, &scr_h);
GetDC()->GetSize(&dc_w, &dc_h);
GetDC()->SetUserScale((double)dc_w / (double)pageWidth,
(double)dc_h / (double)pageHeight);
/* prepare headers/footers renderer: */
m_RendererHdr->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
m_RendererHdr->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
(int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom)));
if (m_Headers[0] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[0], 1));
m_HeaderHeight = m_RendererHdr->GetTotalHeight();
}
else if (m_Headers[1] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[1], 1));
m_HeaderHeight = m_RendererHdr->GetTotalHeight();
}
if (m_Footers[0] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[0], 1));
m_FooterHeight = m_RendererHdr->GetTotalHeight();
}
else if (m_Footers[1] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[1], 1));
m_FooterHeight = m_RendererHdr->GetTotalHeight();
}
/* prepare main renderer: */
m_Renderer->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
m_Renderer->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
(int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom) -
m_FooterHeight - m_HeaderHeight -
((m_HeaderHeight == 0) ? 0 : m_MarginSpace * ppmm_v) -
((m_FooterHeight == 0) ? 0 : m_MarginSpace * ppmm_v)
));
m_Renderer->SetHtmlText(m_Document, m_BasePath, m_BasePathIsDir);
CountPages();
}
void wxHtmlPrintout::RenderPage(wxDC *dc, int page)
{
wxBusyCursor wait;
int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
float ppmm_h, ppmm_v;
GetPageSizePixels(&pageWidth, &pageHeight);
GetPageSizeMM(&mm_w, &mm_h);
ppmm_h = (float)pageWidth / mm_w;
ppmm_v = (float)pageHeight / mm_h;
wxDisplaySize(&scr_w, &scr_h);
dc->GetSize(&dc_w, &dc_h);
int ppiPrinterX, ppiPrinterY;
GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
wxUnusedVar(ppiPrinterX);
int ppiScreenX, ppiScreenY;
GetPPIScreen(&ppiScreenX, &ppiScreenY);
wxUnusedVar(ppiScreenX);
dc->SetUserScale((double)dc_w / (double)pageWidth,
(double)dc_h / (double)pageHeight);
m_Renderer->SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
dc->SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
m_Renderer->Render((int) (ppmm_h * m_MarginLeft),
(int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight), m_PageBreaks,
m_PageBreaks[page-1], false, m_PageBreaks[page]-m_PageBreaks[page-1]);
m_RendererHdr->SetDC(dc, (double)ppiPrinterY / (double)ppiScreenY);
if (m_Headers[page % 2] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[page % 2], page));
m_RendererHdr->Render((int) (ppmm_h * m_MarginLeft), (int) (ppmm_v * m_MarginTop), m_PageBreaks);
}
if (m_Footers[page % 2] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[page % 2], page));
m_RendererHdr->Render((int) (ppmm_h * m_MarginLeft), (int) (pageHeight - ppmm_v * m_MarginBottom - m_FooterHeight), m_PageBreaks);
}
}
void wxHtmlPrintout::CountPages()
{
wxBusyCursor wait;
int pageWidth, pageHeight, mm_w, mm_h;
float ppmm_h, ppmm_v;
GetPageSizePixels(&pageWidth, &pageHeight);
GetPageSizeMM(&mm_w, &mm_h);
ppmm_h = (float)pageWidth / mm_w;
ppmm_v = (float)pageHeight / mm_h;
int pos = 0;
m_NumPages = 0;
m_PageBreaks[0] = 0;
do
{
pos = m_Renderer->Render((int)( ppmm_h * m_MarginLeft),
(int) (ppmm_v * (m_MarginTop + (m_HeaderHeight == 0 ? 0 : m_MarginSpace)) + m_HeaderHeight),
pos, true, INT_MAX, m_PageBreaks, m_NumPages);
m_PageBreaks[++m_NumPages] = pos;
} while (pos < m_Renderer->GetTotalHeight());
}
void MyPrintout::DrawPageTwo()
{
// You might use THIS code to set the printer DC to ROUGHLY reflect
// the screen text size. This page also draws lines of actual length
// 5cm on the page.
// Compare this to DrawPageOne(), which uses the really convenient routines
// from wxPrintout to fit the screen image onto the printed page. This page
// illustrates how to do all the scaling calculations yourself, if you're so
// inclined.
wxDC *dc = GetDC();
// Get the logical pixels per inch of screen and printer
int ppiScreenX, ppiScreenY;
GetPPIScreen(&ppiScreenX, &ppiScreenY);
int ppiPrinterX, ppiPrinterY;
GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
// This scales the DC so that the printout roughly represents the screen
// scaling. The text point size _should_ be the right size but in fact is
// too small for some reason. This is a detail that will need to be
// addressed at some point but can be fudged for the moment.
float scale = (float)((float)ppiPrinterX/(float)ppiScreenX);
// Now we have to check in case our real page size is reduced (e.g. because
// we're drawing to a print preview memory DC)
int pageWidth, pageHeight;
int w, h;
dc->GetSize(&w, &h);
GetPageSizePixels(&pageWidth, &pageHeight);
// If printer pageWidth == current DC width, then this doesn't change. But w
// might be the preview bitmap width, so scale down.
float overallScale = scale * (float)(w/(float)pageWidth);
dc->SetUserScale(overallScale, overallScale);
// Calculate conversion factor for converting millimetres into logical
// units. There are approx. 25.4 mm to the inch. There are ppi device units
// to the inch. Therefore 1 mm corresponds to ppi/25.4 device units. We also
// divide by the screen-to-printer scaling factor, because we need to
// unscale to pass logical units to DrawLine.
// Draw 50 mm by 50 mm L shape
float logUnitsFactor = (float)(ppiPrinterX/(scale*25.4));
float logUnits = (float)(50*logUnitsFactor);
dc->SetPen(* wxBLACK_PEN);
dc->DrawLine(50, 250, (long)(50.0 + logUnits), 250);
dc->DrawLine(50, 250, 50, (long)(250.0 + logUnits));
dc->SetBackgroundMode(wxTRANSPARENT);
dc->SetBrush(*wxTRANSPARENT_BRUSH);
{ // GetTextExtent demo:
wxString words[7] = { wxT("This "), wxT("is "), wxT("GetTextExtent "),
wxT("testing "), wxT("string. "), wxT("Enjoy "), wxT("it!") };
wxCoord w, h;
long x = 200, y= 250;
wxFont fnt(15, wxSWISS, wxNORMAL, wxNORMAL);
dc->SetFont(fnt);
for (int i = 0; i < 7; i++)
{
wxString word = words[i];
word.Remove( word.Len()-1, 1 );
dc->GetTextExtent(word, &w, &h);
dc->DrawRectangle(x, y, w, h);
dc->GetTextExtent(words[i], &w, &h);
dc->DrawText(words[i], x, y);
x += w;
}
}
dc->SetFont(wxGetApp().GetTestFont());
dc->DrawText(wxT("Some test text"), 200, 300 );
// TESTING
int leftMargin = 20;
int rightMargin = 20;
int topMargin = 20;
int bottomMargin = 20;
int pageWidthMM, pageHeightMM;
GetPageSizeMM(&pageWidthMM, &pageHeightMM);
float leftMarginLogical = (float)(logUnitsFactor*leftMargin);
float topMarginLogical = (float)(logUnitsFactor*topMargin);
float bottomMarginLogical = (float)(logUnitsFactor*(pageHeightMM - bottomMargin));
float rightMarginLogical = (float)(logUnitsFactor*(pageWidthMM - rightMargin));
dc->SetPen(* wxRED_PEN);
dc->DrawLine( (long)leftMarginLogical, (long)topMarginLogical,
(long)rightMarginLogical, (long)topMarginLogical);
dc->DrawLine( (long)leftMarginLogical, (long)bottomMarginLogical,
(long)rightMarginLogical, (long)bottomMarginLogical);
WritePageHeader(this, dc, wxT("A header"), logUnitsFactor);
}
void
TrussPrintout::OnPreparePrinting() {
int page_width, page_height;
int current_page_y = 0;
GetPageSizePixels(&page_width, &page_height);
wxDC *dc = GetDC();
int printer_x, printer_y, screen_x, screen_y;
GetPPIPrinter(&printer_x, &printer_y);
GetPPIScreen(&screen_x, &screen_y);
float scale = printer_x / (float)screen_x;
// Use a 12pt font. For some reason wxFont doesn't use real points, so
// we still have to scale it.
wxFont &font = *wxTheFontList->FindOrCreateFont(
12 * scale, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL,
wxFONTWEIGHT_NORMAL
);
dc->SetFont(font);
// Margins:
int ml, mt, mr, mb;
int widthmm, heightmm;
GetPageSizeMM(&widthmm, &heightmm);
double one_mm_px = page_width / (double)widthmm;
wxPoint margintl = page_setup_dialog_data->GetMarginTopLeft();
wxPoint marginbr = page_setup_dialog_data->GetMarginBottomRight();
ml = margintl.x * one_mm_px;
mt = margintl.y * one_mm_px;
mr = marginbr.x * one_mm_px;
mb = marginbr.y * one_mm_px;
page_height -= mt + mb;
page_width -= ml + mr;
for (int i = 0; i < printitems.size(); ++i) {
if (printitems[i]->isbreak()) {
PageBreak *pb = static_cast<PageBreak *>(printitems[i]);
// Add room for the page header/title.
current_page_y = get_text_height(*dc, pb->header);
pages.push_back(Page(pb->header, ml, mt, mr, mb));
delete pb;
} else {
Truss *truss = static_cast<TrussContainer *>(printitems[i])->truss;
int truss_height_px = truss->getHeight() * page_width
/ (60.0 * 12.0);
int total_height = truss_height_px
+ get_text_height(*dc, truss->gettext());
if (!truss->getnotes().empty()) {
total_height += get_text_height(*dc, truss->getnotes());
// Add the 1/2 line padding in between title and notes
total_height += get_text_height(*dc, wxT("X")) / 2;
}
if (current_page_y + total_height > page_height) {
current_page_y = get_text_height(*dc, "continuation...");
pages.push_back(Page("continuation...", ml, mt, mr, mb));
}
pages.back().add(truss);
current_page_y += total_height;
// Add 3 blank lines of padding before the next truss.
current_page_y += get_text_height(*dc, wxT("X")) * 3;
delete static_cast<TrussContainer *>(printitems[i]);
}
}
printitems.clear();
}
void wxHtmlPrintout::OnPreparePrinting()
{
int pageWidth, pageHeight, mm_w, mm_h, scr_w, scr_h, dc_w, dc_h;
float ppmm_h, ppmm_v;
GetPageSizePixels(&pageWidth, &pageHeight);
GetPageSizeMM(&mm_w, &mm_h);
ppmm_h = (float)pageWidth / mm_w;
ppmm_v = (float)pageHeight / mm_h;
int ppiPrinterX, ppiPrinterY;
GetPPIPrinter(&ppiPrinterX, &ppiPrinterY);
wxUnusedVar(ppiPrinterX);
int ppiScreenX, ppiScreenY;
GetPPIScreen(&ppiScreenX, &ppiScreenY);
wxUnusedVar(ppiScreenX);
wxDisplaySize(&scr_w, &scr_h);
GetDC()->GetSize(&dc_w, &dc_h);
GetDC()->SetUserScale((double)dc_w / (double)pageWidth,
(double)dc_h / (double)pageHeight);
/* prepare headers/footers renderer: */
m_RendererHdr->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
m_RendererHdr->SetSize((int) (ppmm_h * (mm_w - m_MarginLeft - m_MarginRight)),
(int) (ppmm_v * (mm_h - m_MarginTop - m_MarginBottom)));
if (m_Headers[0] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[0], 1));
m_HeaderHeight = m_RendererHdr->GetTotalHeight();
}
else if (m_Headers[1] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Headers[1], 1));
m_HeaderHeight = m_RendererHdr->GetTotalHeight();
}
if (m_Footers[0] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[0], 1));
m_FooterHeight = m_RendererHdr->GetTotalHeight();
}
else if (m_Footers[1] != wxEmptyString)
{
m_RendererHdr->SetHtmlText(TranslateHeader(m_Footers[1], 1));
m_FooterHeight = m_RendererHdr->GetTotalHeight();
}
/* prepare main renderer: */
m_Renderer->SetDC(GetDC(), (double)ppiPrinterY / (double)ppiScreenY);
const int printAreaW = int(ppmm_h * (mm_w - m_MarginLeft - m_MarginRight));
int printAreaH = int(ppmm_v * (mm_h - m_MarginTop - m_MarginBottom));
if ( m_HeaderHeight )
printAreaH -= int(m_HeaderHeight + m_MarginSpace * ppmm_v);
if ( m_FooterHeight )
printAreaH -= int(m_FooterHeight + m_MarginSpace * ppmm_v);
m_Renderer->SetSize(printAreaW, printAreaH);
m_Renderer->SetHtmlText(m_Document, m_BasePath, m_BasePathIsDir);
if ( CheckFit(wxSize(printAreaW, printAreaH),
wxSize(m_Renderer->GetTotalWidth(),
m_Renderer->GetTotalHeight())) )
{
// do paginate the document
CountPages();
}
//else: if we don't call CountPages() m_PageBreaks remains empty and our
// GetPageInfo() will return 0 as max page and so nothing will be
// printed
}
void EDA_Printout::DrawPage(void)
/********************************/
/*
Routine effective d'impression
*/
{
int tmpzoom;
wxPoint tmp_startvisu;
wxSize PageSize_in_mm;
wxSize SheetSize; // Sheet size in internal units
wxSize PlotAreaSize; // Taille de la surface utile de trace (pixels)
float scaleX, scaleY, scale;
wxPoint old_org;
wxPoint DrawOffset; // Offset de trace
float userscale = 1.0;
wxDC * dc = GetDC();
wxBusyCursor dummy;
GetPageSizeMM(&PageSize_in_mm.x, &PageSize_in_mm.y);
/* modification des cadrages et reglages locaux */
tmp_startvisu = ActiveScreen->m_StartVisu;
tmpzoom = ActiveScreen->GetZoom();
old_org = ActiveScreen->m_DrawOrg;
ActiveScreen->m_DrawOrg.x = ActiveScreen->m_DrawOrg.y = 0;
ActiveScreen->m_StartVisu.x = ActiveScreen->m_StartVisu.y = 0;
// Get margins
float marginX0 = (float) g_PageSetupData->GetMarginTopLeft().x; // in mm
float marginY0 = (float) g_PageSetupData->GetMarginTopLeft().y;
float marginX1 = (float) g_PageSetupData->GetMarginBottomRight().x;
float marginY1 = (float) g_PageSetupData->GetMarginBottomRight().y;
SheetSize = ActiveScreen->m_CurrentSheet->m_Size; // size in 1/1000 inch
SheetSize.x *= m_Parent->m_InternalUnits / 1000;
SheetSize.y *= m_Parent->m_InternalUnits / 1000; // size in pixels
// Get the size of the DC in pixels
dc->GetSize(&PlotAreaSize.x, &PlotAreaSize.y);
// Calcul des marges
marginX0 *= (float) PlotAreaSize.x / PageSize_in_mm.x; /* margin est en pixels */
marginY0 *= (float) PlotAreaSize.y / PageSize_in_mm.y;
marginX1 *= (float) PlotAreaSize.x / PageSize_in_mm.x;
marginY1 *= (float) PlotAreaSize.y / PageSize_in_mm.y;
PlotAreaSize.x -= (int)( marginX0 + marginX1);
PlotAreaSize.y -= (int)( marginY0 + marginY1);
#ifdef PCBNEW
WinEDA_BasePcbFrame * pcbframe = (WinEDA_BasePcbFrame*) m_Parent;
pcbframe->m_Pcb->ComputeBoundaryBox();
/* calcul des dimensions du PCB */
if (s_ScaleList[s_Scale_Select] == 0) // fit in page
{
SheetSize.x = pcbframe->m_Pcb->m_BoundaryBox.GetWidth();
SheetSize.y = pcbframe->m_Pcb->m_BoundaryBox.GetHeight();
}
else userscale = s_ScaleList[s_Scale_Select];
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{
DrawOffset.x += pcbframe->m_Pcb->m_BoundaryBox.GetX();
DrawOffset.y += pcbframe->m_Pcb->m_BoundaryBox.GetY();
}
#endif
// Calculate a suitable scaling factor
scaleX = (float)SheetSize.x / PlotAreaSize.x;
scaleY = (float)SheetSize.y / PlotAreaSize.y;
scale = wxMax(scaleX,scaleY) / userscale; // Use x or y scaling factor, whichever fits on the DC
int zoom = 1;
ActiveScreen->SetZoom(zoom);
// ajustage de l'echelle de trace
#ifdef PCBNEW
dc->SetUserScale(zoom / scale * m_PrintFrame->m_XScaleAdjust, zoom / scale * m_PrintFrame->m_YScaleAdjust);
#else
dc->SetUserScale(zoom / scale, zoom / scale);
#endif
DrawOffset.x -= (int)(marginX0 * scale); // margin est désiré en absolu!
DrawOffset.y -= (int)(marginY0 * scale);
#ifdef PCBNEW
DrawOffset.x += (int)( (SheetSize.x/2) * (m_PrintFrame->m_XScaleAdjust -1.0));
DrawOffset.y += (int)( (SheetSize.y/2) * (m_PrintFrame->m_YScaleAdjust -1.0));
#endif
ActiveScreen->m_DrawOrg = DrawOffset;
GRResetPenAndBrush(dc);
if( s_Print_Black_and_White ) GRForceBlackPen(TRUE);
#ifdef EESCHEMA
/* set Pen min width */
float ftmp;
// PenMinWidth est donné en 1/100 mm, a convertir en pixels
ftmp = (float)PenMinWidth / 100; // ftmp est en mm
ftmp *= (float)PlotAreaSize.x / PageSize_in_mm.x; /* ftmp est en pixels */
SetPenMinWidth((int)ftmp);
#else
SetPenMinWidth(1);
#endif
WinEDA_DrawPanel * panel = m_Parent->DrawPanel;
EDA_Rect tmp = panel->m_ClipBox;
panel->m_ClipBox.SetOrigin(wxPoint(0,0));
panel->m_ClipBox.SetSize(wxSize(0x7FFFFF0, 0x7FFFFF0));
#ifdef EESCHEMA
if( s_Print_Black_and_White )
g_PrintFillMask = FILLED_WITH_BG_BODYCOLOR;
#endif
g_IsPrinting = TRUE;
panel->PrintPage(dc, m_Print_Sheet_Ref, s_PrintMaskLayer);
g_IsPrinting = FALSE;
#ifdef EESCHEMA
g_PrintFillMask = 0;
#endif
panel->m_ClipBox = tmp;
SetPenMinWidth(1);
GRForceBlackPen(FALSE);
ActiveScreen->m_StartVisu = tmp_startvisu;
ActiveScreen->m_DrawOrg = old_org;
ActiveScreen->SetZoom(tmpzoom);
}
void EDA_Printout::DrawPage(void)
/********************************/
/*
This is the real print function: print the active screen
*/
{
int tmpzoom;
wxPoint tmp_startvisu;
wxSize PageSize_in_mm;
wxSize SheetSize; // Sheet size in internal units
wxSize PlotAreaSize; // Taille de la surface utile de trace (pixels)
double scaleX, scaleY, scale;
wxPoint old_org;
wxPoint DrawOffset; // Offset de trace
double userscale;
wxDC * dc = GetDC();
int DrawZoom = 1;
wxBusyCursor dummy;
GetPageSizeMM(&PageSize_in_mm.x, &PageSize_in_mm.y);
/* Save old draw scale and draw offset */
tmp_startvisu = ActiveScreen->m_StartVisu;
tmpzoom = ActiveScreen->GetZoom();
old_org = ActiveScreen->m_DrawOrg;
/* Change draw scale and offset to draw the whole page*/
ActiveScreen->SetZoom(DrawZoom);
ActiveScreen->m_DrawOrg.x = ActiveScreen->m_DrawOrg.y = 0;
ActiveScreen->m_StartVisu.x = ActiveScreen->m_StartVisu.y = 0;
SheetSize = ActiveScreen->m_CurrentSheet->m_Size; // size in 1/1000 inch
SheetSize.x *= m_Parent->m_InternalUnits / 1000;
SheetSize.y *= m_Parent->m_InternalUnits / 1000; // size in pixels
// Get the size of the DC in pixels
dc->GetSize(&PlotAreaSize.x, &PlotAreaSize.y);
#ifdef PCBNEW
WinEDA_BasePcbFrame * pcbframe = (WinEDA_BasePcbFrame*) m_Parent;
pcbframe->m_Pcb->ComputeBoundaryBox();
/* calcul des dimensions du PCB */
if (s_ScaleList[s_Scale_Select] == 0) // fit in page
{
int extra_margin = 8000; // Margin = 8000/2 units pcb = 0,4 inch
SheetSize.x = pcbframe->m_Pcb->m_BoundaryBox.GetWidth() + extra_margin;
SheetSize.y = pcbframe->m_Pcb->m_BoundaryBox.GetHeight() + extra_margin;
userscale = 0.99;
}
else userscale = s_ScaleList[s_Scale_Select];
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{
DrawOffset.x += pcbframe->m_Pcb->m_BoundaryBox.Centre().x;
DrawOffset.y += pcbframe->m_Pcb->m_BoundaryBox.Centre().y;
}
#endif
// Calculate a suitable scaling factor
scaleX = (double)SheetSize.x / PlotAreaSize.x;
scaleY = (double)SheetSize.y / PlotAreaSize.y;
scale = wxMax(scaleX,scaleY) / userscale; // Use x or y scaling factor, whichever fits on the DC
// ajust the real draw scale
#ifdef PCBNEW
double accurate_Xscale, accurate_Yscale;
dc->SetUserScale(DrawZoom / scale * m_PrintFrame->m_XScaleAdjust,
DrawZoom / scale * m_PrintFrame->m_YScaleAdjust);
// Compute Accurate scale 1
{
int w, h;
GetPPIPrinter(&w, &h);
accurate_Xscale = ((double)(DrawZoom * w))/ PCB_INTERNAL_UNIT;
accurate_Yscale = ((double)(DrawZoom * h))/ PCB_INTERNAL_UNIT;
if ( IsPreview() ) // Scale must take in account the DC size in Preview
{
// Get the size of the DC in pixels
dc->GetSize(&PlotAreaSize.x, &PlotAreaSize.y);
GetPageSizePixels(&w, &h);
accurate_Xscale *= PlotAreaSize.x; accurate_Xscale /= w;
accurate_Yscale *= PlotAreaSize.y; accurate_Yscale /= h;
}
accurate_Xscale *= m_PrintFrame->m_XScaleAdjust;
accurate_Yscale *= m_PrintFrame->m_YScaleAdjust;
}
#else
dc->SetUserScale(DrawZoom / scale, DrawZoom / scale);
#endif
#ifdef PCBNEW
if ( (s_ScaleList[s_Scale_Select] > 1.0) || // scale > 1 -> Recadrage
(s_ScaleList[s_Scale_Select] == 0) ) // fit in page
{
DrawOffset.x -= (int)( (PlotAreaSize.x/2) * scale);
DrawOffset.y -= (int)( (PlotAreaSize.y/2) * scale );
}
DrawOffset.x += (int)( (SheetSize.x/2) * (m_PrintFrame->m_XScaleAdjust -1.0));
DrawOffset.y += (int)( (SheetSize.y/2) * (m_PrintFrame->m_YScaleAdjust -1.0));
#endif
ActiveScreen->m_DrawOrg = DrawOffset;
GRResetPenAndBrush(dc);
if( s_Print_Black_and_White ) GRForceBlackPen(TRUE);
#ifdef EESCHEMA
/* set Pen min width */
float ftmp;
// PenMinWidth est donné en 1/100 mm, a convertir en pixels
ftmp = (float)PenMinWidth / 100; // ftmp est en mm
ftmp *= (float)PlotAreaSize.x / PageSize_in_mm.x; /* ftmp est en pixels */
SetPenMinWidth((int)ftmp);
#else
SetPenMinWidth(1);
#endif
WinEDA_DrawPanel * panel = m_Parent->DrawPanel;
EDA_Rect tmp = panel->m_ClipBox;
panel->m_ClipBox.SetOrigin(wxPoint(0,0));
panel->m_ClipBox.SetSize(wxSize(0x7FFFFF0, 0x7FFFFF0));
g_IsPrinting = TRUE;
#ifdef EESCHEMA
if( s_Print_Black_and_White )
g_PrintFillMask = FILLED_WITH_BG_BODYCOLOR;
#endif
#ifdef PCBNEW
if ( userscale == 1.0 ) // Draw the Sheet refs at optimum scale, and board at 1.0 scale
{
if ( m_Print_Sheet_Ref )
m_Parent->TraceWorkSheet( dc, ActiveScreen);
m_Print_Sheet_Ref = FALSE;
dc->SetUserScale( accurate_Yscale, accurate_Yscale);
}
#endif
panel->PrintPage(dc, m_Print_Sheet_Ref, s_PrintMaskLayer);
#ifdef EESCHEMA
g_PrintFillMask = 0;
#endif
g_IsPrinting = FALSE;
panel->m_ClipBox = tmp;
SetPenMinWidth(1);
GRForceBlackPen(FALSE);
ActiveScreen->m_StartVisu = tmp_startvisu;
ActiveScreen->m_DrawOrg = old_org;
ActiveScreen->SetZoom(tmpzoom);
}
