void wxClientDisplayRect(int *x, int *y, int *width, int *height)
{
// return desktop dimensions minus any panels, menus, trays:
if (x) *x = 0;
if (y) *y = 0;
wxDisplaySize(width, height);
}
bool MyApp::OnInit()
{
#if wxUSE_LIBPNG
wxImage::AddHandler( new wxPNGHandler );
#endif
wxImage image;
if (image.LoadFile(_T("backgrnd.png"), wxBITMAP_TYPE_PNG))
{
m_background = wxBitmap(image);
}
MyFrame *frame = new MyFrame();
wxString rootName(_T("shape0"));
int i;
for (i = 1; i < 4; i++)
{
wxString filename;
filename.Printf(wxT("%s%d.png"), (const wxChar*)rootName, i);
/* For some reason under wxX11, the 2nd LoadFile in this loop fails, with
a BadMatch inside CreateFromImage (inside ConvertToBitmap). This happens even if you copy
the first file over the second file. */
if (image.LoadFile(filename, wxBITMAP_TYPE_PNG))
{
DragShape* newShape = new DragShape(wxBitmap(image));
newShape->SetPosition(wxPoint(i*50, i*50));
if (i == 2)
newShape->SetDragMethod(SHAPE_DRAG_TEXT);
else if (i == 3)
newShape->SetDragMethod(SHAPE_DRAG_ICON);
else
newShape->SetDragMethod(SHAPE_DRAG_BITMAP);
frame->GetCanvas()->GetDisplayList().Append(newShape);
}
}
#if 0
// Under Motif or GTK, this demonstrates that
// wxScreenDC only gets the root window content.
// We need to be able to copy the overall content
// for full-screen dragging to work.
int w, h;
wxDisplaySize(& w, & h);
wxBitmap bitmap(w, h);
wxScreenDC dc;
wxMemoryDC memDC;
memDC.SelectObject(bitmap);
memDC.Blit(0, 0, w, h, & dc, 0, 0);
memDC.SelectObject(wxNullBitmap);
m_background = bitmap;
#endif
frame->Show( true );
return true;
}
bool wxTopLevelWindowDFB::ShowFullScreen(bool show, long style)
{
if ( show == m_fsIsShowing )
return true;
m_fsIsShowing = show;
if (show)
{
m_fsSaveStyle = m_windowStyle;
m_fsSaveFlag = style;
GetPosition(&m_fsSaveFrame.x, &m_fsSaveFrame.y);
GetSize(&m_fsSaveFrame.width, &m_fsSaveFrame.height);
if ( style & wxFULLSCREEN_NOCAPTION )
m_windowStyle &= ~wxCAPTION;
if ( style & wxFULLSCREEN_NOBORDER )
m_windowStyle = wxSIMPLE_BORDER;
int x, y;
wxDisplaySize(&x, &y);
SetSize(0, 0, x, y);
}
else
{
m_windowStyle = m_fsSaveStyle;
SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
m_fsSaveFrame.width, m_fsSaveFrame.height);
}
return true;
}
// Create a DC representing the whole screen
wxScreenDCImpl::wxScreenDCImpl( wxDC *owner ) :
wxWindowDCImpl( owner )
{
#if wxOSX_USE_COCOA_OR_CARBON
CGRect cgbounds ;
cgbounds = CGDisplayBounds(CGMainDisplayID());
m_width = (wxCoord)cgbounds.size.width;
m_height = (wxCoord)cgbounds.size.height;
#else
wxDisplaySize( &m_width, &m_height );
#endif
#if wxOSX_USE_COCOA_OR_IPHONE
SetGraphicsContext( wxGraphicsContext::Create() );
#else
Rect bounds;
bounds.top = (short)cgbounds.origin.y;
bounds.left = (short)cgbounds.origin.x;
bounds.bottom = bounds.top + (short)cgbounds.size.height;
bounds.right = bounds.left + (short)cgbounds.size.width;
WindowAttributes overlayAttributes = kWindowIgnoreClicksAttribute;
CreateNewWindow( kOverlayWindowClass, overlayAttributes, &bounds, (WindowRef*) &m_overlayWindow );
ShowWindow((WindowRef)m_overlayWindow);
SetGraphicsContext( wxGraphicsContext::CreateFromNativeWindow( m_overlayWindow ) );
#endif
m_ok = true ;
}
wxTopLevelWindow *ScreenshotCommand::GetFrontWindow(AudacityProject *project)
{
wxWindow *front = NULL;
wxWindow *proj = wxGetTopLevelParent(project);
// This is kind of an odd hack. There's no method to enumerate all
// possible windows, so we search the whole screen for any windows
// that are not this one and not the given Audacity project and
// if we find anything, we assume that's the dialog the user wants
// to capture.
int width, height, x, y;
wxDisplaySize(&width, &height);
for (x = 0; x < width; x += 50) {
for (y = 0; y < height; y += 50) {
wxWindow *win = wxFindWindowAtPoint(wxPoint(x, y));
if (win) {
win = wxGetTopLevelParent(win);
if (win != mIgnore && win != proj) {
front = win;
break;
}
}
}
}
if (!front || !front->IsTopLevel()) {
return (wxTopLevelWindow *)proj;
}
return (wxTopLevelWindow *)front;
}
std::string Platform::DisplaySize() {
int x, y;
wxDisplaySize(&x, &y);
std::stringstream ss;
ss << x << " " << y;
return ss.str();
}
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 MyApp::NewWindow(wxString file,bool batchmode)
{
int x = 40, y = 40, h = 650, w = 950, m = 0;
int rs = 0;
int display_width = 1024, display_height = 768;
bool have_pos;
wxConfig *config = (wxConfig *)wxConfig::Get();
wxDisplaySize(&display_width, &display_height);
have_pos = config->Read(wxT("pos-x"), &x);
config->Read(wxT("pos-y"), &y);
config->Read(wxT("pos-h"), &h);
config->Read(wxT("pos-w"), &w);
config->Read(wxT("pos-max"), &m);
config->Read(wxT("pos-restore"), &rs);
if (rs == 0)
have_pos = false;
if (!have_pos || m == 1 || x > display_width || y > display_height || x < 0 || y < 0)
{
x = 40;
y = 40;
h = 650;
w = 950;
}
#if defined __WXMAC__
x += topLevelWindows.GetCount()*20;
y += topLevelWindows.GetCount()*20;
#endif
m_frame = new wxMaxima((wxFrame *)NULL, -1, _("wxMaxima"),
wxPoint(x, y), wxSize(w, h));
m_frame->Move(wxPoint(x, y));
m_frame->SetSize(wxSize(w, h));
if (m == 1)
m_frame->Maximize(true);
if (file.Length() > 0 && wxFileExists(file)) {
m_frame->SetOpenFile(file);
}
m_frame->SetBatchMode(batchmode);
#if defined __WXMAC__
topLevelWindows.Append(m_frame);
if (topLevelWindows.GetCount()>1)
m_frame->SetTitle(wxString::Format(_("untitled %d"), ++window_counter));
#endif
SetTopWindow(m_frame);
m_frame->Show(true);
m_frame->InitSession();
m_frame->ShowTip(false);
}
void wxMDIParentFrame::GetRectForTopLevelChildren(int *x, int *y, int *w, int *h)
{
if (x)
*x = 0;
if (y)
*y = 0;
wxDisplaySize(w, h);
}
int wxSystemSettingsNative::GetMetric(wxSystemMetric index,
wxWindow* WXUNUSED(win))
{
int val;
switch (index)
{
case wxSYS_SCREEN_X:
wxDisplaySize(&val, NULL);
return val;
case wxSYS_SCREEN_Y:
wxDisplaySize(NULL, &val);
return val;
default:
return -1;
}
}
ODSelect::ODSelect()
{
pSelectList = new SelectableItemList;
pixelRadius = 8;
int w,h;
wxDisplaySize( &w, &h );
if( h > 800 ) pixelRadius = 10;
if( h > 1024 ) pixelRadius = 12;
}
void wxClientDisplayRect(int *x, int *y, int *width, int *height)
{
// This is supposed to return desktop dimensions minus any window
// manager panels, menus, taskbars, etc. If there is a way to do that
// for this platform please fix this function, otherwise it defaults
// to the entire desktop.
if (x) *x = 0;
if (y) *y = 0;
wxDisplaySize(width, height);
}
bool wxUIActionSimulator::MouseMove(long x, long y)
{
// Because MOUSEEVENTF_ABSOLUTE takes measurements scaled between 0 & 65535
// we need to scale our input too
int displayx, displayy, scaledx, scaledy;
wxDisplaySize(&displayx, &displayy);
scaledx = ((float)x / displayx) * 65535;
scaledy = ((float)y / displayy) * 65535;
mouse_event(MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE, scaledx, scaledy, 0, 0);
return true;
}
void wxDisplaySizeMM(int *width, int *height)
{
wxDisplaySize(width, height);
// on mac 72 is fixed (at least now;-)
double cvPt2Mm = 25.4 / 72;
if (width != NULL)
*width = int( *width * cvPt2Mm );
if (height != NULL)
*height = int( *height * cvPt2Mm );
}
void MiscGUIFuncsTestCase::DisplaySize()
{
// test that different (almost) overloads return the same results
int w, h;
wxDisplaySize(&w, &h);
wxSize sz = wxGetDisplaySize();
CPPUNIT_ASSERT_EQUAL( w, sz.x );
CPPUNIT_ASSERT_EQUAL( h, sz.y );
// test that passing NULL works as expected, e.g. doesn't crash
wxDisplaySize(NULL, NULL);
wxDisplaySize(&w, NULL);
wxDisplaySize(NULL, &h);
CPPUNIT_ASSERT_EQUAL( w, sz.x );
CPPUNIT_ASSERT_EQUAL( h, sz.y );
// test that display PPI is something reasonable
sz = wxGetDisplayPPI();
CPPUNIT_ASSERT( sz.x < 1000 && sz.y < 1000 );
}
int wxDisplayFactorySingle::GetFromPoint(const wxPoint& pt)
{
if ( pt.x >= 0 && pt.y >= 0 )
{
int w, h;
wxDisplaySize(&w, &h);
if ( pt.x < w && pt.y < h )
return 0;
}
// the point is outside of the screen
return wxNOT_FOUND;
}
void wxDisplaySizeMM(int *width, int *height)
{
// FIXME: there's no way to get physical resolution using the DirectDB
// API, we hardcode a commonly used value of 72dpi
#define DPI 72.0
#define PX_TO_MM(x) (int(((x) / DPI) * inches2mm))
wxDisplaySize(width, height);
if ( width ) *width = PX_TO_MM(*width);
if ( height ) *height = PX_TO_MM(*height);
#undef DPI
#undef PX_TO_MM
}
void CUnitPane::OnRClick(wxListEvent& event)
{
wxMenu menu;
long idx = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
CUnit * pUnit = GetUnit(idx);
int x=0,y;
int width, height;
int nItems = GetSelectedItemCount();
wxDisplaySize(&width, &height);
y = event.GetPoint().y;
ClientToScreen(&x, &y);
if (height-y < 150)
y = height-150;
ScreenToClient(&x, &y);
if (nItems>1)
{
// multiple units
menu.Append(menu_Popup_IssueOrders , wxT("Issue orders"));
menu.Append(menu_Popup_UnitFlags , wxT("Set custom flags") );
menu.Append(menu_Popup_AddToTracking , wxT("Add to a tracking group"));
PopupMenu( &menu, event.GetPoint().x, y);
}
else
if (pUnit)
{
// single unit
if (pUnit->IsOurs)
{
menu.Append(menu_Popup_ShareSilv , wxT("Share SILV") );
menu.Append(menu_Popup_Teach , wxT("Teach") );
menu.Append(menu_Popup_Split , wxT("Split") );
menu.Append(menu_Popup_DiscardJunk , wxT("Discard junk items"));
menu.Append(menu_Popup_GiveEverything, wxT("Give everything") );
menu.Append(menu_Popup_DetectSpies , wxT("Detect spies") );
}
menu.Append(menu_Popup_UnitFlags , wxT("Set custom flags") );
menu.Append(menu_Popup_AddToTracking , wxT("Add to a tracking group"));
PopupMenu( &menu, event.GetPoint().x, y);
}
}
void wxWindowDFB::WarpPointer(int x, int y)
{
int w, h;
wxDisplaySize(&w, &h);
ClientToScreen(&x, &y);
if ( x < 0 ) x = 0;
if ( y < 0 ) y = 0;
if ( x >= w ) x = w-1;
if ( y >= h ) y = h-1;
wxIDirectFBDisplayLayerPtr layer(wxIDirectFB::Get()->GetDisplayLayer());
wxCHECK_RET( layer, "no display layer" );
layer->WarpCursor(x, y);
}
void wxMacPrintPreview::DetermineScaling(void)
{
int screenWidth , screenHeight ;
wxDisplaySize( &screenWidth , &screenHeight ) ;
wxSize ppiScreen( 72 , 72 ) ;
wxSize ppiPrinter( 72 , 72 ) ;
// Note that with Leopard, screen dpi=72 is no longer a given
m_previewPrintout->SetPPIScreen( ppiScreen.x , ppiScreen.y ) ;
wxCoord w , h ;
wxCoord ww, hh;
wxRect paperRect;
// Get a device context for the currently selected printer
wxPrinterDC printerDC(m_printDialogData.GetPrintData());
if (printerDC.IsOk())
{
printerDC.GetSizeMM(&ww, &hh);
printerDC.GetSize( &w , &h ) ;
ppiPrinter = printerDC.GetPPI() ;
paperRect = printerDC.GetPaperRect();
m_isOk = true ;
}
else
{
// use some defaults
w = 8 * 72 ;
h = 11 * 72 ;
ww = (wxCoord) (w * 25.4 / ppiPrinter.x) ;
hh = (wxCoord) (h * 25.4 / ppiPrinter.y) ;
paperRect = wxRect(0, 0, w, h);
m_isOk = false ;
}
m_pageWidth = w;
m_pageHeight = h;
m_previewPrintout->SetPageSizePixels(w , h) ;
m_previewPrintout->SetPageSizeMM(ww, hh);
m_previewPrintout->SetPaperRectPixels(paperRect);
m_previewPrintout->SetPPIPrinter( ppiPrinter.x , ppiPrinter.y ) ;
m_previewScaleX = float(ppiScreen.x) / ppiPrinter.x;
m_previewScaleY = float(ppiScreen.y) / ppiPrinter.y;
}
void wxClientDisplayRect(int *x, int *y, int *width, int *height)
{
#if defined(__WXMICROWIN__)
*x = 0; *y = 0;
wxDisplaySize(width, height);
#else
// Determine the desktop dimensions minus the taskbar and any other
// special decorations...
RECT r;
SystemParametersInfo(SPI_GETWORKAREA, 0, &r, 0);
if (x) *x = r.left;
if (y) *y = r.top;
if (width) *width = r.right - r.left;
if (height) *height = r.bottom - r.top;
#endif
}
void wxWindowMGL::WarpPointer(int x, int y)
{
int w, h;
wxDisplaySize(&w, &h);
ClientToScreen(&x, &y);
if ( x < 0 )
x = 0;
if ( y < 0 )
y = 0;
if ( x >= w )
x = w-1;
if ( y >= h )
y = h-1;
EVT_setMousePos(x, y);
}
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);
}
}
wxImage ToolBar::GetImage(wxString name)
{
Dirstructure dirstructure;
wxImage img = wxImage(dirstructure.ConfigToolbarDir() + name + wxT(".png"));
// We want to scale the images according to the display's resolution.
// But we want to do so in discrete steps as scaling bitmaps by odd
// factors will add visible antialiassing to things that are clearly
// meant to be sharp lines.
int resolutionMultiplier = wxGetDisplayPPI().x/72;
int imgWidth = 24 * resolutionMultiplier;
int width,height;
wxDisplaySize(&width,&height);
if(width <= 800)
imgWidth = 24;
if(imgWidth < 24)
imgWidth = 24;
double scaleFactor = (double)imgWidth / img.GetWidth();
img.Rescale(imgWidth,img.GetHeight()*scaleFactor,wxIMAGE_QUALITY_HIGH );
return img;
}
bool wxScreenDCImpl::StartDrawingOnTop(wxRect* rect)
{
if (sm_overlayWindow)
return false;
Display *dpy = (Display*) wxGetDisplay();
Pixmap screenPixmap = RootWindow(dpy, DefaultScreen(dpy));
int x = 0;
int y = 0;
int width, height;
wxDisplaySize(&width, &height);
if (rect)
{
x = rect->x; y = rect->y;
width = rect->width; height = rect->height;
}
sm_overlayWindowX = x;
sm_overlayWindowY = y;
XSetWindowAttributes attributes;
attributes.override_redirect = True;
unsigned long valueMask = CWOverrideRedirect;
sm_overlayWindow = (WXWindow) XCreateWindow(dpy, screenPixmap, x, y, width, height, 0,
wxDisplayDepth(), InputOutput,
DefaultVisual(dpy, 0), valueMask,
& attributes);
if (sm_overlayWindow)
{
XMapWindow(dpy, (Window) sm_overlayWindow);
return true;
}
else
return false;
}
BoatDialog::BoatDialog(WeatherRouting &weatherrouting)
: BoatDialogBase(&weatherrouting),
m_WeatherRouting(weatherrouting), m_PlotScale(0), m_CrossOverRegenerate(false), m_CrossOverGenerationThread(NULL)
{
// for small screens: don't let boat dialog be larger than screen
int w,h;
wxDisplaySize( &w, &h );
w = wxMin(w, GetMinWidth());
h = wxMin(h-32, GetMinHeight());
SetMinSize(wxSize(w, h));
SetSize(wxSize(w, h));
m_lPolars->InsertColumn(spFILENAME, _("Filename"));
wxFileConfig *pConf = GetOCPNConfigObject();
pConf->SetPath ( _T( "/PlugIns/WeatherRouting/BoatDialog" ) );
m_orientation[0] = pConf->Read ( _T ( "Orientation0" ), 1L );
m_orientation[1] = pConf->Read ( _T ( "Orientation1" ), 1L );
// hack to adjust items
SetSize(wxSize(w, h));
}
// update device_window size data when size changes
void view::OnSize(wxSizeEvent & event)
{
this->GetClientSize(
&this->m_device_window.m_size_px.x,
&this->m_device_window.m_size_px.y
);
// find window size in mm by getting size of pixel on display
// may be an ondisplay change function so dont need to continaully update
vect2_i display_size_in_px;
wxDisplaySize(&display_size_in_px.x,&display_size_in_px.y);
wxSize detail_display_size_mm = wxGetDisplaySizeMM();
vect2_mm display_size_in_mm{mm{detail_display_size_mm.x},mm{detail_display_size_mm.y}};
this->m_device_window.m_size_mm.x
= (this->m_device_window.m_size_px.x * display_size_in_mm.x) / display_size_in_px.x;
this->m_device_window.m_size_mm.y
= (this->m_device_window.m_size_px.y * display_size_in_mm.y) / display_size_in_px.y;
this->Refresh();
}
void wxMacPrintPreview::DetermineScaling(void)
{
int screenWidth , screenHeight ;
wxDisplaySize( &screenWidth , &screenHeight ) ;
m_previewPrintout->SetPPIScreen( 72 , 72 ) ;
m_previewPrintout->SetPPIPrinter( 72 , 72 ) ;
m_previewPrintout->SetPageSizeMM( (int) (8.0 * 25.6), (int) (11.0 * 25.6) );
m_previewPrintout->SetPageSizePixels( 8 * 72 , 11 * 72 ) ;
m_pageWidth = 8 * 72 ;
m_pageHeight = 11 * 72 ;
m_previewScale = 1 ;
// Get a device context for the currently selected printer
wxPrinterDC printerDC(m_printDialogData.GetPrintData());
if (printerDC.Ok())
{
int x , y ;
wxCoord ww, hh;
printerDC.GetSizeMM(&ww, &hh);
printerDC.GetSize( &x , &y ) ;
m_previewPrintout->SetPageSizeMM((int)ww, (int)hh);
m_previewPrintout->SetPageSizePixels( x , y) ;
m_pageWidth = x ;
m_pageHeight = y ;
m_isOk = true ;
}
else
{
m_isOk = false ;
}
// At 100%, the page should look about page-size on the screen.
// m_previewScale = (float)((float)screenWidth/(float)printerWidth);
// m_previewScale = m_previewScale * (float)((float)screenXRes/(float)printerXRes);
m_previewScale = 1 ;
}
void wxScreenDCImpl::DoGetSize(int *width, int *height) const
{
wxDisplaySize(width, height);
}
// Get a system metric, e.g. scrollbar size
int wxSystemSettingsNative::GetMetric(wxSystemMetric index, wxWindow* WXUNUSED(win))
{
int value;
switch ( index )
{
case wxSYS_MOUSE_BUTTONS:
// we emulate a two button mouse (ctrl + click = right button)
return 2;
// TODO case wxSYS_BORDER_X:
// TODO case wxSYS_BORDER_Y:
// TODO case wxSYS_CURSOR_X:
// TODO case wxSYS_CURSOR_Y:
// TODO case wxSYS_DCLICK_X:
// TODO case wxSYS_DCLICK_Y:
// TODO case wxSYS_DRAG_X:
// TODO case wxSYS_DRAG_Y:
// TODO case wxSYS_EDGE_X:
// TODO case wxSYS_EDGE_Y:
case wxSYS_HSCROLL_ARROW_X:
case wxSYS_HSCROLL_ARROW_Y:
case wxSYS_HTHUMB_X:
return 16;
// TODO case wxSYS_ICON_X:
// TODO case wxSYS_ICON_Y:
// TODO case wxSYS_ICONSPACING_X:
// TODO case wxSYS_ICONSPACING_Y:
// TODO case wxSYS_WINDOWMIN_X:
// TODO case wxSYS_WINDOWMIN_Y:
case wxSYS_SCREEN_X:
wxDisplaySize( &value, NULL );
return value;
case wxSYS_SCREEN_Y:
wxDisplaySize( NULL, &value );
return value;
// TODO case wxSYS_FRAMESIZE_X:
// TODO case wxSYS_FRAMESIZE_Y:
// TODO case wxSYS_SMALLICON_X:
// TODO case wxSYS_SMALLICON_Y:
case wxSYS_HSCROLL_Y:
case wxSYS_VSCROLL_X:
case wxSYS_VSCROLL_ARROW_X:
case wxSYS_VSCROLL_ARROW_Y:
case wxSYS_VTHUMB_Y:
return 16;
case wxSYS_PENWINDOWS_PRESENT:
return 0;
case wxSYS_SWAP_BUTTONS:
return 0;
// TODO: case wxSYS_CAPTION_Y:
// TODO: case wxSYS_MENU_Y:
// TODO: case wxSYS_NETWORK_PRESENT:
// TODO: case wxSYS_SHOW_SOUNDS:
default:
// unsupported metric
break;
}
return -1;
}