void mxConfig::OnAlto (wxCommandEvent & evt) {
if (ignore_events) return;
ignore_events=true;
evt.Skip();
long h;
if (tx_alto->GetValue().ToLong(&h)) {
int w1,h1; get_wh(1,w1,h1);
float z=100.f*(float(h)/float(h1));
SetZoom(z,2);
}
ignore_events=false;
}
void CustomWebView::wheelEvent (QWheelEvent *e)
{
if (e->modifiers () & Qt::ControlModifier)
{
int degrees = e->delta () / 8;
qreal delta = static_cast<qreal> (degrees) / 150;
SetZoom (zoomFactor () + delta);
e->accept ();
}
else
QWebView::wheelEvent (e);
}
void Interface::BaseReset()
{
if (origImageFilename.size() > 0) {
SetPic(origImageFilename);
SetZoom( ratio );
}
sx1->setValue(0);
sx2->setValue(0);
Top_startX = 0;
QApplication::restoreOverrideCursor();
}
bool BASE_SCREEN::SetPreviousZoom()
{
for( unsigned i = m_ZoomList.size(); i != 0; --i )
{
if( m_Zoom > m_ZoomList[i - 1] )
{
SetZoom( m_ZoomList[i - 1] );
return true;
}
}
return false;
}
bool BASE_SCREEN::SetNextZoom()
{
for( unsigned i=0; i < m_ZoomList.size(); ++i )
{
if( m_Zoom < m_ZoomList[i] )
{
SetZoom( m_ZoomList[i] );
return true;
}
}
return false;
}
void GameBase::Loop(){
SetZoom();
Init();
InitWorldPhysics();
while(wnd->isOpen()){
wnd->clear(clearColor);
DoEvents();
CheckCollitions();
UpdateWorldPhysics();
DrawWorld();
wnd->display();
}
}
bool WeaponMenuItem::IsMouseOver()
{
if (!ActiveTeam().ReadNbAmmos(weapon->GetType())) {
if (zoom)
SetZoom(false);
return false;
}
// Compute the size of the icon bounding box
Point2i size(MAX_ICON_SIZE, MAX_ICON_SIZE);
// The icon bounding box for this is centered around the transformed position
Rectanglei r(transformed_position + 1 - size/2, size);
if (r.Contains(Mouse::GetInstance()->GetPosition())) {
if (!zoom)
SetZoom(true);
return true;
}
if (zoom)
SetZoom(false);
return false;
}
void ZoomText::OnSettingsChanged(wxCommandEvent& e)
{
e.Skip();
znConfigItem data;
clConfig conf("zoom-navigator.conf");
if(conf.ReadItem(&data)) {
m_zoomFactor = data.GetZoomFactor();
m_colour = data.GetHighlightColour();
MarkerSetBackground(1, m_colour);
SetZoom(m_zoomFactor);
Colourise(0, wxSTC_INVALID_POSITION);
}
}
VideoDisplay::VideoDisplay(
wxToolBar *visualSubToolBar,
bool freeSize,
wxComboBox *zoomBox,
wxWindow* parent,
agi::Context *c)
: wxGLCanvas(parent, -1, attribList)
, autohideTools(OPT_GET("Tool/Visual/Autohide"))
, con(c)
, zoomValue(OPT_GET("Video/Default Zoom")->GetInt() * .125 + .125)
, toolBar(visualSubToolBar)
, zoomBox(zoomBox)
, freeSize(freeSize)
, retina_helper(agi::util::make_unique<RetinaHelper>(this))
, scale_factor(retina_helper->GetScaleFactor())
, scale_factor_connection(retina_helper->AddScaleFactorListener([=](int new_scale_factor) {
double new_zoom = zoomValue * new_scale_factor / scale_factor;
scale_factor = new_scale_factor;
SetZoom(new_zoom);
}))
{
zoomBox->SetValue(wxString::Format("%g%%", zoomValue * 100.));
zoomBox->Bind(wxEVT_COMBOBOX, &VideoDisplay::SetZoomFromBox, this);
zoomBox->Bind(wxEVT_TEXT_ENTER, &VideoDisplay::SetZoomFromBoxText, this);
con->videoController->Bind(EVT_FRAME_READY, &VideoDisplay::UploadFrameData, this);
slots.push_back(con->videoController->AddVideoOpenListener(&VideoDisplay::UpdateSize, this));
slots.push_back(con->videoController->AddARChangeListener(&VideoDisplay::UpdateSize, this));
slots.push_back(con->subsController->AddFileSaveListener(&VideoDisplay::OnSubtitlesSave, this));
Bind(wxEVT_PAINT, std::bind(&VideoDisplay::Render, this));
Bind(wxEVT_SIZE, &VideoDisplay::OnSizeEvent, this);
Bind(wxEVT_CONTEXT_MENU, &VideoDisplay::OnContextMenu, this);
Bind(wxEVT_ENTER_WINDOW, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_CHAR_HOOK, &VideoDisplay::OnKeyDown, this);
Bind(wxEVT_LEAVE_WINDOW, &VideoDisplay::OnMouseLeave, this);
Bind(wxEVT_LEFT_DCLICK, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_LEFT_DOWN, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_LEFT_UP, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_MOTION, &VideoDisplay::OnMouseEvent, this);
Bind(wxEVT_MOUSEWHEEL, &VideoDisplay::OnMouseWheel, this);
SetCursor(wxNullCursor);
c->videoDisplay = this;
if (con->videoController->IsLoaded())
con->videoController->JumpToFrame(con->videoController->GetFrameN());
}
void
GraphCanvas::OnKeyDown(wxKeyEvent& evt)
{
int x, y;
int key = evt.GetKeyCode();
switch (key)
{
case WXK_PAGEUP:
SetZoom(m_Zoom * 1.25f);
break;
case WXK_PAGEDOWN:
SetZoom(m_Zoom / 1.25f);
break;
case WXK_HOME:
SetZoom(1.0);
case WXK_UP:
GetViewStart(&x, &y);
Scroll(x, y - 10);
break;
case WXK_DOWN:
GetViewStart(&x, &y);
Scroll(x, y + 10);
break;
case WXK_LEFT:
GetViewStart(&x, &y);
Scroll(x - 10, y);
break;
case WXK_RIGHT:
GetViewStart(&x, &y);
Scroll(x + 10, y);
break;
default:
evt.Skip();
break;
}
}
void CNCaptureView::OnCaptureImageChanged()
{
FTLTRACE(TEXT("CNCaptureView::OnCaptureImageChanged\n"));
CNCaptureDoc* pDoc = CNCaptureApplication::Instance()->GetDocument();
if (pDoc)
{
CCapImageObj* pCaptureImage = pDoc->GetCurCaptureImage();
//save zoom to imageobject
if (m_pImage != NULL)
{
m_pImage->SetZoom(GetZoom());
}
m_pImage = pCaptureImage;
m_bImageChanged = TRUE;
}
//m_iFixedZoomIndex = s_NormalZoomIndex;
//ReleaseSelectRect();
_CalcImageSize();
//make scrollbar disappear and set statusbar text unvisible
if (NULL == m_pImage)
{
CRect rcClient;
GetClientRect(&rcClient);
SetScrollSize(0, 0, FALSE, FALSE);
STATUSBARINFO stStatusBarInfo;
stStatusBarInfo.bEnable = FALSE;
SetCurrentToolType(ttNone);
CMainFrame* pMainFrame = CNCaptureApplication::Instance()->GetMainFrame();
if (pMainFrame)
{
pMainFrame->SetStatusInfo(&stStatusBarInfo);
}
}
else
{
//first capture
if (1 == pDoc->GetCaptureCount() )
{
SetCurrentToolType(CalcCurrentToolType());
}
SetZoom(m_pImage->GetZoom(), TRUE, TRUE);
m_pImage->GetCurrentObjectInfo(m_allObjects, m_selection, TRUE);
}
Invalidate();
}
void BASE_SCREEN::SetScalingFactor(double aScale )
{
double zoom = aScale;
// Limit zoom to max and min allowed values:
if( zoom < m_ZoomList[0] )
zoom = m_ZoomList[0];
int idxmax = m_ZoomList.GetCount() - 1;
if( zoom > m_ZoomList[idxmax] )
zoom = m_ZoomList[idxmax];
SetZoom( zoom );
}
virtual int OnCommand(int cmd, HWND hWnd)
{
switch ( cmd )
{
case IDM_VIEW_LINECURVE:
case IDM_VIEW_AREAFILL:
case IDM_VIEW_BITMAP:
case IDM_VIEW_TEXT:
if ( cmd==m_demo )
return View_NoChange;
else
{
m_demo = cmd;
return View_Redraw;
}
break;
case IDM_VIEW_ZOOM500 : return SetZoom(500);
case IDM_VIEW_ZOOM400 : return SetZoom(400);
case IDM_VIEW_ZOOM200 : return SetZoom(200);
case IDM_VIEW_ZOOM150 : return SetZoom(150);
case IDM_VIEW_ZOOM100 : return SetZoom(100);
case IDM_VIEW_ZOOM75 : return SetZoom( 75);
case IDM_VIEW_ZOOM50 : return SetZoom( 50);
case IDM_VIEW_ZOOM25 : return SetZoom( 25);
case IDM_VIEW_ZOOM10 : return SetZoom( 10);
case IDM_FILE_PRINT : UponFilePrint(); GetDimension(); return View_Resize;
case IDM_FILE_PAGESETUP: UponFilePageSetup(); GetDimension(); return View_Resize;
case IDM_FILE_PROPERTY:
{
int nControlID[] = { IDC_LIST, IDC_DEFAULT, IDC_PRINTERS,
IDC_PRINTERPROPERTIES, IDC_ADVANCEDDOCUMENTPROPERTIES, IDC_DOCUMENTPROPERTIES };
ShowProperty(m_OutputSetup, m_hInst, nControlID, IDD_PROPERTY);
}
}
return View_NoChange;
}
// TODO: Make this class thread-aware. Can't send events to a different thread. Currently only works on X11.
// Needs to use QueuedConnection for signals/slots.
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
nextState(CORE_POWERDOWN),
dialogDisasm(0),
memoryWindow(0),
memoryTexWindow(0),
timer(this),
displaylistWindow(0),
lastUIState(UISTATE_MENU)
{
ui->setupUi(this);
controls = new Controls(this);
#if QT_HAS_SDL
gamePadDlg = new GamePadDialog(&input_state, this);
#endif
host = new QtHost(this);
emugl = ui->widget;
emugl->init(&input_state);
emugl->resize(pixel_xres, pixel_yres);
emugl->setMinimumSize(pixel_xres, pixel_yres);
emugl->setMaximumSize(pixel_xres, pixel_yres);
QObject::connect( emugl, SIGNAL(doubleClick()), this, SLOT(on_action_OptionsFullScreen_triggered()) );
createLanguageMenu();
UpdateMenus();
int zoom = g_Config.iWindowZoom;
if (zoom < 1) zoom = 1;
if (zoom > 4) zoom = 4;
SetZoom(zoom);
SetGameTitle(fileToStart);
connect(&timer, SIGNAL(timeout()), this, SLOT(Update()));
timer.setInterval(0);
timer.start();
// if (!fileToStart.isNull())
// {
// UpdateMenus();
// if (stateToLoad != NULL)
// SaveState::Load(stateToLoad);
// }
}
bool BASE_SCREEN::SetPreviousZoom()
{
// Step must be AT LEAST 1.2
double target = m_Zoom / 1.2;
for( unsigned i = m_ZoomList.size(); i != 0; --i )
{
if( target > m_ZoomList[i - 1] )
{
SetZoom( m_ZoomList[i - 1] );
return true;
}
}
return false;
}
bool BASE_SCREEN::SetNextZoom()
{
// Step must be AT LEAST 1.2
double target = m_Zoom * 1.2;
for( unsigned i=0; i < m_ZoomList.size(); ++i )
{
if( target < m_ZoomList[i] )
{
SetZoom( m_ZoomList[i] );
return true;
}
}
return false;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
nextState(CORE_POWERDOWN),
dialogDisasm(0)
{
ui->setupUi(this);
qApp->installEventFilter(this);
controls = new Controls(this);
#if QT_HAS_SDL
gamePadDlg = new GamePadDialog(&input_state, this);
#endif
host = new QtHost(this);
w = ui->widget;
w->init(&input_state);
w->resize(pixel_xres, pixel_yres);
w->setMinimumSize(pixel_xres, pixel_yres);
w->setMaximumSize(pixel_xres, pixel_yres);
/*
DialogManager::AddDlg(memoryWindow[0] = new CMemoryDlg(_hInstance, hwndMain, currentDebugMIPS));
DialogManager::AddDlg(vfpudlg = new CVFPUDlg(_hInstance, hwndMain, currentDebugMIPS));
*/
// Update();
UpdateMenus();
int zoom = g_Config.iWindowZoom;
if (zoom < 1) zoom = 1;
if (zoom > 4) zoom = 4;
SetZoom(zoom);
if (!fileToStart.isNull())
{
SetPlaying(fileToStart);
//Update();
UpdateMenus();
EmuThread_Start(fileToStart, w);
}
else
BrowseAndBoot();
if (!fileToStart.isNull() && stateToLoad != NULL)
SaveState::Load(stateToLoad);
}
//
// FUNCTION: HandleCommand()
//
// PURPOSE: Take action in response to user action at the dialog box's controls.
//
void HandleCommand(_In_ HWND hwndDlg, _In_ WORD wCtrlId)
{
switch (wCtrlId)
{
case IDC_CLOSE:
// Close the sample dialog box.
EndDialog(hwndDlg, 0);
break;
case IDC_RADIO_100:
case IDC_RADIO_200:
case IDC_RADIO_300:
case IDC_RADIO_400:
// The user clicked one of the radio button to apply some fullscreen magnification. (We know the control ids are sequential here.)
SetZoom(hwndDlg, (float)(wCtrlId - IDC_RADIO_100 + 1));
break;
case IDC_CHECK_SETGRAYSCALE:
{
// The user clicked the checkbox to apply grayscale to the colors on the screen.
bool fGrayscaleOn = (BST_CHECKED == SendDlgItemMessage(hwndDlg, IDC_CHECK_SETGRAYSCALE, BM_GETCHECK, 0, 0));
SetColorGrayscaleState(fGrayscaleOn);
break;
}
case IDC_CHECK_SETINPUTTRANSFORM:
{
// The user clicked the checkbox to apply an input transform for touch and pen input.
bool fInputTransformOn = (BST_CHECKED == SendDlgItemMessage(hwndDlg, IDC_CHECK_SETINPUTTRANSFORM, BM_GETCHECK, 0, 0));
SetInputTransform(hwndDlg, fInputTransformOn);
break;
}
case IDC_BUTTON_GETSETTINGS:
// The user wants to retrieve the current magnification settings.
GetSettings(hwndDlg);
break;
}
}
void MainWindow::on_action_OptionsFullScreen_triggered()
{
if(isFullScreen()) {
g_Config.bFullScreen = false;
showNormal();
ui->menubar->setVisible(true);
ui->statusbar->setVisible(true);
SetZoom(g_Config.iInternalResolution);
InitPadLayout();
if (globalUIState == UISTATE_INGAME && QApplication::overrideCursor())
QApplication::restoreOverrideCursor();
}
else {
g_Config.bFullScreen = true;
ui->menubar->setVisible(false);
ui->statusbar->setVisible(false);
// Remove constraint
emugl->setMinimumSize(0, 0);
emugl->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
ui->centralwidget->setFixedSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
setFixedSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
showFullScreen();
int width = (int) QApplication::desktop()->screenGeometry().width();
int height = (int) QApplication::desktop()->screenGeometry().height();
PSP_CoreParameter().pixelWidth = width;
PSP_CoreParameter().pixelHeight = height;
PSP_CoreParameter().outputWidth = width;
PSP_CoreParameter().outputHeight = height;
PSP_CoreParameter().renderWidth = width;
PSP_CoreParameter().renderHeight = height;
pixel_xres = width;
pixel_yres = height;
dp_xres = pixel_xres;
dp_yres = pixel_yres;
if (gpu)
gpu->Resized();
InitPadLayout();
if (globalUIState == UISTATE_INGAME && !g_Config.bShowTouchControls)
QApplication::setOverrideCursor(QCursor(Qt::BlankCursor));
}
}
ZoomText::ZoomText(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style,
const wxString& name)
{
Hide();
if(!wxStyledTextCtrl::Create(parent, id, pos, size, style | wxNO_BORDER, name)) {
return;
}
wxColour bgColour = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
for(int i = 0; i < wxSTC_STYLE_MAX; ++i) {
StyleSetBackground(i, bgColour);
}
znConfigItem data;
clConfig conf("zoom-navigator.conf");
conf.ReadItem(&data);
SetEditable(false);
SetUseHorizontalScrollBar(false);
SetUseVerticalScrollBar(data.IsUseScrollbar());
HideSelection(true);
SetMarginWidth(1, 0);
SetMarginWidth(2, 0);
SetMarginWidth(3, 0);
m_zoomFactor = data.GetZoomFactor();
m_colour = data.GetHighlightColour();
MarkerSetBackground(1, m_colour);
SetZoom(m_zoomFactor);
EventNotifier::Get()->Connect(wxEVT_ZN_SETTINGS_UPDATED, wxCommandEventHandler(ZoomText::OnSettingsChanged), NULL,
this);
EventNotifier::Get()->Connect(wxEVT_CL_THEME_CHANGED, wxCommandEventHandler(ZoomText::OnThemeChanged), NULL, this);
MarkerDefine(1, wxSTC_MARK_BACKGROUND, m_colour, m_colour);
#ifndef __WXMSW__
SetTwoPhaseDraw(false);
SetBufferedDraw(false);
SetLayoutCache(wxSTC_CACHE_DOCUMENT);
#endif
MarkerSetAlpha(1, 10);
m_timer = new wxTimer(this);
Bind(wxEVT_TIMER, &ZoomText::OnTimer, this, m_timer->GetId());
Show();
}
int mapcontrol::OPMapWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QGraphicsView::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 22)
qt_static_metacall(this, _c, _id, _a);
_id -= 22;
}
#ifndef QT_NO_PROPERTIES
else if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast< int*>(_v) = MinZoom(); break;
case 1: *reinterpret_cast< bool*>(_v) = ShowTileGridLines(); break;
case 2: *reinterpret_cast< double*>(_v) = ZoomTotal(); break;
case 3: *reinterpret_cast< qreal*>(_v) = Rotate(); break;
}
_id -= 4;
} else if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: SetMinZoom(*reinterpret_cast< int*>(_v)); break;
case 1: SetShowTileGridLines(*reinterpret_cast< bool*>(_v)); break;
case 2: SetZoom(*reinterpret_cast< double*>(_v)); break;
case 3: SetRotate(*reinterpret_cast< qreal*>(_v)); break;
}
_id -= 4;
} else if (_c == QMetaObject::ResetProperty) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyDesignable) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyScriptable) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyStored) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyEditable) {
_id -= 4;
} else if (_c == QMetaObject::QueryPropertyUser) {
_id -= 4;
}
#endif // QT_NO_PROPERTIES
return _id;
}
GBR_SCREEN::GBR_SCREEN( const wxSize& aPageSizeIU ) :
BASE_SCREEN( SCREEN_T )
{
for( unsigned i = 0; i < DIM( gbrZoomList ); ++i )
m_ZoomList.push_back( gbrZoomList[i] );
for( unsigned i = 0; i < DIM( gbrGridList ); ++i )
AddGrid( gbrGridList[i] );
// Set the working grid size to a reasonable value (in 1/10000 inch)
SetGrid( DMIL_GRID( 500 ) );
m_Active_Layer = B_Cu; // default active layer = bottom layer
SetZoom( ZOOM_FACTOR( 350 ) ); // a default value for zoom
InitDataPoints( aPageSizeIU );
}
void Interface::setMesure( int w , int mode )
{
onwi = true;
QPixmap resized;
QPixmap picsa(origImageFilename);
if (mode == 0) {
resized = picsa.scaledToWidth(w);
} else {
resized = picsa.scaledToHeight(w);
}
ratio = 100.0;
display = resized;
original = resized;
original2 = resized;
SetZoom(100);
}
bool BASE_SCREEN::SetPreviousZoom()
{
size_t i;
if( m_ZoomList.IsEmpty() || m_Zoom <= m_ZoomList[0] )
return false;
for( i = m_ZoomList.GetCount(); i != 0; i-- )
{
if( m_Zoom > m_ZoomList[i - 1] )
{
SetZoom( m_ZoomList[i - 1] );
return true;
}
}
return false;
}
bool BASE_SCREEN::SetNextZoom()
{
size_t i;
if( m_ZoomList.IsEmpty() || m_Zoom >= m_ZoomList.Last() )
return false;
for( i = 0; i < m_ZoomList.GetCount(); i++ )
{
if( m_Zoom < m_ZoomList[i] )
{
SetZoom( m_ZoomList[i] );
return true;
}
}
return false;
}
LRESULT cBiomeViewWnd::OnChar(WPARAM wParam, LPARAM lParam)
{
switch (wParam)
{
case '1': SetZoom(1); break;
case '2': SetZoom(2); break;
case '3': SetZoom(3); break;
case '4': SetZoom(4); break;
case '5': SetZoom(5); break;
case '6': SetZoom(6); break;
case '7': SetZoom(7); break;
case '8': SetZoom(8); break;
case 27:
{
// Esc pressed, exit
PostQuitMessage(0);
break;
}
}
return 0;
}
void MainWindow::on_action_OptionsFullScreen_triggered()
{
if(isFullScreen()) {
g_Config.bFullScreen = false;
showNormal();
ui->menubar->setVisible(true);
ui->statusbar->setVisible(true);
SetZoom(g_Config.iWindowZoom);
}
else {
g_Config.bFullScreen = true;
ui->menubar->setVisible(false);
ui->statusbar->setVisible(false);
// Remove constraint
emugl->setMinimumSize(0, 0);
emugl->setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
ui->centralwidget->setFixedSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
setFixedSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
showFullScreen();
int width = (int) QApplication::desktop()->screenGeometry().width();
int height = (int) QApplication::desktop()->screenGeometry().height();
PSP_CoreParameter().pixelWidth = width;
PSP_CoreParameter().pixelHeight = height;
PSP_CoreParameter().outputWidth = width;
PSP_CoreParameter().outputHeight = height;
int antialias = 1;
if (g_Config.bAntiAliasing) antialias = 2;
PSP_CoreParameter().renderWidth = width * antialias;
PSP_CoreParameter().renderHeight = height * antialias;
pixel_xres = width;
pixel_yres = height;
dp_xres = pixel_xres;
dp_yres = pixel_yres;
if (gpu)
gpu->Resized();
}
}
PL_EDITOR_SCREEN::PL_EDITOR_SCREEN( const wxSize& aPageSizeIU ) :
BASE_SCREEN( SCREEN_T )
{
for( unsigned i = 0; i < DIM( pl_editorZoomList ); ++i )
m_ZoomList.push_back( pl_editorZoomList[i] );
for( unsigned i = 0; i < DIM( pl_editorGridList ); ++i )
AddGrid( pl_editorGridList[i] );
// pl_editor uses the same frame position as schematic and board editors
m_Center = false;
// Set the working grid size to a reasonable value
SetGrid( MM_GRID( 1.0 ) );
SetZoom( ZOOM_FACTOR( 350 ) ); // a default value for zoom
InitDataPoints( aPageSizeIU );
m_NumberOfScreens = 2;
}
void Interface::BaseSave()
{
if (TagliaPoi.width() > 10) {
SetZoom( ratio );
}
Top_startX = 0;
QRect areaplace(QPoint(0,0),QPoint(0,0));
TagliaPoi = areaplace;
if (origImageFilename.size() > 0) {
ratio = 100.0;
original.save(origImageFilename,extension.data(),qualvalue->value());
rotazione = 0;
spinBox_4->setValue(rotazione);
BaseReset();
}
accept();
}
SCH_SCREEN::SCH_SCREEN( KIWAY* aKiway ) :
BASE_SCREEN( SCH_SCREEN_T ),
KIWAY_HOLDER( aKiway ),
m_paper( wxT( "A4" ) )
{
SetZoom( 32 );
for( unsigned i = 0; i < DIM( SchematicZoomList ); i++ )
m_ZoomList.push_back( SchematicZoomList[i] );
for( unsigned i = 0; i < DIM( SchematicGridList ); i++ )
AddGrid( SchematicGridList[i] );
SetGrid( wxRealPoint( 50, 50 ) ); // Default grid size.
m_refCount = 0;
// Suitable for schematic only. For libedit and viewlib, must be set to true
m_Center = false;
InitDataPoints( m_paper.GetSizeIU() );
}