int ZDvidDataSliceHelper::getWidth() const
{
if (getViewPort().isEmpty()) {
return 0;
}
return getViewPort().width();
}
int ZDvidDataSliceHelper::getHeight() const
{
if (getViewPort().isEmpty()) {
return 0;
}
return getViewPort().height();
}
/**
* returns paintViewPort
**/
nmc::DkPluginViewPort* DkNikonPlugin::getViewPort() {
if (!viewport) {
// >DIR: dummy viewport [4.7.2014 markus]
viewport = new DkNikonViewPort();
}
if (!maidFacade) {
QMainWindow* mainWindow = getMainWindow();
maidFacade = new MaidFacade(mainWindow);
if (maidFacade->init()) {
if (!camControls) {
// get last location
QSettings settings;
int dockLocation = settings.value("camControlsLocation", Qt::RightDockWidgetArea).toInt();
camControls = new DkCamControls(maidFacade, tr("Camera Controls"));
if (mainWindow)
mainWindow->addDockWidget((Qt::DockWidgetArea)dockLocation, camControls);
connect(camControls, SIGNAL(updateImage(QImage)), getViewPort(), SIGNAL(loadImage(QImage)));
connect(camControls, SIGNAL(loadFile(QFileInfo)), getViewPort(), SIGNAL(loadFile(QFileInfo)));
connect(camControls, SIGNAL(closeSignal()), getViewPort(), SIGNAL(closePlugin()));
}
camControls->setVisible(true);
} else {
QMessageBox warningDialog(mainWindow);
warningDialog.setWindowTitle(tr("MAID Library could not be opened"));
warningDialog.setText(tr("The MAID library could not be opened. Camera controls will be disabled."));
warningDialog.setIcon(QMessageBox::Warning);
warningDialog.setStandardButtons(QMessageBox::Ok);
warningDialog.setDefaultButton(QMessageBox::Ok);
warningDialog.show();
warningDialog.exec();
return 0;
}
}
return viewport;
}
void Window::setWindowSize( int w, int h ) noexcept
{
SDL_SetWindowSize( m_wimpl->window, w, h );
m_wimpl->original_width = w;
m_wimpl->original_height = h;
getViewPort( m_wimpl->viewport );
}
Texture2D* Director::getScreenshot(int format)
{
#if 0
fzSize viewPort = getViewPort();
fzPixelInfo formatInfo = Texture2D::getPixelInfo((fzPixelFormat)format);
fzTextureInfo textureInfo = Texture2D::getTextureInfo(formatInfo.textureFormat);
fzUInt bufferSize = (formatInfo.bbp * viewPort.width * viewPort.height)/8;
unsigned char *pixels = new unsigned char[bufferSize];
glReadPixels(0, 0, viewPort.width, viewPort.height, textureInfo.openGLFormat, formatInfo.dataType, pixels);
Texture2D *texture;
try {
texture = new Texture2D(pixels, (fzTextureFormat)format,
fzMath_nextPOT(viewPort.width), fzMath_nextPOT(viewPort.height), viewPort);
} catch (std::exception& error) {
FZLOGERROR("%s", error.what());
delete [] pixels;
return NULL;
}
return texture;
#endif
return NULL;
}
void Window::toggleFullscreen( const ScreenMode flag ) noexcept
{
SDL_SetWindowFullscreen( m_wimpl->window, toSDL2Flags_( flag ) );
if ( flag == ScreenMode::NO_FULLSCREEN )
{
setWindowSize( m_wimpl->original_width, m_wimpl->original_height );
}
else if ( flag == ScreenMode::FULLSCREEN )
{
SDL_RenderSetLogicalSize( m_wimpl->renderer, m_wimpl->original_width,
m_wimpl->original_height );
}
getViewPort( m_wimpl->viewport );
}
void CurveWidget::updatePlot()
{
if (leftPressed || rightPressed)
{
drawRubberBand(mousePressBeginPoint, mousePressEndPoint, DASH_SIZE, RUBBER_BAND_COLOR);
}
else
{
buffer.fill(Qt::white);
drawAxis();
curve.draw(getViewPort(), scale, thickness, antiAliasing);
QRgb oldColor = setColor(qRgb(0, 0, 0));
drawRect(QPoint(), QPoint(buffer.width() - 1, buffer.height() - 1));
setColor(oldColor);
}
const int FIELD_WIDTH = 2;
emit thicknessChanged(QString("%1").arg(QString::number(thickness), FIELD_WIDTH));
emit scaleChanged(QString("%1 : %2").
arg(QString::number(scale > 1 ? scale : 1.)).
arg(QString::number(scale > 1 ? 1. : 1 / scale)));
update();
}
Window::Window( WindowInfo& info )
: m_wimpl( new Window_( info ) )
{
getInfo( info );
getViewPort( m_wimpl->viewport );
}
void Director::updateProjection()
{
FZ_ASSERT(OSW::Instance(), "OS Wrapper is not defined.");
updateViewRect();
if(!(m_dirtyFlags & kFZDDirty_projection))
return;
// VIEW PORT
// The view port must be the display size in pixels.
// Display size is not equal to the screen size, an application could not use the whole screen.
fzSize viewPort = getViewPort();
glViewport(0, 0, viewPort.width, viewPort.height);
// PROJECTION
// The projection must be calculated using the canvas size. No pixels here.
fzSize canvasSize = getCanvasSize();
fzOrientation orientation = getOrientation();
if(orientation == kFZOrientation_LandscapeLeft || orientation == kFZOrientation_LandscapeRight)
FZ_SWAP(canvasSize.width, canvasSize.height);
switch (m_projection) {
case kFZProjection2D:
{
fzMath_mat4OrthoProjection(0, canvasSize.width, 0, canvasSize.height, -1024, 1024, m_transformMV);
break;
}
default:
FZ_RAISE("Director: Unrecognized projection.");
}
m_orientationTransform = FZAffineTransformIdentity;
if(orientation == kFZOrientation_LandscapeLeft) {
m_orientationTransform.translate(canvasSize.width, 0);
m_orientationTransform.rotate(FZ_DEGREES_TO_RADIANS(90));
fzMat4 mat;
fzMath_mat4Multiply(m_transformMV, m_orientationTransform, mat);
fzMath_mat4Copy(mat, m_transformMV);
}else if(orientation == kFZOrientation_LandscapeRight) {
m_orientationTransform.translate(0, canvasSize.height);
m_orientationTransform.rotate(FZ_DEGREES_TO_RADIANS(-90));
fzMat4 mat;
fzMath_mat4Multiply(m_transformMV, m_orientationTransform, mat);
fzMath_mat4Copy(mat, m_transformMV);
}
m_orientationTransform = m_orientationTransform.getInverse();
m_dirtyFlags &= ~kFZDDirty_projection;
if(p_runningScene) {
p_runningScene->updateLayout();
if(p_hud)
p_hud->updateLayout();
}
}
void Director::updateViewRect()
{
if(!(m_dirtyFlags & kFZDDirty_viewPort))
return;
if(m_windowSize == FZSizeZero && m_originalCanvasSize == FZSizeZero)
setFullscreen();
else if(m_windowSize == FZSizeZero)
setWindowSize(m_originalCanvasSize);
fzSize windowSize = getWindowSize();
fzSize canvasSize = (m_originalCanvasSize == FZSizeZero) ? windowSize : m_originalCanvasSize;
fzOrientation orientation = getOrientation();
if(orientation == kFZOrientation_LandscapeLeft ||
orientation == kFZOrientation_LandscapeRight)
{
FZ_SWAP(canvasSize.width, canvasSize.height);
}
fzFloat windowRate = windowSize.width/windowSize.height;
fzFloat canvasRate = canvasSize.width/canvasSize.height;
fzSize newCanvasSize = canvasSize; // could be the same
if(windowRate == canvasRate) {
// No resizing because the canvas and window rate is the same.
m_renderingRect = fzRect(FZPointZero, windowSize);
}else{
// The window and the canvas rate is different, so we have to apply
// the proper resizing algorythm
switch (m_resizeMode) {
case kFZResizeMode_None:
{
m_renderingRect.size = canvasSize;
m_renderingRect.origin = (windowSize - canvasSize)/2;
break;
}
case kFZResizeMode_Expand:
{
m_renderingRect = fzRect(FZPointZero, windowSize);
break;
}
case kFZResizeMode_Fit:
{
if(canvasRate > windowRate)
{
m_renderingRect.size.width = windowSize.width;
m_renderingRect.size.height = canvasSize.height * windowSize.width/canvasSize.width;
m_renderingRect.origin = fzPoint(0, (windowSize.height-m_renderingRect.size.height)/2);
}else{
m_renderingRect.size.height = windowSize.height;
m_renderingRect.size.width = canvasSize.width * windowSize.height/canvasSize.height;
m_renderingRect.origin = fzPoint((windowSize.width-m_renderingRect.size.width)/2, 0);
}
break;
}
case kFZResizeMode_FitFill:
{
if(canvasRate > windowRate)
newCanvasSize.height = canvasSize.width / windowRate;
else
newCanvasSize.width = canvasSize.height * windowRate;
m_renderingRect = fzRect(FZPointZero, windowSize);
break;
}
case kFZResizeMode_IntFit:
{
fzFloat factorX = windowSize.width / canvasSize.width;
fzFloat factorY = windowSize.height / canvasSize.height;
fzFloat factor = MIN(factorX, factorY);
factor = (factor >= 1.0f) ? static_cast<fzInt>(factor) : factor;
m_renderingRect.size = canvasSize * factor;
m_renderingRect.origin = (windowSize - m_renderingRect.size)/2;
break;
}
case kFZResizeMode_IntFitFill:
{
fzFloat factorX = windowSize.width / canvasSize.width;
fzFloat factorY = windowSize.height / canvasSize.height;
fzFloat factor = MIN(factorX, factorY);
factor = (factor >= 1.0f) ? static_cast<fzInt>(factor) : factor;
newCanvasSize = windowSize / factor;
m_renderingRect = fzRect(FZPointZero, windowSize);
break;
}
default:
break;
}
}
m_canvasSize = newCanvasSize;
if(orientation == kFZOrientation_LandscapeLeft ||
orientation == kFZOrientation_LandscapeRight)
{
FZ_SWAP(m_canvasSize.width, m_canvasSize.height);
}
// FACTORS
fzSize viewPort = getViewPort();
fzFloat factorX = viewPort.width / newCanvasSize.width;
fzFloat factorY = viewPort.height / newCanvasSize.height;
// COMPUTE FINAL FACTOR
fzFloat newFactor = roundf(MAX(MAX(factorX, factorY), 1));
if(newFactor > DeviceConfig::Instance().getMaxFactor())
newFactor = DeviceConfig::Instance().getMaxFactor();
if(newFactor > m_resourcesFactor)
{
TextureCache::Instance().removeAllTextures();
FontCache::Instance().removeAllFonts();
}
m_resourcesFactor = newFactor;
m_dirtyFlags &= ~kFZDDirty_viewPort;
m_dirtyFlags |= kFZDDirty_projection;
// Notify changes to the OS Wrapper
OSW::setOrientation(orientation);
OSW::updateWindow();
}
void handleSetViewPort() override {
getDisplayDevice()->setViewPort(getViewPort());
}
ZIntCuboid ZDvidDataSliceHelper::getBoundBox() const
{
return GetBoundBox(getViewPort(), getZ());
}
int ZDvidDataSliceHelper::getY() const
{
return getViewPort().top();
}
int ZDvidDataSliceHelper::getX() const
{
return getViewPort().left();
}
QPointF CurveWidget::toAbsolute(const QPointF& relative)
{
QRectF viewPort = getViewPort();
return QPointF(relative.x() / scale + viewPort.x(),
(buffer.height() - relative.y()) / scale + viewPort.y());
}
QPointF CurveWidget::toRelative(const QPointF& absolute)
{
QRectF viewPort = getViewPort();
return QPointF((absolute.x() - viewPort.x()) * scale,
buffer.height() - (absolute.y() - viewPort.y()) * scale);
}
