mirror of
https://github.com/hrydgard/ppsspp.git
synced 2024-12-14 08:59:47 +00:00
382 lines
15 KiB
C++
382 lines
15 KiB
C++
// Copyright (c) 2013- PPSSPP Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0 or later versions.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official git repository and contact information can be found at
|
|
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
|
|
|
#include <algorithm>
|
|
|
|
#include "Common/System/Display.h"
|
|
#include "Common/System/System.h"
|
|
#include "Common/Render/TextureAtlas.h"
|
|
#include "Common/Render/DrawBuffer.h"
|
|
#include "Common/UI/Context.h"
|
|
#include "Common/UI/View.h"
|
|
|
|
#include "Common/Data/Color/RGBAUtil.h"
|
|
#include "Common/Data/Text/I18n.h"
|
|
#include "UI/DisplayLayoutScreen.h"
|
|
#include "Core/Config.h"
|
|
#include "Core/ConfigValues.h"
|
|
#include "Core/System.h"
|
|
#include "DisplayLayoutEditor.h"
|
|
#include "GPU/Common/FramebufferManagerCommon.h"
|
|
|
|
static const int leftColumnWidth = 200;
|
|
static const float orgRatio = 1.764706f;
|
|
|
|
static const float UI_DISPLAY_SCALE = 8.0f;
|
|
static float ScaleSettingToUI() {
|
|
float scale = g_Config.fSmallDisplayZoomLevel * UI_DISPLAY_SCALE;
|
|
// Account for 1x display doubling dps.
|
|
if (g_dpi_scale_x > 1.0f) {
|
|
scale *= g_dpi_scale_x;
|
|
}
|
|
return scale;
|
|
}
|
|
|
|
static void UpdateScaleSetting(float scale) {
|
|
// Account for 1x display doubling dps.
|
|
if (g_dpi_scale_x > 1.0f) {
|
|
scale /= g_dpi_scale_x;
|
|
}
|
|
g_Config.fSmallDisplayZoomLevel = scale;
|
|
}
|
|
|
|
static void UpdateScaleSettingFromUI(float scale) {
|
|
UpdateScaleSetting(scale / UI_DISPLAY_SCALE);
|
|
}
|
|
|
|
class DragDropDisplay : public MultiTouchDisplay {
|
|
public:
|
|
DragDropDisplay(float &x, float &y, ImageID img, float scale, const Bounds &screenBounds)
|
|
: MultiTouchDisplay(img, scale, new UI::AnchorLayoutParams(x * screenBounds.w, y * screenBounds.h, UI::NONE, UI::NONE, true)),
|
|
x_(x), y_(y), screenBounds_(screenBounds) {
|
|
UpdateScale(scale);
|
|
}
|
|
|
|
std::string DescribeText() const override;
|
|
|
|
void SaveDisplayPosition() {
|
|
x_ = bounds_.centerX() / screenBounds_.w;
|
|
y_ = bounds_.centerY() / screenBounds_.h;
|
|
}
|
|
|
|
void UpdateScale(float s) {
|
|
scale_ = s;
|
|
}
|
|
float Scale() {
|
|
return scale_;
|
|
}
|
|
|
|
private:
|
|
float &x_, &y_;
|
|
const Bounds &screenBounds_;
|
|
};
|
|
|
|
std::string DragDropDisplay::DescribeText() const {
|
|
auto u = GetI18NCategory("UI Elements");
|
|
return u->T("Screen representation");
|
|
}
|
|
|
|
DisplayLayoutScreen::DisplayLayoutScreen() {
|
|
// Ignore insets - just couldn't get the logic to work.
|
|
ignoreInsets_ = true;
|
|
}
|
|
|
|
bool DisplayLayoutScreen::touch(const TouchInput &touch) {
|
|
UIScreen::touch(touch);
|
|
|
|
using namespace UI;
|
|
|
|
int mode = mode_ ? mode_->GetSelection() : 0;
|
|
if (g_Config.iSmallDisplayZoomType == (int)SmallDisplayZoom::AUTO) {
|
|
mode = -1;
|
|
}
|
|
|
|
const Bounds &screen_bounds = screenManager()->getUIContext()->GetBounds();
|
|
if ((touch.flags & TOUCH_MOVE) != 0 && dragging_) {
|
|
int touchX = touch.x - offsetTouchX_;
|
|
int touchY = touch.y - offsetTouchY_;
|
|
if (mode == 0) {
|
|
const auto &prevParams = displayRepresentation_->GetLayoutParams()->As<AnchorLayoutParams>();
|
|
Point newPos(prevParams->left, prevParams->top);
|
|
|
|
int limitX = g_Config.fSmallDisplayZoomLevel * 120;
|
|
int limitY = g_Config.fSmallDisplayZoomLevel * 68;
|
|
|
|
const int quarterResX = screen_bounds.w / 4;
|
|
const int quarterResY = screen_bounds.h / 4;
|
|
|
|
if (bRotated_) {
|
|
//swap X/Y limit for rotated display
|
|
std::swap(limitX, limitY);
|
|
}
|
|
|
|
// Check where each edge of the screen is
|
|
const int windowLeftEdge = quarterResX;
|
|
const int windowRightEdge = windowLeftEdge * 3;
|
|
const int windowUpperEdge = quarterResY;
|
|
const int windowLowerEdge = windowUpperEdge * 3;
|
|
// And stick display when close to any edge
|
|
stickToEdgeX_ = false;
|
|
stickToEdgeY_ = false;
|
|
if (touchX > windowLeftEdge - 8 + limitX && touchX < windowLeftEdge + 8 + limitX) { touchX = windowLeftEdge + limitX; stickToEdgeX_ = true; }
|
|
if (touchX > windowRightEdge - 8 - limitX && touchX < windowRightEdge + 8 - limitX) { touchX = windowRightEdge - limitX; stickToEdgeX_ = true; }
|
|
if (touchY > windowUpperEdge - 8 + limitY && touchY < windowUpperEdge + 8 + limitY) { touchY = windowUpperEdge + limitY; stickToEdgeY_ = true; }
|
|
if (touchY > windowLowerEdge - 8 - limitY && touchY < windowLowerEdge + 8 - limitY) { touchY = windowLowerEdge - limitY; stickToEdgeY_ = true; }
|
|
|
|
const int minX = screen_bounds.w / 2;
|
|
const int maxX = screen_bounds.w + minX;
|
|
const int minY = screen_bounds.h / 2;
|
|
const int maxY = screen_bounds.h + minY;
|
|
// Display visualization disappear outside of those bounds, so we have to limit
|
|
if (touchX < -minX) touchX = -minX;
|
|
if (touchX > maxX) touchX = maxX;
|
|
if (touchY < -minY) touchY = -minY;
|
|
if (touchY > maxY) touchY = maxY;
|
|
|
|
// Limit small display on much larger output a bit differently
|
|
if (quarterResX > limitX) limitX = quarterResX;
|
|
if (quarterResY > limitY) limitY = quarterResY;
|
|
|
|
// Allow moving zoomed in display freely as long as at least noticeable portion of the screen is occupied
|
|
if (touchX > minX - limitX - 10 && touchX < minX + limitX + 10) {
|
|
newPos.x = touchX;
|
|
}
|
|
if (touchY > minY - limitY - 10 && touchY < minY + limitY + 10) {
|
|
newPos.y = touchY;
|
|
}
|
|
displayRepresentation_->ReplaceLayoutParams(new AnchorLayoutParams(newPos.x, newPos.y, NONE, NONE, true));
|
|
} else if (mode == 1) {
|
|
// Resize. Vertical = scaling; Up should be bigger so let's negate in that direction
|
|
float diffY = -(touchY - startY_);
|
|
|
|
float movementScale = 0.5f;
|
|
float newScale = startScale_ + diffY * movementScale;
|
|
// Desired scale * 8.0 since the visualization is tiny size and multiplied by 8.
|
|
newScale = clamp_value(newScale, UI_DISPLAY_SCALE, UI_DISPLAY_SCALE * 10.0f);
|
|
displayRepresentation_->UpdateScale(newScale);
|
|
UpdateScaleSettingFromUI(newScale);
|
|
}
|
|
}
|
|
if ((touch.flags & TOUCH_DOWN) != 0 && !dragging_) {
|
|
dragging_ = true;
|
|
const Bounds &bounds = displayRepresentation_->GetBounds();
|
|
startY_ = bounds.centerY();
|
|
offsetTouchX_ = touch.x - bounds.centerX();
|
|
offsetTouchY_ = touch.y - bounds.centerY();
|
|
startScale_ = displayRepresentation_->Scale();
|
|
}
|
|
if ((touch.flags & TOUCH_UP) != 0 && dragging_) {
|
|
displayRepresentation_->SaveDisplayPosition();
|
|
dragging_ = false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DisplayLayoutScreen::resized() {
|
|
RecreateViews();
|
|
}
|
|
|
|
void DisplayLayoutScreen::onFinish(DialogResult reason) {
|
|
g_Config.Save("DisplayLayoutScreen::onFinish");
|
|
}
|
|
|
|
UI::EventReturn DisplayLayoutScreen::OnCenter(UI::EventParams &e) {
|
|
if (!stickToEdgeX_ || (stickToEdgeX_ && stickToEdgeY_))
|
|
g_Config.fSmallDisplayOffsetX = 0.5f;
|
|
if (!stickToEdgeY_ || (stickToEdgeX_ && stickToEdgeY_))
|
|
g_Config.fSmallDisplayOffsetY = 0.5f;
|
|
RecreateViews();
|
|
return UI::EVENT_DONE;
|
|
};
|
|
|
|
UI::EventReturn DisplayLayoutScreen::OnZoomTypeChange(UI::EventParams &e) {
|
|
if (g_Config.iSmallDisplayZoomType < (int)SmallDisplayZoom::MANUAL) {
|
|
const Bounds &bounds = screenManager()->getUIContext()->GetBounds();
|
|
float autoBound = bounds.w / 480.0f;
|
|
UpdateScaleSetting(autoBound);
|
|
displayRepresentation_->UpdateScale(ScaleSettingToUI());
|
|
g_Config.fSmallDisplayOffsetX = 0.5f;
|
|
g_Config.fSmallDisplayOffsetY = 0.5f;
|
|
}
|
|
RecreateViews();
|
|
return UI::EVENT_DONE;
|
|
};
|
|
|
|
void DisplayLayoutScreen::dialogFinished(const Screen *dialog, DialogResult result) {
|
|
RecreateViews();
|
|
}
|
|
|
|
class Boundary : public UI::View {
|
|
public:
|
|
Boundary(UI::LayoutParams *layoutParams) : UI::View(layoutParams) {
|
|
}
|
|
|
|
std::string DescribeText() const override {
|
|
return "";
|
|
}
|
|
|
|
void Draw(UIContext &dc) override {
|
|
dc.Draw()->DrawImageCenterTexel(dc.theme->whiteImage, bounds_.x, bounds_.y, bounds_.x2(), bounds_.y2(), dc.theme->itemDownStyle.background.color);
|
|
}
|
|
};
|
|
|
|
// Stealing StickyChoice's layout and text rendering.
|
|
class HighlightLabel : public UI::StickyChoice {
|
|
public:
|
|
HighlightLabel(const std::string &text, UI::LayoutParams *layoutParams)
|
|
: UI::StickyChoice(text, "", layoutParams) {
|
|
Press();
|
|
}
|
|
|
|
bool CanBeFocused() const override { return false; }
|
|
};
|
|
|
|
void DisplayLayoutScreen::CreateViews() {
|
|
const Bounds &bounds = screenManager()->getUIContext()->GetBounds();
|
|
|
|
using namespace UI;
|
|
|
|
auto di = GetI18NCategory("Dialog");
|
|
auto gr = GetI18NCategory("Graphics");
|
|
auto co = GetI18NCategory("Controls");
|
|
|
|
root_ = new AnchorLayout(new LayoutParams(FILL_PARENT, FILL_PARENT));
|
|
|
|
const float previewWidth = bounds.w / 2.0f;
|
|
const float previewHeight = bounds.h / 2.0f;
|
|
|
|
// Just visual boundaries of the screen, should be easier to use than imagination
|
|
const float horizPreviewPadding = bounds.w / 4.0f;
|
|
const float vertPreviewPadding = bounds.h / 4.0f;
|
|
const float horizBoundariesWidth = 4.0f;
|
|
// This makes it have at least 10.0f padding below at 1x.
|
|
const float vertBoundariesHeight = 52.0f;
|
|
|
|
// We manually implement insets here for the buttons. This file defied refactoring :(
|
|
float leftInset = System_GetPropertyFloat(SYSPROP_DISPLAY_SAFE_INSET_LEFT);
|
|
|
|
// Left side, right, top, bottom.
|
|
root_->Add(new Boundary(new AnchorLayoutParams(horizBoundariesWidth, FILL_PARENT, horizPreviewPadding - horizBoundariesWidth, 0, NONE, 0)));
|
|
root_->Add(new Boundary(new AnchorLayoutParams(horizBoundariesWidth, FILL_PARENT, horizPreviewPadding + previewWidth, 0, NONE, 0)));
|
|
root_->Add(new Boundary(new AnchorLayoutParams(previewWidth, vertBoundariesHeight, horizPreviewPadding, vertPreviewPadding - vertBoundariesHeight, NONE, NONE)));
|
|
root_->Add(new Boundary(new AnchorLayoutParams(previewWidth, vertBoundariesHeight, horizPreviewPadding, vertPreviewPadding + previewHeight, NONE, NONE)));
|
|
|
|
bool displayRotEnable = (g_Config.iRenderingMode != FB_NON_BUFFERED_MODE) || g_Config.bSoftwareRendering;
|
|
bRotated_ = false;
|
|
if (displayRotEnable && (g_Config.iInternalScreenRotation == ROTATION_LOCKED_VERTICAL || g_Config.iInternalScreenRotation == ROTATION_LOCKED_VERTICAL180)) {
|
|
bRotated_ = true;
|
|
}
|
|
|
|
HighlightLabel *label = nullptr;
|
|
mode_ = nullptr;
|
|
if (g_Config.iSmallDisplayZoomType >= (int)SmallDisplayZoom::AUTO) { // Scaling
|
|
if (g_Config.iSmallDisplayZoomType == (int)SmallDisplayZoom::AUTO) {
|
|
label = new HighlightLabel(gr->T("Auto Scaling"), new AnchorLayoutParams(WRAP_CONTENT, 64.0f, bounds.w / 2.0f, bounds.h / 2.0f, NONE, NONE, true));
|
|
float autoBound = bounds.h / 270.0f;
|
|
// Case of screen rotated ~ only works with buffered rendering
|
|
if (bRotated_) {
|
|
autoBound = bounds.h / 480.0f;
|
|
} else { // Without rotation in common cases like 1080p we cut off 2 pixels of height, this reflects other cases
|
|
float resCommonWidescreen = autoBound - floor(autoBound);
|
|
if (resCommonWidescreen != 0.0f) {
|
|
float ratio = bounds.w / bounds.h;
|
|
if (ratio < orgRatio) {
|
|
autoBound = bounds.w / 480.0f;
|
|
}
|
|
else {
|
|
autoBound = bounds.h / 272.0f;
|
|
}
|
|
}
|
|
}
|
|
UpdateScaleSetting(autoBound);
|
|
g_Config.fSmallDisplayOffsetX = 0.5f;
|
|
g_Config.fSmallDisplayOffsetY = 0.5f;
|
|
} else { // Manual Scaling
|
|
Choice *center = new Choice(di->T("Center"), "", false, new AnchorLayoutParams(leftColumnWidth, WRAP_CONTENT, 10 + leftInset, NONE, NONE, 74));
|
|
center->OnClick.Handle(this, &DisplayLayoutScreen::OnCenter);
|
|
root_->Add(center);
|
|
float minZoom = 1.0f;
|
|
if (g_dpi_scale_x > 1.0f) {
|
|
minZoom /= g_dpi_scale_x;
|
|
}
|
|
PopupSliderChoiceFloat *zoomlvl = new PopupSliderChoiceFloat(&g_Config.fSmallDisplayZoomLevel, minZoom, 10.0f, di->T("Zoom"), 1.0f, screenManager(), di->T("* PSP res"), new AnchorLayoutParams(leftColumnWidth, WRAP_CONTENT, 10 + leftInset, NONE, NONE, 10 + 64 + 64));
|
|
root_->Add(zoomlvl);
|
|
mode_ = new ChoiceStrip(ORIENT_VERTICAL, new AnchorLayoutParams(leftColumnWidth, WRAP_CONTENT, 10 + leftInset, NONE, NONE, 158 + 64 + 10));
|
|
mode_->AddChoice(di->T("Move"));
|
|
mode_->AddChoice(di->T("Resize"));
|
|
mode_->SetSelection(0, false);
|
|
}
|
|
displayRepresentation_ = new DragDropDisplay(g_Config.fSmallDisplayOffsetX, g_Config.fSmallDisplayOffsetY, ImageID("I_PSP_DISPLAY"), ScaleSettingToUI(), bounds);
|
|
displayRepresentation_->SetVisibility(V_VISIBLE);
|
|
} else { // Stretching
|
|
label = new HighlightLabel(gr->T("Stretching"), new AnchorLayoutParams(WRAP_CONTENT, 64.0f, bounds.w / 2.0f, bounds.h / 2.0f, NONE, NONE, true));
|
|
displayRepresentation_ = new DragDropDisplay(g_Config.fSmallDisplayOffsetX, g_Config.fSmallDisplayOffsetY, ImageID("I_PSP_DISPLAY"), ScaleSettingToUI(), bounds);
|
|
displayRepresentation_->SetVisibility(V_INVISIBLE);
|
|
float width = previewWidth;
|
|
float height = previewHeight;
|
|
if (g_Config.iSmallDisplayZoomType == (int)SmallDisplayZoom::STRETCH) {
|
|
Choice *stretched = new Choice("", "", false, new AnchorLayoutParams(width, height, width - width / 2.0f, NONE, NONE, height - height / 2.0f));
|
|
stretched->SetEnabled(false);
|
|
root_->Add(stretched);
|
|
} else { // Partially stretched
|
|
float origRatio = !bRotated_ ? 480.0f / 272.0f : 272.0f / 480.0f;
|
|
float frameRatio = width / height;
|
|
if (origRatio > frameRatio) {
|
|
height = width / origRatio;
|
|
if (!bRotated_ && g_Config.iSmallDisplayZoomType == (int)SmallDisplayZoom::PARTIAL_STRETCH) {
|
|
height = (272.0f + height) / 2.0f;
|
|
}
|
|
} else {
|
|
width = height * origRatio;
|
|
if (bRotated_ && g_Config.iSmallDisplayZoomType == (int)SmallDisplayZoom::PARTIAL_STRETCH) {
|
|
width = (272.0f + height) / 2.0f;
|
|
}
|
|
}
|
|
Choice *stretched = new Choice("", "", false, new AnchorLayoutParams(width, height, previewWidth - width / 2.0f, NONE, NONE, previewHeight - height / 2.0f));
|
|
stretched->SetEnabled(false);
|
|
root_->Add(stretched);
|
|
}
|
|
}
|
|
if (bRotated_) {
|
|
displayRepresentation_->SetAngle(90.0f);
|
|
}
|
|
|
|
root_->Add(displayRepresentation_);
|
|
if (mode_) {
|
|
root_->Add(mode_);
|
|
}
|
|
if (label) {
|
|
root_->Add(label);
|
|
}
|
|
|
|
static const char *zoomLevels[] = { "Stretching", "Partial Stretch", "Auto Scaling", "Manual Scaling" };
|
|
auto zoom = new PopupMultiChoice(&g_Config.iSmallDisplayZoomType, di->T("Options"), zoomLevels, 0, ARRAY_SIZE(zoomLevels), gr->GetName(), screenManager(), new AnchorLayoutParams(400, WRAP_CONTENT, previewWidth - 200.0f, NONE, NONE, 10));
|
|
zoom->OnChoice.Handle(this, &DisplayLayoutScreen::OnZoomTypeChange);
|
|
root_->Add(zoom);
|
|
|
|
static const char *displayRotation[] = { "Landscape", "Portrait", "Landscape Reversed", "Portrait Reversed" };
|
|
auto rotation = new PopupMultiChoice(&g_Config.iInternalScreenRotation, gr->T("Rotation"), displayRotation, 1, ARRAY_SIZE(displayRotation), co->GetName(), screenManager(), new AnchorLayoutParams(400, WRAP_CONTENT, previewWidth - 200.0f, 10, NONE, bounds.h - 64 - 10));
|
|
rotation->SetEnabledFunc([] {
|
|
return g_Config.iRenderingMode != FB_NON_BUFFERED_MODE || g_Config.bSoftwareRendering;
|
|
});
|
|
root_->Add(rotation);
|
|
|
|
Choice *back = new Choice(di->T("Back"), "", false, new AnchorLayoutParams(leftColumnWidth, WRAP_CONTENT, 10 + leftInset, NONE, NONE, 10));
|
|
back->OnClick.Handle<UIScreen>(this, &UIScreen::OnBack);
|
|
root_->Add(back);
|
|
}
|