Xargon/ES-DE
1
0
Fork 0
mirror of https://github.com/RetroDECK/ES-DE.git synced 2024-11-22 06:05:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

update from master

Browse source
This commit is contained in:
SophiaHadash 2021-07-16 10:10:55 +02:00
parent 5f23074f72 fd742ab452
commit 75bf7781e3
218 changed files with 10117 additions and 9860 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

144
.clang-format Normal file
View file

@ -0,0 +1,144 @@
# SPDX-License-Identifier: MIT
#
# EmulationStation Desktop Edition
# .clang-format
#
# Style configuration file for automatic C++ code formatting using clang-format.
# This file requires at least clang-format version 10.0.
#
---
Language: Cpp
# BasedOnStyle: WebKit
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: false
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: false
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Empty
AllowShortCaseLabelsOnASingleLine: false
# The following option requires version >= 11.0.
#####AllowShortEnumsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: false
BraceWrapping:
AfterCaseLabel: false
AfterClass: true
AfterControlStatement: false
AfterEnum: false
AfterFunction: true
AfterNamespace: true
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: true
BeforeElse: true
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: false
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeComma
BreakStringLiterals: true
ColumnLimit: 100
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: false
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
- Regex: '.*'
Priority: 1
SortPriority: 0
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: true
IndentGotoLabels: true
IndentPPDirectives: None
IndentWidth: 4
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: All
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 4
ObjCSpaceAfterProperty: true
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: true
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: false
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: c++14
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseCRLF: false
UseTab: Never
...

3
.gitignore vendored
View file

@ -28,6 +28,9 @@ emulationstation.core
# Profiling data
gmon.out
# Patch/diff files
*.patch
# Build directories
build
Debug

27
CHANGELOG.md
View file

@ -12,9 +12,9 @@ The 1.1 release brings many large changes including a fullscreen media viewer, a
A much better mechanism to find emulators and emulator cores has been implemented as well, which among other things removes the need to manually modify the Path variable on Windows to find RetroArch. It also eliminates the requirement for a separate Flatpak-specific es_systems.xml file on Linux.
The User guide contains additional in-depth explanations of the new functionality.
There are also several changes under the hood, such as the addition of the CImg image processing library, automatic code formatting of the entire codebase using clang-format, change of language standard from C++11 to C++14 and lots of general code refactoring.
Apart from this, many small improvements and bug fixes are part of the release, as listed below.
Apart from this, numerous small improvements and bug fixes are part of the release, as detailed below.
### Detailed list of changes
@ -25,14 +25,16 @@ Apart from this, many small improvements and bug fixes are part of the release,
* Added a new video player based on FFmpeg
* Added a 60 FPS frame rate upscaler option to the video player which results in slightly smoother playback for low frame rate videos (e.g. 24 and 30 FPS)
* Implemented a new mechanism for locating emulators and cores, with configurable find rules (this eliminates some hacks such as the separate Flatpak es_systems.cfg file)
* Added a Windows-specific find rule that searches the Registry for the App Paths keys, which should eliminate the need to modify the Path manually to find RetroArch
* Added a Windows-specific find rule that searches the Registry for the App Paths keys, which eliminates the need to modify the Path manually to find RetroArch
* Removed the deprecated %COREPATH% setting and corresponding menu entry
* The "Run in background (while game is launched)" option can now be enabled on all operating systems instead of only on Windows
* Added a workaround for a game launch issue on Windows when using AMD and Intel GPUs
* Moved to the SDL GameController API which gives numerous improvements to the controller handling
* Default controller configuration is now automatically applied, input configuration should rarely if ever be required any longer except for deliberate button customization
* Added support for selecting the controller type (Xbox, Xbox 360, PS4, PS5 and SNES), which changes the help icons, help text and the input configuration tool icons and text
* Added an option to limit the input in ES-DE to only the first controller (does not affect the emulators)
* Added an option to limit the input in ES-DE to only the first controller (this does not affect the emulators)
* Switched the order of the "Back" and "Start" buttons (or equivalents) in the input configurator to align with the other button entries which go from left to right
* Added separate controller deadzone values for the triggers and thumbsticks
* Removed the startup notification regarding default keyboard mappings being in use, instead default mappings are now considered the recommended input configuration
* The controller input configuration is not automatically started any longer if there is no es_input.cfg file or if there are no applicable configuration entries in the file
* Increased the max allowed size for images when scraping, which should now only downscale files which really need it
@ -42,7 +44,7 @@ Apart from this, many small improvements and bug fixes are part of the release,
* The help text for the "A" button now shows "Enter" instead of "Launch" in the grouped custom collections view
* Added navigation sounds for some actions where it was missing, such as when attempting to add folders, placeholders or systems to custom collections
* Changed the custom collection "Jump to" navigation sound to the select sound instead of the scroll sound
* A notification is now displayed in the grouped custom collections view if a filter is applied to the collection
* A notification is now displayed in the grouped custom collections view if a filter is applied to the selected collection
* Changed the default screensaver type from "dim" to "video" and made the fallback screensaver "dim" instead of "black"
* Moved the video screensaver audio setting to the sound settings menu
* Added support for the Nintendo Switch game system (using the Yuzu emulator)
@ -53,6 +55,7 @@ Apart from this, many small improvements and bug fixes are part of the release,
* The quit menu is now disabled by default, instead showing the "Quit EmulationStation" entry unless configured otherwise
* Removed the "Display game media from ROM directories" setting as it doesn't make sense to support this legacy functionality any longer
* Added support for using the %ESPATH% and %ROMPATH% variables in the slideshow screensaver custom image directory setting
* Improved scaling relative to the screen aspect ratio for various GUI components which enhances the layout on 4:3 displays and ultrawide monitors
* Removed the menu fade-in effect as it looked terrible
* Enabled the menu scale-up effect for the OpenGL ES renderer
* Renamed es_systems.cfg, es_settings.cfg and es_input.cfg to es_systems.xml, es_settings.xml and es_input.xml
@ -69,17 +72,28 @@ Apart from this, many small improvements and bug fixes are part of the release,
* Added a DebugSkipInputLogging option which is intended primarily for development and needs to be manually set in es_settings.xml
* Added the CImg library as a Git subtree and created some utility functions for it (used by the miximage generator and the game launch screen)
* Added a function to ImageComponent to crop fully transparent areas around an image
* Added and clarified startup log warnings for missing or invalid es_systems.xml platform tags
* Added a CMake option to control whether the VLC video player should be built, and set this to off by default
* Made it possible to build on the Raspberry Pi 4 (tested on Raspberry Pi OS)
* Removed the deprecated VideoOmxComponent
* Removed the pointless APPLE_SKIP_INSTALL_LIBS CMake option
* Added a clang-format style configuration file to use for automatic code formatting
* Formatted the entire codebase using clang-format
* Integrated clang-tidy with CMake and made it possible to enable it via a flag
* Added the NanoSVG library as a proper Git subtree
* Changed the language standard from C++11 to C++14
### Bug fixes
* Marking all games as favorites for a system or folder or removing all favorite markings would sometimes crash the application
* Scraping new game media using the single-game scraper followed by a re-scrape that was aborted could crash the application
* The scraper search could be refined or skipped after the result was accepted which sometimes crashed the application
* Attempting to load a non-existent font file defined by the theme crashed the application instead of using the bundled font as fallback
* Refining a search before it was completed and then cancelling the dialog would lead to an empty scraper screen
* Games that were filtered out were included in the random game selection for the grouped custom collections view
* After switching theme sets with only a single system available, diagonal slide transitions would sometimes play when moving to the system view
* Ongoing slide transition animations would continue to play after switching theme sets
* When using the Video view style, the static image would not get rendered during the first Slide transition when coming from the System view
* Long game names that were horizontally scrolling in the gamelist view would sometimes flicker when returning to the start position
* On Windows, images with Unicode characters in the game name that were resized when scraping would not get saved with valid filenames
* The glitches when configuring trigger buttons in GuiInputConfig have been fixed
@ -87,7 +101,10 @@ Apart from this, many small improvements and bug fixes are part of the release,
* GuiInputConfig didn't correctly inform which buttons could be skipped for some rows
* The scraper would sometimes consider very small images to be invalid
* The Quick System Select help prompt was shown even when there was only a single game system present
* The "Back (cancel)" help prompt was missing for the single-game scraper
* The "Y" button help prompt wasn't displayed correctly when using the Grid view style
* Fractional game rating values would always get rounded up
* Encountering a corrupt image file would lead to a continuous loop of attempts to load the image while filling the log file with error messages
* Cropping in ImageComponent didn't work correctly
* The debug logging for the analog controller inputs had some inconsistent signs

110
CMakeLists.txt
View file

@ -14,8 +14,6 @@ set(CMAKE_VERBOSE_MAKEFILE OFF CACHE BOOL "Show verbose compiler output" FORCE)
# Package type to use for CPack on Linux.
set(LINUX_CPACK_GENERATOR "DEB" CACHE STRING "CPack generator, DEB or RPM")
set(VLC_PLAYER OFF CACHE BOOL "Whether to build with the VLC video player")
# Add local find modules to the CMake path.
list(APPEND CMAKE_MODULE_PATH
${CMAKE_CURRENT_SOURCE_DIR}/CMake/Utils
@ -26,38 +24,37 @@ option(GLES "Set to ON if targeting Embedded OpenGL" ${GLES})
option(GL "Set to ON if targeting Desktop OpenGL" ${GL})
option(RPI "Set to ON to enable Raspberry Pi specific build" ${RPI})
option(CEC "Set to ON to enable CEC" ${CEC})
option(VLC_PLAYER "Set to ON to build the VLC-based video player" ${VLC_PLAYER})
option(CLANG_TIDY "Set to ON to build using the clang-tidy static analyzer" ${CLANG_TIDY})
if (CLANG_TIDY)
find_program(CLANG_TIDY_BINARY NAMES clang-tidy)
if("${CLANG_TIDY_BINARY}" STREQUAL "CLANG_TIDY_BINARY-NOTFOUND")
message("-- CLANG_TIDY was set but the clang-tidy binary was not found")
else()
message("-- Building with the clang-tidy static analyzer")
set(CMAKE_CXX_CLANG_TIDY "clang-tidy;-checks=*,-fuchsia-*,-hicpp-*,-llvm-*, \
-readability-braces-*,-google-readability-braces-*, \
-readability-uppercase-literal-suffix,-modernize-use-trailing-return-type, \
-cppcoreguidelines-avoid-magic-numbers,-readability-magic-numbers")
endif()
endif()
#---------------------------------------------------------------------------------------------------
# OpenGL setup.
if(GLES)
set(GLSystem "Embedded OpenGL" CACHE STRING "The OpenGL system to be used")
elseif(GL)
set(GLSystem "Desktop OpenGL" CACHE STRING "The OpenGL system to be used")
# Check if we're running on a Raspberry Pi.
elseif(EXISTS "${CMAKE_FIND_ROOT_PATH}/opt/vc/include/bcm_host.h")
MESSAGE("bcm_host.h found")
set(BCMHOST found)
if(EXISTS "${CMAKE_FIND_ROOT_PATH}/opt/vc/include/bcm_host.h")
message("-- Building on a Raspberry Pi (bcm_host.h found)")
# Setting BCMHOST seems to break OpenGL ES on the RPi 4 so set RPI instead.
#set(BCMHOST found)
set(RPI ON)
set(GLSystem "Embedded OpenGL" CACHE STRING "The OpenGL system to be used")
# Check if we're running on OSMC Vero4K.
elseif(EXISTS "${CMAKE_FIND_ROOT_PATH}/opt/vero3/lib/libMali.so")
MESSAGE("libMali.so found")
set(VERO4K found)
set(GLSystem "Embedded OpenGL" CACHE STRING "The OpenGL system to be used")
# Check if we're running on olinuxino / odroid / etc.
elseif(EXISTS "${CMAKE_FIND_ROOT_PATH}/usr/lib/libMali.so" OR
EXISTS "${CMAKE_FIND_ROOT_PATH}/usr/lib/arm-linux-gnueabihf/libMali.so" OR
EXISTS "${CMAKE_FIND_ROOT_PATH}/usr/lib/aarch64-linux-gnu/libMali.so" OR
EXISTS "${CMAKE_FIND_ROOT_PATH}/usr/lib/arm-linux-gnueabihf/mali-egl/libmali.so" OR
EXISTS "${CMAKE_FIND_ROOT_PATH}/usr/lib/arm-linux-gnueabihf/libmali.so")
MESSAGE("libMali.so found")
elseif(GLES OR RPI)
set(GLSystem "Embedded OpenGL" CACHE STRING "The OpenGL system to be used")
else()
set(GLSystem "Desktop OpenGL" CACHE STRING "The OpenGL system to be used")
endif(GLES)
endif()
set_property(CACHE GLSystem PROPERTY STRINGS "Desktop OpenGL" "Embedded OpenGL")
@ -80,7 +77,7 @@ if(NOT WIN32)
find_package(Pugixml REQUIRED)
find_package(RapidJSON REQUIRED)
find_package(SDL2 REQUIRED)
if(VLC_PLAYER OR RPI)
if(VLC_PLAYER)
find_package(VLC REQUIRED)
endif()
endif()
@ -107,8 +104,8 @@ if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
message("-- Compiler is GNU/GCC")
execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpfullversion OUTPUT_VARIABLE G++_VERSION)
if(G++_VERSION VERSION_LESS 4.8)
message(SEND_ERROR "You need at least GCC 4.8 to compile EmulationStation-DE")
if(G++_VERSION VERSION_LESS 5.4)
message(SEND_ERROR "You need at least GCC 5.4 to compile EmulationStation-DE")
endif()
if(WIN32)
set(CMAKE_CXX_FLAGS "-mwindows ${CMAKE_CXX_FLAGS}")
@ -193,11 +190,6 @@ endif()
if(DEFINED BCMHOST OR RPI)
add_definitions(-D_RPI_)
add_definitions(-DBUILD_VLC_PLAYER)
endif()
if(DEFINED VERO4K)
add_definitions(-D_VERO4K_)
endif()
if(DEFINED libCEC_FOUND)
@ -240,7 +232,7 @@ set(COMMON_INCLUDE_DIRS
${CMAKE_CURRENT_SOURCE_DIR}/external/CImg
${CMAKE_CURRENT_SOURCE_DIR}/external/nanosvg/src
${CMAKE_CURRENT_SOURCE_DIR}/es-core/src)
if(VLC_PLAYER OR RPI)
if(VLC_PLAYER)
set(COMMON_INCLUDE_DIRS ${COMMON_INCLUDE_DIRS} ${VLC_INCLUDE_DIR})
endif()
@ -250,7 +242,6 @@ if(WIN32)
if(NOT EXISTS ${WIN32_INCLUDE_DIR})
message(SEND_ERROR "Can't find WIN32 include directory: ${WIN32_INCLUDE_DIR}")
endif()
#include_directories(${WIN32_INCLUDE_DIR})
endif()
# Temporary solution until the VLC find module has been updated to work properly on macOS.
@ -272,23 +263,12 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
list(APPEND COMMON_INCLUDE_DIRS ${ALSA_INCLUDE_DIRS})
endif()
if(DEFINED BCMHOST)
if(DEFINED BCMHOST OR RPI)
list(APPEND COMMON_INCLUDE_DIRS
"${CMAKE_FIND_ROOT_PATH}/opt/vc/include"
"${CMAKE_FIND_ROOT_PATH}/opt/vc/include/interface/vcos"
"${CMAKE_FIND_ROOT_PATH}/opt/vc/include/interface/vmcs_host/linux"
"${CMAKE_FIND_ROOT_PATH}/opt/vc/include/interface/vcos/pthreads")
# Add Vero4k include directory.
elseif(DEFINED VERO4K)
list(APPEND COMMON_INCLUDE_DIRS "${CMAKE_FIND_ROOT_PATH}/opt/vero3/include")
else()
# Add OpenGL include directory.
if(${GLSystem} MATCHES "Desktop OpenGL")
list(APPEND COMMON_INCLUDE_DIRS ${OPENGL_INCLUDE_DIR})
else()
# Add OpenGL ES include directory.
list(APPEND COMMON_INCLUDE_DIRS ${OPENGLES_INCLUDE_DIR})
endif()
endif()
#---------------------------------------------------------------------------------------------------
@ -302,7 +282,7 @@ if(NOT WIN32)
${FREETYPE_LIBRARIES}
${PUGIXML_LIBRARIES}
${SDL2_LIBRARY})
if(VLC_PLAYER OR RPI)
if(VLC_PLAYER)
set(COMMON_LIBRARIES ${COMMON_LIBRARIES} ${VLC_LIBRARIES})
endif()
elseif(WIN32)
@ -327,12 +307,12 @@ elseif(WIN32)
endif()
else()
set(COMMON_LIBRARIES
"${PROJECT_SOURCE_DIR}/avcodec-59.dll"
"${PROJECT_SOURCE_DIR}/avfilter-8.dll"
"${PROJECT_SOURCE_DIR}/avformat-59.dll"
"${PROJECT_SOURCE_DIR}/avutil-57.dll"
"${PROJECT_SOURCE_DIR}/swresample-4.dll"
"${PROJECT_SOURCE_DIR}/swscale-6.dll"
"${PROJECT_SOURCE_DIR}/avcodec-58.dll"
"${PROJECT_SOURCE_DIR}/avfilter-7.dll"
"${PROJECT_SOURCE_DIR}/avformat-58.dll"
"${PROJECT_SOURCE_DIR}/avutil-56.dll"
"${PROJECT_SOURCE_DIR}/swresample-3.dll"
"${PROJECT_SOURCE_DIR}/swscale-5.dll"
"${PROJECT_SOURCE_DIR}/FreeImage.dll"
"${PROJECT_SOURCE_DIR}/glew32.dll"
"${PROJECT_SOURCE_DIR}/libcurl-x64.dll"
@ -368,9 +348,9 @@ endif()
# Add libCEC libraries.
if(DEFINED libCEC_FOUND)
if(DEFINED BCMHOST)
list(APPEND COMMON_LIBRARIES vchiq_arm)
endif()
if(DEFINED BCMHOST OR RPI)
list(APPEND COMMON_LIBRARIES bcm_host vchiq_arm)
endif()
list(APPEND COMMON_LIBRARIES dl ${libCEC_LIBRARIES})
endif()
@ -382,15 +362,15 @@ endif()
if(DEFINED BCMHOST)
link_directories("${CMAKE_FIND_ROOT_PATH}/opt/vc/lib")
list(APPEND COMMON_LIBRARIES bcm_host brcmEGL ${OPENGLES_LIBRARIES})
elseif(DEFINED VERO4K)
link_directories("${CMAKE_FIND_ROOT_PATH}/opt/vero3/lib")
list(APPEND COMMON_LIBRARIES EGL ${OPENGLES_LIBRARIES})
elseif(RPI)
link_directories("${CMAKE_FIND_ROOT_PATH}/opt/vc/lib")
list(APPEND COMMON_LIBRARIES ${OPENGLES_LIBRARIES})
endif()
if(${GLSystem} MATCHES "Desktop OpenGL")
list(APPEND COMMON_LIBRARIES ${OPENGL_LIBRARIES})
else()
if(${GLSystem} MATCHES "Desktop OpenGL")
list(APPEND COMMON_LIBRARIES ${OPENGL_LIBRARIES})
else()
list(APPEND COMMON_LIBRARIES EGL ${OPENGLES_LIBRARIES})
endif()
list(APPEND COMMON_LIBRARIES EGL ${OPENGLES_LIBRARIES})
endif()
#---------------------------------------------------------------------------------------------------

49
CONTRIBUTING.md
View file

@ -43,22 +43,22 @@ This plan is under constant review so expect it to change from time to time. Sti
* Badges highlighting things like favorite games, completed games etc. (will require theme support)
* On-screen keyboard
* Web proxy support for the scraper
* Add GLM library dependency for matrix and vector operations, decommissioning the built-in functions
* Add GLM library dependency for matrix and vector operations, starting to decommission the built-in functions
* Flatpak and Snap releases on Linux
#### v1.3
* Localization/multi-language support
* Overhaul of the theme handling, adding capabilities and improving compatibility with Recalbox and Batocera themes
* Scrapping the Grid view style and adding a general grid/wall component instead
* Checksum support for the scraper for exact searches and for determining when to overwrite files
* Complete overhaul of the grid view style
* A nice and useful grid view implementation in rbsimple-DE
* Improved text and font functions, e.g. faster and cleaner line wrapping
* Flatpak and Snap support on Linux
* Improved text and font functions, e.g. faster and cleaner line wrapping and more exact sizing
#### v1.4
* Authoring tools to clean up orphaned gamelist entries, media files etc.
* Scrollbars for menus and gamelists
* Support for pre-defined alternative emulators and cores (configured in es_systems.xml)
* Simple file browsing component
* Add 'time played' counter per game, similar to how it works in Steam
* Preload all built-in resources and never clear them from the cache
* Improved multi-threading
@ -66,8 +66,7 @@ This plan is under constant review so expect it to change from time to time. Sti
#### v1.5
* Bulk metadata editor
* Overhaul of the GUI element scaling and placement logic to make ES-DE look more consistent across different resolutions
* Scrollbars for menus and gamelists
* Simple file browsing component
* Improve the performance of the GLSL shader code
* Animated menu elements like switches, tick boxes, smooth scrolling etc.
* Support for additional scraper services (if feasible?)
@ -88,37 +87,21 @@ To see which features have been implemented in previous versions, please refer t
### Coding style
The coding style for ES-DE is mostly a combination of the Linux kernel style (although that's C it's close enough to C++ as far as I'm concerned) and Google's C++ guidelines.
The visual appearance aspect of the coding style is automatically applied using clang-format, so to understand the exact formatting rules, refer to the .clang-format file in the root of the repository.
Please refer to these documents here:
Due to this approach, all code changes must be auto-formatted before they are committed. You can read in [INSTALL-DEV.md](INSTALL-DEV.md#using-clang-format-for-automatic-code-formatting) how clang-format is installed and used.
https://www.kernel.org/doc/html/v4.10/process/coding-style.html \
https://google.github.io/styleguide/cppguide.html
But as clang-format won't change the actual code content or fix all code style choices, here are some additional key points:
**Some key points:**
* Column width (line length) is 100 characters
* Indentation is 4 spaces, don't use tabs as they can be interpreted differently
* Line break is Unix-style (line feed only, no carriage return)
* Do not leave trailing whitespaces at the end of the lines (a good source code editor should have a setting to automatically trim these for you)
* When breaking up long lines into multiple lines, consider what could be useful data to grep for so you don't break in the middle of such a string
* Comments always in C++ style, i.e. `//` instead of `/* */`
* Always write comments in C++ style, i.e. `//` instead of `/* */`
* Comments should be proper sentences, starting with a capital letter and ending with a dot
* Use K&R placements of braces, read the Linux kernel coding style document for clarifications
* Always use spaces between keywords and opening brackets, i.e. `if ()`, `for ()`, `while ()` etc.
* Indentation of switch/case statements is optional, but it's usually easier to read the code with indentations in place
* Use `std::string` or `std::vector<char>` instead of `char *` or `char []` unless there is a specific reason requiring the latter
* Actually, try to use C++ syntax in general instead of C syntax, another example would be `static_cast<int>(someFloatVariable)` instead of `(int)someFloatVariable`
* If the arguments (and initializer list) for a function or class exceeds 4 items, arrange them vertically to make the code easier to read
* As a general rule, use C++ syntax instead of C syntax, for example `static_cast<int>(someFloatVariable)` instead of `(int)someFloatVariable`
* Always declare one variable per line, never combine multiple declarations of the same type
* Name local variables with the first word in small letters and the proceeding words starting with capital letters, e.g. `myExampleVariable`
* Name member variables starting with an `m` such as `mMyMemberVariable` and name static variables with an `s` such as `sMyStaticVariable`
* Use the same naming convention for functions as for local variables, e.g. `someFunction()`
* Single-line function definitions are fine to put in the header files, but if it's more than one line, place it in the corresponding .cpp file
* Inline functions makes perfect sense to use, but don't overdo it by using them for functions that won't be called very frequently
* Don't put more than one statement on a single line (there are some exceptions though like lambda expressions and possibly switch statements)
* Name member variables starting with an `m` such as `mMyMemberVariable` and name static variables starting with an `s` such as `sMyStaticVariable`
* Short function definitions can be placed in either the .h or .cpp file depending on the situation
* Avoid overoptimizations, especially if it sacrifices readability, makes the code hard to expand on or is error prone
* For the rest, check the code and have fun! :)
* Try to be coherent with the existing codebase regarding names, structure etc., it should not be obvious what person wrote which parts
* For the rest, check the code and have fun :)
### Building and configuring

4
CREDITS.md
View file

@ -2,7 +2,7 @@
# Programming
Alec "Aloshi" Lofquist (original version) \
Alec Lofquist (original version) \
http://www.aloshi.com
RetroPie Community (RetroPie fork) \
@ -110,6 +110,6 @@ https://freesound.org/people/farpro/sounds/264762
https://freesound.org/people/farpro/sounds/264763/
https://freesound.org/people/newlocknew/sounds/515827 \
(Sample cut slightly.)
(Sample cut slightly)
https://freesound.org/people/ertfelda/sounds/243701/

406
INSTALL-DEV.md
View file

@ -14,20 +14,20 @@ ES-DE is developed and compiled using Clang/LLVM and GCC on Unix, Clang/LLVM on
CMake is the build system for all the supported operating systems, used in conjunction with `make` on Unix and macOS and `nmake` and `make` on Windows. Xcode on macOS or Visual Studio on Windows are not required for building ES-DE and they have not been used during the development. The only exception is notarization of codesigned macOS packages which require the `altool` and `stapler` binaries that come bundled with Xcode.
For automatic code formatting [clang-format](https://clang.llvm.org/docs/ClangFormat.html) is used.
Any code editor can be used of course, but I recommend [VSCode](https://code.visualstudio.com).
## Building on Unix
The code has some dependencies. For building, you'll need CMake and development packages for cURL, FFmpeg, FreeImage, FreeType, pugixml, SDL2 and RapidJSON (and optionally VLC).
There are some dependencies that need to be fulfilled in order to build ES-DE. These are detailed per operating system below.
**Installing dependencies:**
**On Debian/Ubuntu**
**Debian/Ubuntu**
All of the required packages can be installed with apt-get:
```
sudo apt-get install build-essential git cmake libsdl2-dev libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev libfreeimage-dev libfreetype6-dev libcurl4-openssl-dev libpugixml-dev rapidjson-dev libasound2-dev libgl1-mesa-dev
sudo apt-get install build-essential clang-format git cmake libsdl2-dev libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev libfreeimage-dev libfreetype6-dev libcurl4-openssl-dev libpugixml-dev rapidjson-dev libasound2-dev libgl1-mesa-dev
```
If building with the optional VLC video player, the following packages are also needed:
@ -35,28 +35,28 @@ If building with the optional VLC video player, the following packages are also
sudo apt-get install vlc libvlc-dev
```
**On Fedora**
**Fedora**
Use dnf to install all the required packages:
```
sudo dnf install gcc-c++ cmake SDL2-devel ffmpeg-devel freeimage-devel freetype-devel curl-devel pugixml-devel rapidjson-devel alsa-lib-devel mesa-libGL-devel
sudo dnf install gcc-c++ clang-tools-extra cmake SDL2-devel ffmpeg-devel freeimage-devel freetype-devel curl-devel pugixml-devel rapidjson-devel alsa-lib-devel mesa-libGL-devel
```
If building with the VLC video player, add the RPM Fusion repository.
Go to [https://rpmfusion.org/Configuration](https://rpmfusion.org/Configuration) and download the .rpm package for the free repository, then install it as well as VLC:
Go to [https://rpmfusion.org/Configuration](https://rpmfusion.org/Configuration) and download the .rpm package for the free repository. Then install it, followed by VLC:
```
sudo dnf install ./rpmfusion-free-release-33.noarch.rpm
sudo dnf install vlc vlc-devel
```
**On Manjaro**
**Manjaro**
Use pacman to install all the required packages:
```
sudo pacman -S gcc make cmake pkgconf sdl2 ffmpeg freeimage freetype2 pugixml rapidjson
sudo pacman -S gcc clang make cmake pkgconf sdl2 ffmpeg freeimage freetype2 pugixml rapidjson
```
If building with the optional VLC video player, the following package is also needed:
@ -64,7 +64,26 @@ If building with the optional VLC video player, the following package is also ne
sudo pacman -S vlc
```
**On FreeBSD**
**Raspberry Pi OS (Raspian)**
Note: The Raspberry Pi 4 is the minimum recommended model to use with ES-DE. As this type of device is quite weak and because the FFmpeg video player does not support hardware decoding on this platform, it's strongly adviced to build with the VLC player, which is hardware accelerated.
All of the required packages can be installed with apt-get:
```
sudo apt-get install clang-format cmake libsdl2-dev libavcodec-dev libavfilter-dev libavformat-dev libavutil-dev libfreeimage-dev libcurl4-gnutls-dev libpugixml-dev rapidjson-dev
```
If building with the optional VLC video player, the following packages are also needed:
```
sudo apt-get install vlc libvlc-dev
```
To build with CEC support you also need to install these packages:
```
sudo apt-get install libcec-dev libp8-platform-dev
```
**FreeBSD**
Use pkg to install the dependencies:
```
@ -76,13 +95,13 @@ If building with the optional VLC video player, the following package is also ne
pkg install vlc
```
Clang/LLVM and cURL should already be installed in the base OS image.
Clang/LLVM and cURL should already be included in the base OS installation.
**On NetBSD**
**NetBSD**
Use pkgin to install the dependencies:
```
pkgin install git cmake pkgconf SDL2 ffmpeg4 freeimage pugixml rapidjson
pkgin install clang git cmake pkgconf SDL2 ffmpeg4 freeimage pugixml rapidjson
```
If building with the optional VLC video player, the following package is also needed:
@ -90,13 +109,13 @@ If building with the optional VLC video player, the following package is also ne
pkgin vlc
```
NetBSD ships with GCC by default, and although you should be able to install and use Clang/LLVM, it's probably easier to just stick to the default compiler environment.
NetBSD ships with GCC by default, and although you should be able to use Clang/LLVM, it's probably easier to just stick to the default compiler environment. The reason why the clang package needs to be installed is to get clang-format onto the system.
**On OpenBSD**
**OpenBSD**
Use pkg_add to install the dependencies:
```
pkg_add cmake pkgconf sdl2 ffmpeg freeimage
pkg_add clang-tools-extra cmake pkgconf sdl2 ffmpeg freeimage
```
If building with the optional VLC video player, the following package is also needed:
@ -143,7 +162,7 @@ cmake .
make
```
By default the master branch will be used, which is where the development takes place. To instead build the latest stable release, switch to the `stable` branch:
By default the master branch will be used, which is where development takes place. To instead build the latest stable release, switch to the `stable` branch:
```
cd emulationstation-de
@ -207,22 +226,29 @@ scan-build cmake -DCMAKE_BUILD_TYPE=Debug .
scan-build make -j6
```
You open the report with the `scan-view` command which lets you browse it using your web browser. Note that the compilation time is much higher when using the static analyzer compared to a normal compilation. As well this tool generates a lot of extra files and folders in the build tree, so it may make sense to run it in a separate copy of the source folder to avoid having to clean up all this extra data when the analysis has been completed.
You open the report with the `scan-view` command which lets you read it using your web browser. Note that the compilation time is much longer when using the static analyzer compared to a normal build. As well this tool generates a lot of extra files and folders in the build tree, so it may make sense to run it in a separate copy of the source folder to avoid having to clean up all this extra data when the analysis has been completed.
An even more advanced static analyzer is `clang-tidy`, to use it first make sure it's installed on your system and then run the following:
```
cmake -DCLANG_TIDY=on .
```
Even though many irrelevant checks are filtered out via the configuration, this will still likely produce a quite huge report (at least until most of the recommendations have been implemented). In the same manner as for scan-view, the compilation time is much longer when using this static analyzer compared to a normal build.
To build ES-DE with CEC support, enable the corresponding option, for example:
```
cmake -DCMAKE_BUILD_TYPE=Debug -DCEC=on .
cmake -DCEC=on .
make
```
I have however not been able to test the CEC support and I'm not entirely sure how it's supposed to work.
You will most likely need to install additional packages to get this to build. On Debian-based systems these are _libcec-dev_ and _libp8-platform-dev_. Note that the CEC support is currently untested.
To build with the GLES renderer, run the following:
```
cmake -DCMAKE_BUILD_TYPE=Debug -DGLES=on .
cmake -DGLES=on .
make
```
Note that the GLES renderer is quite limited as there is no shader support for it, so ES-DE will definitely not look as pretty as when using the default OpenGL renderer.
The GLES renderer is quite limited as there is no shader support for it, so ES-DE will definitely not look as pretty as when using the default OpenGL renderer. When building on a Raspberry Pi, the GLES renderer will be automatically selected.
Running multiple compile jobs in parallel is a good thing as it speeds up the build time a lot (scaling almost linearly). Here's an example telling make to run 6 parallel jobs:
@ -238,7 +264,7 @@ The following example will build the application for installtion under /opt:
cmake -DCMAKE_INSTALL_PREFIX=/opt .
```
It's important to know that this is not only the directory used by the install script, the CMAKE_INSTALL_PREFIX variable also modifies code inside ES-DE used to locate the required program resources. So it's necessary that the install prefix corresponds to the location where the application will actually be installed.
It's important to understand that this is not only the directory used by the install script, the CMAKE_INSTALL_PREFIX variable also modifies code inside ES-DE used to locate the required program resources. So it's necessary that the install prefix corresponds to the location where the application will actually be installed.
On Linux, if you're not building a package and instead intend to install using `make install` it's recommended to set the installation prefix to /usr/local instead of /usr.
@ -246,26 +272,24 @@ On Linux, if you're not building a package and instead intend to install using `
Both Clang/LLVM and GCC work fine for building ES-DE.
I did some small benchmarks comparing Clang to GCC with the ES-DE codebase (as of writing it's year 2020) and it's pretty interesting.
I did some small benchmarks comparing Clang 10.0 to GCC 9.3.0 with the ES-DE v1.1 codebase on an Intel Xeon W-2245 @ 3.90GHz running Kubuntu 20.04.2 LTS and it's pretty interesting.
Advantages with Clang (vs GCC):
* 10% smaller binary size for a release build
* 17% smaller binary size for a debug build
* 2% faster compile time for a release build
* 16% faster compile time for a debug build
* 8% smaller binary size for a release build
* 31% smaller binary size for a debug build
* 16% faster compile time for a release build
* 25% faster compile time for a debug build
* 13% faster application startup time for a release build
* 4% faster application startup time for a debug build
Advantage with GCC (vs Clang):
* 1% faster application startup time for a release build
*Release build: Optimizations enabled, debug info disabled, binary stripped.* \
*Debug build: Optimizations disabled, debug info enabled, binary not stripped.*
This Clang debug build is LLVM "native", i.e. intended to be debugged using the LLVM project debugger LLDB. The problem is that this is still not well integrated with VSCode that I use for development so I need to keep using GDB. But this is problematic as the libstd++ data required by GDB is missing in the binary, making it impossible to see the values of for instance std::string variables.
It's possible to activate the additional debug info needed by GDB by using the flag `-D_GLIBCXX_DEBUG`. I've added this to CMakeLists.txt when using Clang, but this bloats the binary and makes the code much slower. Actually, instead of a 4% faster application startup, it's now 36% slower! The same goes for the binary size, instead of 17% smaller it's now 17% larger.
It's possible to activate the additional debug info needed by GDB by using the flag `-D_GLIBCXX_DEBUG`. I've added this to CMakeLists.txt when using Clang, but this bloats the binary and makes the code much slower. Actually, instead of a 4% faster application startup, it's now 25% slower. The same goes for the binary size, instead of 31% smaller it's now 5% larger. The compilation time is still less than GCC but only by 10% instead of 25%.
I'm expecting this to be resolved in the near future though, and as I think Clang is an interesting compiler, I use it as the default when working on the project (I sometimes test with GCC to make sure that it still builds the software correctly).
But I'm expecting this issue to be resolved in the future so the workaround can be removed.
It's by the way very easy to switch between LLVM and GCC using Ubuntu, just use the `update-alternatives` command:
@ -311,7 +335,7 @@ However, when installing manually instead of building a package, it's recommende
Be aware that if using the GNOME desktop environment, /usr/share/pixmaps/emulationstation.svg must exist in order for the ES-DE icon to be shown in the Dash and task switcher.
ES-DE will look in the following locations for the resources, in the listed order:
ES-DE will look in the following locations for application resources, in the listed order:
* \<home\>/.emulationstation/resources/
* \<install prefix\>/share/emulationstation/resources/
@ -319,7 +343,7 @@ ES-DE will look in the following locations for the resources, in the listed orde
The resources directory is critical, without it the application won't start.
And it will look in the following locations for the themes, also in the listed order:
As well the following locations will be searched for themes, also in the listed order:
* \<home\>/.emulationstation/themes/
* \<install prefix\>/share/emulationstation/themes/
@ -327,7 +351,7 @@ And it will look in the following locations for the themes, also in the listed o
A theme is not mandatory to start the application, but ES-DE will be basically useless without it.
The home directory will always take precedence, and any resources or themes located there will override the ones in the installation path or in the path of the ES-DE executable.
As indicated above, the home directory will always take precedence and any resources or themes located there will override the ones in the installation path, or in the path of the ES-DE executable.
**Creating .deb and .rpm packages**
@ -344,7 +368,7 @@ CPackDeb: - Generating dependency list
CPack: - package: /home/myusername/emulationstation-de/emulationstation-de-1.1.0-x64.deb generated.
```
You may like to check that the dependencies look fine, as they're automatically generated by CMake:
You may want to check that the dependencies look fine, as they're (mostly) automatically generated by CMake:
```
dpkg -I ./emulationstation-de-1.1.0-x64.deb
@ -375,17 +399,17 @@ CPackRPM: Will use GENERATED spec file: /home/myusername/emulationstation-de/_CP
CPack: - package: /home/myusername/emulationstation-de/emulationstation-de-1.1.0-x64.rpm generated.
```
On Fedora, you need to install rpmbuild before this command can be run though:
On Fedora, you need to install rpmbuild before this command can be run:
```
sudo dnf install rpm-build
```
After the package generation you can check that the metadata looks fine using this command:
After the package generation you can check that the metadata looks fine using the `rpm` command:
```
rpm -qi ./emulationstation-de-1.1.0-x64.rpm
```
And to see the automatically generated dependency requirements, run this:
To see the automatically generated dependencies, run this:
```
rpm -q --requires ./emulationstation-de-1.1.0-x64.rpm
```
@ -405,7 +429,7 @@ As for code editing, I use [VSCode](https://code.visualstudio.com). I suppose Xc
Install the Command Line Tools which include Clang/LLVM, Git, make etc. Simply open a terminal and enter the command `clang`. This will open a dialog that will let you download and install the tools.
Following this, install the Homebrew package manager which will simplify the rest of the installation greatly. Install it by runing the following in a terminal window:
Following this, install the Homebrew package manager which will greatly simplify the rest of the installation. Install it by runing the following in a terminal window:
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
```
@ -416,7 +440,7 @@ Be aware that Homebrew can be really slow, especially when it compiles packages
Install the required tools and dependencies:
```
brew install cmake pkg-config nasm fdk-aac libvpx sdl2 freeimage freetype pugixml rapidjson
brew install clang-format cmake pkg-config nasm fdk-aac libvpx sdl2 freeimage freetype pugixml rapidjson
```
If building with the optional VLC video player, then run this as well:
@ -427,7 +451,7 @@ brew install --cask vlc
**Compiling FFmpeg:**
The FFmpeg build distributed via Homebrew has a lot of dependencies we don't need, and which would make it very difficult to package it in an installer. Instead we will build this software with only some limited options:
The FFmpeg build distributed via Homebrew has a lot of dependencies we don't need, and which would make it very difficult to package the application. Instead we will build this software with only some limited options:
```
git clone https://github.com/FFmpeg/FFmpeg.git
@ -444,7 +468,7 @@ Enable developer mode to avoid annoying password requests when attaching the deb
```
sudo /usr/sbin/DevToolsSecurity --enable
```
It makes me wonder who designed this functionality and what was their thinking, but a simple command is enough to not having to ponder this any further.
It makes me wonder who designed this functionality and what was their thinking, I've never seen anything like this on any of the other systems I've been developing on.
If required, define SDKROOT. This is only needed if during compilation you get error messages regarding missing include files. Running the following will properly setup the development environment paths:
```
@ -478,36 +502,35 @@ cmake .
make
```
To build ES-DE with the VLC video player in addition to the default FFmpeg player, enable the VLC_PLAYER option, for example:
To build ES-DE with the VLC video player in addition to the default FFmpeg player, enable the VLC_PLAYER option:
```
cmake -DVLC_PLAYER=on .
make
```
To generate a debug build, run this instead:
To generate a debug build, run this:
```
cmake -DCMAKE_BUILD_TYPE=Debug .
make
```
Keep in mind though that a debug version will be much slower due to all compiler optimizations being disabled.
Keep in mind that the debug version will be much slower due to all compiler optimizations being disabled.
Running `make -j6` (or whatever number of parallel jobs you prefer) speeds up the compilation time if you have cores to spare.
After building ES-DE and trying to execute the application, there could be issues with finding the dynamic link libraries for VLC (assuming VLC is actually enabled for the build) as these are not installed into a standard location but rather into the /Applications folder. As such, you may need to set the DYLD_LIBRARY_PATH environmental variable to find the VLC libraries. Note that this is not intended or required for the release build that will be shipped in a DMG installer or if you manually install ES-DE using 'make install'. It's only needed to be able to run the binary from the build directory. The following will of course only be active during your session, and you need to set the variable for each terminal window that you want to start ES-DE from, unless you add it to your shell profile file:
After building ES-DE and trying to execute the application, there could be issues with finding the dynamic link libraries for VLC (assuming VLC was enabled for the build) as these are not installed into a standard location but rather into the /Applications folder. As such, you may need to set the DYLD_LIBRARY_PATH environmental variable to find the VLC libraries. Note that this is not intended or required for the release build that will be shipped in a DMG installer or if you manually install ES-DE using _make install_. It's only needed to be able to run the binary from the build directory. You should add this to your shell profile file to avoid having to set it each time you open a new terminal window:
```
export DYLD_LIBRARY_PATH=/Applications/VLC.app/Contents/MacOS/lib
```
**Note:** Running ES-DE from the build directory may be a bit flaky as there is no Info.plist file available which is required for setting the proper window mode and such. It's therefore recommended to run the application from the installation directory for any more in-depth testing. But normal debugging can of course be done from the build directory.
Running ES-DE from the build directory may be a bit flaky as there is no Info.plist file available which is required for setting the proper window mode and such. It's therefore recommended to run the application from the installation directory for any more in-depth testing. But normal debugging can of course be done from the build directory.
Be aware that the approach taken for macOS has the limitation that you can't build for previous operating system versions. You can certainly set CMAKE_OSX_DEPLOYMENT_TARGET to whatever version you like, but the problem is that the Homebrew libraries will most likely not work on earlier macOS versions. In theory this can be worked around by building all these libraries yourself with a lower deployment target, but it's hardly worth the effort. It's better to build on the lowest OS version that should be supported and rely on forward compatibility.
**Code signing:**
Due to the Apple notarization requirement implemented as of macOS 10.14.5 a build with simple code signing is needed for versions up to 10.13 and another build with both code signing and notarization will be required for versions 10.14 and higher.
Due to the Apple notarization requirement implemented as of macOS 10.14.5 a build with simple code signing is needed for versions up to 10.13 and another build with both code signing and notarization is required for version 10.14 and higher.
macOS code signing is beyond the scope of this document, but the option MACOS_CODESIGN_IDENTITY is used to to specify the code signing certificate identity, for example:
macOS code signing is beyond the scope of this document, but the option MACOS_CODESIGN_IDENTITY is used to specify the code signing certificate identity, for example:
```
cmake -DMACOS_CODESIGN_IDENTITY="My Name" .
```
@ -516,12 +539,14 @@ Assuming the code signing ceritificate is properly setup in Keychain Access, the
**Legacy build:**
Normally ES-DE is meant to be built for macOS 10.14 and higher, but a legacy build for earlier operating system versions can be enabled. This has been tested with a minimum version of 10.11 and it's unclear if it works with even older macOS versions.
Normally ES-DE is meant to be built for macOS 10.14 and higher, but a legacy build for earlier operating system versions can be enabled. This has been tested with a minimum version of 10.11. It's unclear if it works with even older macOS versions.
To enable a legacy build, change the CMAKE_OSX_DEPLOYMENT_TARGET variable in CMakeLists.txt from 10.14 to whatever version you would like to build for. This will disable Hardened Runtime if signing is enabled and it will add 'legacy' to the DMG installer file name when running CPack.
You also need to modify es-app/assets/EmulationStation-DE_Info.plist and set the key SMinimumSystemVersion to the version you're building for.
Due to issues with getting FFmpeg to compile on some older macOS versions, ES-DE v1.0.1 is the last version where a legacy build has been tested.
**Installing:**
As macOS does not have any package manager which would have handled the library dependencies, we need to bundle the required shared libraries with the application. Copy the following .dylib files from their respective installation directories to the emulationstation-de build directory:
@ -547,12 +572,12 @@ All except the VLC libraries should be located in /usr/local/lib. The VLC librar
Note that the filenames could be slightly different depending on what versions you have installed on your system.
After copying the libraries to the build directory, set the permissions to writable:
After copying the libraries to the build directory, set their permissions like this:
```
chmod 755 ./*.dylib
```
There are some secondary internal dependencies between some of these library files, and these are baked into the files as absolut paths. As such we need to rewrite these to rpaths (relative paths) which is done using the install_name_tool command.
There are some secondary internal dependencies between some of these library files, and these are baked into the files as absolute paths. As such we need to rewrite these to rpaths (relative paths) which is done using the install_name_tool command.
A script is available to automate this: `tools/macOS_change_dylib_rpaths.sh`
@ -636,23 +661,23 @@ This will be the directory structure for the installation (the VLC-related files
/Applications/EmulationStation Desktop Edition.app/Contents/Resources/themes/*
```
ES will look in the following locations for the resources, in the listed order:
ES-DE will look in the following locations for application resources, in the listed order:
* \<home\>/.emulationstation/resources/
* \<ES-DE executable directory\>/../Resources/resources/
* \<ES-DE executable directory\>/resources/
**Note:** The resources directory is critical, without it the application won't start.
The resources directory is critical, without it the application won't start.
And it will look in the following locations for the themes, also in the listed order:
As well the following locations will be searched for themes, also in the listed order:
* \<HOME\>/.emulationstation/themes/
* \<ES-DE executable directory\>/../Resources/themes/
* \<ES-DE executable directory\>/themes/
A theme is not mandatory to start the application, but ES will be basically useless without it.
A theme is not mandatory to start the application, but ES-DE will be basically useless without it.
The home directory will always take precedence, and any resources or themes located there will override the ones in the installation path or in the path of the ES-DE executable.
As indicated above, the home directory will always take precedence and any resources or themes located there will override the ones in the path of the ES-DE executable.
**Creating a .dmg installer:**
@ -668,7 +693,7 @@ CPack: Create package
CPack: - package: /Users/myusername/emulationstation-de/EmulationStation-DE-1.1.0-x64.dmg generated.
```
Generating .dmg installers on older version of macOS seems to make them forward compatible to a pretty good extent, for instance building on El Capitan seems to generate an application that is usable on Catalina and Big Sur. The other way around does however not seem to be true, which is quite unsurprising.
Generating .dmg installers on older version of macOS seems to make them forward compatible to a pretty good extent, for instance building on El Capitan seems to generate an application that is usable on Catalina and Big Sur. The other way around is not true due to the use of dependencies from the Homebrew repository.
**Special considerations regarding run-paths:**
@ -701,29 +726,12 @@ This is what an incorrect line would look like:
`/usr/local/opt/sdl2/lib/libSDL2-2.0.0.dylib (compatibility version 13.0.0, current version 13.0.0)`
This is the section in es-app/CMakeLists.txt that would need to be modified:
```
add_custom_command(TARGET EmulationStation POST_BUILD COMMAND ${CMAKE_INSTALL_NAME_TOOL}
-change /usr/local/lib/libavcodec.58.dylib @rpath/libavcodec.58.dylib
-change /usr/local/lib/libavfilter.7.dylib @rpath/libavfilter.7.dylib
-change /usr/local/lib/libavformat.58.dylib @rpath/libavformat.58.dylib
-change /usr/local/lib/libavutil.56.dylib @rpath/libavutil.56.dylib
-change /usr/local/lib/libswresample.3.dylib @rpath/libswresample.3.dylib
-change /usr/local/lib/libswscale.5.dylib @rpath/libswscale.5.dylib
-change /usr/local/opt/freeimage/lib/libfreeimage.dylib @rpath/libfreeimage.dylib
-change /usr/local/opt/freetype/lib/libfreetype.6.dylib @rpath/libfreetype.6.dylib
-change /usr/local/opt/libpng/lib/libpng16.16.dylib @rpath/libpng16.16.dylib
-change /usr/local/opt/sdl2/lib/libSDL2-2.0.0.dylib @rpath/libSDL2-2.0.0.dylib
$<TARGET_FILE:EmulationStation>)
```
## Building on Windows
Both MSVC and MinGW (GCC) work fine for building ES-DE on Windows.
Although I would prefer to exclude support for MSVC, this proprietary compiler simply works much better when developing as it's much faster than MinGW when linking debug builds and when actually debugging. For release builds though MinGW is very fast and it seems as if ES-DE starts around 18% faster when built with MinGW so this compiler probably generates more efficient code overall. As well MSVC requires a lot more junk DLL files to be distributed with the application so it's not a good candidate for the final release build.
Although I would prefer to exclude support for MSVC, this compiler simply works much better when developing as it's much faster than MinGW when linking debug builds and when actually debugging. But for release builds MinGW is very fast and ES-DE starts around 18% faster when built with MinGW meaning this compiler probably generates more efficient code overall. As well MSVC requires a lot more junk DLL files to be distributed with the application so it's not a good candidate for the final release build.
For this reason I think MSVC makes sense for development and MinGW for the releases.
@ -746,7 +754,7 @@ Just-In-Time debugger
C++ CMake tools for Windows
```
If you intend to use both MinGW and MSVC on the machine, it's probably better to exclude CMake and install it manually as described in the MinGW setup instructions below.
If you intend to use both MinGW and MSVC on the same machine, it's probably better to exclude CMake and install it manually as described in the MinGW setup instructions below.
The way the MSVC environment works is that a specific developer shell is provided where the build environment is properly configured. You open this from the Start menu via `Visual Studio 2019` -> `Visual Studio tools` -> `VC` -> `x64 Native Tools Command Prompt for VS 2019`.
@ -762,30 +770,35 @@ Download the following packages and install them:
[https://jmeubank.github.io/tdm-gcc](https://jmeubank.github.io/tdm-gcc)
After installation, make a copy of `TDM-GCC-64/bin/mingw32-make` to `make` just for convenience.
After installation, make a copy of `TDM-GCC-64\bin\mingw32-make` to `make` just for convenience.
Note that most GDB builds for Windows have broken Python support so that pretty printing won't work. The recommended MinGW installation should work fine though.
Note that most GDB builds for Windows have broken Python support so that pretty printing won't work. The recommended MinGW distribution should work fine though.
**Other preparations:**
In order to get clang-format onto the system you need to download and install Clang: \
[https://llvm.org/builds](https://llvm.org/builds)
Just run the installer and make sure to select the option _Add LLVM to the system PATH for current user_.
Install your editor of choice, I use [VSCode](https://code.visualstudio.com).
Configure Git. I won't get into the details on how it's done, but there are many resources available online to support with this. The `Git Bash` shell shipped with Git for Windows is very useful though as it's somewhat reproducing a Unix environment using MinGW/MSYS2.
Configure Git. I won't get into the details on how this is done, but there are many resources available online to support with this. The `Git Bash` shell shipped with Git for Windows is very useful though as it's somewhat reproducing a Unix environment using MinGW/MSYS2.
It's strongly recommended to set line breaks to Unix-style (line feed only) directly in the editor, although it can also be configured in Git for conversion during commits. The source code for ES-DE only uses Unix-style line breaks.
It's strongly recommended to set line breaks to Unix-style (line feed only) directly in the editor. But if not done, lines breaks will anyway be converted when running clang-format on the code, as explained [here](INSTALL-DEV.md#using-clang-format-for-automatic-code-formatting).
In the description below it's assumed that all build steps for MinGW/GCC will be done in the Git Bash shell, and all the build steps for MSVC will be done in the MSVC developer console (x64 Native Tools Command Prompt for VS).
In the descriptions below it's assumed that all build steps for MinGW/GCC will be done in the Git Bash shell, and all the build steps for MSVC will be done in the MSVC developer console (x64 Native Tools Command Prompt for VS).
**Download the dependency packages:**
FFmpeg (choose a package with win64-gpl-shared in the filename, the latest snapshot build should generally be fine to use) \
FFmpeg (choose the n4.4 package with win64-gpl-shared in the filename, the snapshot version will not work) \
[https://github.com/BtbN/FFmpeg-Builds/releases](https://github.com/BtbN/FFmpeg-Builds/releases)
FreeImage (binary distribution) \
[https://sourceforge.net/projects/freeimage](https://sourceforge.net/projects/freeimage)
cURL (Windows 64 bit binary, the MinGW version even if using MSVC) \
cURL (Windows 64 bit binary, select the MinGW version even if using MSVC) \
[https://curl.haxx.se/download.html](https://curl.haxx.se/download.html)
SDL2 (development libraries, MinGW or VC/MSVC) \
@ -859,7 +872,7 @@ make
[RapidJSON](http://rapidjson.org)
For RapidJSON, you don't need to compile it, you just need the include files:
For RapidJSON you don't need to compile, you just need the include files:
```
git clone git://github.com/Tencent/rapidjson.git
@ -877,7 +890,7 @@ This works the same as on Unix or macOS, just run the following:
git clone https://gitlab.com/leonstyhre/emulationstation-de.git
```
By default the master branch will be used, which is where the development takes place. To instead build the latest stable release, switch to the `stable` branch:
By default the master branch will be used, which is where development takes place. To instead build the latest stable release, switch to the `stable` branch:
```
cd emulationstation-de
@ -896,7 +909,7 @@ You may need to create the SDL2 directory manually and copy the header files the
For FFmpeg, copy the directories libavcodec, libavfilter, libavformat and libavutil.
It should then look something like this:
It should look something like this:
```
$ ls -1 include/
@ -924,18 +937,18 @@ Copy the files to the `emulationstation-de` build directory. Most of them will c
**Required files for MSVC:**
```
avcodec-59.dll
avcodec-58.dll
avcodec.lib
avfilter.lib
avfilter-8.dll
avformat-59.dll
avfilter-7.dll
avformat-58.dll
avformat.lib
avutil-57.dll
avutil-56.dll
avutil.lib
postproc-56.dll
swresample-4.dll
postproc-55.dll
swresample-3.dll
swresample.lib
swscale-6.dll
swscale-5.dll
swscale.lib
FreeImage.dll
FreeImage.lib
@ -982,13 +995,13 @@ lib /def:libvlc.def /out:libvlc.lib /machine:x64
**Required files for MinGW:**
```
avcodec-59.dll
avfilter-8.dll
avformat-59.dll
avutil-57.dll
postproc-56.dll
swresample-4.dll
swscale-6.dll
avcodec-58.dll
avfilter-7.dll
avformat-58.dll
avutil-56.dll
postproc-55.dll
swresample-3.dll
swscale-5.dll
FreeImage.dll
glew32.dll
libcrypto-1_1-x64.dll (from the OpenSSL package, located in Git MinGW/MSYS2 under \mingw64\bin)
@ -1005,11 +1018,9 @@ vcomp140.dll (From Visual C++ Redistributable for Visual Studio 201
**Additional files for both MSVC and MinGW if building with the VLC video player:**
In addition to the files above, you need to copy some libraries from the VLC `plugins` folder to be able to play video files. There is a subdirectory structure under the plugins folder but there is no requirement to retain this as libVLC apparently looks recursively for the .dll files.
In addition to the files above, you need to copy some libraries from the VLC `plugins` folder. This contains a subdirectory structure but there is no requirement to retain this as libVLC apparently looks recursively for the .dll files.
It's a bit tricky to know which libraries are really needed. But as the plugins directory is around 120 MB (as of VLC version 3.0.11), we definitely only want to copy the files we need.
The following files seem to be required to play most video and audio formats (place them in `emulationstation-de\plugins`):
The following libraries seem to be required to play most video and audio formats:
```
access\libfilesystem_plugin.dll
@ -1029,7 +1040,9 @@ video_chroma\libswscale_plugin.dll
video_output\libvmem_plugin.dll
```
The combined size of these files is around 22 MB which is more reasonable.
The reason to not simply copy all plugins is that the combined size of these is around 120 MB (as of VLC version 3.0.11) and the size of the selected files listed above is around 22 MB, which is more reasonable.
Place the files in the `emulationstation-de\plugins\` directory.
**Building ES-DE using MSVC:**
@ -1097,7 +1110,7 @@ Note that compilation time is much longer than on Unix or macOS, and linking tim
If you are running Windows in a virtualized environment such as QEMU-KVM that does not support HW accelerated OpenGL, you can install the Mesa3D for Windows library, which can be downloaded at [https://fdossena.com/?p=mesa/index.frag](https://fdossena.com/?p=mesa/index.frag).
You simply extract the opengl32.dll file into the ES-DE directory and this will enable the llvmpipe renderer. The performance will be terrible of course, but everything should work and it should be good enough for test building on Windows without having to reboot your computer to a native Windows installation. (Note that you may need to copy opengl32.dll to your RetroArch installation directory as well to get the emulators to work correctly.)
You simply extract the opengl32.dll file into the ES-DE directory and this will enable the llvmpipe renderer. The performance will be terrible of course, but everything should work and it should be good enough for test building on Windows without having to reboot your computer to a native Windows installation. (Note that you may need to copy opengl32.dll to your RetroArch installation directory as well to get the emulators to work somehow correctly.)
Obviously this library is only intended for development and will not be shipped with ES-DE.
@ -1123,23 +1136,98 @@ CPack: - package: C:/Programming/emulationstation-de/EmulationStation-DE-1.1.0-x
The default installation directory suggested by the installer is `C:\Program Files\EmulationStation-DE` but this can of course be changed by the user.
ES will look in the following locations for the resources, in the listed order:
ES-DE will look in the following locations for application resources, in the listed order:
* \<home\>\\.emulationstation\resources\
* \<ES-DE executable directory\>\resources\
The resources directory is critical, without it the application won't start.
And it will look in the following locations for the themes, also in the listed order:
As well the following locations will be searched for themes, also in the listed order:
* \<home\>\\.emulationstation\themes\
* \<ES-DE executable directory\>\themes\
The theme is not mandatory to start the application, but ES-DE will be basically useless without it.
A theme is not mandatory to start the application, but ES-DE will be basically useless without it.
So the home directory will always take precedence, and any resources or themes located there will override the ones in the path of the ES-DE executable.
As indicated above, the home directory will always take precedence and any resources or themes located there will override the ones in the path of the ES-DE executable.
## Using clang-format for automatic code formatting
The entire ES-DE codebase is formatted using clang-format and all new code must be formatted using this tool before being committed.
There is a style configuration file named .clang-format located directly at the root of the repository which contains the formatting rules. How to install clang-format is detailed per operating system earlier in this document.
There are two ways to run the tool, from the command line or from inside an editor such as VSCode.
To format a file from the command line, simply run:
```clang-format -i <source file>```
The -i flag will make an inplace edit of the file.
But the recommended approach is to run clang-format from within the editor. If using VSCode, there is an extension available named Clang-Format. After installing this, simply open a source file, right click and choose `Format Document` or use the applicable keyboard shortcut. The first time you do this, you will have to make a choice to perform the formatting using clang-format. The rest should be completely automatic.
In some instances you may want to avoid getting code formatted, and you can accomplish this by simply enclosing the lines with the two comments "clang-format off" and "clang-format on", such as this:
```c++
// clang-format off
CollectionSystemDecl systemDecls[] = {
// Type Name Long name Theme folder isCustom
{ AUTO_ALL_GAMES, "all", "all games", "auto-allgames", false },
{ AUTO_LAST_PLAYED, "recent", "last played", "auto-lastplayed", false },
{ AUTO_FAVORITES, "favorites", "favorites", "auto-favorites", false },
{ CUSTOM_COLLECTION, myCollectionsName, "collections", "custom-collections", true }
};
// clang-format on
```
Adding a comment on its own line will also prevent some formatting such as turning short functions and lambda expressions into single lines. For this function such a comment has been added:
```c++
const std::string FileData::get3DBoxPath() const
{
// Return path to the 3D box image.
return getMediafilePath("3dboxes", "3dbox");
}
```
If the comment was omitted, the function would get formatted like this:
```c++
const std::string FileData::get3DBoxPath() const { return getMediafilePath("3dboxes", "3dbox"); }
```
Adding comments (even empty ones) can also force line breaks to avoid ugly formatting such as this:
```c++
for (auto it = mCursorStackHistory.begin(); it != mCursorStackHistory.end();
it++) {
if (std::find(listEntries.begin(), listEntries.end(), *it) !=
listEntries.end()) {
newCursor = *it;
mCursorStackHistory.erase(it);
break;
}
}
```
A comment at the right place produces this much nicer formatting:
```c++
for (auto it = mCursorStackHistory.begin(); // Line break.
it != mCursorStackHistory.end(); it++) {
if (std::find(listEntries.begin(), listEntries.end(), *it) !=
listEntries.end()) {
newCursor = *it;
mCursorStackHistory.erase(it);
break;
}
}
```
Of course you would like to get the code formatted according to the clang-format rules in most instances, these workaround are only meant for rare exceptions. Some compromises are necessary when auto-formatting code, at least with clang-format in its current state.
## CA certificates and MAME ROM information
**CA certificates:**
@ -1158,9 +1246,9 @@ emulationstation-de/resources/certificates/curl-ca-bundle.crt
**MAME ROM info:**
This is a bit tricky as the data needs to be converted to an internal format used by ES-DE. The original file is huge and most of the information is not required.
ES-DE automatically identifies and excludes MAME BIOS and device files, as well as translating the short MAME ROM names to their full game names. This is done using information from the MAME driver file shipped with the official MAME distribution. The file needs to be converted to an internal format used by ES-DE as the original file is huge and most of the information is not required.
Go to [https://www.mamedev.org/release.php](https://www.mamedev.org/release.php) and select the Windows version, but only download the driver information in XML format and not MAME itself. This file will be named something like `mame0226lx.zip` and unzipping it will give you a file name such as `mame0226.xml`.
To get hold of the driver file, go to [https://www.mamedev.org/release.php](https://www.mamedev.org/release.php) and select the Windows version, but only download the driver information in XML format and not MAME itself. This file will be named something like `mame0226lx.zip` and unzipping it will give you a file name such as `mame0226.xml`.
Move the XML driver file to the resources/MAME directory and then convert it to the ES-DE internal files:
@ -1197,14 +1285,14 @@ git diff mamebioses
git diff mamedevices
```
The reason to not simply replace the BIOS and devices files with the new version is that we want to retain entries from all older MAME versions as otherwise older ROM sets used on older MAME versions would have missing information. This is so as the MAME project sometimes removes older entries when they're reorganizing the ROM sets. By merging the files we retain backwards compatibility but still support the latest MAME version. To clarify, this of course does not affect the emulation itself, but rather the filtering of BIOS and device files inside ES-DE. The mamenames.xml file containing the translation of MAME ROM names to the full game names does not suffer from this problem as it's cumulative, which is why it is simply overwritten.
The reason to not simply replace the BIOS and devices files with the new version is that we want to retain entries from all older MAME versions as otherwise older ROM sets used on older MAME versions would have missing information. This is so as the MAME project sometimes removes older entries when they're reorganizing the ROM sets. By merging the files we retain backward compatibility but still support the latest MAME version. To clarify, this of course does not affect the emulation itself, but rather the filtering of BIOS and device files inside ES-DE. The mamenames.xml file containing the translation of MAME ROM names to the full game names does not suffer from this problem as it's cumulative, which is why it is simply overwritten.
## Configuration
**~/.emulationstation/es_settings.xml:**
When ES-DE is first run, a configuration file will be created as `~/.emulationstation/es_settings.xml`.
When ES-DE is first started, a configuration file will be created as `~/.emulationstation/es_settings.xml`
This file will contain all supported settings at their default values. Normally you shouldn't need to modify this file manually, instead you should be able to use the menu inside ES-DE to update all the necessary settings.
@ -1238,9 +1326,11 @@ There is also support to add the variable %ESPATH% to the ROM directory setting,
**~/.emulationstation/es_input.xml:**
You normally don't need to modify this file manually as it's created by the built-in input configuration step. This procedure is detailed in the [User guide](USERGUIDE.md#input-device-configuration).
As ES-DE auto-configures the keyboard and controllers, neither the input configuration step or manual adjustments to the es_input.xml file should normally be needed. Actually, unless the button layout has been customized using the input configurator, the es_input.xml file will not even exist.
If your controller and keyboard stop working, you can delete the `~/.emulationstation/es_input.xml` file to make the input configuration screen re-appear on the next startup, or you can start ES-DE with the `--force-input-config` command line option.
But if you have customized your button layout and your controller or keyboard stop working, you can delete the `~/.emulationstation/es_input.xml` file to remove the customizations, or you can start ES-DE with the `--force-input-config` command line option to make the input configurator appear.
The input configuration is described in the [User guide](USERGUIDE-DEV.md#input-device-configuration).
## Command line options
@ -1315,15 +1405,17 @@ ES-DE ships with a comprehensive `es_systems.xml` configuration file and normall
To make a customized version of the systems configuration file, it first needs to be copied to `~/.emulationstation/custom_systems/es_systems.xml`. (The tilde symbol `~` translates to `$HOME` on Unix and macOS, and to `%HOMEPATH%` on Windows unless overridden using the --home command line option.)
The bundled es_systems.xml file is located in the resources directory that is part of the application installation. For example this could be `/usr/share/emulationstation/resources/systems/unix/es_systems.xml` on Unix, `/Applications/EmulationStation Desktop Edition.app/Contents/Resources/resources/systems/macos/es_systems.xml` on macOS and `C:\Program Files\EmulationStation-DE\resources\systems\windows\es_systems.xml` on Windows. The actual location may differ from these examples of course, depending on where ES-DE has been installed.
The bundled es_systems.xml file is located in the resources directory that is part of the application installation. For example this could be `/usr/share/emulationstation/resources/systems/unix/es_systems.xml` on Unix, `/Applications/EmulationStation Desktop Edition.app/Contents/Resources/resources/systems/macos/es_systems.xml` on macOS or `C:\Program Files\EmulationStation-DE\resources\systems\windows\es_systems.xml` on Windows. The actual location may differ from these examples of course, depending on where ES-DE has been installed.
Note that when copying the bundled es_systems.xml file to ~/.emulationstation/custom_systems/, it will completely replace the default file. So when upgrading to future ES-DE versions, any modifications such as additional game systems will not be enabled until the customized configuration file has been manually updated.
Note that when copying the bundled es_systems.xml file to ~/.emulationstation/custom_systems/, it will completely replace the default file processing. So when upgrading to future ES-DE versions, any modifications such as additional game systems will not be enabled until the customized configuration file has been manually updated.
It doesn't matter in which order you define the systems as they will be sorted by the full system name inside the application, but it's still probably a good idea to add them in alphabetical order to make the file easier to maintain.
Keep in mind that you have to set up your emulators separately from ES-DE as the es_systems.xml file assumes that your emulator environment is properly configured.
Below is an overview of the file layout with various examples. For a real system entry there can of course not be multiple entries for the same tag such as the multiple \<command\> entries listed here.
Below is an overview of the file layout with various examples. For the command tag, the newer es_find_rules.xml logic described later in this document removes the need for most of the legacy options, but they are still supported for special configurations and for backward compatibility with old configuration files.
For a real system entry there can of course not be multiple entries for the same tag such as the multiple \<command\> entries listed here.
```xml
<?xml version="1.0"?>
@ -1336,7 +1428,7 @@ Below is an overview of the file layout with various examples. For a real system
<name>snes</name>
<!-- The full system name, used for sorting the systems, for selecting the systems to multi-scrape etc. -->
<fullname>Super Nintendo Entertainment System</fullname>
<fullname>Nintendo SNES (Super Nintendo)</fullname>
<!-- The path to look for ROMs in. '~' will be expanded to $HOME or %HOMEPATH%, depending on the operating system.
The optional %ROMPATH% variable will expand to the path defined in the setting ROMDirectory in es_settings.xml.
@ -1361,7 +1453,7 @@ Below is an overview of the file layout with various examples. For a real system
the find rules for the emulator cores. -->
<command>retroarch -L %CORE_RETROARCH%/snes9x_libretro.so %ROM%</command>
<!-- This is an example for macOS, which is very similar to the Unix example above except using an absolut path to the emulator. -->
<!-- This is an example for macOS, which is very similar to the Unix example above except using an absolute path to the emulator. -->
<command>/Applications/RetroArch.app/Contents/MacOS/RetroArch -L %CORE_RETROARCH%/snes9x_libretro.dylib %ROM%</command>
<!-- This is an example for Windows. The .exe extension is optional and both forward slashes and backslashes are allowed as
@ -1381,14 +1473,14 @@ Below is an overview of the file layout with various examples. For a real system
<!-- The platform(s) to use when scraping. You can see the full list of supported platforms in es-app/src/PlatformId.cpp.
The entry is case insensitive as it will be converted to lower case during startup.
This tag is optional but the system can't be scraped if it's left out.
This tag is optional but scraper searches for the system will be inaccurate if it's left out.
You can use multiple platforms too, delimited with any of the whitespace characters (", \r\n\t"), e.g. "megadrive, genesis". -->
<platform>snes</platform>
<!-- The theme to load from the current theme set. See THEMES.md for more information.
This tag is optional and if it doesn't exist, ES-DE will attempt to find a theme with the same name as the system name.
If no such match is made, the system will be unthemed.
It's strongly recommended to include this tag even if it's just to clarify that the theme should correspond to the system name. -->
It's recommended to include this tag even if it's just to clarify that the theme should correspond to the system name. -->
<theme>snes</theme>
</system>
</systemList>
@ -1400,7 +1492,7 @@ The following variable is expanded for the `path` tag:
The following variables are expanded for the `command` tag:
`%ROM%` - Replaced with the absolute path to the selected ROM, with most Bash special characters escaped with a backslash.
`%ROM%` - Replaced with the absolute path to the selected ROM, with most special characters escaped with a backslash.
`%ROMRAW%` - Replaced with the unescaped, absolute path to the selected ROM. If your emulator is picky about paths, you might want to use this instead of %ROM%, but enclosed in quotes.
@ -1529,12 +1621,12 @@ The `name` attribute must correspond to the command tags in es_systems.xml, take
Here %EMULATOR_ and %CORE_ are followed by the string RETROARCH which corresponds to the name attribute in es_find_rules.xml. The name is case sensitive but it's recommended to use uppercase names to make the variables feel consistent (%EMULATOR_retroarch% doesn't look so pretty).
Of course this makes it possible to add any number of emulators to the configuration file if not only using RetroArch.
Of course this makes it possible to add any number of emulators to the configuration file.
The `winregistrypath` rule searches the Windows Registry "App Paths" keys for the emulators defined in the `<entry>` tags. If for example this tag is set to `retroarch.exe`, the key `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\retroarch.exe` will be searched for. HKEY_CURRENT_USER is tried first, and if no key is found there, HKEY_LOCAL_MACHINE is tried as well. In addition to this, ES-DE will check that the binary defined in the key actually exists, and if not, processing will proceed with the next rule. Be aware that the App Paths keys are added by the emulators during their installation, and although RetroArch does add this key, not all emulators do.
The `winregistrypath` rule searches the Windows Registry "App Paths" keys for the emulators defined in the `<entry>` tags. If for example this tag is set to `retroarch.exe`, the key `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\retroarch.exe` will be searched for. HKEY_CURRENT_USER is tried first, and if no key is found there, HKEY_LOCAL_MACHINE is tried as well. In addition to this, ES-DE will check that the binary defined in the key actually exists, and if not, it will proceed with the next rule. Be aware that the App Paths keys are added by the emulators during their installation, and although RetroArch does add this key, not all emulators do.
The other rules are probably self-explanatory with `systempath` searching the PATH environment variable for the binary names defined by the `<entry>` tags and `staticpath` defines absolute paths to the emulators. For staticpath, the actual emulator binary must also be included in the entry tag.
The other rules are probably self-explanatory with `systempath` searching the PATH environment variable for the binary names defined by the `<entry>` tags and `staticpath` defines absolute paths to the emulators. For staticpath, the actual emulator binary must be included in the entry tag.
The winregistrypath rules are always processed first, followed by systempath and then staticpath. This is done regardless of which order they are defined in the es_find_rules.xml file.
@ -1542,7 +1634,7 @@ As for `corepath` this rule is simply a path to search for the emulator core.
Each rule supports multiple entry tags which are tried in the order that they are defined in the file.
The %ESPATH% variable can be used inside the staticpath rules and both the %EMUPATH% and %ESPATH% variables can be used inside the corepath rules.
The %ESPATH% and %ROMPATH% variables can be used inside the staticpath rules and the %ESPATH% and %EMUPATH% variables can be used inside the corepath rules.
The tilde symbol `~` is supported for the staticpath and corepath rules and will expand to the user home directory. Be aware that if ES-DE has been started with the --home command line option, the home directory is considered to be whatever path was passed as an argument to that option. The same is true if using a portable.txt file.
@ -1638,7 +1730,7 @@ There is also support to add the variable %ESPATH% to the media directory settin
The default media directory is `~/.emulationstation/downloaded_media`
You can use ES-DE's scraping tools to populate the gamelist.xml files, or manually update individual entries using the metadata editor. All of this is explained in the [User guide](USERGUIDE.md).
You can use ES-DE's scrapers to populate the gamelist.xml files, or manually update individual entries using the metadata editor. All of this is explained in the [User guide](USERGUIDE-DEV.md).
The gamelist.xml files are searched for in the ES-DE home directory, i.e. `~/.emulationstation/gamelists/<system name>/gamelist.xml`
@ -1680,10 +1772,10 @@ There are a few different data types for the metadata which the string values in
* `string` - just text
* `float` - a floating-point decimal value (written as a string)
* `integer` - an integer value (written as a string)
* `datetime` - a date and, potentially, a time. These are encoded as an ISO string, in the following format: "%Y%m%dT%H%M%S%F%q". For example, the release date for Chrono Trigger is encoded as "19950311T000000" (no time specified)
* `datetime` - a date and optionally a time encoded as an ISO string in the format "%Y%m%dT%H%M%S", for example "19950311T000000"
* `bool` - a true or false value
Some metadata is also marked as "statistic" - these are kept track of by ES-DE and do not show up in the metadata editor. They are shown in certain views (for example, the detailed view and the video view both show `lastplayed`, although the label can be disabled by the theme).
Some metadata is also marked as "statistic", these are kept track of by ES-DE and do not show up in the metadata editor. They are shown in certain views (for example, the detailed view and the video view both show `lastplayed`, although the label can be disabled by the theme).
There are two basic categories of metadata, `game` and `folders` and the metdata tags for these are described in detail below.
@ -1766,34 +1858,36 @@ This will draw a semi-transparent blue frame around all text elements.
This will reload either a single gamelist or all gamelists depending on where you're located when entering the key combination (go to the system view to make a complete reload). Very useful for theme development as any changes to the theme files will be activated without requiring an application restart. Note that the menu needs to be closed for this key combination to have any effect.
By default all controller input (keyboard and controller button presses) will be logged when the --debug flag has been passed. To disable the input logging, the setting DebugSkipInputLogging kan be set to false in the es_settings.xml file. There is no menu entry to change this as it's intended for developers and not for end users.
## Portable installation on Windows
It's possible to easily create a portable installation of ES-DE for Windows, for example to place on a USB memory stick.
It's possible to easily create a portable installation of ES-DE on Windows, for example to place on a USB memory stick.
For the sake of this example, let's assume that the removable media has the device name `f:\`
For the sake of this example, let's assume that the removable media has the device name `F:\`
These are the steps to perform:
* Copy the EmulationStation-DE installation directory to f:\
* Copy your emulator directories to f:\EmulationStation-DE\
* Copy your ROMs directory to f:\EmulationStation-DE\
* Create an empty file named portable.txt in f:\EmulationStation-DE\
* Copy the EmulationStation-DE installation directory to F:\
* Copy your emulator directories to F:\EmulationStation-DE\
* Copy your ROMs directory to F:\EmulationStation-DE\
* Create an empty file named portable.txt in F:\EmulationStation-DE\
You should end up with something like this:
```
f:\EmulationStation-DE\
f:\EmulationStation-DE\RetroArch-Win64\
f:\EmulationStation-DE\yuzu\
f:\EmulationStation-DE\ROMs\
f:\EmulationStation-DE\portable.txt
F:\EmulationStation-DE\
F:\EmulationStation-DE\RetroArch-Win64\
F:\EmulationStation-DE\yuzu\
F:\EmulationStation-DE\ROMs\
F:\EmulationStation-DE\portable.txt
```
(Yuzu is an optional Nintendo Switch emulator.)
Of course there will be many more files and directories from the normal installation than those listed above.
How this works is that when ES-DE finds a file named portable.txt in its executable directory, it will locate the .emulationstation directory directly in this folder. It's however also possible to modify portable.txt with a path relative to the ES-DE executable directory. For instance if two dots `..` are placed inside the portable.txt file, then the .emulationstation directory will be located in the parent folder, which would be directly under f:\ in this example.
How this works is that when ES-DE finds a file named portable.txt in its executable directory, it will by default locate the .emulationstation directory directly in this folder. It's also possible to modify portable.txt with a path relative to the ES-DE executable directory. For instance if two dots `..` are placed inside the portable.txt file, then the .emulationstation directory will be located in the parent folder, which would be directly under F:\ in this example.
If the --home command line parameter is passed when starting ES-DE, that will override the portable.txt file.
@ -1808,15 +1902,15 @@ yuzu\yuzu-windows-msvc\yuzu.exe
..\yuzu\yuzu-windows-msvc\yuzu.exe
```
If you want to place your emulators elsewhere, you need to create a customized es_find_rules.xml file, which is explained later in this document.
If you want to place your emulators elsewhere, you need to create a customized es_find_rules.xml file, which is explained earlier in this document.
Start ES-DE from the f:\ device and check that everything works as expected.
Start ES-DE from the F:\ device and check that everything works as expected.
Following this, optionally copy any existing gamelist.xml files, game media files etc. to the removable media. For example:
```
f:\EmulationStation-DE\.emulationstation\gamelists\
f:\EmulationStation-DE\.emulationstation\downloaded_media\
F:\EmulationStation-DE\.emulationstation\gamelists\
F:\EmulationStation-DE\.emulationstation\downloaded_media\
```
You now have a fully functional portable retro gaming installation!
@ -1831,10 +1925,10 @@ There are numerous locations throughout ES-DE where custom scripts will be execu
The approach is quite straightforward, ES-DE will look for any files inside a script directory that corresponds to the event that is triggered and will then execute all these files.
We'll go through two examples:
* Create a log file that will record the start and end time for each game we play, letting us see how much time we spend on retro-gaming
* Change the system resolution when launching and returning from a game in order to run the emulator at a lower resolution than ES-DE
* Creating a log file that will record the start and end time for each game we play, letting us see how much time we spend on retro-gaming
* Changing the system resolution when launching and returning from a game in order to run the emulator at a lower resolution than ES-DE
**Note:** The following examples are for Unix systems, but it works the same way in macOS (which is also Unix after all), and on Windows (although .bat batch files are then used instead of shell scripts and any spaces in the parameters are not escaped as is the case on Unix).
**Note:** The following examples are for Unix systems, but it works the same way on macOS (which is also Unix after all), and on Windows (although .bat batch files are then used instead of shell scripts and any spaces in the parameters are not escaped as is the case on Unix).
The events executed when a game starts and ends are called `game-start` and `game-end` respectively. Finding these event names is easily achieved by starting ES-DE with the `--debug` flag. If this is done, all attempts to execute custom event scripts will be logged to es_log.txt, including the event names.
@ -1867,7 +1961,7 @@ After creating the two scripts, you should have something like this on the files
~/.emulationstation/scripts/game-end/game_end_logging.sh
```
Don't forget to make the scripts executable (e.g. 'chmod 755 ./game_start_logging.sh').
Don't forget to make the scripts executable (e.g. "chmod 755 ./game_start_logging.sh").
If we now start ES-DE with the debug flag and launch a game, something like the following should show up in es_log.txt:

12
README.md
View file

@ -31,7 +31,7 @@ The following operating systems have been tested with ES-DE (all for the x86 arc
**Note:** If using a Mac with an ARM CPU (e.g. M1) you need to install the x86 version of RetroArch and any other emulators, or you won't be able to launch any games. This will be fixed whenever a native macOS ARM build of ES-DE is released.
At the moment Raspberry Pi is not supported, but this is planned for version 1.2. It may still be possible to compile and run ES-DE on this type of device, but as of v1.1 it's not actively used during development and therefore not tested.
The Raspberry Pi 4 has been tested as well (with Raspberry Pi OS) but it's a bit buggy at the moment and is missing some features like GLSL shaders. Official support will probably be added for this device as of ES-DE v1.2.
### Download
@ -45,14 +45,14 @@ The latest stable version is 1.0.1 (released 2021-05-01)
| macOS DMG installer | Legacy macOS 10.11 "El Capitan" to 10.13 "High Sierra" | x64 (x86) | [EmulationStation-DE-1.0.1-x64_legacy.dmg](https://es-de.org/releases/stable/macOS/EmulationStation-DE-1.0.1-x64_legacy.dmg)|
| Windows installer | Windows 10 and 8.1 | x64 (x86) | [EmulationStation-DE-1.0.1-x64.exe](https://es-de.org/releases/stable/Windows/EmulationStation-DE-1.0.1-x64.exe)|
The latest pre-release version is 1.1.0-beta1 (released 2021-06-27)
The latest pre-release version is 1.1.0-beta2 (released 2021-07-04)
| Package | Operating systems | Architecture | Download link |
| :------------------ | :------------------------------------------------------ | :----------- | :------------- |
| Debian DEB package | Ubuntu 20.04 to 21.04, Linux Mint 20, possibly others | x64 (x86) | [emulationstation-de-1.1.0-beta1-x64.deb](https://es-de.org/releases/beta/Linux/emulationstation-de-1.1.0-beta1-x64.deb)|
| Fedora RPM package | Fedora Workstation 33, possibly others | x64 (x86) | [emulationstation-de-1.1.0-beta1-x64.rpm](https://es-de.org/releases/beta/Linux/emulationstation-de-1.1.0-beta1-x64.rpm)|
| macOS DMG installer | macOS 10.14 "Mojave" to 11 "Big Sur" | x64 (x86) | [EmulationStation-DE-1.1.0-beta1-x64.dmg](https://es-de.org/releases/beta/macOS/EmulationStation-DE-1.1.0-beta1-x64.dmg)|
| Windows installer | Windows 10 and 8.1 | x64 (x86) | [EmulationStation-DE-1.1.0-beta1-x64.exe](https://es-de.org/releases/beta/Windows/EmulationStation-DE-1.1.0-beta1-x64.exe)|
| Debian DEB package | Ubuntu 20.04 to 21.04, Linux Mint 20, possibly others | x64 (x86) | [emulationstation-de-1.1.0-beta2-x64.deb](https://es-de.org/releases/beta/Linux/emulationstation-de-1.1.0-beta2-x64.deb)|
| Fedora RPM package | Fedora Workstation 33, possibly others | x64 (x86) | [emulationstation-de-1.1.0-beta2-x64.rpm](https://es-de.org/releases/beta/Linux/emulationstation-de-1.1.0-beta2-x64.rpm)|
| macOS DMG installer | macOS 10.14 "Mojave" to 11 "Big Sur" | x64 (x86) | [EmulationStation-DE-1.1.0-beta2-x64.dmg](https://es-de.org/releases/beta/macOS/EmulationStation-DE-1.1.0-beta2-x64.dmg)|
| Windows installer | Windows 10 and 8.1 | x64 (x86) | [EmulationStation-DE-1.1.0-beta2-x64.exe](https://es-de.org/releases/beta/Windows/EmulationStation-DE-1.1.0-beta2-x64.exe)|
Unfortunately due to technical reasons, v1.0.1 will be the last release for legacy macOS versions.

383
USERGUIDE-DEV.md
View file

File diff suppressed because it is too large Load diff

12
es-app/CMakeLists.txt
View file

@ -127,8 +127,8 @@ endif()
if(WIN32)
install(TARGETS EmulationStation RUNTIME DESTINATION .)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
install(FILES ../avcodec-59.dll ../avfilter-8.dll ../avformat-59.dll ../avutil-57.dll
../postproc-56.dll ../swresample-4.dll ../swscale-6.dll ../FreeImage.dll
install(FILES ../avcodec-58.dll ../avfilter-7.dll ../avformat-58.dll ../avutil-56.dll
../postproc-55.dll ../swresample-3.dll ../swscale-5.dll ../FreeImage.dll
../glew32.dll ../libcrypto-1_1-x64.dll ../libcurl-x64.dll ../freetype.dll
../pugixml.dll ../libssl-1_1-x64.dll ../SDL2.dll ../MSVCP140.dll ../VCOMP140.DLL
../VCRUNTIME140.dll ../VCRUNTIME140_1.dll DESTINATION .)
@ -136,8 +136,8 @@ if(WIN32)
install(FILES ../libvlc.dll ../libvlccore.dll DESTINATION .)
endif()
else()
install(FILES ../avcodec-59.dll ../avfilter-8.dll ../avformat-59.dll ../avutil-57.dll
../postproc-56.dll ../swresample-4.dll ../swscale-6.dll ../FreeImage.dll
install(FILES ../avcodec-58.dll ../avfilter-7.dll ../avformat-58.dll ../avutil-56.dll
../postproc-55.dll ../swresample-3.dll ../swscale-5.dll ../FreeImage.dll
../glew32.dll ../libcrypto-1_1-x64.dll ../libcurl-x64.dll ../libfreetype.dll
../libpugixml.dll ../libssl-1_1-x64.dll ../SDL2.dll ../vcomp140.dll DESTINATION .)
if(VLC_PLAYER)
@ -275,7 +275,7 @@ endif()
set(CPACK_PACKAGE_VENDOR "Leon Styhre")
# Update this when there has been a new release.
set(CPACK_PACKAGE_VERSION "1.1.0-beta2-dev")
set(CPACK_PACKAGE_VERSION "1.1.0-rc")
# Use the shorter x64 descriptor if on the x86_64/AMD64 architecture.
if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL AMD64)
@ -332,7 +332,7 @@ else()
set(CPACK_DEBIAN_PACKAGE_HOMEPAGE "https://es-de.org")
set(CPACK_DEBIAN_PACKAGE_SECTION "games")
set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
if(VLC_PLAYER OR RPI)
if(VLC_PLAYER)
set(CPACK_DEBIAN_PACKAGE_DEPENDS "vlc")
endif()
set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)

2
es-app/assets/EmulationStation-DE_Info.plist
View file

@ -19,7 +19,7 @@
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleVersion</key>
<string>1.1.0-beta2-dev</string>
<string>1.1.0-rc</string>
<key>LSMinimumSystemVersion</key>
<string>10.14.0</string>
<key>LSUIPresentationMode</key>

BIN
es-app/assets/emulationstation.6.gz
View file

Binary file not shown.

2
es-app/assets/emulationstation.desktop
View file

@ -1,5 +1,5 @@
[Desktop Entry]
Version=1.1.0-beta2-dev
Version=1.1.0-rc
Name=EmulationStation Desktop Edition
GenericName=Emulator Front-end
Type=Application

553
es-app/src/CollectionSystemsManager.cpp
View file

File diff suppressed because it is too large Load diff

28
es-app/src/CollectionSystemsManager.h
View file

@ -34,7 +34,7 @@ class Window;
struct SystemEnvironmentData;
enum CollectionSystemType {
AUTO_ALL_GAMES,
AUTO_ALL_GAMES, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
AUTO_LAST_PLAYED,
AUTO_FAVORITES,
CUSTOM_COLLECTION
@ -115,13 +115,17 @@ public:
// Repopulate the collection, which is basically a forced update of its complete content.
void repopulateCollection(SystemData* sysData);
inline std::map<std::string, CollectionSystemData, stringComparator>
getAutoCollectionSystems() { return mAutoCollectionSystemsData; };
inline std::map<std::string, CollectionSystemData, stringComparator>
getCustomCollectionSystems() { return mCustomCollectionSystemsData; };
inline SystemData* getCustomCollectionsBundle() { return mCustomCollectionsBundle; };
inline bool isEditing() { return mIsEditingCustom; };
inline std::string getEditingCollection() { return mEditingCollection; };
std::map<std::string, CollectionSystemData, stringComparator> getAutoCollectionSystems()
{
return mAutoCollectionSystemsData;
}
std::map<std::string, CollectionSystemData, stringComparator> getCustomCollectionSystems()
{
return mCustomCollectionSystemsData;
}
SystemData* getCustomCollectionsBundle() { return mCustomCollectionsBundle; }
bool isEditing() { return mIsEditingCustom; }
std::string getEditingCollection() { return mEditingCollection; }
private:
static CollectionSystemsManager* sInstance;
@ -143,7 +147,9 @@ private:
SystemData* getAllGamesCollection();
// Create a new empty collection system based on the name and declaration.
SystemData* createNewCollectionEntry(std::string name,
CollectionSystemDecl sysDecl, bool index = true, bool custom = false);
CollectionSystemDecl sysDecl,
bool index = true,
bool custom = false);
// Populate an automatic collection system.
void populateAutoCollection(CollectionSystemData* sysData);
// Populate a custom collection system.
@ -151,8 +157,8 @@ private:
// Functions to handle System View removal and insertion of collections:
void removeCollectionsFromDisplayedSystems();
void addEnabledCollectionsToDisplayedSystems(std::map<std::string,
CollectionSystemData, stringComparator>* colSystemData);
void addEnabledCollectionsToDisplayedSystems(
std::map<std::string, CollectionSystemData, stringComparator>* colSystemData);
// Auxiliary functions:
std::vector<std::string> getSystemsFromConfig();

8
es-app/src/EmulationStation.h
View file

@ -10,14 +10,16 @@
// These numbers and strings need to be manually updated for a new version.
// Do this version number update as the very last commit for the new release version.
// clang-format off
#define PROGRAM_VERSION_MAJOR 1
#define PROGRAM_VERSION_MINOR 0
#define PROGRAM_VERSION_MINOR 1
#define PROGRAM_VERSION_MAINTENANCE 0
#define PROGRAM_VERSION_STRING "1.1.0-beta2-dev"
// clang-format on
#define PROGRAM_VERSION_STRING "1.1.0-rc"
#define PROGRAM_BUILT_STRING __DATE__ " - " __TIME__
#define RESOURCE_VERSION_STRING "1,1,0\0"
#define RESOURCE_VERSION PROGRAM_VERSION_MAJOR,PROGRAM_VERSION_MINOR,PROGRAM_VERSION_MAINTENANCE
#define RESOURCE_VERSION PROGRAM_VERSION_MAJOR, PROGRAM_VERSION_MINOR, PROGRAM_VERSION_MAINTENANCE
#endif // ES_APP_EMULATION_STATION_H

447
es-app/src/FileData.cpp
View file

@ -10,12 +10,6 @@
#include "FileData.h"
#include "guis/GuiInfoPopup.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "utils/TimeUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "AudioManager.h"
#include "CollectionSystemsManager.h"
#include "FileFilterIndex.h"
@ -26,33 +20,37 @@
#include "Scripting.h"
#include "SystemData.h"
#include "Window.h"
#include "guis/GuiInfoPopup.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "utils/TimeUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include <assert.h>
FileData::FileData(
FileType type,
const std::string& path,
SystemEnvironmentData* envData,
SystemData* system)
: mType(type),
mPath(path),
mSystem(system),
mEnvData(envData),
mSourceFileData(nullptr),
mParent(nullptr),
mOnlyFolders(false),
mDeletionFlag(false),
// Metadata is set in the constructor.
metadata(type == GAME ? GAME_METADATA : FOLDER_METADATA)
FileData::FileData(FileType type,
const std::string& path,
SystemEnvironmentData* envData,
SystemData* system)
: mType(type)
, mPath(path)
, mSystem(system)
, mEnvData(envData)
, mSourceFileData(nullptr)
, mParent(nullptr)
, mOnlyFolders(false)
, mDeletionFlag(false)
// Metadata is set in the constructor.
, metadata(type == GAME ? GAME_METADATA : FOLDER_METADATA)
{
// Metadata needs at least a name field (since that's what getName() will return).
if (metadata.get("name").empty()) {
if ((system->hasPlatformId(PlatformIds::ARCADE) ||
system->hasPlatformId(PlatformIds::SNK_NEO_GEO)) &&
metadata.getType() != FOLDER_METADATA) {
system->hasPlatformId(PlatformIds::SNK_NEO_GEO)) &&
metadata.getType() != FOLDER_METADATA) {
// If it's a MAME or Neo Geo game, expand the game name accordingly.
metadata.set("name",
MameNames::getInstance()->getCleanName(getCleanName()));
metadata.set("name", MameNames::getInstance()->getCleanName(getCleanName()));
}
else {
if (metadata.getType() == FOLDER_METADATA && Utils::FileSystem::isHidden(mPath)) {
@ -89,6 +87,7 @@ std::string FileData::getCleanName() const
const std::string& FileData::getName()
{
// Return metadata name.
return metadata.get("name");
}
@ -144,14 +143,13 @@ const std::vector<FileData*> FileData::getChildrenRecursive() const
{
std::vector<FileData*> childrenRecursive;
for (auto it = mChildrenByFilename.cbegin();
it != mChildrenByFilename.cend(); it++) {
for (auto it = mChildrenByFilename.cbegin(); it != mChildrenByFilename.cend(); it++) {
childrenRecursive.push_back((*it).second);
// Recurse through any subdirectories.
if ((*it).second->getType() == FOLDER) {
std::vector<FileData*> childrenSubdirectory = (*it).second->getChildrenRecursive();
childrenRecursive.insert(childrenRecursive.end(),
childrenSubdirectory.begin(), childrenSubdirectory.end());
childrenRecursive.insert(childrenRecursive.end(), childrenSubdirectory.begin(),
childrenSubdirectory.end());
}
}
@ -171,13 +169,13 @@ const std::string FileData::getROMDirectory()
// Expand home path if ~ is used.
romDirPath = Utils::FileSystem::expandHomePath(romDirPath);
#if defined(_WIN64)
if (romDirPath.back() != '\\')
#if defined(_WIN64)
if (romDirPath.back() != '\\')
romDirPath = romDirPath + "\\";
#else
if (romDirPath.back() != '/')
#else
if (romDirPath.back() != '/')
romDirPath = romDirPath + "/";
#endif
#endif
}
// If %ESPATH% is used for the ROM path configuration, then expand it to the binary
@ -202,10 +200,10 @@ const std::string FileData::getMediaDirectory()
// If %ESPATH% is used for the media directory configuration, then expand it to the
// binary directory of ES-DE.
mediaDirPath = Utils::String::replace(
mediaDirPath, "%ESPATH%", Utils::FileSystem::getExePath());
mediaDirPath =
Utils::String::replace(mediaDirPath, "%ESPATH%", Utils::FileSystem::getExePath());
if (mediaDirPath.back() != '/')
if (mediaDirPath.back() != '/')
mediaDirPath = mediaDirPath + "/";
}
@ -219,11 +217,11 @@ const std::string FileData::getMediafilePath(std::string subdirectory, std::stri
// Extract possible subfolders from the path.
if (mEnvData->mStartPath != "")
subFolders = Utils::String::replace(
Utils::FileSystem::getParent(mPath), mEnvData->mStartPath, "");
subFolders =
Utils::String::replace(Utils::FileSystem::getParent(mPath), mEnvData->mStartPath, "");
const std::string tempPath = getMediaDirectory() + mSystemName + "/" + subdirectory +
subFolders + "/" + getDisplayName();
subFolders + "/" + getDisplayName();
// Look for an image file in the media directory.
for (int i = 0; i < extList.size(); i++) {
@ -253,31 +251,37 @@ const std::string FileData::getImagePath() const
const std::string FileData::get3DBoxPath() const
{
// Return path to the 3D box image.
return getMediafilePath("3dboxes", "3dbox");
}
const std::string FileData::getCoverPath() const
{
// Return path to the cover image.
return getMediafilePath("covers", "cover");
}
const std::string FileData::getMarqueePath() const
{
// Return path to the marquee image.
return getMediafilePath("marquees", "marquee");
}
const std::string FileData::getMiximagePath() const
{
// Return path to the miximage.
return getMediafilePath("miximages", "miximage");
}
const std::string FileData::getScreenshotPath() const
{
// Return path to the screenshot image.
return getMediafilePath("screenshots", "screenshot");
}
const std::string FileData::getThumbnailPath() const
{
// Return path to the thumbnail image.
return getMediafilePath("thumbnails", "thumbnail");
}
@ -288,11 +292,11 @@ const std::string FileData::getVideoPath() const
// Extract possible subfolders from the path.
if (mEnvData->mStartPath != "")
subFolders = Utils::String::replace(
Utils::FileSystem::getParent(mPath), mEnvData->mStartPath, "");
subFolders =
Utils::String::replace(Utils::FileSystem::getParent(mPath), mEnvData->mStartPath, "");
const std::string tempPath =
getMediaDirectory() + mSystemName + "/videos" + subFolders + "/" + getDisplayName();
getMediaDirectory() + mSystemName + "/videos" + subFolders + "/" + getDisplayName();
// Look for media in the media directory.
for (int i = 0; i < extList.size(); i++) {
@ -322,7 +326,8 @@ const std::vector<FileData*>& FileData::getChildrenListToDisplay()
}
std::vector<FileData*> FileData::getFilesRecursive(unsigned int typeMask,
bool displayedOnly, bool countAllGames) const
bool displayedOnly,
bool countAllGames) const
{
std::vector<FileData*> out;
FileFilterIndex* idx = mSystem->getIndex();
@ -354,7 +359,8 @@ std::vector<FileData*> FileData::getFilesRecursive(unsigned int typeMask,
}
std::vector<FileData*> FileData::getScrapeFilesRecursive(bool includeFolders,
bool excludeRecursively, bool respectExclusions) const
bool excludeRecursively,
bool respectExclusions) const
{
std::vector<FileData*> out;
@ -375,7 +381,7 @@ std::vector<FileData*> FileData::getScrapeFilesRecursive(bool includeFolders,
if ((*it)->getChildren().size() > 0) {
std::vector<FileData*> subChildren = (*it)->getScrapeFilesRecursive(
includeFolders, excludeRecursively, respectExclusions);
includeFolders, excludeRecursively, respectExclusions);
out.insert(out.cend(), subChildren.cbegin(), subChildren.cend());
}
}
@ -383,32 +389,25 @@ std::vector<FileData*> FileData::getScrapeFilesRecursive(bool includeFolders,
return out;
}
std::string FileData::getKey() {
return getFileName();
}
std::string FileData::getKey() { return getFileName(); }
const bool FileData::isArcadeAsset()
{
const std::string stem = Utils::FileSystem::getStem(mPath);
return ((mSystem && (mSystem->hasPlatformId(PlatformIds::ARCADE) ||
mSystem->hasPlatformId(PlatformIds::SNK_NEO_GEO))) &&
(MameNames::getInstance()->isBios(stem) ||
MameNames::getInstance()->isDevice(stem)));
mSystem->hasPlatformId(PlatformIds::SNK_NEO_GEO))) &&
(MameNames::getInstance()->isBios(stem) || MameNames::getInstance()->isDevice(stem)));
}
const bool FileData::isArcadeGame()
{
const std::string stem = Utils::FileSystem::getStem(mPath);
return ((mSystem && (mSystem->hasPlatformId(PlatformIds::ARCADE) ||
mSystem->hasPlatformId(PlatformIds::SNK_NEO_GEO))) &&
(!MameNames::getInstance()->isBios(stem) &&
!MameNames::getInstance()->isDevice(stem)));
mSystem->hasPlatformId(PlatformIds::SNK_NEO_GEO))) &&
(!MameNames::getInstance()->isBios(stem) && !MameNames::getInstance()->isDevice(stem)));
}
FileData* FileData::getSourceFileData()
{
return this;
}
FileData* FileData::getSourceFileData() { return this; }
void FileData::addChild(FileData* file)
{
@ -441,7 +440,7 @@ void FileData::removeChild(FileData* file)
}
void FileData::sort(ComparisonFunction& comparator,
std::pair<unsigned int, unsigned int>& gameCount)
std::pair<unsigned int, unsigned int>& gameCount)
{
mOnlyFolders = true;
mHasFolders = false;
@ -456,17 +455,17 @@ void FileData::sort(ComparisonFunction& comparator,
if (!showHiddenGames) {
for (auto it = mChildren.begin(); it != mChildren.end();) {
// If the option to hide hidden games has been set and the game is hidden,
// then skip it. Normally games are hidden during loading of the gamelists in
// Gamelist::parseGamelist() and this code should only run when a user has marked
// an entry manually as hidden. So upon the next application startup, this game
// should be filtered already at that earlier point.
// If the option to hide hidden games has been set and the game is hidden,
// then skip it. Normally games are hidden during loading of the gamelists in
// Gamelist::parseGamelist() and this code should only run when a user has marked
// an entry manually as hidden. So upon the next application startup, this game
// should be filtered already at that earlier point.
if ((*it)->getHidden())
it = mChildren.erase(it);
// Also hide folders where all its entries have been hidden, unless it's a
// grouped custom collection.
else if ((*it)->getType() == FOLDER && (*it)->getChildren().size() == 0 &&
!(*it)->getSystem()->isGroupedCustomCollection())
!(*it)->getSystem()->isGroupedCustomCollection())
it = mChildren.erase(it);
else
it++;
@ -502,11 +501,11 @@ void FileData::sort(ComparisonFunction& comparator,
// If the requested sorting is not by filename, then sort in ascending filename order
// as a first step, in order to get a correct secondary sorting.
if (getSortTypeFromString("filename, ascending").comparisonFunction != comparator &&
getSortTypeFromString("filename, descending").comparisonFunction != comparator) {
getSortTypeFromString("filename, descending").comparisonFunction != comparator) {
std::stable_sort(mChildrenFolders.begin(), mChildrenFolders.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
std::stable_sort(mChildrenOthers.begin(), mChildrenOthers.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
}
if (foldersOnTop && mOnlyFolders)
@ -523,9 +522,9 @@ void FileData::sort(ComparisonFunction& comparator,
// If the requested sorting is not by filename, then sort in ascending filename order
// as a first step, in order to get a correct secondary sorting.
if (getSortTypeFromString("filename, ascending").comparisonFunction != comparator &&
getSortTypeFromString("filename, descending").comparisonFunction != comparator)
getSortTypeFromString("filename, descending").comparisonFunction != comparator)
std::stable_sort(mChildren.begin(), mChildren.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
std::stable_sort(mChildren.begin(), mChildren.end(), comparator);
}
@ -555,7 +554,7 @@ void FileData::sort(ComparisonFunction& comparator,
}
void FileData::sortFavoritesOnTop(ComparisonFunction& comparator,
std::pair<unsigned int, unsigned int>& gameCount)
std::pair<unsigned int, unsigned int>& gameCount)
{
mOnlyFolders = true;
mHasFolders = false;
@ -634,39 +633,39 @@ void FileData::sortFavoritesOnTop(ComparisonFunction& comparator,
// some folders as favorites is probably a rare situation.
if (!mOnlyFolders && mChildrenFavoritesFolders.size() > 0) {
mChildrenFolders.insert(mChildrenFolders.end(), mChildrenFavoritesFolders.begin(),
mChildrenFavoritesFolders.end());
mChildrenFavoritesFolders.end());
mChildrenFavoritesFolders.erase(mChildrenFavoritesFolders.begin(),
mChildrenFavoritesFolders.end());
mChildrenFavoritesFolders.end());
std::stable_sort(mChildrenFolders.begin(), mChildrenFolders.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
}
// If the requested sorting is not by filename, then sort in ascending filename order
// as a first step, in order to get a correct secondary sorting.
if (getSortTypeFromString("filename, ascending").comparisonFunction != comparator &&
getSortTypeFromString("filename, descending").comparisonFunction != comparator) {
getSortTypeFromString("filename, descending").comparisonFunction != comparator) {
std::stable_sort(mChildrenFolders.begin(), mChildrenFolders.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
std::stable_sort(mChildrenFavoritesFolders.begin(), mChildrenFavoritesFolders.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
std::stable_sort(mChildrenFavorites.begin(), mChildrenFavorites.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
std::stable_sort(mChildrenOthers.begin(), mChildrenOthers.end(),
getSortTypeFromString("filename, ascending").comparisonFunction);
getSortTypeFromString("filename, ascending").comparisonFunction);
}
// Sort favorite games and the other games separately.
if (foldersOnTop && mOnlyFolders) {
std::stable_sort(mChildrenFavoritesFolders.begin(),
mChildrenFavoritesFolders.end(), comparator);
std::stable_sort(mChildrenFavoritesFolders.begin(), mChildrenFavoritesFolders.end(),
comparator);
std::stable_sort(mChildrenFolders.begin(), mChildrenFolders.end(), comparator);
}
std::stable_sort(mChildrenFavorites.begin(), mChildrenFavorites.end(), comparator);
std::stable_sort(mChildrenOthers.begin(), mChildrenOthers.end(), comparator);
// Iterate through any child favorite folders.
for (auto it = mChildrenFavoritesFolders.cbegin(); it !=
mChildrenFavoritesFolders.cend(); it++) {
for (auto it = mChildrenFavoritesFolders.cbegin(); // Line break.
it != mChildrenFavoritesFolders.cend(); it++) {
if ((*it)->getChildren().size() > 0)
(*it)->sortFavoritesOnTop(comparator, gameCount);
}
@ -690,9 +689,9 @@ void FileData::sortFavoritesOnTop(ComparisonFunction& comparator,
// Combine the individually sorted favorite games and other games vectors.
mChildren.erase(mChildren.begin(), mChildren.end());
mChildren.reserve(mChildrenFavoritesFolders.size() + mChildrenFolders.size() +
mChildrenFavorites.size() + mChildrenOthers.size());
mChildrenFavorites.size() + mChildrenOthers.size());
mChildren.insert(mChildren.end(), mChildrenFavoritesFolders.begin(),
mChildrenFavoritesFolders.end());
mChildrenFavoritesFolders.end());
mChildren.insert(mChildren.end(), mChildrenFolders.begin(), mChildrenFolders.end());
mChildren.insert(mChildren.end(), mChildrenFavorites.begin(), mChildrenFavorites.end());
mChildren.insert(mChildren.end(), mChildrenOthers.begin(), mChildrenOthers.end());
@ -711,10 +710,10 @@ void FileData::sort(const SortType& type, bool mFavoritesOnTop)
void FileData::countGames(std::pair<unsigned int, unsigned int>& gameCount)
{
bool isKidMode = (Settings::getInstance()->getString("UIMode") == "kid" ||
Settings::getInstance()->getBool("ForceKid"));
Settings::getInstance()->getBool("ForceKid"));
(Settings::getInstance()->getString("UIMode") == "kid" ||
Settings::getInstance()->getBool("ForceKid"));
Settings::getInstance()->getBool("ForceKid"));
for (unsigned int i = 0; i < mChildren.size(); i++) {
if (mChildren[i]->getType() == GAME && mChildren[i]->getCountAsGame()) {
@ -731,7 +730,8 @@ void FileData::countGames(std::pair<unsigned int, unsigned int>& gameCount)
mGameCount = gameCount;
}
FileData::SortType FileData::getSortTypeFromString(std::string desc) {
FileData::SortType FileData::getSortTypeFromString(std::string desc)
{
std::vector<FileData::SortType> SortTypes = FileSorts::SortTypes;
for (unsigned int i = 0; i < FileSorts::SortTypes.size(); i++) {
@ -752,10 +752,12 @@ void FileData::launchGame(Window* window)
// Check if there is a launch command override for the game
// and the corresponding option to use it has been set.
if (Settings::getInstance()->getBool("LaunchCommandOverride") &&
!metadata.get("launchcommand").empty())
!metadata.get("launchcommand").empty()) {
command = metadata.get("launchcommand");
else
}
else {
command = mEnvData->mLaunchCommand;
}
std::string commandRaw = command;
@ -794,14 +796,14 @@ void FileData::launchGame(Window* window)
// Hack to show an error message if there was no emulator entry in es_find_rules.xml.
if (binaryPath.substr(0, 18) == "NO EMULATOR RULE: ") {
std::string emulatorEntry = binaryPath.substr(18, binaryPath.size() - 18);
LOG(LogError) << "Couldn't launch game, either there is no emulator entry for \"" <<
emulatorEntry << "\" in es_find_rules.xml or there are no systempath or staticpath "
"rules defined";
LOG(LogError)
<< "Couldn't launch game, either there is no emulator entry for \"" << emulatorEntry
<< "\" in es_find_rules.xml or there are no systempath or staticpath rules defined";
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR: MISSING EMULATOR CONFIGURATION FOR '" +
emulatorEntry + "'", 6000);
GuiInfoPopup* s = new GuiInfoPopup(
window, "ERROR: MISSING EMULATOR CONFIGURATION FOR '" + emulatorEntry + "'", 6000);
window->setInfoPopup(s);
return;
}
@ -810,20 +812,23 @@ void FileData::launchGame(Window* window)
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR: COULDN'T FIND EMULATOR, HAS IT " \
"BEEN PROPERLY INSTALLED?", 6000);
GuiInfoPopup* s = new GuiInfoPopup(window,
"ERROR: COULDN'T FIND EMULATOR, HAS IT "
"BEEN PROPERLY INSTALLED?",
6000);
window->setInfoPopup(s);
return;
}
else {
#if defined(_WIN64)
LOG(LogDebug) << "FileData::launchGame(): Found emulator binary \"" <<
Utils::String::replace(Utils::String::replace(
binaryPath, "%ESPATH%", esPath), "/", "\\") << "\"";
#else
LOG(LogDebug) << "FileData::launchGame(): Found emulator binary \"" <<
Utils::String::replace(binaryPath, "%ESPATH%", esPath) << "\"";
#endif
#if defined(_WIN64)
LOG(LogDebug) << "FileData::launchGame(): Found emulator binary \""
<< Utils::String::replace(
Utils::String::replace(binaryPath, "%ESPATH%", esPath), "/", "\\")
<< "\"";
#else
LOG(LogDebug) << "FileData::launchGame(): Found emulator binary \""
<< Utils::String::replace(binaryPath, "%ESPATH%", esPath) << "\"";
#endif
}
// If %EMUPATH% is used in es_systems.xml for this system, then check that the core
@ -834,8 +839,8 @@ void FileData::launchGame(Window* window)
unsigned int quotationMarkPos = 0;
if (command.find("\"%EMUPATH%", emuPathPos - 1) != std::string::npos) {
hasQuotationMark = true;
quotationMarkPos = static_cast<unsigned int>(
command.find("\"", emuPathPos + 9) - emuPathPos);
quotationMarkPos =
static_cast<unsigned int>(command.find("\"", emuPathPos + 9) - emuPathPos);
}
size_t spacePos = command.find(" ", emuPathPos + quotationMarkPos);
std::string coreRaw;
@ -843,22 +848,23 @@ void FileData::launchGame(Window* window)
if (spacePos != std::string::npos) {
coreRaw = command.substr(emuPathPos, spacePos - emuPathPos);
coreFile = Utils::FileSystem::getParent(binaryPath) +
command.substr(emuPathPos + 9, spacePos - emuPathPos - 9);
command.substr(emuPathPos + 9, spacePos - emuPathPos - 9);
if (hasQuotationMark) {
coreRaw.pop_back();
coreFile.pop_back();
}
if (!Utils::FileSystem::isRegularFile(coreFile) &&
!Utils::FileSystem::isSymlink(coreFile)) {
LOG(LogError) << "Couldn't launch game, emulator core file \"" <<
Utils::FileSystem::getFileName(coreFile) << "\" not found";
!Utils::FileSystem::isSymlink(coreFile)) {
LOG(LogError) << "Couldn't launch game, emulator core file \""
<< Utils::FileSystem::getFileName(coreFile) << "\" not found";
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
GuiInfoPopup* s = new GuiInfoPopup(window,
"ERROR: COULDN'T FIND EMULATOR CORE FILE '" +
Utils::String::toUpper(Utils::FileSystem::getFileName(coreFile)) +
"'", 6000);
GuiInfoPopup* s = new GuiInfoPopup(
window,
"ERROR: COULDN'T FIND EMULATOR CORE FILE '" +
Utils::String::toUpper(Utils::FileSystem::getFileName(coreFile)) + "'",
6000);
window->setInfoPopup(s);
return;
}
@ -877,8 +883,10 @@ void FileData::launchGame(Window* window)
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR: INVALID ENTRY IN SYSTEMS " \
"CONFIGURATION FILE", 6000);
GuiInfoPopup* s = new GuiInfoPopup(window,
"ERROR: INVALID ENTRY IN SYSTEMS "
"CONFIGURATION FILE",
6000);
window->setInfoPopup(s);
return;
}
@ -886,13 +894,13 @@ void FileData::launchGame(Window* window)
// Error handling in case of no core find rule.
if (coreEntry != "" && emulatorCorePaths.empty()) {
LOG(LogError) << "Couldn't launch game, either there is no core entry for \"" <<
coreEntry << "\" in es_find_rules.xml or there are no corepath rules defined";
LOG(LogError) << "Couldn't launch game, either there is no core entry for \"" << coreEntry
<< "\" in es_find_rules.xml or there are no corepath rules defined";
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR: MISSING CORE CONFIGURATION FOR '" +
coreEntry + "'", 6000);
GuiInfoPopup* s = new GuiInfoPopup(
window, "ERROR: MISSING CORE CONFIGURATION FOR '" + coreEntry + "'", 6000);
window->setInfoPopup(s);
return;
}
@ -913,46 +921,47 @@ void FileData::launchGame(Window* window)
separatorPos = quotePos;
if (separatorPos != std::string::npos) {
coreName = command.substr(coreFilePos + 2, separatorPos - (coreFilePos + 2));
coreName = command.substr(coreFilePos + 2, separatorPos - (coreFilePos + 2));
#if defined(_WIN64)
#if defined(_WIN64)
std::string coreFile = Utils::FileSystem::expandHomePath(path + "\\" + coreName);
#else
#else
std::string coreFile = Utils::FileSystem::expandHomePath(path + "/" + coreName);
#endif
#endif
// Expand %EMUPATH% if it has been used in the %CORE_ variable.
size_t stringPos = coreFile.find("%EMUPATH%");
if (stringPos != std::string::npos) {
#if defined (_WIN64)
coreFile = Utils::String::replace(coreFile.replace(stringPos, 9,
Utils::FileSystem::getParent(binaryPath)), "/", "\\");
#else
#if defined(_WIN64)
coreFile = Utils::String::replace(
coreFile.replace(stringPos, 9, Utils::FileSystem::getParent(binaryPath)), "/",
"\\");
#else
coreFile = coreFile.replace(stringPos, 9, Utils::FileSystem::getParent(binaryPath));
#endif
#endif
}
// Expand %ESPATH% if it has been used in the %CORE_ variable.
stringPos = coreFile.find("%ESPATH%");
if (stringPos != std::string::npos) {
coreFile = coreFile.replace(stringPos, 8, esPath);
#if defined(_WIN64)
#if defined(_WIN64)
coreFile = Utils::String::replace(coreFile, "/", "\\");
#endif
#endif
}
if (Utils::FileSystem::isRegularFile(coreFile) ||
Utils::FileSystem::isSymlink(coreFile)) {
Utils::FileSystem::isSymlink(coreFile)) {
foundCoreFile = true;
// Escape any blankspaces.
if (coreFile.find(" ") != std::string::npos)
coreFile = Utils::FileSystem::getEscapedPath(coreFile);
command.replace(coreEntryPos, separatorPos - coreEntryPos, coreFile);
#if !defined(_WIN64)
#if !defined(_WIN64)
// Remove any quotation marks as it would make the launch function fail.
if (command.find("\"") != std::string::npos)
command = Utils::String::replace(command, "\"", "");
#endif
#endif
break;
}
}
@ -961,23 +970,28 @@ void FileData::launchGame(Window* window)
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR: INVALID ENTRY IN SYSTEMS " \
"CONFIGURATION FILE", 6000);
GuiInfoPopup* s = new GuiInfoPopup(window,
"ERROR: INVALID ENTRY IN SYSTEMS "
"CONFIGURATION FILE",
6000);
window->setInfoPopup(s);
return;
}
}
if (!foundCoreFile && coreName.size() > 0) {
LOG(LogError) << "Couldn't launch game, emulator core file \"" <<
coreName.substr(0, coreName.size()) << "\" not found";
LOG(LogError) << "Couldn't launch game, emulator core file \""
<< coreName.substr(0, coreName.size()) << "\" not found";
LOG(LogError) << "Raw emulator launch command:";
LOG(LogError) << commandRaw;
LOG(LogError) <<
"Tried to find the core file using these paths as defined by es_find_rules.xml:";
LOG(LogError)
<< "Tried to find the core file using these paths as defined by es_find_rules.xml:";
LOG(LogError) << Utils::String::vectorToDelimitedString(emulatorCorePaths, ", ");
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR: COULDN'T FIND EMULATOR CORE FILE '" +
Utils::String::toUpper(coreName.substr(0, coreName.size()) + "'"), 6000);
GuiInfoPopup* s =
new GuiInfoPopup(window,
"ERROR: COULDN'T FIND EMULATOR CORE FILE '" +
Utils::String::toUpper(coreName.substr(0, coreName.size()) + "'"),
6000);
window->setInfoPopup(s);
return;
}
@ -990,12 +1004,13 @@ void FileData::launchGame(Window* window)
// swapBuffers() is called here to turn the screen black to eliminate some potential
// flickering and to avoid showing the game launch message briefly when returning
// from the game.
#if defined(_WIN64)
#if defined(_WIN64)
if (!(Settings::getInstance()->getBool("LaunchWorkaround") ||
ViewController::get()->runInBackground(mSystem)))
#else
ViewController::get()->runInBackground(mSystem)))
#else
if (!ViewController::get()->runInBackground(mSystem))
#endif
#endif
Renderer::swapBuffers();
Scripting::fireEvent("game-start", romPath, getSourceFileData()->metadata.get("name"));
@ -1004,28 +1019,31 @@ void FileData::launchGame(Window* window)
LOG(LogDebug) << "Raw emulator launch command:";
LOG(LogDebug) << commandRaw;
LOG(LogInfo) << "Expanded emulator launch command:";
LOG(LogInfo) << command;
// Possibly keep ES-DE running in the background while the game is launched.
#if defined(_WIN64)
#if defined(_WIN64)
returnValue = launchGameWindows(Utils::String::stringToWideString(command),
ViewController::get()->runInBackground(mSystem));
#else
ViewController::get()->runInBackground(mSystem));
#else
returnValue = launchGameUnix(command, ViewController::get()->runInBackground(mSystem));
#endif
#endif
// Notify the user in case of a failed game launch using a popup window.
if (returnValue != 0) {
LOG(LogWarning) << "...launch terminated with nonzero return value " << returnValue;
GuiInfoPopup* s = new GuiInfoPopup(window, "ERROR LAUNCHING GAME '" +
Utils::String::toUpper(metadata.get("name")) + "' (ERROR CODE " +
Utils::String::toUpper(std::to_string(returnValue) + ")"), 6000);
GuiInfoPopup* s = new GuiInfoPopup(
window,
"ERROR LAUNCHING GAME '" + Utils::String::toUpper(metadata.get("name")) +
"' (ERROR CODE " + Utils::String::toUpper(std::to_string(returnValue) + ")"),
6000);
window->setInfoPopup(s);
}
else {
// Stop showing the game launch notification.
window->stopInfoPopup();
#if defined(_WIN64)
#if defined(_WIN64)
// For some game systems or if the "RunInBackground" setting has been enabled, keep
// ES-DE running while the game is launched. This pauses any video and keeps the
// screensaver from getting activated.
@ -1035,7 +1053,7 @@ void FileData::launchGame(Window* window)
// Normalize deltaTime so that the screensaver does not start immediately
// when returning from the game.
window->normalizeNextUpdate();
#else
#else
// For some game systems we need to keep ES-DE running while the game is launched.
// This pauses any video and keeps the screensaver from getting activated.
if (ViewController::get()->runInBackground(mSystem))
@ -1043,7 +1061,7 @@ void FileData::launchGame(Window* window)
// Normalize deltaTime so that the screensaver does not start immediately
// when returning from the game.
window->normalizeNextUpdate();
#endif
#endif
}
Scripting::fireEvent("game-end", romPath, getSourceFileData()->metadata.get("name"));
@ -1062,10 +1080,10 @@ void FileData::launchGame(Window* window)
// If the parent is a folder and it's not the root of the system, then update its lastplayed
// timestamp to the same time as the game that was just launched.
if (gameToUpdate->getParent()->getType() == FOLDER && gameToUpdate->getParent()->getName() !=
gameToUpdate->getSystem()->getFullName()) {
if (gameToUpdate->getParent()->getType() == FOLDER &&
gameToUpdate->getParent()->getName() != gameToUpdate->getSystem()->getFullName()) {
gameToUpdate->getParent()->metadata.set("lastplayed",
gameToUpdate->metadata.get("lastplayed"));
gameToUpdate->metadata.get("lastplayed"));
}
CollectionSystemsManager::get()->refreshCollectionSystems(gameToUpdate);
@ -1086,9 +1104,9 @@ std::string FileData::findEmulatorPath(std::string& command)
// Method 1, emulator binary is defined using find rules:
#if defined(_WIN64)
#if defined(_WIN64)
std::vector<std::string> emulatorWinRegistryPaths;
#endif
#endif
std::vector<std::string> emulatorSystemPaths;
std::vector<std::string> emulatorStaticPaths;
std::string emulatorEntry;
@ -1101,10 +1119,10 @@ std::string FileData::findEmulatorPath(std::string& command)
}
if (emulatorEntry != "") {
#if defined(_WIN64)
#if defined(_WIN64)
emulatorWinRegistryPaths =
SystemData::sFindRules.get()->mEmulators[emulatorEntry].winRegistryPaths;
#endif
SystemData::sFindRules.get()->mEmulators[emulatorEntry].winRegistryPaths;
#endif
emulatorSystemPaths = SystemData::sFindRules.get()->mEmulators[emulatorEntry].systemPaths;
emulatorStaticPaths = SystemData::sFindRules.get()->mEmulators[emulatorEntry].staticPaths;
}
@ -1113,11 +1131,11 @@ std::string FileData::findEmulatorPath(std::string& command)
if (emulatorEntry != "" && emulatorSystemPaths.empty() && emulatorStaticPaths.empty())
return "NO EMULATOR RULE: " + emulatorEntry;
#if defined(_WIN64)
#if defined(_WIN64)
for (std::string path : emulatorWinRegistryPaths) {
// Search for the emulator using the App Paths keys in the Windows Registry.
std::string registryKeyPath =
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" + path;
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\" + path;
HKEY registryKey;
LSTATUS keyStatus = -1;
@ -1126,33 +1144,19 @@ std::string FileData::findEmulatorPath(std::string& command)
DWORD pathSize = 1024;
// First look in HKEY_CURRENT_USER.
keyStatus = RegOpenKeyEx(
HKEY_CURRENT_USER,
registryKeyPath.c_str(),
0,
KEY_QUERY_VALUE,
&registryKey);
keyStatus = RegOpenKeyEx(HKEY_CURRENT_USER, registryKeyPath.c_str(), 0, KEY_QUERY_VALUE,
&registryKey);
// If not found, then try in HKEY_LOCAL_MACHINE.
if (keyStatus != ERROR_SUCCESS) {
keyStatus = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
registryKeyPath.c_str(),
0,
KEY_QUERY_VALUE,
&registryKey);
keyStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, registryKeyPath.c_str(), 0,
KEY_QUERY_VALUE, &registryKey);
}
// If the key exists, then try to retrieve the value.
if (keyStatus == ERROR_SUCCESS) {
pathStatus = RegGetValue(
registryKey,
nullptr,
nullptr,
RRF_RT_REG_SZ,
nullptr,
&registryPath,
&pathSize);
pathStatus = RegGetValue(registryKey, nullptr, nullptr, RRF_RT_REG_SZ, nullptr,
&registryPath, &pathSize);
}
else {
RegCloseKey(registryKey);
@ -1163,7 +1167,7 @@ std::string FileData::findEmulatorPath(std::string& command)
// so check for that as well.
if (pathStatus == ERROR_SUCCESS) {
if (Utils::FileSystem::isRegularFile(registryPath) ||
Utils::FileSystem::isSymlink(registryPath)) {
Utils::FileSystem::isSymlink(registryPath)) {
command.replace(0, endPos + 1, registryPath);
RegCloseKey(registryKey);
return registryPath;
@ -1171,25 +1175,24 @@ std::string FileData::findEmulatorPath(std::string& command)
}
RegCloseKey(registryKey);
}
#endif
#endif
for (std::string path : emulatorSystemPaths) {
#if defined(_WIN64)
#if defined(_WIN64)
std::wstring pathWide = Utils::String::stringToWideString(path);
// Search for the emulator using the PATH environmental variable.
DWORD size = SearchPathW(nullptr, pathWide.c_str(), L".exe", 0, nullptr, nullptr);
if (size) {
std::vector<wchar_t> pathBuffer(static_cast<size_t>(size) + 1 );
std::vector<wchar_t> pathBuffer(static_cast<size_t>(size) + 1);
wchar_t* fileName = nullptr;
SearchPathW(nullptr, pathWide.c_str(), L".exe", size + 1 ,
pathBuffer.data(), &fileName);
SearchPathW(nullptr, pathWide.c_str(), L".exe", size + 1, pathBuffer.data(), &fileName);
std::wstring pathString = pathBuffer.data();
if (pathString.length()) {
exePath = Utils::String::wideStringToString(pathString.substr(0,
pathString.size() - std::wstring(fileName).size()));
exePath = Utils::String::wideStringToString(
pathString.substr(0, pathString.size() - std::wstring(fileName).size()));
exePath.pop_back();
}
}
@ -1198,25 +1201,26 @@ std::string FileData::findEmulatorPath(std::string& command)
command.replace(0, endPos + 1, exePath);
return exePath;
}
#else
#else
exePath = Utils::FileSystem::getPathToBinary(path);
if (exePath != "") {
exePath += "/" + path;
command.replace(0, endPos + 1, exePath);
return exePath;
}
#endif
#endif
}
for (std::string path : emulatorStaticPaths) {
path = Utils::FileSystem::expandHomePath(path);
// If %ESPATH% is used for the rule, then expand it to the binary directory of ES-DE.
path = Utils::String::replace(path, "%ESPATH%", Utils::FileSystem::getExePath());
#if defined(_WIN64)
// Likewise for the %ROMPATH% variable which expands to the configured ROM directory.
path = Utils::String::replace(path, "%ROMPATH%", getROMDirectory());
#if defined(_WIN64)
path = Utils::String::replace(path, "/", "\\");
#endif
if (Utils::FileSystem::isRegularFile(path) ||
Utils::FileSystem::isSymlink(path)) {
#endif
if (Utils::FileSystem::isRegularFile(path) || Utils::FileSystem::isSymlink(path)) {
command.replace(0, endPos + 1, path);
return path;
}
@ -1226,9 +1230,9 @@ std::string FileData::findEmulatorPath(std::string& command)
// If %ESPATH% is used, then expand it to the binary directory of ES-DE.
command = Utils::String::replace(command, "%ESPATH%", Utils::FileSystem::getExePath());
#if defined(_WIN64)
#if defined(_WIN64)
command = Utils::String::replace(command, "/", "\\");
#endif
#endif
// If the first character is a quotation mark, then we need to extract up to the
// next quotation mark, otherwise we'll only extract up to the first space character.
@ -1240,23 +1244,23 @@ std::string FileData::findEmulatorPath(std::string& command)
emuExecutable = command.substr(0, command.find(' '));
}
#if defined(_WIN64)
#if defined(_WIN64)
std::wstring emuExecutableWide = Utils::String::stringToWideString(emuExecutable);
// Search for the emulator using the PATH environmental variable.
DWORD size = SearchPathW(nullptr, emuExecutableWide.c_str(), L".exe", 0, nullptr, nullptr);
if (size) {
std::vector<wchar_t> pathBuffer(static_cast<size_t>(size) + 1 );
std::vector<wchar_t> pathBuffer(static_cast<size_t>(size) + 1);
wchar_t* fileName = nullptr;
SearchPathW(nullptr, emuExecutableWide.c_str(), L".exe", size + 1 ,
pathBuffer.data(), &fileName);
SearchPathW(nullptr, emuExecutableWide.c_str(), L".exe", size + 1, pathBuffer.data(),
&fileName);
exePath = Utils::String::wideStringToString(pathBuffer.data());
}
#else
#else
if (Utils::FileSystem::isRegularFile(emuExecutable) ||
Utils::FileSystem::isSymlink(emuExecutable)) {
Utils::FileSystem::isSymlink(emuExecutable)) {
exePath = emuExecutable;
}
else {
@ -1264,14 +1268,16 @@ std::string FileData::findEmulatorPath(std::string& command)
if (exePath != "")
exePath += "/" + emuExecutable;
}
#endif
#endif
return exePath;
}
CollectionFileData::CollectionFileData(FileData* file, SystemData* system)
: FileData(file->getSourceFileData()->getType(), file->getSourceFileData()->getPath(),
file->getSourceFileData()->getSystemEnvData(), system)
: FileData(file->getSourceFileData()->getType(),
file->getSourceFileData()->getPath(),
file->getSourceFileData()->getSystemEnvData(),
system)
{
// We use this constructor to create a clone of the filedata, and change its system.
mSourceFileData = file->getSourceFileData();
@ -1289,15 +1295,6 @@ CollectionFileData::~CollectionFileData()
mParent = nullptr;
}
std::string CollectionFileData::getKey() {
return getFullPath();
}
FileData* CollectionFileData::getSourceFileData()
{
return mSourceFileData;
}
void CollectionFileData::refreshMetadata()
{
metadata = mSourceFileData->metadata;
@ -1308,9 +1305,9 @@ const std::string& CollectionFileData::getName()
{
if (mDirty) {
mCollectionFileName =
Utils::String::removeParenthesis(mSourceFileData->metadata.get("name"));
Utils::String::removeParenthesis(mSourceFileData->metadata.get("name"));
mCollectionFileName +=
" [" + Utils::String::toUpper(mSourceFileData->getSystem()->getName()) + "]";
" [" + Utils::String::toUpper(mSourceFileData->getSystem()->getName()) + "]";
mDirty = false;
}

69
es-app/src/FileData.h
View file

@ -11,8 +11,8 @@
#ifndef ES_APP_FILE_DATA_H
#define ES_APP_FILE_DATA_H
#include "utils/FileSystemUtil.h"
#include "MetaData.h"
#include "utils/FileSystemUtil.h"
#include <unordered_map>
@ -30,8 +30,10 @@ enum FileType {
class FileData
{
public:
FileData(FileType type, const std::string& path,
SystemEnvironmentData* envData, SystemData* system);
FileData(FileType type,
const std::string& path,
SystemEnvironmentData* envData,
SystemData* system);
virtual ~FileData();
@ -41,17 +43,19 @@ public:
const bool getKidgame();
const bool getHidden();
const bool getCountAsGame();
const std::pair<unsigned int, unsigned int> getGameCount() { return mGameCount; };
const std::pair<unsigned int, unsigned int> getGameCount() { return mGameCount; }
const bool getExcludeFromScraper();
const std::vector<FileData*> getChildrenRecursive() const;
inline FileType getType() const { return mType; }
inline const std::string& getPath() const { return mPath; }
inline FileData* getParent() const { return mParent; }
inline const std::unordered_map<std::string, FileData*>& getChildrenByFilename() const
{ return mChildrenByFilename; }
inline const std::vector<FileData*>& getChildren() const { return mChildren; }
inline SystemData* getSystem() const { return mSystem; }
inline SystemEnvironmentData* getSystemEnvData() const { return mEnvData; }
FileType getType() const { return mType; }
const std::string& getPath() const { return mPath; }
FileData* getParent() const { return mParent; }
const std::unordered_map<std::string, FileData*>& getChildrenByFilename() const
{
return mChildrenByFilename;
}
const std::vector<FileData*>& getChildren() const { return mChildren; }
SystemData* getSystem() const { return mSystem; }
SystemEnvironmentData* getSystemEnvData() const { return mEnvData; }
const bool getOnlyFoldersFlag() { return mOnlyFolders; }
const bool getHasFoldersFlag() { return mHasFolders; }
static const std::string getROMDirectory();
@ -66,29 +70,31 @@ public:
const std::string getThumbnailPath() const;
const std::string getVideoPath() const;
bool getDeletionFlag() { return mDeletionFlag; };
void setDeletionFlag(bool setting) { mDeletionFlag = setting; };
bool getDeletionFlag() { return mDeletionFlag; }
void setDeletionFlag(bool setting) { mDeletionFlag = setting; }
const std::vector<FileData*>& getChildrenListToDisplay();
std::vector<FileData*> getFilesRecursive(unsigned int typeMask,
bool displayedOnly = false, bool countAllGames = true) const;
std::vector<FileData*> getScrapeFilesRecursive(bool includeFolders, bool excludeRecursively,
bool respectExclusions) const;
bool displayedOnly = false,
bool countAllGames = true) const;
std::vector<FileData*> getScrapeFilesRecursive(bool includeFolders,
bool excludeRecursively,
bool respectExclusions) const;
void addChild(FileData* file); // Error if mType != FOLDER
void removeChild(FileData* file); //Error if mType != FOLDER
void removeChild(FileData* file); // Error if mType != FOLDER
inline bool isPlaceHolder() { return mType == PLACEHOLDER; };
bool isPlaceHolder() { return mType == PLACEHOLDER; }
virtual inline void refreshMetadata() { return; };
virtual void refreshMetadata() { return; }
virtual std::string getKey();
const bool isArcadeAsset();
const bool isArcadeGame();
inline std::string getFullPath() { return getPath(); };
inline std::string getFileName() { return Utils::FileSystem::getFileName(getPath()); };
std::string getFullPath() { return getPath(); }
std::string getFileName() { return Utils::FileSystem::getFileName(getPath()); }
virtual FileData* getSourceFileData();
inline std::string getSystemName() const { return mSystemName; };
std::string getSystemName() const { return mSystemName; }
// Returns our best guess at the "real" name for this file.
std::string getDisplayName() const;
@ -104,19 +110,22 @@ public:
ComparisonFunction* comparisonFunction;
std::string description;
SortType(ComparisonFunction* sortFunction, const std::string& sortDescription)
: comparisonFunction(sortFunction), description(sortDescription) {}
: comparisonFunction(sortFunction)
, description(sortDescription)
{
}
};
void sort(ComparisonFunction& comparator, std::pair<unsigned int, unsigned int>& gameCount);
void sortFavoritesOnTop(ComparisonFunction& comparator,
std::pair<unsigned int, unsigned int>& gameCount);
std::pair<unsigned int, unsigned int>& gameCount);
void sort(const SortType& type, bool mFavoritesOnTop = false);
MetaDataList metadata;
// Only count the games, a cheaper alternative to a full sort when that is not required.
void countGames(std::pair<unsigned int, unsigned int>& gameCount);
inline void setSortTypeString(std::string typestring) { mSortTypeString = typestring; }
inline std::string getSortTypeString() { return mSortTypeString; }
void setSortTypeString(std::string typestring) { mSortTypeString = typestring; }
std::string getSortTypeString() { return mSortTypeString; }
FileData::SortType getSortTypeFromString(std::string desc);
protected:
@ -130,7 +139,7 @@ private:
std::string mPath;
SystemEnvironmentData* mEnvData;
SystemData* mSystem;
std::unordered_map<std::string,FileData*> mChildrenByFilename;
std::unordered_map<std::string, FileData*> mChildrenByFilename;
std::vector<FileData*> mChildren;
std::vector<FileData*> mFilteredChildren;
// The pair includes all games, and favorite games.
@ -148,8 +157,8 @@ public:
~CollectionFileData();
const std::string& getName();
void refreshMetadata();
FileData* getSourceFileData();
std::string getKey();
FileData* getSourceFileData() { return mSourceFileData; }
std::string getKey() { return getFullPath(); }
private:
// Needs to be updated when metadata changes.

133
es-app/src/FileFilterIndex.cpp
View file

@ -8,12 +8,12 @@
#include "FileFilterIndex.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include "views/UIModeController.h"
#include "FileData.h"
#include "Log.h"
#include "Settings.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include "views/UIModeController.h"
#include <cmath>
@ -21,19 +21,20 @@
#define INCLUDE_UNKNOWN false;
FileFilterIndex::FileFilterIndex()
: mFilterByText(false),
mFilterByFavorites(false),
mFilterByGenre(false),
mFilterByPlayers(false),
mFilterByPubDev(false),
mFilterByRatings(false),
mFilterByKidGame(false),
mFilterByCompleted(false),
mFilterByBroken(false),
mFilterByHidden(false)
: mFilterByText(false)
, mFilterByFavorites(false)
, mFilterByGenre(false)
, mFilterByPlayers(false)
, mFilterByPubDev(false)
, mFilterByRatings(false)
, mFilterByKidGame(false)
, mFilterByCompleted(false)
, mFilterByBroken(false)
, mFilterByHidden(false)
{
clearAllFilters();
// clang-format off
FilterDataDecl filterDecls[] = {
//type //allKeys //filteredBy //filteredKeys //primaryKey //hasSecondaryKey //secondaryKey //menuLabel
{ FAVORITES_FILTER, &mFavoritesIndexAllKeys, &mFilterByFavorites, &mFavoritesIndexFilteredKeys, "favorite", false, "", "FAVORITES" },
@ -46,21 +47,18 @@ FileFilterIndex::FileFilterIndex()
{ BROKEN_FILTER, &mBrokenIndexAllKeys, &mFilterByBroken, &mBrokenIndexFilteredKeys, "broken", false, "", "BROKEN" },
{ HIDDEN_FILTER, &mHiddenIndexAllKeys, &mFilterByHidden, &mHiddenIndexFilteredKeys, "hidden", false, "", "HIDDEN" }
};
// clang-format on
filterDataDecl = std::vector<FilterDataDecl>(filterDecls, filterDecls +
sizeof(filterDecls) / sizeof(filterDecls[0]));
filterDataDecl = std::vector<FilterDataDecl>(
filterDecls, filterDecls + sizeof(filterDecls) / sizeof(filterDecls[0]));
}
FileFilterIndex::~FileFilterIndex()
{
// Reset the index when destroyed.
resetIndex();
}
std::vector<FilterDataDecl>& FileFilterIndex::getFilterDataDecls()
{
return filterDataDecl;
}
void FileFilterIndex::importIndex(FileFilterIndex* indexToImport)
{
struct IndexImportStructure {
@ -80,22 +78,23 @@ void FileFilterIndex::importIndex(FileFilterIndex* indexToImport)
{ &mHiddenIndexAllKeys, &(indexToImport->mHiddenIndexAllKeys) },
};
std::vector<IndexImportStructure> indexImportDecl =
std::vector<IndexImportStructure>(indexStructDecls, indexStructDecls +
sizeof(indexStructDecls) / sizeof(indexStructDecls[0]));
std::vector<IndexImportStructure> indexImportDecl = std::vector<IndexImportStructure>(
indexStructDecls,
indexStructDecls + sizeof(indexStructDecls) / sizeof(indexStructDecls[0]));
for (std::vector<IndexImportStructure>::const_iterator indexesIt =
indexImportDecl.cbegin(); indexesIt != indexImportDecl.cend(); indexesIt++)
{
for (std::vector<IndexImportStructure>::const_iterator indexesIt = indexImportDecl.cbegin();
indexesIt != indexImportDecl.cend(); indexesIt++) {
for (std::map<std::string, int>::const_iterator sourceIt =
(*indexesIt).sourceIndex->cbegin(); sourceIt !=
(*indexesIt).sourceIndex->cend(); sourceIt++) {
(*indexesIt).sourceIndex->cbegin();
sourceIt != (*indexesIt).sourceIndex->cend(); sourceIt++) {
if ((*indexesIt).destinationIndex->find((*sourceIt).first) ==
(*indexesIt).destinationIndex->cend())
(*indexesIt).destinationIndex->cend()) {
// Entry doesn't exist.
(*((*indexesIt).destinationIndex))[(*sourceIt).first] = (*sourceIt).second;
else
}
else {
(*((*indexesIt).destinationIndex))[(*sourceIt).first] += (*sourceIt).second;
}
}
}
}
@ -115,7 +114,8 @@ void FileFilterIndex::resetIndex()
}
std::string FileFilterIndex::getIndexableKey(FileData* game,
FilterIndexType type, bool getSecondary)
FilterIndexType type,
bool getSecondary)
{
std::string key = "";
switch (type) {
@ -166,8 +166,8 @@ std::string FileFilterIndex::getIndexableKey(FileData* game,
// These values should only exist if a third party application has
// been used for scraping the ratings, or if the gamelist.xml file
// has been manually edited.
ratingNumber = static_cast<int>(
(ceilf(stof(ratingString) / 0.1f) / 10) * 5);
ratingNumber =
static_cast<int>((ceilf(stof(ratingString) / 0.1f) / 10.0f) * 5.0f);
if (ratingNumber < 0)
ratingNumber = 0;
@ -176,11 +176,11 @@ std::string FileFilterIndex::getIndexableKey(FileData* game,
key = "5 STARS";
else
key = std::to_string(ratingNumber) + " - " +
std::to_string(ratingNumber) + ".5 STARS";
std::to_string(ratingNumber) + ".5 STARS";
}
catch (int e) {
LOG(LogError) << "Error parsing Rating (invalid value, exception nr.): " <<
ratingString << ", " << e;
LOG(LogError) << "Error parsing Rating (invalid value, exception nr.): "
<< ratingString << ", " << e;
}
}
}
@ -254,13 +254,13 @@ void FileFilterIndex::setFilter(FilterIndexType type, std::vector<std::string>*
}
else {
for (std::vector<FilterDataDecl>::const_iterator it = filterDataDecl.cbegin();
it != filterDataDecl.cend(); it++) {
it != filterDataDecl.cend(); it++) {
if ((*it).type == type) {
FilterDataDecl filterData = (*it);
*(filterData.filteredByRef) = values->size() > 0;
filterData.currentFilteredKeys->clear();
for (std::vector<std::string>::const_iterator vit =
values->cbegin(); vit != values->cend(); vit++) {
for (std::vector<std::string>::const_iterator vit = values->cbegin();
vit != values->cend(); vit++) {
// Check if it exists.
if (filterData.allIndexKeys->find(*vit) != filterData.allIndexKeys->cend()) {
filterData.currentFilteredKeys->push_back(std::string(*vit));
@ -272,20 +272,20 @@ void FileFilterIndex::setFilter(FilterIndexType type, std::vector<std::string>*
return;
}
void FileFilterIndex::setTextFilter(std::string textFilter)
{
void FileFilterIndex::setTextFilter(std::string textFilter)
{
mTextFilter = textFilter;
if (textFilter == "")
mFilterByText = false;
else
mFilterByText = true;
};
};
void FileFilterIndex::clearAllFilters()
{
for (std::vector<FilterDataDecl>::const_iterator it = filterDataDecl.cbegin();
it != filterDataDecl.cend(); it++) {
it != filterDataDecl.cend(); it++) {
FilterDataDecl filterData = (*it);
*(filterData.filteredByRef) = false;
filterData.currentFilteredKeys->clear();
@ -312,19 +312,19 @@ void FileFilterIndex::setKidModeFilters()
void FileFilterIndex::debugPrintIndexes()
{
LOG(LogInfo) << "Printing Indexes...";
for (auto x: mFavoritesIndexAllKeys) {
for (auto x : mFavoritesIndexAllKeys) {
LOG(LogInfo) << "Favorites Index: " << x.first << ": " << x.second;
}
for (auto x: mGenreIndexAllKeys) {
for (auto x : mGenreIndexAllKeys) {
LOG(LogInfo) << "Genre Index: " << x.first << ": " << x.second;
}
for (auto x: mPlayersIndexAllKeys) {
for (auto x : mPlayersIndexAllKeys) {
LOG(LogInfo) << "Multiplayer Index: " << x.first << ": " << x.second;
}
for (auto x: mPubDevIndexAllKeys) {
for (auto x : mPubDevIndexAllKeys) {
LOG(LogInfo) << "PubDev Index: " << x.first << ": " << x.second;
}
for (auto x: mRatingsIndexAllKeys) {
for (auto x : mRatingsIndexAllKeys) {
LOG(LogInfo) << "Ratings Index: " << x.first << ": " << x.second;
}
for (auto x : mKidGameIndexAllKeys) {
@ -348,8 +348,8 @@ bool FileFilterIndex::showFile(FileData* game)
if (game->getType() == FOLDER) {
std::vector<FileData*> children = game->getChildren();
// Iterate through all of the children, until there's a match.
for (std::vector<FileData*>::const_iterator it = children.cbegin();
it != children.cend(); it++) {
for (std::vector<FileData*>::const_iterator it = children.cbegin(); it != children.cend();
it++) {
if (showFile(*it))
return true;
}
@ -361,8 +361,8 @@ bool FileFilterIndex::showFile(FileData* game)
// Name filters take precedence over all other filters, so if there is no match for
// the game name, then always return false.
if (mTextFilter != "" && !(Utils::String::toUpper(game->
getName()).find(mTextFilter) != std::string::npos)) {
if (mTextFilter != "" &&
!(Utils::String::toUpper(game->getName()).find(mTextFilter) != std::string::npos)) {
return false;
}
else if (mTextFilter != "") {
@ -370,7 +370,7 @@ bool FileFilterIndex::showFile(FileData* game)
}
for (std::vector<FilterDataDecl>::const_iterator it = filterDataDecl.cbegin();
it != filterDataDecl.cend(); it++) {
it != filterDataDecl.cend(); it++) {
FilterDataDecl filterData = (*it);
if (filterData.primaryKey == "kidgame" && UIModeController::getInstance()->isUIModeKid()) {
return (getIndexableKey(game, filterData.type, false) != "FALSE");
@ -419,18 +419,19 @@ bool FileFilterIndex::isFiltered()
bool FileFilterIndex::isKeyBeingFilteredBy(std::string key, FilterIndexType type)
{
const FilterIndexType filterTypes[9] = { FAVORITES_FILTER, GENRE_FILTER,
PLAYER_FILTER, PUBDEV_FILTER, RATINGS_FILTER, KIDGAME_FILTER,
COMPLETED_FILTER, BROKEN_FILTER, HIDDEN_FILTER };
std::vector<std::string> filterKeysList[9] = { mFavoritesIndexFilteredKeys,
mGenreIndexFilteredKeys, mPlayersIndexFilteredKeys, mPubDevIndexFilteredKeys,
mRatingsIndexFilteredKeys, mKidGameIndexFilteredKeys, mCompletedIndexFilteredKeys,
mBrokenIndexFilteredKeys, mHiddenIndexFilteredKeys };
const FilterIndexType filterTypes[9] = { FAVORITES_FILTER, GENRE_FILTER, PLAYER_FILTER,
PUBDEV_FILTER, RATINGS_FILTER, KIDGAME_FILTER,
COMPLETED_FILTER, BROKEN_FILTER, HIDDEN_FILTER };
std::vector<std::string> filterKeysList[9] = {
mFavoritesIndexFilteredKeys, mGenreIndexFilteredKeys, mPlayersIndexFilteredKeys,
mPubDevIndexFilteredKeys, mRatingsIndexFilteredKeys, mKidGameIndexFilteredKeys,
mCompletedIndexFilteredKeys, mBrokenIndexFilteredKeys, mHiddenIndexFilteredKeys
};
for (int i = 0; i < 9; i++) {
if (filterTypes[i] == type) {
for (std::vector<std::string>::const_iterator it = filterKeysList[i].cbegin();
it != filterKeysList[i].cend(); it++) {
it != filterKeysList[i].cend(); it++) {
if (key == (*it))
return true;
}
@ -589,7 +590,8 @@ void FileFilterIndex::manageHiddenEntryInIndex(FileData* game, bool remove)
}
void FileFilterIndex::manageIndexEntry(std::map<std::string, int>* index,
std::string key, bool remove)
std::string key,
bool remove)
{
bool includeUnknown = INCLUDE_UNKNOWN;
if (!includeUnknown && key == UNKNOWN_LABEL)
@ -600,7 +602,7 @@ void FileFilterIndex::manageIndexEntry(std::map<std::string, int>* index,
if (index->find(key) == index->cend()) {
// Disabled for now as this could happen because default values are assigned as
// filters, for example 'FALSE' for favorites and kidgames for non-game entries.
// LOG(LogDebug) << "Couldn't find entry in index! " << key;
// LOG(LogDebug) << "Couldn't find entry in index! " << key;
}
else {
(index->at(key))--;
@ -617,8 +619,3 @@ void FileFilterIndex::manageIndexEntry(std::map<std::string, int>* index,
(index->at(key))++;
}
}
void FileFilterIndex::clearIndex(std::map<std::string, int>& indexMap)
{
indexMap.clear();
}

7
es-app/src/FileFilterIndex.h
View file

@ -52,13 +52,13 @@ public:
void removeFromIndex(FileData* game);
void setFilter(FilterIndexType type, std::vector<std::string>* values);
void setTextFilter(std::string textFilter);
std::string getTextFilter() { return mTextFilter; };
std::string getTextFilter() { return mTextFilter; }
void clearAllFilters();
void debugPrintIndexes();
bool showFile(FileData* game);
bool isFiltered();
bool isKeyBeingFilteredBy(std::string key, FilterIndexType type);
std::vector<FilterDataDecl>& getFilterDataDecls();
std::vector<FilterDataDecl>& getFilterDataDecls() { return filterDataDecl; }
void importIndex(FileFilterIndex* indexToImport);
void resetIndex();
@ -81,7 +81,7 @@ private:
void manageIndexEntry(std::map<std::string, int>* index, std::string key, bool remove);
void clearIndex(std::map<std::string, int>& indexMap);
void clearIndex(std::map<std::string, int>& indexMap) { indexMap.clear(); }
std::string mTextFilter;
bool mFilterByText;
@ -117,7 +117,6 @@ private:
std::vector<std::string> mHiddenIndexFilteredKeys;
FileData* mRootFolder;
};
#endif // ES_APP_FILE_FILTER_INDEX_H

26
es-app/src/FileSorts.cpp
View file

@ -48,8 +48,9 @@ namespace FileSorts
FileData::SortType(&compareSystemDescending, "system, descending")
};
const std::vector<FileData::SortType> SortTypes(typesArr, typesArr +
sizeof(typesArr)/sizeof(typesArr[0]));
const std::vector<FileData::SortType> SortTypes(typesArr,
typesArr +
sizeof(typesArr) / sizeof(typesArr[0]));
bool compareName(const FileData* file1, const FileData* file2)
{
@ -155,11 +156,13 @@ namespace FileSorts
file2Players = file2Players.substr(dashPos + 1, file2Players.size() - dashPos - 1);
// Any non-numeric value will end up as zero.
if (!file1Players.empty() &&
std::all_of(file1Players.begin(), file1Players.end(), ::isdigit))
std::all_of(file1Players.begin(), file1Players.end(), ::isdigit)) {
file1Int = stoi(file1Players);
}
if (!file2Players.empty() &&
std::all_of(file2Players.begin(), file2Players.end(), ::isdigit))
std::all_of(file2Players.begin(), file2Players.end(), ::isdigit)) {
file2Int = stoi(file2Players);
}
return file1Int < file2Int;
}
@ -177,11 +180,13 @@ namespace FileSorts
if (dashPos != std::string::npos)
file2Players = file2Players.substr(dashPos + 1, file2Players.size() - dashPos - 1);
if (!file1Players.empty() &&
std::all_of(file1Players.begin(), file1Players.end(), ::isdigit))
std::all_of(file1Players.begin(), file1Players.end(), ::isdigit)) {
file1Int = stoi(file1Players);
}
if (!file2Players.empty() &&
std::all_of(file2Players.begin(), file2Players.end(), ::isdigit))
std::all_of(file2Players.begin(), file2Players.end(), ::isdigit)) {
file2Int = stoi(file2Players);
}
return file1Int > file2Int;
}
@ -201,16 +206,18 @@ namespace FileSorts
{
// Only games have playcount metadata.
if (file1->metadata.getType() == GAME_METADATA &&
file2->metadata.getType() == GAME_METADATA)
file2->metadata.getType() == GAME_METADATA) {
return (file1)->metadata.getInt("playcount") < (file2)->metadata.getInt("playcount");
}
return false;
}
bool compareTimesPlayedDescending(const FileData* file1, const FileData* file2)
{
if (file1->metadata.getType() == GAME_METADATA &&
file2->metadata.getType() == GAME_METADATA)
file2->metadata.getType() == GAME_METADATA) {
return (file1)->metadata.getInt("playcount") > (file2)->metadata.getInt("playcount");
}
return false;
}
@ -227,4 +234,5 @@ namespace FileSorts
std::string system2 = Utils::String::toUpper(file2->getSystemName());
return system1.compare(system2) > 0;
}
};
}; // namespace FileSorts

2
es-app/src/FileSorts.h
View file

@ -38,6 +38,6 @@ namespace FileSorts
bool compareSystemDescending(const FileData* file1, const FileData* file2);
extern const std::vector<FileData::SortType> SortTypes;
};
}; // namespace FileSorts
#endif // ES_APP_FILE_SORTS_H

122
es-app/src/Gamelist.cpp
View file

@ -8,12 +8,12 @@
#include "Gamelist.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "FileData.h"
#include "Log.h"
#include "Settings.h"
#include "SystemData.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include <pugixml.hpp>
@ -25,8 +25,8 @@ FileData* findOrCreateFile(SystemData* system, const std::string& path, FileType
std::string relative = Utils::FileSystem::removeCommonPath(path, root->getPath(), contains);
if (!contains) {
LOG(LogError) << "Path \"" << path << "\" is outside system path \"" <<
system->getStartPath() << "\"";
LOG(LogError) << "Path \"" << path << "\" is outside system path \""
<< system->getStartPath() << "\"";
return nullptr;
}
@ -36,7 +36,7 @@ FileData* findOrCreateFile(SystemData* system, const std::string& path, FileType
bool found = false;
while (path_it != pathList.end()) {
const std::unordered_map<std::string, FileData*>& children =
treeNode->getChildrenByFilename();
treeNode->getChildrenByFilename();
std::string key = *path_it;
found = children.find(key) != children.cend();
@ -71,8 +71,9 @@ FileData* findOrCreateFile(SystemData* system, const std::string& path, FileType
}
// Create missing folder.
FileData* folder = new FileData(FOLDER, Utils::FileSystem::getStem(treeNode->getPath())
+ "/" + *path_it, system->getSystemEnvData(), system);
FileData* folder = new FileData(
FOLDER, Utils::FileSystem::getStem(treeNode->getPath()) + "/" + *path_it,
system->getSystemEnvData(), system);
treeNode->addChild(folder);
treeNode = folder;
}
@ -89,24 +90,24 @@ void parseGamelist(SystemData* system)
std::string xmlpath = system->getGamelistPath(false);
if (!Utils::FileSystem::exists(xmlpath)) {
LOG(LogDebug) << "Gamelist::parseGamelist(): System \"" << system->getName() <<
"\" does not have a gamelist.xml file";
LOG(LogDebug) << "Gamelist::parseGamelist(): System \"" << system->getName()
<< "\" does not have a gamelist.xml file";
return;
}
LOG(LogInfo) << "Parsing gamelist file \"" << xmlpath << "\"...";
pugi::xml_document doc;
#if defined(_WIN64)
#if defined(_WIN64)
pugi::xml_parse_result result =
doc.load_file(Utils::String::stringToWideString(xmlpath).c_str());
#else
doc.load_file(Utils::String::stringToWideString(xmlpath).c_str());
#else
pugi::xml_parse_result result = doc.load_file(xmlpath.c_str());
#endif
#endif
if (!result) {
LOG(LogError) << "Error parsing gamelist file \"" << xmlpath <<
"\": " << result.description();
LOG(LogError) << "Error parsing gamelist file \"" << xmlpath
<< "\": " << result.description();
return;
}
@ -124,24 +125,24 @@ void parseGamelist(SystemData* system)
for (int i = 0; i < 2; i++) {
std::string tag = tagList[i];
FileType type = typeList[i];
for (pugi::xml_node fileNode = root.child(tag.c_str()); fileNode; fileNode =
fileNode.next_sibling(tag.c_str())) {
const std::string path =
Utils::FileSystem::resolveRelativePath(fileNode.child("path").text().get(),
relativeTo, false);
for (pugi::xml_node fileNode = root.child(tag.c_str()); fileNode;
fileNode = fileNode.next_sibling(tag.c_str())) {
const std::string path = Utils::FileSystem::resolveRelativePath(
fileNode.child("path").text().get(), relativeTo, false);
if (!trustGamelist && !Utils::FileSystem::exists(path)) {
LOG(LogWarning) << (type == GAME ? "File \"" : "Folder \"") << path <<
"\" does not exist, ignoring entry";
LOG(LogWarning) << (type == GAME ? "File \"" : "Folder \"") << path
<< "\" does not exist, ignoring entry";
continue;
}
// Skip hidden files, check both the file itself and the directory in which
// it is located.
if (!showHiddenFiles && (Utils::FileSystem::isHidden(path) ||
Utils::FileSystem::isHidden(Utils::FileSystem::getParent(path)))) {
LOG(LogDebug) << "Gamelist::parseGamelist(): Skipping hidden file \"" <<
path << "\"";
if (!showHiddenFiles &&
(Utils::FileSystem::isHidden(path) ||
Utils::FileSystem::isHidden(Utils::FileSystem::getParent(path)))) {
LOG(LogDebug) << "Gamelist::parseGamelist(): Skipping hidden file \"" << path
<< "\"";
continue;
}
@ -163,8 +164,8 @@ void parseGamelist(SystemData* system)
else {
// Skip arcade asset entries as these will not be used in any way inside
// the application.
LOG(LogDebug) << "Gamelist::parseGamelist(): Skipping arcade asset \"" <<
file->getName() << "\"";
LOG(LogDebug) << "Gamelist::parseGamelist(): Skipping arcade asset \""
<< file->getName() << "\"";
delete file;
continue;
}
@ -174,9 +175,10 @@ void parseGamelist(SystemData* system)
// application restart.
if (!Settings::getInstance()->getBool("ShowHiddenGames")) {
if (file->getHidden()) {
LOG(LogDebug) << "Gamelist::parseGamelist(): Skipping hidden " <<
(type == GAME ? "file" : "folder") << " entry \"" <<
file->getName() << "\"" << " (\"" << file->getPath() << "\")";
LOG(LogDebug) << "Gamelist::parseGamelist(): Skipping hidden "
<< (type == GAME ? "file" : "folder") << " entry \""
<< file->getName() << "\""
<< " (\"" << file->getPath() << "\")";
delete file;
}
// Also delete any folders which are empty, i.e. all their entries are hidden.
@ -188,8 +190,10 @@ void parseGamelist(SystemData* system)
}
}
void addFileDataNode(pugi::xml_node& parent, const FileData* file,
const std::string& tag, SystemData* system)
void addFileDataNode(pugi::xml_node& parent,
const FileData* file,
const std::string& tag,
SystemData* system)
{
// Create game and add to parent node.
pugi::xml_node newNode = parent.append_child(tag.c_str());
@ -199,8 +203,8 @@ void addFileDataNode(pugi::xml_node& parent, const FileData* file,
// First element is "name", there's only one element and the name is the default.
if (newNode.children().begin() == newNode.child("name") &&
++newNode.children().begin() == newNode.children().end() &&
newNode.child("name").text().get() == file->getDisplayName()) {
++newNode.children().begin() == newNode.children().end() &&
newNode.child("name").text().get() == file->getDisplayName()) {
// If the only info is the default name, don't bother
// with this node, delete it and ultimately do nothing.
@ -211,8 +215,9 @@ void addFileDataNode(pugi::xml_node& parent, const FileData* file,
// Try and make the path relative if we can so things still
// work if we change the ROM folder location in the future.
newNode.prepend_child("path").text().set(Utils::FileSystem::createRelativePath(file->
getPath(), system->getStartPath(), false).c_str());
newNode.prepend_child("path").text().set(
Utils::FileSystem::createRelativePath(file->getPath(), system->getStartPath(), false)
.c_str());
}
}
@ -232,23 +237,23 @@ void updateGamelist(SystemData* system)
if (Utils::FileSystem::exists(xmlReadPath)) {
// Parse an existing file first.
#if defined(_WIN64)
#if defined(_WIN64)
pugi::xml_parse_result result =
doc.load_file(Utils::String::stringToWideString(xmlReadPath).c_str());
#else
doc.load_file(Utils::String::stringToWideString(xmlReadPath).c_str());
#else
pugi::xml_parse_result result = doc.load_file(xmlReadPath.c_str());
#endif
#endif
if (!result) {
LOG(LogError) << "Error parsing gamelist file \"" << xmlReadPath << "\": " <<
result.description();
LOG(LogError) << "Error parsing gamelist file \"" << xmlReadPath
<< "\": " << result.description();
return;
}
root = doc.child("gameList");
if (!root) {
LOG(LogError) << "Couldn't find <gameList> node in gamelist \"" <<
xmlReadPath << "\"";
LOG(LogError) << "Couldn't find <gameList> node in gamelist \"" << xmlReadPath << "\"";
return;
}
}
@ -266,8 +271,8 @@ void updateGamelist(SystemData* system)
// Get only files, no folders.
std::vector<FileData*> files = rootFolder->getFilesRecursive(GAME | FOLDER);
// Iterate through all files, checking if they're already in the XML file.
for (std::vector<FileData*>::const_iterator fit = files.cbegin();
fit != files.cend(); fit++) {
for (std::vector<FileData*>::const_iterator fit = files.cbegin(); // Line break.
fit != files.cend(); fit++) {
const std::string tag = ((*fit)->getType() == GAME) ? "game" : "folder";
// Do not touch if it wasn't changed and is not flagged for deletion.
@ -277,16 +282,16 @@ void updateGamelist(SystemData* system)
// Check if the file already exists in the XML file.
// If it does, remove the entry before adding it back.
for (pugi::xml_node fileNode = root.child(tag.c_str()); fileNode;
fileNode = fileNode.next_sibling(tag.c_str())) {
fileNode = fileNode.next_sibling(tag.c_str())) {
pugi::xml_node pathNode = fileNode.child("path");
if (!pathNode) {
LOG(LogError) << "<" << tag << "> node contains no <path> child";
continue;
}
std::string nodePath =Utils::FileSystem::getCanonicalPath(
Utils::FileSystem::resolveRelativePath(pathNode.text().get(),
system->getStartPath(), true));
std::string nodePath =
Utils::FileSystem::getCanonicalPath(Utils::FileSystem::resolveRelativePath(
pathNode.text().get(), system->getStartPath(), true));
std::string gamePath = Utils::FileSystem::getCanonicalPath((*fit)->getPath());
if (nodePath == gamePath) {
@ -312,16 +317,17 @@ void updateGamelist(SystemData* system)
std::string xmlWritePath(system->getGamelistPath(true));
Utils::FileSystem::createDirectory(Utils::FileSystem::getParent(xmlWritePath));
LOG(LogDebug) << "Gamelist::updateGamelist(): Added/updated " << numUpdated <<
(numUpdated == 1 ? " entity in \"" : " entities in \"") << xmlReadPath << "\"";
LOG(LogDebug) << "Gamelist::updateGamelist(): Added/updated " << numUpdated
<< (numUpdated == 1 ? " entity in \"" : " entities in \"") << xmlReadPath
<< "\"";
#if defined(_WIN64)
#if defined(_WIN64)
if (!doc.save_file(Utils::String::stringToWideString(xmlWritePath).c_str())) {
#else
#else
if (!doc.save_file(xmlWritePath.c_str())) {
#endif
LOG(LogError) << "Error saving gamelist.xml to \"" <<
xmlWritePath << "\" (for system " << system->getName() << ")";
#endif
LOG(LogError) << "Error saving gamelist.xml to \"" << xmlWritePath
<< "\" (for system " << system->getName() << ")";
}
}
}

35
es-app/src/MediaViewer.cpp
View file

@ -12,11 +12,14 @@
#if defined(BUILD_VLC_PLAYER)
#include "components/VideoVlcComponent.h"
#endif
#include "views/ViewController.h"
#include "AudioManager.h"
#include "Sound.h"
#include "views/ViewController.h"
MediaViewer::MediaViewer(Window* window) : mWindow(window), mVideo(nullptr), mImage(nullptr)
MediaViewer::MediaViewer(Window* window)
: mWindow(window)
, mVideo(nullptr)
, mImage(nullptr)
{
mWindow->setMediaViewer(this);
}
@ -85,12 +88,12 @@ void MediaViewer::render()
// Render a black background below the game media.
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
if (mVideo && !mDisplayingImage) {
mVideo->render(transform);
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
Renderer::shaderParameters videoParameters;
unsigned int shaders = 0;
if (Settings::getInstance()->getBool("MediaViewerVideoScanlines"))
@ -98,6 +101,7 @@ void MediaViewer::render()
if (Settings::getInstance()->getBool("MediaViewerVideoBlur")) {
shaders |= Renderer::SHADER_BLUR_HORIZONTAL;
float heightModifier = Renderer::getScreenHeightModifier();
// clang-format off
if (heightModifier < 1)
videoParameters.blurPasses = 2; // Below 1080
else if (heightModifier >= 4)
@ -112,18 +116,19 @@ void MediaViewer::render()
videoParameters.blurPasses = 3; // 1440
else if (heightModifier >= 1)
videoParameters.blurPasses = 2; // 1080
// clang-format on
}
Renderer::shaderPostprocessing(shaders, videoParameters);
#endif
#endif
}
else if (mImage && mImage->hasImage()) {
else if (mImage && mImage->hasImage() && mImage->getSize() != 0) {
mImage->render(transform);
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
if (mCurrentImageIndex == mScreenShotIndex &&
Settings::getInstance()->getBool("MediaViewerScreenshotScanlines"))
Settings::getInstance()->getBool("MediaViewerScreenshotScanlines"))
Renderer::shaderPostprocessing(Renderer::SHADER_SCANLINES);
#endif
#endif
// This is necessary so that the video loops if viewing an image when
// the video ends.
@ -244,14 +249,14 @@ void MediaViewer::playVideo()
mDisplayingImage = false;
ViewController::get()->onStopVideo();
#if defined(BUILD_VLC_PLAYER)
#if defined(BUILD_VLC_PLAYER)
if (Settings::getInstance()->getString("VideoPlayer") == "ffmpeg")
mVideo = new VideoFFmpegComponent(mWindow);
else
mVideo = new VideoVlcComponent(mWindow);
#else
#else
mVideo = new VideoFFmpegComponent(mWindow);
#endif
#endif
mVideo->topWindow(true);
mVideo->setOrigin(0.5f, 0.5f);
@ -259,10 +264,10 @@ void MediaViewer::playVideo()
if (Settings::getInstance()->getBool("MediaViewerStretchVideos"))
mVideo->setResize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
else
mVideo->setMaxSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
mVideo->setVideo(mVideoFile);
mVideo->setMediaViewerMode(true);
@ -282,6 +287,6 @@ void MediaViewer::showImage(int index)
mImage->setOrigin(0.5f, 0.5f);
mImage->setPosition(Renderer::getScreenWidth() / 2.0f, Renderer::getScreenHeight() / 2.0f);
mImage->setMaxSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
}
}

4
es-app/src/MediaViewer.h
View file

@ -9,10 +9,10 @@
#ifndef ES_APP_MEDIA_VIEWER_H
#define ES_APP_MEDIA_VIEWER_H
#include "components/ImageComponent.h"
#include "components/VideoComponent.h"
#include "FileData.h"
#include "Window.h"
#include "components/ImageComponent.h"
#include "components/VideoComponent.h"
class MediaViewer : public Window::MediaViewer
{

37
es-app/src/MetaData.cpp
View file

@ -9,11 +9,12 @@
#include "MetaData.h"
#include "utils/FileSystemUtil.h"
#include "Log.h"
#include "utils/FileSystemUtil.h"
#include <pugixml.hpp>
// clang-format off
MetaDataDecl gameDecls[] = {
// key, type, default, statistic, name in GuiMetaDataEd, prompt in GuiMetaDataEd, shouldScrape
{"name", MD_STRING, "", false, "name", "enter name", true},
@ -39,9 +40,6 @@ MetaDataDecl gameDecls[] = {
{"lastplayed", MD_TIME, "0", true, "last played", "enter last played date", false}
};
const std::vector<MetaDataDecl> gameMDD(gameDecls, gameDecls +
sizeof(gameDecls) / sizeof(gameDecls[0]));
MetaDataDecl folderDecls[] = {
{"name", MD_STRING, "", false, "name", "enter name", true},
{"desc", MD_MULTILINE_STRING, "", false, "description", "enter description", true},
@ -59,13 +57,18 @@ MetaDataDecl folderDecls[] = {
{"hidemetadata", MD_BOOL, "false", false, "hide metadata fields", "enter hide metadata off/on", false},
{"lastplayed", MD_TIME, "0", true, "last played", "enter last played date", false}
};
// clang-format on
const std::vector<MetaDataDecl> folderMDD(folderDecls, folderDecls +
sizeof(folderDecls) / sizeof(folderDecls[0]));
const std::vector<MetaDataDecl> gameMDD(gameDecls,
gameDecls + sizeof(gameDecls) / sizeof(gameDecls[0]));
const std::vector<MetaDataDecl> folderMDD(folderDecls,
folderDecls +
sizeof(folderDecls) / sizeof(folderDecls[0]));
const std::vector<MetaDataDecl>& getMDDByType(MetaDataListType type)
{
switch(type) {
switch (type) {
case GAME_METADATA:
return gameMDD;
case FOLDER_METADATA:
@ -77,7 +80,8 @@ const std::vector<MetaDataDecl>& getMDDByType(MetaDataListType type)
}
MetaDataList::MetaDataList(MetaDataListType type)
: mType(type), mWasChanged(false)
: mType(type)
, mWasChanged(false)
{
const std::vector<MetaDataDecl>& mdd = getMDD();
for (auto iter = mdd.cbegin(); iter != mdd.cend(); iter++)
@ -85,7 +89,8 @@ MetaDataList::MetaDataList(MetaDataListType type)
}
MetaDataList MetaDataList::createFromXML(MetaDataListType type,
pugi::xml_node& node, const std::string& relativeTo)
pugi::xml_node& node,
const std::string& relativeTo)
{
MetaDataList mdl(type);
@ -107,8 +112,9 @@ MetaDataList MetaDataList::createFromXML(MetaDataListType type,
return mdl;
}
void MetaDataList::appendToXML(pugi::xml_node& parent, bool ignoreDefaults,
const std::string& relativeTo) const
void MetaDataList::appendToXML(pugi::xml_node& parent,
bool ignoreDefaults,
const std::string& relativeTo) const
{
const std::vector<MetaDataDecl>& mdd = getMDD();
@ -138,30 +144,33 @@ void MetaDataList::set(const std::string& key, const std::string& value)
const std::string& MetaDataList::get(const std::string& key) const
{
// Check that the key actually exists, otherwise return empty string.
// Check that the key actually exists, otherwise return an empty string.
if (mMap.count(key) > 0)
return mMap.at(key);
else
return mNoResult;
return mNoResult;
}
int MetaDataList::getInt(const std::string& key) const
{
// Return integer value.
return atoi(get(key).c_str());
}
float MetaDataList::getFloat(const std::string& key) const
{
// Return float value.
return static_cast<float>(atof(get(key).c_str()));
}
bool MetaDataList::wasChanged() const
{
// Return whether the metadata was changed.
return mWasChanged;
}
void MetaDataList::resetChangedFlag()
{
// Reset the change flag.
mWasChanged = false;
}

27
es-app/src/MetaData.h
View file

@ -18,7 +18,10 @@
#include <string>
#include <vector>
namespace pugi { class xml_node; }
namespace pugi
{
class xml_node;
}
enum MetaDataType {
// Generic types.
@ -40,7 +43,7 @@ struct MetaDataDecl {
std::string key;
MetaDataType type;
std::string defaultValue;
// If true, ignore values for this metadata.
// If true, ignore values for this metadata.
bool isStatistic;
// Displayed as this in editors.
std::string displayName;
@ -51,7 +54,7 @@ struct MetaDataDecl {
};
enum MetaDataListType {
GAME_METADATA,
GAME_METADATA, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
FOLDER_METADATA
};
@ -61,9 +64,11 @@ class MetaDataList
{
public:
static MetaDataList createFromXML(MetaDataListType type,
pugi::xml_node& node, const std::string& relativeTo);
void appendToXML(pugi::xml_node& parent, bool ignoreDefaults,
const std::string& relativeTo) const;
pugi::xml_node& node,
const std::string& relativeTo);
void appendToXML(pugi::xml_node& parent,
bool ignoreDefaults,
const std::string& relativeTo) const;
MetaDataList(MetaDataListType type);
@ -76,10 +81,12 @@ public:
bool wasChanged() const;
void resetChangedFlag();
inline MetaDataListType getType() const { return mType; }
inline const std::vector<MetaDataDecl>& getMDD() const { return getMDDByType(getType()); }
inline const std::vector<MetaDataDecl>& getMDD(MetaDataListType type) const
{ return getMDDByType(type); }
MetaDataListType getType() const { return mType; }
const std::vector<MetaDataDecl>& getMDD() const { return getMDDByType(getType()); }
const std::vector<MetaDataDecl>& getMDD(MetaDataListType type) const
{
return getMDDByType(type);
}
private:
MetaDataListType mType;

232
es-app/src/MiximageGenerator.cpp
View file

@ -9,47 +9,45 @@
#include "MiximageGenerator.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include "Log.h"
#include "Settings.h"
#include "SystemData.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include <chrono>
MiximageGenerator::MiximageGenerator(FileData* game, std::string& resultMessage)
: mGame(game),
mResultMessage(resultMessage),
mWidth(1280),
mHeight(960),
mMarquee(false),
mBox3D(false),
mCover(false)
: mGame(game)
, mResultMessage(resultMessage)
, mWidth(1280)
, mHeight(960)
, mMarquee(false)
, mBox3D(false)
, mCover(false)
{
}
MiximageGenerator::~MiximageGenerator()
{
}
MiximageGenerator::~MiximageGenerator() {}
void MiximageGenerator::startThread(std::promise<bool>* miximagePromise)
{
mMiximagePromise = miximagePromise;
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): Creating miximage for \""
<< mGame->getFileName() << "\"";
<< mGame->getFileName() << "\"";
if (mGame->getMiximagePath() != "" && !Settings::getInstance()->getBool("MiximageOverwrite")) {
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): File already exists and miximage "
"overwriting has not been enabled, aborting";
"overwriting has not been enabled, aborting";
mMiximagePromise->set_value(true);
return;
}
if ((mScreenshotPath = mGame->getScreenshotPath()) == "") {
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): "
"No screenshot image found, aborting";
mResultMessage = "No screenshot image found, couldn't generate miximage";
"No screenshot image found, aborting";
mResultMessage = "No screenshot image found, couldn't generate miximage";
mMiximagePromise->set_value(true);
return;
}
@ -68,14 +66,14 @@ void MiximageGenerator::startThread(std::promise<bool>* miximagePromise)
mBox3D = true;
}
else if (Settings::getInstance()->getBool("MiximageCoverFallback") &&
(mCoverPath= mGame->getCoverPath()) != "") {
(mCoverPath = mGame->getCoverPath()) != "") {
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): "
"No 3D box image found, using cover image as fallback";
"No 3D box image found, using cover image as fallback";
mCover = true;
}
else if (Settings::getInstance()->getBool("MiximageCoverFallback")) {
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): "
"No 3D box or cover images found";
"No 3D box or cover images found";
}
else {
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): No 3D box image found";
@ -93,9 +91,10 @@ void MiximageGenerator::startThread(std::promise<bool>* miximagePromise)
else {
const auto endTime = std::chrono::system_clock::now();
LOG(LogDebug) << "MiximageGenerator::MiximageGenerator(): Processing completed in: " <<
std::chrono::duration_cast<std::chrono::milliseconds>
(endTime - startTime).count() << " ms";
LOG(LogDebug)
<< "MiximageGenerator::MiximageGenerator(): Processing completed in: "
<< std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count()
<< " ms";
}
mResultMessage = mMessage;
@ -113,19 +112,19 @@ bool MiximageGenerator::generateImage()
unsigned int fileHeight = 0;
unsigned int filePitch = 0;
#if defined(_WIN64)
#if defined(_WIN64)
fileFormat = FreeImage_GetFileTypeU(Utils::String::stringToWideString(mScreenshotPath).c_str());
#else
#else
fileFormat = FreeImage_GetFileType(mScreenshotPath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN)
#if defined(_WIN64)
#if defined(_WIN64)
fileFormat = FreeImage_GetFIFFromFilenameU(
Utils::String::stringToWideString(mScreenshotPath).c_str());
#else
Utils::String::stringToWideString(mScreenshotPath).c_str());
#else
fileFormat = FreeImage_GetFIFFromFilename(mScreenshotPath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN) {
LOG(LogError) << "Screenshot image in unknown image format, aborting";
@ -135,12 +134,12 @@ bool MiximageGenerator::generateImage()
// Make sure that we can actually read this format.
if (FreeImage_FIFSupportsReading(fileFormat)) {
#if defined(_WIN64)
screenshotFile = FreeImage_LoadU(fileFormat,
Utils::String::stringToWideString(mScreenshotPath).c_str());
#else
#if defined(_WIN64)
screenshotFile =
FreeImage_LoadU(fileFormat, Utils::String::stringToWideString(mScreenshotPath).c_str());
#else
screenshotFile = FreeImage_Load(fileFormat, mScreenshotPath.c_str());
#endif
#endif
}
else {
LOG(LogError) << "Screenshot file format not supported";
@ -155,20 +154,20 @@ bool MiximageGenerator::generateImage()
}
if (mMarquee) {
#if defined(_WIN64)
fileFormat = FreeImage_GetFileTypeU(
Utils::String::stringToWideString(mMarqueePath).c_str());
#else
#if defined(_WIN64)
fileFormat =
FreeImage_GetFileTypeU(Utils::String::stringToWideString(mMarqueePath).c_str());
#else
fileFormat = FreeImage_GetFileType(mMarqueePath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN)
#if defined(_WIN64)
#if defined(_WIN64)
fileFormat = FreeImage_GetFIFFromFilenameU(
Utils::String::stringToWideString(mMarqueePath).c_str());
#else
Utils::String::stringToWideString(mMarqueePath).c_str());
#else
fileFormat = FreeImage_GetFIFFromFilename(mMarqueePath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN) {
LOG(LogDebug) << "Marquee in unknown format, skipping image";
@ -180,12 +179,12 @@ bool MiximageGenerator::generateImage()
mMarquee = false;
}
else {
#if defined(_WIN64)
#if defined(_WIN64)
marqueeFile = FreeImage_LoadU(fileFormat,
Utils::String::stringToWideString(mMarqueePath).c_str());
#else
Utils::String::stringToWideString(mMarqueePath).c_str());
#else
marqueeFile = FreeImage_Load(fileFormat, mMarqueePath.c_str());
#endif
#endif
if (!marqueeFile) {
LOG(LogError) << "Couldn't load marquee image, corrupt file?";
mMessage = "Error loading marquee image, corrupt file?";
@ -195,19 +194,19 @@ bool MiximageGenerator::generateImage()
}
if (mBox3D) {
#if defined(_WIN64)
#if defined(_WIN64)
fileFormat = FreeImage_GetFileTypeU(Utils::String::stringToWideString(mBox3DPath).c_str());
#else
#else
fileFormat = FreeImage_GetFileType(mBox3DPath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN)
#if defined(_WIN64)
#if defined(_WIN64)
fileFormat = FreeImage_GetFIFFromFilenameU(
Utils::String::stringToWideString(mBox3DPath).c_str());
#else
Utils::String::stringToWideString(mBox3DPath).c_str());
#else
fileFormat = FreeImage_GetFIFFromFilename(mBox3DPath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN) {
LOG(LogDebug) << "3D box in unknown format, skipping image";
@ -219,12 +218,12 @@ bool MiximageGenerator::generateImage()
mBox3D = false;
}
else {
#if defined(_WIN64)
boxFile = FreeImage_LoadU(fileFormat,
Utils::String::stringToWideString(mBox3DPath).c_str());
#else
#if defined(_WIN64)
boxFile =
FreeImage_LoadU(fileFormat, Utils::String::stringToWideString(mBox3DPath).c_str());
#else
boxFile = FreeImage_Load(fileFormat, mBox3DPath.c_str());
#endif
#endif
if (!boxFile) {
LOG(LogError) << "Couldn't load 3D box image, corrupt file?";
mMessage = "Error loading 3d box image, corrupt file?";
@ -233,20 +232,19 @@ bool MiximageGenerator::generateImage()
}
}
else if (mCover) {
#if defined(_WIN64)
fileFormat = FreeImage_GetFileTypeU(
Utils::String::stringToWideString(mCoverPath).c_str());
#else
#if defined(_WIN64)
fileFormat = FreeImage_GetFileTypeU(Utils::String::stringToWideString(mCoverPath).c_str());
#else
fileFormat = FreeImage_GetFileType(mCoverPath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN)
#if defined(_WIN64)
#if defined(_WIN64)
fileFormat = FreeImage_GetFIFFromFilenameU(
Utils::String::stringToWideString(mCoverPath).c_str());
#else
Utils::String::stringToWideString(mCoverPath).c_str());
#else
fileFormat = FreeImage_GetFIFFromFilename(mCoverPath.c_str());
#endif
#endif
if (fileFormat == FIF_UNKNOWN) {
LOG(LogDebug) << "Box cover in unknown format, skipping image";
@ -258,12 +256,12 @@ bool MiximageGenerator::generateImage()
mCover = false;
}
else {
#if defined(_WIN64)
boxFile = FreeImage_LoadU(fileFormat,
Utils::String::stringToWideString(mCoverPath).c_str());
#else
#if defined(_WIN64)
boxFile =
FreeImage_LoadU(fileFormat, Utils::String::stringToWideString(mCoverPath).c_str());
#else
boxFile = FreeImage_Load(fileFormat, mCoverPath.c_str());
#endif
#endif
if (!boxFile) {
LOG(LogError) << "Couldn't load box cover image, corrupt file?";
mMessage = "Error loading box cover image, corrupt file?";
@ -318,7 +316,7 @@ bool MiximageGenerator::generateImage()
std::vector<unsigned char> screenshotVector(fileWidth * fileHeight * 4);
FreeImage_ConvertToRawBits(reinterpret_cast<BYTE*>(&screenshotVector.at(0)), screenshotFile,
filePitch, 32, FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE, 1);
filePitch, 32, FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE, 1);
CImg<unsigned char> screenshotImage(fileWidth, fileHeight, 1, 4, 0);
@ -386,10 +384,10 @@ bool MiximageGenerator::generateImage()
std::vector<unsigned char> marqueeVector(fileWidth * fileHeight * 4);
FreeImage_ConvertToRawBits(reinterpret_cast<BYTE*>(&marqueeVector.at(0)), marqueeFile,
filePitch, 32, FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE, 1);
filePitch, 32, FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE, 1);
marqueeImage = CImg<unsigned char>(FreeImage_GetWidth(marqueeFile),
FreeImage_GetHeight(marqueeFile), 1, 4, 0);
FreeImage_GetHeight(marqueeFile), 1, 4, 0);
Utils::CImg::convertRGBAToCImg(marqueeVector, marqueeImage);
Utils::CImg::removeTransparentPadding(marqueeImage);
@ -409,7 +407,7 @@ bool MiximageGenerator::generateImage()
yPosMarquee = 0;
// Only RGB channels for the image.
marqueeImageRGB = CImg<unsigned char>(marqueeImage.get_shared_channels(0,2));
marqueeImageRGB = CImg<unsigned char>(marqueeImage.get_shared_channels(0, 2));
// Only alpha channel for the image.
marqueeImageAlpha = CImg<unsigned char>(marqueeImage.get_shared_channel(3));
}
@ -427,17 +425,17 @@ bool MiximageGenerator::generateImage()
std::vector<unsigned char> boxVector(fileWidth * fileHeight * 4);
FreeImage_ConvertToRawBits(reinterpret_cast<BYTE*>(&boxVector.at(0)), boxFile,
filePitch, 32, FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE, 1);
FreeImage_ConvertToRawBits(reinterpret_cast<BYTE*>(&boxVector.at(0)), boxFile, filePitch,
32, FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE, 1);
boxImage = CImg<unsigned char>(FreeImage_GetWidth(boxFile),
FreeImage_GetHeight(boxFile), 1, 4);
boxImage =
CImg<unsigned char>(FreeImage_GetWidth(boxFile), FreeImage_GetHeight(boxFile), 1, 4);
Utils::CImg::convertRGBAToCImg(boxVector, boxImage);
Utils::CImg::removeTransparentPadding(boxImage);
float scaleFactor = static_cast<float>(boxTargetHeight) /
static_cast<float>(boxImage.height());
float scaleFactor =
static_cast<float>(boxTargetHeight) / static_cast<float>(boxImage.height());
unsigned int width = static_cast<int>(static_cast<float>(boxImage.width()) * scaleFactor);
unsigned int targetWidth = 0;
@ -464,7 +462,7 @@ bool MiximageGenerator::generateImage()
yPosBox = canvasImage.height() - boxImage.height();
// Only RGB channels for the image.
boxImageRGB = CImg<unsigned char>(boxImage.get_shared_channels(0,2));
boxImageRGB = CImg<unsigned char>(boxImage.get_shared_channels(0, 2));
// Only alpha channel for the image.
boxImageAlpha = CImg<unsigned char>(boxImage.get_shared_channel(3));
}
@ -478,20 +476,15 @@ bool MiximageGenerator::generateImage()
sampleFrameColor(screenshotImage, frameColor);
// Upper / lower frame.
frameImage.draw_rectangle(
xPosScreenshot + 2,
yPosScreenshot - screenshotFrameWidth,
xPosScreenshot + screenshotWidth - 2,
yPosScreenshot + screenshotHeight + screenshotFrameWidth - 1,
frameColor);
frameImage.draw_rectangle(xPosScreenshot + 2, yPosScreenshot - screenshotFrameWidth,
xPosScreenshot + screenshotWidth - 2,
yPosScreenshot + screenshotHeight + screenshotFrameWidth - 1,
frameColor);
// Left / right frame.
frameImage.draw_rectangle(
xPosScreenshot - screenshotFrameWidth,
yPosScreenshot + 2,
xPosScreenshot + screenshotWidth + screenshotFrameWidth - 1,
yPosScreenshot + screenshotHeight - 2,
frameColor);
frameImage.draw_rectangle(xPosScreenshot - screenshotFrameWidth, yPosScreenshot + 2,
xPosScreenshot + screenshotWidth + screenshotFrameWidth - 1,
yPosScreenshot + screenshotHeight - 2, frameColor);
// We draw circles in order to get rounded corners for the frame.
const unsigned int circleRadius = 8 * resolutionMultiplier;
@ -499,16 +492,18 @@ bool MiximageGenerator::generateImage()
// Upper left corner.
frameImage.draw_circle(xPosScreenshot + circleOffset, yPosScreenshot + circleOffset,
circleRadius, frameColor);
circleRadius, frameColor);
// Upper right corner.
frameImage.draw_circle(xPosScreenshot + screenshotWidth - circleOffset - 1,
yPosScreenshot + circleOffset, circleRadius, frameColor);
yPosScreenshot + circleOffset, circleRadius, frameColor);
// Lower right corner.
frameImage.draw_circle(xPosScreenshot + screenshotWidth - circleOffset - 1,
yPosScreenshot + screenshotHeight - circleOffset - 1, circleRadius, frameColor);
yPosScreenshot + screenshotHeight - circleOffset - 1, circleRadius,
frameColor);
// Lower left corner.
frameImage.draw_circle(xPosScreenshot + circleOffset,
yPosScreenshot + screenshotHeight - circleOffset - 1, circleRadius, frameColor);
yPosScreenshot + screenshotHeight - circleOffset - 1, circleRadius,
frameColor);
CImg<unsigned char> frameImageRGB(frameImage.get_shared_channels(0, 2));
@ -516,8 +511,8 @@ bool MiximageGenerator::generateImage()
canvasImage.draw_image(xPosScreenshot, yPosScreenshot, screenshotImage);
if (mMarquee)
canvasImage.draw_image(xPosMarquee, yPosMarquee, marqueeImageRGB,
marqueeImageAlpha, 1, 255);
canvasImage.draw_image(xPosMarquee, yPosMarquee, marqueeImageRGB, marqueeImageAlpha, 1,
255);
if (mBox3D || mCover)
canvasImage.draw_image(xPosBox, yPosBox, boxImageRGB, boxImageAlpha, 1, 255);
@ -528,15 +523,16 @@ bool MiximageGenerator::generateImage()
FIBITMAP* mixImage = nullptr;
mixImage = FreeImage_ConvertFromRawBits(&canvasVector.at(0), canvasImage.width(),
canvasImage.height(), canvasImage.width() * 4, 32,
FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE);
canvasImage.height(), canvasImage.width() * 4, 32,
FI_RGBA_RED, FI_RGBA_GREEN, FI_RGBA_BLUE);
#if defined(_WIN64)
bool savedImage = (FreeImage_SaveU(FIF_PNG, mixImage,
Utils::String::stringToWideString(getSavePath()).c_str()) != 0);
#else
#if defined(_WIN64)
bool savedImage =
(FreeImage_SaveU(FIF_PNG, mixImage,
Utils::String::stringToWideString(getSavePath()).c_str()) != 0);
#else
bool savedImage = (FreeImage_Save(FIF_PNG, mixImage, getSavePath().c_str()) != 0);
#endif
#endif
if (!savedImage) {
LOG(LogError) << "Couldn't save miximage, permission problems or disk full?";
@ -555,7 +551,9 @@ bool MiximageGenerator::generateImage()
}
void MiximageGenerator::calculateMarqueeSize(const unsigned int& targetWidth,
const unsigned int& targetHeight, unsigned int& width, unsigned int& height)
const unsigned int& targetHeight,
unsigned int& width,
unsigned int& height)
{
unsigned int adjustedTargetWidth = 0;
float widthModifier = 0.5f;
@ -572,13 +570,13 @@ void MiximageGenerator::calculateMarqueeSize(const unsigned int& targetWidth,
if (widthRatio >= 4)
widthModifier += Math::clamp(widthRatio / 40.0f, 0.0f, 0.3f);
adjustedTargetWidth = static_cast<unsigned int>(
static_cast<float>(targetWidth) * widthModifier);
adjustedTargetWidth =
static_cast<unsigned int>(static_cast<float>(targetWidth) * widthModifier);
scaleFactor = static_cast<float>(adjustedTargetWidth) / static_cast<float>(width);
// For really tall and narrow images, we may have exceeded the target height.
if (static_cast<int>(scaleFactor * static_cast<float>(height)) >
static_cast<float>(targetHeight))
static_cast<float>(targetHeight))
scaleFactor = static_cast<float>(targetHeight) / static_cast<float>(height);
width = static_cast<int>(static_cast<float>(width) * scaleFactor);
@ -586,7 +584,7 @@ void MiximageGenerator::calculateMarqueeSize(const unsigned int& targetWidth,
}
void MiximageGenerator::sampleFrameColor(CImg<unsigned char>& screenshotImage,
unsigned char (&frameColor)[4])
unsigned char (&frameColor)[4])
{
// Calculate the number of samples relative to the configured resolution so we get
// the same result regardless of miximage target size seting.
@ -627,9 +625,9 @@ void MiximageGenerator::sampleFrameColor(CImg<unsigned char>& screenshotImage,
unsigned char blueC = Math::clamp(static_cast<int>(blueLine / 255), 0, 255);
// Convert to the HSL color space to be able to modify saturation and lightness.
CImg<float> colorHSL = CImg<>(1,1,1,3).fill(redC, greenC, blueC).RGBtoHSL();
CImg<float> colorHSL = CImg<>(1, 1, 1, 3).fill(redC, greenC, blueC).RGBtoHSL();
float hue = colorHSL(0, 0, 0, 0);
// float hue = colorHSL(0, 0, 0, 0);
float saturation = colorHSL(0, 0, 0, 1);
float lightness = colorHSL(0, 0, 0, 2);
@ -656,7 +654,7 @@ std::string MiximageGenerator::getSavePath()
// Extract possible subfolders from the path.
if (mGame->getSystemEnvData()->mStartPath != "")
subFolders = Utils::String::replace(Utils::FileSystem::getParent(mGame->getPath()),
mGame->getSystemEnvData()->mStartPath, "");
mGame->getSystemEnvData()->mStartPath, "");
std::string path = FileData::getMediaDirectory();

8
es-app/src/MiximageGenerator.h
View file

@ -10,9 +10,9 @@
#ifndef ES_APP_SCRAPERS_MIXIMAGE_GENERATOR_H
#define ES_APP_SCRAPERS_MIXIMAGE_GENERATOR_H
#include "utils/CImgUtil.h"
#include "FileData.h"
#include "GuiComponent.h"
#include "utils/CImgUtil.h"
#include <FreeImage.h>
#include <future>
@ -29,8 +29,10 @@ public:
private:
bool generateImage();
void calculateMarqueeSize(const unsigned int& targetWidth, const unsigned int& targetHeight,
unsigned int& width, unsigned int& height);
void calculateMarqueeSize(const unsigned int& targetWidth,
const unsigned int& targetHeight,
unsigned int& width,
unsigned int& height);
void sampleFrameColor(CImg<unsigned char>& screenshotImage, unsigned char (&frameColor)[4]);
std::string getSavePath();

6
es-app/src/PlatformId.cpp
View file

@ -13,6 +13,7 @@
namespace PlatformIds
{
// clang-format off
std::vector<std::string> platformNames = {
"unknown", // Nothing set.
@ -132,6 +133,7 @@ namespace PlatformIds
"ignore", // Do not allow scraping for this system.
"invalid"
};
// clang-format on
PlatformId getPlatformId(const std::string& str)
{
@ -148,6 +150,8 @@ namespace PlatformIds
const std::string getPlatformName(PlatformId id)
{
// Return the platform name.
return platformNames[id];
}
}
} // namespace PlatformIds

3
es-app/src/PlatformId.h
View file

@ -135,6 +135,7 @@ namespace PlatformIds
PlatformId getPlatformId(const std::string& str);
const std::string getPlatformName(PlatformId id);
}
} // namespace PlatformIds
#endif // ES_APP_PLATFORM_ID_H

391
es-app/src/SystemData.cpp
View file

@ -11,12 +11,6 @@
#include "SystemData.h"
#include "resources/ResourceManager.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "views/gamelist/IGameListView.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "FileFilterIndex.h"
#include "FileSorts.h"
@ -25,6 +19,12 @@
#include "Platform.h"
#include "Settings.h"
#include "ThemeData.h"
#include "resources/ResourceManager.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "views/gamelist/IGameListView.h"
#include <fstream>
#include <pugixml.hpp>
@ -39,14 +39,10 @@ FindRules::FindRules()
loadFindRules();
}
FindRules::~FindRules()
{
}
void FindRules::loadFindRules()
{
std::string customSystemsDirectory =
Utils::FileSystem::getHomePath() + "/.emulationstation/custom_systems";
Utils::FileSystem::getHomePath() + "/.emulationstation/custom_systems";
std::string path = customSystemsDirectory + "/es_find_rules.xml";
@ -54,16 +50,16 @@ void FindRules::loadFindRules()
LOG(LogInfo) << "Found custom find rules configuration file";
}
else {
#if defined(_WIN64)
path = ResourceManager::getInstance()->
getResourcePath(":/systems/windows/es_find_rules.xml", false);
#elif defined(__APPLE__)
path = ResourceManager::getInstance()->
getResourcePath(":/systems/macos/es_find_rules.xml", false);
#else
path = ResourceManager::getInstance()->
getResourcePath(":/systems/unix/es_find_rules.xml", false);
#endif
#if defined(_WIN64)
path = ResourceManager::getInstance()->getResourcePath(
":/systems/windows/es_find_rules.xml", false);
#elif defined(__APPLE__)
path = ResourceManager::getInstance()->getResourcePath(":/systems/macos/es_find_rules.xml",
false);
#else
path = ResourceManager::getInstance()->getResourcePath(":/systems/unix/es_find_rules.xml",
false);
#endif
}
if (path == "") {
@ -74,11 +70,11 @@ void FindRules::loadFindRules()
LOG(LogInfo) << "Parsing find rules configuration file \"" << path << "\"...";
pugi::xml_document doc;
#if defined(_WIN64)
#if defined(_WIN64)
pugi::xml_parse_result res = doc.load_file(Utils::String::stringToWideString(path).c_str());
#else
#else
pugi::xml_parse_result res = doc.load_file(path.c_str());
#endif
#endif
if (!res) {
LOG(LogError) << "Couldn't parse es_find_rules.xml: " << res.description();
@ -97,81 +93,79 @@ void FindRules::loadFindRules()
CoreRules coreRules;
for (pugi::xml_node emulator = ruleList.child("emulator"); emulator;
emulator = emulator.next_sibling("emulator")) {
emulator = emulator.next_sibling("emulator")) {
std::string emulatorName = emulator.attribute("name").as_string();
if (emulatorName.empty()) {
LOG(LogWarning) << "Found emulator tag without name attribute, skipping entry";
continue;
}
if (mEmulators.find(emulatorName) != mEmulators.end()) {
LOG(LogWarning) << "Found repeating emulator tag \"" << emulatorName <<
"\", skipping entry";
LOG(LogWarning) << "Found repeating emulator tag \"" << emulatorName
<< "\", skipping entry";
continue;
}
for (pugi::xml_node rule = emulator.child("rule"); rule; rule = rule.next_sibling("rule")) {
std::string ruleType = rule.attribute("type").as_string();
if (ruleType.empty()) {
LOG(LogWarning) << "Found rule tag without type attribute for emulator \"" <<
emulatorName << "\", skipping entry";
LOG(LogWarning) << "Found rule tag without type attribute for emulator \""
<< emulatorName << "\", skipping entry";
continue;
}
#if defined(_WIN64)
#if defined(_WIN64)
if (ruleType != "winregistrypath" && ruleType != "systempath" &&
ruleType != "staticpath") {
#else
ruleType != "staticpath") {
#else
if (ruleType != "systempath" && ruleType != "staticpath") {
#endif
LOG(LogWarning) << "Found invalid rule type \"" << ruleType <<
"\" for emulator \"" << emulatorName << "\", skipping entry";
#endif
LOG(LogWarning) << "Found invalid rule type \"" << ruleType << "\" for emulator \""
<< emulatorName << "\", skipping entry";
continue;
}
for (pugi::xml_node entry = rule.child("entry"); entry;
entry = entry.next_sibling("entry")) {
entry = entry.next_sibling("entry")) {
std::string entryValue = entry.text().get();
if (ruleType == "systempath")
emulatorRules.systemPaths.push_back(entryValue);
else if (ruleType == "staticpath")
emulatorRules.staticPaths.push_back(entryValue);
#if defined(_WIN64)
#if defined(_WIN64)
else if (ruleType == "winregistrypath")
emulatorRules.winRegistryPaths.push_back(entryValue);
#endif
#endif
}
}
mEmulators[emulatorName] = emulatorRules;
emulatorRules.systemPaths.clear();
emulatorRules.staticPaths.clear();
#if defined(_WIN64)
#if defined(_WIN64)
emulatorRules.winRegistryPaths.clear();
#endif
#endif
}
for (pugi::xml_node core = ruleList.child("core"); core;
core = core.next_sibling("core")) {
for (pugi::xml_node core = ruleList.child("core"); core; core = core.next_sibling("core")) {
std::string coreName = core.attribute("name").as_string();
if (coreName.empty()) {
LOG(LogWarning) << "Found core tag without name attribute, skipping entry";
continue;
}
if (mCores.find(coreName) != mCores.end()) {
LOG(LogWarning) << "Found repeating core tag \"" << coreName <<
"\", skipping entry";
LOG(LogWarning) << "Found repeating core tag \"" << coreName << "\", skipping entry";
continue;
}
for (pugi::xml_node rule = core.child("rule"); rule; rule = rule.next_sibling("rule")) {
std::string ruleType = rule.attribute("type").as_string();
if (ruleType.empty()) {
LOG(LogWarning) << "Found rule tag without type attribute for core \"" <<
coreName << "\", skipping entry";
LOG(LogWarning) << "Found rule tag without type attribute for core \"" << coreName
<< "\", skipping entry";
continue;
}
if (ruleType != "corepath") {
LOG(LogWarning) << "Found invalid rule type \"" << ruleType <<
"\" for core \"" << coreName << "\", skipping entry";
LOG(LogWarning) << "Found invalid rule type \"" << ruleType << "\" for core \""
<< coreName << "\", skipping entry";
continue;
}
for (pugi::xml_node entry = rule.child("entry"); entry;
entry = entry.next_sibling("entry")) {
entry = entry.next_sibling("entry")) {
std::string entryValue = entry.text().get();
if (ruleType == "corepath")
coreRules.corePaths.push_back(entryValue);
@ -182,23 +176,22 @@ void FindRules::loadFindRules()
}
}
SystemData::SystemData(
const std::string& name,
const std::string& fullName,
SystemEnvironmentData* envData,
const std::string& themeFolder,
bool CollectionSystem,
bool CustomCollectionSystem)
: mName(name),
mFullName(fullName),
mEnvData(envData),
mThemeFolder(themeFolder),
mIsCollectionSystem(CollectionSystem),
mIsCustomCollectionSystem(CustomCollectionSystem),
mIsGroupedCustomCollectionSystem(false),
mIsGameSystem(true),
mScrapeFlag(false),
mPlaceholder(nullptr)
SystemData::SystemData(const std::string& name,
const std::string& fullName,
SystemEnvironmentData* envData,
const std::string& themeFolder,
bool CollectionSystem,
bool CustomCollectionSystem)
: mName(name)
, mFullName(fullName)
, mEnvData(envData)
, mThemeFolder(themeFolder)
, mIsCollectionSystem(CollectionSystem)
, mIsCustomCollectionSystem(CustomCollectionSystem)
, mIsGroupedCustomCollectionSystem(false)
, mIsGameSystem(true)
, mScrapeFlag(false)
, mPlaceholder(nullptr)
{
mFilterIndex = new FileFilterIndex();
@ -220,7 +213,7 @@ SystemData::SystemData(
setupSystemSortType(mRootFolder);
mRootFolder->sort(mRootFolder->getSortTypeFromString(mRootFolder->getSortTypeString()),
Settings::getInstance()->getBool("FavoritesFirst"));
Settings::getInstance()->getBool("FavoritesFirst"));
indexAllGameFilters(mRootFolder);
}
@ -275,14 +268,23 @@ bool SystemData::populateFolder(FileData* folder)
return false;
for (Utils::FileSystem::stringList::const_iterator it = dirContent.cbegin();
it != dirContent.cend(); it++) {
it != dirContent.cend(); it++) {
filePath = *it;
// Skip any recursive symlinks as those would hang the application at various places.
if (Utils::FileSystem::isSymlink(filePath)) {
if (Utils::FileSystem::resolveSymlink(filePath) ==
Utils::FileSystem::getFileName(filePath)) {
LOG(LogWarning) << "Skipped \"" << filePath << "\" as it's a recursive symlink";
continue;
}
}
// Skip hidden files and folders.
if (!showHiddenFiles && Utils::FileSystem::isHidden(filePath)) {
LOG(LogDebug) << "SystemData::populateFolder(): Skipping hidden " <<
(Utils::FileSystem::isDirectory(filePath) ? "directory \"" : "file \"") <<
filePath << "\"";
LOG(LogDebug) << "SystemData::populateFolder(): Skipping hidden "
<< (Utils::FileSystem::isDirectory(filePath) ? "directory \"" : "file \"")
<< filePath << "\"";
continue;
}
@ -297,7 +299,7 @@ bool SystemData::populateFolder(FileData* folder)
isGame = false;
if (std::find(mEnvData->mSearchExtensions.cbegin(), mEnvData->mSearchExtensions.cend(),
extension) != mEnvData->mSearchExtensions.cend()) {
extension) != mEnvData->mSearchExtensions.cend()) {
FileData* newGame = new FileData(GAME, filePath, mEnvData, this);
// Prevent new arcade assets from being added.
@ -317,15 +319,17 @@ bool SystemData::populateFolder(FileData* folder)
if (Utils::FileSystem::isSymlink(filePath)) {
const std::string canonicalPath = Utils::FileSystem::getCanonicalPath(filePath);
const std::string canonicalStartPath =
Utils::FileSystem::getCanonicalPath(mEnvData->mStartPath);
const std::string combinedPath = mEnvData->mStartPath +
canonicalPath.substr(canonicalStartPath.size(),
canonicalStartPath.size() - canonicalPath.size());
Utils::FileSystem::getCanonicalPath(mEnvData->mStartPath);
const std::string combinedPath =
mEnvData->mStartPath +
canonicalPath.substr(canonicalStartPath.size(),
canonicalStartPath.size() - canonicalPath.size());
if (filePath.find(combinedPath) == 0) {
LOG(LogWarning) << "Skipped \"" << filePath << "\" as it's a recursive symlink";
continue;
}
}
FileData* newFolder = new FileData(FOLDER, filePath, mEnvData, this);
populateFolder(newFolder);
@ -343,17 +347,15 @@ void SystemData::indexAllGameFilters(const FileData* folder)
{
const std::vector<FileData*>& children = folder->getChildren();
for (std::vector<FileData*>::const_iterator it = children.cbegin();
it != children.cend(); it++) {
for (std::vector<FileData*>::const_iterator it = children.cbegin(); // Line break.
it != children.cend(); it++) {
switch ((*it)->getType()) {
case GAME: {
case GAME:
mFilterIndex->addToIndex(*it);
}
break;
case FOLDER: {
break;
case FOLDER:
indexAllGameFilters(*it);
}
break;
break;
default:
break;
}
@ -391,11 +393,11 @@ bool SystemData::loadConfig()
LOG(LogInfo) << "Parsing systems configuration file \"" << path << "\"...";
pugi::xml_document doc;
#if defined(_WIN64)
#if defined(_WIN64)
pugi::xml_parse_result res = doc.load_file(Utils::String::stringToWideString(path).c_str());
#else
#else
pugi::xml_parse_result res = doc.load_file(path.c_str());
#endif
#endif
if (!res) {
LOG(LogError) << "Couldn't parse es_systems.xml: " << res.description();
@ -411,7 +413,7 @@ bool SystemData::loadConfig()
}
for (pugi::xml_node system = systemList.child("system"); system;
system = system.next_sibling("system")) {
system = system.next_sibling("system")) {
std::string name;
std::string fullname;
std::string path;
@ -427,21 +429,21 @@ bool SystemData::loadConfig()
// the ROM path configured as ROMDirectory in es_settings.xml. If it's set to ""
// in this configuration file, the default hardcoded path $HOME/ROMs/ will be used.
path = Utils::String::replace(path, "%ROMPATH%", rompath);
#if defined(_WIN64)
#if defined(_WIN64)
path = Utils::String::replace(path, "\\", "/");
#endif
#endif
path = Utils::String::replace(path, "//", "/");
// Check that the ROM directory for the system is valid or otherwise abort the processing.
if (!Utils::FileSystem::exists(path)) {
LOG(LogDebug) << "SystemData::loadConfig(): Skipping system \"" <<
name << "\" as the defined ROM directory \"" << path << "\" does not exist";
LOG(LogDebug) << "SystemData::loadConfig(): Skipping system \"" << name
<< "\" as the defined ROM directory \"" << path << "\" does not exist";
continue;
}
if (!Utils::FileSystem::isDirectory(path)) {
LOG(LogDebug) << "SystemData::loadConfig(): Skipping system \"" <<
name << "\" as the defined ROM directory \"" << path <<
"\" is not actually a directory";
LOG(LogDebug) << "SystemData::loadConfig(): Skipping system \"" << name
<< "\" as the defined ROM directory \"" << path
<< "\" is not actually a directory";
continue;
}
if (Utils::FileSystem::isSymlink(path)) {
@ -449,9 +451,9 @@ bool SystemData::loadConfig()
// as that would lead to an infite loop, meaning the application would never start.
std::string resolvedRompath = Utils::FileSystem::getCanonicalPath(rompath);
if (resolvedRompath.find(Utils::FileSystem::getCanonicalPath(path)) == 0) {
LOG(LogWarning) << "Skipping system \"" << name <<
"\" as the defined ROM directory \"" << path <<
"\" is an infinitely recursive symlink";
LOG(LogWarning) << "Skipping system \"" << name
<< "\" as the defined ROM directory \"" << path
<< "\" is an infinitely recursive symlink";
continue;
}
}
@ -463,7 +465,13 @@ bool SystemData::loadConfig()
// Platform ID list
const std::string platformList =
Utils::String::toLower(system.child("platform").text().get());
Utils::String::toLower(system.child("platform").text().get());
if (platformList == "") {
LOG(LogWarning) << "No platform defined for system \"" << name
<< "\", scraper searches will be inaccurate";
}
std::vector<std::string> platformStrs = readList(platformList);
std::vector<PlatformIds::PlatformId> platformIds;
for (auto it = platformStrs.cbegin(); it != platformStrs.cend(); it++) {
@ -480,8 +488,8 @@ bool SystemData::loadConfig()
// If there's a platform entry defined but it does not match the list of supported
// platforms, then generate a warning.
if (str != "" && platformId == PlatformIds::PLATFORM_UNKNOWN)
LOG(LogWarning) << "Unknown platform \"" << str << "\" defined for system \"" <<
name << "\"";
LOG(LogWarning) << "Unknown platform \"" << str << "\" defined for system \""
<< name << "\", scraper searches will be inaccurate";
else if (platformId != PlatformIds::PLATFORM_UNKNOWN)
platformIds.push_back(platformId);
}
@ -492,26 +500,27 @@ bool SystemData::loadConfig()
// Validate.
if (name.empty()) {
LOG(LogError) <<
"A system in the es_systems.xml file has no name defined, skipping entry";
LOG(LogError)
<< "A system in the es_systems.xml file has no name defined, skipping entry";
continue;
}
else if (fullname.empty() || path.empty() || extensions.empty() || cmd.empty()) {
LOG(LogError) << "System \"" << name << "\" is missing the fullname, path, "
"extension, or command tag, skipping entry";
LOG(LogError) << "System \"" << name
<< "\" is missing the fullname, path, "
"extension, or command tag, skipping entry";
continue;
}
// Convert path to generic directory seperators.
path = Utils::FileSystem::getGenericPath(path);
#if defined(_WIN64)
#if defined(_WIN64)
if (!Settings::getInstance()->getBool("ShowHiddenFiles") &&
Utils::FileSystem::isHidden(path)) {
Utils::FileSystem::isHidden(path)) {
LOG(LogWarning) << "Skipping hidden ROM folder \"" << path << "\"";
continue;
}
#endif
#endif
// Create the system runtime environment data.
SystemEnvironmentData* envData = new SystemEnvironmentData;
@ -526,8 +535,7 @@ bool SystemData::loadConfig()
// If the option to show hidden games has been disabled, then check whether all
// games for the system are hidden. That will flag the system as empty.
if (!Settings::getInstance()->getBool("ShowHiddenGames")) {
std::vector<FileData*> recursiveGames =
newSys->getRootFolder()->getChildrenRecursive();
std::vector<FileData*> recursiveGames = newSys->getRootFolder()->getChildrenRecursive();
onlyHidden = true;
for (auto it = recursiveGames.cbegin(); it != recursiveGames.cend(); it++) {
if ((*it)->getType() != FOLDER) {
@ -539,8 +547,8 @@ bool SystemData::loadConfig()
}
if (newSys->getRootFolder()->getChildrenByFilename().size() == 0 || onlyHidden) {
LOG(LogDebug) << "SystemData::loadConfig(): Skipping system \"" <<
name << "\" as no files matched any of the defined file extensions";
LOG(LogDebug) << "SystemData::loadConfig(): Skipping system \"" << name
<< "\" as no files matched any of the defined file extensions";
delete newSys;
}
else {
@ -550,8 +558,7 @@ bool SystemData::loadConfig()
// Sort systems by their full names.
std::sort(std::begin(sSystemVector), std::end(sSystemVector),
[](SystemData* a, SystemData* b) {
return a->getFullName() < b->getFullName(); });
[](SystemData* a, SystemData* b) { return a->getFullName() < b->getFullName(); });
// Don't load any collections if there are no systems available.
if (sSystemVector.size() > 0)
@ -571,18 +578,18 @@ void SystemData::deleteSystems()
std::string SystemData::getConfigPath(bool legacyWarning)
{
if (legacyWarning) {
std::string legacyConfigFile = Utils::FileSystem::getHomePath() +
"/.emulationstation/es_systems.cfg";
std::string legacyConfigFile =
Utils::FileSystem::getHomePath() + "/.emulationstation/es_systems.cfg";
if (Utils::FileSystem::exists(legacyConfigFile)) {
LOG(LogInfo) << "Found legacy systems configuration file \"" << legacyConfigFile <<
"\", to retain your customizations move it to "
"\"custom_systems/es_systems.xml\" or otherwise delete the file";
LOG(LogInfo) << "Found legacy systems configuration file \"" << legacyConfigFile
<< "\", to retain your customizations move it to "
"\"custom_systems/es_systems.xml\" or otherwise delete the file";
}
}
std::string customSystemsDirectory =
Utils::FileSystem::getHomePath() + "/.emulationstation/custom_systems";
Utils::FileSystem::getHomePath() + "/.emulationstation/custom_systems";
if (!Utils::FileSystem::exists(customSystemsDirectory)) {
LOG(LogInfo) << "Creating custom systems directory \"" << customSystemsDirectory << "\"...";
@ -599,16 +606,14 @@ std::string SystemData::getConfigPath(bool legacyWarning)
return path;
}
#if defined(_WIN64)
path = ResourceManager::getInstance()->
getResourcePath(":/systems/windows/es_systems.xml", true);
#elif defined(__APPLE__)
path = ResourceManager::getInstance()->
getResourcePath(":/systems/macos/es_systems.xml", true);
#else
path = ResourceManager::getInstance()->
getResourcePath(":/systems/unix/es_systems.xml", true);
#endif
#if defined(_WIN64)
path =
ResourceManager::getInstance()->getResourcePath(":/systems/windows/es_systems.xml", true);
#elif defined(__APPLE__)
path = ResourceManager::getInstance()->getResourcePath(":/systems/macos/es_systems.xml", true);
#else
path = ResourceManager::getInstance()->getResourcePath(":/systems/unix/es_systems.xml", true);
#endif
return path;
}
@ -618,16 +623,16 @@ bool SystemData::createSystemDirectories()
std::string path = getConfigPath(false);
const std::string rompath = FileData::getROMDirectory();
if (!Utils::FileSystem::exists(path)) {
if (!Utils::FileSystem::exists(path)) {
LOG(LogInfo) << "Systems configuration file does not exist, aborting";
return true;
}
}
LOG(LogInfo) << "Generating ROM directory structure...";
if (Utils::FileSystem::exists(rompath) && Utils::FileSystem::isRegularFile(rompath)) {
LOG(LogError) <<
"Requested ROM directory \"" << rompath << "\" is actually a file, aborting";
LOG(LogError) << "Requested ROM directory \"" << rompath
<< "\" is actually a file, aborting";
return true;
}
@ -645,11 +650,11 @@ bool SystemData::createSystemDirectories()
LOG(LogInfo) << "Parsing systems configuration file \"" << path << "\"...";
pugi::xml_document doc;
#if defined(_WIN64)
#if defined(_WIN64)
pugi::xml_parse_result res = doc.load_file(Utils::String::stringToWideString(path).c_str());
#else
#else
pugi::xml_parse_result res = doc.load_file(path.c_str());
#endif
#endif
if (!res) {
LOG(LogError) << "Couldn't parse es_systems.xml";
@ -668,7 +673,7 @@ bool SystemData::createSystemDirectories()
std::vector<std::string> systemsVector;
for (pugi::xml_node system = systemList.child("system"); system;
system = system.next_sibling("system")) {
system = system.next_sibling("system")) {
std::string systemDir;
std::string name;
std::string fullname;
@ -692,8 +697,9 @@ bool SystemData::createSystemDirectories()
// Check that the %ROMPATH% variable is actually used for the path element.
// If not, skip the system.
if (path.find("%ROMPATH%") != 0) {
LOG(LogWarning) << "The path element for system \"" << name << "\" does not "
"utilize the %ROMPATH% variable, skipping entry";
LOG(LogWarning) << "The path element for system \"" << name
<< "\" does not "
"utilize the %ROMPATH% variable, skipping entry";
continue;
}
else {
@ -702,14 +708,13 @@ bool SystemData::createSystemDirectories()
// Trim any leading directory separator characters.
systemDir.erase(systemDir.begin(),
std::find_if(systemDir.begin(), systemDir.end(), [](char c) {
return c != '/' && c != '\\';
}));
std::find_if(systemDir.begin(), systemDir.end(),
[](char c) { return c != '/' && c != '\\'; }));
if (!Utils::FileSystem::exists(rompath + systemDir)) {
if (!Utils::FileSystem::createDirectory(rompath + systemDir)) {
LOG(LogError) << "Couldn't create system directory \"" << systemDir <<
"\", permission problems or disk full?";
LOG(LogError) << "Couldn't create system directory \"" << systemDir
<< "\", permission problems or disk full?";
return true;
}
else {
@ -730,16 +735,17 @@ bool SystemData::createSystemDirectories()
return true;
}
#if defined(_WIN64)
systemInfoFile.open(Utils::String::stringToWideString(rompath +
systemDir + systemInfoFileName).c_str());
#else
#if defined(_WIN64)
systemInfoFile.open(
Utils::String::stringToWideString(rompath + systemDir + systemInfoFileName).c_str());
#else
systemInfoFile.open(rompath + systemDir + systemInfoFileName);
#endif
#endif
if (systemInfoFile.fail()) {
LOG(LogError) << "Couldn't create system information file \"" << rompath +
systemDir + systemInfoFileName << "\", permission problems or disk full?";
LOG(LogError) << "Couldn't create system information file \""
<< rompath + systemDir + systemInfoFileName
<< "\", permission problems or disk full?";
systemInfoFile.close();
return true;
}
@ -761,12 +767,12 @@ bool SystemData::createSystemDirectories()
systemsVector.push_back(systemDir + ": " + fullname);
if (replaceInfoFile) {
LOG(LogInfo) << "Replaced existing system information file \"" <<
rompath + systemDir + systemInfoFileName << "\"";
LOG(LogInfo) << "Replaced existing system information file \""
<< rompath + systemDir + systemInfoFileName << "\"";
}
else {
LOG(LogInfo) << "Created system information file \"" <<
rompath + systemDir + systemInfoFileName << "\"";
LOG(LogInfo) << "Created system information file \""
<< rompath + systemDir + systemInfoFileName << "\"";
}
}
@ -784,11 +790,11 @@ bool SystemData::createSystemDirectories()
if (systemsFileSuccess) {
std::ofstream systemsFile;
#if defined(_WIN64)
#if defined(_WIN64)
systemsFile.open(Utils::String::stringToWideString(rompath + systemsFileName).c_str());
#else
#else
systemsFile.open(rompath + systemsFileName);
#endif
#endif
if (systemsFile.fail()) {
systemsFileSuccess = false;
}
@ -802,7 +808,7 @@ bool SystemData::createSystemDirectories()
if (!systemsFileSuccess) {
LOG(LogWarning) << "System directories successfully created but couldn't create "
"the systems.txt file in the ROM directory root";
"the systems.txt file in the ROM directory root";
return false;
}
}
@ -858,8 +864,8 @@ std::string SystemData::getGamelistPath(bool forWrite) const
if (Utils::FileSystem::exists(filePath))
return filePath;
filePath = Utils::FileSystem::getHomePath() + "/.emulationstation/gamelists/" +
mName + "/gamelist.xml";
filePath = Utils::FileSystem::getHomePath() + "/.emulationstation/gamelists/" + mName +
"/gamelist.xml";
// Make sure the directory exists if we're going to write to it,
// or crashes will happen.
@ -890,17 +896,12 @@ std::string SystemData::getThemePath() const
return localThemePath;
// Not system theme, try default system theme in theme set.
localThemePath = Utils::FileSystem::getParent(Utils::FileSystem::getParent(localThemePath)) +
"/theme.xml";
localThemePath =
Utils::FileSystem::getParent(Utils::FileSystem::getParent(localThemePath)) + "/theme.xml";
return localThemePath;
}
bool SystemData::hasGamelist() const
{
return (Utils::FileSystem::exists(getGamelistPath(false)));
}
SystemData* SystemData::getRandomSystem(const SystemData* currentSystem)
{
unsigned int total = 0;
@ -918,7 +919,7 @@ SystemData* SystemData::getRandomSystem(const SystemData* currentSystem)
// Get a random number in range.
std::random_device randDev;
// Mersenne Twister pseudorandom number generator.
std::mt19937 engine{randDev()};
std::mt19937 engine { randDev() };
std::uniform_int_distribution<int> uniform_dist(0, total - 1);
int target = uniform_dist(engine);
@ -933,8 +934,7 @@ SystemData* SystemData::getRandomSystem(const SystemData* currentSystem)
}
}
}
}
while (randomSystem == currentSystem);
} while (randomSystem == currentSystem);
return randomSystem;
}
@ -947,13 +947,17 @@ FileData* SystemData::getRandomGame(const FileData* currentGame)
// If we're in the custom collection group list, then get the list of collections,
// otherwise get a list of all the folder and file entries in the view.
if (currentGame && currentGame->getType() == FOLDER && currentGame->
getSystem()->isGroupedCustomCollection()) {
if (currentGame && currentGame->getType() == FOLDER &&
currentGame->getSystem()->isGroupedCustomCollection()) {
gameList = mRootFolder->getParent()->getChildrenListToDisplay();
}
else {
gameList = ViewController::get()->getGameListView(mRootFolder->
getSystem()).get()->getCursor()->getParent()->getChildrenListToDisplay();
gameList = ViewController::get()
->getGameListView(mRootFolder->getSystem())
.get()
->getCursor()
->getParent()
->getChildrenListToDisplay();
}
if (gameList.size() > 0 && gameList.front()->getParent()->getOnlyFoldersFlag())
@ -994,11 +998,10 @@ FileData* SystemData::getRandomGame(const FileData* currentGame)
// Get a random number in range.
std::random_device randDev;
// Mersenne Twister pseudorandom number generator.
std::mt19937 engine{randDev()};
std::mt19937 engine { randDev() };
std::uniform_int_distribution<int> uniform_dist(0, total - 1);
target = uniform_dist(engine);
}
while (currentGame && gameList.at(target) == currentGame);
} while (currentGame && gameList.at(target) == currentGame);
return gameList.at(target);
}
@ -1011,23 +1014,25 @@ void SystemData::sortSystem(bool reloadGamelist, bool jumpToFirstRow)
bool favoritesSorting;
if (this->isCustomCollection() ||
(this->isCollection() && this->getFullName() == "collections"))
(this->isCollection() && this->getFullName() == "collections")) {
favoritesSorting = Settings::getInstance()->getBool("FavFirstCustom");
else
}
else {
favoritesSorting = Settings::getInstance()->getBool("FavoritesFirst");
}
FileData* rootFolder = getRootFolder();
// Assign the sort type to all grouped custom collections.
if (mIsCollectionSystem && mFullName == "collections") {
for (auto it = rootFolder->getChildren().begin();
it != rootFolder->getChildren().end(); it++) {
for (auto it = rootFolder->getChildren().begin(); // Line break.
it != rootFolder->getChildren().end(); it++) {
setupSystemSortType((*it)->getSystem()->getRootFolder());
}
}
setupSystemSortType(rootFolder);
rootFolder->sort(rootFolder->getSortTypeFromString(
rootFolder->getSortTypeString()), favoritesSorting);
rootFolder->sort(rootFolder->getSortTypeFromString(rootFolder->getSortTypeString()),
favoritesSorting);
if (reloadGamelist)
ViewController::get()->reloadGameListView(this, false);
@ -1070,7 +1075,8 @@ void SystemData::loadTheme()
}
}
void SystemData::writeMetaData() {
void SystemData::writeMetaData()
{
if (Settings::getInstance()->getBool("IgnoreGamelist") || mIsCollectionSystem)
return;
@ -1078,7 +1084,8 @@ void SystemData::writeMetaData() {
updateGamelist(this);
}
void SystemData::onMetaDataSavePoint() {
void SystemData::onMetaDataSavePoint()
{
if (Settings::getInstance()->getString("SaveGamelistsMode") != "always")
return;
@ -1091,15 +1098,15 @@ void SystemData::setupSystemSortType(FileData* mRootFolder)
if (Settings::getInstance()->getString("DefaultSortOrder") != "") {
for (unsigned int i = 0; i < FileSorts::SortTypes.size(); i++) {
if (FileSorts::SortTypes.at(i).description ==
Settings::getInstance()->getString("DefaultSortOrder")) {
mRootFolder->setSortTypeString(Settings::getInstance()->
getString("DefaultSortOrder"));
Settings::getInstance()->getString("DefaultSortOrder")) {
mRootFolder->setSortTypeString(
Settings::getInstance()->getString("DefaultSortOrder"));
break;
}
}
}
// If no valid sort type was defined in the configuration file, set to default sorting.
if (mRootFolder->getSortTypeString() == "")
mRootFolder->setSortTypeString(Settings::getInstance()->
getDefaultString("DefaultSortOrder"));
mRootFolder->setSortTypeString(
Settings::getInstance()->getDefaultString("DefaultSortOrder"));
}

84
es-app/src/SystemData.h
View file

@ -35,15 +35,14 @@ class FindRules
{
public:
FindRules();
~FindRules();
void loadFindRules();
private:
struct EmulatorRules {
#if defined(_WIN64)
#if defined(_WIN64)
std::vector<std::string> winRegistryPaths;
#endif
#endif
std::vector<std::string> systemPaths;
std::vector<std::string> staticPaths;
};
@ -61,38 +60,41 @@ private:
class SystemData
{
public:
SystemData(
const std::string& name,
const std::string& fullName,
SystemEnvironmentData* envData,
const std::string& themeFolder,
bool CollectionSystem = false,
bool CustomCollectionSystem = false);
SystemData(const std::string& name,
const std::string& fullName,
SystemEnvironmentData* envData,
const std::string& themeFolder,
bool CollectionSystem = false,
bool CustomCollectionSystem = false);
~SystemData();
inline FileData* getRootFolder() const { return mRootFolder; };
inline const std::string& getName() const { return mName; }
inline const std::string& getFullName() const { return mFullName; }
inline const std::string& getStartPath() const { return mEnvData->mStartPath; }
inline const std::vector<std::string>& getExtensions() const
{ return mEnvData->mSearchExtensions; }
inline const std::string& getThemeFolder() const { return mThemeFolder; }
inline SystemEnvironmentData* getSystemEnvData() const { return mEnvData; }
inline const std::vector<PlatformIds::PlatformId>& getPlatformIds() const
{ return mEnvData->mPlatformIds; }
inline bool hasPlatformId(PlatformIds::PlatformId id) { if (!mEnvData) return false;
return std::find(mEnvData->mPlatformIds.cbegin(), mEnvData->mPlatformIds.cend(), id)
!= mEnvData->mPlatformIds.cend(); }
FileData* getRootFolder() const { return mRootFolder; }
const std::string& getName() const { return mName; }
const std::string& getFullName() const { return mFullName; }
const std::string& getStartPath() const { return mEnvData->mStartPath; }
const std::vector<std::string>& getExtensions() const { return mEnvData->mSearchExtensions; }
const std::string& getThemeFolder() const { return mThemeFolder; }
SystemEnvironmentData* getSystemEnvData() const { return mEnvData; }
const std::vector<PlatformIds::PlatformId>& getPlatformIds() const
{
return mEnvData->mPlatformIds;
}
bool hasPlatformId(PlatformIds::PlatformId id)
{
if (!mEnvData)
return false;
return std::find(mEnvData->mPlatformIds.cbegin(), mEnvData->mPlatformIds.cend(), id) !=
mEnvData->mPlatformIds.cend();
}
inline const std::shared_ptr<ThemeData>& getTheme() const { return mTheme; }
const std::shared_ptr<ThemeData>& getTheme() const { return mTheme; }
std::string getGamelistPath(bool forWrite) const;
bool hasGamelist() const;
std::string getThemePath() const;
std::pair<unsigned int, unsigned int> getDisplayedGameCount() const;
bool getScrapeFlag() { return mScrapeFlag; };
bool getScrapeFlag() { return mScrapeFlag; }
void setScrapeFlag(bool scrapeflag) { mScrapeFlag = scrapeflag; }
static void deleteSystems();
@ -106,16 +108,22 @@ public:
static std::vector<SystemData*> sSystemVector;
static std::unique_ptr<FindRules> sFindRules;
inline std::vector<SystemData*>::const_iterator getIterator() const
{ return std::find(sSystemVector.cbegin(), sSystemVector.cend(), this); };
inline std::vector<SystemData*>::const_reverse_iterator getRevIterator() const
{ return std::find(sSystemVector.crbegin(), sSystemVector.crend(), this); };
inline bool isCollection() { return mIsCollectionSystem; };
inline bool isCustomCollection() { return mIsCustomCollectionSystem; };
inline bool isGroupedCustomCollection() { return mIsGroupedCustomCollectionSystem; };
std::vector<SystemData*>::const_iterator getIterator() const
{
return std::find(sSystemVector.cbegin(), sSystemVector.cend(), this);
}
std::vector<SystemData*>::const_reverse_iterator getRevIterator() const
{
return std::find(sSystemVector.crbegin(), sSystemVector.crend(), this);
}
bool isCollection() { return mIsCollectionSystem; }
bool isCustomCollection() { return mIsCustomCollectionSystem; }
bool isGroupedCustomCollection() { return mIsGroupedCustomCollectionSystem; }
void setIsGroupedCustomCollection(bool isGroupedCustom)
{ mIsGroupedCustomCollectionSystem = isGroupedCustom; };
inline bool isGameSystem() { return mIsGameSystem; };
{
mIsGroupedCustomCollectionSystem = isGroupedCustom;
};
bool isGameSystem() { return mIsGameSystem; }
bool isVisible();
@ -123,14 +131,14 @@ public:
SystemData* getPrev() const;
static SystemData* getRandomSystem(const SystemData* currentSystem);
FileData* getRandomGame(const FileData* currentGame = nullptr);
FileData* getPlaceholder() { return mPlaceholder; };
FileData* getPlaceholder() { return mPlaceholder; }
void sortSystem(bool reloadGamelist = true, bool jumpToFirstRow = false);
// Load or re-load theme.
void loadTheme();
FileFilterIndex* getIndex() { return mFilterIndex; };
FileFilterIndex* getIndex() { return mFilterIndex; }
void onMetaDataSavePoint();
void writeMetaData();
@ -141,7 +149,7 @@ private:
bool mIsCustomCollectionSystem;
bool mIsGroupedCustomCollectionSystem;
bool mIsGameSystem;
bool mScrapeFlag; // Only used by scraper GUI to remember which systems to scrape.
bool mScrapeFlag; // Only used by scraper GUI to remember which systems to scrape.
std::string mName;
std::string mFullName;
SystemEnvironmentData* mEnvData;

218
es-app/src/SystemScreensaver.cpp
View file

@ -10,21 +10,18 @@
#include "SystemScreensaver.h"
#include "components/VideoFFmpegComponent.h"
#if defined(_RPI_)
#include "components/VideoOmxComponent.h"
#endif
#if defined(BUILD_VLC_PLAYER)
#include "components/VideoVlcComponent.h"
#endif
#include "resources/Font.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "views/gamelist/IGameListView.h"
#include "views/ViewController.h"
#include "AudioManager.h"
#include "FileData.h"
#include "Log.h"
#include "SystemData.h"
#include "resources/Font.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include "views/gamelist/IGameListView.h"
#include <random>
#include <time.h>
@ -36,24 +33,23 @@
#define FADE_TIME 300
SystemScreensaver::SystemScreensaver(
Window* window)
: mWindow(window),
mState(STATE_INACTIVE),
mImageScreensaver(nullptr),
mVideoScreensaver(nullptr),
mCurrentGame(nullptr),
mPreviousGame(nullptr),
mTimer(0),
mMediaSwapTime(0),
mTriggerNextGame(false),
mHasMediaFiles(false),
mFallbackScreensaver(false),
mOpacity(0.0f),
mDimValue(1.0),
mRectangleFadeIn(50),
mTextFadeIn(0),
mSaturationAmount(1.0)
SystemScreensaver::SystemScreensaver(Window* window)
: mWindow(window)
, mState(STATE_INACTIVE)
, mImageScreensaver(nullptr)
, mVideoScreensaver(nullptr)
, mCurrentGame(nullptr)
, mPreviousGame(nullptr)
, mTimer(0)
, mMediaSwapTime(0)
, mTriggerNextGame(false)
, mHasMediaFiles(false)
, mFallbackScreensaver(false)
, mOpacity(0.0f)
, mDimValue(1.0)
, mRectangleFadeIn(50)
, mTextFadeIn(0)
, mSaturationAmount(1.0)
{
mWindow->setScreensaver(this);
}
@ -65,21 +61,6 @@ SystemScreensaver::~SystemScreensaver()
delete mImageScreensaver;
}
bool SystemScreensaver::allowSleep()
{
return ((mVideoScreensaver == nullptr) && (mImageScreensaver == nullptr));
}
bool SystemScreensaver::isScreensaverActive()
{
return (mState != STATE_INACTIVE);
}
bool SystemScreensaver::isFallbackScreensaver()
{
return mFallbackScreensaver;
}
void SystemScreensaver::startScreensaver(bool generateMediaList)
{
std::string path = "";
@ -146,14 +127,14 @@ void SystemScreensaver::startScreensaver(bool generateMediaList)
mImageScreensaver->setImage(path);
mImageScreensaver->setOrigin(0.5f, 0.5f);
mImageScreensaver->setPosition(Renderer::getScreenWidth() / 2.0f,
Renderer::getScreenHeight() / 2.0f);
Renderer::getScreenHeight() / 2.0f);
if (Settings::getInstance()->getBool("ScreensaverStretchImages"))
mImageScreensaver->setResize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
else
mImageScreensaver->setMaxSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
}
mTimer = 0;
return;
@ -179,34 +160,26 @@ void SystemScreensaver::startScreensaver(bool generateMediaList)
if (Settings::getInstance()->getBool("ScreensaverVideoGameInfo"))
generateOverlayInfo();
#if defined(_RPI_)
// Create the correct type of video component.
if (Settings::getInstance()->getBool("ScreensaverOmxPlayer"))
mVideoScreensaver = new VideoOmxComponent(mWindow);
else if (Settings::getInstance()->getString("VideoPlayer") == "vlc")
mVideoScreensaver = new VideoVlcComponent(mWindow);
else
mVideoScreensaver = new VideoFFmpegComponent(mWindow);
#elif defined(BUILD_VLC_PLAYER)
#if defined(BUILD_VLC_PLAYER)
if (Settings::getInstance()->getString("VideoPlayer") == "vlc")
mVideoScreensaver = new VideoVlcComponent(mWindow);
else
mVideoScreensaver = new VideoFFmpegComponent(mWindow);
#else
#else
mVideoScreensaver = new VideoFFmpegComponent(mWindow);
#endif
#endif
mVideoScreensaver->topWindow(true);
mVideoScreensaver->setOrigin(0.5f, 0.5f);
mVideoScreensaver->setPosition(Renderer::getScreenWidth() / 2.0f,
Renderer::getScreenHeight() / 2.0f);
Renderer::getScreenHeight() / 2.0f);
if (Settings::getInstance()->getBool("ScreensaverStretchVideos"))
mVideoScreensaver->setResize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
else
mVideoScreensaver->setMaxSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
static_cast<float>(Renderer::getScreenHeight()));
mVideoScreensaver->setVideo(path);
mVideoScreensaver->setScreensaverMode(true);
@ -229,16 +202,17 @@ void SystemScreensaver::stopScreensaver()
mState = STATE_INACTIVE;
mDimValue = 1.0;
mDimValue = 1.0f;
mRectangleFadeIn = 50;
mTextFadeIn = 0;
mSaturationAmount = 1.0;
mSaturationAmount = 1.0f;
if (mGameOverlay)
mGameOverlay.reset();
}
void SystemScreensaver::nextGame() {
void SystemScreensaver::nextGame()
{
stopScreensaver();
startScreensaver(false);
}
@ -249,8 +223,8 @@ void SystemScreensaver::launchGame()
// Launching game
ViewController::get()->triggerGameLaunch(mCurrentGame);
ViewController::get()->goToGameList(mCurrentGame->getSystem());
IGameListView* view = ViewController::get()->
getGameListView(mCurrentGame->getSystem()).get();
IGameListView* view =
ViewController::get()->getGameListView(mCurrentGame->getSystem()).get();
view->setCursor(mCurrentGame);
ViewController::get()->cancelViewTransitions();
}
@ -261,8 +235,8 @@ void SystemScreensaver::goToGame()
if (mCurrentGame != nullptr) {
// Go to the game in the gamelist view, but don't launch it.
ViewController::get()->goToGameList(mCurrentGame->getSystem());
IGameListView* view = ViewController::get()->
getGameListView(mCurrentGame->getSystem()).get();
IGameListView* view =
ViewController::get()->getGameListView(mCurrentGame->getSystem()).get();
view->setCursor(mCurrentGame);
ViewController::get()->cancelViewTransitions();
}
@ -276,7 +250,7 @@ void SystemScreensaver::renderScreensaver()
// Render a black background below the video.
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
// Only render the video if the state requires it.
if (static_cast<int>(mState) >= STATE_FADE_IN_VIDEO) {
@ -288,7 +262,7 @@ void SystemScreensaver::renderScreensaver()
// Render a black background below the image.
Renderer::setMatrix(Transform4x4f::Identity());
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
static_cast<float>(Renderer::getScreenHeight()), 0x000000FF, 0x000000FF);
// Only render the image if the state requires it.
if (static_cast<int>(mState) >= STATE_FADE_IN_VIDEO) {
@ -305,20 +279,20 @@ void SystemScreensaver::renderScreensaver()
Renderer::setMatrix(Transform4x4f::Identity());
if (Settings::getInstance()->getString("ScreensaverType") == "slideshow") {
if (mHasMediaFiles) {
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
if (Settings::getInstance()->getBool("ScreensaverSlideshowScanlines"))
Renderer::shaderPostprocessing(Renderer::SHADER_SCANLINES);
#endif
#endif
if (Settings::getInstance()->getBool("ScreensaverSlideshowGameInfo") &&
mGameOverlay) {
mGameOverlay) {
if (mGameOverlayRectangleCoords.size() == 4) {
Renderer::drawRect(mGameOverlayRectangleCoords[0],
mGameOverlayRectangleCoords[1], mGameOverlayRectangleCoords[2],
mGameOverlayRectangleCoords[3], 0x00000000 | mRectangleFadeIn,
0x00000000 | mRectangleFadeIn );
Renderer::drawRect(
mGameOverlayRectangleCoords[0], mGameOverlayRectangleCoords[1],
mGameOverlayRectangleCoords[2], mGameOverlayRectangleCoords[3],
0x00000000 | mRectangleFadeIn, 0x00000000 | mRectangleFadeIn);
}
mRectangleFadeIn = Math::clamp(mRectangleFadeIn + 6 +
mRectangleFadeIn / 20, 0, 170);
mRectangleFadeIn =
Math::clamp(mRectangleFadeIn + 6 + mRectangleFadeIn / 20, 0, 170);
mGameOverlay.get()->setColor(0xFFFFFF00 | mTextFadeIn);
if (mTextFadeIn > 50)
@ -333,7 +307,7 @@ void SystemScreensaver::renderScreensaver()
}
else if (Settings::getInstance()->getString("ScreensaverType") == "video") {
if (mHasMediaFiles) {
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
Renderer::shaderParameters videoParameters;
unsigned int shaders = 0;
if (Settings::getInstance()->getBool("ScreensaverVideoScanlines"))
@ -341,6 +315,7 @@ void SystemScreensaver::renderScreensaver()
if (Settings::getInstance()->getBool("ScreensaverVideoBlur")) {
shaders |= Renderer::SHADER_BLUR_HORIZONTAL;
float heightModifier = Renderer::getScreenHeightModifier();
// clang-format off
if (heightModifier < 1)
videoParameters.blurPasses = 2; // Below 1080
else if (heightModifier >= 4)
@ -355,21 +330,22 @@ void SystemScreensaver::renderScreensaver()
videoParameters.blurPasses = 3; // 1440
else if (heightModifier >= 1)
videoParameters.blurPasses = 2; // 1080
// clang-format on
}
Renderer::shaderPostprocessing(shaders, videoParameters);
#endif
#endif
if (Settings::getInstance()->getBool("ScreensaverVideoGameInfo") && mGameOverlay) {
if (mGameOverlayRectangleCoords.size() == 4) {
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
Renderer::shaderPostprocessing(Renderer::SHADER_OPACITY);
#endif
Renderer::drawRect(mGameOverlayRectangleCoords[0],
mGameOverlayRectangleCoords[1], mGameOverlayRectangleCoords[2],
mGameOverlayRectangleCoords[3], 0x00000000 | mRectangleFadeIn,
0x00000000 | mRectangleFadeIn );
#endif
Renderer::drawRect(
mGameOverlayRectangleCoords[0], mGameOverlayRectangleCoords[1],
mGameOverlayRectangleCoords[2], mGameOverlayRectangleCoords[3],
0x00000000 | mRectangleFadeIn, 0x00000000 | mRectangleFadeIn);
}
mRectangleFadeIn = Math::clamp(mRectangleFadeIn + 6 +
mRectangleFadeIn / 20, 0, 170);
mRectangleFadeIn =
Math::clamp(mRectangleFadeIn + 6 + mRectangleFadeIn / 20, 0, 170);
mGameOverlay.get()->setColor(0xFFFFFF00 | mTextFadeIn);
if (mTextFadeIn > 50)
@ -383,8 +359,8 @@ void SystemScreensaver::renderScreensaver()
}
}
if (mFallbackScreensaver ||
Settings::getInstance()->getString("ScreensaverType") == "dim") {
#if defined(USE_OPENGL_21)
Settings::getInstance()->getString("ScreensaverType") == "dim") {
#if defined(USE_OPENGL_21)
Renderer::shaderParameters dimParameters;
dimParameters.fragmentDimValue = mDimValue;
Renderer::shaderPostprocessing(Renderer::SHADER_DIM, dimParameters);
@ -394,22 +370,22 @@ void SystemScreensaver::renderScreensaver()
Renderer::shaderPostprocessing(Renderer::SHADER_DESATURATE, dimParameters);
if (mSaturationAmount > 0.0)
mSaturationAmount = Math::clamp(mSaturationAmount - 0.035f, 0.0f, 1.0f);
#else
Renderer::drawRect(0.0f, 0.0f, Renderer::getScreenWidth(),
Renderer::getScreenHeight(), 0x000000A0, 0x000000A0);
#endif
#else
Renderer::drawRect(0.0f, 0.0f, Renderer::getScreenWidth(), Renderer::getScreenHeight(),
0x000000A0, 0x000000A0);
#endif
}
else if (Settings::getInstance()->getString("ScreensaverType") == "black") {
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
Renderer::shaderParameters blackParameters;
blackParameters.fragmentDimValue = mDimValue;
Renderer::shaderPostprocessing(Renderer::SHADER_DIM, blackParameters);
if (mDimValue > 0.0)
mDimValue = Math::clamp(mDimValue - 0.045f, 0.0f, 1.0f);
#else
Renderer::drawRect(0.0f, 0.0f, Renderer::getScreenWidth(),
Renderer::getScreenHeight(), 0x000000FF, 0x000000FF);
#endif
#else
Renderer::drawRect(0.0f, 0.0f, Renderer::getScreenWidth(), Renderer::getScreenHeight(),
0x000000FF, 0x000000FF);
#endif
}
}
}
@ -458,8 +434,8 @@ void SystemScreensaver::update(int deltaTime)
void SystemScreensaver::generateImageList()
{
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
// We only want nodes from game systems that are not collections.
if (!(*it)->isGameSystem() || (*it)->isCollection())
continue;
@ -475,8 +451,8 @@ void SystemScreensaver::generateImageList()
void SystemScreensaver::generateVideoList()
{
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
// We only want nodes from game systems that are not collections.
if (!(*it)->isGameSystem() || (*it)->isCollection())
continue;
@ -493,7 +469,7 @@ void SystemScreensaver::generateVideoList()
void SystemScreensaver::generateCustomImageList()
{
std::string imageDir = Utils::FileSystem::expandHomePath(
Settings::getInstance()->getString("ScreensaverSlideshowImageDir"));
Settings::getInstance()->getString("ScreensaverSlideshowImageDir"));
// This makes it possible to set the custom image directory relative to the ES-DE binary
// directory or the ROM directory.
@ -503,7 +479,7 @@ void SystemScreensaver::generateCustomImageList()
if (imageDir != "" && Utils::FileSystem::isDirectory(imageDir)) {
std::string imageFilter = ".jpg, .JPG, .png, .PNG";
Utils::FileSystem::stringList dirContent = Utils::FileSystem::getDirContent(
imageDir, Settings::getInstance()->getBool("ScreensaverSlideshowRecurse"));
imageDir, Settings::getInstance()->getBool("ScreensaverSlideshowRecurse"));
for (auto it = dirContent.begin(); it != dirContent.end(); it++) {
if (Utils::FileSystem::isRegularFile(*it)) {
@ -513,8 +489,7 @@ void SystemScreensaver::generateCustomImageList()
}
}
else {
LOG(LogWarning) << "Custom screensaver image directory '" <<
imageDir << "' does not exist.";
LOG(LogWarning) << "Custom screensaver image directory '" << imageDir << "' does not exist";
}
}
@ -540,12 +515,11 @@ void SystemScreensaver::pickRandomImage(std::string& path)
// Get a random number in range.
std::random_device randDev;
// Mersenne Twister pseudorandom number generator.
std::mt19937 engine{randDev()};
std::uniform_int_distribution<int>
uniform_dist(0, static_cast<int>(mImageFiles.size()) - 1);
std::mt19937 engine { randDev() };
std::uniform_int_distribution<int> uniform_dist(0,
static_cast<int>(mImageFiles.size()) - 1);
index = uniform_dist(engine);
}
while (mPreviousGame && mImageFiles.at(index) == mPreviousGame);
} while (mPreviousGame && mImageFiles.at(index) == mPreviousGame);
path = mImageFiles.at(index)->getImagePath();
mGameName = mImageFiles.at(index)->getName();
@ -575,12 +549,11 @@ void SystemScreensaver::pickRandomVideo(std::string& path)
// Get a random number in range.
std::random_device randDev;
// Mersenne Twister pseudorandom number generator.
std::mt19937 engine{randDev()};
std::uniform_int_distribution<int>
uniform_dist(0, static_cast<int>(mVideoFiles.size()) - 1);
std::mt19937 engine { randDev() };
std::uniform_int_distribution<int> uniform_dist(0,
static_cast<int>(mVideoFiles.size()) - 1);
index = uniform_dist(engine);
}
while (mPreviousGame && mVideoFiles.at(index) == mPreviousGame);
} while (mPreviousGame && mVideoFiles.at(index) == mPreviousGame);
path = mVideoFiles.at(index)->getVideoPath();
mGameName = mVideoFiles.at(index)->getName();
@ -604,12 +577,11 @@ void SystemScreensaver::pickRandomCustomImage(std::string& path)
// Get a random number in range.
std::random_device randDev;
// Mersenne Twister pseudorandom number generator.
std::mt19937 engine{randDev()};
std::uniform_int_distribution<int>
uniform_dist(0, static_cast<int>(mImageCustomFiles.size()) - 1);
std::mt19937 engine { randDev() };
std::uniform_int_distribution<int> uniform_dist(
0, static_cast<int>(mImageCustomFiles.size()) - 1);
index = uniform_dist(engine);
}
while (mPreviousCustomImage != "" && mImageCustomFiles.at(index) == mPreviousCustomImage);
} while (mPreviousCustomImage != "" && mImageCustomFiles.at(index) == mPreviousCustomImage);
path = mImageCustomFiles.at(index);
mPreviousCustomImage = path;
@ -633,8 +605,8 @@ void SystemScreensaver::generateOverlayInfo()
const std::string systemName = Utils::String::toUpper(mSystemName);
const std::string overlayText = gameName + "\n" + systemName;
mGameOverlay = std::unique_ptr<TextCache>(mGameOverlayFont.at(0)->
buildTextCache(overlayText, posX, posY, 0xFFFFFFFF));
mGameOverlay = std::unique_ptr<TextCache>(
mGameOverlayFont.at(0)->buildTextCache(overlayText, posX, posY, 0xFFFFFFFF));
float textSizeX;
float textSizeY = mGameOverlayFont[0].get()->sizeText(overlayText).y();
@ -645,7 +617,7 @@ void SystemScreensaver::generateOverlayInfo()
// injected in the size calculation. Regardless, this workaround is working
// fine for the time being.
if (mGameOverlayFont[0].get()->sizeText(gameName).x() >
mGameOverlayFont[0].get()->sizeText(systemName).x())
mGameOverlayFont[0].get()->sizeText(systemName).x())
textSizeX = mGameOverlayFont[0].get()->sizeText(gameName).x();
else
textSizeX = mGameOverlayFont[0].get()->sizeText(systemName).x();

13
es-app/src/SystemScreensaver.h
View file

@ -22,9 +22,12 @@ public:
SystemScreensaver(Window* window);
virtual ~SystemScreensaver();
virtual bool allowSleep();
virtual bool isScreensaverActive();
virtual bool isFallbackScreensaver();
virtual bool allowSleep()
{
return ((mVideoScreensaver == nullptr) && (mImageScreensaver == nullptr));
}
virtual bool isScreensaverActive() { return (mState != STATE_INACTIVE); }
virtual bool isFallbackScreensaver() { return mFallbackScreensaver; }
virtual void startScreensaver(bool generateMediaList);
virtual void stopScreensaver();
@ -35,8 +38,8 @@ public:
virtual void renderScreensaver();
virtual void update(int deltaTime);
virtual FileData* getCurrentGame() { return mCurrentGame; };
virtual void triggerNextGame() { mTriggerNextGame = true; };
virtual FileData* getCurrentGame() { return mCurrentGame; }
virtual void triggerNextGame() { mTriggerNextGame = true; }
private:
void generateImageList();

106
es-app/src/VolumeControl.cpp
View file

@ -8,45 +8,30 @@
#include "VolumeControl.h"
#include "math/Misc.h"
#include "Log.h"
#if defined(_RPI_)
#include "Settings.h"
#endif
#include "math/Misc.h"
#if defined(_WIN64)
#include <cmath>
#endif
// The ALSA Audio Card and Audio Device selection code is disabled at the moment.
// As PulseAudio controls the sound devices for the desktop environment, it doesn't
// make much sense to be able to select ALSA devices directly.
// The code is still active for Raspberry Pi though as I'm not sure if this is
// useful for that device.
// Keeping mixerName and mixerCard at their default values should make sure that
// the rest of the volume control code in here compiles and works fine.
#if defined(__linux__)
#if defined(_RPI_) || defined(_VERO4K_)
std::string VolumeControl::mixerName = "PCM";
#else
std::string VolumeControl::mixerName = "Master";
#endif
std::string VolumeControl::mixerCard = "default";
#endif
VolumeControl* VolumeControl::sInstance = nullptr;
VolumeControl::VolumeControl()
#if defined(__linux__)
: mixerIndex(0),
mixerHandle(nullptr),
mixerElem(nullptr),
mixerSelemId(nullptr)
#elif defined(_WIN64)
: mixerHandle(nullptr),
endpointVolume(nullptr)
#endif
#if defined(__linux__)
: mixerIndex(0)
, mixerHandle(nullptr)
, mixerElem(nullptr)
, mixerSelemId(nullptr)
#elif defined(_WIN64)
: mixerHandle(nullptr)
, endpointVolume(nullptr)
#endif
{
init();
}
@ -54,9 +39,9 @@ VolumeControl::VolumeControl()
VolumeControl::~VolumeControl()
{
deinit();
#if defined(__linux__)
#if defined(__linux__)
snd_config_update_free_global();
#endif
#endif
}
VolumeControl* VolumeControl::getInstance()
@ -79,15 +64,10 @@ void VolumeControl::deleteInstance()
void VolumeControl::init()
{
// Initialize audio mixer interface.
#if defined(__linux__)
#if defined(__linux__)
// Try to open mixer device.
if (mixerHandle == nullptr) {
// Allow user to override the AudioCard and AudioDevice in es_settings.xml.
#if defined(_RPI_)
mixerCard = Settings::getInstance()->getString("AudioCard");
mixerName = Settings::getInstance()->getString("AudioDevice");
#endif
snd_mixer_selem_id_alloca(&mixerSelemId);
// Sets simple-mixer index and name.
snd_mixer_selem_id_set_index(mixerSelemId, mixerIndex);
@ -106,8 +86,8 @@ void VolumeControl::init()
LOG(LogDebug) << "VolumeControl::init(): Mixer initialized";
}
else {
LOG(LogError) <<
"VolumeControl::init(): Failed to find mixer elements!";
LOG(LogError)
<< "VolumeControl::init(): Failed to find mixer elements!";
snd_mixer_close(mixerHandle);
mixerHandle = nullptr;
}
@ -119,8 +99,8 @@ void VolumeControl::init()
}
}
else {
LOG(LogError) <<
"VolumeControl::init(): Failed to register simple element class!";
LOG(LogError)
<< "VolumeControl::init(): Failed to register simple element class!";
snd_mixer_close(mixerHandle);
mixerHandle = nullptr;
}
@ -135,31 +115,30 @@ void VolumeControl::init()
LOG(LogError) << "VolumeControl::init(): Failed to open ALSA mixer!";
}
}
#elif defined(_WIN64)
#elif defined(_WIN64)
// Windows Vista or above.
if (endpointVolume == nullptr) {
CoInitialize(nullptr);
IMMDeviceEnumerator* deviceEnumerator = nullptr;
CoCreateInstance(__uuidof(MMDeviceEnumerator), nullptr, CLSCTX_INPROC_SERVER,
__uuidof(IMMDeviceEnumerator), reinterpret_cast<LPVOID *>(&deviceEnumerator));
__uuidof(IMMDeviceEnumerator),
reinterpret_cast<LPVOID*>(&deviceEnumerator));
if (deviceEnumerator != nullptr) {
// Get default endpoint.
IMMDevice * defaultDevice = nullptr;
IMMDevice* defaultDevice = nullptr;
deviceEnumerator->GetDefaultAudioEndpoint(eRender, eConsole, &defaultDevice);
if (defaultDevice != nullptr) {
// Retrieve endpoint volume.
defaultDevice->Activate(__uuidof(IAudioEndpointVolume),
CLSCTX_INPROC_SERVER, nullptr,
reinterpret_cast<LPVOID *>(&endpointVolume));
defaultDevice->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER,
nullptr, reinterpret_cast<LPVOID*>(&endpointVolume));
if (endpointVolume == nullptr)
LOG(LogError) << "VolumeControl::init(): "
"Failed to get default audio endpoint volume!";
"Failed to get default audio endpoint volume!";
// Release default device. we don't need it anymore.
defaultDevice->Release();
}
else {
LOG(LogError) <<
"VolumeControl::init(): Failed to get default audio endpoint!";
LOG(LogError) << "VolumeControl::init(): Failed to get default audio endpoint!";
}
// Release device enumerator. we don't need it anymore.
deviceEnumerator->Release();
@ -169,13 +148,14 @@ void VolumeControl::init()
CoUninitialize();
}
}
#endif
#endif
}
void VolumeControl::deinit()
{
// Deinitialize audio mixer interface.
#if defined(__linux__)
#if defined(__linux__)
if (mixerHandle != nullptr) {
snd_mixer_detach(mixerHandle, mixerCard.c_str());
snd_mixer_free(mixerHandle);
@ -183,28 +163,28 @@ void VolumeControl::deinit()
mixerHandle = nullptr;
mixerElem = nullptr;
}
#elif defined(_WIN64)
#elif defined(_WIN64)
if (endpointVolume != nullptr) {
endpointVolume->Release();
endpointVolume = nullptr;
CoUninitialize();
}
#endif
#endif
}
int VolumeControl::getVolume() const
{
int volume = 0;
#if defined(__linux__)
#if defined(__linux__)
if (mixerElem != nullptr) {
// Get volume range.
long minVolume;
long maxVolume;
if (snd_mixer_selem_get_playback_volume_range(mixerElem, &minVolume, &maxVolume) == 0) {
long rawVolume;
if (snd_mixer_selem_get_playback_volume(mixerElem,
SND_MIXER_SCHN_MONO, &rawVolume) == 0) {
if (snd_mixer_selem_get_playback_volume(mixerElem, SND_MIXER_SCHN_MONO, &rawVolume) ==
0) {
// Bring into range 0-100.
rawVolume -= minVolume;
if (rawVolume > 0)
@ -218,7 +198,7 @@ int VolumeControl::getVolume() const
LOG(LogError) << "VolumeControl::getVolume(): Failed to get volume range";
}
}
#elif defined(_WIN64)
#elif defined(_WIN64)
if (endpointVolume != nullptr) {
// Windows Vista or above, uses EndpointVolume API.
float floatVolume = 0.0f; // 0-1
@ -230,7 +210,7 @@ int VolumeControl::getVolume() const
LOG(LogError) << "VolumeControl::getVolume(): Failed to get master volume!";
}
}
#endif
#endif
volume = Math::clamp(volume, 0, 100);
return volume;
@ -240,7 +220,7 @@ void VolumeControl::setVolume(int volume)
{
volume = Math::clamp(volume, 0, 100);
#if defined(__linux__)
#if defined(__linux__)
if (mixerElem != nullptr) {
// Get volume range.
long minVolume;
@ -248,10 +228,10 @@ void VolumeControl::setVolume(int volume)
if (snd_mixer_selem_get_playback_volume_range(mixerElem, &minVolume, &maxVolume) == 0) {
// Bring into minVolume-maxVolume range and set.
long rawVolume = (volume * (maxVolume - minVolume) / 100) + minVolume;
if (snd_mixer_selem_set_playback_volume(mixerElem,
SND_MIXER_SCHN_FRONT_LEFT, rawVolume) < 0 ||
snd_mixer_selem_set_playback_volume(mixerElem,
SND_MIXER_SCHN_FRONT_RIGHT, rawVolume) < 0) {
if (snd_mixer_selem_set_playback_volume(mixerElem, SND_MIXER_SCHN_FRONT_LEFT,
rawVolume) < 0 ||
snd_mixer_selem_set_playback_volume(mixerElem, SND_MIXER_SCHN_FRONT_RIGHT,
rawVolume) < 0) {
LOG(LogError) << "VolumeControl::getVolume(): Failed to set mixer volume";
}
}
@ -259,7 +239,7 @@ void VolumeControl::setVolume(int volume)
LOG(LogError) << "VolumeControl::getVolume(): Failed to get volume range";
}
}
#elif defined(_WIN64)
#elif defined(_WIN64)
if (endpointVolume != nullptr) {
// Windows Vista or above, uses EndpointVolume API.
float floatVolume = 0.0f; // 0-1
@ -268,5 +248,5 @@ void VolumeControl::setVolume(int volume)
if (endpointVolume->SetMasterVolumeLevelScalar(floatVolume, nullptr) != S_OK)
LOG(LogError) << "VolumeControl::setVolume(): Failed to set master volume";
}
#endif
#endif
}

8
es-app/src/VolumeControl.h
View file

@ -38,18 +38,18 @@ public:
static VolumeControl* sInstance;
#if defined(__linux__)
#if defined(__linux__)
static std::string mixerName;
static std::string mixerCard;
int mixerIndex;
snd_mixer_t* mixerHandle;
snd_mixer_elem_t* mixerElem;
snd_mixer_selem_id_t* mixerSelemId;
#elif defined(_WIN64)
#elif defined(_WIN64)
HMIXER mixerHandle;
MIXERCONTROL mixerControl;
IAudioEndpointVolume * endpointVolume;
#endif
IAudioEndpointVolume* endpointVolume;
#endif
};
#endif // ES_APP_VOLUME_CONTROL_H

15
es-app/src/animations/MoveCameraAnimation.h
View file

@ -14,12 +14,12 @@
class MoveCameraAnimation : public Animation
{
public:
MoveCameraAnimation(
Transform4x4f& camera,
const Vector3f& target)
: mCameraStart(camera),
mTarget(target),
cameraOut(camera) {}
MoveCameraAnimation(Transform4x4f& camera, const Vector3f& target)
: mCameraStart(camera)
, mTarget(target)
, cameraOut(camera)
{
}
int getDuration() const override { return 400; }
@ -27,7 +27,8 @@ public:
{
// Cubic ease out.
t -= 1;
cameraOut.translation() = -Vector3f().lerp(-mCameraStart.translation(), mTarget, t*t*t + 1);
cameraOut.translation() =
-Vector3f().lerp(-mCameraStart.translation(), mTarget, t * t * t + 1);
}
private:

227
es-app/src/guis/GuiCollectionSystemsOptions.cpp
View file

@ -9,6 +9,7 @@
#include "guis/GuiCollectionSystemsOptions.h"
#include "CollectionSystemsManager.h"
#include "components/OptionListComponent.h"
#include "components/SwitchComponent.h"
#include "guis/GuiMsgBox.h"
@ -16,21 +17,23 @@
#include "guis/GuiTextEditPopup.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
Window* window,
std::string title)
: GuiSettings(window, title),
mAddedCustomCollection(false),
mDeletedCustomCollection(false)
GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(Window* window, std::string title)
: GuiSettings(window, title)
, mAddedCustomCollection(false)
, mDeletedCustomCollection(false)
{
// Finish editing custom collection.
if (CollectionSystemsManager::get()->isEditing()) {
ComponentListRow row;
row.addElement(std::make_shared<TextComponent>(mWindow, "FINISH EDITING '" +
Utils::String::toUpper(CollectionSystemsManager::get()->getEditingCollection()) +
"' COLLECTION", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(
mWindow,
"FINISH EDITING '" +
Utils::String::toUpper(
CollectionSystemsManager::get()->getEditingCollection()) +
"' COLLECTION",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.makeAcceptInputHandler([this] {
CollectionSystemsManager::get()->exitEditMode();
mWindow->invalidateCachedBackground();
@ -40,19 +43,20 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
}
// Automatic collections.
collection_systems_auto = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "SELECT COLLECTIONS", true);
collection_systems_auto = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "SELECT COLLECTIONS", true);
std::map<std::string, CollectionSystemData, stringComparator> autoSystems =
CollectionSystemsManager::get()->getAutoCollectionSystems();
CollectionSystemsManager::get()->getAutoCollectionSystems();
// Add automatic systems.
for (std::map<std::string, CollectionSystemData, stringComparator>::const_iterator
it = autoSystems.cbegin(); it != autoSystems.cend() ; it++)
for (std::map<std::string, CollectionSystemData, stringComparator>::const_iterator it =
autoSystems.cbegin();
it != autoSystems.cend(); it++)
collection_systems_auto->add(it->second.decl.longName, it->second.decl.name,
it->second.isEnabled);
it->second.isEnabled);
addWithLabel("AUTOMATIC GAME COLLECTIONS", collection_systems_auto);
addSaveFunc([this, autoSystems] {
std::string autoSystemsSelected = Utils::String::vectorToDelimitedString(
collection_systems_auto->getSelectedObjects(), ",", true);
collection_systems_auto->getSelectedObjects(), ",", true);
std::string autoSystemsConfig = Settings::getInstance()->getString("CollectionSystemsAuto");
if (autoSystemsSelected != autoSystemsConfig) {
if (CollectionSystemsManager::get()->isEditing())
@ -67,19 +71,19 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
}
else if (autoSystemsSelected != "") {
std::vector<std::string> selectedVector =
Utils::String::delimitedStringToVector(autoSystemsSelected, ",");
Utils::String::delimitedStringToVector(autoSystemsSelected, ",");
std::vector<std::string> configuredVector =
Utils::String::delimitedStringToVector(autoSystemsConfig, ",");
Utils::String::delimitedStringToVector(autoSystemsConfig, ",");
for (std::string system : selectedVector) {
if (std::find(configuredVector.begin(), configuredVector.end(), system) ==
configuredVector.end())
configuredVector.end())
addedAutoSystems.push_back(system);
}
}
if (!addedAutoSystems.empty()) {
for (std::string system : addedAutoSystems)
CollectionSystemsManager::get()->
repopulateCollection(autoSystems.find(system)->second.system);
CollectionSystemsManager::get()->repopulateCollection(
autoSystems.find(system)->second.system);
}
setNeedsSaving();
setNeedsReloading();
@ -88,50 +92,52 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
});
// Custom collections.
collection_systems_custom = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "SELECT COLLECTIONS", true);
collection_systems_custom = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "SELECT COLLECTIONS", true);
std::map<std::string, CollectionSystemData, stringComparator> customSystems =
CollectionSystemsManager::get()->getCustomCollectionSystems();
CollectionSystemsManager::get()->getCustomCollectionSystems();
// Add custom systems.
for (std::map<std::string, CollectionSystemData, stringComparator>::const_iterator
it = customSystems.cbegin(); it != customSystems.cend() ; it++)
for (std::map<std::string, CollectionSystemData, stringComparator>::const_iterator it =
customSystems.cbegin();
it != customSystems.cend(); it++)
collection_systems_custom->add(it->second.decl.longName, it->second.decl.name,
it->second.isEnabled);
it->second.isEnabled);
addWithLabel("CUSTOM GAME COLLECTIONS", collection_systems_custom);
addSaveFunc([this, customSystems] {
if (!mDeletedCustomCollection) {
std::string customSystemsSelected = Utils::String::vectorToDelimitedString(
collection_systems_custom->getSelectedObjects(), ",", true);
std::string customSystemsConfig = Settings::getInstance()->
getString("CollectionSystemsCustom");
collection_systems_custom->getSelectedObjects(), ",", true);
std::string customSystemsConfig =
Settings::getInstance()->getString("CollectionSystemsCustom");
if (customSystemsSelected != customSystemsConfig) {
if (CollectionSystemsManager::get()->isEditing())
CollectionSystemsManager::get()->exitEditMode();
Settings::getInstance()->setString("CollectionSystemsCustom",
customSystemsSelected);
customSystemsSelected);
// Check if any systems have been enabled, and if so repopulate them, which
// results in a complete initialization of their content. This is necessary as
// collections aren't updated while they are disabled.
std::vector<std::string> addedCustomSystems;
if (customSystemsConfig == "") {
addedCustomSystems =
Utils::String::delimitedStringToVector(customSystemsSelected, ",");
Utils::String::delimitedStringToVector(customSystemsSelected, ",");
}
else if (customSystemsSelected != "") {
std::vector<std::string> selectedVector =
Utils::String::delimitedStringToVector(customSystemsSelected, ",");
Utils::String::delimitedStringToVector(customSystemsSelected, ",");
std::vector<std::string> configuredVector =
Utils::String::delimitedStringToVector(customSystemsConfig, ",");
Utils::String::delimitedStringToVector(customSystemsConfig, ",");
for (std::string system : selectedVector) {
if (std::find(configuredVector.begin(), configuredVector.end(), system) ==
configuredVector.end())
configuredVector.end())
addedCustomSystems.push_back(system);
}
}
if (!mAddedCustomCollection && !addedCustomSystems.empty()) {
for (std::string system : addedCustomSystems)
CollectionSystemsManager::get()->
repopulateCollection(customSystems.find(system)->second.system);
CollectionSystemsManager::get()->repopulateCollection(
customSystems.find(system)->second.system);
}
setNeedsSaving();
setNeedsReloading();
@ -143,32 +149,33 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
// Create custom collection from theme.
std::vector<std::string> unusedFolders =
CollectionSystemsManager::get()->getUnusedSystemsFromTheme();
CollectionSystemsManager::get()->getUnusedSystemsFromTheme();
if (unusedFolders.size() > 0) {
ComponentListRow row;
auto themeCollection = std::make_shared<TextComponent>(mWindow,
"CREATE NEW CUSTOM COLLECTION FROM THEME", Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto themeCollection =
std::make_shared<TextComponent>(mWindow, "CREATE NEW CUSTOM COLLECTION FROM THEME",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto bracketThemeCollection = std::make_shared<ImageComponent>(mWindow);
bracketThemeCollection->setImage(":/graphics/arrow.svg");
bracketThemeCollection->setResize(Vector2f(0,
Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
bracketThemeCollection->setResize(
Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
row.addElement(themeCollection, true);
row.addElement(bracketThemeCollection, false);
row.makeAcceptInputHandler([this, unusedFolders] {
auto ss = new GuiSettings(mWindow, "SELECT THEME FOLDER");
std::shared_ptr<OptionListComponent<std::string>> folderThemes =
std::make_shared<OptionListComponent<std::string>>(mWindow,
getHelpStyle(), "SELECT THEME FOLDER", true);
std::make_shared<OptionListComponent<std::string>>(mWindow, getHelpStyle(),
"SELECT THEME FOLDER", true);
// Add custom systems.
for (auto it = unusedFolders.cbegin() ; it != unusedFolders.cend() ; it++ ) {
for (auto it = unusedFolders.cbegin(); it != unusedFolders.cend(); it++) {
ComponentListRow row;
std::string name = *it;
std::function<void()> createCollectionCall = [this, name] {
createCustomCollection(name);
};
row.makeAcceptInputHandler(createCollectionCall);
auto themeFolder = std::make_shared<TextComponent>(mWindow,
Utils::String::toUpper(name), Font::get(FONT_SIZE_SMALL), 0x777777FF);
auto themeFolder = std::make_shared<TextComponent>(
mWindow, Utils::String::toUpper(name), Font::get(FONT_SIZE_SMALL), 0x777777FF);
row.addElement(themeFolder, true);
// This transparent bracket is only added to generate the correct help prompts.
auto bracket = std::make_shared<ImageComponent>(mWindow);
@ -184,12 +191,11 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
// Create new custom collection.
ComponentListRow row;
auto newCollection = std::make_shared<TextComponent>(mWindow,
"CREATE NEW CUSTOM COLLECTION", Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto newCollection = std::make_shared<TextComponent>(mWindow, "CREATE NEW CUSTOM COLLECTION",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto bracketNewCollection = std::make_shared<ImageComponent>(mWindow);
bracketNewCollection->setImage(":/graphics/arrow.svg");
bracketNewCollection->setResize(Vector2f(0,
Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
bracketNewCollection->setResize(Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
row.addElement(newCollection, true);
row.addElement(bracketNewCollection, false);
auto createCollectionCall = [this](const std::string& newVal) {
@ -202,72 +208,72 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
createCustomCollection(name);
};
row.makeAcceptInputHandler([this, createCollectionCall] {
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(),
"New Collection Name", "", createCollectionCall, false, "SAVE"));
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), "New Collection Name", "",
createCollectionCall, false, "SAVE"));
});
addRow(row);
// Delete custom collection.
row.elements.clear();
auto deleteCollection = std::make_shared<TextComponent>(mWindow,
"DELETE CUSTOM COLLECTION", Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto deleteCollection = std::make_shared<TextComponent>(
mWindow, "DELETE CUSTOM COLLECTION", Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto bracketDeleteCollection = std::make_shared<ImageComponent>(mWindow);
bracketDeleteCollection->setImage(":/graphics/arrow.svg");
bracketDeleteCollection->setResize(Vector2f(0,
Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
bracketDeleteCollection->setResize(Vector2f(0, Font::get(FONT_SIZE_MEDIUM)->getLetterHeight()));
row.addElement(deleteCollection, true);
row.addElement(bracketDeleteCollection, false);
row.makeAcceptInputHandler([this, customSystems] {
auto ss = new GuiSettings(mWindow, "SELECT COLLECTION TO DELETE");
std::shared_ptr<OptionListComponent<std::string>> customCollections =
std::make_shared<OptionListComponent<std::string>>(mWindow,
getHelpStyle(), "", true);
for (std::map<std::string, CollectionSystemData, stringComparator>::const_iterator
it = customSystems.cbegin(); it != customSystems.cend() ; it++) {
std::make_shared<OptionListComponent<std::string>>(mWindow, getHelpStyle(), "", true);
for (std::map<std::string, CollectionSystemData, stringComparator>::const_iterator it =
customSystems.cbegin();
it != customSystems.cend(); it++) {
ComponentListRow row;
std::string name = (*it).first;
std::function<void()> deleteCollectionCall = [this, name] {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"THIS WILL PERMANENTLY\nDELETE THE COLLECTION\n'" +
Utils::String::toUpper(name) + "'\n"
mWindow->pushGui(new GuiMsgBox(
mWindow, getHelpStyle(),
"THIS WILL PERMANENTLY\nDELETE THE COLLECTION\n'" +
Utils::String::toUpper(name) +
"'\n"
"ARE YOU SURE?",
"YES", [this, name] {
if (CollectionSystemsManager::get()->isEditing())
CollectionSystemsManager::get()->exitEditMode();
mDeletedCustomCollection = true;
std::vector<std::string> selectedCustomCollections =
collection_systems_custom->getSelectedObjects();
std::string collectionsConfigEntry;
// Create the configuration file entry. If the collection to be
// deleted was activated, then exclude it.
for (auto it = selectedCustomCollections.begin();
it != selectedCustomCollections.end(); it++) {
if ((*it) != name) {
if ((*it) != selectedCustomCollections.front() &&
collectionsConfigEntry != "")
collectionsConfigEntry += ",";
collectionsConfigEntry += (*it);
}
"YES",
[this, name] {
if (CollectionSystemsManager::get()->isEditing())
CollectionSystemsManager::get()->exitEditMode();
mDeletedCustomCollection = true;
std::vector<std::string> selectedCustomCollections =
collection_systems_custom->getSelectedObjects();
std::string collectionsConfigEntry;
// Create the configuration file entry. If the collection to be
// deleted was activated, then exclude it.
for (auto it = selectedCustomCollections.begin();
it != selectedCustomCollections.end(); it++) {
if ((*it) != name) {
if ((*it) != selectedCustomCollections.front() &&
collectionsConfigEntry != "")
collectionsConfigEntry += ",";
collectionsConfigEntry += (*it);
}
// If the system to be deleted was present in es_settings.xml, we
// need to re-write it.
if (collectionsConfigEntry !=
Settings::getInstance()->getString("CollectionSystemsCustom")) {
Settings::getInstance()->setString("CollectionSystemsCustom",
collectionsConfigEntry);
setNeedsSaving();
setNeedsGoToStart();
}
CollectionSystemsManager::get()->deleteCustomCollection(name);
return true;
},
"NO", [this] {
return false;
}));
}
// If the system to be deleted was present in es_settings.xml, we
// need to re-write it.
if (collectionsConfigEntry !=
Settings::getInstance()->getString("CollectionSystemsCustom")) {
Settings::getInstance()->setString("CollectionSystemsCustom",
collectionsConfigEntry);
setNeedsSaving();
setNeedsGoToStart();
}
CollectionSystemsManager::get()->deleteCustomCollection(name);
return true;
},
"NO", [this] { return false; }));
};
row.makeAcceptInputHandler(deleteCollectionCall);
auto customCollection = std::make_shared<TextComponent>(mWindow,
Utils::String::toUpper(name), Font::get(FONT_SIZE_SMALL), 0x777777FF);
auto customCollection = std::make_shared<TextComponent>(
mWindow, Utils::String::toUpper(name), Font::get(FONT_SIZE_SMALL), 0x777777FF);
row.addElement(customCollection, true);
// This transparent bracket is only added generate the correct help prompts.
auto bracket = std::make_shared<ImageComponent>(mWindow);
@ -310,14 +316,14 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
// Group unthemed custom collections.
auto use_custom_collections_system = std::make_shared<SwitchComponent>(mWindow);
use_custom_collections_system->setState(Settings::getInstance()->
getBool("UseCustomCollectionsSystem"));
use_custom_collections_system->setState(
Settings::getInstance()->getBool("UseCustomCollectionsSystem"));
addWithLabel("GROUP UNTHEMED CUSTOM COLLECTIONS", use_custom_collections_system);
addSaveFunc([this, use_custom_collections_system] {
if (use_custom_collections_system->getState() !=
Settings::getInstance()->getBool("UseCustomCollectionsSystem")) {
Settings::getInstance()->getBool("UseCustomCollectionsSystem")) {
Settings::getInstance()->setBool("UseCustomCollectionsSystem",
use_custom_collections_system->getState());
use_custom_collections_system->getState());
if (CollectionSystemsManager::get()->isEditing())
CollectionSystemsManager::get()->exitEditMode();
setNeedsSaving();
@ -330,14 +336,14 @@ GuiCollectionSystemsOptions::GuiCollectionSystemsOptions(
// Show system names in collections.
auto collection_show_system_info = std::make_shared<SwitchComponent>(mWindow);
collection_show_system_info->setState(Settings::getInstance()->
getBool("CollectionShowSystemInfo"));
collection_show_system_info->setState(
Settings::getInstance()->getBool("CollectionShowSystemInfo"));
addWithLabel("SHOW SYSTEM NAMES IN COLLECTIONS", collection_show_system_info);
addSaveFunc([this, collection_show_system_info] {
if (collection_show_system_info->getState() !=
Settings::getInstance()->getBool("CollectionShowSystemInfo")) {
Settings::getInstance()->getBool("CollectionShowSystemInfo")) {
Settings::getInstance()->setBool("CollectionShowSystemInfo",
collection_show_system_info->getState());
collection_show_system_info->getState());
setNeedsSaving();
setNeedsReloading();
setInvalidateCachedBackground();
@ -350,10 +356,9 @@ void GuiCollectionSystemsOptions::createCustomCollection(std::string inName)
if (CollectionSystemsManager::get()->isEditing())
CollectionSystemsManager::get()->exitEditMode();
std::string collectionName = CollectionSystemsManager::get()->
getValidNewCollectionName(inName);
SystemData* newCollection = CollectionSystemsManager::get()->
addNewCustomCollection(collectionName);
std::string collectionName = CollectionSystemsManager::get()->getValidNewCollectionName(inName);
SystemData* newCollection =
CollectionSystemsManager::get()->addNewCustomCollection(collectionName);
CollectionSystemsManager::get()->saveCustomCollection(newCollection);
collection_systems_custom->add(collectionName, collectionName, true);

3
es-app/src/guis/GuiCollectionSystemsOptions.h
View file

@ -12,8 +12,7 @@
#include "GuiSettings.h"
template<typename T>
class OptionListComponent;
template <typename T> class OptionListComponent;
class GuiCollectionSystemsOptions : public GuiSettings
{

135
es-app/src/guis/GuiGameScraper.cpp
View file

@ -10,23 +10,22 @@
#include "guis/GuiGameScraper.h"
#include "FileData.h"
#include "MameNames.h"
#include "SystemData.h"
#include "components/ButtonComponent.h"
#include "components/MenuComponent.h"
#include "components/TextComponent.h"
#include "views/ViewController.h"
#include "FileData.h"
#include "MameNames.h"
#include "SystemData.h"
GuiGameScraper::GuiGameScraper(
Window* window,
ScraperSearchParams params,
std::function<void(const ScraperSearchResult&)> doneFunc)
: GuiComponent(window),
mGrid(window, Vector2i(1, 7)),
mBox(window, ":/graphics/frame.svg"),
mSearchParams(params),
mClose(false)
GuiGameScraper::GuiGameScraper(Window* window,
ScraperSearchParams params,
std::function<void(const ScraperSearchResult&)> doneFunc)
: GuiComponent(window)
, mGrid(window, Vector2i(1, 7))
, mBox(window, ":/graphics/frame.svg")
, mSearchParams(params)
, mClose(false)
{
addChild(&mBox);
addChild(&mGrid);
@ -40,87 +39,75 @@ GuiGameScraper::GuiGameScraper(
}
else {
if (params.game->isArcadeGame() &&
Settings::getInstance()->getString("Scraper") == "thegamesdb")
scrapeName = Utils::FileSystem::getFileName(mSearchParams.game->getPath()) + " (" +
MameNames::getInstance()->getCleanName(mSearchParams.game->getCleanName()) +
")";
Settings::getInstance()->getString("Scraper") == "thegamesdb")
scrapeName =
Utils::FileSystem::getFileName(mSearchParams.game->getPath()) + " (" +
MameNames::getInstance()->getCleanName(mSearchParams.game->getCleanName()) + ")";
else
scrapeName = Utils::FileSystem::getFileName(mSearchParams.game->getPath());
}
mGameName = std::make_shared<TextComponent>(mWindow, scrapeName +
mGameName = std::make_shared<TextComponent>(
mWindow,
scrapeName +
((mSearchParams.game->getType() == FOLDER) ? " " + ViewController::FOLDER_CHAR : ""),
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mGameName, Vector2i(0, 1), false, true);
// Row 2 is a spacer.
mSystemName = std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(
mSearchParams.system->getFullName()), Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_CENTER);
mSystemName = std::make_shared<TextComponent>(
mWindow, Utils::String::toUpper(mSearchParams.system->getFullName()),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mGrid.setEntry(mSystemName, Vector2i(0, 3), false, true);
// Row 4 is a spacer.
// GuiScraperSearch.
mSearch = std::make_shared<GuiScraperSearch>(window,
GuiScraperSearch::NEVER_AUTO_ACCEPT, 1);
mSearch = std::make_shared<GuiScraperSearch>(window, GuiScraperSearch::NEVER_AUTO_ACCEPT, 1);
mGrid.setEntry(mSearch, Vector2i(0, 5), true);
// Buttons
std::vector<std::shared_ptr<ButtonComponent>> buttons;
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "REFINE SEARCH",
"refine search", [&] {
mSearch->openInputScreen(mSearchParams);
mGrid.resetCursor();
buttons.push_back(
std::make_shared<ButtonComponent>(mWindow, "REFINE SEARCH", "refine search", [&] {
// Refine the search, unless the result has already been accepted.
if (!mSearch->getAcceptedResult()) {
mSearch->openInputScreen(mSearchParams);
mGrid.resetCursor();
}
}));
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "CANCEL", "cancel", [&] {
if (mSearch->getSavedNewMedia()) {
// If the user aborted the scraping but there was still some media downloaded,
// then force an unload of the textures for the game image and marquee, and make
// an update of the game entry. Otherwise the images would not get updated until
// the user scrolls up and down the gamelist.
TextureResource::manualUnload(mSearchParams.game->getImagePath(), false);
TextureResource::manualUnload(mSearchParams.game->getMarqueePath(), false);
ViewController::get()->onFileChanged(mSearchParams.game, true);
}
delete this;
}));
buttons.push_back(std::make_shared<ButtonComponent>(
mWindow, "CANCEL", "cancel", [&] {
if (mSearch->getSavedNewMedia()) {
// If the user aborted the scraping but there was still some media downloaded,
// then force an unload of the textures for the game image and marquee, and make
// an update of the game entry. Otherwise the images would not get updated until
// the user scrolls up and down the gamelist.
TextureResource::manualUnload(mSearchParams.game->getImagePath(), false);
TextureResource::manualUnload(mSearchParams.game->getMarqueePath(), false);
ViewController::get()->onFileChanged(mSearchParams.game, true);
}
delete this; }));
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 6), true, false);
// We call this->close() instead of just 'delete this' in the accept callback.
// This is because of how GuiComponent::update works. If it was just 'delete this',
// the following would happen when the metadata resolver is done:
// GuiGameScraper::update()
// GuiComponent::update()
// it = mChildren.cbegin();
// mBox::update()
// it++;
// mSearchComponent::update()
// acceptCallback -> delete this
// it++; // Error, mChildren has been deleted because it was part of 'this'.
// So instead we do this:
// GuiGameScraper::update()
// GuiComponent::update()
// it = mChildren.cbegin();
// mBox::update()
// it++;
// mSearchComponent::update()
// acceptCallback -> close() -> mClose = true
// it++; // OK.
// if (mClose)
// delete this;
mSearch->setAcceptCallback([this, doneFunc](const ScraperSearchResult& result) {
doneFunc(result); close(); });
doneFunc(result);
close();
});
mSearch->setCancelCallback([&] { delete this; });
setSize(Renderer::getScreenWidth() * 0.95f, Renderer::getScreenHeight() * 0.747f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2, (Renderer::getScreenHeight() -
mSize.y()) / 2);
// Limit the width of the GUI on ultrawide monitors. The 1.778 aspect ratio value is
// the 16:9 reference.
float aspectValue = 1.778f / Renderer::getScreenAspectRatio();
float width = Math::clamp(0.95f * aspectValue, 0.70f, 0.95f) * Renderer::getScreenWidth();
setSize(width, Renderer::getScreenHeight() * 0.747f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
mGrid.resetCursor();
mSearch->search(params); // Start the search.
@ -128,14 +115,14 @@ GuiGameScraper::GuiGameScraper(
void GuiGameScraper::onSizeChanged()
{
mBox.fitTo(mSize, Vector3f::Zero(), Vector2f(-32, -32));
mBox.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mGrid.setRowHeightPerc(0, 0.04f, false);
mGrid.setRowHeightPerc(1, mGameName->getFont()->getLetterHeight() /
mSize.y(), false); // Game name.
mGrid.setRowHeightPerc(1, mGameName->getFont()->getLetterHeight() / mSize.y(),
false); // Game name.
mGrid.setRowHeightPerc(2, 0.04f, false);
mGrid.setRowHeightPerc(3, mSystemName->getFont()->getLetterHeight() /
mSize.y(), false); // System name.
mGrid.setRowHeightPerc(3, mSystemName->getFont()->getLetterHeight() / mSize.y(),
false); // System name.
mGrid.setRowHeightPerc(4, 0.04f, false);
mGrid.setRowHeightPerc(6, mButtonGrid->getSize().y() / mSize.y(), false); // Buttons.
mGrid.setSize(mSize);
@ -170,7 +157,10 @@ void GuiGameScraper::update(int deltaTime)
std::vector<HelpPrompt> GuiGameScraper::getHelpPrompts()
{
return mGrid.getHelpPrompts();
std::vector<HelpPrompt> prompts = mGrid.getHelpPrompts();
prompts.push_back(HelpPrompt("b", "back (cancel)"));
return prompts;
}
HelpStyle GuiGameScraper::getHelpStyle()
@ -182,5 +172,6 @@ HelpStyle GuiGameScraper::getHelpStyle()
void GuiGameScraper::close()
{
// This will cause update() to close the GUI.
mClose = true;
}

7
es-app/src/guis/GuiGameScraper.h
View file

@ -11,15 +11,16 @@
#ifndef ES_APP_GUIS_GUI_GAME_SCRAPER_H
#define ES_APP_GUIS_GUI_GAME_SCRAPER_H
#include "GuiComponent.h"
#include "components/NinePatchComponent.h"
#include "guis/GuiScraperSearch.h"
#include "GuiComponent.h"
class GuiGameScraper : public GuiComponent
{
public:
GuiGameScraper(Window* window, ScraperSearchParams params,
std::function<void(const ScraperSearchResult&)> doneFunc);
GuiGameScraper(Window* window,
ScraperSearchParams params,
std::function<void(const ScraperSearchResult&)> doneFunc);
void onSizeChanged() override;

81
es-app/src/guis/GuiGamelistFilter.cpp
View file

@ -10,21 +10,20 @@
#include "guis/GuiGamelistFilter.h"
#include "SystemData.h"
#include "components/OptionListComponent.h"
#include "guis/GuiTextEditPopup.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "SystemData.h"
GuiGamelistFilter::GuiGamelistFilter(
Window* window,
SystemData* system,
std::function<void(bool)> filterChangedCallback)
: GuiComponent(window),
mMenu(window, "FILTER GAMELIST BY"),
mSystem(system),
mFiltersChangedCallback(filterChangedCallback),
mFiltersChanged(false)
GuiGamelistFilter::GuiGamelistFilter(Window* window,
SystemData* system,
std::function<void(bool)> filterChangedCallback)
: GuiComponent(window)
, mMenu(window, "FILTER GAMELIST BY")
, mSystem(system)
, mFiltersChangedCallback(filterChangedCallback)
, mFiltersChanged(false)
{
initializeMenu();
}
@ -41,7 +40,8 @@ void GuiGamelistFilter::initializeMenu()
// Show filtered menu.
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow, "RESET ALL FILTERS",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.makeAcceptInputHandler(std::bind(&GuiGamelistFilter::resetAllFilters, this));
mMenu.addRow(row);
row.elements.clear();
@ -51,13 +51,15 @@ void GuiGamelistFilter::initializeMenu()
mMenu.addButton("BACK", "back", std::bind(&GuiGamelistFilter::applyFilters, this));
mMenu.setPosition((Renderer::getScreenWidth() - mMenu.getSize().x()) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
Renderer::getScreenHeight() * 0.13f);
// Save the initial filter values to be able to check later if any changes were made.
mInitialTextFilter = mTextFilterField->getValue();
for (std::map<FilterIndexType, std::shared_ptr<OptionListComponent<std::string>>>::
const_iterator it = mFilterOptions.cbegin(); it != mFilterOptions.cend(); it++) {
for (std::map<FilterIndexType,
std::shared_ptr<OptionListComponent<std::string>>>::const_iterator it =
mFilterOptions.cbegin();
it != mFilterOptions.cend(); it++) {
std::shared_ptr<OptionListComponent<std::string>> optionList = it->second;
std::vector<std::string> filters = optionList->getSelectedObjects();
mInitialFilters.push_back(filters);
@ -67,8 +69,10 @@ void GuiGamelistFilter::initializeMenu()
void GuiGamelistFilter::resetAllFilters()
{
mFilterIndex->resetFilters();
for (std::map<FilterIndexType, std::shared_ptr< OptionListComponent<std::string>>>::
const_iterator it = mFilterOptions.cbegin(); it != mFilterOptions.cend(); it++) {
for (std::map<FilterIndexType,
std::shared_ptr<OptionListComponent<std::string>>>::const_iterator it =
mFilterOptions.cbegin();
it != mFilterOptions.cend(); it++) {
std::shared_ptr<OptionListComponent<std::string>> optionList = it->second;
optionList->selectNone();
}
@ -78,21 +82,18 @@ void GuiGamelistFilter::resetAllFilters()
mFiltersChanged = true;
}
GuiGamelistFilter::~GuiGamelistFilter()
{
mFilterOptions.clear();
}
GuiGamelistFilter::~GuiGamelistFilter() { mFilterOptions.clear(); }
void GuiGamelistFilter::addFiltersToMenu()
{
ComponentListRow row;
auto lbl = std::make_shared<TextComponent>(mWindow,
Utils::String::toUpper("TEXT FILTER (GAME NAME)"),
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
auto lbl =
std::make_shared<TextComponent>(mWindow, Utils::String::toUpper("TEXT FILTER (GAME NAME)"),
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
mTextFilterField = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_RIGHT);
mTextFilterField = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_MEDIUM),
0x777777FF, ALIGN_RIGHT);
// Don't show the free text filter entry unless there are any games in the system.
if (mSystem->getRootFolder()->getChildren().size() > 0) {
@ -113,25 +114,25 @@ void GuiGamelistFilter::addFiltersToMenu()
// Callback function.
auto updateVal = [this](const std::string& newVal) {
mTextFilterField->setValue(Utils::String::toUpper(newVal));
mFilterIndex->setTextFilter(Utils::String::toUpper(newVal));
mTextFilterField->setValue(Utils::String::toUpper(newVal));
mFilterIndex->setTextFilter(Utils::String::toUpper(newVal));
};
row.makeAcceptInputHandler([this, updateVal] {
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(),
"TEXT FILTER (GAME NAME)", mTextFilterField->getValue(),
updateVal, false, "OK", "APPLY CHANGES?"));
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), "TEXT FILTER (GAME NAME)",
mTextFilterField->getValue(), updateVal, false, "OK",
"APPLY CHANGES?"));
});
mMenu.addRow(row);
std::vector<FilterDataDecl> decls = mFilterIndex->getFilterDataDecls();
for (std::vector<FilterDataDecl>::const_iterator it =
decls.cbegin(); it != decls.cend(); it++) {
for (std::vector<FilterDataDecl>::const_iterator it = decls.cbegin(); // Line break.
it != decls.cend(); it++) {
FilterIndexType type = (*it).type; // Type of filter.
// All possible filters for this type.
// All possible filters for this type.
std::map<std::string, int>* allKeys = (*it).allIndexKeys;
std::string menuLabel = (*it).menuLabel; // Text to show in menu.
std::shared_ptr<OptionListComponent<std::string>> optionList;
@ -140,9 +141,9 @@ void GuiGamelistFilter::addFiltersToMenu()
ComponentListRow row;
// Add genres.
optionList = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), menuLabel, true);
for (auto it: *allKeys)
optionList = std::make_shared<OptionListComponent<std::string>>(mWindow, getHelpStyle(),
menuLabel, true);
for (auto it : *allKeys)
optionList->add(it.first, it.first, mFilterIndex->isKeyBeingFilteredBy(it.first, type));
if (allKeys->size() > 0)
mMenu.addWithLabel(menuLabel, optionList);
@ -157,8 +158,10 @@ void GuiGamelistFilter::applyFilters()
mFiltersChanged = true;
std::vector<FilterDataDecl> decls = mFilterIndex->getFilterDataDecls();
for (std::map<FilterIndexType, std::shared_ptr<OptionListComponent<std::string>>>::
const_iterator it = mFilterOptions.cbegin(); it != mFilterOptions.cend(); it++) {
for (std::map<FilterIndexType,
std::shared_ptr<OptionListComponent<std::string>>>::const_iterator it =
mFilterOptions.cbegin();
it != mFilterOptions.cend(); it++) {
std::shared_ptr<OptionListComponent<std::string>> optionList = it->second;
std::vector<std::string> filters = optionList->getSelectedObjects();
auto iteratorDistance = std::distance(mFilterOptions.cbegin(), it);

8
es-app/src/guis/GuiGamelistFilter.h
View file

@ -11,19 +11,19 @@
#ifndef ES_APP_GUIS_GUI_GAME_LIST_FILTER_H
#define ES_APP_GUIS_GUI_GAME_LIST_FILTER_H
#include "components/MenuComponent.h"
#include "FileFilterIndex.h"
#include "GuiComponent.h"
#include "components/MenuComponent.h"
template<typename T>
class OptionListComponent;
template <typename T> class OptionListComponent;
class SystemData;
class GuiGamelistFilter : public GuiComponent
{
public:
GuiGamelistFilter(Window* window,
SystemData* system, std::function<void(bool)> filtersChangedCallback);
SystemData* system,
std::function<void(bool)> filtersChangedCallback);
~GuiGamelistFilter();
bool input(InputConfig* config, Input input) override;

202
es-app/src/guis/GuiGamelistOptions.cpp
View file

@ -12,11 +12,6 @@
#include "GuiGamelistOptions.h"
#include "guis/GuiGamelistFilter.h"
#include "scrapers/Scraper.h"
#include "views/gamelist/IGameListView.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "FileFilterIndex.h"
#include "FileSorts.h"
@ -24,18 +19,21 @@
#include "MameNames.h"
#include "Sound.h"
#include "SystemData.h"
#include "guis/GuiGamelistFilter.h"
#include "scrapers/Scraper.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "views/gamelist/IGameListView.h"
GuiGamelistOptions::GuiGamelistOptions(
Window* window,
SystemData* system)
: GuiComponent(window),
mSystem(system),
mMenu(window, "OPTIONS"),
mFiltersChanged(false),
mCancelled(false),
mIsCustomCollection(false),
mIsCustomCollectionGroup(false),
mCustomCollectionSystem(nullptr)
GuiGamelistOptions::GuiGamelistOptions(Window* window, SystemData* system)
: GuiComponent(window)
, mSystem(system)
, mMenu(window, "OPTIONS")
, mFiltersChanged(false)
, mCancelled(false)
, mIsCustomCollection(false)
, mIsCustomCollectionGroup(false)
, mCustomCollectionSystem(nullptr)
{
addChild(&mMenu);
@ -46,11 +44,10 @@ GuiGamelistOptions::GuiGamelistOptions(
ComponentListRow row;
// There is some special logic required for custom collections.
if (file->getSystem()->isCustomCollection() &&
file->getPath() != file->getSystem()->getName())
if (file->getSystem()->isCustomCollection() && file->getPath() != file->getSystem()->getName())
mIsCustomCollection = true;
else if (file->getSystem()->isCustomCollection() &&
file->getPath() == file->getSystem()->getName())
file->getPath() == file->getSystem()->getName())
mIsCustomCollectionGroup = true;
if (mFromPlaceholder && file->getSystem()->isGroupedCustomCollection())
@ -84,12 +81,12 @@ GuiGamelistOptions::GuiGamelistOptions(
else {
// Check if the currently selected game is a favorite.
bool isFavorite = false;
if (mFirstLetterIndex.size() == 1 && mFirstLetterIndex.front() ==
ViewController::FAVORITE_CHAR)
if (mFirstLetterIndex.size() == 1 &&
mFirstLetterIndex.front() == ViewController::FAVORITE_CHAR)
isFavorite = true;
else if (mFirstLetterIndex.size() > 1 && (mFirstLetterIndex.front() ==
ViewController::FAVORITE_CHAR || mFirstLetterIndex[1] ==
ViewController::FAVORITE_CHAR))
else if (mFirstLetterIndex.size() > 1 &&
(mFirstLetterIndex.front() == ViewController::FAVORITE_CHAR ||
mFirstLetterIndex[1] == ViewController::FAVORITE_CHAR))
isFavorite = true;
// Get the first character of the game name (which could be a Unicode character).
@ -99,8 +96,8 @@ GuiGamelistOptions::GuiGamelistOptions(
mCurrentFirstCharacter = Utils::String::getFirstCharacter(file->getSortName());
}
mJumpToLetterList = std::make_shared<LetterList>(mWindow, getHelpStyle(),
"JUMP TO...", false);
mJumpToLetterList =
std::make_shared<LetterList>(mWindow, getHelpStyle(), "JUMP TO...", false);
// Populate the quick selector.
for (unsigned int i = 0; i < mFirstLetterIndex.size(); i++) {
@ -146,8 +143,9 @@ GuiGamelistOptions::GuiGamelistOptions(
if (!mIsCustomCollectionGroup && system->getRootFolder()->getChildren().size() > 0) {
if (system->getName() != "recent" && Settings::getInstance()->getBool("GamelistFilters")) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>
(mWindow, "FILTER GAMELIST", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "FILTER GAMELIST",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.addElement(makeArrow(mWindow), false);
row.makeAcceptInputHandler(std::bind(&GuiGamelistOptions::openGamelistFilter, this));
mMenu.addRow(row);
@ -155,12 +153,12 @@ GuiGamelistOptions::GuiGamelistOptions(
}
// Add a dummy entry when applicable as the menu looks quite ugly if it's just blank.
else if (!CollectionSystemsManager::get()->isEditing() &&
mSystem->getRootFolder()->getChildren().size() == 0 &&
!mIsCustomCollectionGroup && !mIsCustomCollection) {
mSystem->getRootFolder()->getChildren().size() == 0 && !mIsCustomCollectionGroup &&
!mIsCustomCollection) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>
(mWindow, "THIS SYSTEM HAS NO GAMES",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "THIS SYSTEM HAS NO GAMES",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
mMenu.addRow(row);
}
@ -171,34 +169,40 @@ GuiGamelistOptions::GuiGamelistOptions(
customSystem = system->getName();
if (UIModeController::getInstance()->isUIModeFull() &&
(mIsCustomCollection || mIsCustomCollectionGroup)) {
(mIsCustomCollection || mIsCustomCollectionGroup)) {
if (CollectionSystemsManager::get()->getEditingCollection() != customSystem) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(
mWindow, "ADD/REMOVE GAMES TO THIS COLLECTION",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow,
"ADD/REMOVE GAMES TO THIS COLLECTION",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.makeAcceptInputHandler(std::bind(&GuiGamelistOptions::startEditMode, this));
mMenu.addRow(row);
}
}
if (UIModeController::getInstance()->isUIModeFull() &&
CollectionSystemsManager::get()->isEditing()) {
CollectionSystemsManager::get()->isEditing()) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(
mWindow, "FINISH EDITING '" + Utils::String::toUpper(
CollectionSystemsManager::get()->getEditingCollection()) +
"' COLLECTION",Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
mWindow,
"FINISH EDITING '" +
Utils::String::toUpper(
CollectionSystemsManager::get()->getEditingCollection()) +
"' COLLECTION",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.makeAcceptInputHandler(std::bind(&GuiGamelistOptions::exitEditMode, this));
mMenu.addRow(row);
}
if (file->getType() == FOLDER) {
if (UIModeController::getInstance()->isUIModeFull() && !mFromPlaceholder &&
!(mSystem->isCollection() && file->getType() == FOLDER)) {
!(mSystem->isCollection() && file->getType() == FOLDER)) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow,
"EDIT THIS FOLDER'S METADATA", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "EDIT THIS FOLDER'S METADATA",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.addElement(makeArrow(mWindow), false);
row.makeAcceptInputHandler(std::bind(&GuiGamelistOptions::openMetaDataEd, this));
mMenu.addRow(row);
@ -206,10 +210,11 @@ GuiGamelistOptions::GuiGamelistOptions(
}
else {
if (UIModeController::getInstance()->isUIModeFull() && !mFromPlaceholder &&
!(mSystem->isCollection() && file->getType() == FOLDER)) {
!(mSystem->isCollection() && file->getType() == FOLDER)) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow,
"EDIT THIS GAME'S METADATA", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "EDIT THIS GAME'S METADATA",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.addElement(makeArrow(mWindow), false);
row.makeAcceptInputHandler(std::bind(&GuiGamelistOptions::openMetaDataEd, this));
mMenu.addRow(row);
@ -218,19 +223,25 @@ GuiGamelistOptions::GuiGamelistOptions(
// Buttons. The logic to apply or cancel settings are handled by the destructor.
if ((!mIsCustomCollectionGroup && system->getRootFolder()->getChildren().size() == 0) ||
system->getName() == "recent") {
mMenu.addButton("CLOSE", "close", [&] { mCancelled = true; delete this; });
system->getName() == "recent") {
mMenu.addButton("CLOSE", "close", [&] {
mCancelled = true;
delete this;
});
}
else {
mMenu.addButton("APPLY", "apply", [&] { delete this; });
mMenu.addButton("CANCEL", "cancel", [&] { mCancelled = true; delete this; });
mMenu.addButton("CANCEL", "cancel", [&] {
mCancelled = true;
delete this;
});
}
// Center the menu.
setSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
mMenu.setPosition((mSize.x() - mMenu.getSize().x()) / 2.0f, (mSize.y() -
mMenu.getSize().y()) / 2.0f);
mMenu.setPosition((mSize.x() - mMenu.getSize().x()) / 2.0f,
(mSize.y() - mMenu.getSize().y()) / 2.0f);
}
GuiGamelistOptions::~GuiGamelistOptions()
@ -248,11 +259,12 @@ GuiGamelistOptions::~GuiGamelistOptions()
if (!mFromPlaceholder) {
ViewController::get()->reloadGameListView(mSystem);
}
else if (!mCustomCollectionSystem->getRootFolder()->
getChildrenListToDisplay().empty()) {
ViewController::get()->reloadGameListView(mSystem);
getGamelist()->setCursor(mCustomCollectionSystem->
getRootFolder()->getChildrenListToDisplay().front());
else if (!mCustomCollectionSystem->getRootFolder()
->getChildrenListToDisplay()
.empty()) {
ViewController::get()->reloadGameListView(mSystem);
getGamelist()->setCursor(
mCustomCollectionSystem->getRootFolder()->getChildrenListToDisplay().front());
}
}
}
@ -262,6 +274,7 @@ GuiGamelistOptions::~GuiGamelistOptions()
if (!mFromPlaceholder) {
FileData* root;
if (mIsCustomCollection)
root = getGamelist()->getCursor()->getSystem()->getRootFolder();
else
@ -269,7 +282,7 @@ GuiGamelistOptions::~GuiGamelistOptions()
// If a new sorting type was selected, then sort and update mSortTypeString for the system.
if (!mIsCustomCollectionGroup &&
(*mListSort->getSelected()).description != root->getSortTypeString()) {
(*mListSort->getSelected()).description != root->getSortTypeString()) {
// This will also recursively sort children.
root->sort(*mListSort->getSelected(), mFavoritesSorting);
root->setSortTypeString((*mListSort->getSelected()).description);
@ -281,7 +294,7 @@ GuiGamelistOptions::~GuiGamelistOptions()
// Has the user changed the letter using the quick selector?
if (mCurrentFirstCharacter != mJumpToLetterList->getSelected()) {
if (mJumpToLetterList->getSelected() == ViewController::FAVORITE_CHAR ||
mJumpToLetterList->getSelected() == ViewController::FOLDER_CHAR)
mJumpToLetterList->getSelected() == ViewController::FOLDER_CHAR)
jumpToFirstRow();
else
jumpToLetter();
@ -303,7 +316,7 @@ void GuiGamelistOptions::openGamelistFilter()
if (mIsCustomCollection)
ggf = new GuiGamelistFilter(mWindow, getGamelist()->getCursor()->getSystem(),
filtersChangedFunc);
filtersChangedFunc);
else
ggf = new GuiGamelistFilter(mWindow, mSystem, filtersChangedFunc);
@ -329,10 +342,9 @@ void GuiGamelistOptions::startEditMode()
// Display the indication icons which show what games are part of the custom collection
// currently being edited. This is done cheaply using onFileChanged() which will trigger
// populateList().
for (auto it = SystemData::sSystemVector.begin();
it != SystemData::sSystemVector.end(); it++) {
for (auto it = SystemData::sSystemVector.begin(); it != SystemData::sSystemVector.end(); it++) {
ViewController::get()->getGameListView((*it))->onFileChanged(
ViewController::get()->getGameListView((*it))->getCursor(), false);
ViewController::get()->getGameListView((*it))->getCursor(), false);
}
if (mSystem->getRootFolder()->getChildren().size() == 0)
@ -362,12 +374,12 @@ void GuiGamelistOptions::openMetaDataEd()
clearGameBtnFunc = [this, file] {
if (file->getType() == FOLDER) {
LOG(LogInfo) << "Deleting the media files and gamelist.xml entry for the folder \"" <<
file->getFullPath() << "\"";
LOG(LogInfo) << "Deleting the media files and gamelist.xml entry for the folder \""
<< file->getFullPath() << "\"";
}
else {
LOG(LogInfo) << "Deleting the media files and gamelist.xml entry for the file \"" <<
file->getFullPath() << "\"";
LOG(LogInfo) << "Deleting the media files and gamelist.xml entry for the file \""
<< file->getFullPath() << "\"";
}
ViewController::get()->getGameListView(file->getSystem()).get()->removeMedia(file);
@ -375,10 +387,10 @@ void GuiGamelistOptions::openMetaDataEd()
const std::vector<MetaDataDecl>& mdd = file->metadata.getMDD();
for (auto it = mdd.cbegin(); it != mdd.cend(); it++) {
if (it->key == "name") {
if (file->isArcadeGame()) {
if (file->isArcadeGame()) {
// If it's a MAME or Neo Geo game, expand the game name accordingly.
file->metadata.set(it->key, MameNames::getInstance()->
getCleanName(file->getCleanName()));
file->metadata.set(
it->key, MameNames::getInstance()->getCleanName(file->getCleanName()));
}
else {
file->metadata.set(it->key, file->getDisplayName());
@ -408,8 +420,8 @@ void GuiGamelistOptions::openMetaDataEd()
};
deleteGameBtnFunc = [this, file] {
LOG(LogInfo) << "Deleting the game file \"" << file->getFullPath() <<
"\", all its media files and its gamelist.xml entry.";
LOG(LogInfo) << "Deleting the game file \"" << file->getFullPath()
<< "\", all its media files and its gamelist.xml entry.";
CollectionSystemsManager::get()->deleteCollectionFiles(file);
ViewController::get()->getGameListView(file->getSystem()).get()->removeMedia(file);
ViewController::get()->getGameListView(file->getSystem()).get()->remove(file, true);
@ -420,20 +432,20 @@ void GuiGamelistOptions::openMetaDataEd()
};
if (file->getType() == FOLDER) {
mWindow->pushGui(new GuiMetaDataEd(mWindow, &file->metadata,
file->metadata.getMDD(FOLDER_METADATA), p,
Utils::FileSystem::getFileName(file->getPath()), std::bind(
&IGameListView::onFileChanged, ViewController::get()->getGameListView(
file->getSystem()).get(), file, true),
clearGameBtnFunc, deleteGameBtnFunc));
mWindow->pushGui(new GuiMetaDataEd(
mWindow, &file->metadata, file->metadata.getMDD(FOLDER_METADATA), p,
Utils::FileSystem::getFileName(file->getPath()),
std::bind(&IGameListView::onFileChanged,
ViewController::get()->getGameListView(file->getSystem()).get(), file, true),
clearGameBtnFunc, deleteGameBtnFunc));
}
else {
mWindow->pushGui(new GuiMetaDataEd(mWindow, &file->metadata,
file->metadata.getMDD(GAME_METADATA), p,
Utils::FileSystem::getFileName(file->getPath()), std::bind(
&IGameListView::onFileChanged, ViewController::get()->getGameListView(
file->getSystem()).get(), file, true),
clearGameBtnFunc, deleteGameBtnFunc));
mWindow->pushGui(new GuiMetaDataEd(
mWindow, &file->metadata, file->metadata.getMDD(GAME_METADATA), p,
Utils::FileSystem::getFileName(file->getPath()),
std::bind(&IGameListView::onFileChanged,
ViewController::get()->getGameListView(file->getSystem()).get(), file, true),
clearGameBtnFunc, deleteGameBtnFunc));
}
}
@ -442,14 +454,14 @@ void GuiGamelistOptions::jumpToLetter()
char letter = mJumpToLetterList->getSelected().front();
// Get the gamelist.
const std::vector<FileData*>& files = getGamelist()->getCursor()->
getParent()->getChildrenListToDisplay();
const std::vector<FileData*>& files =
getGamelist()->getCursor()->getParent()->getChildrenListToDisplay();
for (unsigned int i = 0; i < files.size(); i++) {
if (mFavoritesSorting && (mFirstLetterIndex.front() == ViewController::FAVORITE_CHAR ||
mFirstLetterIndex.front() == ViewController::FOLDER_CHAR)) {
if (static_cast<char>(toupper(files.at(i)->getSortName().front())) ==
letter && !files.at(i)->getFavorite()) {
mFirstLetterIndex.front() == ViewController::FOLDER_CHAR)) {
if (static_cast<char>(toupper(files.at(i)->getSortName().front())) == letter &&
!files.at(i)->getFavorite()) {
if (!mOnlyHasFolders && mFoldersOnTop && files.at(i)->getType() == FOLDER) {
continue;
}
@ -477,8 +489,8 @@ void GuiGamelistOptions::jumpToFirstRow()
{
if (mFoldersOnTop && mJumpToLetterList->getSelected() == ViewController::FAVORITE_CHAR) {
// Get the gamelist.
const std::vector<FileData*>& files = getGamelist()->getCursor()->
getParent()->getChildrenListToDisplay();
const std::vector<FileData*>& files =
getGamelist()->getCursor()->getParent()->getChildrenListToDisplay();
// Select the first game that is not a folder, unless it's a folder-only list in
// which case the first line overall is selected.
for (auto it = files.cbegin(); it != files.cend(); it++) {
@ -502,8 +514,7 @@ bool GuiGamelistOptions::input(InputConfig* config, Input input)
if (input.value != 0 && config->isMappedTo("back", input))
mCancelled = true;
if (input.value != 0 && (config->isMappedTo("b", input) ||
config->isMappedTo("back", input))) {
if (input.value != 0 && (config->isMappedTo("b", input) || config->isMappedTo("back", input))) {
delete this;
return true;
}
@ -521,9 +532,8 @@ HelpStyle GuiGamelistOptions::getHelpStyle()
std::vector<HelpPrompt> GuiGamelistOptions::getHelpPrompts()
{
auto prompts = mMenu.getHelpPrompts();
if (mSystem->getRootFolder()->getChildren().size() > 0 ||
mIsCustomCollectionGroup || mIsCustomCollection ||
CollectionSystemsManager::get()->isEditing())
if (mSystem->getRootFolder()->getChildren().size() > 0 || mIsCustomCollectionGroup ||
mIsCustomCollection || CollectionSystemsManager::get()->isEditing())
prompts.push_back(HelpPrompt("a", "select"));
if (mSystem->getRootFolder()->getChildren().size() > 0 && mSystem->getName() != "recent") {
prompts.push_back(HelpPrompt("b", "close (apply)"));

4
es-app/src/guis/GuiGamelistOptions.h
View file

@ -13,11 +13,11 @@
#ifndef ES_APP_GUIS_GUI_GAME_LIST_OPTIONS_H
#define ES_APP_GUIS_GUI_GAME_LIST_OPTIONS_H
#include "FileData.h"
#include "GuiComponent.h"
#include "components/MenuComponent.h"
#include "components/OptionListComponent.h"
#include "utils/StringUtil.h"
#include "FileData.h"
#include "GuiComponent.h"
class IGameListView;
class SystemData;

21
es-app/src/guis/GuiInfoPopup.cpp
View file

@ -14,21 +14,18 @@
#include <SDL2/SDL_timer.h>
GuiInfoPopup::GuiInfoPopup(
Window* window,
std::string message,
int duration)
: GuiComponent(window),
mMessage(message),
mDuration(duration),
mRunning(true)
GuiInfoPopup::GuiInfoPopup(Window* window, std::string message, int duration)
: GuiComponent(window)
, mMessage(message)
, mDuration(duration)
, mRunning(true)
{
mFrame = new NinePatchComponent(window);
float maxWidth = Renderer::getScreenWidth() * 0.9f;
float maxHeight = Renderer::getScreenHeight() * 0.2f;
std::shared_ptr<TextComponent> s = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_MINI), 0x444444FF, ALIGN_CENTER);
std::shared_ptr<TextComponent> s = std::make_shared<TextComponent>(
mWindow, "", Font::get(FONT_SIZE_MINI), 0x444444FF, ALIGN_CENTER);
// We do this to force the text container to resize and return the actual expected popup size.
s->setSize(0.0f, 0.0f);
@ -51,13 +48,13 @@ GuiInfoPopup::GuiInfoPopup(
mSize[0] = mSize.x() + paddingX;
mSize[1] = mSize.y() + paddingY;
float posX = Renderer::getScreenWidth()* 0.5f - mSize.x() * 0.5f;
float posX = Renderer::getScreenWidth() * 0.5f - mSize.x() * 0.5f;
float posY = Renderer::getScreenHeight() * 0.02f;
setPosition(posX, posY, 0);
mFrame->setImagePath(":/graphics/frame.svg");
mFrame->fitTo(mSize, Vector3f::Zero(), Vector2f(-32, -32));
mFrame->fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
addChild(mFrame);
// We only initialize the actual time when we first start to render.

2
es-app/src/guis/GuiInfoPopup.h
View file

@ -22,7 +22,7 @@ public:
~GuiInfoPopup();
void render(const Transform4x4f& parentTrans) override;
inline void stop() override { mRunning = false; }
void stop() override { mRunning = false; }
private:
bool updateState();

88
es-app/src/guis/GuiLaunchScreen.cpp
View file

@ -8,20 +8,19 @@
#include "guis/GuiLaunchScreen.h"
#include "FileData.h"
#include "SystemData.h"
#include "components/ComponentGrid.h"
#include "components/TextComponent.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include "FileData.h"
#include "SystemData.h"
GuiLaunchScreen::GuiLaunchScreen(
Window* window)
: GuiComponent(window),
mBackground(window, ":/graphics/frame.svg"),
mGrid(nullptr),
mMarquee(nullptr),
mWindow(window)
GuiLaunchScreen::GuiLaunchScreen(Window* window)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(nullptr)
, mMarquee(nullptr)
, mWindow(window)
{
addChild(&mBackground);
mWindow->setLaunchScreen(this);
@ -29,6 +28,7 @@ GuiLaunchScreen::GuiLaunchScreen(
GuiLaunchScreen::~GuiLaunchScreen()
{
// This only executes when exiting the application.
closeLaunchScreen();
}
@ -51,49 +51,53 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
const float gameNameFontSize = 0.073f;
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0),
false, false, Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0), false, false,
Vector2i(1, 1));
// Title.
mTitle = std::make_shared<TextComponent>(mWindow, "LAUNCHING GAME",
Font::get(static_cast<int>(titleFontSize * std::min(Renderer::getScreenHeight(),
Renderer::getScreenWidth()))), 0x666666FF, ALIGN_CENTER);
mTitle = std::make_shared<TextComponent>(
mWindow, "LAUNCHING GAME",
Font::get(static_cast<int>(
titleFontSize * std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth()))),
0x666666FF, ALIGN_CENTER);
mGrid->setEntry(mTitle, Vector2i(1, 1), false, true, Vector2i(1, 1));
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 2),
false, false, Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 2), false, false,
Vector2i(1, 1));
// Row for the marquee.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 3),
false, false, Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 3), false, false,
Vector2i(1, 1));
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 4),
false, false, Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 4), false, false,
Vector2i(1, 1));
// Game name.
mGameName = std::make_shared<TextComponent>(mWindow, "GAME NAME",
Font::get(static_cast<int>(gameNameFontSize * std::min(Renderer::getScreenHeight(),
Renderer::getScreenWidth()))), 0x444444FF, ALIGN_CENTER);
mGameName = std::make_shared<TextComponent>(
mWindow, "GAME NAME",
Font::get(static_cast<int>(
gameNameFontSize * std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth()))),
0x444444FF, ALIGN_CENTER);
mGrid->setEntry(mGameName, Vector2i(1, 5), false, true, Vector2i(1, 1));
// System name.
mSystemName = std::make_shared<TextComponent>(mWindow, "SYSTEM NAME",
Font::get(FONT_SIZE_MEDIUM), 0x666666FF, ALIGN_CENTER);
mSystemName = std::make_shared<TextComponent>(
mWindow, "SYSTEM NAME", Font::get(FONT_SIZE_MEDIUM), 0x666666FF, ALIGN_CENTER);
mGrid->setEntry(mSystemName, Vector2i(1, 6), false, true, Vector2i(1, 1));
// Spacer row.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 7),
false, false, Vector2i(1, 1));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 7), false, false,
Vector2i(1, 1));
// Left spacer.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0),
false, false, Vector2i(1, 8));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false, false,
Vector2i(1, 8));
// Right spacer.
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(2, 0),
false, false, Vector2i(1, 8));
mGrid->setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(2, 0), false, false,
Vector2i(1, 8));
// Adjust the width depending on the aspect ratio of the screen, to make the screen look
// somewhat coherent regardless of screen type. The 1.778 aspect ratio value is the 16:9
@ -106,9 +110,11 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
float maxWidth = static_cast<float>(Renderer::getScreenWidth()) * maxWidthModifier;
float minWidth = static_cast<float>(Renderer::getScreenWidth()) * minWidthModifier;
float fontWidth = Font::get(static_cast<int>(gameNameFontSize *
std::min(Renderer::getScreenHeight(), Renderer::getScreenWidth())))->
sizeText(Utils::String::toUpper(game->getName())).x();
float fontWidth =
Font::get(static_cast<int>(gameNameFontSize * std::min(Renderer::getScreenHeight(),
Renderer::getScreenWidth())))
->sizeText(Utils::String::toUpper(game->getName()))
.x();
// Add a bit of width to compensate for the left and right spacers.
fontWidth += static_cast<float>(Renderer::getScreenWidth()) * 0.05f;
@ -159,7 +165,8 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
if (mImagePath != "") {
mMarquee->setImage(game->getMarqueePath(), false);
mMarquee->cropTransparentPadding(static_cast<float>(Renderer::getScreenWidth()) *
(0.25f * (1.778f / Renderer::getScreenAspectRatio())), mGrid->getRowHeight(3));
(0.25f * (1.778f / Renderer::getScreenAspectRatio())),
mGrid->getRowHeight(3));
mMarquee->setOrigin(0.5f, 0.5f);
Vector3f currentPos = mMarquee->getPosition();
@ -167,18 +174,18 @@ void GuiLaunchScreen::displayLaunchScreen(FileData* game)
// Position the image in the middle of row four.
currentPos.x() = mSize.x() / 2.0f;
currentPos.y() = mGrid->getRowHeight(0) + mGrid->getRowHeight(1) +
mGrid->getRowHeight(2) + mGrid->getRowHeight(3) / 2.0f;
currentPos.y() = mGrid->getRowHeight(0) + mGrid->getRowHeight(1) + mGrid->getRowHeight(2) +
mGrid->getRowHeight(3) / 2.0f;
mMarquee->setPosition(currentPos);
}
setOrigin({0.5f, 0.5f});
setOrigin({ 0.5f, 0.5f });
// Center on the X axis and keep slightly off-center on the Y axis.
setPosition(static_cast<float>(Renderer::getScreenWidth()) / 2.0f,
static_cast<float>(Renderer::getScreenHeight()) / 2.25f);
static_cast<float>(Renderer::getScreenHeight()) / 2.25f);
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32, -32));
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mBackground.setEdgeColor(0xEEEEEEFF);
}
@ -203,6 +210,7 @@ void GuiLaunchScreen::closeLaunchScreen()
void GuiLaunchScreen::onSizeChanged()
{
// Update mGrid size.
mGrid->setSize(mSize);
}

5
es-app/src/guis/GuiLaunchScreen.h
View file

@ -9,12 +9,12 @@
#ifndef ES_APP_GUIS_GUI_LAUNCH_SCREEN_H
#define ES_APP_GUIS_GUI_LAUNCH_SCREEN_H
#include "GuiComponent.h"
#include "Window.h"
#include "components/ComponentGrid.h"
#include "components/ImageComponent.h"
#include "components/NinePatchComponent.h"
#include "components/TextComponent.h"
#include "GuiComponent.h"
#include "Window.h"
class FileData;
@ -35,7 +35,6 @@ public:
private:
Window* mWindow;
ComponentGrid* mGrid;
NinePatchComponent mBackground;
std::shared_ptr<TextComponent> mTitle;

34
es-app/src/guis/GuiMediaViewerOptions.cpp
View file

@ -9,11 +9,11 @@
#include "guis/GuiMediaViewerOptions.h"
#include "components/SwitchComponent.h"
#include "Settings.h"
#include "components/SwitchComponent.h"
GuiMediaViewerOptions::GuiMediaViewerOptions(Window* window, const std::string& title)
: GuiSettings(window, title)
: GuiSettings(window, title)
{
// Keep videos running when viewing images.
auto keep_video_running = std::make_shared<SwitchComponent>(mWindow);
@ -21,9 +21,9 @@ GuiMediaViewerOptions::GuiMediaViewerOptions(Window* window, const std::string&
addWithLabel("KEEP VIDEOS RUNNING WHEN VIEWING IMAGES", keep_video_running);
addSaveFunc([keep_video_running, this] {
if (keep_video_running->getState() !=
Settings::getInstance()->getBool("MediaViewerKeepVideoRunning")) {
Settings::getInstance()->getBool("MediaViewerKeepVideoRunning")) {
Settings::getInstance()->setBool("MediaViewerKeepVideoRunning",
keep_video_running->getState());
keep_video_running->getState());
setNeedsSaving();
}
});
@ -34,23 +34,23 @@ GuiMediaViewerOptions::GuiMediaViewerOptions(Window* window, const std::string&
addWithLabel("STRETCH VIDEOS TO SCREEN RESOLUTION", stretch_videos);
addSaveFunc([stretch_videos, this] {
if (stretch_videos->getState() !=
Settings::getInstance()->getBool("MediaViewerStretchVideos")) {
Settings::getInstance()->getBool("MediaViewerStretchVideos")) {
Settings::getInstance()->setBool("MediaViewerStretchVideos",
stretch_videos->getState());
stretch_videos->getState());
setNeedsSaving();
}
});
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
// Render scanlines for videos using a shader.
auto video_scanlines = std::make_shared<SwitchComponent>(mWindow);
video_scanlines->setState(Settings::getInstance()->getBool("MediaViewerVideoScanlines"));
addWithLabel("RENDER SCANLINES FOR VIDEOS", video_scanlines);
addSaveFunc([video_scanlines, this] {
if (video_scanlines->getState() !=
Settings::getInstance()->getBool("MediaViewerVideoScanlines")) {
Settings::getInstance()->getBool("MediaViewerVideoScanlines")) {
Settings::getInstance()->setBool("MediaViewerVideoScanlines",
video_scanlines->getState());
video_scanlines->getState());
setNeedsSaving();
}
});
@ -60,26 +60,24 @@ GuiMediaViewerOptions::GuiMediaViewerOptions(Window* window, const std::string&
video_blur->setState(Settings::getInstance()->getBool("MediaViewerVideoBlur"));
addWithLabel("RENDER BLUR FOR VIDEOS", video_blur);
addSaveFunc([video_blur, this] {
if (video_blur->getState() !=
Settings::getInstance()->getBool("MediaViewerVideoBlur")) {
Settings::getInstance()->setBool("MediaViewerVideoBlur",
video_blur->getState());
if (video_blur->getState() != Settings::getInstance()->getBool("MediaViewerVideoBlur")) {
Settings::getInstance()->setBool("MediaViewerVideoBlur", video_blur->getState());
setNeedsSaving();
}
});
// Render scanlines for screenshots using a shader.
auto screenshot_scanlines = std::make_shared<SwitchComponent>(mWindow);
screenshot_scanlines->setState(Settings::getInstance()->
getBool("MediaViewerScreenshotScanlines"));
screenshot_scanlines->setState(
Settings::getInstance()->getBool("MediaViewerScreenshotScanlines"));
addWithLabel("RENDER SCANLINES FOR SCREENSHOTS", screenshot_scanlines);
addSaveFunc([screenshot_scanlines, this] {
if (screenshot_scanlines->getState() !=
Settings::getInstance()->getBool("MediaViewerScreenshotScanlines")) {
Settings::getInstance()->getBool("MediaViewerScreenshotScanlines")) {
Settings::getInstance()->setBool("MediaViewerScreenshotScanlines",
screenshot_scanlines->getState());
screenshot_scanlines->getState());
setNeedsSaving();
}
});
#endif
#endif
}

685
es-app/src/guis/GuiMenu.cpp
View file

File diff suppressed because it is too large Load diff

8
es-app/src/guis/GuiMenu.h
View file

@ -10,9 +10,9 @@
#ifndef ES_APP_GUIS_GUI_MENU_H
#define ES_APP_GUIS_GUI_MENU_H
#include "GuiComponent.h"
#include "components/MenuComponent.h"
#include "guis/GuiSettings.h"
#include "GuiComponent.h"
class GuiMenu : public GuiComponent
{
@ -27,8 +27,10 @@ public:
private:
void close(bool closeAllWindows);
void addEntry(const std::string& name, unsigned int color,
bool add_arrow, const std::function<void()>& func);
void addEntry(const std::string& name,
unsigned int color,
bool add_arrow,
const std::function<void()>& func);
void addVersionInfo();
void openScraperOptions();

330
es-app/src/guis/GuiMetaDataEd.cpp
View file

@ -11,6 +11,12 @@
#include "guis/GuiMetaDataEd.h"
#include "CollectionSystemsManager.h"
#include "FileData.h"
#include "FileFilterIndex.h"
#include "Gamelist.h"
#include "SystemData.h"
#include "Window.h"
#include "components/ButtonComponent.h"
#include "components/ComponentList.h"
#include "components/DateTimeEditComponent.h"
@ -18,69 +24,63 @@
#include "components/RatingComponent.h"
#include "components/SwitchComponent.h"
#include "components/TextComponent.h"
#include "guis/GuiComplexTextEditPopup.h"
#include "guis/GuiGameScraper.h"
#include "guis/GuiMsgBox.h"
#include "guis/GuiTextEditPopup.h"
#include "guis/GuiComplexTextEditPopup.h"
#include "resources/Font.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "FileData.h"
#include "FileFilterIndex.h"
#include "Gamelist.h"
#include "SystemData.h"
#include "Window.h"
GuiMetaDataEd::GuiMetaDataEd(
Window* window,
MetaDataList* md,
const std::vector<MetaDataDecl>& mdd,
ScraperSearchParams scraperParams,
const std::string& /*header*/,
std::function<void()> saveCallback,
std::function<void()> clearGameFunc,
std::function<void()> deleteGameFunc)
: GuiComponent(window),
mScraperParams(scraperParams),
mBackground(window, ":/graphics/frame.svg"),
mGrid(window, Vector2i(1, 3)),
mMetaDataDecl(mdd),
mMetaData(md),
mSavedCallback(saveCallback),
mClearGameFunc(clearGameFunc),
mDeleteGameFunc(deleteGameFunc),
mMediaFilesUpdated(false)
GuiMetaDataEd::GuiMetaDataEd(Window* window,
MetaDataList* md,
const std::vector<MetaDataDecl>& mdd,
ScraperSearchParams scraperParams,
const std::string& /*header*/,
std::function<void()> saveCallback,
std::function<void()> clearGameFunc,
std::function<void()> deleteGameFunc)
: GuiComponent(window)
, mScraperParams(scraperParams)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 3))
, mMetaDataDecl(mdd)
, mMetaData(md)
, mSavedCallback(saveCallback)
, mClearGameFunc(clearGameFunc)
, mDeleteGameFunc(deleteGameFunc)
, mMediaFilesUpdated(false)
{
addChild(&mBackground);
addChild(&mGrid);
mHeaderGrid = std::make_shared<ComponentGrid>(mWindow, Vector2i(1, 5));
mTitle = std::make_shared<TextComponent>(mWindow, "EDIT METADATA",
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
mTitle = std::make_shared<TextComponent>(mWindow, "EDIT METADATA", Font::get(FONT_SIZE_LARGE),
0x555555FF, ALIGN_CENTER);
// Extract possible subfolders from the path.
std::string folderPath = Utils::String::replace(
Utils::FileSystem::getParent(scraperParams.game->getPath()),
scraperParams.system->getSystemEnvData()->mStartPath, "");
std::string folderPath =
Utils::String::replace(Utils::FileSystem::getParent(scraperParams.game->getPath()),
scraperParams.system->getSystemEnvData()->mStartPath, "");
if (folderPath.size() >= 2) {
folderPath.erase(0, 1);
#if defined(_WIN64)
#if defined(_WIN64)
folderPath.push_back('\\');
folderPath = Utils::String::replace(folderPath, "/", "\\");
#else
#else
folderPath.push_back('/');
#endif
#endif
}
mSubtitle = std::make_shared<TextComponent>(mWindow, folderPath +
Utils::FileSystem::getFileName(scraperParams.game->getPath()) +
" [" + Utils::String::toUpper(scraperParams.system->getName()) + "]" +
mSubtitle = std::make_shared<TextComponent>(
mWindow,
folderPath + Utils::FileSystem::getFileName(scraperParams.game->getPath()) + " [" +
Utils::String::toUpper(scraperParams.system->getName()) + "]" +
(scraperParams.game->getType() == FOLDER ? " " + ViewController::FOLDER_CHAR : ""),
Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER, Vector3f(0.0f, 0.0f, 0.0f),
Vector2f(0.0f, 0.0f), 0x00000000, 0.05f);
Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_CENTER, Vector3f(0.0f, 0.0f, 0.0f),
Vector2f(0.0f, 0.0f), 0x00000000, 0.05f);
mHeaderGrid->setEntry(mTitle, Vector2i(0, 1), false, true);
mHeaderGrid->setEntry(mSubtitle, Vector2i(0, 3), false, true);
@ -102,27 +102,26 @@ GuiMetaDataEd::GuiMetaDataEd(
// Don't show the launch command override entry if this option has been disabled.
if (!Settings::getInstance()->getBool("LaunchCommandOverride") &&
iter->type == MD_LAUNCHCOMMAND) {
ed = std::make_shared<TextComponent>(window, "", Font::get(FONT_SIZE_SMALL,
FONT_PATH_LIGHT), 0x777777FF, ALIGN_RIGHT);
iter->type == MD_LAUNCHCOMMAND) {
ed = std::make_shared<TextComponent>(
window, "", Font::get(FONT_SIZE_SMALL, FONT_PATH_LIGHT), 0x777777FF, ALIGN_RIGHT);
assert(ed);
ed->setValue(mMetaData->get(iter->key));
mEditors.push_back(ed);
continue;
}
// Create ed and add it (and any related components) to mMenu.
// ed's value will be set below.
// It's very important to put the element with the help prompt as the last row
// entry instead of for instance the spacer. That is so because ComponentList
// always looks for the help prompt at the back of the element stack.
ComponentListRow row;
auto lbl = std::make_shared<TextComponent>(mWindow,
Utils::String::toUpper(iter->displayName), Font::get(FONT_SIZE_SMALL), 0x777777FF);
auto lbl =
std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(iter->displayName),
Font::get(FONT_SIZE_SMALL), 0x777777FF);
row.addElement(lbl, true); // Label.
switch (iter->type) {
case MD_BOOL: {
case MD_BOOL: {
ed = std::make_shared<SwitchComponent>(window);
// Make the switches slightly smaller.
auto switchSize = ed->getSize() * 0.9f;
@ -133,9 +132,9 @@ GuiMetaDataEd::GuiMetaDataEd(
row.addElement(ed, false, true);
break;
}
case MD_RATING: {
case MD_RATING: {
auto spacer = std::make_shared<GuiComponent>(mWindow);
spacer->setSize(Renderer::getScreenWidth() * 0.0025f, 0);
spacer->setSize(Renderer::getScreenWidth() * 0.0025f, 0.0f);
row.addElement(spacer, false);
ed = std::make_shared<RatingComponent>(window, true);
@ -145,17 +144,17 @@ GuiMetaDataEd::GuiMetaDataEd(
row.addElement(ed, false, true);
auto ratingSpacer = std::make_shared<GuiComponent>(mWindow);
ratingSpacer->setSize(Renderer::getScreenWidth() * 0.001f, 0);
ratingSpacer->setSize(Renderer::getScreenWidth() * 0.001f, 0.0f);
row.addElement(ratingSpacer, false);
// Pass input to the actual RatingComponent instead of the spacer.
row.input_handler = std::bind(&GuiComponent::input,
ed.get(), std::placeholders::_1, std::placeholders::_2);
row.input_handler = std::bind(&GuiComponent::input, ed.get(), std::placeholders::_1,
std::placeholders::_2);
break;
}
case MD_DATE: {
case MD_DATE: {
auto spacer = std::make_shared<GuiComponent>(mWindow);
spacer->setSize(Renderer::getScreenWidth() * 0.0025f, 0);
spacer->setSize(Renderer::getScreenWidth() * 0.0025f, 0.0f);
row.addElement(spacer, false);
ed = std::make_shared<DateTimeEditComponent>(window, true);
@ -164,29 +163,22 @@ GuiMetaDataEd::GuiMetaDataEd(
row.addElement(ed, false);
auto dateSpacer = std::make_shared<GuiComponent>(mWindow);
dateSpacer->setSize(Renderer::getScreenWidth() * 0.0035f, 0);
dateSpacer->setSize(Renderer::getScreenWidth() * 0.0035f, 0.0f);
row.addElement(dateSpacer, false);
// Pass input to the actual DateTimeEditComponent instead of the spacer.
row.input_handler = std::bind(&GuiComponent::input, ed.get(),
std::placeholders::_1, std::placeholders::_2);
row.input_handler = std::bind(&GuiComponent::input, ed.get(), std::placeholders::_1,
std::placeholders::_2);
break;
}
// Not in use as 'lastplayed' is flagged as statistics and these are skipped.
// Let's still keep the code because it may be needed in the future.
// case MD_TIME: {
// ed = std::make_shared<DateTimeEditComponent>(window,
// DateTimeEditComponent::DISP_RELATIVE_TO_NOW);
// row.addElement(ed, false);
// break;
// }
case MD_LAUNCHCOMMAND: {
case MD_LAUNCHCOMMAND: {
ed = std::make_shared<TextComponent>(window, "",
Font::get(FONT_SIZE_SMALL, FONT_PATH_LIGHT), 0x777777FF, ALIGN_RIGHT);
Font::get(FONT_SIZE_SMALL, FONT_PATH_LIGHT),
0x777777FF, ALIGN_RIGHT);
row.addElement(ed, true);
auto spacer = std::make_shared<GuiComponent>(mWindow);
spacer->setSize(Renderer::getScreenWidth() * 0.005f, 0);
spacer->setSize(Renderer::getScreenWidth() * 0.005f, 0.0f);
row.addElement(spacer, false);
auto bracket = std::make_shared<ImageComponent>(mWindow);
@ -207,26 +199,27 @@ GuiMetaDataEd::GuiMetaDataEd(
};
std::string staticTextString = "Default value from es_systems.xml:";
std::string defaultLaunchCommand = scraperParams.system->
getSystemEnvData()->mLaunchCommand;
std::string defaultLaunchCommand =
scraperParams.system->getSystemEnvData()->mLaunchCommand;
row.makeAcceptInputHandler([this, title, staticTextString,
defaultLaunchCommand, ed, updateVal, multiLine] {
mWindow->pushGui(new GuiComplexTextEditPopup(mWindow, getHelpStyle(),
title, staticTextString, defaultLaunchCommand, ed->getValue(),
updateVal, multiLine, "APPLY", "APPLY CHANGES?"));
row.makeAcceptInputHandler([this, title, staticTextString, defaultLaunchCommand, ed,
updateVal, multiLine] {
mWindow->pushGui(new GuiComplexTextEditPopup(
mWindow, getHelpStyle(), title, staticTextString, defaultLaunchCommand,
ed->getValue(), updateVal, multiLine, "APPLY", "APPLY CHANGES?"));
});
break;
}
case MD_MULTILINE_STRING:
default: {
case MD_MULTILINE_STRING:
default: {
// MD_STRING.
ed = std::make_shared<TextComponent>(window, "", Font::get(FONT_SIZE_SMALL,
FONT_PATH_LIGHT), 0x777777FF, ALIGN_RIGHT);
ed = std::make_shared<TextComponent>(window, "",
Font::get(FONT_SIZE_SMALL, FONT_PATH_LIGHT),
0x777777FF, ALIGN_RIGHT);
row.addElement(ed, true);
auto spacer = std::make_shared<GuiComponent>(mWindow);
spacer->setSize(Renderer::getScreenWidth() * 0.005f, 0);
spacer->setSize(Renderer::getScreenWidth() * 0.005f, 0.0f);
row.addElement(spacer, false);
auto bracket = std::make_shared<ImageComponent>(mWindow);
@ -239,9 +232,9 @@ GuiMetaDataEd::GuiMetaDataEd(
gamePath = Utils::FileSystem::getStem(mScraperParams.game->getPath());
// OK callback (apply new value to ed).
auto updateVal = [ed, currentKey, originalValue, gamePath]
(const std::string& newVal) {
// OK callback (apply new value to ed).
auto updateVal = [ed, currentKey, originalValue,
gamePath](const std::string& newVal) {
// If the user has entered a blank game name, then set the name to the ROM
// filename (minus the extension).
if (currentKey == "name" && newVal == "") {
@ -251,27 +244,28 @@ GuiMetaDataEd::GuiMetaDataEd(
else
ed->setColor(TEXTCOLOR_USERMARKED);
}
else if (newVal == "" && (currentKey == "developer" ||
currentKey == "publisher" || currentKey == "genre" ||
currentKey == "players")) {
else if (newVal == "" &&
(currentKey == "developer" || currentKey == "publisher" ||
currentKey == "genre" || currentKey == "players")) {
ed->setValue("unknown");
if (originalValue == "unknown")
ed->setColor(DEFAULT_TEXTCOLOR);
else
ed->setColor(TEXTCOLOR_USERMARKED);
ed->setColor(TEXTCOLOR_USERMARKED);
}
else {
ed->setValue(newVal);
if (newVal == originalValue)
ed->setColor(DEFAULT_TEXTCOLOR);
else
ed->setColor(TEXTCOLOR_USERMARKED);
ed->setColor(TEXTCOLOR_USERMARKED);
}
};
};
row.makeAcceptInputHandler([this, title, ed, updateVal, multiLine] {
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), title,
ed->getValue(), updateVal, multiLine, "APPLY", "APPLY CHANGES?"));
ed->getValue(), updateVal, multiLine,
"APPLY", "APPLY CHANGES?"));
});
break;
}
@ -286,8 +280,8 @@ GuiMetaDataEd::GuiMetaDataEd(
std::vector<std::shared_ptr<ButtonComponent>> buttons;
if (!scraperParams.system->hasPlatformId(PlatformIds::PLATFORM_IGNORE))
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "SCRAPE", "scrape",
std::bind(&GuiMetaDataEd::fetch, this)));
buttons.push_back(std::make_shared<ButtonComponent>(
mWindow, "SCRAPE", "scrape", std::bind(&GuiMetaDataEd::fetch, this)));
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "SAVE", "save metadata", [&] {
save();
@ -295,49 +289,60 @@ GuiMetaDataEd::GuiMetaDataEd(
delete this;
}));
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "CANCEL", "cancel changes",
[&] { delete this; }));
[&] { delete this; }));
if (scraperParams.game->getType() == FOLDER) {
if (mClearGameFunc) {
auto clearSelf = [&] { mClearGameFunc(); delete this; };
auto clearSelf = [&] {
mClearGameFunc();
delete this;
};
auto clearSelfBtnFunc = [this, clearSelf] {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"THIS WILL DELETE ANY MEDIA FILES AND\n"
"THE GAMELIST.XML ENTRY FOR THIS FOLDER,\n"
"BUT NEITHER THE FOLDER ITSELF OR ANY\n"
"CONTENT INSIDE IT WILL BE REMOVED\n"
"ARE YOU SURE?",
"YES", clearSelf, "NO", nullptr)); };
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "CLEAR",
"clear folder", clearSelfBtnFunc));
"THIS WILL DELETE ANY MEDIA FILES AND\n"
"THE GAMELIST.XML ENTRY FOR THIS FOLDER,\n"
"BUT NEITHER THE FOLDER ITSELF OR ANY\n"
"CONTENT INSIDE IT WILL BE REMOVED\n"
"ARE YOU SURE?",
"YES", clearSelf, "NO", nullptr));
};
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "CLEAR", "clear folder",
clearSelfBtnFunc));
}
}
else {
if (mClearGameFunc) {
auto clearSelf = [&] { mClearGameFunc(); delete this; };
auto clearSelf = [&] {
mClearGameFunc();
delete this;
};
auto clearSelfBtnFunc = [this, clearSelf] {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"THIS WILL DELETE ANY MEDIA FILES\n"
"AND THE GAMELIST.XML ENTRY FOR\n"
"THIS GAME, BUT THE GAME FILE\n"
"ITSELF WILL NOT BE REMOVED\n"
"ARE YOU SURE?",
"YES", clearSelf, "NO", nullptr)); };
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "CLEAR",
"clear file", clearSelfBtnFunc));
"THIS WILL DELETE ANY MEDIA FILES\n"
"AND THE GAMELIST.XML ENTRY FOR\n"
"THIS GAME, BUT THE GAME FILE\n"
"ITSELF WILL NOT BE REMOVED\n"
"ARE YOU SURE?",
"YES", clearSelf, "NO", nullptr));
};
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "CLEAR", "clear file",
clearSelfBtnFunc));
}
if (mDeleteGameFunc) {
auto deleteFilesAndSelf = [&] { mDeleteGameFunc(); delete this; };
auto deleteFilesAndSelf = [&] {
mDeleteGameFunc();
delete this;
};
auto deleteGameBtnFunc = [this, deleteFilesAndSelf] {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"THIS WILL DELETE THE GAME\n"
"FILE, ANY MEDIA FILES AND\n"
"THE GAMELIST.XML ENTRY\n"
"ARE YOU SURE?",
"YES", deleteFilesAndSelf, "NO", nullptr)); };
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "DELETE",
"delete game", deleteGameBtnFunc));
"THIS WILL DELETE THE GAME\n"
"FILE, ANY MEDIA FILES AND\n"
"THE GAMELIST.XML ENTRY\n"
"ARE YOU SURE?",
"YES", deleteFilesAndSelf, "NO", nullptr));
};
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "DELETE", "delete game",
deleteGameBtnFunc));
}
}
@ -345,11 +350,12 @@ GuiMetaDataEd::GuiMetaDataEd(
mGrid.setEntry(mButtons, Vector2i(0, 2), true, false);
// Resize + center.
float width = static_cast<float>(std::min(static_cast<int>(Renderer::getScreenHeight() *
1.05f), static_cast<int>(Renderer::getScreenWidth() * 0.90f)));
float width =
static_cast<float>(std::min(static_cast<int>(Renderer::getScreenHeight() * 1.05f),
static_cast<int>(Renderer::getScreenWidth() * 0.90f)));
setSize(width, Renderer::getScreenHeight() * 0.83f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2,
(Renderer::getScreenHeight() - mSize.y()) / 2);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
}
void GuiMetaDataEd::onSizeChanged()
@ -360,8 +366,8 @@ void GuiMetaDataEd::onSizeChanged()
const float subtitleHeight = mSubtitle->getFont()->getLetterHeight();
const float titleSubtitleSpacing = mSize.y() * 0.03f;
mGrid.setRowHeightPerc(0, (titleHeight + titleSubtitleSpacing + subtitleHeight +
TITLE_VERT_PADDING) / mSize.y());
mGrid.setRowHeightPerc(
0, (titleHeight + titleSubtitleSpacing + subtitleHeight + TITLE_VERT_PADDING) / mSize.y());
mGrid.setRowHeightPerc(2, mButtons->getSize().y() / mSize.y());
// Snap list size to the row height to prevent a fraction of a row from being displayed.
@ -383,7 +389,7 @@ void GuiMetaDataEd::onSizeChanged()
mList->setSize(mList->getSize().x(), listHeight);
Vector2f newWindowSize = mSize;
newWindowSize.y() -= heightAdjustment;
mBackground.fitTo(newWindowSize, Vector3f::Zero(), Vector2f(-32, -32));
mBackground.fitTo(newWindowSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
// Move the buttons up as well to make the layout align correctly after the resize.
Vector3f newButtonPos = mButtons->getPosition();
@ -411,13 +417,13 @@ void GuiMetaDataEd::save()
continue;
if (!showHiddenGames && mMetaDataDecl.at(i).key == "hidden" &&
mEditors.at(i)->getValue() != mMetaData->get("hidden"))
mEditors.at(i)->getValue() != mMetaData->get("hidden"))
hideGameWhileHidden = true;
// Check whether the flag to count the entry as a game was set to enabled.
if (mMetaDataDecl.at(i).key == "nogamecount" &&
mEditors.at(i)->getValue() != mMetaData->get("nogamecount") &&
mMetaData->get("nogamecount") == "true") {
mEditors.at(i)->getValue() != mMetaData->get("nogamecount") &&
mMetaData->get("nogamecount") == "true") {
setGameAsCounted = true;
}
@ -450,7 +456,7 @@ void GuiMetaDataEd::save()
for (FileData* child : mScraperParams.game->getChildrenRecursive()) {
if (!child->getHidden())
child->metadata.set("hidden", "true");
hideGames.push_back(child);
hideGames.push_back(child);
}
}
else {
@ -501,8 +507,9 @@ void GuiMetaDataEd::save()
void GuiMetaDataEd::fetch()
{
GuiGameScraper* scr = new GuiGameScraper(mWindow, mScraperParams,
std::bind(&GuiMetaDataEd::fetchDone, this, std::placeholders::_1));
mMediaFilesUpdated = false;
GuiGameScraper* scr = new GuiGameScraper(
mWindow, mScraperParams, std::bind(&GuiMetaDataEd::fetchDone, this, std::placeholders::_1));
mWindow->pushGui(scr);
}
@ -514,10 +521,6 @@ void GuiMetaDataEd::fetchDone(const ScraperSearchResult& result)
mMediaFilesUpdated = result.savedNewMedia;
// Curently disabled as I'm not sure if this is more annoying than helpful.
// // Select the Save button.
// mButtons->moveCursor(Vector2i(1, 0));
// Check if any values were manually changed before starting the scraping.
// If so, it's these values we should compare against when scraping, not
// the values previously saved for the game.
@ -561,42 +564,31 @@ void GuiMetaDataEd::close()
}
}
// Keep code for potential future use.
// std::function<void()> closeFunc;
// if (!closeAllWindows) {
// closeFunc = [this] { delete this; };
// }
// else {
// Window* window = mWindow;
// closeFunc = [window, this] {
// while (window->peekGui() != ViewController::get())
// delete window->peekGui();
// };
// }
std::function<void()> closeFunc;
closeFunc = [this] {
if (mMediaFilesUpdated) {
// Always reload the gamelist if media files were updated, even if the user
// chose to not save any metadata changes. Also manually unload the game image
// and marquee, as otherwise they would not get updated until the user scrolls up
// and down the gamelist.
TextureResource::manualUnload(mScraperParams.game->getImagePath(), false);
TextureResource::manualUnload(mScraperParams.game->getMarqueePath(), false);
ViewController::get()->reloadGameListView(mScraperParams.system);
mWindow->invalidateCachedBackground();
}
ViewController::get()->onPauseVideo();
delete this;
};
closeFunc = [this] {
if (mMediaFilesUpdated) {
// Always reload the gamelist if media files were updated, even if the user
// chose to not save any metadata changes. Also manually unload the game image
// and marquee, as otherwise they would not get updated until the user scrolls up
// and down the gamelist.
TextureResource::manualUnload(mScraperParams.game->getImagePath(), false);
TextureResource::manualUnload(mScraperParams.game->getMarqueePath(), false);
ViewController::get()->reloadGameListView(mScraperParams.system);
mWindow->invalidateCachedBackground();
}
ViewController::get()->onPauseVideo();
delete this;
};
if (metadataUpdated) {
// Changes were made, ask if the user wants to save them.
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"SAVE CHANGES?",
"YES", [this, closeFunc] { save(); closeFunc(); },
"NO", closeFunc
));
mWindow->pushGui(new GuiMsgBox(
mWindow, getHelpStyle(), "SAVE CHANGES?", "YES",
[this, closeFunc] {
save();
closeFunc();
},
"NO", closeFunc));
}
else {
// Always save if the media files have been changed (i.e. newly scraped images).

20
es-app/src/guis/GuiMetaDataEd.h
View file

@ -12,11 +12,11 @@
#ifndef ES_APP_GUIS_GUI_META_DATA_ED_H
#define ES_APP_GUIS_GUI_META_DATA_ED_H
#include "GuiComponent.h"
#include "MetaData.h"
#include "components/ComponentGrid.h"
#include "components/NinePatchComponent.h"
#include "scrapers/Scraper.h"
#include "GuiComponent.h"
#include "MetaData.h"
class ComponentList;
class TextComponent;
@ -24,14 +24,14 @@ class TextComponent;
class GuiMetaDataEd : public GuiComponent
{
public:
GuiMetaDataEd(
Window* window,
MetaDataList* md, const std::vector<MetaDataDecl>&mdd,
ScraperSearchParams params,
const std::string& header,
std::function<void()> savedCallback,
std::function<void()> clearGameFunc,
std::function<void()> deleteGameFunc);
GuiMetaDataEd(Window* window,
MetaDataList* md,
const std::vector<MetaDataDecl>& mdd,
ScraperSearchParams params,
const std::string& header,
std::function<void()> savedCallback,
std::function<void()> clearGameFunc,
std::function<void()> deleteGameFunc);
bool input(InputConfig* config, Input input) override;
void onSizeChanged() override;

185
es-app/src/guis/GuiOfflineGenerator.cpp
View file

@ -9,17 +9,15 @@
#include "guis/GuiOfflineGenerator.h"
#include "SystemData.h"
#include "components/MenuComponent.h"
#include "views/ViewController.h"
#include "SystemData.h"
GuiOfflineGenerator::GuiOfflineGenerator(
Window* window,
const std::queue<FileData*>& gameQueue)
: GuiComponent(window),
mBackground(window, ":/graphics/frame.svg"),
mGrid(window, Vector2i(6, 13)),
mGameQueue(gameQueue)
GuiOfflineGenerator::GuiOfflineGenerator(Window* window, const std::queue<FileData*>& gameQueue)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(6, 13))
, mGameQueue(gameQueue)
{
addChild(&mBackground);
addChild(&mGrid);
@ -39,140 +37,139 @@ GuiOfflineGenerator::GuiOfflineGenerator(
// Header.
mTitle = std::make_shared<TextComponent>(mWindow, "MIXIMAGE OFFLINE GENERATOR",
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true, Vector2i(6, 1));
mStatus = std::make_shared<TextComponent>(mWindow, "NOT STARTED",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
mStatus = std::make_shared<TextComponent>(mWindow, "NOT STARTED", Font::get(FONT_SIZE_MEDIUM),
0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mStatus, Vector2i(0, 1), false, true, Vector2i(6, 1));
mGameCounter = std::make_shared<TextComponent>(mWindow,
std::to_string(mGamesProcessed) + " OF " + std::to_string(mTotalGames) +
mGameCounter = std::make_shared<TextComponent>(
mWindow,
std::to_string(mGamesProcessed) + " OF " + std::to_string(mTotalGames) +
(mTotalGames == 1 ? " GAME " : " GAMES ") + "PROCESSED",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mGrid.setEntry(mGameCounter, Vector2i(0, 2), false, true, Vector2i(6, 1));
// Spacer row with top border.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 3),
false, false, Vector2i(6, 1), GridFlags::BORDER_TOP);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 3), false, false,
Vector2i(6, 1), GridFlags::BORDER_TOP);
// Left spacer.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 4),
false, false, Vector2i(1, 7));
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 4), false, false,
Vector2i(1, 7));
// Generated label.
mGeneratedLbl = std::make_shared<TextComponent>(mWindow, "Generated:",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGeneratedLbl = std::make_shared<TextComponent>(
mWindow, "Generated:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mGeneratedLbl, Vector2i(1, 4), false, true, Vector2i(1, 1));
// Generated value/counter.
mGeneratedVal = std::make_shared<TextComponent>(mWindow,
std::to_string(mGamesProcessed),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGeneratedVal =
std::make_shared<TextComponent>(mWindow, std::to_string(mGamesProcessed),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mGeneratedVal, Vector2i(2, 4), false, true, Vector2i(1, 1));
// Overwritten label.
mOverwrittenLbl = std::make_shared<TextComponent>(mWindow, "Overwritten:",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mOverwrittenLbl = std::make_shared<TextComponent>(
mWindow, "Overwritten:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mOverwrittenLbl, Vector2i(1, 5), false, true, Vector2i(1, 1));
// Overwritten value/counter.
mOverwrittenVal = std::make_shared<TextComponent>(mWindow,
std::to_string(mImagesOverwritten),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mOverwrittenVal =
std::make_shared<TextComponent>(mWindow, std::to_string(mImagesOverwritten),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mOverwrittenVal, Vector2i(2, 5), false, true, Vector2i(1, 1));
// Skipping label.
mSkippedLbl = std::make_shared<TextComponent>(mWindow, "Skipped (existing):",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mSkippedLbl = std::make_shared<TextComponent>(
mWindow, "Skipped (existing):", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mSkippedLbl, Vector2i(1, 6), false, true, Vector2i(1, 1));
// Skipping value/counter.
mSkippedVal= std::make_shared<TextComponent>(mWindow,
std::to_string(mGamesSkipped),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mSkippedVal = std::make_shared<TextComponent>(
mWindow, std::to_string(mGamesSkipped), Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mSkippedVal, Vector2i(2, 6), false, true, Vector2i(1, 1));
// Failed label.
mFailedLbl = std::make_shared<TextComponent>(mWindow, "Failed:",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mFailedLbl = std::make_shared<TextComponent>(mWindow, "Failed:", Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mFailedLbl, Vector2i(1, 7), false, true, Vector2i(1, 1));
// Failed value/counter.
mFailedVal = std::make_shared<TextComponent>(mWindow,
std::to_string(mGamesFailed),
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mFailedVal = std::make_shared<TextComponent>(
mWindow, std::to_string(mGamesFailed), Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mFailedVal, Vector2i(2, 7), false, true, Vector2i(1, 1));
// Processing label.
mProcessingLbl = std::make_shared<TextComponent>(mWindow, "Processing: ",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mProcessingLbl = std::make_shared<TextComponent>(
mWindow, "Processing: ", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mProcessingLbl, Vector2i(3, 4), false, true, Vector2i(1, 1));
// Processing value.
mProcessingVal = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mProcessingVal = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mProcessingVal, Vector2i(4, 4), false, true, Vector2i(1, 1));
// Spacer row.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 8),
false, false, Vector2i(4, 1));
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 8), false, false,
Vector2i(4, 1));
// Last error message label.
mLastErrorLbl = std::make_shared<TextComponent>(mWindow, "Last error message:",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mLastErrorLbl = std::make_shared<TextComponent>(
mWindow, "Last error message:", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mLastErrorLbl, Vector2i(1, 9), false, true, Vector2i(4, 1));
// Last error message value.
mLastErrorVal = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_LEFT);
mLastErrorVal = std::make_shared<TextComponent>(mWindow, "", Font::get(FONT_SIZE_SMALL),
0x888888FF, ALIGN_LEFT);
mGrid.setEntry(mLastErrorVal, Vector2i(1, 10), false, true, Vector2i(4, 1));
// Right spacer.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(5, 4),
false, false, Vector2i(1, 7));
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(5, 4), false, false,
Vector2i(1, 7));
// Spacer row with bottom border.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 11),
false, false, Vector2i(6, 1), GridFlags::BORDER_BOTTOM);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 11), false, false,
Vector2i(6, 1), GridFlags::BORDER_BOTTOM);
// Buttons.
std::vector<std::shared_ptr<ButtonComponent>> buttons;
mStartPauseButton = std::make_shared<ButtonComponent>(mWindow, "START",
"start processing", [this](){
if (!mProcessing) {
mProcessing = true;
mPaused = false;
mStartPauseButton->setText("PAUSE", "pause processing");
mCloseButton->setText("CLOSE", "close (abort processing)");
mStatus->setText("RUNNING...");
if (mGamesProcessed == 0) {
LOG(LogInfo) << "GuiOfflineGenerator: Processing " << mTotalGames << " games";
mStartPauseButton =
std::make_shared<ButtonComponent>(mWindow, "START", "start processing", [this]() {
if (!mProcessing) {
mProcessing = true;
mPaused = false;
mStartPauseButton->setText("PAUSE", "pause processing");
mCloseButton->setText("CLOSE", "close (abort processing)");
mStatus->setText("RUNNING...");
if (mGamesProcessed == 0) {
LOG(LogInfo) << "GuiOfflineGenerator: Processing " << mTotalGames << " games";
}
}
}
else {
if (mMiximageGeneratorThread.joinable())
mMiximageGeneratorThread.join();
mPaused = true;
update(1);
mProcessing = false;
this->mStartPauseButton->setText("START", "start processing");
this->mCloseButton->setText("CLOSE", "close (abort processing)");
mStatus->setText("PAUSED");
}
});
else {
if (mMiximageGeneratorThread.joinable())
mMiximageGeneratorThread.join();
mPaused = true;
update(1);
mProcessing = false;
this->mStartPauseButton->setText("START", "start processing");
this->mCloseButton->setText("CLOSE", "close (abort processing)");
mStatus->setText("PAUSED");
}
});
buttons.push_back(mStartPauseButton);
mCloseButton = std::make_shared<ButtonComponent>(mWindow, "CLOSE", "close", [this](){
mCloseButton = std::make_shared<ButtonComponent>(mWindow, "CLOSE", "close", [this]() {
if (mGamesProcessed != 0 && mGamesProcessed != mTotalGames) {
LOG(LogInfo) << "GuiOfflineGenerator: Aborted after processing " <<
mGamesProcessed << (mGamesProcessed == 1 ? " game (" : " games (") <<
mImagesGenerated << (mImagesGenerated == 1 ? " image " : " images ") <<
"generated, " << mGamesSkipped <<
(mGamesSkipped == 1 ? " game " : " games ") << "skipped, " << mGamesFailed <<
(mGamesFailed == 1 ? " game " : " games ") << "failed)";
LOG(LogInfo) << "GuiOfflineGenerator: Aborted after processing " << mGamesProcessed
<< (mGamesProcessed == 1 ? " game (" : " games (") << mImagesGenerated
<< (mImagesGenerated == 1 ? " image " : " images ") << "generated, "
<< mGamesSkipped << (mGamesSkipped == 1 ? " game " : " games ")
<< "skipped, " << mGamesFailed
<< (mGamesFailed == 1 ? " game " : " games ") << "failed)";
}
delete this;
});
@ -184,12 +181,12 @@ GuiOfflineGenerator::GuiOfflineGenerator(
// For narrower displays (e.g. in 4:3 ratio), allow the window to fill 95% of the screen
// width rather than the 85% allowed for wider displays.
float width = Renderer::getScreenWidth() *
((Renderer::getScreenAspectRatio() < 1.4f) ? 0.95f : 0.85f);
float width =
Renderer::getScreenWidth() * ((Renderer::getScreenAspectRatio() < 1.4f) ? 0.95f : 0.85f);
setSize(width, Renderer::getScreenHeight() * 0.75f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
}
GuiOfflineGenerator::~GuiOfflineGenerator()
@ -281,12 +278,12 @@ void GuiOfflineGenerator::update(int deltaTime)
mGame = mGameQueue.front();
mGameQueue.pop();
mGameName = mGame->getName() + " [" +
Utils::String::toUpper(mGame->getSystem()->getName()) + "]";
mGameName =
mGame->getName() + " [" + Utils::String::toUpper(mGame->getSystem()->getName()) + "]";
mProcessingVal->setText(mGameName);
if (!Settings::getInstance()->getBool("MiximageOverwrite") &&
mGame->getMiximagePath() != "") {
mGame->getMiximagePath() != "") {
mGamesProcessed++;
mGamesSkipped++;
mSkippedVal->setText(std::to_string(mGamesSkipped));
@ -303,14 +300,14 @@ void GuiOfflineGenerator::update(int deltaTime)
mGeneratorFuture = mGeneratorPromise.get_future();
mMiximageGeneratorThread = std::thread(&MiximageGenerator::startThread,
mMiximageGenerator.get(), &mGeneratorPromise);
mMiximageGenerator.get(), &mGeneratorPromise);
}
}
// Update the statistics.
mStatus->setText("RUNNING...");
mGameCounter->setText(std::to_string(mGamesProcessed) + " OF " + std::to_string(mTotalGames) +
(mTotalGames == 1 ? " GAME " : " GAMES ") + "PROCESSED");
(mTotalGames == 1 ? " GAME " : " GAMES ") + "PROCESSED");
mGeneratedVal->setText(std::to_string(mImagesGenerated));
mFailedVal->setText(std::to_string(mGamesFailed));
@ -319,13 +316,13 @@ void GuiOfflineGenerator::update(int deltaTime)
if (mGamesProcessed == mTotalGames) {
mStatus->setText("COMPLETED");
mStartPauseButton->setText("DONE", "done (close)");
mStartPauseButton->setPressedFunc([this](){ delete this; });
mStartPauseButton->setPressedFunc([this]() { delete this; });
mCloseButton->setText("CLOSE", "close");
mProcessingVal->setText("");
LOG(LogInfo) << "GuiOfflineGenerator: Completed processing (" << mImagesGenerated <<
(mImagesGenerated == 1 ? " image " : " images ") << "generated, " <<
mGamesSkipped << (mGamesSkipped == 1 ? " game " : " games ") << "skipped, " <<
mGamesFailed << (mGamesFailed == 1 ? " game " : " games ") << "failed)";
LOG(LogInfo) << "GuiOfflineGenerator: Completed processing (" << mImagesGenerated
<< (mImagesGenerated == 1 ? " image " : " images ") << "generated, "
<< mGamesSkipped << (mGamesSkipped == 1 ? " game " : " games ") << "skipped, "
<< mGamesFailed << (mGamesFailed == 1 ? " game " : " games ") << "failed)";
mProcessing = false;
}
}

4
es-app/src/guis/GuiOfflineGenerator.h
View file

@ -10,10 +10,10 @@
#ifndef ES_APP_GUIS_GUI_OFFLINE_GENERATOR_H
#define ES_APP_GUIS_GUI_OFFLINE_GENERATOR_H
#include "components/ButtonComponent.h"
#include "components/ComponentGrid.h"
#include "GuiComponent.h"
#include "MiximageGenerator.h"
#include "components/ButtonComponent.h"
#include "components/ComponentGrid.h"
#include <queue>

412
es-app/src/guis/GuiScraperMenu.cpp
View file

@ -10,23 +10,23 @@
#include "guis/GuiScraperMenu.h"
#include "FileData.h"
#include "FileSorts.h"
#include "SystemData.h"
#include "components/OptionListComponent.h"
#include "components/SwitchComponent.h"
#include "guis/GuiMsgBox.h"
#include "guis/GuiOfflineGenerator.h"
#include "guis/GuiScraperMulti.h"
#include "views/ViewController.h"
#include "FileData.h"
#include "FileSorts.h"
#include "SystemData.h"
GuiScraperMenu::GuiScraperMenu(Window* window, std::string title)
: GuiComponent(window), mMenu(window, title)
: GuiComponent(window)
, mMenu(window, title)
{
// Scraper service.
mScraper = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "SCRAPE FROM", false);
mScraper = std::make_shared<OptionListComponent<std::string>>(mWindow, getHelpStyle(),
"SCRAPE FROM", false);
std::vector<std::string> scrapers = getScraperList();
// Select either the first entry or the one read from the settings,
// just in case the scraper from settings has vanished.
@ -36,22 +36,50 @@ GuiScraperMenu::GuiScraperMenu(Window* window, std::string title)
// Search filters, getSearches() will generate a queue of games to scrape
// based on the outcome of the checks below.
mFilters = std::make_shared< OptionListComponent<GameFilterFunc>>
(mWindow, getHelpStyle(), "SCRAPE THESE GAMES", false);
mFilters->add("ALL GAMES", [](SystemData*, FileData*) -> bool { return true; }, false);
mFilters->add("FAVORITE GAMES", [](SystemData*, FileData* g) -> bool {
return g->getFavorite(); }, false);
mFilters->add("NO METADATA", [](SystemData*, FileData* g) -> bool {
return g->metadata.get("desc").empty(); }, false);
mFilters->add("NO GAME IMAGE",
[](SystemData*, FileData* g) -> bool {
return g->getImagePath().empty(); }, false);
mFilters->add("NO GAME VIDEO",
[](SystemData*, FileData* g) -> bool {
return g->getVideoPath().empty(); }, false);
mFilters->add("FOLDERS ONLY",
[](SystemData*, FileData* g) -> bool {
return g->getType() == FOLDER; }, false);
mFilters = std::make_shared<OptionListComponent<GameFilterFunc>>(mWindow, getHelpStyle(),
"SCRAPE THESE GAMES", false);
mFilters->add(
"ALL GAMES",
[](SystemData*, FileData*) -> bool {
// All games.
return true;
},
false);
mFilters->add(
"FAVORITE GAMES",
[](SystemData*, FileData* g) -> bool {
// Favorite games.
return g->getFavorite();
},
false);
mFilters->add(
"NO METADATA",
[](SystemData*, FileData* g) -> bool {
// No metadata.
return g->metadata.get("desc").empty();
},
false);
mFilters->add(
"NO GAME IMAGE",
[](SystemData*, FileData* g) -> bool {
// No game image.
return g->getImagePath().empty();
},
false);
mFilters->add(
"NO GAME VIDEO",
[](SystemData*, FileData* g) -> bool {
// No game video.
return g->getVideoPath().empty();
},
false);
mFilters->add(
"FOLDERS ONLY",
[](SystemData*, FileData* g) -> bool {
// Folders only.
return g->getType() == FOLDER;
},
false);
mFilters->selectEntry(Settings::getInstance()->getInt("ScraperFilter"));
mMenu.addWithLabel("SCRAPE THESE GAMES", mFilters);
@ -68,20 +96,20 @@ GuiScraperMenu::GuiScraperMenu(Window* window, std::string title)
});
// Add systems (all systems with an existing platform ID are listed).
mSystems = std::make_shared< OptionListComponent<SystemData*>>
(mWindow, getHelpStyle(), "SCRAPE THESE SYSTEMS", true);
mSystems = std::make_shared<OptionListComponent<SystemData*>>(mWindow, getHelpStyle(),
"SCRAPE THESE SYSTEMS", true);
for (unsigned int i = 0; i < SystemData::sSystemVector.size(); i++) {
if (!SystemData::sSystemVector[i]->hasPlatformId(PlatformIds::PLATFORM_IGNORE)) {
mSystems->add(SystemData::sSystemVector[i]->getFullName(),
SystemData::sSystemVector[i],
!SystemData::sSystemVector[i]->getPlatformIds().empty());
SystemData::sSystemVector[i]->getScrapeFlag() ?
mSystems->selectEntry(i) : mSystems->unselectEntry(i);
mSystems->add(SystemData::sSystemVector[i]->getFullName(), SystemData::sSystemVector[i],
!SystemData::sSystemVector[i]->getPlatformIds().empty());
SystemData::sSystemVector[i]->getScrapeFlag() ? mSystems->selectEntry(i) :
mSystems->unselectEntry(i);
}
}
mMenu.addWithLabel("SCRAPE THESE SYSTEMS", mSystems);
addEntry("ACCOUNT SETTINGS", 0x777777FF, true, [this] {
// Open the account options menu.
openAccountOptions();
});
addEntry("CONTENT SETTINGS", 0x777777FF, true, [this] {
@ -93,6 +121,7 @@ GuiScraperMenu::GuiScraperMenu(Window* window, std::string title)
openContentOptions();
});
addEntry("MIXIMAGE SETTINGS", 0x777777FF, true, [this] {
// Open the miximage options menu.
openMiximageOptions();
});
addEntry("OTHER SETTINGS", 0x777777FF, true, [this] {
@ -111,8 +140,8 @@ GuiScraperMenu::GuiScraperMenu(Window* window, std::string title)
setSize(mMenu.getSize());
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2,
Renderer::getScreenHeight() * 0.13f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
}
GuiScraperMenu::~GuiScraperMenu()
@ -120,9 +149,9 @@ GuiScraperMenu::~GuiScraperMenu()
// Save the scrape flags to the system settings so that they are
// remembered throughout the program session.
std::vector<SystemData*> sys = mSystems->getSelectedObjects();
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it++) {
(*it)->setScrapeFlag(false);
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
(*it)->setScrapeFlag(false);
for (auto it_sys = sys.cbegin(); it_sys != sys.cend(); it_sys++) {
if ((*it)->getFullName() == (*it_sys)->getFullName())
(*it)->setScrapeFlag(true);
@ -136,48 +165,48 @@ void GuiScraperMenu::openAccountOptions()
// Whether to use the ScreenScraper account when scraping.
auto scraper_use_account_screenscraper = std::make_shared<SwitchComponent>(mWindow);
scraper_use_account_screenscraper->setState(Settings::getInstance()->
getBool("ScraperUseAccountScreenScraper"));
scraper_use_account_screenscraper->setState(
Settings::getInstance()->getBool("ScraperUseAccountScreenScraper"));
s->addWithLabel("USE THIS ACCOUNT FOR SCREENSCRAPER", scraper_use_account_screenscraper);
s->addSaveFunc([scraper_use_account_screenscraper, s] {
if (scraper_use_account_screenscraper->getState() !=
Settings::getInstance()->getBool("ScraperUseAccountScreenScraper")) {
Settings::getInstance()->getBool("ScraperUseAccountScreenScraper")) {
Settings::getInstance()->setBool("ScraperUseAccountScreenScraper",
scraper_use_account_screenscraper->getState());
scraper_use_account_screenscraper->getState());
s->setNeedsSaving();
}
});
// ScreenScraper username.
auto scraper_username_screenscraper = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_RIGHT);
auto scraper_username_screenscraper = std::make_shared<TextComponent>(
mWindow, "", Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_RIGHT);
s->addEditableTextComponent("SCREENSCRAPER USERNAME", scraper_username_screenscraper,
Settings::getInstance()->getString("ScraperUsernameScreenScraper"));
Settings::getInstance()->getString("ScraperUsernameScreenScraper"));
s->addSaveFunc([scraper_username_screenscraper, s] {
if (scraper_username_screenscraper->getValue() !=
Settings::getInstance()->getString("ScraperUsernameScreenScraper")) {
Settings::getInstance()->getString("ScraperUsernameScreenScraper")) {
Settings::getInstance()->setString("ScraperUsernameScreenScraper",
scraper_username_screenscraper->getValue());
scraper_username_screenscraper->getValue());
s->setNeedsSaving();
}
});
// ScreenScraper password.
auto scraper_password_screenscraper = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_RIGHT);
auto scraper_password_screenscraper = std::make_shared<TextComponent>(
mWindow, "", Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_RIGHT);
std::string passwordMasked;
if (Settings::getInstance()->getString("ScraperPasswordScreenScraper") != "") {
passwordMasked = "********";
scraper_password_screenscraper->setHiddenValue(
Settings::getInstance()->getString("ScraperPasswordScreenScraper"));
Settings::getInstance()->getString("ScraperPasswordScreenScraper"));
}
s->addEditableTextComponent("SCREENSCRAPER PASSWORD",
scraper_password_screenscraper, passwordMasked, "", true);
s->addEditableTextComponent("SCREENSCRAPER PASSWORD", scraper_password_screenscraper,
passwordMasked, "", true);
s->addSaveFunc([scraper_password_screenscraper, s] {
if (scraper_password_screenscraper->getHiddenValue() !=
Settings::getInstance()->getString("ScraperPasswordScreenScraper")) {
Settings::getInstance()->getString("ScraperPasswordScreenScraper")) {
Settings::getInstance()->setString("ScraperPasswordScreenScraper",
scraper_password_screenscraper->getHiddenValue());
scraper_password_screenscraper->getHiddenValue());
s->setNeedsSaving();
}
});
@ -211,12 +240,13 @@ void GuiScraperMenu::openContentOptions()
}
});
// Ratings are not supported by TheGamesDB, so disable the option if this scraper is selected.
// Ratings are not supported by TheGamesDB, so gray out the option if this scraper is selected.
if (Settings::getInstance()->getString("Scraper") == "thegamesdb") {
scrape_ratings->setEnabled(false);
scrape_ratings->setOpacity(DISABLED_OPACITY);
scrape_ratings->getParent()->getChild(scrape_ratings->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scrape_ratings->getParent()
->getChild(scrape_ratings->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Scrape other metadata.
@ -241,12 +271,13 @@ void GuiScraperMenu::openContentOptions()
}
});
// Videos are not supported by TheGamesDB, so disable the option if this scraper is selected.
// Videos are not supported by TheGamesDB, so gray out the option if this scraper is selected.
if (Settings::getInstance()->getString("Scraper") == "thegamesdb") {
scrape_videos->setEnabled(false);
scrape_videos->setOpacity(DISABLED_OPACITY);
scrape_videos->getParent()->getChild(scrape_videos->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scrape_videos->getParent()
->getChild(scrape_videos->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Scrape screenshots images.
@ -255,7 +286,7 @@ void GuiScraperMenu::openContentOptions()
s->addWithLabel("SCRAPE SCREENSHOT IMAGES", scrape_screenshots);
s->addSaveFunc([scrape_screenshots, s] {
if (scrape_screenshots->getState() !=
Settings::getInstance()->getBool("ScrapeScreenshots")) {
Settings::getInstance()->getBool("ScrapeScreenshots")) {
Settings::getInstance()->setBool("ScrapeScreenshots", scrape_screenshots->getState());
s->setNeedsSaving();
}
@ -294,13 +325,14 @@ void GuiScraperMenu::openContentOptions()
}
});
// 3D box images are not supported by TheGamesDB, so disable the option if this scraper
// 3D box images are not supported by TheGamesDB, so gray out the option if this scraper
// is selected.
if (Settings::getInstance()->getString("Scraper") == "thegamesdb") {
scrape_3dboxes->setEnabled(false);
scrape_3dboxes->setOpacity(DISABLED_OPACITY);
scrape_3dboxes->getParent()->getChild(scrape_3dboxes->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scrape_3dboxes->getParent()
->getChild(scrape_3dboxes->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
mWindow->pushGui(s);
@ -311,12 +343,12 @@ void GuiScraperMenu::openMiximageOptions()
auto s = new GuiSettings(mWindow, "MIXIMAGE SETTINGS");
// Miximage resolution.
auto miximage_resolution = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "MIXIMAGE RESOLUTION", false);
auto miximage_resolution = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "MIXIMAGE RESOLUTION", false);
std::string selectedResolution = Settings::getInstance()->getString("MiximageResolution");
miximage_resolution->add("1280x960", "1280x960", selectedResolution == "1280x960");
miximage_resolution->add("1920x1440", "1920x1440", selectedResolution == "1920x1440");
miximage_resolution->add("640x480", "640x480", selectedResolution == "640x480");
miximage_resolution->add("1280x960", "1280x960", selectedResolution == "1280x960");
miximage_resolution->add("1920x1440", "1920x1440", selectedResolution == "1920x1440");
miximage_resolution->add("640x480", "640x480", selectedResolution == "640x480");
// If there are no objects returned, then there must be a manually modified entry in the
// configuration file. Simply set the resolution to "1280x960" in this case.
if (miximage_resolution->getSelectedObjects().size() == 0)
@ -324,19 +356,19 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("MIXIMAGE RESOLUTION", miximage_resolution);
s->addSaveFunc([miximage_resolution, s] {
if (miximage_resolution->getSelected() !=
Settings::getInstance()->getString("MiximageResolution")) {
Settings::getInstance()->
setString("MiximageResolution", miximage_resolution->getSelected());
Settings::getInstance()->getString("MiximageResolution")) {
Settings::getInstance()->setString("MiximageResolution",
miximage_resolution->getSelected());
s->setNeedsSaving();
}
});
// Screenshot scaling method.
auto miximage_scaling = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "SCREENSHOT SCALING", false);
auto miximage_scaling = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "SCREENSHOT SCALING", false);
std::string selectedScaling = Settings::getInstance()->getString("MiximageScreenshotScaling");
miximage_scaling->add("sharp", "sharp", selectedScaling == "sharp");
miximage_scaling->add("smooth", "smooth", selectedScaling == "smooth");
miximage_scaling->add("sharp", "sharp", selectedScaling == "sharp");
miximage_scaling->add("smooth", "smooth", selectedScaling == "smooth");
// If there are no objects returned, then there must be a manually modified entry in the
// configuration file. Simply set the scaling method to "sharp" in this case.
if (miximage_scaling->getSelectedObjects().size() == 0)
@ -344,9 +376,9 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("SCREENSHOT SCALING METHOD", miximage_scaling);
s->addSaveFunc([miximage_scaling, s] {
if (miximage_scaling->getSelected() !=
Settings::getInstance()->getString("MiximageScreenshotScaling")) {
Settings::getInstance()->
setString("MiximageScreenshotScaling", miximage_scaling->getSelected());
Settings::getInstance()->getString("MiximageScreenshotScaling")) {
Settings::getInstance()->setString("MiximageScreenshotScaling",
miximage_scaling->getSelected());
s->setNeedsSaving();
}
});
@ -356,8 +388,7 @@ void GuiScraperMenu::openMiximageOptions()
miximage_generate->setState(Settings::getInstance()->getBool("MiximageGenerate"));
s->addWithLabel("GENERATE MIXIMAGES WHEN SCRAPING", miximage_generate);
s->addSaveFunc([miximage_generate, s] {
if (miximage_generate->getState() !=
Settings::getInstance()->getBool("MiximageGenerate")) {
if (miximage_generate->getState() != Settings::getInstance()->getBool("MiximageGenerate")) {
Settings::getInstance()->setBool("MiximageGenerate", miximage_generate->getState());
s->setNeedsSaving();
}
@ -369,7 +400,7 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("OVERWRITE MIXIMAGES (SCRAPER/OFFLINE GENERATOR)", miximage_overwrite);
s->addSaveFunc([miximage_overwrite, s] {
if (miximage_overwrite->getState() !=
Settings::getInstance()->getBool("MiximageOverwrite")) {
Settings::getInstance()->getBool("MiximageOverwrite")) {
Settings::getInstance()->setBool("MiximageOverwrite", miximage_overwrite->getState());
s->setNeedsSaving();
}
@ -381,9 +412,9 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("REMOVE LETTERBOXES FROM SCREENSHOTS", remove_letterboxes);
s->addSaveFunc([remove_letterboxes, s] {
if (remove_letterboxes->getState() !=
Settings::getInstance()->getBool("MiximageRemoveLetterboxes")) {
Settings::getInstance()->getBool("MiximageRemoveLetterboxes")) {
Settings::getInstance()->setBool("MiximageRemoveLetterboxes",
remove_letterboxes->getState());
remove_letterboxes->getState());
s->setNeedsSaving();
}
});
@ -394,9 +425,9 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("REMOVE PILLARBOXES FROM SCREENSHOTS", remove_pillarboxes);
s->addSaveFunc([remove_pillarboxes, s] {
if (remove_pillarboxes->getState() !=
Settings::getInstance()->getBool("MiximageRemovePillarboxes")) {
Settings::getInstance()->getBool("MiximageRemovePillarboxes")) {
Settings::getInstance()->setBool("MiximageRemovePillarboxes",
remove_pillarboxes->getState());
remove_pillarboxes->getState());
s->setNeedsSaving();
}
});
@ -407,9 +438,9 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("INCLUDE MARQUEE IMAGE", miximage_marquee);
s->addSaveFunc([miximage_marquee, s] {
if (miximage_marquee->getState() !=
Settings::getInstance()->getBool("MiximageIncludeMarquee")) {
Settings::getInstance()->
setBool("MiximageIncludeMarquee", miximage_marquee->getState());
Settings::getInstance()->getBool("MiximageIncludeMarquee")) {
Settings::getInstance()->setBool("MiximageIncludeMarquee",
miximage_marquee->getState());
s->setNeedsSaving();
}
});
@ -419,10 +450,8 @@ void GuiScraperMenu::openMiximageOptions()
miximage_box->setState(Settings::getInstance()->getBool("MiximageIncludeBox"));
s->addWithLabel("INCLUDE BOX IMAGE", miximage_box);
s->addSaveFunc([miximage_box, s] {
if (miximage_box->getState() !=
Settings::getInstance()->getBool("MiximageIncludeBox")) {
Settings::getInstance()->
setBool("MiximageIncludeBox", miximage_box->getState());
if (miximage_box->getState() != Settings::getInstance()->getBool("MiximageIncludeBox")) {
Settings::getInstance()->setBool("MiximageIncludeBox", miximage_box->getState());
s->setNeedsSaving();
}
});
@ -433,9 +462,9 @@ void GuiScraperMenu::openMiximageOptions()
s->addWithLabel("USE COVER IMAGE IF 3D BOX IS MISSING", miximage_cover_fallback);
s->addSaveFunc([miximage_cover_fallback, s] {
if (miximage_cover_fallback->getState() !=
Settings::getInstance()->getBool("MiximageCoverFallback")) {
Settings::getInstance()->
setBool("MiximageCoverFallback", miximage_cover_fallback->getState());
Settings::getInstance()->getBool("MiximageCoverFallback")) {
Settings::getInstance()->setBool("MiximageCoverFallback",
miximage_cover_fallback->getState());
s->setNeedsSaving();
}
});
@ -443,11 +472,13 @@ void GuiScraperMenu::openMiximageOptions()
// Miximage offline generator.
ComponentListRow offline_generator_row;
offline_generator_row.elements.clear();
offline_generator_row.addElement(std::make_shared<TextComponent>
(mWindow, "OFFLINE GENERATOR", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
offline_generator_row.addElement(std::make_shared<TextComponent>(mWindow, "OFFLINE GENERATOR",
Font::get(FONT_SIZE_MEDIUM),
0x777777FF),
true);
offline_generator_row.addElement(makeArrow(mWindow), false);
offline_generator_row.makeAcceptInputHandler(
std::bind(&GuiScraperMenu::openOfflineGenerator, this, s));
std::bind(&GuiScraperMenu::openOfflineGenerator, this, s));
s->addRow(offline_generator_row);
mWindow->pushGui(s);
@ -457,9 +488,9 @@ void GuiScraperMenu::openOfflineGenerator(GuiSettings* settings)
{
if (mSystems->getSelectedObjects().empty()) {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"THE MIXIMAGE GENERATOR USES THE SAME SYSTEM\n"
"SELECTIONS AS THE SCRAPER, SO PLEASE SELECT\n"
"AT LEAST ONE SYSTEM TO GENERATE IMAGES FOR"));
"THE MIXIMAGE GENERATOR USES THE SAME SYSTEM\n"
"SELECTIONS AS THE SCRAPER, SO PLEASE SELECT\n"
"AT LEAST ONE SYSTEM TO GENERATE IMAGES FOR"));
return;
}
@ -492,13 +523,15 @@ void GuiScraperMenu::openOtherOptions()
auto s = new GuiSettings(mWindow, "OTHER SETTINGS");
// Scraper region.
auto scraper_region = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "REGION", false);
auto scraper_region = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "REGION", false);
std::string selectedScraperRegion = Settings::getInstance()->getString("ScraperRegion");
// clang-format off
scraper_region->add("Europe", "eu", selectedScraperRegion == "eu");
scraper_region->add("Japan", "jp", selectedScraperRegion == "jp");
scraper_region->add("USA", "us", selectedScraperRegion == "us");
scraper_region->add("World", "wor", selectedScraperRegion == "wor");
// clang-format on
// If there are no objects returned, then there must be a manually modified entry in the
// configuration file. Simply set the region to "Europe" in this case.
if (scraper_region->getSelectedObjects().size() == 0)
@ -511,18 +544,20 @@ void GuiScraperMenu::openOtherOptions()
}
});
// Regions are not supported by TheGamesDB, so disable the option if this scraper is selected.
// Regions are not supported by TheGamesDB, so gray out the option if this scraper is selected.
if (Settings::getInstance()->getString("Scraper") == "thegamesdb") {
scraper_region->setEnabled(false);
scraper_region->setOpacity(DISABLED_OPACITY);
scraper_region->getParent()->getChild(scraper_region->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scraper_region->getParent()
->getChild(scraper_region->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Scraper language.
auto scraper_language = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "PREFERRED LANGUAGE", false);
auto scraper_language = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "PREFERRED LANGUAGE", false);
std::string selectedScraperLanguage = Settings::getInstance()->getString("ScraperLanguage");
// clang-format off
scraper_language->add("English", "en", selectedScraperLanguage == "en");
scraper_language->add("Español", "es", selectedScraperLanguage == "es");
scraper_language->add("Português", "pt", selectedScraperLanguage == "pt");
@ -543,6 +578,7 @@ void GuiScraperMenu::openOtherOptions()
scraper_language->add("Čeština", "cz", selectedScraperLanguage == "cz");
scraper_language->add("Slovenčina", "sk", selectedScraperLanguage == "sk");
scraper_language->add("Türkçe", "tr", selectedScraperLanguage == "tr");
// clang-format on
// If there are no objects returned, then there must be a manually modified entry in the
// configuration file. Simply set the language to "English" in this case.
if (scraper_language->getSelectedObjects().size() == 0)
@ -550,18 +586,20 @@ void GuiScraperMenu::openOtherOptions()
s->addWithLabel("PREFERRED LANGUAGE", scraper_language);
s->addSaveFunc([scraper_language, s] {
if (scraper_language->getSelected() !=
Settings::getInstance()->getString("ScraperLanguage")) {
Settings::getInstance()->getString("ScraperLanguage")) {
Settings::getInstance()->setString("ScraperLanguage", scraper_language->getSelected());
s->setNeedsSaving();
}
});
// Languages are not supported by TheGamesDB, so disable the option if this scraper is selected.
// Languages are not supported by TheGamesDB, so gray out the option if this scraper is
// selected.
if (Settings::getInstance()->getString("Scraper") == "thegamesdb") {
scraper_language->setEnabled(false);
scraper_language->setOpacity(DISABLED_OPACITY);
scraper_language->getParent()->getChild(scraper_language->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scraper_language->getParent()
->getChild(scraper_language->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Overwrite files and data.
@ -570,37 +608,37 @@ void GuiScraperMenu::openOtherOptions()
s->addWithLabel("OVERWRITE FILES AND DATA", scraper_overwrite_data);
s->addSaveFunc([scraper_overwrite_data, s] {
if (scraper_overwrite_data->getState() !=
Settings::getInstance()->getBool("ScraperOverwriteData")) {
Settings::getInstance()->getBool("ScraperOverwriteData")) {
Settings::getInstance()->setBool("ScraperOverwriteData",
scraper_overwrite_data->getState());
scraper_overwrite_data->getState());
s->setNeedsSaving();
}
});
// Halt scraping on invalid media files.
auto scraper_halt_on_invalid_media = std::make_shared<SwitchComponent>(mWindow);
scraper_halt_on_invalid_media->
setState(Settings::getInstance()->getBool("ScraperHaltOnInvalidMedia"));
scraper_halt_on_invalid_media->setState(
Settings::getInstance()->getBool("ScraperHaltOnInvalidMedia"));
s->addWithLabel("HALT ON INVALID MEDIA FILES", scraper_halt_on_invalid_media);
s->addSaveFunc([scraper_halt_on_invalid_media, s] {
if (scraper_halt_on_invalid_media->getState() !=
Settings::getInstance()->getBool("ScraperHaltOnInvalidMedia")) {
Settings::getInstance()->getBool("ScraperHaltOnInvalidMedia")) {
Settings::getInstance()->setBool("ScraperHaltOnInvalidMedia",
scraper_halt_on_invalid_media->getState());
scraper_halt_on_invalid_media->getState());
s->setNeedsSaving();
}
});
// Search using metadata names.
auto scraper_search_metadata_name = std::make_shared<SwitchComponent>(mWindow);
scraper_search_metadata_name->
setState(Settings::getInstance()->getBool("ScraperSearchMetadataName"));
scraper_search_metadata_name->setState(
Settings::getInstance()->getBool("ScraperSearchMetadataName"));
s->addWithLabel("SEARCH USING METADATA NAMES", scraper_search_metadata_name);
s->addSaveFunc([scraper_search_metadata_name, s] {
if (scraper_search_metadata_name->getState() !=
Settings::getInstance()->getBool("ScraperSearchMetadataName")) {
Settings::getInstance()->getBool("ScraperSearchMetadataName")) {
Settings::getInstance()->setBool("ScraperSearchMetadataName",
scraper_search_metadata_name->getState());
scraper_search_metadata_name->getState());
s->setNeedsSaving();
}
});
@ -611,7 +649,7 @@ void GuiScraperMenu::openOtherOptions()
s->addWithLabel("INTERACTIVE MODE", scraper_interactive);
s->addSaveFunc([scraper_interactive, s] {
if (scraper_interactive->getState() !=
Settings::getInstance()->getBool("ScraperInteractive")) {
Settings::getInstance()->getBool("ScraperInteractive")) {
Settings::getInstance()->setBool("ScraperInteractive", scraper_interactive->getState());
s->setNeedsSaving();
}
@ -621,34 +659,34 @@ void GuiScraperMenu::openOtherOptions()
auto scraper_semiautomatic = std::make_shared<SwitchComponent>(mWindow);
scraper_semiautomatic->setState(Settings::getInstance()->getBool("ScraperSemiautomatic"));
s->addWithLabel("AUTO-ACCEPT SINGLE GAME MATCHES", scraper_semiautomatic);
s->addSaveFunc([scraper_semiautomatic ,s] {
if (scraper_semiautomatic->getState() !=
Settings::getInstance()->getBool("ScraperSemiautomatic")) {
s->addSaveFunc([scraper_semiautomatic, s] {
if (scraper_semiautomatic->getState() !=
Settings::getInstance()->getBool("ScraperSemiautomatic")) {
Settings::getInstance()->setBool("ScraperSemiautomatic",
scraper_semiautomatic->getState());
scraper_semiautomatic->getState());
s->setNeedsSaving();
}
});
// If interactive mode is set to off, then disable this option.
// If interactive mode is set to off, then gray out this option.
if (!Settings::getInstance()->getBool("ScraperInteractive")) {
scraper_semiautomatic->setEnabled(false);
scraper_semiautomatic->setOpacity(DISABLED_OPACITY);
scraper_semiautomatic->getParent()->getChild(scraper_semiautomatic->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scraper_semiautomatic->getParent()
->getChild(scraper_semiautomatic->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Respect the per-file multi-scraper exclusion flag.
auto scraper_respect_exclusions = std::make_shared<SwitchComponent>(mWindow);
scraper_respect_exclusions->setState(
Settings::getInstance()->getBool("ScraperRespectExclusions"));
Settings::getInstance()->getBool("ScraperRespectExclusions"));
s->addWithLabel("RESPECT PER-FILE SCRAPER EXCLUSIONS", scraper_respect_exclusions);
s->addSaveFunc([scraper_respect_exclusions, s] {
if (scraper_respect_exclusions->getState() !=
Settings::getInstance()->getBool("ScraperRespectExclusions")) {
Settings::getInstance()->getBool("ScraperRespectExclusions")) {
Settings::getInstance()->setBool("ScraperRespectExclusions",
scraper_respect_exclusions->getState());
scraper_respect_exclusions->getState());
s->setNeedsSaving();
}
});
@ -656,35 +694,35 @@ void GuiScraperMenu::openOtherOptions()
// Exclude files recursively for excluded folders.
auto scraper_exclude_recursively = std::make_shared<SwitchComponent>(mWindow);
scraper_exclude_recursively->setState(
Settings::getInstance()->getBool("ScraperExcludeRecursively"));
Settings::getInstance()->getBool("ScraperExcludeRecursively"));
s->addWithLabel("EXCLUDE FOLDERS RECURSIVELY", scraper_exclude_recursively);
s->addSaveFunc([scraper_exclude_recursively, s] {
if (scraper_exclude_recursively->getState() !=
Settings::getInstance()->getBool("ScraperExcludeRecursively")) {
Settings::getInstance()->getBool("ScraperExcludeRecursively")) {
Settings::getInstance()->setBool("ScraperExcludeRecursively",
scraper_exclude_recursively->getState());
scraper_exclude_recursively->getState());
s->setNeedsSaving();
}
});
// If respecting excluded files is set to off, then disable this option.
// If respecting excluded files is set to off, then gray out this option.
if (!Settings::getInstance()->getBool("ScraperRespectExclusions")) {
scraper_exclude_recursively->setEnabled(false);
scraper_exclude_recursively->setOpacity(DISABLED_OPACITY);
scraper_exclude_recursively->getParent()->getChild(scraper_exclude_recursively->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scraper_exclude_recursively->getParent()
->getChild(scraper_exclude_recursively->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Include actual folders when scraping.
auto scraper_include_folders = std::make_shared<SwitchComponent>(mWindow);
scraper_include_folders->setState(
Settings::getInstance()->getBool("ScraperIncludeFolders"));
scraper_include_folders->setState(Settings::getInstance()->getBool("ScraperIncludeFolders"));
s->addWithLabel("SCRAPE ACTUAL FOLDERS", scraper_include_folders);
s->addSaveFunc([scraper_include_folders, s] {
if (scraper_include_folders->getState() !=
Settings::getInstance()->getBool("ScraperIncludeFolders")) {
Settings::getInstance()->getBool("ScraperIncludeFolders")) {
Settings::getInstance()->setBool("ScraperIncludeFolders",
scraper_include_folders->getState());
scraper_include_folders->getState());
s->setNeedsSaving();
}
});
@ -692,30 +730,42 @@ void GuiScraperMenu::openOtherOptions()
// Retry search on peer verification errors (TLS/certificate issues).
auto retry_peer_verification = std::make_shared<SwitchComponent>(mWindow);
retry_peer_verification->setState(
Settings::getInstance()->getBool("ScraperRetryPeerVerification"));
Settings::getInstance()->getBool("ScraperRetryPeerVerification"));
s->addWithLabel("AUTO-RETRY ON PEER VERIFICATION ERRORS", retry_peer_verification);
s->addSaveFunc([retry_peer_verification, s] {
if (retry_peer_verification->getState() !=
Settings::getInstance()->getBool("ScraperRetryPeerVerification")) {
Settings::getInstance()->getBool("ScraperRetryPeerVerification")) {
Settings::getInstance()->setBool("ScraperRetryPeerVerification",
retry_peer_verification->getState());
retry_peer_verification->getState());
s->setNeedsSaving();
}
});
// The TLS/certificate issue is not present for TheGamesDB, so gray out the option if this
// scraper is selected.
if (Settings::getInstance()->getString("Scraper") == "thegamesdb") {
retry_peer_verification->setEnabled(false);
retry_peer_verification->setOpacity(DISABLED_OPACITY);
retry_peer_verification->getParent()
->getChild(retry_peer_verification->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
// Switch callbacks.
auto interactiveToggleFunc = [scraper_semiautomatic]() {
if (scraper_semiautomatic->getEnabled()) {
scraper_semiautomatic->setEnabled(false);
scraper_semiautomatic->setOpacity(DISABLED_OPACITY);
scraper_semiautomatic->getParent()->getChild(scraper_semiautomatic->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scraper_semiautomatic->getParent()
->getChild(scraper_semiautomatic->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
else {
scraper_semiautomatic->setEnabled(true);
scraper_semiautomatic->setOpacity(255);
scraper_semiautomatic->getParent()->getChild(scraper_semiautomatic->
getChildIndex() - 1)->setOpacity(255);
scraper_semiautomatic->getParent()
->getChild(scraper_semiautomatic->getChildIndex() - 1)
->setOpacity(255);
}
};
@ -723,14 +773,16 @@ void GuiScraperMenu::openOtherOptions()
if (scraper_exclude_recursively->getEnabled()) {
scraper_exclude_recursively->setEnabled(false);
scraper_exclude_recursively->setOpacity(DISABLED_OPACITY);
scraper_exclude_recursively->getParent()->getChild(scraper_exclude_recursively->
getChildIndex() - 1)->setOpacity(DISABLED_OPACITY);
scraper_exclude_recursively->getParent()
->getChild(scraper_exclude_recursively->getChildIndex() - 1)
->setOpacity(DISABLED_OPACITY);
}
else {
scraper_exclude_recursively->setEnabled(true);
scraper_exclude_recursively->setOpacity(255);
scraper_exclude_recursively->getParent()->getChild(scraper_exclude_recursively->
getChildIndex() - 1)->setOpacity(255);
scraper_exclude_recursively->getParent()
->getChild(scraper_exclude_recursively->getChildIndex() - 1)
->setOpacity(255);
}
};
@ -753,19 +805,18 @@ void GuiScraperMenu::pressedStart()
std::string warningString;
if (sys.size() == 1) {
warningString = "The selected system does not have a\n"
"platform set, results may be inaccurate\n"
"Continue anyway?";
"platform set, results may be inaccurate\n"
"Continue anyway?";
}
else {
warningString = "At least one of your selected\n"
"systems does not have a platform\n"
"set, results may be inaccurate\n"
"Continue anyway?";
"systems does not have a platform\n"
"set, results may be inaccurate\n"
"Continue anyway?";
}
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
Utils::String::toUpper(warningString),
"YES", std::bind(&GuiScraperMenu::start, this),
"NO", nullptr));
Utils::String::toUpper(warningString), "YES",
std::bind(&GuiScraperMenu::start, this), "NO", nullptr));
return;
}
}
@ -775,8 +826,8 @@ void GuiScraperMenu::pressedStart()
void GuiScraperMenu::start()
{
if (mSystems->getSelectedObjects().empty()) {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"PLEASE SELECT AT LEAST ONE SYSTEM TO SCRAPE"));
mWindow->pushGui(
new GuiMsgBox(mWindow, getHelpStyle(), "PLEASE SELECT AT LEAST ONE SYSTEM TO SCRAPE"));
return;
}
@ -790,7 +841,7 @@ void GuiScraperMenu::start()
break;
}
if (scraperService == "screenscraper" &&
Settings::getInstance()->getBool("ScrapeRatings")) {
Settings::getInstance()->getBool("ScrapeRatings")) {
contentToScrape = true;
break;
}
@ -798,8 +849,7 @@ void GuiScraperMenu::start()
contentToScrape = true;
break;
}
if (scraperService == "screenscraper" &&
Settings::getInstance()->getBool("ScrapeVideos")) {
if (scraperService == "screenscraper" && Settings::getInstance()->getBool("ScrapeVideos")) {
contentToScrape = true;
break;
}
@ -816,7 +866,7 @@ void GuiScraperMenu::start()
break;
}
if (scraperService == "screenscraper" &&
Settings::getInstance()->getBool("Scrape3DBoxes")) {
Settings::getInstance()->getBool("Scrape3DBoxes")) {
contentToScrape = true;
break;
}
@ -824,35 +874,35 @@ void GuiScraperMenu::start()
if (!contentToScrape) {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"PLEASE SELECT AT LEAST ONE CONTENT TYPE TO SCRAPE"));
"PLEASE SELECT AT LEAST ONE CONTENT TYPE TO SCRAPE"));
return;
}
std::queue<ScraperSearchParams> searches =
getSearches(mSystems->getSelectedObjects(), mFilters->getSelected());
getSearches(mSystems->getSelectedObjects(), mFilters->getSelected());
if (searches.empty()) {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"ALL GAMES WERE FILTERED, NOTHING TO SCRAPE"));
mWindow->pushGui(
new GuiMsgBox(mWindow, getHelpStyle(), "ALL GAMES WERE FILTERED, NOTHING TO SCRAPE"));
}
else {
GuiScraperMulti* gsm = new GuiScraperMulti(mWindow, searches,
Settings::getInstance()->getBool("ScraperInteractive"));
GuiScraperMulti* gsm = new GuiScraperMulti(
mWindow, searches, Settings::getInstance()->getBool("ScraperInteractive"));
mWindow->pushGui(gsm);
mMenu.setCursorToList();
mMenu.setCursorToFirstListEntry();
}
}
std::queue<ScraperSearchParams> GuiScraperMenu::getSearches(
std::vector<SystemData*> systems, GameFilterFunc selector)
std::queue<ScraperSearchParams> GuiScraperMenu::getSearches(std::vector<SystemData*> systems,
GameFilterFunc selector)
{
std::queue<ScraperSearchParams> queue;
for (auto sys = systems.cbegin(); sys != systems.cend(); sys++) {
std::vector<FileData*> games = (*sys)->getRootFolder()->getScrapeFilesRecursive(
Settings::getInstance()->getBool("ScraperIncludeFolders"),
Settings::getInstance()->getBool("ScraperExcludeRecursively"),
Settings::getInstance()->getBool("ScraperRespectExclusions"));
Settings::getInstance()->getBool("ScraperIncludeFolders"),
Settings::getInstance()->getBool("ScraperExcludeRecursively"),
Settings::getInstance()->getBool("ScraperRespectExclusions"));
for (auto game = games.cbegin(); game != games.cend(); game++) {
if (selector((*sys), (*game))) {
ScraperSearchParams search;
@ -866,8 +916,10 @@ std::queue<ScraperSearchParams> GuiScraperMenu::getSearches(
return queue;
}
void GuiScraperMenu::addEntry(const std::string& name, unsigned int color,
bool add_arrow, const std::function<void()>& func)
void GuiScraperMenu::addEntry(const std::string& name,
unsigned int color,
bool add_arrow,
const std::function<void()>& func)
{
std::shared_ptr<Font> font = Font::get(FONT_SIZE_MEDIUM);

13
es-app/src/guis/GuiScraperMenu.h
View file

@ -16,11 +16,10 @@
#include "scrapers/Scraper.h"
class FileData;
template<typename T>
class OptionListComponent;
class SwitchComponent;
class SystemData;
template <typename T> class OptionListComponent;
typedef std::function<bool(SystemData*, FileData*)> GameFilterFunc;
class GuiScraperMenu : public GuiComponent
@ -38,16 +37,18 @@ private:
void pressedStart();
void start();
void addEntry(const std::string&, unsigned int color,
bool add_arrow, const std::function<void()>& func);
void addEntry(const std::string&,
unsigned int color,
bool add_arrow,
const std::function<void()>& func);
void openAccountOptions();
void openContentOptions();
void openMiximageOptions();
void openOfflineGenerator(GuiSettings* settings);
void openOtherOptions();
std::queue<ScraperSearchParams> getSearches(
std::vector<SystemData*> systems, GameFilterFunc selector);
std::queue<ScraperSearchParams> getSearches(std::vector<SystemData*> systems,
GameFilterFunc selector);
std::shared_ptr<OptionListComponent<std::string>> mScraper;
std::shared_ptr<OptionListComponent<GameFilterFunc>> mFilters;

140
es-app/src/guis/GuiScraperMulti.cpp
View file

@ -11,27 +11,26 @@
#include "guis/GuiScraperMulti.h"
#include "CollectionSystemsManager.h"
#include "Gamelist.h"
#include "MameNames.h"
#include "SystemData.h"
#include "Window.h"
#include "components/ButtonComponent.h"
#include "components/MenuComponent.h"
#include "components/TextComponent.h"
#include "guis/GuiMsgBox.h"
#include "guis/GuiScraperSearch.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "Gamelist.h"
#include "MameNames.h"
#include "SystemData.h"
#include "Window.h"
GuiScraperMulti::GuiScraperMulti(
Window* window,
const std::queue<ScraperSearchParams>& searches,
bool approveResults)
: GuiComponent(window),
mBackground(window, ":/graphics/frame.svg"),
mGrid(window, Vector2i(1, 5)),
mSearchQueue(searches),
mApproveResults(approveResults)
GuiScraperMulti::GuiScraperMulti(Window* window,
const std::queue<ScraperSearchParams>& searches,
bool approveResults)
: GuiComponent(window)
, mBackground(window, ":/graphics/frame.svg")
, mGrid(window, Vector2i(1, 5))
, mSearchQueue(searches)
, mApproveResults(approveResults)
{
assert(mSearchQueue.size());
@ -47,57 +46,72 @@ GuiScraperMulti::GuiScraperMulti(
// Set up grid.
mTitle = std::make_shared<TextComponent>(mWindow, "SCRAPING IN PROGRESS",
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
Font::get(FONT_SIZE_LARGE), 0x555555FF, ALIGN_CENTER);
mGrid.setEntry(mTitle, Vector2i(0, 0), false, true);
mSystem = std::make_shared<TextComponent>(mWindow, "SYSTEM",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF, ALIGN_CENTER);
mSystem = std::make_shared<TextComponent>(mWindow, "SYSTEM", Font::get(FONT_SIZE_MEDIUM),
0x777777FF, ALIGN_CENTER);
mGrid.setEntry(mSystem, Vector2i(0, 1), false, true);
mSubtitle = std::make_shared<TextComponent>(mWindow, "subtitle text",
Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mSubtitle = std::make_shared<TextComponent>(
mWindow, "subtitle text", Font::get(FONT_SIZE_SMALL), 0x888888FF, ALIGN_CENTER);
mGrid.setEntry(mSubtitle, Vector2i(0, 2), false, true);
if (mApproveResults && !Settings::getInstance()->getBool("ScraperSemiautomatic"))
mSearchComp = std::make_shared<GuiScraperSearch>(mWindow,
GuiScraperSearch::NEVER_AUTO_ACCEPT, mTotalGames);
mSearchComp = std::make_shared<GuiScraperSearch>(
mWindow, GuiScraperSearch::NEVER_AUTO_ACCEPT, mTotalGames);
else if (mApproveResults && Settings::getInstance()->getBool("ScraperSemiautomatic"))
mSearchComp = std::make_shared<GuiScraperSearch>(mWindow,
GuiScraperSearch::ACCEPT_SINGLE_MATCHES, mTotalGames);
mSearchComp = std::make_shared<GuiScraperSearch>(
mWindow, GuiScraperSearch::ACCEPT_SINGLE_MATCHES, mTotalGames);
else if (!mApproveResults)
mSearchComp = std::make_shared<GuiScraperSearch>(mWindow,
GuiScraperSearch::ALWAYS_ACCEPT_FIRST_RESULT, mTotalGames);
mSearchComp->setAcceptCallback(std::bind(&GuiScraperMulti::acceptResult,
this, std::placeholders::_1));
mSearchComp = std::make_shared<GuiScraperSearch>(
mWindow, GuiScraperSearch::ALWAYS_ACCEPT_FIRST_RESULT, mTotalGames);
mSearchComp->setAcceptCallback(
std::bind(&GuiScraperMulti::acceptResult, this, std::placeholders::_1));
mSearchComp->setSkipCallback(std::bind(&GuiScraperMulti::skip, this));
mSearchComp->setCancelCallback(std::bind(&GuiScraperMulti::finish, this));
mGrid.setEntry(mSearchComp, Vector2i(0, 3), mSearchComp->getSearchType() !=
GuiScraperSearch::ALWAYS_ACCEPT_FIRST_RESULT, true);
mGrid.setEntry(mSearchComp, Vector2i(0, 3),
mSearchComp->getSearchType() != GuiScraperSearch::ALWAYS_ACCEPT_FIRST_RESULT,
true);
std::vector<std::shared_ptr<ButtonComponent>> buttons;
if (mApproveResults) {
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "REFINE SEARCH",
"refine search", [&] {
mSearchComp->openInputScreen(mSearchQueue.front());
mGrid.resetCursor();
}));
buttons.push_back(
std::make_shared<ButtonComponent>(mWindow, "REFINE SEARCH", "refine search", [&] {
// Refine the search, unless the result has already been accepted or we're in
// semi-automatic mode and there are less than 2 search results.
if (!mSearchComp->getAcceptedResult() &&
!(mSearchComp->getSearchType() == GuiScraperSearch::ACCEPT_SINGLE_MATCHES &&
mSearchComp->getScraperResultsSize() < 2)) {
mSearchComp->openInputScreen(mSearchQueue.front());
mGrid.resetCursor();
}
}));
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "SKIP", "skip game", [&] {
skip();
mGrid.resetCursor();
// Skip game, unless the result has already been accepted.
if (!mSearchComp->getAcceptedResult()) {
skip();
mGrid.resetCursor();
}
}));
}
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "STOP",
"stop", std::bind(&GuiScraperMulti::finish, this)));
buttons.push_back(std::make_shared<ButtonComponent>(mWindow, "STOP", "stop",
std::bind(&GuiScraperMulti::finish, this)));
mButtonGrid = makeButtonGrid(mWindow, buttons);
mGrid.setEntry(mButtonGrid, Vector2i(0, 4), true, false);
setSize(Renderer::getScreenWidth() * 0.95f, Renderer::getScreenHeight() * 0.849f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2, (Renderer::getScreenHeight() -
mSize.y()) / 2);
// Limit the width of the GUI on ultrawide monitors. The 1.778 aspect ratio value is
// the 16:9 reference.
float aspectValue = 1.778f / Renderer::getScreenAspectRatio();
float width = Math::clamp(0.95f * aspectValue, 0.70f, 0.95f) * Renderer::getScreenWidth();
setSize(width, Renderer::getScreenHeight() * 0.849f);
setPosition((Renderer::getScreenWidth() - mSize.x()) / 2.0f,
(Renderer::getScreenHeight() - mSize.y()) / 2.0f);
doNextSearch();
}
@ -106,8 +120,8 @@ GuiScraperMulti::~GuiScraperMulti()
{
if (mTotalSuccessful > 0) {
// Sort all systems to possibly update their view style from Basic to Detailed or Video.
for (auto it = SystemData::sSystemVector.cbegin();
it !=SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
(*it)->sortSystem();
}
}
@ -116,10 +130,10 @@ GuiScraperMulti::~GuiScraperMulti()
void GuiScraperMulti::onSizeChanged()
{
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32, -32));
mBackground.fitTo(mSize, Vector3f::Zero(), Vector2f(-32.0f, -32.0f));
mGrid.setRowHeightPerc(0, mTitle->getFont()->getLetterHeight() * 1.9725f / mSize.y(), false);
mGrid.setRowHeightPerc(1, (mSystem->getFont()->getLetterHeight() + 2) / mSize.y(), false);
mGrid.setRowHeightPerc(1, (mSystem->getFont()->getLetterHeight() + 2.0f) / mSize.y(), false);
mGrid.setRowHeightPerc(2, mSubtitle->getFont()->getHeight() * 1.75f / mSize.y(), false);
mGrid.setRowHeightPerc(4, mButtonGrid->getSize().y() / mSize.y(), false);
mGrid.setSize(mSize);
@ -143,34 +157,36 @@ void GuiScraperMulti::doNextSearch()
}
else {
if (mSearchQueue.front().game->isArcadeGame() &&
Settings::getInstance()->getString("Scraper") == "thegamesdb")
scrapeName = Utils::FileSystem::getFileName(mSearchQueue.front().game->getPath()) +
" (" + MameNames::getInstance()->getCleanName(mSearchQueue.front().game->
getCleanName()) + ")";
Settings::getInstance()->getString("Scraper") == "thegamesdb")
scrapeName =
Utils::FileSystem::getFileName(mSearchQueue.front().game->getPath()) + " (" +
MameNames::getInstance()->getCleanName(mSearchQueue.front().game->getCleanName()) +
")";
else
scrapeName = Utils::FileSystem::getFileName(mSearchQueue.front().game->getPath());
}
// Extract possible subfolders from the path.
std::string folderPath = Utils::String::replace(
Utils::FileSystem::getParent(mSearchQueue.front().game->getPath()),
mSearchQueue.front().system->getSystemEnvData()->mStartPath, "");
std::string folderPath =
Utils::String::replace(Utils::FileSystem::getParent(mSearchQueue.front().game->getPath()),
mSearchQueue.front().system->getSystemEnvData()->mStartPath, "");
if (folderPath.size() >= 2) {
folderPath.erase(0, 1);
#if defined(_WIN64)
#if defined(_WIN64)
folderPath.push_back('\\');
folderPath = Utils::String::replace(folderPath, "/", "\\");
#else
#else
folderPath.push_back('/');
#endif
#endif
}
// Update subtitle.
ss.str("");
ss << "GAME " << (mCurrentGame + 1) << " OF " << mTotalGames << " - " << folderPath <<
scrapeName << ((mSearchQueue.front().game->getType() == FOLDER) ? " " +
ViewController::FOLDER_CHAR : "");
ss << "GAME " << (mCurrentGame + 1) << " OF " << mTotalGames << " - " << folderPath
<< scrapeName
<< ((mSearchQueue.front().game->getType() == FOLDER) ? " " + ViewController::FOLDER_CHAR :
"");
mSubtitle->setText(ss.str());
mSearchComp->search(mSearchQueue.front());
@ -207,12 +223,12 @@ void GuiScraperMulti::finish()
ss << "NO GAMES WERE SCRAPED";
}
else {
ss << mTotalSuccessful << " GAME" <<
((mTotalSuccessful > 1) ? "S" : "") << " SUCCESSFULLY SCRAPED";
ss << mTotalSuccessful << " GAME" << ((mTotalSuccessful > 1) ? "S" : "")
<< " SUCCESSFULLY SCRAPED";
if (mTotalSkipped > 0)
ss << "\n" << mTotalSkipped << " GAME"
<< ((mTotalSkipped > 1) ? "S" : "") << " SKIPPED";
ss << "\n"
<< mTotalSkipped << " GAME" << ((mTotalSkipped > 1) ? "S" : "") << " SKIPPED";
}
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(), ss.str(), "OK", [&] {

27
es-app/src/guis/GuiScraperMulti.h
View file

@ -12,11 +12,11 @@
#ifndef ES_APP_GUIS_GUI_SCRAPER_MULTI_H
#define ES_APP_GUIS_GUI_SCRAPER_MULTI_H
#include "GuiComponent.h"
#include "MetaData.h"
#include "components/ComponentGrid.h"
#include "components/NinePatchComponent.h"
#include "scrapers/Scraper.h"
#include "GuiComponent.h"
#include "MetaData.h"
class GuiScraperSearch;
class TextComponent;
@ -24,10 +24,9 @@ class TextComponent;
class GuiScraperMulti : public GuiComponent
{
public:
GuiScraperMulti(
Window* window,
const std::queue<ScraperSearchParams>& searches,
bool approveResults);
GuiScraperMulti(Window* window,
const std::queue<ScraperSearchParams>& searches,
bool approveResults);
virtual ~GuiScraperMulti();
@ -40,15 +39,7 @@ private:
void acceptResult(const ScraperSearchResult& result);
void skip();
void doNextSearch();
void finish();
unsigned int mTotalGames;
unsigned int mCurrentGame;
unsigned int mTotalSuccessful;
unsigned int mTotalSkipped;
std::queue<ScraperSearchParams> mSearchQueue;
std::vector<MetaDataDecl> mMetaDataDecl;
bool mApproveResults;
NinePatchComponent mBackground;
ComponentGrid mGrid;
@ -58,6 +49,14 @@ private:
std::shared_ptr<TextComponent> mSubtitle;
std::shared_ptr<GuiScraperSearch> mSearchComp;
std::shared_ptr<ComponentGrid> mButtonGrid;
std::queue<ScraperSearchParams> mSearchQueue;
std::vector<MetaDataDecl> mMetaDataDecl;
unsigned int mTotalGames;
unsigned int mCurrentGame;
unsigned int mTotalSuccessful;
unsigned int mTotalSkipped;
bool mApproveResults;
};
#endif // ES_APP_GUIS_GUI_SCRAPER_MULTI_H

265
es-app/src/guis/GuiScraperSearch.cpp
View file

@ -15,6 +15,13 @@
#include "guis/GuiScraperSearch.h"
#include "CollectionSystemsManager.h"
#include "FileData.h"
#include "Log.h"
#include "MameNames.h"
#include "PlatformId.h"
#include "SystemData.h"
#include "Window.h"
#include "components/ComponentList.h"
#include "components/DateTimeEditComponent.h"
#include "components/ImageComponent.h"
@ -26,42 +33,33 @@
#include "resources/Font.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "FileData.h"
#include "Log.h"
#include "MameNames.h"
#include "PlatformId.h"
#include "SystemData.h"
#include "Window.h"
#define FAILED_VERIFICATION_RETRIES 8
GuiScraperSearch::GuiScraperSearch(
Window* window,
SearchType type,
unsigned int scrapeCount)
: GuiComponent(window),
mGrid(window, Vector2i(4, 3)),
mBusyAnim(window),
mSearchType(type),
mScrapeCount(scrapeCount),
mScrapeRatings(false),
mRefinedSearch(false),
mFoundGame(false)
GuiScraperSearch::GuiScraperSearch(Window* window, SearchType type, unsigned int scrapeCount)
: GuiComponent(window)
, mGrid(window, Vector2i(4, 3))
, mBusyAnim(window)
, mSearchType(type)
, mScrapeCount(scrapeCount)
, mScrapeRatings(false)
, mRefinedSearch(false)
, mFoundGame(false)
{
addChild(&mGrid);
mBlockAccept = false;
mAcceptedResult = false;
mRetrySearch = false;
mRetryCount = 0;
// Left spacer (empty component, needed for borders).
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0),
false, false, Vector2i(1, 3), GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 0), false, false,
Vector2i(1, 3), GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
// Selected result name.
mResultName = std::make_shared<TextComponent>(mWindow, "Result name",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
// Selected result thumbnail.
mResultThumbnail = std::make_shared<ImageComponent>(mWindow);
@ -77,7 +75,7 @@ GuiScraperSearch::GuiScraperSearch(
mDescContainer->setScrollParameters(6000, 3000, 85);
mResultDesc = std::make_shared<TextComponent>(mWindow, "Result desc",
Font::get(FONT_SIZE_SMALL), 0x777777FF);
Font::get(FONT_SIZE_SMALL), 0x777777FF);
mDescContainer->addChild(mResultDesc.get());
mDescContainer->setAutoScroll(true);
@ -89,40 +87,47 @@ GuiScraperSearch::GuiScraperSearch(
mMD_ReleaseDate = std::make_shared<DateTimeEditComponent>(mWindow);
mMD_ReleaseDate->setColor(mdColor);
mMD_ReleaseDate->setUppercase(true);
mMD_Developer = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
Vector3f::Zero(), Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Publisher = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
Vector3f::Zero(), Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Genre = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
Vector3f::Zero(), Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Players = std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT,
Vector3f::Zero(), Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Developer =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Publisher =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Genre =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Players =
std::make_shared<TextComponent>(mWindow, "", font, mdColor, ALIGN_LEFT, Vector3f::Zero(),
Vector2f::Zero(), 0x00000000, 0.02f);
mMD_Filler = std::make_shared<TextComponent>(mWindow, "", font, mdColor);
if (Settings::getInstance()->getString("Scraper") != "thegamesdb")
mScrapeRatings = true;
if (mScrapeRatings)
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "RATING:", font, mdLblColor), mMD_Rating, false));
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "RELEASED:", font, mdLblColor), mMD_ReleaseDate));
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "DEVELOPER:", font, mdLblColor), mMD_Developer));
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "PUBLISHER:", font, mdLblColor), mMD_Publisher));
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "GENRE:", font, mdLblColor), mMD_Genre));
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "PLAYERS:", font, mdLblColor), mMD_Players));
mMD_Pairs.push_back(
MetaDataPair(std::make_shared<TextComponent>(mWindow, "RATING:", font, mdLblColor),
mMD_Rating, false));
mMD_Pairs.push_back(MetaDataPair(
std::make_shared<TextComponent>(mWindow, "RELEASED:", font, mdLblColor), mMD_ReleaseDate));
mMD_Pairs.push_back(MetaDataPair(
std::make_shared<TextComponent>(mWindow, "DEVELOPER:", font, mdLblColor), mMD_Developer));
mMD_Pairs.push_back(MetaDataPair(
std::make_shared<TextComponent>(mWindow, "PUBLISHER:", font, mdLblColor), mMD_Publisher));
mMD_Pairs.push_back(MetaDataPair(
std::make_shared<TextComponent>(mWindow, "GENRE:", font, mdLblColor), mMD_Genre));
mMD_Pairs.push_back(MetaDataPair(
std::make_shared<TextComponent>(mWindow, "PLAYERS:", font, mdLblColor), mMD_Players));
// If no rating is being scraped, add a filler to make sure that the fonts keep the same
// size so the GUI looks consistent.
if (!mScrapeRatings)
mMD_Pairs.push_back(MetaDataPair(std::make_shared<TextComponent>
(mWindow, "", font, mdLblColor), mMD_Filler));
mMD_Pairs.push_back(MetaDataPair(
std::make_shared<TextComponent>(mWindow, "", font, mdLblColor), mMD_Filler));
mMD_Grid = std::make_shared<ComponentGrid>(mWindow,
Vector2i(2, static_cast<int>(mMD_Pairs.size()*2 - 1)));
mMD_Grid = std::make_shared<ComponentGrid>(
mWindow, Vector2i(2, static_cast<int>(mMD_Pairs.size() * 2 - 1)));
unsigned int i = 0;
for (auto it = mMD_Pairs.cbegin(); it != mMD_Pairs.cend(); it++) {
mMD_Grid->setEntry(it->first, Vector2i(0, i), false, true);
@ -135,7 +140,9 @@ GuiScraperSearch::GuiScraperSearch(
// Result list.
mResultList = std::make_shared<ComponentList>(mWindow);
mResultList->setCursorChangedCallback([this](CursorState state) {
if (state == CURSOR_STOPPED) updateInfoPane(); });
if (state == CURSOR_STOPPED)
updateInfoPane();
});
updateViewStyle();
}
@ -163,7 +170,7 @@ GuiScraperSearch::~GuiScraperSearch()
// This is required to properly refresh the gamelist view if the user aborted the
// scraping when the miximage was getting generated.
if (Settings::getInstance()->getBool("MiximageGenerate") &&
mMiximageGeneratorThread.joinable()) {
mMiximageGeneratorThread.joinable()) {
mScrapeResult.savedNewMedia = true;
// We always let the miximage generator thread complete.
mMiximageGeneratorThread.join();
@ -196,7 +203,7 @@ void GuiScraperSearch::onSizeChanged()
// Row heights.
if (mSearchType == ALWAYS_ACCEPT_FIRST_RESULT) // Show name.
mGrid.setRowHeightPerc(0, (mResultName->getFont()->getHeight() * 1.6f) /
mGrid.getSize().y()); // Result name.
mGrid.getSize().y()); // Result name.
else
mGrid.setRowHeightPerc(0, 0.0825f); // Hide name but do padding.
@ -216,11 +223,11 @@ void GuiScraperSearch::onSizeChanged()
resizeMetadata();
if (mSearchType != ALWAYS_ACCEPT_FIRST_RESULT)
mDescContainer->setSize(mGrid.getColWidth(1) * boxartCellScale +
mGrid.getColWidth(2), mResultDesc->getFont()->getHeight() * 3);
mDescContainer->setSize(mGrid.getColWidth(1) * boxartCellScale + mGrid.getColWidth(2),
mResultDesc->getFont()->getHeight() * 3.0f);
else
mDescContainer->setSize(mGrid.getColWidth(3) * boxartCellScale,
mResultDesc->getFont()->getHeight() * 6);
mResultDesc->getFont()->getHeight() * 6.0f);
// Make description text wrap at edge of container.
mResultDesc->setSize(mDescContainer->getSize().x(), 0);
@ -247,13 +254,14 @@ void GuiScraperSearch::resizeMetadata()
it->first->setFont(fontLbl);
it->first->setSize(0, 0);
if (it->first->getSize().x() > maxLblWidth)
maxLblWidth = it->first->getSize().x() +
(16.0f * Renderer::getScreenWidthModifier());
maxLblWidth =
it->first->getSize().x() + (16.0f * Renderer::getScreenWidthModifier());
}
for (unsigned int i = 0; i < mMD_Pairs.size(); i++)
mMD_Grid->setRowHeightPerc(i * 2, (fontLbl->getLetterHeight() +
(2.0f * Renderer::getScreenHeightModifier())) / mMD_Grid->getSize().y());
mMD_Grid->setRowHeightPerc(
i * 2, (fontLbl->getLetterHeight() + (2.0f * Renderer::getScreenHeightModifier())) /
mMD_Grid->getSize().y());
// Update component fonts.
mMD_ReleaseDate->setFont(fontComp);
@ -286,30 +294,30 @@ void GuiScraperSearch::updateViewStyle()
if (mSearchType == ALWAYS_ACCEPT_FIRST_RESULT) {
// Show name.
mGrid.setEntry(mResultName, Vector2i(1, 0), false, false, Vector2i(2, 1),
GridFlags::BORDER_TOP);
GridFlags::BORDER_TOP);
// Need a border on the bottom left.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 2),
false, false, Vector2i(3, 1), GridFlags::BORDER_BOTTOM);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(0, 2), false, false,
Vector2i(3, 1), GridFlags::BORDER_BOTTOM);
// Show description on the right.
mGrid.setEntry(mDescContainer, Vector2i(3, 0), false, false, Vector2i(1, 3),
GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
// Make description text wrap at edge of container.
mResultDesc->setSize(mDescContainer->getSize().x(), 0.0f);
}
else {
// Fake row where name would be.
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0),
false, true, Vector2i(2, 1), GridFlags::BORDER_TOP);
mGrid.setEntry(std::make_shared<GuiComponent>(mWindow), Vector2i(1, 0), false, true,
Vector2i(2, 1), GridFlags::BORDER_TOP);
// Show result list on the right.
mGrid.setEntry(mResultList, Vector2i(3, 0), true, true, Vector2i(1, 3),
GridFlags::BORDER_LEFT | GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
GridFlags::BORDER_LEFT | GridFlags::BORDER_TOP | GridFlags::BORDER_BOTTOM);
// Show description under image/info.
mGrid.setEntry(mDescContainer, Vector2i(1, 2), false, false, Vector2i(2, 1),
GridFlags::BORDER_BOTTOM);
GridFlags::BORDER_BOTTOM);
// Make description text wrap at edge of container.
mResultDesc->setSize(mDescContainer->getSize().x(), 0);
}
@ -318,6 +326,7 @@ void GuiScraperSearch::updateViewStyle()
void GuiScraperSearch::search(const ScraperSearchParams& params)
{
mBlockAccept = true;
mAcceptedResult = false;
mMiximageResult = false;
mScrapeResult = {};
@ -340,6 +349,7 @@ void GuiScraperSearch::stop()
mMDRetrieveURLsHandle.reset();
mMiximageGenerator.reset();
mBlockAccept = false;
mAcceptedResult = false;
mMiximageResult = false;
mScrapeResult = {};
}
@ -355,16 +365,17 @@ void GuiScraperSearch::onSearchDone(const std::vector<ScraperSearchResult>& resu
if (results.empty()) {
// Check if the scraper used is still valid.
if (!isValidConfiguredScraper()) {
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
Utils::String::toUpper("Configured scraper is no longer available.\n"
"Please change the scraping source in the settings."),
mWindow->pushGui(new GuiMsgBox(
mWindow, getHelpStyle(),
Utils::String::toUpper("Configured scraper is no longer available.\n"
"Please change the scraping source in the settings."),
"FINISH", mSkipCallback));
}
else {
mFoundGame = false;
ComponentListRow row;
row.addElement(std::make_shared<TextComponent>(mWindow, "NO GAMES FOUND",
font, color), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "NO GAMES FOUND", font, color),
true);
if (mSkipCallback)
row.makeAcceptInputHandler(mSkipCallback);
@ -379,8 +390,10 @@ void GuiScraperSearch::onSearchDone(const std::vector<ScraperSearchResult>& resu
for (size_t i = 0; i < results.size(); i++) {
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow,
Utils::String::toUpper(results.at(i).mdl.get("name")), font, color), true);
row.addElement(
std::make_shared<TextComponent>(
mWindow, Utils::String::toUpper(results.at(i).mdl.get("name")), font, color),
true);
row.makeAcceptInputHandler([this, i] { returnResult(mScraperResults.at(i)); });
mResultList->addRow(row);
}
@ -393,14 +406,14 @@ void GuiScraperSearch::onSearchDone(const std::vector<ScraperSearchResult>& resu
// If there is no thumbnail to download and we're in semi-automatic mode, proceed to return
// the results or we'll get stuck forever waiting for a thumbnail to be downloaded.
if (mSearchType == ACCEPT_SINGLE_MATCHES && results.size() == 1 &&
mScraperResults.front().thumbnailImageUrl == "")
mScraperResults.front().thumbnailImageUrl == "")
returnResult(mScraperResults.front());
// For automatic mode, if there's no thumbnail to download or no matching games found,
// proceed directly or we'll get stuck forever.
if (mSearchType == ALWAYS_ACCEPT_FIRST_RESULT) {
if (mScraperResults.size() == 0 || (mScraperResults.size() > 0 &&
mScraperResults.front().thumbnailImageUrl == "")) {
if (mScraperResults.size() == 0 ||
(mScraperResults.size() > 0 && mScraperResults.front().thumbnailImageUrl == "")) {
if (mScraperResults.size() == 0)
mSkipCallback();
else
@ -420,12 +433,12 @@ void GuiScraperSearch::onSearchError(const std::string& error, HttpReq::Status s
// the error dialog will be presented to the user, and if the "Retry" button is pressed,
// a new round of retries will take place.
if (status == HttpReq::REQ_FAILED_VERIFICATION && mRetryCount < FAILED_VERIFICATION_RETRIES &&
Settings::getInstance()->getBool("ScraperRetryPeerVerification")) {
Settings::getInstance()->getBool("ScraperRetryPeerVerification")) {
LOG(LogError) << "GuiScraperSearch: " << Utils::String::replace(error, "\n", "");
mRetrySearch = true;
mRetryCount++;
LOG(LogError) << "GuiScraperSearch: Attempting automatic retry " << mRetryCount <<
" of " << FAILED_VERIFICATION_RETRIES;
LOG(LogError) << "GuiScraperSearch: Attempting automatic retry " << mRetryCount << " of "
<< FAILED_VERIFICATION_RETRIES;
return;
}
else {
@ -435,15 +448,16 @@ void GuiScraperSearch::onSearchError(const std::string& error, HttpReq::Status s
if (mScrapeCount > 1) {
LOG(LogError) << "GuiScraperSearch: " << Utils::String::replace(error, "\n", "");
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(), Utils::String::toUpper(error),
"RETRY", std::bind(&GuiScraperSearch::search, this, mLastSearch),
"SKIP", mSkipCallback,
"CANCEL", mCancelCallback, true));
"RETRY",
std::bind(&GuiScraperSearch::search, this, mLastSearch),
"SKIP", mSkipCallback, "CANCEL", mCancelCallback, true));
}
else {
LOG(LogError) << "GuiScraperSearch: " << Utils::String::replace(error, "\n", "");
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(), Utils::String::toUpper(error),
"RETRY", std::bind(&GuiScraperSearch::search, this, mLastSearch),
"CANCEL", mCancelCallback, "", nullptr, true));
"RETRY",
std::bind(&GuiScraperSearch::search, this, mLastSearch),
"CANCEL", mCancelCallback, "", nullptr, true));
}
}
@ -489,9 +503,9 @@ void GuiScraperSearch::updateInfoPane()
// Add an entry into the thumbnail map, this way we can track and download
// each thumbnail separately even as they're downloading while scrolling
// through the result list.
mThumbnailReqMap.insert(std::pair<std::string,
std::unique_ptr<HttpReq>>(mScraperResults[i].thumbnailImageUrl,
std::unique_ptr<HttpReq>(new HttpReq(thumb))));
mThumbnailReqMap.insert(std::pair<std::string, std::unique_ptr<HttpReq>>(
mScraperResults[i].thumbnailImageUrl,
std::unique_ptr<HttpReq>(new HttpReq(thumb))));
}
}
}
@ -535,12 +549,17 @@ bool GuiScraperSearch::input(InputConfig* config, Input input)
return true;
}
// Refine search.
if (config->isMappedTo("y", input) && input.value != 0)
openInputScreen(mLastSearch);
// Refine the search, unless the result has already been accepted or we're in semi-automatic
// mode and there are less than 2 search results.
if (!mAcceptedResult && config->isMappedTo("y", input) && input.value != 0) {
if (mSearchType != ACCEPT_SINGLE_MATCHES ||
(mSearchType == ACCEPT_SINGLE_MATCHES && mScraperResults.size() > 1)) {
openInputScreen(mLastSearch);
}
}
// Skip game.
if (mScrapeCount > 1 && config->isMappedTo("x", input) && input.value != 0)
// Skip game, unless the result has already been accepted.
if (!mAcceptedResult && mScrapeCount > 1 && config->isMappedTo("x", input) && input.value != 0)
mSkipCallback();
return GuiComponent::input(config, input);
@ -562,6 +581,7 @@ void GuiScraperSearch::render(const Transform4x4f& parentTrans)
void GuiScraperSearch::returnResult(ScraperSearchResult result)
{
mBlockAccept = true;
mAcceptedResult = true;
// Resolve metadata image before returning.
if (result.mediaFilesDownloadStatus != COMPLETED) {
@ -593,8 +613,8 @@ void GuiScraperSearch::update(int deltaTime)
// Check if the thumbnail for the currently selected game has finished downloading.
if (mScraperResults.size() > 0) {
auto it = mThumbnailReqMap.find(mScraperResults[mResultList->
getCursorId()].thumbnailImageUrl);
auto it =
mThumbnailReqMap.find(mScraperResults[mResultList->getCursorId()].thumbnailImageUrl);
if (it != mThumbnailReqMap.end() && it->second->status() != HttpReq::REQ_IN_PROGRESS)
updateThumbnail();
}
@ -681,13 +701,14 @@ void GuiScraperSearch::update(int deltaTime)
mMDResolveHandle.reset();
if (mScrapeResult.mediaFilesDownloadStatus == COMPLETED &&
Settings::getInstance()->getBool("MiximageGenerate")) {
Settings::getInstance()->getBool("MiximageGenerate")) {
std::string currentMiximage = mLastSearch.game->getMiximagePath();
if (currentMiximage == "" || (currentMiximage != "" &&
Settings::getInstance()->getBool("MiximageOverwrite"))) {
if (currentMiximage == "" ||
(currentMiximage != "" &&
Settings::getInstance()->getBool("MiximageOverwrite"))) {
mMiximageGenerator = std::make_unique<MiximageGenerator>(mLastSearch.game,
mResultMessage);
mMiximageGenerator =
std::make_unique<MiximageGenerator>(mLastSearch.game, mResultMessage);
// The promise/future mechanism is used as signaling for the thread to
// indicate that processing has been completed. The reason to run a separate
@ -697,8 +718,9 @@ void GuiScraperSearch::update(int deltaTime)
std::promise<bool>().swap(mGeneratorPromise);
mGeneratorFuture = mGeneratorPromise.get_future();
mMiximageGeneratorThread = std::thread(&MiximageGenerator::startThread,
mMiximageGenerator.get(), &mGeneratorPromise);
mMiximageGeneratorThread =
std::thread(&MiximageGenerator::startThread, mMiximageGenerator.get(),
&mGeneratorPromise);
}
else {
returnResult(mScrapeResult);
@ -724,7 +746,7 @@ void GuiScraperSearch::updateThumbnail()
// thumbnail download has been completed for this game.
if (mScraperResults[mResultList->getCursorId()].thumbnailDownloadStatus == IN_PROGRESS) {
mScraperResults[mResultList->getCursorId()].thumbnailImageData =
it->second->getContent();
it->second->getContent();
mScraperResults[mResultList->getCursorId()].thumbnailDownloadStatus = COMPLETED;
}
// Activate the thumbnail in the GUI.
@ -737,7 +759,7 @@ void GuiScraperSearch::updateThumbnail()
else {
mResultThumbnail->setImage("");
onSearchError("Error downloading thumbnail:\n " + it->second->getErrorMsg(),
it->second->status());
it->second->status());
}
mThumbnailReqMap.erase(it);
@ -746,9 +768,9 @@ void GuiScraperSearch::updateThumbnail()
// we are in semi-automatic mode with a single matching game result, we proceed
// to immediately download the rest of the media files.
if ((mSearchType == ALWAYS_ACCEPT_FIRST_RESULT ||
(mSearchType == ACCEPT_SINGLE_MATCHES && mScraperResults.size() == 1 &&
mRefinedSearch == false)) &&
mScraperResults.front().thumbnailDownloadStatus == COMPLETED) {
(mSearchType == ACCEPT_SINGLE_MATCHES && mScraperResults.size() == 1 &&
mRefinedSearch == false)) &&
mScraperResults.front().thumbnailDownloadStatus == COMPLETED) {
mRefinedSearch = false;
if (mScraperResults.size() == 0)
mSkipCallback();
@ -760,12 +782,12 @@ void GuiScraperSearch::updateThumbnail()
void GuiScraperSearch::openInputScreen(ScraperSearchParams& params)
{
auto searchForFunc = [&](const std::string& name) {
stop();
mRefinedSearch = true;
params.nameOverride = name;
search(params);
};
stop();
mRetryCount = 0;
std::string searchString;
@ -778,25 +800,26 @@ void GuiScraperSearch::openInputScreen(ScraperSearchParams& params)
}
else {
// If searching based on the actual file name, then expand to the full game name
// in case the scraper is set to TheGamesDB and it's an arcade game. This is required
// as TheGamesDB has issues with searches using the short MAME names.
// in case the scraper is set to TheGamesDB and it's an arcade game. This is
// required as TheGamesDB does not support searches using the short MAME names.
if (params.game->isArcadeGame() &&
Settings::getInstance()->getString("Scraper") == "thegamesdb")
Settings::getInstance()->getString("Scraper") == "thegamesdb")
searchString = MameNames::getInstance()->getCleanName(params.game->getCleanName());
else
searchString = params.game->getCleanName();
}
}
else {
else {
searchString = params.nameOverride;
}
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), "REFINE SEARCH",
searchString, searchForFunc, false, "SEARCH", "APPLY CHANGES?"));
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), "REFINE SEARCH", searchString,
searchForFunc, false, "SEARCH", "APPLY CHANGES?"));
}
bool GuiScraperSearch::saveMetadata(
const ScraperSearchResult& result, MetaDataList& metadata, FileData* scrapedGame)
bool GuiScraperSearch::saveMetadata(const ScraperSearchResult& result,
MetaDataList& metadata,
FileData* scrapedGame)
{
bool metadataUpdated = false;
bool hasDefaultName = false;
@ -825,7 +848,7 @@ bool GuiScraperSearch::saveMetadata(
// Skip element if the setting to not scrape metadata has been set,
// unless its type is rating or name.
if (!Settings::getInstance()->getBool("ScrapeMetadata") &&
(key != "rating" && key != "name"))
(key != "rating" && key != "name"))
continue;
// Skip saving of rating if the corresponding option has been set to false.
@ -885,7 +908,7 @@ std::vector<HelpPrompt> GuiScraperSearch::getHelpPrompts()
if (mScrapeCount > 1)
prompts.push_back(HelpPrompt("x", "skip"));
if (mFoundGame && (mRefinedSearch || mSearchType != ACCEPT_SINGLE_MATCHES ||
(mSearchType == ACCEPT_SINGLE_MATCHES && mScraperResults.size() > 1)))
(mSearchType == ACCEPT_SINGLE_MATCHES && mScraperResults.size() > 1)))
prompts.push_back(HelpPrompt("a", "accept result"));
return prompts;
@ -897,13 +920,3 @@ HelpStyle GuiScraperSearch::getHelpStyle()
style.applyTheme(ViewController::get()->getState().getSystem()->getTheme(), "system");
return style;
}
void GuiScraperSearch::onFocusGained()
{
mGrid.onFocusGained();
}
void GuiScraperSearch::onFocusLost()
{
mGrid.onFocusLost();
}

62
es-app/src/guis/GuiScraperSearch.h
View file

@ -16,11 +16,11 @@
#ifndef ES_APP_GUIS_GUI_SCRAPER_SEARCH_H
#define ES_APP_GUIS_GUI_SCRAPER_SEARCH_H
#include "GuiComponent.h"
#include "MiximageGenerator.h"
#include "components/BusyComponent.h"
#include "components/ComponentGrid.h"
#include "scrapers/Scraper.h"
#include "GuiComponent.h"
#include "MiximageGenerator.h"
#include <future>
#include <thread>
@ -36,9 +36,9 @@ class GuiScraperSearch : public GuiComponent
{
public:
enum SearchType {
ALWAYS_ACCEPT_FIRST_RESULT,
ACCEPT_SINGLE_MATCHES,
NEVER_AUTO_ACCEPT
ALWAYS_ACCEPT_FIRST_RESULT, // Automatic mode.
ACCEPT_SINGLE_MATCHES, // Semi-automatic mode.
NEVER_AUTO_ACCEPT // Manual mode.
};
GuiScraperSearch(Window* window, SearchType searchType, unsigned int scrapeCount = 1);
@ -47,20 +47,31 @@ public:
void search(const ScraperSearchParams& params);
void openInputScreen(ScraperSearchParams& from);
void stop();
inline SearchType getSearchType() const { return mSearchType; }
int getScraperResultsSize() { return static_cast<int>(mScraperResults.size()); }
bool getAcceptedResult() { return mAcceptedResult; }
SearchType getSearchType() const { return mSearchType; }
bool getSavedNewMedia()
{ return (mMDResolveHandle ? mMDResolveHandle->getSavedNewMedia() : false); };
{
return (mMDResolveHandle ? mMDResolveHandle->getSavedNewMedia() : false);
}
static bool saveMetadata(const ScraperSearchResult& result,
MetaDataList& metadata, FileData* scrapedGame);
MetaDataList& metadata,
FileData* scrapedGame);
// Metadata assets will be resolved before calling the accept callback
// (e.g. result.mdl's "image" is automatically downloaded and properly set).
inline void setAcceptCallback(const std::function<void(const ScraperSearchResult&)>&
acceptCallback) { mAcceptCallback = acceptCallback; }
inline void setSkipCallback(const std::function<void()>&
skipCallback) { mSkipCallback = skipCallback; };
inline void setCancelCallback(const std::function<void()>&
cancelCallback) { mScrapeCount -= 1; mCancelCallback = cancelCallback; }
// Metadata assets will be resolved before calling the accept callback.
void setAcceptCallback(const std::function<void(const ScraperSearchResult&)>& acceptCallback)
{
mAcceptCallback = acceptCallback;
}
void setSkipCallback(const std::function<void()>& skipCallback)
{
mSkipCallback = skipCallback;
}
void setCancelCallback(const std::function<void()>& cancelCallback)
{
mScrapeCount -= 1;
mCancelCallback = cancelCallback;
}
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
@ -68,20 +79,19 @@ public:
std::vector<HelpPrompt> getHelpPrompts() override;
HelpStyle getHelpStyle() override;
void onSizeChanged() override;
void onFocusGained() override;
void onFocusLost() override;
void unsetRefinedSearch() { mRefinedSearch = false; }
void onFocusGained() override { mGrid.onFocusGained(); }
void onFocusLost() override { mGrid.onFocusLost(); }
private:
void updateViewStyle();
void updateThumbnail();
void updateInfoPane();
void resizeMetadata();
void onSearchError(const std::string& error, HttpReq::Status status =
HttpReq::REQ_UNDEFINED_ERROR);
void onSearchError(const std::string& error,
HttpReq::Status status = HttpReq::REQ_UNDEFINED_ERROR);
void onSearchDone(const std::vector<ScraperSearchResult>& results);
int getSelectedIndex();
@ -117,8 +127,13 @@ private:
bool resize;
MetaDataPair(const std::shared_ptr<TextComponent>& f,
const std::shared_ptr<GuiComponent>& s, bool r = true)
: first(f), second(s), resize(r) {};
const std::shared_ptr<GuiComponent>& s,
bool r = true)
: first(f)
, second(s)
, resize(r)
{
}
};
std::vector<MetaDataPair> mMD_Pairs;
@ -132,6 +147,7 @@ private:
unsigned int mScrapeCount;
bool mRefinedSearch;
bool mBlockAccept;
bool mAcceptedResult;
bool mFoundGame;
bool mScrapeRatings;

203
es-app/src/guis/GuiScreensaverOptions.cpp
View file

@ -9,54 +9,55 @@
#include "guis/GuiScreensaverOptions.h"
#include "Settings.h"
#include "components/OptionListComponent.h"
#include "components/SliderComponent.h"
#include "components/SwitchComponent.h"
#include "guis/GuiMsgBox.h"
#include "Settings.h"
GuiScreensaverOptions::GuiScreensaverOptions(Window* window, const std::string& title)
: GuiSettings(window, title)
: GuiSettings(window, title)
{
// Screensaver timer.
auto screensaver_timer = std::make_shared<SliderComponent>(mWindow, 0.f, 30.f, 1.f, "m");
screensaver_timer->setValue(static_cast<float>(Settings::getInstance()->
getInt("ScreensaverTimer") / (1000 * 60)));
auto screensaver_timer = std::make_shared<SliderComponent>(mWindow, 0.0f, 30.0f, 1.0f, "m");
screensaver_timer->setValue(
static_cast<float>(Settings::getInstance()->getInt("ScreensaverTimer") / (1000 * 60)));
addWithLabel("START SCREENSAVER AFTER (MINUTES)", screensaver_timer);
addSaveFunc([screensaver_timer, this] {
if (static_cast<int>(std::round(screensaver_timer->getValue()) * (1000 * 60)) !=
Settings::getInstance()->getInt("ScreensaverTimer")) {
Settings::getInstance()->setInt("ScreensaverTimer",
static_cast<int>(std::round(screensaver_timer->getValue()) * (1000 * 60)));
Settings::getInstance()->getInt("ScreensaverTimer")) {
Settings::getInstance()->setInt(
"ScreensaverTimer",
static_cast<int>(std::round(screensaver_timer->getValue()) * (1000 * 60)));
setNeedsSaving();
}
});
// Screensaver type.
auto screensaver_type = std::make_shared<OptionListComponent<std::string>>
(mWindow, getHelpStyle(), "SCREENSAVER TYPE", false);
auto screensaver_type = std::make_shared<OptionListComponent<std::string>>(
mWindow, getHelpStyle(), "SCREENSAVER TYPE", false);
std::vector<std::string> screensavers;
screensavers.push_back("dim");
screensavers.push_back("black");
screensavers.push_back("slideshow");
screensavers.push_back("video");
for (auto it = screensavers.cbegin(); it != screensavers.cend(); it++)
screensaver_type->add(*it, *it, Settings::getInstance()->
getString("ScreensaverType") == *it);
screensaver_type->add(*it, *it,
Settings::getInstance()->getString("ScreensaverType") == *it);
addWithLabel("SCREENSAVER TYPE", screensaver_type);
addSaveFunc([screensaver_type, this] {
if (screensaver_type->getSelected() !=
Settings::getInstance()->getString("ScreensaverType")) {
Settings::getInstance()->getString("ScreensaverType")) {
if (screensaver_type->getSelected() == "video") {
// If before it wasn't risky but now there's a risk of problems, show warning.
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"THE 'VIDEO' SCREENSAVER SHOWS\nVIDEOS FROM YOUR GAMELISTS\n\n"
"IF YOU DO NOT HAVE ANY VIDEOS, THE\n"
"SCREENSAVER WILL DEFAULT TO 'DIM'",
"OK", [] { return; }, "", nullptr, "", nullptr));
}
Settings::getInstance()->setString("ScreensaverType",
screensaver_type->getSelected());
mWindow->pushGui(new GuiMsgBox(
mWindow, getHelpStyle(),
"THE 'VIDEO' SCREENSAVER SHOWS\nVIDEOS FROM YOUR GAMELISTS\n\n"
"IF YOU DO NOT HAVE ANY VIDEOS, THE\n"
"SCREENSAVER WILL DEFAULT TO 'DIM'",
"OK", [] { return; }, "", nullptr, "", nullptr));
}
Settings::getInstance()->setString("ScreensaverType", screensaver_type->getSelected());
setNeedsSaving();
}
});
@ -67,9 +68,9 @@ GuiScreensaverOptions::GuiScreensaverOptions(Window* window, const std::string&
addWithLabel("ENABLE SCREENSAVER CONTROLS", screensaver_controls);
addSaveFunc([screensaver_controls, this] {
if (screensaver_controls->getState() !=
Settings::getInstance()->getBool("ScreensaverControls")) {
Settings::getInstance()->getBool("ScreensaverControls")) {
Settings::getInstance()->setBool("ScreensaverControls",
screensaver_controls->getState());
screensaver_controls->getState());
setNeedsSaving();
}
});
@ -77,19 +78,21 @@ GuiScreensaverOptions::GuiScreensaverOptions(Window* window, const std::string&
// Show filtered menu.
ComponentListRow row;
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow,
"SLIDESHOW SCREENSAVER SETTINGS", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "SLIDESHOW SCREENSAVER SETTINGS",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.addElement(makeArrow(mWindow), false);
row.makeAcceptInputHandler(std::bind(
&GuiScreensaverOptions::openSlideshowScreensaverOptions, this));
row.makeAcceptInputHandler(
std::bind(&GuiScreensaverOptions::openSlideshowScreensaverOptions, this));
addRow(row);
row.elements.clear();
row.addElement(std::make_shared<TextComponent>(mWindow,
"VIDEO SCREENSAVER SETTINGS", Font::get(FONT_SIZE_MEDIUM), 0x777777FF), true);
row.addElement(std::make_shared<TextComponent>(mWindow, "VIDEO SCREENSAVER SETTINGS",
Font::get(FONT_SIZE_MEDIUM), 0x777777FF),
true);
row.addElement(makeArrow(mWindow), false);
row.makeAcceptInputHandler(std::bind(
&GuiScreensaverOptions::openVideoScreensaverOptions, this));
row.makeAcceptInputHandler(
std::bind(&GuiScreensaverOptions::openVideoScreensaverOptions, this));
addRow(row);
}
@ -99,104 +102,105 @@ void GuiScreensaverOptions::openSlideshowScreensaverOptions()
// Timer for swapping images (in seconds).
auto screensaver_swap_image_timeout =
std::make_shared<SliderComponent>(mWindow, 2.f, 120.f, 2.f, "s");
screensaver_swap_image_timeout->setValue(static_cast<float>(Settings::getInstance()->
getInt("ScreensaverSwapImageTimeout") / (1000)));
std::make_shared<SliderComponent>(mWindow, 2.0f, 120.0f, 2.0f, "s");
screensaver_swap_image_timeout->setValue(static_cast<float>(
Settings::getInstance()->getInt("ScreensaverSwapImageTimeout") / (1000)));
s->addWithLabel("SWAP IMAGES AFTER (SECONDS)", screensaver_swap_image_timeout);
s->addSaveFunc([screensaver_swap_image_timeout, s] {
if (screensaver_swap_image_timeout->getValue() !=
static_cast<float>(Settings::getInstance()->
getInt("ScreensaverSwapImageTimeout") / (1000))) {
Settings::getInstance()->setInt("ScreensaverSwapImageTimeout",
static_cast<int>(std::round(screensaver_swap_image_timeout->getValue()) *
(1000)));
static_cast<float>(Settings::getInstance()->getInt("ScreensaverSwapImageTimeout") /
(1000))) {
Settings::getInstance()->setInt(
"ScreensaverSwapImageTimeout",
static_cast<int>(std::round(screensaver_swap_image_timeout->getValue()) * (1000)));
s->setNeedsSaving();
}
});
// Stretch images to screen resolution.
auto screensaver_stretch_images = std::make_shared<SwitchComponent>(mWindow);
screensaver_stretch_images->
setState(Settings::getInstance()->getBool("ScreensaverStretchImages"));
screensaver_stretch_images->setState(
Settings::getInstance()->getBool("ScreensaverStretchImages"));
s->addWithLabel("STRETCH IMAGES TO SCREEN RESOLUTION", screensaver_stretch_images);
s->addSaveFunc([screensaver_stretch_images, s] {
if (screensaver_stretch_images->getState() !=
Settings::getInstance()->getBool("ScreensaverStretchImages")) {
Settings::getInstance()->getBool("ScreensaverStretchImages")) {
Settings::getInstance()->setBool("ScreensaverStretchImages",
screensaver_stretch_images->getState());
screensaver_stretch_images->getState());
s->setNeedsSaving();
}
});
// Show game info overlay for slideshow screensaver.
auto screensaver_slideshow_game_info = std::make_shared<SwitchComponent>(mWindow);
screensaver_slideshow_game_info->
setState(Settings::getInstance()->getBool("ScreensaverSlideshowGameInfo"));
screensaver_slideshow_game_info->setState(
Settings::getInstance()->getBool("ScreensaverSlideshowGameInfo"));
s->addWithLabel("DISPLAY GAME INFO OVERLAY", screensaver_slideshow_game_info);
s->addSaveFunc([screensaver_slideshow_game_info, s] {
if (screensaver_slideshow_game_info->getState() !=
Settings::getInstance()->getBool("ScreensaverSlideshowGameInfo")) {
Settings::getInstance()->getBool("ScreensaverSlideshowGameInfo")) {
Settings::getInstance()->setBool("ScreensaverSlideshowGameInfo",
screensaver_slideshow_game_info->getState());
screensaver_slideshow_game_info->getState());
s->setNeedsSaving();
}
});
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
// Render scanlines using a shader.
auto screensaver_slideshow_scanlines = std::make_shared<SwitchComponent>(mWindow);
screensaver_slideshow_scanlines->
setState(Settings::getInstance()->getBool("ScreensaverSlideshowScanlines"));
screensaver_slideshow_scanlines->setState(
Settings::getInstance()->getBool("ScreensaverSlideshowScanlines"));
s->addWithLabel("RENDER SCANLINES", screensaver_slideshow_scanlines);
s->addSaveFunc([screensaver_slideshow_scanlines, s] {
if (screensaver_slideshow_scanlines->getState() !=
Settings::getInstance()->getBool("ScreensaverSlideshowScanlines")) {
Settings::getInstance()->getBool("ScreensaverSlideshowScanlines")) {
Settings::getInstance()->setBool("ScreensaverSlideshowScanlines",
screensaver_slideshow_scanlines->getState());
screensaver_slideshow_scanlines->getState());
s->setNeedsSaving();
}
});
#endif
#endif
// Whether to use custom images.
auto screensaver_slideshow_custom_images = std::make_shared<SwitchComponent>(mWindow);
screensaver_slideshow_custom_images->setState(Settings::getInstance()->
getBool("ScreensaverSlideshowCustomImages"));
screensaver_slideshow_custom_images->setState(
Settings::getInstance()->getBool("ScreensaverSlideshowCustomImages"));
s->addWithLabel("USE CUSTOM IMAGES", screensaver_slideshow_custom_images);
s->addSaveFunc([screensaver_slideshow_custom_images, s] {
if (screensaver_slideshow_custom_images->getState() !=
Settings::getInstance()->getBool("ScreensaverSlideshowCustomImages")) {
Settings::getInstance()->getBool("ScreensaverSlideshowCustomImages")) {
Settings::getInstance()->setBool("ScreensaverSlideshowCustomImages",
screensaver_slideshow_custom_images->getState());
screensaver_slideshow_custom_images->getState());
s->setNeedsSaving();
}
});
// Whether to recurse the custom image directory.
auto screensaver_slideshow_recurse = std::make_shared<SwitchComponent>(mWindow);
screensaver_slideshow_recurse->setState(Settings::getInstance()->
getBool("ScreensaverSlideshowRecurse"));
screensaver_slideshow_recurse->setState(
Settings::getInstance()->getBool("ScreensaverSlideshowRecurse"));
s->addWithLabel("CUSTOM IMAGE DIRECTORY RECURSIVE SEARCH", screensaver_slideshow_recurse);
s->addSaveFunc([screensaver_slideshow_recurse, s] {
if (screensaver_slideshow_recurse->getState() !=
Settings::getInstance()->getBool("ScreensaverSlideshowRecurse")) {
Settings::getInstance()->getBool("ScreensaverSlideshowRecurse")) {
Settings::getInstance()->setBool("ScreensaverSlideshowRecurse",
screensaver_slideshow_recurse->getState());
screensaver_slideshow_recurse->getState());
s->setNeedsSaving();
}
});
// Custom image directory.
auto screensaver_slideshow_image_dir = std::make_shared<TextComponent>(mWindow, "",
Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_RIGHT);
s->addEditableTextComponent("CUSTOM IMAGE DIRECTORY", screensaver_slideshow_image_dir,
Settings::getInstance()->getString("ScreensaverSlideshowImageDir"),
Settings::getInstance()->getDefaultString("ScreensaverSlideshowImageDir"));
auto screensaver_slideshow_image_dir = std::make_shared<TextComponent>(
mWindow, "", Font::get(FONT_SIZE_SMALL), 0x777777FF, ALIGN_RIGHT);
s->addEditableTextComponent(
"CUSTOM IMAGE DIRECTORY", screensaver_slideshow_image_dir,
Settings::getInstance()->getString("ScreensaverSlideshowImageDir"),
Settings::getInstance()->getDefaultString("ScreensaverSlideshowImageDir"));
s->addSaveFunc([screensaver_slideshow_image_dir, s] {
if (screensaver_slideshow_image_dir->getValue() !=
Settings::getInstance()->getString("ScreensaverSlideshowImageDir")) {
Settings::getInstance()->getString("ScreensaverSlideshowImageDir")) {
Settings::getInstance()->setString("ScreensaverSlideshowImageDir",
screensaver_slideshow_image_dir->getValue());
screensaver_slideshow_image_dir->getValue());
s->setNeedsSaving();
}
});
@ -210,75 +214,60 @@ void GuiScreensaverOptions::openVideoScreensaverOptions()
// Timer for swapping videos (in seconds).
auto screensaver_swap_video_timeout =
std::make_shared<SliderComponent>(mWindow, 0.f, 120.f, 2.f, "s");
screensaver_swap_video_timeout->setValue(static_cast<float>(Settings::getInstance()->
getInt("ScreensaverSwapVideoTimeout") / (1000)));
std::make_shared<SliderComponent>(mWindow, 0.0f, 120.0f, 2.0f, "s");
screensaver_swap_video_timeout->setValue(static_cast<float>(
Settings::getInstance()->getInt("ScreensaverSwapVideoTimeout") / (1000)));
s->addWithLabel("SWAP VIDEOS AFTER (SECONDS)", screensaver_swap_video_timeout);
s->addSaveFunc([screensaver_swap_video_timeout, s] {
if (screensaver_swap_video_timeout->getValue() !=
static_cast<float>(Settings::getInstance()->
getInt("ScreensaverSwapVideoTimeout") / (1000))) {
Settings::getInstance()->setInt("ScreensaverSwapVideoTimeout",
static_cast<int>(std::round(screensaver_swap_video_timeout->getValue()) *
(1000)));
static_cast<float>(Settings::getInstance()->getInt("ScreensaverSwapVideoTimeout") /
(1000))) {
Settings::getInstance()->setInt(
"ScreensaverSwapVideoTimeout",
static_cast<int>(std::round(screensaver_swap_video_timeout->getValue()) * (1000)));
s->setNeedsSaving();
}
});
// Stretch videos to screen resolution.
auto screensaver_stretch_videos = std::make_shared<SwitchComponent>(mWindow);
screensaver_stretch_videos->
setState(Settings::getInstance()->getBool("ScreensaverStretchVideos"));
screensaver_stretch_videos->setState(
Settings::getInstance()->getBool("ScreensaverStretchVideos"));
s->addWithLabel("STRETCH VIDEOS TO SCREEN RESOLUTION", screensaver_stretch_videos);
s->addSaveFunc([screensaver_stretch_videos, s] {
if (screensaver_stretch_videos->getState() !=
Settings::getInstance()->getBool("ScreensaverStretchVideos")) {
Settings::getInstance()->getBool("ScreensaverStretchVideos")) {
Settings::getInstance()->setBool("ScreensaverStretchVideos",
screensaver_stretch_videos->getState());
screensaver_stretch_videos->getState());
s->setNeedsSaving();
}
});
// Show game info overlay for video screensaver.
auto screensaver_video_game_info = std::make_shared<SwitchComponent>(mWindow);
screensaver_video_game_info->
setState(Settings::getInstance()->getBool("ScreensaverVideoGameInfo"));
screensaver_video_game_info->setState(
Settings::getInstance()->getBool("ScreensaverVideoGameInfo"));
s->addWithLabel("DISPLAY GAME INFO OVERLAY", screensaver_video_game_info);
s->addSaveFunc([screensaver_video_game_info, s] {
if (screensaver_video_game_info->getState() !=
Settings::getInstance()->getBool("ScreensaverVideoGameInfo")) {
Settings::getInstance()->getBool("ScreensaverVideoGameInfo")) {
Settings::getInstance()->setBool("ScreensaverVideoGameInfo",
screensaver_video_game_info->getState());
screensaver_video_game_info->getState());
s->setNeedsSaving();
}
});
#if defined(_RPI_)
// Use OMX player for screensaver.
auto screensaver_omx_player = std::make_shared<SwitchComponent>(mWindow);
screensaver_omx_player->setState(Settings::getInstance()->getBool("ScreensaverOmxPlayer"));
s->addWithLabel("USE OMX PLAYER FOR SCREENSAVER", screensaver_omx_player);
s->addSaveFunc([screensaver_omx_player, s] {
if (screensaver_omx_player->getState() !=
Settings::getInstance()->getBool("ScreensaverOmxPlayer")) {
Settings::getInstance()->
setBool("ScreensaverOmxPlayer", screensaver_omx_player->getState());
s->setNeedsSaving();
}
});
#endif
#if defined(USE_OPENGL_21)
#if defined(USE_OPENGL_21)
// Render scanlines using a shader.
auto screensaver_video_scanlines = std::make_shared<SwitchComponent>(mWindow);
screensaver_video_scanlines->
setState(Settings::getInstance()->getBool("ScreensaverVideoScanlines"));
screensaver_video_scanlines->setState(
Settings::getInstance()->getBool("ScreensaverVideoScanlines"));
s->addWithLabel("RENDER SCANLINES", screensaver_video_scanlines);
s->addSaveFunc([screensaver_video_scanlines, s] {
if (screensaver_video_scanlines->getState() !=
Settings::getInstance()->getBool("ScreensaverVideoScanlines")) {
Settings::getInstance()->getBool("ScreensaverVideoScanlines")) {
Settings::getInstance()->setBool("ScreensaverVideoScanlines",
screensaver_video_scanlines->getState());
screensaver_video_scanlines->getState());
s->setNeedsSaving();
}
});
@ -289,13 +278,13 @@ void GuiScreensaverOptions::openVideoScreensaverOptions()
s->addWithLabel("RENDER BLUR", screensaver_video_blur);
s->addSaveFunc([screensaver_video_blur, s] {
if (screensaver_video_blur->getState() !=
Settings::getInstance()->getBool("ScreensaverVideoBlur")) {
Settings::getInstance()->getBool("ScreensaverVideoBlur")) {
Settings::getInstance()->setBool("ScreensaverVideoBlur",
screensaver_video_blur->getState());
screensaver_video_blur->getState());
s->setNeedsSaving();
}
});
#endif
#endif
mWindow->pushGui(s);
}

92
es-app/src/guis/GuiSettings.cpp
View file

@ -10,33 +10,31 @@
#include "guis/GuiSettings.h"
#include "components/HelpComponent.h"
#include "guis/GuiTextEditPopup.h"
#include "views/gamelist/IGameListView.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "FileFilterIndex.h"
#include "Settings.h"
#include "SystemData.h"
#include "Window.h"
#include "components/HelpComponent.h"
#include "guis/GuiTextEditPopup.h"
#include "views/ViewController.h"
#include "views/gamelist/IGameListView.h"
GuiSettings::GuiSettings(
Window* window,
std::string title)
: GuiComponent(window),
mMenu(window, title),
mNeedsSaving(false),
mNeedsReloadHelpPrompts(false),
mNeedsCollectionsUpdate(false),
mNeedsSorting(false),
mNeedsSortingCollections(false),
mNeedsResetFilters(false),
mNeedsReloading(false),
mNeedsGoToStart(false),
mNeedsGoToSystem(false),
mNeedsGoToGroupedCollections(false),
mInvalidateCachedBackground(false),
mGoToSystem(nullptr)
GuiSettings::GuiSettings(Window* window, std::string title)
: GuiComponent(window)
, mMenu(window, title)
, mNeedsSaving(false)
, mNeedsReloadHelpPrompts(false)
, mNeedsCollectionsUpdate(false)
, mNeedsSorting(false)
, mNeedsSortingCollections(false)
, mNeedsResetFilters(false)
, mNeedsReloading(false)
, mNeedsGoToStart(false)
, mNeedsGoToSystem(false)
, mNeedsGoToGroupedCollections(false)
, mInvalidateCachedBackground(false)
, mGoToSystem(nullptr)
{
addChild(&mMenu);
mMenu.addButton("BACK", "back", [this] { delete this; });
@ -44,11 +42,12 @@ GuiSettings::GuiSettings(
setSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
mMenu.setPosition((mSize.x() - mMenu.getSize().x()) / 2.0f,
Renderer::getScreenHeight() * 0.13f);
Renderer::getScreenHeight() * 0.13f);
}
GuiSettings::~GuiSettings()
{
// Save on exit.
save();
}
@ -72,11 +71,11 @@ void GuiSettings::save()
}
if (mNeedsSorting) {
for (auto it = SystemData::sSystemVector.cbegin(); it !=
SystemData::sSystemVector.cend(); it++) {
if (!(!mNeedsSortingCollections && (*it)->isCollection())) {
for (auto it = SystemData::sSystemVector.cbegin(); it != SystemData::sSystemVector.cend();
it++) {
if (!(!mNeedsSortingCollections && (*it)->isCollection()))
(*it)->sortSystem(true);
}
// Jump to the first row of the gamelist.
IGameListView* gameList = ViewController::get()->getGameListView((*it)).get();
gameList->setCursor(gameList->getFirstEntry());
@ -84,11 +83,10 @@ void GuiSettings::save()
}
if (mNeedsResetFilters) {
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
if ((*it)->getThemeFolder() == "custom-collections") {
for (FileData* customSystem :
(*it)->getRootFolder()->getChildrenListToDisplay())
for (FileData* customSystem : (*it)->getRootFolder()->getChildrenListToDisplay())
customSystem->getSystem()->getIndex()->resetFilters();
}
(*it)->getIndex()->resetFilters();
@ -125,7 +123,7 @@ void GuiSettings::save()
// these views can behave a bit strange during collection changes so it's better to be on
// the safe side.
if (state.getSystem()->isCollection() &&
state.getSystem()->getThemeFolder() != "custom-collections") {
state.getSystem()->getThemeFolder() != "custom-collections") {
ViewController::get()->goToStart();
ViewController::get()->goToSystem(SystemData::sSystemVector.front(), false);
// We don't want to invalidate the cached background when there has been a collection
@ -135,7 +133,7 @@ void GuiSettings::save()
// If the last displayed custom collection was just disabled, then go to start (to the
// system view).
if (std::find(SystemData::sSystemVector.begin(), SystemData::sSystemVector.end(),
state.getSystem()) == SystemData::sSystemVector.end()) {
state.getSystem()) == SystemData::sSystemVector.end()) {
ViewController::get()->goToStart();
return;
}
@ -152,18 +150,17 @@ void GuiSettings::save()
}
}
void GuiSettings::addEditableTextComponent(
const std::string label,
std::shared_ptr<GuiComponent> ed,
std::string value,
std::string defaultValue,
bool isPassword)
void GuiSettings::addEditableTextComponent(const std::string label,
std::shared_ptr<GuiComponent> ed,
std::string value,
std::string defaultValue,
bool isPassword)
{
ComponentListRow row;
row.elements.clear();
auto lbl = std::make_shared<TextComponent>(mWindow, Utils::String::toUpper(label),
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
Font::get(FONT_SIZE_MEDIUM), 0x777777FF);
row.addElement(lbl, true);
row.addElement(ed, true);
@ -200,11 +197,11 @@ void GuiSettings::addEditableTextComponent(
row.makeAcceptInputHandler([this, label, ed, updateVal, isPassword] {
// Never display the value if it's a password, instead set it to blank.
if (isPassword)
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), label,
"", updateVal, false));
mWindow->pushGui(
new GuiTextEditPopup(mWindow, getHelpStyle(), label, "", updateVal, false));
else
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), label,
ed->getValue(), updateVal, false));
mWindow->pushGui(new GuiTextEditPopup(mWindow, getHelpStyle(), label, ed->getValue(),
updateVal, false));
});
assert(ed);
addRow(row);
@ -219,15 +216,6 @@ bool GuiSettings::input(InputConfig* config, Input input)
return true;
}
// Keep code for potential future use.
// if (config->isMappedTo("start", input) && input.value != 0) {
// // Close everything.
// Window* window = mWindow;
// while (window->peekGui() && window->peekGui() != ViewController::get())
// delete window->peekGui();
// return true;
// }
return GuiComponent::input(config, input);
}

50
es-app/src/guis/GuiSettings.h
View file

@ -11,8 +11,8 @@
#ifndef ES_APP_GUIS_GUI_SETTINGS_H
#define ES_APP_GUIS_GUI_SETTINGS_H
#include "components/MenuComponent.h"
#include "SystemData.h"
#include "components/MenuComponent.h"
// This is just a really simple template for a GUI that calls some save functions when closed.
class GuiSettings : public GuiComponent
@ -22,29 +22,33 @@ public:
virtual ~GuiSettings();
void save();
inline void addRow(const ComponentListRow& row) { mMenu.addRow(row); };
inline void addWithLabel(const std::string& label,
const std::shared_ptr<GuiComponent>& comp) { mMenu.addWithLabel(label, comp); };
void addEditableTextComponent(
const std::string label,
std::shared_ptr<GuiComponent> ed,
std::string value,
std::string defaultValue = "",
bool isPassword = false);
inline void addSaveFunc(const std::function<void()>& func) { mSaveFuncs.push_back(func); };
void addRow(const ComponentListRow& row) { mMenu.addRow(row); }
void addWithLabel(const std::string& label, const std::shared_ptr<GuiComponent>& comp)
{
mMenu.addWithLabel(label, comp);
}
void addEditableTextComponent(const std::string label,
std::shared_ptr<GuiComponent> ed,
std::string value,
std::string defaultValue = "",
bool isPassword = false);
void addSaveFunc(const std::function<void()>& func) { mSaveFuncs.push_back(func); }
void setNeedsSaving(bool state = true) { mNeedsSaving = state; };
void setNeedsReloadHelpPrompts() { mNeedsReloadHelpPrompts = true; };
void setNeedsCollectionsUpdate() { mNeedsCollectionsUpdate = true; };
void setNeedsSorting() { mNeedsSorting = true; };
void setNeedsSortingCollections() { mNeedsSortingCollections = true; };
void setNeedsSaving(bool state = true) { mNeedsSaving = state; }
void setNeedsReloadHelpPrompts() { mNeedsReloadHelpPrompts = true; }
void setNeedsCollectionsUpdate() { mNeedsCollectionsUpdate = true; }
void setNeedsSorting() { mNeedsSorting = true; }
void setNeedsSortingCollections() { mNeedsSortingCollections = true; }
void setNeedsResetFilters() { mNeedsResetFilters = true; }
void setNeedsReloading() { mNeedsReloading = true; };
void setNeedsGoToStart() { mNeedsGoToStart = true; };
void setNeedsReloading() { mNeedsReloading = true; }
void setNeedsGoToStart() { mNeedsGoToStart = true; }
void setNeedsGoToSystem(SystemData* goToSystem)
{ mNeedsGoToSystem = true; mGoToSystem = goToSystem; };
void setNeedsGoToGroupedCollections() { mNeedsGoToGroupedCollections = true; };
void setInvalidateCachedBackground() { mInvalidateCachedBackground = true; };
{
mNeedsGoToSystem = true;
mGoToSystem = goToSystem;
};
void setNeedsGoToGroupedCollections() { mNeedsGoToGroupedCollections = true; }
void setInvalidateCachedBackground() { mInvalidateCachedBackground = true; }
bool input(InputConfig* config, Input input) override;
std::vector<HelpPrompt> getHelpPrompts() override;
@ -53,6 +57,8 @@ public:
private:
MenuComponent mMenu;
std::vector<std::function<void()>> mSaveFuncs;
SystemData* mGoToSystem;
bool mNeedsSaving;
bool mNeedsReloadHelpPrompts;
bool mNeedsCollectionsUpdate;
@ -64,8 +70,6 @@ private:
bool mNeedsGoToSystem;
bool mNeedsGoToGroupedCollections;
bool mInvalidateCachedBackground;
SystemData* mGoToSystem;
};
#endif // ES_APP_GUIS_GUI_SETTINGS_H

172
es-app/src/main.cpp
View file

@ -1,15 +1,14 @@
// SPDX-License-Identifier: MIT
//
// EmulationStation Desktop Edition, an emulator front-end
// with controller navigation and theming support.
// EmulationStation Desktop Edition (ES-DE) is a front-end for browsing
// and launching games from your multi-platform game collection.
//
// Originally created by Alec "Aloshi" Lofquist.
// http://www.aloshi.com
// Originally created by Alec Lofquist.
// Improved and extended by the RetroPie community.
// Desktop Edition fork by Leon Styhre.
//
// The line length limit is 100 characters and the indentations are 4 spaces.
// Line breaks are Unix-style (line feed only).
// The column limit is 100 characters.
// All ES-DE C++ source code is formatted using clang-format.
//
// main.cpp
//
@ -18,13 +17,6 @@
// environment and starts listening to SDL events.
//
#include "guis/GuiDetectDevice.h"
#include "guis/GuiMsgBox.h"
#include "guis/GuiComplexTextEditPopup.h"
#include "guis/GuiLaunchScreen.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include "AudioManager.h"
#include "CollectionSystemsManager.h"
#include "EmulationStation.h"
@ -37,6 +29,13 @@
#include "Sound.h"
#include "SystemData.h"
#include "SystemScreensaver.h"
#include "guis/GuiComplexTextEditPopup.h"
#include "guis/GuiDetectDevice.h"
#include "guis/GuiLaunchScreen.h"
#include "guis/GuiMsgBox.h"
#include "utils/FileSystemUtil.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include <SDL2/SDL_events.h>
#include <SDL2/SDL_main.h>
@ -56,14 +55,14 @@ bool forceInputConfig = false;
bool settingsNeedSaving = false;
enum loadSystemsReturnCode {
LOADING_OK,
LOADING_OK, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
INVALID_FILE,
NO_ROMS
};
#if defined(_WIN64)
enum win64ConsoleType {
NO_CONSOLE,
NO_CONSOLE, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
PARENT_CONSOLE,
ALLOCATED_CONSOLE
};
@ -85,7 +84,7 @@ win64ConsoleType outputToConsole(bool allocConsole)
// Try to attach to a parent console process.
if (AttachConsole(ATTACH_PARENT_PROCESS))
outputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
outputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
// If there is a parent console process, then attempt to retrieve its handle.
if (outputHandle != INVALID_HANDLE_VALUE && outputHandle != nullptr) {
@ -131,11 +130,11 @@ bool parseArgs(int argc, char* argv[])
{
Utils::FileSystem::setExePath(argv[0]);
#if defined(_WIN64)
#if defined(_WIN64)
// Print any command line output to the console.
if (argc > 1)
win64ConsoleType consoleType = outputToConsole(false);
#endif
#endif
std::string portableFilePath = Utils::FileSystem::getExePath() + "/portable.txt";
@ -145,11 +144,11 @@ bool parseArgs(int argc, char* argv[])
std::cout << "Found portable.txt in the ES-DE executable directory\n";
std::ifstream portableFile;
std::string homePath;
#if defined(_WIN64)
#if defined(_WIN64)
portableFile.open(Utils::String::stringToWideString(portableFilePath).c_str());
#else
#else
portableFile.open(portableFilePath.c_str());
#endif
#endif
if (!portableFile.fail()) {
std::string relativePath;
getline(portableFile, relativePath);
@ -159,9 +158,9 @@ bool parseArgs(int argc, char* argv[])
else
homePath = Utils::FileSystem::getExePath() + "/" + relativePath;
#if defined(_WIN64)
#if defined(_WIN64)
homePath = Utils::String::replace(homePath, "/", "\\");
#endif
#endif
if (!Utils::FileSystem::exists(homePath)) {
std::cerr << "Error: Defined home path \"" << homePath << "\" does not exist\n";
@ -185,18 +184,18 @@ bool parseArgs(int argc, char* argv[])
std::cerr << "Error: No home path supplied with \'--home'\n";
return false;
}
#if defined(_WIN64)
#if defined(_WIN64)
if (!Utils::FileSystem::exists(argv[i + 1]) &&
(!Utils::FileSystem::driveExists(argv[i + 1]))) {
#else
(!Utils::FileSystem::driveExists(argv[i + 1]))) {
#else
if (!Utils::FileSystem::exists(argv[i + 1])) {
#endif
#endif
std::cerr << "Error: Home path \'" << argv[i + 1] << "\' does not exist\n";
return false;
}
if (Utils::FileSystem::isRegularFile(argv[i + 1])) {
std::cerr << "Error: Home path \'" << argv[i + 1] <<
"\' is a file and not a directory\n";
std::cerr << "Error: Home path \'" << argv[i + 1]
<< "\' is a file and not a directory\n";
return false;
}
Utils::FileSystem::setHomePath(argv[i + 1]);
@ -228,16 +227,16 @@ bool parseArgs(int argc, char* argv[])
std::string widthArg = argv[i + 1];
std::string heightArg = argv[i + 2];
if (widthArg.find_first_not_of("0123456789") != std::string::npos ||
heightArg.find_first_not_of("0123456789") != std::string::npos) {
heightArg.find_first_not_of("0123456789") != std::string::npos) {
std::cerr << "Error: Invalid resolution values supplied.\n";
return false;
}
int width = atoi(argv[i + 1]);
int height = atoi(argv[i + 2]);
if (width < 640 || height < 480 || width > 7680 || height > 4320 ||
height < width / 4 || width < height / 2) {
std::cerr << "Error: Unsupported resolution "
<< width << "x" << height << " supplied.\n";
height < width / 4 || width < height / 2) {
std::cerr << "Error: Unsupported resolution " << width << "x" << height
<< " supplied.\n";
return false;
}
Settings::getInstance()->setInt("WindowWidth", width);
@ -277,7 +276,8 @@ bool parseArgs(int argc, char* argv[])
}
// On Unix, enable settings for the fullscreen mode.
// On macOS and Windows only windowed mode is supported.
#if defined(__unix__)
#if defined(__unix__)
else if (strcmp(argv[i], "--windowed") == 0) {
Settings::getInstance()->setBool("Windowed", true);
}
@ -289,7 +289,7 @@ bool parseArgs(int argc, char* argv[])
Settings::getInstance()->setString("FullscreenMode", "borderless");
settingsNeedSaving = true;
}
#endif
#endif
else if (strcmp(argv[i], "--vsync") == 0) {
if (i >= argc - 1) {
std::cerr << "Error: No VSync value supplied.\n";
@ -297,7 +297,7 @@ bool parseArgs(int argc, char* argv[])
}
std::string vSyncValue = argv[i + 1];
if (vSyncValue != "on" && vSyncValue != "off" && vSyncValue != "1" &&
vSyncValue != "0") {
vSyncValue != "0") {
std::cerr << "Error: Invalid VSync value supplied.\n";
return false;
}
@ -350,12 +350,12 @@ bool parseArgs(int argc, char* argv[])
Log::setReportingLevel(LogDebug);
}
else if (strcmp(argv[i], "--version") == 0 || strcmp(argv[i], "-v") == 0) {
std::cout <<
"EmulationStation Desktop Edition v" << PROGRAM_VERSION_STRING << "\n";
std::cout << "EmulationStation Desktop Edition v" << PROGRAM_VERSION_STRING << "\n";
return false;
}
else if (strcmp(argv[i], "--help") == 0 || strcmp(argv[i], "-h") == 0) {
std::cout <<
// clang-format off
"Usage: emulationstation [options]\n"
"EmulationStation Desktop Edition, Emulator Front-end\n\n"
"Options:\n"
@ -381,6 +381,7 @@ bool parseArgs(int argc, char* argv[])
" --debug Print debug information\n"
" --version, -v Display version information\n"
" --help, -h Summon a sentient, angry tuba\n";
// clang-format on
return false; // Exit after printing help.
}
else {
@ -400,13 +401,13 @@ bool checkApplicationHomeDirectory()
std::string home = Utils::FileSystem::getHomePath();
std::string applicationHome = home + "/.emulationstation";
if (!Utils::FileSystem::exists(applicationHome)) {
#if defined(_WIN64)
std::cout << "First startup, creating application home directory \"" <<
Utils::String::replace(applicationHome, "/", "\\") << "\"\n";
#else
std::cout << "First startup, creating application home directory \"" <<
applicationHome << "\"\n";
#endif
#if defined(_WIN64)
std::cout << "First startup, creating application home directory \""
<< Utils::String::replace(applicationHome, "/", "\\") << "\"\n";
#else
std::cout << "First startup, creating application home directory \"" << applicationHome
<< "\"\n";
#endif
Utils::FileSystem::createDirectory(applicationHome);
if (!Utils::FileSystem::exists(applicationHome)) {
std::cerr << "Fatal error: Couldn't create directory, permission problems?\n";
@ -424,16 +425,16 @@ loadSystemsReturnCode loadSystemConfigFile()
if (SystemData::sSystemVector.size() == 0) {
LOG(LogError) << "No game files were found, make sure that the system directories are "
"setup correctly and that the file extensions are supported";
"setup correctly and that the file extensions are supported";
return NO_ROMS;
}
return LOADING_OK;
}
// Called on exit, assuming we get far enough to have the log initialized.
void onExit()
{
// Called on exit, assuming we get far enough to have the log initialized.
Log::close();
}
@ -443,12 +444,12 @@ int main(int argc, char* argv[])
std::locale::global(std::locale("C"));
#if defined(__APPLE__)
#if defined(__APPLE__)
// This is a workaround to disable the incredibly annoying save state functionality in
// macOS which forces a restore of the previous window state. The problem is that this
// removes the splash screen on startup and it may have other adverse effects as well.
std::string saveStateDir = Utils::FileSystem::expandHomePath(
"~/Library/Saved Application State/org.es-de.EmulationStation.savedState");
"~/Library/Saved Application State/org.es-de.EmulationStation.savedState");
// Deletion of the state files should normally not be required as there shouldn't be any
// files to begin with. But maybe the files can still be created for unknown reasons
// as macOS really really loves to restore windows. Let's therefore include this deletion
@ -465,22 +466,22 @@ int main(int argc, char* argv[])
// the functionality.
std::string chmodCommand = "chmod 500 \"" + saveStateDir + "\"";
system(chmodCommand.c_str());
#endif
#endif
if (!parseArgs(argc, argv)) {
#if defined(_WIN64)
#if defined(_WIN64)
FreeConsole();
#endif
#endif
return 0;
}
#if defined(_WIN64)
#if defined(_WIN64)
// Send debug output to the console..
if (Settings::getInstance()->getBool("Debug"))
outputToConsole(true);
#endif
#endif
#if defined(_WIN64)
#if defined(_WIN64)
// Hide taskbar if the setting for this is enabled.
bool taskbarStateChanged = false;
unsigned int taskbarState;
@ -490,12 +491,12 @@ int main(int argc, char* argv[])
taskbarState = getTaskbarState();
hideTaskbar();
}
#endif
#endif
#if defined(FREEIMAGE_LIB)
// Call this ONLY when linking with FreeImage as a static library.
#if defined(FREEIMAGE_LIB)
FreeImage_Initialise();
#endif
#endif
// If ~/.emulationstation doesn't exist and cannot be created, bail.
if (!checkApplicationHomeDirectory())
@ -504,8 +505,8 @@ int main(int argc, char* argv[])
// Start the logger.
Log::init();
Log::open();
LOG(LogInfo) << "EmulationStation Desktop Edition v" << PROGRAM_VERSION_STRING <<
", built " << PROGRAM_BUILT_STRING;
LOG(LogInfo) << "EmulationStation Desktop Edition v" << PROGRAM_VERSION_STRING << ", built "
<< PROGRAM_BUILT_STRING;
// Always close the log on exit.
atexit(&onExit);
@ -513,7 +514,7 @@ int main(int argc, char* argv[])
// Check if the configuration file exists, and if not, create it.
// This should only happen on first application startup.
if (!Utils::FileSystem::exists(Utils::FileSystem::getHomePath() +
"/.emulationstation/es_settings.xml")) {
"/.emulationstation/es_settings.xml")) {
LOG(LogInfo) << "Settings file es_settings.xml does not exist, creating it...";
Settings::getInstance()->saveFile();
}
@ -525,15 +526,15 @@ int main(int argc, char* argv[])
// Check if the application version has changed, which would normally mean that the
// user has upgraded to a newer release.
std::string applicationVersion;
if ((applicationVersion = Settings::getInstance()->
getString("ApplicationVersion")) != PROGRAM_VERSION_STRING) {
if ((applicationVersion = Settings::getInstance()->getString("ApplicationVersion")) !=
PROGRAM_VERSION_STRING) {
if (applicationVersion != "") {
LOG(LogInfo) << "Application version changed from previous startup, from \"" <<
applicationVersion << "\" to \"" << PROGRAM_VERSION_STRING << "\"";
LOG(LogInfo) << "Application version changed from previous startup, from \""
<< applicationVersion << "\" to \"" << PROGRAM_VERSION_STRING << "\"";
}
else {
LOG(LogInfo) << "Application version setting is blank, changing it to \"" <<
PROGRAM_VERSION_STRING << "\"";
LOG(LogInfo) << "Application version setting is blank, changing it to \""
<< PROGRAM_VERSION_STRING << "\"";
}
Settings::getInstance()->setString("ApplicationVersion", PROGRAM_VERSION_STRING);
Settings::getInstance()->saveFile();
@ -582,11 +583,11 @@ int main(int argc, char* argv[])
if (event.type == SDL_QUIT)
return 1;
#if !defined(__APPLE__)
// This hides the mouse cursor during startup, i.e. before we have begun to capture SDL events.
// On macOS this causes the mouse cursor to jump back to the Dock so don't do it on this OS.
#if !defined(__APPLE__)
SDL_SetRelativeMouseMode(SDL_TRUE);
#endif
#endif
if (splashScreen) {
std::string progressText = "Loading...";
@ -625,8 +626,8 @@ int main(int argc, char* argv[])
// Open the input configuration GUI if the flag to force this was passed from the command line.
if (!loadSystemsStatus) {
if (forceInputConfig) {
window.pushGui(new GuiDetectDevice(&window, false, true, [] {
ViewController::get()->goToStart(); }));
window.pushGui(new GuiDetectDevice(&window, false, true,
[] { ViewController::get()->goToStart(); }));
}
else {
ViewController::get()->goToStart();
@ -639,16 +640,19 @@ int main(int argc, char* argv[])
int lastTime = SDL_GetTicks();
const auto applicationEndTime = std::chrono::system_clock::now();
LOG(LogInfo) << "Application startup time: " <<
std::chrono::duration_cast<std::chrono::milliseconds>
(applicationEndTime - applicationStartTime).count() << " ms";
LOG(LogInfo) << "Application startup time: "
<< std::chrono::duration_cast<std::chrono::milliseconds>(applicationEndTime -
applicationStartTime)
.count()
<< " ms";
bool running = true;
#if !defined(__APPLE__)
// Now that we've finished loading, disable the relative mouse mode or otherwise mouse
// input wouldn't work in any games that are launched.
#if !defined(__APPLE__)
SDL_SetRelativeMouseMode(SDL_FALSE);
#endif
#endif
while (running) {
if (SDL_PollEvent(&event)) {
@ -657,8 +661,8 @@ int main(int argc, char* argv[])
if (event.type == SDL_QUIT)
running = false;
}
while (SDL_PollEvent(&event));
} while (SDL_PollEvent(&event));
}
if (window.isSleeping()) {
@ -694,24 +698,24 @@ int main(int argc, char* argv[])
NavigationSounds::getInstance()->deinit();
Settings::deinit();
#if defined(FREEIMAGE_LIB)
// Call this ONLY when linking with FreeImage as a static library.
#if defined(FREEIMAGE_LIB)
FreeImage_DeInitialise();
#endif
#endif
#if defined(_WIN64)
#if defined(_WIN64)
// If the taskbar state was changed (taskbar was hidden), then revert it.
if (taskbarStateChanged)
revertTaskbarState(taskbarState);
#endif
#endif
processQuitMode();
LOG(LogInfo) << "EmulationStation cleanly shutting down";
#if defined(_WIN64)
#if defined(_WIN64)
FreeConsole();
#endif
#endif
return 0;
}

331
es-app/src/scrapers/GamesDBJSONScraper.cpp
View file

@ -10,20 +10,20 @@
#include "scrapers/GamesDBJSONScraper.h"
#include "scrapers/GamesDBJSONScraperResources.h"
#include "utils/StringUtil.h"
#include "utils/TimeUtil.h"
#include "FileData.h"
#include "Log.h"
#include "MameNames.h"
#include "PlatformId.h"
#include "Settings.h"
#include "SystemData.h"
#include "utils/StringUtil.h"
#include "utils/TimeUtil.h"
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <exception>
#include <map>
#include <pugixml.hpp>
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
using namespace PlatformIds;
using namespace rapidjson;
@ -103,10 +103,10 @@ const std::map<PlatformId, std::string> gamesdb_new_platformid_map {
{ SONY_PLAYSTATION_PORTABLE, "13" },
{ SUPER_NINTENDO, "6" },
{ SHARP_X1, "4977" },
{ SHARP_X68000, "4931"},
{ SHARP_X68000, "4931" },
{ NEC_SUPERGRAFX, "34" },
{ NEC_PC_8800, "4933"},
{ NEC_PC_9800, "4934"},
{ NEC_PC_8800, "4933" },
{ NEC_PC_9800, "4934" },
{ NEC_PC_ENGINE, "34" },
{ NEC_PC_ENGINE_CD, "4955" },
{ BANDAI_WONDERSWAN, "4925" },
@ -118,9 +118,10 @@ const std::map<PlatformId, std::string> gamesdb_new_platformid_map {
{ TANDY_TRS80, "4941" },
};
void thegamesdb_generate_json_scraper_requests(const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results)
void thegamesdb_generate_json_scraper_requests(
const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results)
{
resources.prepare();
std::string path = "https://api.thegamesdb.net/v1";
@ -168,8 +169,8 @@ void thegamesdb_generate_json_scraper_requests(const ScraperSearchParams& params
if (!platforms.empty()) {
bool first = true;
platformQueryParam += "&filter%5Bplatform%5D=";
for (auto platformIt = platforms.cbegin();
platformIt != platforms.cend(); platformIt++) {
for (auto platformIt = platforms.cbegin(); // Line break.
platformIt != platforms.cend(); platformIt++) {
auto mapIt = gamesdb_new_platformid_map.find(*platformIt);
if (mapIt != gamesdb_new_platformid_map.cend()) {
if (!first)
@ -178,8 +179,9 @@ void thegamesdb_generate_json_scraper_requests(const ScraperSearchParams& params
first = false;
}
else {
LOG(LogWarning) << "TheGamesDB scraper: No support for platform \"" <<
getPlatformName(*platformIt) << "\", search will be inaccurate";
LOG(LogWarning)
<< "TheGamesDB scraper: No support for platform \""
<< getPlatformName(*platformIt) << "\", search will be inaccurate";
}
}
path += platformQueryParam;
@ -188,15 +190,15 @@ void thegamesdb_generate_json_scraper_requests(const ScraperSearchParams& params
LOG(LogWarning) << "TheGamesDB scraper: No platform defined, search will be inaccurate";
}
requests.push(std::unique_ptr<ScraperRequest>
(new TheGamesDBJSONRequest(requests, results, path)));
requests.push(
std::unique_ptr<ScraperRequest>(new TheGamesDBJSONRequest(requests, results, path)));
}
}
void thegamesdb_generate_json_scraper_requests(
const std::string& gameIDs,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results)
const std::string& gameIDs,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results)
{
resources.prepare();
std::string path = "https://api.thegamesdb.net/v1";
@ -204,158 +206,158 @@ void thegamesdb_generate_json_scraper_requests(
path += "/Games/Images/GamesImages?" + apiKey + "&games_id=" + gameIDs;
requests.push(std::unique_ptr<ScraperRequest>
(new TheGamesDBJSONRequest(requests, results, path)));
requests.push(
std::unique_ptr<ScraperRequest>(new TheGamesDBJSONRequest(requests, results, path)));
}
namespace
{
std::string getStringOrThrow(const Value& v, const std::string& key)
{
if (!v.HasMember(key.c_str()) || !v[key.c_str()].IsString()) {
throw std::runtime_error(
std::string getStringOrThrow(const Value& v, const std::string& key)
{
if (!v.HasMember(key.c_str()) || !v[key.c_str()].IsString()) {
throw std::runtime_error(
"rapidjson internal assertion failure: missing or non string key:" + key);
}
return v[key.c_str()].GetString();
}
return v[key.c_str()].GetString();
}
int getIntOrThrow(const Value& v, const std::string& key)
{
if (!v.HasMember(key.c_str()) || !v[key.c_str()].IsInt()) {
throw std::runtime_error(
int getIntOrThrow(const Value& v, const std::string& key)
{
if (!v.HasMember(key.c_str()) || !v[key.c_str()].IsInt()) {
throw std::runtime_error(
"rapidjson internal assertion failure: missing or non int key:" + key);
}
return v[key.c_str()].GetInt();
}
int getIntOrThrow(const Value& v)
{
if (!v.IsInt()) {
throw std::runtime_error("rapidjson internal assertion failure: not an int");
}
return v.GetInt();
}
std::string getDeveloperString(const Value& v)
{
if (!v.IsArray())
return "";
std::string out = "";
bool first = true;
for (int i = 0; i < static_cast<int>(v.Size()); i++) {
auto mapIt = resources.gamesdb_new_developers_map.find(getIntOrThrow(v[i]));
if (mapIt == resources.gamesdb_new_developers_map.cend())
continue;
if (!first)
out += ", ";
out += mapIt->second;
first = false;
}
return out;
}
std::string getPublisherString(const Value& v)
{
if (!v.IsArray())
return "";
std::string out = "";
bool first = true;
for (int i = 0; i < static_cast<int>(v.Size()); i++) {
auto mapIt = resources.gamesdb_new_publishers_map.find(getIntOrThrow(v[i]));
if (mapIt == resources.gamesdb_new_publishers_map.cend())
continue;
if (!first)
out += ", ";
out += mapIt->second;
first = false;
}
return out;
}
std::string getGenreString(const Value& v)
{
if (!v.IsArray())
return "";
std::string out = "";
bool first = true;
for (int i = 0; i < static_cast<int>(v.Size()); i++) {
auto mapIt = resources.gamesdb_new_genres_map.find(getIntOrThrow(v[i]));
if (mapIt == resources.gamesdb_new_genres_map.cend())
continue;
if (!first)
out += ", ";
out += mapIt->second;
first = false;
}
return out;
}
void processGame(const Value& game, std::vector<ScraperSearchResult>& results)
{
ScraperSearchResult result;
if (game.HasMember("id") && game["id"].IsInt())
result.gameID = std::to_string(getIntOrThrow(game, "id"));
result.mdl.set("name", getStringOrThrow(game, "game_title"));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Name: " << result.mdl.get("name");
if (game.HasMember("overview") && game["overview"].IsString())
result.mdl.set("desc", Utils::String::replace(game["overview"].GetString(), "\r", ""));
if (game.HasMember("release_date") && game["release_date"].IsString()) {
result.mdl.set("releasedate", Utils::Time::DateTime(Utils::Time::stringToTime(
game["release_date"].GetString(), "%Y-%m-%d")));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Release Date (unparsed): " <<
game["release_date"].GetString();
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Release Date (parsed): " <<
result.mdl.get("releasedate");
}
return v[key.c_str()].GetInt();
}
if (game.HasMember("developers") && game["developers"].IsArray()) {
result.mdl.set("developer", getDeveloperString(game["developers"]));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Developer: " <<
result.mdl.get("developer");
int getIntOrThrow(const Value& v)
{
if (!v.IsInt()) {
throw std::runtime_error("rapidjson internal assertion failure: not an int");
}
return v.GetInt();
}
if (game.HasMember("publishers") && game["publishers"].IsArray()) {
result.mdl.set("publisher", getPublisherString(game["publishers"]));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Publisher: " <<
result.mdl.get("publisher");
std::string getDeveloperString(const Value& v)
{
if (!v.IsArray())
return "";
std::string out = "";
bool first = true;
for (int i = 0; i < static_cast<int>(v.Size()); i++) {
auto mapIt = resources.gamesdb_new_developers_map.find(getIntOrThrow(v[i]));
if (mapIt == resources.gamesdb_new_developers_map.cend())
continue;
if (!first)
out += ", ";
out += mapIt->second;
first = false;
}
return out;
}
if (game.HasMember("genres") && game["genres"].IsArray()) {
result.mdl.set("genre", getGenreString(game["genres"]));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Genre: " <<
result.mdl.get("genre");
std::string getPublisherString(const Value& v)
{
if (!v.IsArray())
return "";
std::string out = "";
bool first = true;
for (int i = 0; i < static_cast<int>(v.Size()); i++) {
auto mapIt = resources.gamesdb_new_publishers_map.find(getIntOrThrow(v[i]));
if (mapIt == resources.gamesdb_new_publishers_map.cend())
continue;
if (!first)
out += ", ";
out += mapIt->second;
first = false;
}
return out;
}
if (game.HasMember("players") && game["players"].IsInt()) {
result.mdl.set("players", std::to_string(game["players"].GetInt()));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Players: " <<
result.mdl.get("players");
std::string getGenreString(const Value& v)
{
if (!v.IsArray())
return "";
std::string out = "";
bool first = true;
for (int i = 0; i < static_cast<int>(v.Size()); i++) {
auto mapIt = resources.gamesdb_new_genres_map.find(getIntOrThrow(v[i]));
if (mapIt == resources.gamesdb_new_genres_map.cend())
continue;
if (!first)
out += ", ";
out += mapIt->second;
first = false;
}
return out;
}
result.mediaURLFetch = NOT_STARTED;
results.push_back(result);
}
void processGame(const Value& game, std::vector<ScraperSearchResult>& results)
{
ScraperSearchResult result;
if (game.HasMember("id") && game["id"].IsInt())
result.gameID = std::to_string(getIntOrThrow(game, "id"));
result.mdl.set("name", getStringOrThrow(game, "game_title"));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Name: " << result.mdl.get("name");
if (game.HasMember("overview") && game["overview"].IsString())
result.mdl.set("desc", Utils::String::replace(game["overview"].GetString(), "\r", ""));
if (game.HasMember("release_date") && game["release_date"].IsString()) {
result.mdl.set("releasedate", Utils::Time::DateTime(Utils::Time::stringToTime(
game["release_date"].GetString(), "%Y-%m-%d")));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Release Date (unparsed): "
<< game["release_date"].GetString();
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Release Date (parsed): "
<< result.mdl.get("releasedate");
}
if (game.HasMember("developers") && game["developers"].IsArray()) {
result.mdl.set("developer", getDeveloperString(game["developers"]));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Developer: "
<< result.mdl.get("developer");
}
if (game.HasMember("publishers") && game["publishers"].IsArray()) {
result.mdl.set("publisher", getPublisherString(game["publishers"]));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Publisher: "
<< result.mdl.get("publisher");
}
if (game.HasMember("genres") && game["genres"].IsArray()) {
result.mdl.set("genre", getGenreString(game["genres"]));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Genre: "
<< result.mdl.get("genre");
}
if (game.HasMember("players") && game["players"].IsInt()) {
result.mdl.set("players", std::to_string(game["players"].GetInt()));
LOG(LogDebug) << "GamesDBJSONScraper::processGame(): Players: "
<< result.mdl.get("players");
}
result.mediaURLFetch = NOT_STARTED;
results.push_back(result);
}
} // namespace
void processMediaURLs(const Value& images, const std::string& base_url,
std::vector<ScraperSearchResult>& results)
void processMediaURLs(const Value& images,
const std::string& base_url,
std::vector<ScraperSearchResult>& results)
{
ScraperSearchResult result;
@ -367,9 +369,8 @@ void processMediaURLs(const Value& images, const std::string& base_url,
result.marqueeUrl = "";
result.screenshotUrl = "";
// Quite excessive testing for valid values, but you never know
// what the server has returned and we don't want to crash the
// program due to malformed data.
// Quite excessive testing for valid values, but you never know what the server has
// returned and we don't want to crash the program due to malformed data.
if (gameMedia.IsArray()) {
for (SizeType i = 0; i < gameMedia.Size(); i++) {
std::string mediatype;
@ -390,13 +391,13 @@ void processMediaURLs(const Value& images, const std::string& base_url,
result.screenshotUrl = base_url + gameMedia[i]["filename"].GetString();
}
}
result.mediaURLFetch = COMPLETED;
results.push_back(result);
result.mediaURLFetch = COMPLETED;
results.push_back(result);
}
}
void TheGamesDBJSONRequest::process(const std::unique_ptr<HttpReq>& req,
std::vector<ScraperSearchResult>& results)
std::vector<ScraperSearchResult>& results)
{
assert(req->status() == HttpReq::REQ_SUCCESS);
@ -404,9 +405,8 @@ void TheGamesDBJSONRequest::process(const std::unique_ptr<HttpReq>& req,
doc.Parse(req->getContent().c_str());
if (doc.HasParseError()) {
std::string err =
std::string("TheGamesDBJSONRequest - Error parsing JSON \n\t") +
GetParseError_En(doc.GetParseError());
std::string err = std::string("TheGamesDBJSONRequest - Error parsing JSON \n\t") +
GetParseError_En(doc.GetParseError());
setError(err);
LOG(LogError) << err;
return;
@ -414,7 +414,7 @@ void TheGamesDBJSONRequest::process(const std::unique_ptr<HttpReq>& req,
// If the response contains the 'images' object, then it's a game media URL request.
if (doc.HasMember("data") && doc["data"].HasMember("images") &&
doc["data"]["images"].IsObject()) {
doc["data"]["images"].IsObject()) {
const Value& images = doc["data"]["images"];
const Value& base_url = doc["data"]["base_url"];
@ -440,19 +440,18 @@ void TheGamesDBJSONRequest::process(const std::unique_ptr<HttpReq>& req,
if (doc.HasMember("remaining_monthly_allowance") && doc.HasMember("extra_allowance")) {
for (auto i = 0; i < results.size(); i++) {
results[i].scraperRequestAllowance =
doc["remaining_monthly_allowance"].GetInt() +
doc["extra_allowance"].GetInt();
doc["remaining_monthly_allowance"].GetInt() + doc["extra_allowance"].GetInt();
}
LOG(LogDebug) << "TheGamesDBJSONRequest::process(): "
"Remaining monthly scraping allowance: " <<
results.back().scraperRequestAllowance;
"Remaining monthly scraping allowance: "
<< results.back().scraperRequestAllowance;
}
return;
}
// These process steps are for the initial scraping response.
if (!doc.HasMember("data") || !doc["data"].HasMember("games") ||
!doc["data"]["games"].IsArray()) {
!doc["data"]["games"].IsArray()) {
LOG(LogWarning) << "TheGamesDBJSONRequest - Response had no game data\n";
return;
}

37
es-app/src/scrapers/GamesDBJSONScraper.h
View file

@ -12,39 +12,42 @@
#include "scrapers/Scraper.h"
namespace pugi {
namespace pugi
{
class xml_document;
}
void thegamesdb_generate_json_scraper_requests(const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
void thegamesdb_generate_json_scraper_requests(
const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
void thegamesdb_generate_json_scraper_requests(const std::string& gameIDs,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
void thegamesdb_generate_json_scraper_requests(
const std::string& gameIDs,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
class TheGamesDBJSONRequest : public ScraperHttpRequest
{
public:
public:
// Constructor for a GetGameList request.
TheGamesDBJSONRequest(
std::queue<std::unique_ptr<ScraperRequest>>& requestsWrite,
std::vector<ScraperSearchResult>& resultsWrite,
const std::string& url)
: ScraperHttpRequest(resultsWrite, url),
mRequestQueue(&requestsWrite)
TheGamesDBJSONRequest(std::queue<std::unique_ptr<ScraperRequest>>& requestsWrite,
std::vector<ScraperSearchResult>& resultsWrite,
const std::string& url)
: ScraperHttpRequest(resultsWrite, url)
, mRequestQueue(&requestsWrite)
{
}
// Constructior for a GetGame request
TheGamesDBJSONRequest(std::vector<ScraperSearchResult>& resultsWrite, const std::string& url)
: ScraperHttpRequest(resultsWrite, url), mRequestQueue(nullptr)
: ScraperHttpRequest(resultsWrite, url)
, mRequestQueue(nullptr)
{
}
protected:
protected:
void process(const std::unique_ptr<HttpReq>& req,
std::vector<ScraperSearchResult>& results) override;
std::vector<ScraperSearchResult>& results) override;
bool isGameRequest() { return !mRequestQueue; }
std::queue<std::unique_ptr<ScraperRequest>>* mRequestQueue;

110
es-app/src/scrapers/GamesDBJSONScraperResources.cpp
View file

@ -14,52 +14,53 @@
#include "scrapers/GamesDBJSONScraperResources.h"
#include "utils/FileSystemUtil.h"
#include "Log.h"
#include "utils/FileSystemUtil.h"
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <chrono>
#include <fstream>
#include <memory>
#include <rapidjson/document.h>
#include <rapidjson/error/en.h>
#include <thread>
using namespace rapidjson;
namespace {
constexpr char GamesDBAPIKey[] =
namespace
{
constexpr char GamesDBAPIKey[] =
"445fcbc3f32bb2474bc27016b99eb963d318ee3a608212c543b9a79de1041600";
constexpr int MAX_WAIT_MS = 90000;
constexpr int POLL_TIME_MS = 500;
constexpr int MAX_WAIT_ITER = MAX_WAIT_MS / POLL_TIME_MS;
constexpr int MAX_WAIT_MS = 90000;
constexpr int POLL_TIME_MS = 500;
constexpr int MAX_WAIT_ITER = MAX_WAIT_MS / POLL_TIME_MS;
constexpr char SCRAPER_RESOURCES_DIR[] = "scrapers";
constexpr char DEVELOPERS_JSON_FILE[] = "gamesdb_developers.json";
constexpr char PUBLISHERS_JSON_FILE[] = "gamesdb_publishers.json";
constexpr char GENRES_JSON_FILE[] = "gamesdb_genres.json";
constexpr char DEVELOPERS_ENDPOINT[] = "/Developers";
constexpr char PUBLISHERS_ENDPOINT[] = "/Publishers";
constexpr char GENRES_ENDPOINT[] = "/Genres";
constexpr char SCRAPER_RESOURCES_DIR[] = "scrapers";
constexpr char DEVELOPERS_JSON_FILE[] = "gamesdb_developers.json";
constexpr char PUBLISHERS_JSON_FILE[] = "gamesdb_publishers.json";
constexpr char GENRES_JSON_FILE[] = "gamesdb_genres.json";
constexpr char DEVELOPERS_ENDPOINT[] = "/Developers";
constexpr char PUBLISHERS_ENDPOINT[] = "/Publishers";
constexpr char GENRES_ENDPOINT[] = "/Genres";
std::string genFilePath(const std::string& file_name)
{
return Utils::FileSystem::getGenericPath(getScrapersResouceDir() + "/" + file_name);
}
std::string genFilePath(const std::string& file_name)
{
return Utils::FileSystem::getGenericPath(getScrapersResouceDir() + "/" + file_name);
}
void ensureScrapersResourcesDir()
{
std::string path = getScrapersResouceDir();
if (!Utils::FileSystem::exists(path))
Utils::FileSystem::createDirectory(path);
}
void ensureScrapersResourcesDir()
{
std::string path = getScrapersResouceDir();
if (!Utils::FileSystem::exists(path))
Utils::FileSystem::createDirectory(path);
}
} // namespace
std::string getScrapersResouceDir()
{
return Utils::FileSystem::getGenericPath(
Utils::FileSystem::getHomePath() + "/.emulationstation/" + SCRAPER_RESOURCES_DIR);
return Utils::FileSystem::getGenericPath(Utils::FileSystem::getHomePath() +
"/.emulationstation/" + SCRAPER_RESOURCES_DIR);
}
std::string TheGamesDBJSONRequestResources::getApiKey() const { return GamesDBAPIKey; }
@ -69,16 +70,16 @@ void TheGamesDBJSONRequestResources::prepare()
if (checkLoaded())
return;
if (loadResource(gamesdb_new_developers_map, "developers",
genFilePath(DEVELOPERS_JSON_FILE)) && !gamesdb_developers_resource_request)
if (loadResource(gamesdb_new_developers_map, "developers", genFilePath(DEVELOPERS_JSON_FILE)) &&
!gamesdb_developers_resource_request)
gamesdb_developers_resource_request = fetchResource(DEVELOPERS_ENDPOINT);
if (loadResource(gamesdb_new_publishers_map, "publishers",
genFilePath(PUBLISHERS_JSON_FILE)) && !gamesdb_publishers_resource_request)
if (loadResource(gamesdb_new_publishers_map, "publishers", genFilePath(PUBLISHERS_JSON_FILE)) &&
!gamesdb_publishers_resource_request)
gamesdb_publishers_resource_request = fetchResource(PUBLISHERS_ENDPOINT);
if (loadResource(gamesdb_new_genres_map, "genres",
genFilePath(GENRES_JSON_FILE)) && !gamesdb_genres_resource_request)
if (loadResource(gamesdb_new_genres_map, "genres", genFilePath(GENRES_JSON_FILE)) &&
!gamesdb_genres_resource_request)
gamesdb_genres_resource_request = fetchResource(GENRES_ENDPOINT);
}
@ -90,21 +91,22 @@ void TheGamesDBJSONRequestResources::ensureResources()
for (int i = 0; i < MAX_WAIT_ITER; i++) {
if (gamesdb_developers_resource_request &&
saveResource(gamesdb_developers_resource_request.get(),
gamesdb_new_developers_map, "developers", genFilePath(DEVELOPERS_JSON_FILE)))
saveResource(gamesdb_developers_resource_request.get(), gamesdb_new_developers_map,
"developers", genFilePath(DEVELOPERS_JSON_FILE)))
gamesdb_developers_resource_request.reset(nullptr);
if (gamesdb_publishers_resource_request &&
saveResource(gamesdb_publishers_resource_request.get(),
gamesdb_new_publishers_map, "publishers", genFilePath(PUBLISHERS_JSON_FILE)))
saveResource(gamesdb_publishers_resource_request.get(), gamesdb_new_publishers_map,
"publishers", genFilePath(PUBLISHERS_JSON_FILE)))
gamesdb_publishers_resource_request.reset(nullptr);
if (gamesdb_genres_resource_request && saveResource(gamesdb_genres_resource_request.get(),
gamesdb_new_genres_map, "genres", genFilePath(GENRES_JSON_FILE)))
if (gamesdb_genres_resource_request &&
saveResource(gamesdb_genres_resource_request.get(), gamesdb_new_genres_map, "genres",
genFilePath(GENRES_JSON_FILE)))
gamesdb_genres_resource_request.reset(nullptr);
if (!gamesdb_developers_resource_request && !gamesdb_publishers_resource_request &&
!gamesdb_genres_resource_request)
!gamesdb_genres_resource_request)
return;
std::this_thread::sleep_for(std::chrono::milliseconds(POLL_TIME_MS));
@ -115,14 +117,13 @@ void TheGamesDBJSONRequestResources::ensureResources()
bool TheGamesDBJSONRequestResources::checkLoaded()
{
return !gamesdb_new_genres_map.empty() && !gamesdb_new_developers_map.empty() &&
!gamesdb_new_publishers_map.empty();
!gamesdb_new_publishers_map.empty();
}
bool TheGamesDBJSONRequestResources::saveResource(
HttpReq* req,
std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name)
bool TheGamesDBJSONRequestResources::saveResource(HttpReq* req,
std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name)
{
if (req == nullptr) {
@ -133,8 +134,8 @@ bool TheGamesDBJSONRequestResources::saveResource(
return false; // Not ready: wait some more.
}
if (req->status() != HttpReq::REQ_SUCCESS) {
LOG(LogError) << "Resource request for " << file_name <<
" failed:\n\t" << req->getErrorMsg();
LOG(LogError) << "Resource request for " << file_name << " failed:\n\t"
<< req->getErrorMsg();
return true; // Request failed, resetting request..
}
@ -156,10 +157,9 @@ std::unique_ptr<HttpReq> TheGamesDBJSONRequestResources::fetchResource(const std
return std::unique_ptr<HttpReq>(new HttpReq(path));
}
int TheGamesDBJSONRequestResources::loadResource(
std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name)
int TheGamesDBJSONRequestResources::loadResource(std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name)
{
std::ifstream fin(file_name);
if (!fin.good())
@ -172,8 +172,8 @@ int TheGamesDBJSONRequestResources::loadResource(
if (doc.HasParseError()) {
std::string err = std::string("TheGamesDBJSONRequest - "
"Error parsing JSON for resource file ") + file_name +
":\n\t" + GetParseError_En(doc.GetParseError());
"Error parsing JSON for resource file ") +
file_name + ":\n\t" + GetParseError_En(doc.GetParseError());
LOG(LogError) << err;
return 1;
}
@ -189,7 +189,7 @@ int TheGamesDBJSONRequestResources::loadResource(
for (Value::ConstMemberIterator itr = data.MemberBegin(); itr != data.MemberEnd(); itr++) {
auto& entry = itr->value;
if (!entry.IsObject() || !entry.HasMember("id") || !entry["id"].IsInt() ||
!entry.HasMember("name") || !entry["name"].IsString())
!entry.HasMember("name") || !entry["name"].IsString())
continue;
resource[entry["id"].GetInt()] = entry["name"].GetString();

20
es-app/src/scrapers/GamesDBJSONScraperResources.h
View file

@ -33,20 +33,18 @@ struct TheGamesDBJSONRequestResources {
std::unordered_map<int, std::string> gamesdb_new_publishers_map;
std::unordered_map<int, std::string> gamesdb_new_genres_map;
private:
private:
bool checkLoaded();
bool saveResource(
HttpReq* req,
std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name);
std::unique_ptr<HttpReq> fetchResource(const std::string& endpoint);
bool saveResource(HttpReq* req,
std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name);
std::unique_ptr<HttpReq> fetchResource(const std::string& endpoint);
int loadResource(
std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name);
int loadResource(std::unordered_map<int, std::string>& resource,
const std::string& resource_name,
const std::string& file_name);
std::unique_ptr<HttpReq> gamesdb_developers_resource_request;
std::unique_ptr<HttpReq> gamesdb_publishers_resource_request;

176
es-app/src/scrapers/Scraper.cpp
View file

@ -10,20 +10,20 @@
#include "scrapers/Scraper.h"
#include "utils/StringUtil.h"
#include "FileData.h"
#include "GamesDBJSONScraper.h"
#include "Log.h"
#include "ScreenScraper.h"
#include "Settings.h"
#include "SystemData.h"
#include "utils/StringUtil.h"
#if defined(_WIN64)
#include "views/ViewController.h"
#endif
#include <cmath>
#include <FreeImage.h>
#include <cmath>
#include <fstream>
const std::map<std::string, generate_scraper_requests_func> scraper_request_funcs {
@ -41,9 +41,9 @@ std::unique_ptr<ScraperSearchHandle> startScraperSearch(const ScraperSearchParam
LOG(LogError) << "Configured scraper (" << name << ") unavailable, scraping aborted";
}
else {
LOG(LogDebug) << "Scraper::startScraperSearch(): Scraping system \"" <<
params.system->getName() << "\", game file \"" <<
params.game->getFileName() << "\"";
LOG(LogDebug) << "Scraper::startScraperSearch(): Scraping system \""
<< params.system->getName() << "\", game file \""
<< params.game->getFileName() << "\"";
scraper_request_funcs.at(name)(params, handle->mRequestQueue, handle->mResults);
}
@ -84,12 +84,6 @@ bool isValidConfiguredScraper()
return scraper_request_funcs.find(name) != scraper_request_funcs.end();
}
// ScraperSearchHandle.
ScraperSearchHandle::ScraperSearchHandle()
{
setStatus(ASYNC_IN_PROGRESS);
}
void ScraperSearchHandle::update()
{
if (mStatus == ASYNC_DONE)
@ -128,13 +122,14 @@ void ScraperSearchHandle::update()
// ScraperRequest.
ScraperRequest::ScraperRequest(std::vector<ScraperSearchResult>& resultsWrite)
: mResults(resultsWrite)
: mResults(resultsWrite)
{
}
// ScraperHttpRequest.
ScraperHttpRequest::ScraperHttpRequest(std::vector<ScraperSearchResult>& resultsWrite,
const std::string& url) : ScraperRequest(resultsWrite)
const std::string& url)
: ScraperRequest(resultsWrite)
{
setStatus(ASYNC_IN_PROGRESS);
mReq = std::unique_ptr<HttpReq>(new HttpReq(url));
@ -155,20 +150,21 @@ void ScraperHttpRequest::update()
return;
// Everything else is some sort of error.
LOG(LogError) << "ScraperHttpRequest network error (status: " << status<< ") - "
<< mReq->getErrorMsg();
LOG(LogError) << "ScraperHttpRequest network error (status: " << status << ") - "
<< mReq->getErrorMsg();
setError("Network error: " + mReq->getErrorMsg());
}
// Download and write the media files to disk.
std::unique_ptr<MDResolveHandle> resolveMetaDataAssets(const ScraperSearchResult& result,
const ScraperSearchParams& search)
const ScraperSearchParams& search)
{
return std::unique_ptr<MDResolveHandle>(new MDResolveHandle(result, search));
}
MDResolveHandle::MDResolveHandle(const ScraperSearchResult& result,
const ScraperSearchParams& search) : mResult(result)
const ScraperSearchParams& search)
: mResult(result)
{
struct mediaFileInfoStruct {
std::string fileURL;
@ -221,10 +217,10 @@ MDResolveHandle::MDResolveHandle(const ScraperSearchResult& result,
mediaFileInfo.existingMediaFile = search.game->getVideoPath();
mediaFileInfo.resizeFile = false;
scrapeFiles.push_back(mediaFileInfo);
#if defined(_WIN64)
#if defined(_WIN64)
// Required due to the idiotic file locking that exists on this operating system.
ViewController::get()->onStopVideo();
#endif
#endif
}
for (auto it = scrapeFiles.cbegin(); it != scrapeFiles.cend(); it++) {
@ -248,13 +244,12 @@ MDResolveHandle::MDResolveHandle(const ScraperSearchResult& result,
// If there is an existing media file on disk and the setting to overwrite data
// has been set to no, then don't proceed with downloading or saving a new file.
if (it->existingMediaFile != "" &&
!Settings::getInstance()->getBool("ScraperOverwriteData"))
!Settings::getInstance()->getBool("ScraperOverwriteData"))
continue;
// If the image is cached already as the thumbnail, then we don't need
// to download it again, in this case just save it to disk and resize it.
if (mResult.thumbnailImageUrl == it->fileURL &&
mResult.thumbnailImageData.size() > 0) {
if (mResult.thumbnailImageUrl == it->fileURL && mResult.thumbnailImageData.size() > 0) {
// This is just a temporary workaround to avoid saving media files to disk that
// are actually just containing error messages from the scraper service. The
@ -265,19 +260,19 @@ MDResolveHandle::MDResolveHandle(const ScraperSearchResult& result,
// are sometimes returned from the scraper service and these can actually be
// less than 350 bytes in size.
if (Settings::getInstance()->getBool("ScraperHaltOnInvalidMedia") &&
mResult.thumbnailImageData.size() < 350) {
mResult.thumbnailImageData.size() < 350) {
FIMEMORY* memoryStream = FreeImage_OpenMemory(
reinterpret_cast<BYTE*>(&mResult.thumbnailImageData.at(0)),
static_cast<DWORD>(mResult.thumbnailImageData.size()));
FIMEMORY* memoryStream =
FreeImage_OpenMemory(reinterpret_cast<BYTE*>(&mResult.thumbnailImageData.at(0)),
static_cast<DWORD>(mResult.thumbnailImageData.size()));
FREE_IMAGE_FORMAT imageFormat = FreeImage_GetFileTypeFromMemory(memoryStream, 0);
FreeImage_CloseMemory(memoryStream);
if (imageFormat == FIF_UNKNOWN) {
setError("The file \"" + Utils::FileSystem::getFileName(filePath) +
"\" returned by the scraper seems to be invalid as it's less than " +
"350 bytes in size");
"\" returned by the scraper seems to be invalid as it's less than " +
"350 bytes in size");
return;
}
}
@ -293,18 +288,18 @@ MDResolveHandle::MDResolveHandle(const ScraperSearchResult& result,
// problems or the MediaDirectory setting points to a file instead of a directory.
if (!Utils::FileSystem::isDirectory(Utils::FileSystem::getParent(filePath))) {
setError("Media directory does not exist and can't be created. "
"Permission problems?");
LOG(LogError) << "Couldn't create media directory: \"" <<
Utils::FileSystem::getParent(filePath) << "\"";
return;
"Permission problems?");
LOG(LogError) << "Couldn't create media directory: \""
<< Utils::FileSystem::getParent(filePath) << "\"";
return;
}
#if defined(_WIN64)
#if defined(_WIN64)
std::ofstream stream(Utils::String::stringToWideString(filePath).c_str(),
std::ios_base::out | std::ios_base::binary);
#else
std::ios_base::out | std::ios_base::binary);
#else
std::ofstream stream(filePath, std::ios_base::out | std::ios_base::binary);
#endif
#endif
if (!stream || stream.bad()) {
setError("Failed to open path for writing media file.\nPermission error?");
return;
@ -331,8 +326,9 @@ MDResolveHandle::MDResolveHandle(const ScraperSearchResult& result,
// If it's not cached, then initiate the download.
else {
mFuncs.push_back(ResolvePair(downloadMediaAsync(it->fileURL, filePath,
it->existingMediaFile, it->subDirectory, it->resizeFile, mResult.savedNewMedia),
[this, filePath] {}));
it->existingMediaFile, it->subDirectory,
it->resizeFile, mResult.savedNewMedia),
[this, filePath] {}));
}
}
}
@ -361,37 +357,30 @@ void MDResolveHandle::update()
setStatus(ASYNC_DONE);
}
std::unique_ptr<MediaDownloadHandle> downloadMediaAsync(
const std::string& url,
const std::string& saveAs,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia)
std::unique_ptr<MediaDownloadHandle> downloadMediaAsync(const std::string& url,
const std::string& saveAs,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia)
{
return std::unique_ptr<MediaDownloadHandle>(new MediaDownloadHandle(
url,
saveAs,
existingMediaPath,
mediaType,
resizeFile,
savedNewMedia));
url, saveAs, existingMediaPath, mediaType, resizeFile, savedNewMedia));
}
MediaDownloadHandle::MediaDownloadHandle(
const std::string& url,
const std::string& path,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia)
: mSavePath(path),
mExistingMediaFile(existingMediaPath),
mMediaType(mediaType),
mResizeFile(resizeFile),
mReq(new HttpReq(url))
MediaDownloadHandle::MediaDownloadHandle(const std::string& url,
const std::string& path,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia)
: mSavePath(path)
, mExistingMediaFile(existingMediaPath)
, mMediaType(mediaType)
, mResizeFile(resizeFile)
, mReq(new HttpReq(url))
{
mSavedNewMediaPtr = &savedNewMedia;
mSavedNewMediaPtr = &savedNewMedia;
}
void MediaDownloadHandle::update()
@ -421,25 +410,22 @@ void MediaDownloadHandle::update()
// Black/empty images are sometimes returned from the scraper service and these can actually
// be less than 350 bytes in size.
if (Settings::getInstance()->getBool("ScraperHaltOnInvalidMedia") &&
mReq->getContent().size() < 350) {
mReq->getContent().size() < 350) {
FREE_IMAGE_FORMAT imageFormat = FIF_UNKNOWN;
if (mMediaType != "videos") {
std::string imageData = mReq->getContent();
FIMEMORY* memoryStream = FreeImage_OpenMemory(
reinterpret_cast<BYTE*>(&imageData.at(0)),
static_cast<DWORD>(imageData.size()));
FIMEMORY* memoryStream = FreeImage_OpenMemory(reinterpret_cast<BYTE*>(&imageData.at(0)),
static_cast<DWORD>(imageData.size()));
imageFormat = FreeImage_GetFileTypeFromMemory(memoryStream, 0);
FreeImage_CloseMemory(memoryStream);
}
if (imageFormat == FIF_UNKNOWN) {
setError("The file \"" + Utils::FileSystem::getFileName(mSavePath) +
"\" returned by the scraper seems to be invalid as it's less than " +
"350 bytes in size");
"\" returned by the scraper seems to be invalid as it's less than " +
"350 bytes in size");
return;
}
}
@ -455,17 +441,17 @@ void MediaDownloadHandle::update()
// problems or the MediaDirectory setting points to a file instead of a directory.
if (!Utils::FileSystem::isDirectory(Utils::FileSystem::getParent(mSavePath))) {
setError("Media directory does not exist and can't be created. Permission problems?");
LOG(LogError) << "Couldn't create media directory: \"" <<
Utils::FileSystem::getParent(mSavePath) << "\"";
LOG(LogError) << "Couldn't create media directory: \""
<< Utils::FileSystem::getParent(mSavePath) << "\"";
return;
}
#if defined(_WIN64)
#if defined(_WIN64)
std::ofstream stream(Utils::String::stringToWideString(mSavePath).c_str(),
std::ios_base::out | std::ios_base::binary);
#else
std::ios_base::out | std::ios_base::binary);
#else
std::ofstream stream(mSavePath, std::ios_base::out | std::ios_base::binary);
#endif
#endif
if (!stream || stream.bad()) {
setError("Failed to open path for writing media file.\nPermission error?");
return;
@ -512,15 +498,16 @@ bool resizeImage(const std::string& path, const std::string& mediaType)
FIBITMAP* image = nullptr;
// Detect the file format.
#if defined(_WIN64)
#if defined(_WIN64)
format = FreeImage_GetFileTypeU(Utils::String::stringToWideString(path).c_str(), 0);
if (format == FIF_UNKNOWN)
format = FreeImage_GetFIFFromFilenameU(Utils::String::stringToWideString(path).c_str());
#else
#else
format = FreeImage_GetFileType(path.c_str(), 0);
if (format == FIF_UNKNOWN)
format = FreeImage_GetFIFFromFilename(path.c_str());
#endif
#endif
if (format == FIF_UNKNOWN) {
LOG(LogError) << "Could not detect filetype for image \"" << path << "\"!";
return false;
@ -528,11 +515,11 @@ bool resizeImage(const std::string& path, const std::string& mediaType)
// Make sure we can read this format, and if so, then load it.
if (FreeImage_FIFSupportsReading(format)) {
#if defined(_WIN64)
#if defined(_WIN64)
image = FreeImage_LoadU(format, Utils::String::stringToWideString(path).c_str());
#else
#else
image = FreeImage_Load(format, path.c_str());
#endif
#endif
}
else {
LOG(LogError) << "File format not supported for image \"" << path << "\"";
@ -545,8 +532,8 @@ bool resizeImage(const std::string& path, const std::string& mediaType)
// If the image is smaller than (or the same size as) maxWidth and maxHeight, then don't
// do any scaling. It doesn't make sense to upscale the image and waste disk space.
if (maxWidth >= width && maxHeight >= height) {
LOG(LogDebug) << "Scraper::resizeImage(): Saving image \"" << path <<
"\" at its original resolution " << width << "x" << height;
LOG(LogDebug) << "Scraper::resizeImage(): Saving image \"" << path
<< "\" at its original resolution " << width << "x" << height;
FreeImage_Unload(image);
return true;
}
@ -568,7 +555,7 @@ bool resizeImage(const std::string& path, const std::string& mediaType)
// We use Lanczos3 which is the highest quality resampling method available in FreeImage.
FIBITMAP* imageRescaled = FreeImage_Rescale(image, static_cast<int>(maxWidth),
static_cast<int>(maxHeight), FILTER_LANCZOS3);
static_cast<int>(maxHeight), FILTER_LANCZOS3);
FreeImage_Unload(image);
if (imageRescaled == nullptr) {
@ -576,12 +563,12 @@ bool resizeImage(const std::string& path, const std::string& mediaType)
return false;
}
#if defined(_WIN64)
#if defined(_WIN64)
bool saved = (FreeImage_SaveU(format, imageRescaled,
Utils::String::stringToWideString(path).c_str()) != 0);
#else
Utils::String::stringToWideString(path).c_str()) != 0);
#else
bool saved = (FreeImage_Save(format, imageRescaled, path.c_str()) != 0);
#endif
#endif
FreeImage_Unload(imageRescaled);
if (!saved) {
@ -589,14 +576,15 @@ bool resizeImage(const std::string& path, const std::string& mediaType)
}
else {
LOG(LogDebug) << "Scraper::resizeImage(): Downscaled image \"" << path << "\" from "
<< width << "x" << height << " to " << maxWidth << "x" << maxHeight;
<< width << "x" << height << " to " << maxWidth << "x" << maxHeight;
}
return saved;
}
std::string getSaveAsPath(const ScraperSearchParams& params,
const std::string& filetypeSubdirectory, const std::string& extension)
const std::string& filetypeSubdirectory,
const std::string& extension)
{
const std::string systemsubdirectory = params.system->getName();
const std::string name = Utils::FileSystem::getStem(params.game->getPath());
@ -605,7 +593,7 @@ std::string getSaveAsPath(const ScraperSearchParams& params,
// Extract possible subfolders from the path.
if (params.system->getSystemEnvData()->mStartPath != "")
subFolders = Utils::String::replace(Utils::FileSystem::getParent(params.game->getPath()),
params.system->getSystemEnvData()->mStartPath, "");
params.system->getSystemEnvData()->mStartPath, "");
std::string path = FileData::getMediaDirectory();

95
es-app/src/scrapers/Scraper.h
View file

@ -27,7 +27,7 @@ class FileData;
class SystemData;
enum downloadStatus {
NOT_STARTED,
NOT_STARTED, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
IN_PROGRESS,
COMPLETED
};
@ -40,7 +40,10 @@ struct ScraperSearchParams {
};
struct ScraperSearchResult {
ScraperSearchResult() : mdl(GAME_METADATA) {};
ScraperSearchResult()
: mdl(GAME_METADATA)
{
}
MetaDataList mdl;
std::string gameID;
@ -73,34 +76,6 @@ struct ScraperSearchResult {
bool savedNewMedia;
};
// So let me explain why I've abstracted this so heavily.
// There are two ways I can think of that you'd want to write a scraper.
// 1. Do some HTTP request(s) -> process it -> return the results.
// 2. Do some local filesystem queries (an offline scraper) -> return the results.
// The first way needs to be asynchronous while it's waiting for the HTTP request to return.
// The second doesn't.
// It would be nice if we could write it like this:
// search = generate_http_request(searchparams);
// wait_until_done(search);
// ... process search ...
// return results;
// We could do this if we used threads. Right now ES doesn't because I'm pretty sure I'll
// fuck it up, and I'm not sure of the performance of threads on the Pi (single-core ARM).
// We could also do this if we used coroutines.
// I can't find a really good cross-platform coroutine library (x86/64/ARM Linux + Windows),
// and I don't want to spend more time chasing libraries than just writing it the long way once.
// So, I did it the "long" way.
// ScraperSearchHandle - one logical search, e.g. "search for mario".
// ScraperRequest - encapsulates some sort of asynchronous request that will ultimately
// return some results.
// ScraperHttpRequest - implementation of ScraperRequest that waits on an HttpReq, then
// processes it with some processing function.
// A scraper search gathers results from (potentially multiple) ScraperRequests.
class ScraperRequest : public AsyncHandle
{
@ -123,7 +98,7 @@ public:
protected:
virtual void process(const std::unique_ptr<HttpReq>& req,
std::vector<ScraperSearchResult>& results) = 0;
std::vector<ScraperSearchResult>& results) = 0;
private:
std::unique_ptr<HttpReq> mReq;
@ -133,21 +108,20 @@ private:
class ScraperSearchHandle : public AsyncHandle
{
public:
ScraperSearchHandle();
ScraperSearchHandle() { setStatus(ASYNC_IN_PROGRESS); }
void update();
inline const std::vector<ScraperSearchResult>& getResults() const
const std::vector<ScraperSearchResult>& getResults() const
{
assert(mStatus != ASYNC_IN_PROGRESS);
return mResults;
}
protected:
friend std::unique_ptr<ScraperSearchHandle>
startScraperSearch(const ScraperSearchParams& params);
friend std::unique_ptr<ScraperSearchHandle> startScraperSearch(
const ScraperSearchParams& params);
friend std::unique_ptr<ScraperSearchHandle>
startMediaURLsFetch(const std::string& gameIDs);
friend std::unique_ptr<ScraperSearchHandle> startMediaURLsFetch(const std::string& gameIDs);
std::queue<std::unique_ptr<ScraperRequest>> mRequestQueue;
std::vector<ScraperSearchResult> mResults;
@ -164,9 +138,10 @@ std::vector<std::string> getScraperList();
// Returns true if the scraper configured in the settings is still valid.
bool isValidConfiguredScraper();
typedef void (*generate_scraper_requests_func)(const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
typedef void (*generate_scraper_requests_func)(
const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
// -------------------------------------------------------------------------
@ -177,8 +152,11 @@ public:
MDResolveHandle(const ScraperSearchResult& result, const ScraperSearchParams& search);
void update() override;
inline const ScraperSearchResult& getResult() const
{ assert(mStatus == ASYNC_DONE); return mResult; }
const ScraperSearchResult& getResult() const
{
assert(mStatus == ASYNC_DONE);
return mResult;
}
bool getSavedNewMedia() { return mResult.savedNewMedia; }
private:
@ -191,13 +169,12 @@ private:
class MediaDownloadHandle : public AsyncHandle
{
public:
MediaDownloadHandle(
const std::string& url,
const std::string& path,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia);
MediaDownloadHandle(const std::string& url,
const std::string& path,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia);
void update() override;
@ -207,26 +184,26 @@ private:
std::string mExistingMediaFile;
std::string mMediaType;
bool mResizeFile;
bool *mSavedNewMediaPtr;
bool* mSavedNewMediaPtr;
};
// Downloads to the home directory, using this subdirectory structure:
// ".emulationstation/downloaded_media/[system_name]/[media_type]/[game_name].[file_extension]".
// The subdirectories are automatically created if they do not exist.
std::string getSaveAsPath(const ScraperSearchParams& params,
const std::string& filetypeSubdirectory, const std::string& url);
const std::string& filetypeSubdirectory,
const std::string& url);
std::unique_ptr<MediaDownloadHandle> downloadMediaAsync(
const std::string& url,
const std::string& saveAs,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia);
std::unique_ptr<MediaDownloadHandle> downloadMediaAsync(const std::string& url,
const std::string& saveAs,
const std::string& existingMediaPath,
const std::string& mediaType,
const bool resizeFile,
bool& savedNewMedia);
// Resolves all metadata assets that need to be downloaded.
std::unique_ptr<MDResolveHandle> resolveMetaDataAssets(const ScraperSearchResult& result,
const ScraperSearchParams& search);
const ScraperSearchParams& search);
bool resizeImage(const std::string& path, const std::string& mediaType);

324
es-app/src/scrapers/ScreenScraper.cpp
View file

@ -9,14 +9,14 @@
#include "scrapers/ScreenScraper.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include "utils/TimeUtil.h"
#include "FileData.h"
#include "Log.h"
#include "PlatformId.h"
#include "Settings.h"
#include "SystemData.h"
#include "math/Misc.h"
#include "utils/StringUtil.h"
#include "utils/TimeUtil.h"
#include <cmath>
#include <cstring>
@ -42,7 +42,7 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
{ ATARI_JAGUAR, 27 },
{ ATARI_JAGUAR_CD, 171 },
{ ATARI_LYNX, 28 },
{ ATARI_ST, 42},
{ ATARI_ST, 42 },
{ ATARI_XE, 43 },
{ ATOMISWAVE, 53 },
{ BBC_MICRO, 37 },
@ -62,7 +62,7 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
{ MSX_TURBO_R, 118 },
{ SNK_NEO_GEO, 142 },
{ SNK_NEO_GEO_CD, 142 },
{ SNK_NEO_GEO_POCKET, 25},
{ SNK_NEO_GEO_POCKET, 25 },
{ SNK_NEO_GEO_POCKET_COLOR, 82 },
{ NINTENDO_3DS, 17 },
{ NINTENDO_64, 14 },
@ -88,7 +88,7 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
{ NEC_PCFX, 72 },
{ GAMEENGINE_OPENBOR, 214 },
{ TANGERINE_ORIC, 131 },
{ GAMEENGINE_SCUMMVM, 123},
{ GAMEENGINE_SCUMMVM, 123 },
{ SEGA_32X, 19 },
{ SEGA_CD, 20 },
{ SEGA_DREAMCAST, 23 },
@ -98,8 +98,8 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
{ SEGA_MEGA_DRIVE, 1 },
{ SEGA_SATURN, 22 },
{ SEGA_SG1000, 109 },
{ SHARP_X1, 220},
{ SHARP_X68000, 79},
{ SHARP_X1, 220 },
{ SHARP_X68000, 79 },
{ GAMEENGINE_SOLARUS, 223 },
{ SONY_PLAYSTATION, 57 },
{ SONY_PLAYSTATION_2, 58 },
@ -110,8 +110,8 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
{ SUPER_NINTENDO, 4 },
{ NEC_SUPERGRAFX, 105 },
{ GAMEENGINE_TIC80, 222 },
{ NEC_PC_8800, 221},
{ NEC_PC_9800, 208},
{ NEC_PC_8800, 221 },
{ NEC_PC_9800, 208 },
{ NEC_PC_ENGINE, 31 },
{ NEC_PC_ENGINE_CD, 114 },
{ BANDAI_WONDERSWAN, 45 },
@ -131,7 +131,8 @@ const std::map<PlatformId, unsigned short> screenscraper_platformid_map {
// Helper XML parsing method, finding a node-by-name recursively.
pugi::xml_node find_node_by_name_re(const pugi::xml_node& node,
const std::vector<std::string> node_names) {
const std::vector<std::string> node_names)
{
for (const std::string& _val : node_names) {
pugi::xpath_query query_node_name((static_cast<std::string>("//") + _val).c_str());
@ -147,8 +148,9 @@ pugi::xml_node find_node_by_name_re(const pugi::xml_node& node,
// Help XML parsing method, finding an direct child XML node starting from the parent and
// filtering by an attribute value list.
pugi::xml_node find_child_by_attribute_list(const pugi::xml_node& node_parent,
const std::string& node_name, const std::string& attribute_name,
const std::vector<std::string> attribute_values)
const std::string& node_name,
const std::string& attribute_name,
const std::vector<std::string> attribute_values)
{
for (auto _val : attribute_values) {
for (pugi::xml_node node : node_parent.children(node_name.c_str())) {
@ -161,22 +163,22 @@ pugi::xml_node find_child_by_attribute_list(const pugi::xml_node& node_parent,
}
void screenscraper_generate_scraper_requests(const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results)
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results)
{
std::string path;
ScreenScraperRequest::ScreenScraperConfig ssConfig;
if (params.game->isArcadeGame())
ssConfig.isArcadeSystem = true;
ssConfig.isArcadeSystem = true;
else
ssConfig.isArcadeSystem = false;
if (params.nameOverride == "") {
if (Settings::getInstance()->getBool("ScraperSearchMetadataName"))
path = ssConfig.getGameSearchUrl(
Utils::String::removeParenthesis(params.game->metadata.get("name")));
Utils::String::removeParenthesis(params.game->metadata.get("name")));
else
path = ssConfig.getGameSearchUrl(params.game->getCleanName());
}
@ -195,19 +197,19 @@ void screenscraper_generate_scraper_requests(const ScraperSearchParams& params,
p_ids.push_back(mapIt->second);
}
else {
LOG(LogWarning) << "ScreenScraper: No support for platform \"" <<
getPlatformName(*platformIt) << "\", search will be inaccurate";
LOG(LogWarning) << "ScreenScraper: No support for platform \""
<< getPlatformName(*platformIt) << "\", search will be inaccurate";
// Add the scrape request without a platform/system ID.
requests.push(std::unique_ptr<ScraperRequest>
(new ScreenScraperRequest(requests, results, path)));
requests.push(
std::unique_ptr<ScraperRequest>(new ScreenScraperRequest(requests, results, path)));
}
}
if (p_ids.size() == 0) {
LOG(LogWarning) << "ScreenScraper: No platform defined, search will be inaccurate";
// Add the scrape request without a platform/system ID.
requests.push(std::unique_ptr<ScraperRequest>
(new ScreenScraperRequest(requests, results, path)));
requests.push(
std::unique_ptr<ScraperRequest>(new ScreenScraperRequest(requests, results, path)));
}
// Sort the platform IDs and remove duplicates.
@ -218,13 +220,13 @@ void screenscraper_generate_scraper_requests(const ScraperSearchParams& params,
for (auto platform = p_ids.cbegin(); platform != p_ids.cend(); platform++) {
path += "&systemeid=";
path += HttpReq::urlEncode(std::to_string(*platform));
requests.push(std::unique_ptr<ScraperRequest>
(new ScreenScraperRequest(requests, results, path)));
requests.push(
std::unique_ptr<ScraperRequest>(new ScreenScraperRequest(requests, results, path)));
}
}
void ScreenScraperRequest::process(const std::unique_ptr<HttpReq>& req,
std::vector<ScraperSearchResult>& results)
std::vector<ScraperSearchResult>& results)
{
assert(req->status() == HttpReq::REQ_SUCCESS);
@ -263,7 +265,7 @@ void ScreenScraperRequest::process(const std::unique_ptr<HttpReq>& req,
std::string gameName = Utils::String::toUpper((*it).mdl.get("name"));
if (gameName.substr(0, 12) == "ZZZ(NOTGAME)") {
LOG(LogWarning) << "ScreenScraperRequest - Received \"ZZZ(notgame)\" as game name, "
"ignoring response";
"ignoring response";
results.pop_back();
return;
}
@ -271,7 +273,7 @@ void ScreenScraperRequest::process(const std::unique_ptr<HttpReq>& req,
}
void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
std::vector<ScraperSearchResult>& out_results)
std::vector<ScraperSearchResult>& out_results)
{
pugi::xml_node data = xmldoc.child("Data");
@ -280,17 +282,18 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
// also seems to correlate with missing scraper allowance data. This is however a scraper
// service issue so we're not attempting to compensate for it here.
if (Settings::getInstance()->getBool("ScraperUseAccountScreenScraper") &&
Settings::getInstance()->getString("ScraperUsernameScreenScraper") != "" &&
Settings::getInstance()->getString("ScraperPasswordScreenScraper") != "") {
Settings::getInstance()->getString("ScraperUsernameScreenScraper") != "" &&
Settings::getInstance()->getString("ScraperPasswordScreenScraper") != "") {
std::string userID = data.child("ssuser").child("id").text().get();
if (userID != "") {
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Scraping using account \"" <<
userID << "\"";
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Scraping using account \""
<< userID << "\"";
}
else {
LOG(LogDebug) << "ScreenScraperRequest::processGame(): The configured account '" <<
Settings::getInstance()->getString("ScraperUsernameScreenScraper") <<
"' was not included in the scraper response, wrong username or password?";
LOG(LogDebug)
<< "ScreenScraperRequest::processGame(): The configured account '"
<< Settings::getInstance()->getString("ScraperUsernameScreenScraper")
<< "' was not included in the scraper response, wrong username or password?";
}
}
@ -304,17 +307,17 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
// Scraping allowance.
if (maxRequestsPerDay > 0) {
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Daily scraping allowance: " <<
requestsToday << "/" << maxRequestsPerDay << " (" <<
scraperRequestAllowance << " remaining)";
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Daily scraping allowance: "
<< requestsToday << "/" << maxRequestsPerDay << " ("
<< scraperRequestAllowance << " remaining)";
}
else {
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Daily scraping allowance: "
"No statistics were provided with the response";
"No statistics were provided with the response";
}
if (data.child("jeux"))
data = data.child("jeux");
data = data.child("jeux");
for (pugi::xml_node game = data.child("jeu"); game; game = game.next_sibling("jeu")) {
ScraperSearchResult result;
@ -324,13 +327,16 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
result.gameID = game.attribute("id").as_string();
std::string region =
Utils::String::toLower(Settings::getInstance()->getString("ScraperRegion"));
Utils::String::toLower(Settings::getInstance()->getString("ScraperRegion"));
std::string language =
Utils::String::toLower(Settings::getInstance()->getString("ScraperLanguage"));
Utils::String::toLower(Settings::getInstance()->getString("ScraperLanguage"));
// Name fallback: US, WOR(LD). (Xpath: Data/jeu[0]/noms/nom[*]).
result.mdl.set("name", find_child_by_attribute_list(game.child("noms"),
"nom", "region", { region, "wor", "us" , "ss", "eu", "jp" }).text().get());
result.mdl.set("name",
find_child_by_attribute_list(game.child("noms"), "nom", "region",
{ region, "wor", "us", "ss", "eu", "jp" })
.text()
.get());
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Name: " << result.mdl.get("name");
// Validate rating.
@ -346,14 +352,16 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
ss << ratingVal;
if (ratingVal > 0) {
result.mdl.set("rating", ss.str());
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Rating: " <<
result.mdl.get("rating");
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Rating: "
<< result.mdl.get("rating");
}
}
// Description fallback language: EN, WOR(LD).
std::string description = find_child_by_attribute_list(game.child("synopsis"),
"synopsis", "langue", { language, "en", "wor" }).text().get();
std::string description = find_child_by_attribute_list(game.child("synopsis"), "synopsis",
"langue", { language, "en", "wor" })
.text()
.get();
// Translate some HTML character codes to UTF-8 characters.
if (!description.empty()) {
@ -362,80 +370,83 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
}
// Get the date proper. The API returns multiple 'date' children nodes to the 'dates'
// main child of 'jeu'.
// Date fallback: WOR(LD), US, SS, JP, EU.
// main child of 'jeu'. Date fallback: WOR(LD), US, SS, JP, EU.
std::string _date = find_child_by_attribute_list(game.child("dates"), "date", "region",
{ region, "wor", "us", "ss", "jp", "eu" }).text().get();
{ region, "wor", "us", "ss", "jp", "eu" })
.text()
.get();
// Date can be YYYY-MM-DD or just YYYY.
if (_date.length() > 4) {
result.mdl.set("releasedate", Utils::Time::DateTime(
Utils::Time::stringToTime(_date, "%Y-%m-%d")));
result.mdl.set("releasedate",
Utils::Time::DateTime(Utils::Time::stringToTime(_date, "%Y-%m-%d")));
}
else if (_date.length() > 0) {
result.mdl.set("releasedate", Utils::Time::DateTime(
Utils::Time::stringToTime(_date, "%Y")));
result.mdl.set("releasedate",
Utils::Time::DateTime(Utils::Time::stringToTime(_date, "%Y")));
}
if (_date.length() > 0) {
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Release Date (unparsed): " <<
_date;
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Release Date (parsed): " <<
result.mdl.get("releasedate");
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Release Date (unparsed): "
<< _date;
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Release Date (parsed): "
<< result.mdl.get("releasedate");
}
// Developer for the game (Xpath: Data/jeu[0]/developpeur).
std::string developer = game.child("developpeur").text().get();
if (!developer.empty()) {
result.mdl.set("developer", Utils::String::replace(developer, "&nbsp;", " "));
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Developer: " <<
result.mdl.get("developer");
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Developer: "
<< result.mdl.get("developer");
}
// Publisher for the game (Xpath: Data/jeu[0]/editeur).
std::string publisher = game.child("editeur").text().get();
if (!publisher.empty()) {
result.mdl.set("publisher", Utils::String::replace(publisher, "&nbsp;", " "));
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Publisher: " <<
result.mdl.get("publisher");
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Publisher: "
<< result.mdl.get("publisher");
}
// Genre fallback language: EN. (Xpath: Data/jeu[0]/genres/genre[*]).
std::string genre = find_child_by_attribute_list(game.child("genres"),
"genre", "langue", { language, "en" }).text().get();
std::string genre = find_child_by_attribute_list(game.child("genres"), "genre", "langue",
{ language, "en" })
.text()
.get();
if (!genre.empty()) {
result.mdl.set("genre", genre);
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Genre: " <<
result.mdl.get("genre");
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Genre: "
<< result.mdl.get("genre");
}
// Players.
std::string players = game.child("joueurs").text().get();
if (!players.empty()) {
result.mdl.set("players", players);
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Players: " <<
result.mdl.get("players");
LOG(LogDebug) << "ScreenScraperRequest::processGame(): Players: "
<< result.mdl.get("players");
}
// Media super-node.
pugi::xml_node media_list = game.child("medias");
if (media_list) {
// 3D box
processMedia(result, media_list, ssConfig.media_3dbox,
result.box3DUrl, result.box3DFormat, region);
// Cover
processMedia(result, media_list, ssConfig.media_cover,
result.coverUrl, result.coverFormat, region);
// Marquee (wheel)
processMedia(result, media_list, ssConfig.media_marquee,
result.marqueeUrl, result.marqueeFormat, region);
// Screenshot
processMedia(result, media_list, ssConfig.media_screenshot,
result.screenshotUrl, result.screenshotFormat, region);
// Video
processMedia(result, media_list, ssConfig.media_video,
result.videoUrl, result.videoFormat, region);
// 3D box.
processMedia(result, media_list, ssConfig.media_3dbox, result.box3DUrl,
result.box3DFormat, region);
// Cover.
processMedia(result, media_list, ssConfig.media_cover, result.coverUrl,
result.coverFormat, region);
// Marquee (wheel).
processMedia(result, media_list, ssConfig.media_marquee, result.marqueeUrl,
result.marqueeFormat, region);
// Screenshot.
processMedia(result, media_list, ssConfig.media_screenshot, result.screenshotUrl,
result.screenshotFormat, region);
// Video.
processMedia(result, media_list, ssConfig.media_video, result.videoUrl,
result.videoFormat, region);
}
result.mediaURLFetch = COMPLETED;
out_results.push_back(result);
@ -446,13 +457,12 @@ void ScreenScraperRequest::processGame(const pugi::xml_document& xmldoc,
}
}
void ScreenScraperRequest::processMedia(
ScraperSearchResult& result,
const pugi::xml_node& media_list,
std::string mediaType,
std::string& fileURL,
std::string& fileFormat,
std::string region)
void ScreenScraperRequest::processMedia(ScraperSearchResult& result,
const pugi::xml_node& media_list,
std::string mediaType,
std::string& fileURL,
std::string& fileFormat,
std::string region)
{
pugi::xml_node art = pugi::xml_node(nullptr);
@ -460,51 +470,52 @@ void ScreenScraperRequest::processMedia(
// We need to do this because any child of 'medias' has the form
// <media type="..." region="..." format="...">
// and we need to find the right media for the region.
pugi::xpath_node_set results = media_list.select_nodes((static_cast<std::string>
("media[@type='") + mediaType + "']").c_str());
pugi::xpath_node_set results = media_list.select_nodes(
(static_cast<std::string>("media[@type='") + mediaType + "']").c_str());
if (results.size()) {
// Videos don't have any region attributes, so just take the first entry
// (which should be the only entry as well).
if (mediaType == "video" || mediaType == "video-normalized") {
art = results.first().node();
}
else {
// Region fallback: WOR(LD), US, CUS(TOM?), JP, EU.
for (auto _region : std::vector<std::string>{
region, "wor", "us", "cus", "jp", "eu" }) {
if (art)
if (results.size()) {
// Videos don't have any region attributes, so just take the first entry
// (which should be the only entry as well).
if (mediaType == "video" || mediaType == "video-normalized") {
art = results.first().node();
}
else {
// Region fallback: WOR(LD), US, CUS(TOM?), JP, EU.
for (auto _region :
std::vector<std::string> { region, "wor", "us", "cus", "jp", "eu" }) {
if (art)
break;
for (auto node : results) {
if (node.node().attribute("region").value() == _region) {
art = node.node();
break;
for (auto node : results) {
if (node.node().attribute("region").value() == _region) {
art = node.node();
break;
}
}
}
}
}
}
if (art) {
// Sending a 'softname' containing space will make the media URLs returned
// by the API also contain the space. Escape any spaces in the URL here.
fileURL = Utils::String::replace(art.text().get(), " ", "%20");
if (art) {
// Sending a 'softname' containing space will make the media URLs returned
// by the API also contain the space. Escape any spaces in the URL here.
fileURL = Utils::String::replace(art.text().get(), " ", "%20");
// Get the media type returned by ScreenScraper.
std::string media_type = art.attribute("format").value();
if (!media_type.empty())
fileFormat = "." + media_type;
}
else {
LOG(LogDebug) << "ScreenScraperRequest::processMedia(): "
"Failed to find media XML node with name '" << mediaType << "'";
}
// Get the media type returned by ScreenScraper.
std::string media_type = art.attribute("format").value();
if (!media_type.empty())
fileFormat = "." + media_type;
}
else {
LOG(LogDebug) << "ScreenScraperRequest::processMedia(): "
"Failed to find media XML node with name '"
<< mediaType << "'";
}
}
// Currently not used in this module.
void ScreenScraperRequest::processList(const pugi::xml_document& xmldoc,
std::vector<ScraperSearchResult>& results)
std::vector<ScraperSearchResult>& results)
{
assert(mRequestQueue != nullptr);
@ -527,18 +538,18 @@ void ScreenScraperRequest::processList(const pugi::xml_document& xmldoc,
std::string id = game.child("id").text().get();
std::string name = game.child("nom").text().get();
std::string platformId = game.child("systemeid").text().get();
std::string path = ssConfig.getGameSearchUrl(name) + "&systemeid=" +
platformId + "&gameid=" + id;
std::string path =
ssConfig.getGameSearchUrl(name) + "&systemeid=" + platformId + "&gameid=" + id;
mRequestQueue->push(std::unique_ptr<ScraperRequest>
(new ScreenScraperRequest(results, path)));
mRequestQueue->push(
std::unique_ptr<ScraperRequest>(new ScreenScraperRequest(results, path)));
game = game.next_sibling("jeu");
}
}
std::string ScreenScraperRequest::ScreenScraperConfig::getGameSearchUrl(
const std::string gameName) const
const std::string gameName) const
{
std::string screenScraperURL;
std::string searchName = gameName;
@ -546,12 +557,14 @@ std::string ScreenScraperRequest::ScreenScraperConfig::getGameSearchUrl(
// Trim leading and trailing whitespaces.
searchName.erase(searchName.begin(),
std::find_if(searchName.begin(), searchName.end(), [](char c) {
return !std::isspace(static_cast<unsigned char>(c));
}));
searchName.erase(std::find_if(searchName.rbegin(), searchName.rend(), [](char c) {
return !std::isspace(static_cast<unsigned char>(c));
}).base(), searchName.end());
std::find_if(searchName.begin(), searchName.end(), [](char c) {
return !std::isspace(static_cast<unsigned char>(c));
}));
searchName.erase(
std::find_if(searchName.rbegin(), searchName.rend(),
[](char c) { return !std::isspace(static_cast<unsigned char>(c)); })
.base(),
searchName.end());
// If only whitespaces were entered as the search string, then search using a random string
// that will not return any results. This is a quick and dirty way to avoid french error
@ -578,9 +591,10 @@ std::string ScreenScraperRequest::ScreenScraperConfig::getGameSearchUrl(
// than four characters which would break the wide search.
std::string trimTrailingPluses = searchName;
trimTrailingPluses.erase(std::find_if(trimTrailingPluses.rbegin(),
trimTrailingPluses.rend(), [](char c) {
return c != '+';
}).base(), trimTrailingPluses.end());
trimTrailingPluses.rend(),
[](char c) { return c != '+'; })
.base(),
trimTrailingPluses.end());
if (trimTrailingPluses.size() < 4)
singleSearch = true;
@ -589,12 +603,12 @@ std::string ScreenScraperRequest::ScreenScraperConfig::getGameSearchUrl(
// could also lead to an error for short game names.
if (!singleSearch) {
std::string removeThe =
Utils::String::replace(Utils::String::toUpper(searchName), "THE ", "");
Utils::String::replace(Utils::String::toUpper(searchName), "THE ", "");
// Any additional spaces must also be removed.
removeThe.erase(removeThe.begin(),
std::find_if(removeThe.begin(), removeThe.end(), [](char c) {
return !std::isspace(static_cast<unsigned char>(c));
}));
std::find_if(removeThe.begin(), removeThe.end(), [](char c) {
return !std::isspace(static_cast<unsigned char>(c));
}));
// If "the" is placed at the end of the search string, ScreenScraper also removes it.
if (removeThe.size() > 4) {
if (removeThe.substr(removeThe.size() - 4, 4) == " THE")
@ -605,20 +619,18 @@ std::string ScreenScraperRequest::ScreenScraperConfig::getGameSearchUrl(
}
if (singleSearch) {
screenScraperURL = API_URL_BASE
+ "/jeuInfos.php?devid=" + Utils::String::scramble(API_DEV_U, API_DEV_KEY)
+ "&devpassword=" + Utils::String::scramble(API_DEV_P, API_DEV_KEY)
+ "&softname=" + HttpReq::urlEncode(API_SOFT_NAME)
+ "&output=xml"
+ "&romnom=" + HttpReq::urlEncode(searchName);
screenScraperURL = API_URL_BASE + "/jeuInfos.php?devid=" +
Utils::String::scramble(API_DEV_U, API_DEV_KEY) +
"&devpassword=" + Utils::String::scramble(API_DEV_P, API_DEV_KEY) +
"&softname=" + HttpReq::urlEncode(API_SOFT_NAME) + "&output=xml" +
"&romnom=" + HttpReq::urlEncode(searchName);
}
else {
screenScraperURL = API_URL_BASE
+ "/jeuRecherche.php?devid=" + Utils::String::scramble(API_DEV_U, API_DEV_KEY)
+ "&devpassword=" + Utils::String::scramble(API_DEV_P, API_DEV_KEY)
+ "&softname=" + HttpReq::urlEncode(API_SOFT_NAME)
+ "&output=xml"
+ "&recherche=" + HttpReq::urlEncode(searchName);
screenScraperURL = API_URL_BASE + "/jeuRecherche.php?devid=" +
Utils::String::scramble(API_DEV_U, API_DEV_KEY) +
"&devpassword=" + Utils::String::scramble(API_DEV_P, API_DEV_KEY) +
"&softname=" + HttpReq::urlEncode(API_SOFT_NAME) + "&output=xml" +
"&recherche=" + HttpReq::urlEncode(searchName);
}
// Username / password, if this has been setup and activated.
@ -626,8 +638,8 @@ std::string ScreenScraperRequest::ScreenScraperConfig::getGameSearchUrl(
std::string username = Settings::getInstance()->getString("ScraperUsernameScreenScraper");
std::string password = Settings::getInstance()->getString("ScraperPasswordScreenScraper");
if (!username.empty() && !password.empty())
screenScraperURL += "&ssid=" + HttpReq::urlEncode(username) + "&sspassword=" +
HttpReq::urlEncode(password);
screenScraperURL += "&ssid=" + HttpReq::urlEncode(username) +
"&sspassword=" + HttpReq::urlEncode(password);
}
return screenScraperURL;

65
es-app/src/scrapers/ScreenScraper.h
View file

@ -10,49 +10,54 @@
#ifndef ES_APP_SCRAPERS_SCREEN_SCRAPER_H
#define ES_APP_SCRAPERS_SCREEN_SCRAPER_H
#include "scrapers/Scraper.h"
#include "EmulationStation.h"
#include "scrapers/Scraper.h"
namespace pugi { class xml_document; }
namespace pugi
{
class xml_document;
}
void screenscraper_generate_scraper_requests(
const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
void screenscraper_generate_scraper_requests(const ScraperSearchParams& params,
std::queue<std::unique_ptr<ScraperRequest>>& requests,
std::vector<ScraperSearchResult>& results);
class ScreenScraperRequest : public ScraperHttpRequest
{
public:
// ctor for a GetGameList request.
ScreenScraperRequest(std::queue<std::unique_ptr<ScraperRequest>>& requestsWrite,
std::vector<ScraperSearchResult>& resultsWrite,
const std::string& url) : ScraperHttpRequest(resultsWrite, url),
mRequestQueue(&requestsWrite) {}
std::vector<ScraperSearchResult>& resultsWrite,
const std::string& url)
: ScraperHttpRequest(resultsWrite, url)
, mRequestQueue(&requestsWrite)
{
}
// ctor for a GetGame request.
ScreenScraperRequest(std::vector<ScraperSearchResult>& resultsWrite,
const std::string& url) : ScraperHttpRequest(resultsWrite, url),
mRequestQueue(nullptr) {}
ScreenScraperRequest(std::vector<ScraperSearchResult>& resultsWrite, const std::string& url)
: ScraperHttpRequest(resultsWrite, url)
, mRequestQueue(nullptr)
{
}
// Settings for the scraper.
static const struct ScreenScraperConfig {
std::string getGameSearchUrl(const std::string gameName) const;
// Access to the API.
const std::string API_DEV_U =
{ 15, 21, 39, 22, 42, 40 };
const std::string API_DEV_P =
{ 32, 70, 46, 54, 12, 5, 13, 120, 50, 66, 25 };
const std::string API_DEV_KEY =
{ 67, 112, 72, 120, 121, 77, 119, 74, 84, 56, 75, 122, 78, 98, 69, 86, 56, 120, 120, 49 };
const std::string API_DEV_U = { 15, 21, 39, 22, 42, 40 };
const std::string API_DEV_P = { 32, 70, 46, 54, 12, 5, 13, 120, 50, 66, 25 };
const std::string API_DEV_KEY = { 67, 112, 72, 120, 121, 77, 119, 74, 84, 56,
75, 122, 78, 98, 69, 86, 56, 120, 120, 49 };
const std::string API_URL_BASE = "https://www.screenscraper.fr/api2";
const std::string API_SOFT_NAME = "EmulationStation-DE " +
static_cast<std::string>(PROGRAM_VERSION_STRING);
const std::string API_SOFT_NAME =
"EmulationStation-DE " + static_cast<std::string>(PROGRAM_VERSION_STRING);
// Which type of image artwork we need. Possible values (not a comprehensive list):
// - ss: in-game screenshot
// - box-3D: 3D boxart
// - box-2D: 2D boxart (default)
// - box-2D: 2D boxart
// - screenmarque : marquee
// - sstitle: in-game start screenshot
// - steamgrid: Steam artwork
@ -75,27 +80,27 @@ public:
// Which Region to use when selecting the artwork.
// Applies to: artwork, name of the game, date of release.
// This is read from es_settings.xml, setting 'ScraperRegion'.
// This is read from es_settings.xml, setting "ScraperRegion".
// Which Language to use when selecting the textual information.
// Applies to: description, genre.
// This is read from es_settings.xml, setting 'ScraperLanguage'.
// This is read from es_settings.xml, setting "ScraperLanguage".
ScreenScraperConfig() {};
ScreenScraperConfig() {}
} configuration;
protected:
void process(const std::unique_ptr<HttpReq>& req,
std::vector<ScraperSearchResult>& results) override;
std::vector<ScraperSearchResult>& results) override;
void processList(const pugi::xml_document& xmldoc, std::vector<ScraperSearchResult>& results);
void processGame(const pugi::xml_document& xmldoc, std::vector<ScraperSearchResult>& results);
void processMedia(ScraperSearchResult& result,
const pugi::xml_node& media_list,
std::string mediaType,
std::string& fileURL,
std::string& fileFormat,
std::string region);
const pugi::xml_node& media_list,
std::string mediaType,
std::string& fileURL,
std::string& fileFormat,
std::string region);
bool isGameRequest() { return !mRequestQueue; }
std::queue<std::unique_ptr<ScraperRequest>>* mRequestQueue;

416
es-app/src/views/SystemView.cpp
View file

@ -8,15 +8,15 @@
#include "views/SystemView.h"
#include "animations/LambdaAnimation.h"
#include "guis/GuiMsgBox.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "Log.h"
#include "Settings.h"
#include "Sound.h"
#include "SystemData.h"
#include "Window.h"
#include "animations/LambdaAnimation.h"
#include "guis/GuiMsgBox.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#if defined(_WIN64)
#include <cmath>
@ -26,14 +26,12 @@
const int logoBuffersLeft[] = { -5, -2, -1 };
const int logoBuffersRight[] = { 1, 2, 5 };
SystemView::SystemView(
Window* window)
: IList<SystemViewData, SystemData*>
(window, LIST_SCROLL_STYLE_SLOW, LIST_ALWAYS_LOOP),
mPreviousScrollVelocity(0),
mUpdatedGameCount(false),
mViewNeedsReload(true),
mSystemInfo(window, "SYSTEM INFO", Font::get(FONT_SIZE_SMALL), 0x33333300, ALIGN_CENTER)
SystemView::SystemView(Window* window)
: IList<SystemViewData, SystemData*>(window, LIST_SCROLL_STYLE_SLOW, LIST_ALWAYS_LOOP)
, mPreviousScrollVelocity(0)
, mUpdatedGameCount(false)
, mViewNeedsReload(true)
, mSystemInfo(window, "SYSTEM INFO", Font::get(FONT_SIZE_SMALL), 0x33333300, ALIGN_CENTER)
{
mCamOffset = 0;
mExtrasCamOffset = 0;
@ -58,8 +56,8 @@ void SystemView::populate()
{
mEntries.clear();
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
const std::shared_ptr<ThemeData>& theme = (*it)->getTheme();
if (mViewNeedsReload)
@ -74,11 +72,11 @@ void SystemView::populate()
const ThemeData::ThemeElement* logoElem = theme->getElement("system", "logo", "image");
if (logoElem) {
std::string path = logoElem->get<std::string>("path");
std::string defaultPath = logoElem->has("default") ?
logoElem->get<std::string>("default") : "";
std::string defaultPath =
logoElem->has("default") ? logoElem->get<std::string>("default") : "";
if ((!path.empty() && ResourceManager::getInstance()->fileExists(path)) ||
(!defaultPath.empty() &&
ResourceManager::getInstance()->fileExists(defaultPath))) {
(!defaultPath.empty() &&
ResourceManager::getInstance()->fileExists(defaultPath))) {
ImageComponent* logo = new ImageComponent(mWindow, false, false);
logo->setMaxSize(mCarousel.logoSize * mCarousel.logoScale);
logo->applyTheme(theme, "system", "logo", ThemeFlags::PATH | ThemeFlags::COLOR);
@ -88,16 +86,14 @@ void SystemView::populate()
}
if (!e.data.logo) {
// No logo in theme; use text.
TextComponent* text = new TextComponent(
mWindow,
(*it)->getName(),
Font::get(FONT_SIZE_LARGE),
0x000000FF,
ALIGN_CENTER);
TextComponent* text =
new TextComponent(mWindow, (*it)->getName(), Font::get(FONT_SIZE_LARGE),
0x000000FF, ALIGN_CENTER);
text->setSize(mCarousel.logoSize * mCarousel.logoScale);
text->applyTheme((*it)->getTheme(), "system", "logoText",
ThemeFlags::FONT_PATH | ThemeFlags::FONT_SIZE | ThemeFlags::COLOR |
ThemeFlags::FORCE_UPPERCASE | ThemeFlags::LINE_SPACING | ThemeFlags::TEXT);
ThemeFlags::FONT_PATH | ThemeFlags::FONT_SIZE | ThemeFlags::COLOR |
ThemeFlags::FORCE_UPPERCASE | ThemeFlags::LINE_SPACING |
ThemeFlags::TEXT);
e.data.logo = std::shared_ptr<GuiComponent>(text);
if (mCarousel.type == VERTICAL || mCarousel.type == VERTICAL_WHEEL) {
@ -134,10 +130,9 @@ void SystemView::populate()
e.data.backgroundExtras = ThemeData::makeExtras((*it)->getTheme(), "system", mWindow);
// Sort the extras by z-index.
std::stable_sort(e.data.backgroundExtras.begin(), e.data.backgroundExtras.end(),
[](GuiComponent* a, GuiComponent* b) {
return b->getZIndex() > a->getZIndex();
});
std::stable_sort(
e.data.backgroundExtras.begin(), e.data.backgroundExtras.end(),
[](GuiComponent* a, GuiComponent* b) { return b->getZIndex() > a->getZIndex(); });
this->add(e);
}
@ -146,9 +141,10 @@ void SystemView::populate()
// Something is wrong, there is not a single system to show, check if UI mode is not full.
if (!UIModeController::getInstance()->isUIModeFull()) {
Settings::getInstance()->setString("UIMode", "full");
mWindow->pushGui(new GuiMsgBox(mWindow, getHelpStyle(),
"The selected UI mode has nothing to show,\n returning to UI mode \"Full\"",
"OK", nullptr));
mWindow->pushGui(new GuiMsgBox(
mWindow, getHelpStyle(),
"The selected UI mode has nothing to show,\n returning to UI mode \"Full\"", "OK",
nullptr));
}
}
}
@ -162,14 +158,14 @@ void SystemView::updateGameCount()
ss << "CONFIGURATION";
else if (getSelected()->isCollection() && (getSelected()->getName() == "favorites"))
ss << gameCount.first << " GAME" << (gameCount.first == 1 ? " " : "S");
// The 'recent' gamelist has probably been trimmed after sorting, so we'll cap it at
// The "recent" gamelist has probably been trimmed after sorting, so we'll cap it at
// its maximum limit of 50 games.
else if (getSelected()->isCollection() && (getSelected()->getName() == "recent"))
ss << (gameCount.first > 50 ? 50 : gameCount.first) << " GAME" <<
(gameCount.first == 1 ? " " : "S");
ss << (gameCount.first > 50 ? 50 : gameCount.first) << " GAME"
<< (gameCount.first == 1 ? " " : "S");
else
ss << gameCount.first << " GAME" << (gameCount.first == 1 ? " " : "S ") << "(" <<
gameCount.second << " FAVORITE" << (gameCount.second == 1 ? ")" : "S)");
ss << gameCount.first << " GAME" << (gameCount.first == 1 ? " " : "S ") << "("
<< gameCount.second << " FAVORITE" << (gameCount.second == 1 ? ")" : "S)");
mSystemInfo.setText(ss.str());
}
@ -190,40 +186,40 @@ bool SystemView::input(InputConfig* config, Input input)
if (input.value != 0) {
if (config->getDeviceId() == DEVICE_KEYBOARD && input.value && input.id == SDLK_r &&
SDL_GetModState() & KMOD_LCTRL && Settings::getInstance()->getBool("Debug")) {
SDL_GetModState() & KMOD_LCTRL && Settings::getInstance()->getBool("Debug")) {
LOG(LogDebug) << "SystemView::input(): Reloading all";
ViewController::get()->reloadAll();
return true;
}
switch (mCarousel.type) {
case VERTICAL:
case VERTICAL_WHEEL:
if (config->isMappedLike("up", input)) {
ViewController::get()->cancelViewTransitions();
listInput(-1);
return true;
}
if (config->isMappedLike("down", input)) {
ViewController::get()->cancelViewTransitions();
listInput(1);
return true;
}
break;
case HORIZONTAL:
case HORIZONTAL_WHEEL:
default:
if (config->isMappedLike("left", input)) {
ViewController::get()->cancelViewTransitions();
listInput(-1);
return true;
}
if (config->isMappedLike("right", input)) {
ViewController::get()->cancelViewTransitions();
listInput(1);
return true;
}
break;
case VERTICAL:
case VERTICAL_WHEEL:
if (config->isMappedLike("up", input)) {
ViewController::get()->cancelViewTransitions();
listInput(-1);
return true;
}
if (config->isMappedLike("down", input)) {
ViewController::get()->cancelViewTransitions();
listInput(1);
return true;
}
break;
case HORIZONTAL:
case HORIZONTAL_WHEEL:
default:
if (config->isMappedLike("left", input)) {
ViewController::get()->cancelViewTransitions();
listInput(-1);
return true;
}
if (config->isMappedLike("right", input)) {
ViewController::get()->cancelViewTransitions();
listInput(1);
return true;
}
break;
}
if (config->isMappedTo("a", input)) {
@ -233,17 +229,16 @@ bool SystemView::input(InputConfig* config, Input input)
return true;
}
if (Settings::getInstance()->getBool("RandomAddButton") &&
(config->isMappedTo("leftthumbstickclick", input) ||
config->isMappedTo("rightthumbstickclick", input))) {
(config->isMappedTo("leftthumbstickclick", input) ||
config->isMappedTo("rightthumbstickclick", input))) {
// Get a random system and jump to it.
NavigationSounds::getInstance()->playThemeNavigationSound(SYSTEMBROWSESOUND);
setCursor(SystemData::getRandomSystem(getSelected()));
return true;
}
if (!UIModeController::getInstance()->isUIModeKid() &&
config->isMappedTo("back", input) &&
Settings::getInstance()->getBool("ScreensaverControls")) {
if (!UIModeController::getInstance()->isUIModeKid() && config->isMappedTo("back", input) &&
Settings::getInstance()->getBool("ScreensaverControls")) {
if (!mWindow->isScreensaverActive()) {
ViewController::get()->stopScrolling();
ViewController::get()->cancelViewTransitions();
@ -254,10 +249,8 @@ bool SystemView::input(InputConfig* config, Input input)
}
}
else {
if (config->isMappedLike("left", input) ||
config->isMappedLike("right", input) ||
config->isMappedLike("up", input) ||
config->isMappedLike("down", input))
if (config->isMappedLike("left", input) || config->isMappedLike("right", input) ||
config->isMappedLike("up", input) || config->isMappedLike("down", input))
listInput(0);
}
@ -302,8 +295,7 @@ void SystemView::onCursorChanged(const CursorState& /*state*/)
std::string transition_style = Settings::getInstance()->getString("TransitionStyle");
// To prevent ugly jumps with two systems when quickly repeating the same direction.
if (mPreviousScrollVelocity != 0 && posMax == 2 &&
mScrollVelocity == mPreviousScrollVelocity ) {
if (mPreviousScrollVelocity != 0 && posMax == 2 && mScrollVelocity == mPreviousScrollVelocity) {
if (fabs(endPos - startPos) < 0.5 || fabs(endPos - startPos) > 1.5) {
(mScrollVelocity < 0) ? endPos -= 1 : endPos += 1;
(mCursor == 0) ? mCursor = 1 : mCursor = 0;
@ -321,77 +313,84 @@ void SystemView::onCursorChanged(const CursorState& /*state*/)
if (transition_style == "fade") {
float startExtrasFade = mExtrasFadeOpacity;
anim = new LambdaAnimation(
[this, startExtrasFade, startPos, endPos, posMax](float t) {
t -= 1;
float f = Math::lerp(startPos, endPos, t*t*t + 1);
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
[this, startExtrasFade, startPos, endPos, posMax](float t) {
t -= 1;
float f = Math::lerp(startPos, endPos, t * t * t + 1);
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
this->mCamOffset = f;
this->mCamOffset = f;
t += 1;
if (t < 0.3f)
this->mExtrasFadeOpacity = Math::lerp(0.0f, 1.0f, t / 0.2f + startExtrasFade);
else if (t < 0.7f)
this->mExtrasFadeOpacity = 1.0f;
else
this->mExtrasFadeOpacity = Math::lerp(1.0f, 0.0f, (t - 0.6f) / 0.3f);
t += 1;
if (t < 0.3f)
this->mExtrasFadeOpacity = Math::lerp(0.0f, 1.0f, t / 0.2f + startExtrasFade);
else if (t < 0.7f)
this->mExtrasFadeOpacity = 1.0f;
else
this->mExtrasFadeOpacity = Math::lerp(1.0f, 0.0f, (t - 0.6f) / 0.3f);
if (t > 0.5f)
this->mExtrasCamOffset = endPos;
if (t > 0.5f)
this->mExtrasCamOffset = endPos;
// Update the game count when the entire animation has been completed.
if (mExtrasFadeOpacity == 1.0)
updateGameCount();
}, 500);
// Update the game count when the entire animation has been completed.
if (mExtrasFadeOpacity == 1.0f)
updateGameCount();
},
500);
}
else if (transition_style == "slide") {
mUpdatedGameCount = false;
anim = new LambdaAnimation(
[this, startPos, endPos, posMax](float t) {
t -= 1;
float f = Math::lerp(startPos, endPos, t*t*t + 1);
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
[this, startPos, endPos, posMax](float t) {
t -= 1;
float f = Math::lerp(startPos, endPos, t * t * t + 1);
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
this->mCamOffset = f;
this->mExtrasCamOffset = f;
this->mCamOffset = f;
this->mExtrasCamOffset = f;
// Hack to make the game count being updated in the middle of the animation.
bool update = false;
if (endPos == -1 && fabs(fabs(posMax) - fabs(mCamOffset)) > 0.5 && !mUpdatedGameCount)
update = true;
else if (endPos > posMax && fabs(endPos - posMax - fabs(mCamOffset)) <
0.5 && !mUpdatedGameCount)
update = true;
else if (fabs(fabs(endPos) - fabs(mCamOffset)) < 0.5 && !mUpdatedGameCount)
update = true;
// Hack to make the game count being updated in the middle of the animation.
bool update = false;
if (endPos == -1.0f && fabs(fabs(posMax) - fabs(mCamOffset)) > 0.5f &&
!mUpdatedGameCount) {
update = true;
}
else if (endPos > posMax && fabs(endPos - posMax - fabs(mCamOffset)) < 0.5f &&
!mUpdatedGameCount) {
update = true;
}
else if (fabs(fabs(endPos) - fabs(mCamOffset)) < 0.5f && !mUpdatedGameCount) {
update = true;
}
if (update) {
mUpdatedGameCount = true;
updateGameCount();
}
}, 500);
if (update) {
mUpdatedGameCount = true;
updateGameCount();
}
},
500);
}
else {
// Instant.
updateGameCount();
anim = new LambdaAnimation(
[this, startPos, endPos, posMax](float t) {
t -= 1;
float f = Math::lerp(startPos, endPos, t*t*t + 1);
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
[this, startPos, endPos, posMax](float t) {
t -= 1;
float f = Math::lerp(startPos, endPos, t * t * t + 1);
if (f < 0)
f += posMax;
if (f >= posMax)
f -= posMax;
this->mCamOffset = f;
this->mExtrasCamOffset = endPos;
}, 500);
this->mCamOffset = f;
this->mExtrasCamOffset = endPos;
},
500);
}
setAnimation(anim, 0, nullptr, false, 0);
@ -400,7 +399,7 @@ void SystemView::onCursorChanged(const CursorState& /*state*/)
void SystemView::render(const Transform4x4f& parentTrans)
{
if (size() == 0)
return; // Nothing to render.
return; // Nothing to render.
Transform4x4f trans = getTransform() * parentTrans;
@ -430,7 +429,7 @@ std::vector<HelpPrompt> SystemView::getHelpPrompts()
prompts.push_back(HelpPrompt("thumbstickclick", "random"));
if (!UIModeController::getInstance()->isUIModeKid() &&
Settings::getInstance()->getBool("ScreensaverControls"))
Settings::getInstance()->getBool("ScreensaverControls"))
prompts.push_back(HelpPrompt("back", "toggle screensaver"));
return prompts;
@ -443,7 +442,7 @@ HelpStyle SystemView::getHelpStyle()
return style;
}
void SystemView::onThemeChanged(const std::shared_ptr<ThemeData>& /*theme*/)
void SystemView::onThemeChanged(const std::shared_ptr<ThemeData>& /*theme*/)
{
LOG(LogDebug) << "SystemView::onThemeChanged()";
mViewNeedsReload = true;
@ -451,7 +450,7 @@ void SystemView::onThemeChanged(const std::shared_ptr<ThemeData>& /*theme*/)
}
// Get the ThemeElements that make up the SystemView.
void SystemView::getViewElements(const std::shared_ptr<ThemeData>& theme)
void SystemView::getViewElements(const std::shared_ptr<ThemeData>& theme)
{
LOG(LogDebug) << "SystemView::getViewElements()";
@ -460,13 +459,14 @@ void SystemView::getViewElements(const std::shared_ptr<ThemeData>& theme)
if (!theme->hasView("system"))
return;
const ThemeData::ThemeElement* carouselElem = theme->
getElement("system", "systemcarousel", "carousel");
const ThemeData::ThemeElement* carouselElem =
theme->getElement("system", "systemcarousel", "carousel");
if (carouselElem)
getCarouselFromTheme(carouselElem);
const ThemeData::ThemeElement* sysInfoElem = theme->
getElement("system", "systemInfo", "text");
const ThemeData::ThemeElement* sysInfoElem = theme->getElement("system", "systemInfo", "text");
if (sysInfoElem)
mSystemInfo.applyTheme(theme, "system", "systemInfo", ThemeFlags::ALL);
@ -479,71 +479,79 @@ void SystemView::renderCarousel(const Transform4x4f& trans)
// Background box behind logos.
Transform4x4f carouselTrans = trans;
carouselTrans.translate(Vector3f(mCarousel.pos.x(), mCarousel.pos.y(), 0.0));
carouselTrans.translate(Vector3f(mCarousel.origin.x() * mCarousel.size.x() * -1,
mCarousel.origin.y() * mCarousel.size.y() * -1, 0.0f));
carouselTrans.translate(Vector3f(mCarousel.origin.x() * mCarousel.size.x() * -1.0f,
mCarousel.origin.y() * mCarousel.size.y() * -1.0f, 0.0f));
Vector2f clipPos(carouselTrans.translation().x(), carouselTrans.translation().y());
Renderer::pushClipRect(Vector2i(static_cast<int>(clipPos.x()), static_cast<int>(clipPos.y())),
Vector2i(static_cast<int>(mCarousel.size.x()), static_cast<int>(mCarousel.size.y())));
Renderer::pushClipRect(
Vector2i(static_cast<int>(clipPos.x()), static_cast<int>(clipPos.y())),
Vector2i(static_cast<int>(mCarousel.size.x()), static_cast<int>(mCarousel.size.y())));
Renderer::setMatrix(carouselTrans);
Renderer::drawRect(0.0f, 0.0f, mCarousel.size.x(), mCarousel.size.y(),
mCarousel.color, mCarousel.colorEnd, mCarousel.colorGradientHorizontal);
Renderer::drawRect(0.0f, 0.0f, mCarousel.size.x(), mCarousel.size.y(), mCarousel.color,
mCarousel.colorEnd, mCarousel.colorGradientHorizontal);
// Draw logos.
// Note: logoSpacing will also include the size of the logo itself.
Vector2f logoSpacing(0.0, 0.0);
float xOff = 0.0;
float yOff = 0.0;
Vector2f logoSpacing(0.0f, 0.0f);
float xOff = 0.0f;
float yOff = 0.0f;
switch (mCarousel.type) {
case VERTICAL_WHEEL:
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.f -
(mCamOffset * logoSpacing[1]);
case VERTICAL_WHEEL: {
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f -
(mCamOffset * logoSpacing[1]);
if (mCarousel.logoAlignment == ALIGN_LEFT)
xOff = mCarousel.logoSize.x() / 10.f;
xOff = mCarousel.logoSize.x() / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_RIGHT)
xOff = mCarousel.size.x() - (mCarousel.logoSize.x() * 1.1f);
else
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.f;
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f;
break;
case VERTICAL:
logoSpacing[1] = ((mCarousel.size.y() - (mCarousel.logoSize.y() *
mCarousel.maxLogoCount)) / (mCarousel.maxLogoCount)) + mCarousel.logoSize.y();
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.f -
(mCamOffset * logoSpacing[1]);
}
case VERTICAL: {
logoSpacing[1] =
((mCarousel.size.y() - (mCarousel.logoSize.y() * mCarousel.maxLogoCount)) /
(mCarousel.maxLogoCount)) +
mCarousel.logoSize.y();
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f -
(mCamOffset * logoSpacing[1]);
if (mCarousel.logoAlignment == ALIGN_LEFT)
xOff = mCarousel.logoSize.x() / 10.f;
xOff = mCarousel.logoSize.x() / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_RIGHT)
xOff = mCarousel.size.x() - (mCarousel.logoSize.x() * 1.1f);
else
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2;
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f;
break;
case HORIZONTAL_WHEEL:
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2 -
(mCamOffset * logoSpacing[1]);
}
case HORIZONTAL_WHEEL: {
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f -
(mCamOffset * logoSpacing[1]);
if (mCarousel.logoAlignment == ALIGN_TOP)
yOff = mCarousel.logoSize.y() / 10;
yOff = mCarousel.logoSize.y() / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_BOTTOM)
yOff = mCarousel.size.y() - (mCarousel.logoSize.y() * 1.1f);
else
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2;
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f;
break;
case HORIZONTAL:
default:
logoSpacing[0] = ((mCarousel.size.x() - (mCarousel.logoSize.x() *
mCarousel.maxLogoCount)) / (mCarousel.maxLogoCount)) + mCarousel.logoSize.x();
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.f -
(mCamOffset * logoSpacing[0]);
}
case HORIZONTAL: {
}
default: {
logoSpacing[0] =
((mCarousel.size.x() - (mCarousel.logoSize.x() * mCarousel.maxLogoCount)) /
(mCarousel.maxLogoCount)) +
mCarousel.logoSize.x();
xOff = (mCarousel.size.x() - mCarousel.logoSize.x()) / 2.0f -
(mCamOffset * logoSpacing[0]);
if (mCarousel.logoAlignment == ALIGN_TOP)
yOff = mCarousel.logoSize.y() / 10.f;
yOff = mCarousel.logoSize.y() / 10.0f;
else if (mCarousel.logoAlignment == ALIGN_BOTTOM)
yOff = mCarousel.size.y() - (mCarousel.logoSize.y() * 1.1f);
else
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.f;
yOff = (mCarousel.size.y() - mCarousel.logoSize.y()) / 2.0f;
break;
}
}
int center = static_cast<int>(mCamOffset);
@ -558,9 +566,10 @@ void SystemView::renderCarousel(const Transform4x4f& trans)
bufferRight = 0;
}
for (int i = center - logoCount / 2 + bufferLeft;
i <= center + logoCount / 2 + bufferRight; i++) {
for (int i = center - logoCount / 2 + bufferLeft; // Line break.
i <= center + logoCount / 2 + bufferRight; i++) {
int index = i;
while (index < 0)
index += static_cast<int>(mEntries.size());
while (index >= static_cast<int>(mEntries.size()))
@ -575,11 +584,11 @@ void SystemView::renderCarousel(const Transform4x4f& trans)
scale = std::min(mCarousel.logoScale, std::max(1.0f, scale));
scale /= mCarousel.logoScale;
int opacity = static_cast<int>(std::round(0x80 + ((0xFF - 0x80) *
(1.0f - fabs(distance)))));
int opacity =
static_cast<int>(std::round(0x80 + ((0xFF - 0x80) * (1.0f - fabs(distance)))));
opacity = std::max(static_cast<int>(0x80), opacity);
const std::shared_ptr<GuiComponent> &comp = mEntries.at(index).data.logo;
const std::shared_ptr<GuiComponent>& comp = mEntries.at(index).data.logo;
if (mCarousel.type == VERTICAL_WHEEL || mCarousel.type == HORIZONTAL_WHEEL) {
comp->setRotationDegrees(mCarousel.logoRotation * distance);
comp->setRotationOrigin(mCarousel.logoRotationOrigin);
@ -599,11 +608,11 @@ void SystemView::renderExtras(const Transform4x4f& trans, float lower, float upp
// Adding texture loading buffers depending on scrolling speed and status.
int bufferIndex = getScrollingVelocity() + 1;
Renderer::pushClipRect(Vector2i::Zero(), Vector2i(static_cast<int>(mSize.x()),
static_cast<int>(mSize.y())));
Renderer::pushClipRect(Vector2i::Zero(),
Vector2i(static_cast<int>(mSize.x()), static_cast<int>(mSize.y())));
for (int i = extrasCenter + logoBuffersLeft[bufferIndex]; i <= extrasCenter +
logoBuffersRight[bufferIndex]; i++) {
for (int i = extrasCenter + logoBuffersLeft[bufferIndex];
i <= extrasCenter + logoBuffersRight[bufferIndex]; i++) {
int index = i;
while (index < 0)
index += static_cast<int>(mEntries.size());
@ -611,20 +620,20 @@ void SystemView::renderExtras(const Transform4x4f& trans, float lower, float upp
index -= static_cast<int>(mEntries.size());
// Only render selected system when not showing.
if (mShowing || index == mCursor)
{
if (mShowing || index == mCursor) {
Transform4x4f extrasTrans = trans;
if (mCarousel.type == HORIZONTAL || mCarousel.type == HORIZONTAL_WHEEL)
extrasTrans.translate(Vector3f((i - mExtrasCamOffset) * mSize.x(), 0, 0));
else
extrasTrans.translate(Vector3f(0, (i - mExtrasCamOffset) * mSize.y(), 0));
Renderer::pushClipRect(Vector2i(static_cast<int>(extrasTrans.translation()[0]),
static_cast<int>(extrasTrans.translation()[1])),
Vector2i(static_cast<int>(mSize.x()), static_cast<int>(mSize.y())));
Renderer::pushClipRect(
Vector2i(static_cast<int>(extrasTrans.translation()[0]),
static_cast<int>(extrasTrans.translation()[1])),
Vector2i(static_cast<int>(mSize.x()), static_cast<int>(mSize.y())));
SystemViewData data = mEntries.at(index).data;
for (unsigned int j = 0; j < data.backgroundExtras.size(); j++) {
GuiComponent *extra = data.backgroundExtras[j];
GuiComponent* extra = data.backgroundExtras[j];
if (extra->getZIndex() >= lower && extra->getZIndex() < upper)
extra->render(extrasTrans);
}
@ -637,13 +646,13 @@ void SystemView::renderExtras(const Transform4x4f& trans, float lower, float upp
void SystemView::renderFade(const Transform4x4f& trans)
{
unsigned int fadeColor = 0x00000000 | static_cast<unsigned char>(mExtrasFadeOpacity * 255);
unsigned int fadeColor = 0x00000000 | static_cast<unsigned char>(mExtrasFadeOpacity * 255.0f);
Renderer::setMatrix(trans);
Renderer::drawRect(0.0f, 0.0f, mSize.x(), mSize.y(), fadeColor, fadeColor);
}
// Populate the system carousel with the legacy values.
void SystemView::getDefaultElements(void)
void SystemView::getDefaultElements(void)
{
// Carousel.
mCarousel.type = HORIZONTAL;
@ -658,13 +667,13 @@ void SystemView::getDefaultElements(void)
mCarousel.colorEnd = 0xFFFFFFD8;
mCarousel.colorGradientHorizontal = true;
mCarousel.logoScale = 1.2f;
mCarousel.logoRotation = 7.5;
mCarousel.logoRotationOrigin.x() = -5;
mCarousel.logoRotationOrigin.y() = 0.5;
mCarousel.logoRotation = 7.5f;
mCarousel.logoRotationOrigin.x() = -5.0f;
mCarousel.logoRotationOrigin.y() = 0.5f;
mCarousel.logoSize.x() = 0.25f * mSize.x();
mCarousel.logoSize.y() = 0.155f * mSize.y();
mCarousel.maxLogoCount = 3;
mCarousel.zIndex = 40;
mCarousel.zIndex = 40.0f;
// System info bar.
mSystemInfo.setSize(mSize.x(), mSystemInfo.getFont()->getLetterHeight() * 2.2f);
@ -702,7 +711,8 @@ void SystemView::getCarouselFromTheme(const ThemeData::ThemeElement* elem)
if (elem->has("colorEnd"))
mCarousel.colorEnd = elem->get<unsigned int>("colorEnd");
if (elem->has("gradientType"))
mCarousel.colorGradientHorizontal = !(elem->get<std::string>("gradientType").compare("horizontal"));
mCarousel.colorGradientHorizontal =
!(elem->get<std::string>("gradientType").compare("horizontal"));
if (elem->has("logoScale"))
mCarousel.logoScale = elem->get<float>("logoScale");
if (elem->has("logoSize"))
@ -727,14 +737,4 @@ void SystemView::getCarouselFromTheme(const ThemeData::ThemeElement* elem)
else
mCarousel.logoAlignment = ALIGN_CENTER;
}
}
void SystemView::onShow()
{
mShowing = true;
}
void SystemView::onHide()
{
mShowing = false;
}
}

16
es-app/src/views/SystemView.h
View file

@ -9,11 +9,11 @@
#ifndef ES_APP_VIEWS_SYSTEM_VIEW_H
#define ES_APP_VIEWS_SYSTEM_VIEW_H
#include "GuiComponent.h"
#include "Sound.h"
#include "components/IList.h"
#include "components/TextComponent.h"
#include "resources/Font.h"
#include "GuiComponent.h"
#include "Sound.h"
#include <memory>
@ -55,8 +55,8 @@ public:
SystemView(Window* window);
~SystemView();
virtual void onShow() override;
virtual void onHide() override;
virtual void onShow() override { mShowing = true; }
virtual void onHide() override { mShowing = false; }
void goToSystem(SystemData* system, bool animate);
@ -69,12 +69,14 @@ public:
std::vector<HelpPrompt> getHelpPrompts() override;
virtual HelpStyle getHelpStyle() override;
CarouselType getCarouselType() { return mCarousel.type; };
CarouselType getCarouselType() { return mCarousel.type; }
protected:
void onCursorChanged(const CursorState& state) override;
virtual void onScroll() override {
NavigationSounds::getInstance()->playThemeNavigationSound(SYSTEMBROWSESOUND); }
virtual void onScroll() override
{
NavigationSounds::getInstance()->playThemeNavigationSound(SYSTEMBROWSESOUND);
}
private:
void populate();

38
es-app/src/views/UIModeController.cpp
View file

@ -9,12 +9,12 @@
#include "UIModeController.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
#include "FileFilterIndex.h"
#include "Log.h"
#include "SystemData.h"
#include "Window.h"
#include "utils/StringUtil.h"
#include "views/ViewController.h"
UIModeController* UIModeController::sInstance = nullptr;
@ -34,7 +34,8 @@ void UIModeController::deinit()
}
}
UIModeController::UIModeController() : mPassKeyCounter(0)
UIModeController::UIModeController()
: mPassKeyCounter(0)
{
mPassKeySequence = Settings::getInstance()->getString("UIMode_passkey");
mCurrentUIMode = Settings::getInstance()->getString("UIMode");
@ -47,13 +48,12 @@ void UIModeController::monitorUIMode()
if (uimode != mCurrentUIMode && !ViewController::get()->isCameraMoving()) {
mCurrentUIMode = uimode;
// Reset filters and sort gamelists (which will update the game counter).
for (auto it = SystemData::sSystemVector.cbegin(); it !=
SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
(*it)->sortSystem(true);
(*it)->getIndex()->resetFilters();
if ((*it)->getThemeFolder() == "custom-collections") {
for (FileData* customSystem :
(*it)->getRootFolder()->getChildrenListToDisplay())
for (FileData* customSystem : (*it)->getRootFolder()->getChildrenListToDisplay())
customSystem->getSystem()->getIndex()->resetFilters();
}
}
@ -75,6 +75,7 @@ bool UIModeController::listen(InputConfig* config, Input input)
unlockUIMode();
return true;
}
return false;
}
@ -101,21 +102,21 @@ void UIModeController::unlockUIMode()
bool UIModeController::isUIModeFull()
{
return ((mCurrentUIMode == "full" || (isUIModeKid() &&
Settings::getInstance()->getBool("EnableMenuKidMode")))
&& !Settings::getInstance()->getBool("ForceKiosk"));
return ((mCurrentUIMode == "full" ||
(isUIModeKid() && Settings::getInstance()->getBool("EnableMenuKidMode"))) &&
!Settings::getInstance()->getBool("ForceKiosk"));
}
bool UIModeController::isUIModeKid()
{
return (Settings::getInstance()->getBool("ForceKid") ||
((mCurrentUIMode == "kid") && !Settings::getInstance()->getBool("ForceKiosk")));
((mCurrentUIMode == "kid") && !Settings::getInstance()->getBool("ForceKiosk")));
}
bool UIModeController::isUIModeKiosk()
{
return (Settings::getInstance()->getBool("ForceKiosk") ||
((mCurrentUIMode == "kiosk") && !Settings::getInstance()->getBool("ForceKid")));
((mCurrentUIMode == "kiosk") && !Settings::getInstance()->getBool("ForceKid")));
}
std::string UIModeController::getFormattedPassKeyStr()
@ -124,7 +125,7 @@ std::string UIModeController::getFormattedPassKeyStr()
std::string out = "";
for (auto c : mPassKeySequence) {
out += (out == "") ? "" : " , "; // Add commas between the entries.
out += (out == "") ? "" : " , "; // Add commas between the entries.
std::string controllerType = Settings::getInstance()->getString("InputControllerType");
std::string symbolA;
@ -139,12 +140,19 @@ std::string UIModeController::getFormattedPassKeyStr()
symbolY = "X";
}
else if (controllerType == "ps4" || controllerType == "ps5") {
#if defined(_MSC_VER) // MSVC compiler.
// These symbols are far from perfect but you can at least understand what
// they are supposed to depict.
symbolA = Utils::String::wideStringToString(L"\uF00D"); // Cross.
symbolB = Utils::String::wideStringToString(L"\uF111"); // Circle
symbolX = Utils::String::wideStringToString(L"\uF04D"); // Square.
symbolY = Utils::String::wideStringToString(L"\uF0D8"); // Triangle.
#else
symbolA = "\uF00D"; // Cross.
symbolB = "\uF111"; // Circle
symbolX = "\uF04D"; // Square.
symbolY = "\uF0D8"; // Triangle.
#endif
}
else {
// Xbox controller.
@ -186,8 +194,8 @@ std::string UIModeController::getFormattedPassKeyStr()
bool UIModeController::isValidInput(InputConfig* config, Input input)
{
if ((config->getMappedTo(input).size() == 0) || // Not a mapped input, so ignore it.
(!input.value)) // Not a key-down event.
if ((config->getMappedTo(input).size() == 0) || // Not a mapped input, so ignore it.
(!input.value)) // Not a key-down event.
return false;
else
return true;

7
es-app/src/views/UIModeController.h
View file

@ -39,7 +39,7 @@ public:
bool isUIModeKid();
bool isUIModeKiosk();
void setCurrentUIMode(const std::string& mode) { mCurrentUIMode = mode; };
void setCurrentUIMode(const std::string& mode) { mCurrentUIMode = mode; }
private:
UIModeController();
@ -58,8 +58,9 @@ private:
int mPassKeyCounter;
// These are Xbox button names, so they may be different in pracise on non-Xbox controllers.
const std::vector<std::string> mInputVals =
{ "up", "down", "left", "right", "a", "b", "x", "y" };
const std::vector<std::string> mInputVals = {
"up", "down", "left", "right", "a", "b", "x", "y"
};
};
#endif // ES_APP_VIEWS_UI_MODE_CONTROLLER_H

331
es-app/src/views/ViewController.cpp
View file

@ -12,17 +12,6 @@
#include "views/ViewController.h"
#include "animations/Animation.h"
#include "animations/LambdaAnimation.h"
#include "animations/MoveCameraAnimation.h"
#include "guis/GuiInfoPopup.h"
#include "guis/GuiMenu.h"
#include "views/gamelist/DetailedGameListView.h"
#include "views/gamelist/GridGameListView.h"
#include "views/gamelist/IGameListView.h"
#include "views/gamelist/VideoGameListView.h"
#include "views/SystemView.h"
#include "views/UIModeController.h"
#include "AudioManager.h"
#include "FileFilterIndex.h"
#include "InputManager.h"
@ -32,8 +21,20 @@
#include "SystemData.h"
#include "SystemView.h"
#include "Window.h"
#include "animations/Animation.h"
#include "animations/LambdaAnimation.h"
#include "animations/MoveCameraAnimation.h"
#include "guis/GuiInfoPopup.h"
#include "guis/GuiMenu.h"
#include "views/SystemView.h"
#include "views/UIModeController.h"
#include "views/gamelist/DetailedGameListView.h"
#include "views/gamelist/GridGameListView.h"
#include "views/gamelist/IGameListView.h"
#include "views/gamelist/VideoGameListView.h"
ViewController* ViewController::sInstance = nullptr;
#if defined(_MSC_VER) // MSVC compiler.
const std::string ViewController::FAVORITE_CHAR = Utils::String::wideStringToString(L"\uF005");
const std::string ViewController::FOLDER_CHAR = Utils::String::wideStringToString(L"\uF07C");
@ -60,21 +61,20 @@ void ViewController::init(Window* window)
sInstance = new ViewController(window);
}
ViewController::ViewController(
Window* window)
: GuiComponent(window),
mCurrentView(nullptr),
mPreviousView(nullptr),
mSkipView(nullptr),
mCamera(Transform4x4f::Identity()),
mSystemViewTransition(false),
mWrappedViews(false),
mFadeOpacity(0),
mCancelledTransition(false),
mLockInput(false),
mNextSystem(false),
mGameToLaunch(nullptr),
mNoGamesMessageBox(nullptr)
ViewController::ViewController(Window* window)
: GuiComponent(window)
, mCurrentView(nullptr)
, mPreviousView(nullptr)
, mSkipView(nullptr)
, mCamera(Transform4x4f::Identity())
, mSystemViewTransition(false)
, mWrappedViews(false)
, mFadeOpacity(0)
, mCancelledTransition(false)
, mLockInput(false)
, mNextSystem(false)
, mGameToLaunch(nullptr)
, mNoGamesMessageBox(nullptr)
{
mState.viewing = NOTHING;
mState.viewstyle = AUTOMATIC;
@ -89,108 +89,106 @@ ViewController::~ViewController()
void ViewController::invalidSystemsFileDialog()
{
std::string errorMessage =
"COULDN'T PARSE THE SYSTEMS CONFIGURATION FILE.\n"
"IF YOU HAVE A CUSTOMIZED es_systems.xml FILE, THEN\n"
"SOMETHING IS LIKELY WRONG WITH YOUR XML SYNTAX.\n"
"IF YOU DON'T HAVE A CUSTOM SYSTEMS FILE, THEN THE\n"
"EMULATIONSTATION INSTALLATION IS BROKEN. SEE THE\n"
"APPLICATION LOG FILE es_log.txt FOR ADDITIONAL INFO.";
std::string errorMessage = "COULDN'T PARSE THE SYSTEMS CONFIGURATION FILE.\n"
"IF YOU HAVE A CUSTOMIZED es_systems.xml FILE, THEN\n"
"SOMETHING IS LIKELY WRONG WITH YOUR XML SYNTAX.\n"
"IF YOU DON'T HAVE A CUSTOM SYSTEMS FILE, THEN THE\n"
"EMULATIONSTATION INSTALLATION IS BROKEN. SEE THE\n"
"APPLICATION LOG FILE es_log.txt FOR ADDITIONAL INFO.";
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
errorMessage.c_str(),
"QUIT", [] {
SDL_Event quit;
quit.type = SDL_QUIT;
SDL_PushEvent(&quit);
}, "", nullptr, "", nullptr, true));
mWindow->pushGui(new GuiMsgBox(
mWindow, HelpStyle(), errorMessage.c_str(), "QUIT",
[] {
SDL_Event quit;
quit.type = SDL_QUIT;
SDL_PushEvent(&quit);
},
"", nullptr, "", nullptr, true));
}
void ViewController::noGamesDialog()
{
mNoGamesErrorMessage =
"NO GAME FILES WERE FOUND. EITHER PLACE YOUR GAMES IN\n"
"THE CURRENTLY CONFIGURED ROM DIRECTORY OR CHANGE\n"
"ITS PATH USING THE BUTTON BELOW. OPTIONALLY THE ROM\n"
"DIRECTORY STRUCTURE CAN BE GENERATED WHICH WILL\n"
"CREATE A TEXT FILE FOR EACH SYSTEM PROVIDING SOME\n"
"INFORMATION SUCH AS THE SUPPORTED FILE EXTENSIONS.\n"
"THIS IS THE CURRENTLY CONFIGURED ROM DIRECTORY:\n";
mNoGamesErrorMessage = "NO GAME FILES WERE FOUND. EITHER PLACE YOUR GAMES IN\n"
"THE CURRENTLY CONFIGURED ROM DIRECTORY OR CHANGE\n"
"ITS PATH USING THE BUTTON BELOW. OPTIONALLY THE ROM\n"
"DIRECTORY STRUCTURE CAN BE GENERATED WHICH WILL\n"
"CREATE A TEXT FILE FOR EACH SYSTEM PROVIDING SOME\n"
"INFORMATION SUCH AS THE SUPPORTED FILE EXTENSIONS.\n"
"THIS IS THE CURRENTLY CONFIGURED ROM DIRECTORY:\n";
#if defined(_WIN64)
#if defined(_WIN64)
mRomDirectory = Utils::String::replace(FileData::getROMDirectory(), "/", "\\");
#else
#else
mRomDirectory = FileData::getROMDirectory();
#endif
#endif
mNoGamesMessageBox = new GuiMsgBox(mWindow, HelpStyle(), mNoGamesErrorMessage + mRomDirectory,
"CHANGE ROM DIRECTORY", [this] {
std::string currentROMDirectory;
#if defined(_WIN64)
currentROMDirectory = Utils::String::replace(FileData::getROMDirectory(), "/", "\\");
#else
currentROMDirectory = FileData::getROMDirectory();
#endif
mNoGamesMessageBox = new GuiMsgBox(
mWindow, HelpStyle(), mNoGamesErrorMessage + mRomDirectory, "CHANGE ROM DIRECTORY",
[this] {
std::string currentROMDirectory;
#if defined(_WIN64)
currentROMDirectory = Utils::String::replace(FileData::getROMDirectory(), "/", "\\");
#else
currentROMDirectory = FileData::getROMDirectory();
#endif
mWindow->pushGui(new GuiComplexTextEditPopup(
mWindow,
HelpStyle(),
"ENTER ROM DIRECTORY PATH",
"Currently configured path:",
currentROMDirectory,
currentROMDirectory,
mWindow->pushGui(new GuiComplexTextEditPopup(
mWindow, HelpStyle(), "ENTER ROM DIRECTORY PATH",
"Currently configured path:", currentROMDirectory, currentROMDirectory,
[this](const std::string& newROMDirectory) {
Settings::getInstance()->setString("ROMDirectory", newROMDirectory);
Settings::getInstance()->saveFile();
#if defined(_WIN64)
#if defined(_WIN64)
mRomDirectory = Utils::String::replace(FileData::getROMDirectory(), "/", "\\");
#else
#else
mRomDirectory = FileData::getROMDirectory();
#endif
#endif
mNoGamesMessageBox->changeText(mNoGamesErrorMessage + mRomDirectory);
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
"ROM DIRECTORY SETTING SAVED, RESTART\n"
"THE APPLICATION TO RESCAN THE SYSTEMS",
"OK", nullptr, "", nullptr, "", nullptr, true));
"ROM DIRECTORY SETTING SAVED, RESTART\n"
"THE APPLICATION TO RESCAN THE SYSTEMS",
"OK", nullptr, "", nullptr, "", nullptr, true));
},
false,
"SAVE",
"SAVE CHANGES?",
"LOAD CURRENT",
"LOAD CURRENTLY CONFIGURED VALUE",
"CLEAR",
"CLEAR (LEAVE BLANK TO RESET TO DEFAULT DIRECTORY)",
false));
},
"CREATE DIRECTORIES", [this] {
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
false, "SAVE", "SAVE CHANGES?", "LOAD CURRENT", "LOAD CURRENTLY CONFIGURED VALUE",
"CLEAR", "CLEAR (LEAVE BLANK TO RESET TO DEFAULT DIRECTORY)", false));
},
"CREATE DIRECTORIES",
[this] {
mWindow->pushGui(new GuiMsgBox(
mWindow, HelpStyle(),
"THIS WILL CREATE DIRECTORIES FOR ALL THE\n"
"GAME SYSTEMS DEFINED IN es_systems.xml\n\n"
"THIS MAY CREATE A LOT OF FOLDERS SO IT'S\n"
"ADVICED TO REMOVE THE ONES YOU DON'T NEED\n\n"
"PROCEED?",
"YES", [this] {
if (!SystemData::createSystemDirectories()) {
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
"THE SYSTEM DIRECTORIES WERE SUCCESSFULLY\n"
"GENERATED, EXIT THE APPLICATION AND PLACE\n"
"YOUR GAMES IN THE NEWLY CREATED FOLDERS", "OK", nullptr,
"", nullptr, "", nullptr, true));
}
else {
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
"ERROR CREATING THE SYSTEM DIRECTORIES,\n"
"PERMISSION PROBLEMS OR DISK FULL?\n\n"
"SEE THE LOG FILE FOR MORE DETAILS", "OK", nullptr,
"", nullptr, "", nullptr, true));
}
}, "NO", nullptr, "", nullptr, true));
},
"QUIT", [] {
SDL_Event quit;
quit.type = SDL_QUIT;
SDL_PushEvent(&quit);
}, true, false);
"YES",
[this] {
if (!SystemData::createSystemDirectories()) {
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
"THE SYSTEM DIRECTORIES WERE SUCCESSFULLY\n"
"GENERATED, EXIT THE APPLICATION AND PLACE\n"
"YOUR GAMES IN THE NEWLY CREATED FOLDERS",
"OK", nullptr, "", nullptr, "", nullptr,
true));
}
else {
mWindow->pushGui(new GuiMsgBox(mWindow, HelpStyle(),
"ERROR CREATING THE SYSTEM DIRECTORIES,\n"
"PERMISSION PROBLEMS OR DISK FULL?\n\n"
"SEE THE LOG FILE FOR MORE DETAILS",
"OK", nullptr, "", nullptr, "", nullptr,
true));
}
},
"NO", nullptr, "", nullptr, true));
},
"QUIT",
[] {
SDL_Event quit;
quit.type = SDL_QUIT;
SDL_PushEvent(&quit);
},
true, false);
mWindow->pushGui(mNoGamesMessageBox);
}
@ -205,8 +203,8 @@ void ViewController::goToStart()
// If a specific system is requested, go directly to its game list.
auto requestedSystem = Settings::getInstance()->getString("StartupSystem");
if ("" != requestedSystem && "retropie" != requestedSystem) {
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it++) {
for (auto it = SystemData::sSystemVector.cbegin(); // Line break.
it != SystemData::sSystemVector.cend(); it++) {
if ((*it)->getName() == requestedSystem) {
goToGameList(*it);
return;
@ -237,7 +235,7 @@ bool ViewController::isCameraMoving()
{
if (mCurrentView) {
if (mCamera.r3().x() - -mCurrentView->getPosition().x() != 0 ||
mCamera.r3().y() - -mCurrentView->getPosition().y() != 0)
mCamera.r3().y() - -mCurrentView->getPosition().y() != 0)
return true;
}
return false;
@ -322,7 +320,7 @@ void ViewController::goToSystemView(SystemData* system, bool playTransition)
auto systemList = getSystemListView();
systemList->setPosition(getSystemId(system) * static_cast<float>(Renderer::getScreenWidth()),
systemList->getPosition().y());
systemList->getPosition().y());
systemList->goToSystem(system, false);
mCurrentView = systemList;
@ -333,7 +331,7 @@ void ViewController::goToSystemView(SystemData* system, bool playTransition)
mCamera.translation() = -mCurrentView->getPosition();
if (Settings::getInstance()->getString("TransitionStyle") == "slide") {
if (getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL ||
getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL_WHEEL)
getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL_WHEEL)
mCamera.translation().y() += Renderer::getScreenHeight();
else
mCamera.translation().x() -= Renderer::getScreenWidth();
@ -341,7 +339,7 @@ void ViewController::goToSystemView(SystemData* system, bool playTransition)
}
else if (Settings::getInstance()->getString("TransitionStyle") == "fade") {
if (getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL ||
getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL_WHEEL)
getSystemListView()->getCarouselType() == CarouselType::HORIZONTAL_WHEEL)
mCamera.translation().y() += Renderer::getScreenHeight();
else
mCamera.translation().x() += Renderer::getScreenWidth();
@ -396,14 +394,20 @@ void ViewController::goToGameList(SystemData* system)
restoreViewPosition();
if (mPreviousView && Settings::getInstance()->getString("TransitionStyle") == "fade" &&
isAnimationPlaying(0))
isAnimationPlaying(0)) {
mPreviousView->onHide();
}
if (mPreviousView) {
mSkipView = mPreviousView;
mPreviousView.reset();
mPreviousView = nullptr;
}
else if (!mPreviousView && mState.viewing == GAME_LIST) {
// This is needed as otherwise the static image would not get rendered during the
// first Slide transition when coming from the System view.
mSkipView = getGameListView(system);
}
if (mState.viewing != SYSTEM_SELECT) {
mPreviousView = mCurrentView;
@ -444,7 +448,7 @@ void ViewController::goToGameList(SystemData* system)
int sysId = getSystemId(system);
sysList->setPosition(sysId * static_cast<float>(Renderer::getScreenWidth()),
sysList->getPosition().y());
sysList->getPosition().y());
offsetX = sysList->getPosition().x() - offsetX;
mCamera.translation().x() -= offsetX;
}
@ -459,7 +463,7 @@ void ViewController::goToGameList(SystemData* system)
float offsetX = getGameListView(system)->getPosition().x();
// This is needed to move the camera in the correct direction if there are only two systems.
if (SystemData::sSystemVector.size() == 2 && mNextSystem)
offsetX -= Renderer::getScreenWidth();
offsetX -= Renderer::getScreenWidth();
else
offsetX += Renderer::getScreenWidth();
currentPosition.x() = offsetX;
@ -536,11 +540,13 @@ void ViewController::playViewTransition(bool instant)
std::string transition_style = Settings::getInstance()->getString("TransitionStyle");
if (instant || transition_style == "instant") {
setAnimation(new LambdaAnimation([this, target](float /*t*/) {
this->mCamera.translation() = -target;
if (mPreviousView)
mPreviousView->onHide();
}, 1));
setAnimation(new LambdaAnimation(
[this, target](float /*t*/) {
this->mCamera.translation() = -target;
if (mPreviousView)
mPreviousView->onHide();
},
1));
updateHelpPrompts();
}
else if (transition_style == "fade") {
@ -553,7 +559,7 @@ void ViewController::playViewTransition(bool instant)
// Without this, a (much shorter) fade transition would still play as
// finishedCallback is calling this function.
if (!mCancelledTransition)
mFadeOpacity = Math::lerp(0, 1, t);
mFadeOpacity = Math::lerp(0.0f, 1.0f, t);
};
auto fadeCallback = [this]() {
@ -564,12 +570,12 @@ void ViewController::playViewTransition(bool instant)
const static int FADE_DURATION = 120; // Fade in/out time.
const static int FADE_WAIT = 200; // Time to wait between in/out.
setAnimation(new LambdaAnimation(fadeFunc, FADE_DURATION), 0,
[this, fadeFunc, fadeCallback, target] {
this->mCamera.translation() = -target;
updateHelpPrompts();
setAnimation(new LambdaAnimation(fadeFunc, FADE_DURATION),
FADE_WAIT, fadeCallback, true);
});
[this, fadeFunc, fadeCallback, target] {
this->mCamera.translation() = -target;
updateHelpPrompts();
setAnimation(new LambdaAnimation(fadeFunc, FADE_DURATION), FADE_WAIT,
fadeCallback, true);
});
// Fast-forward animation if we're partway faded.
if (target == -mCamera.translation()) {
@ -611,7 +617,7 @@ bool ViewController::runInBackground(SystemData* system)
// with the game. In that situation ES-DE would wait until the whole Steam application was
// shut down before it would resume. I.e. it would not be enough to just stop the game.
if (system->hasPlatformId(PlatformIds::VALVE_STEAM) ||
Settings::getInstance()->getBool("RunInBackground"))
Settings::getInstance()->getBool("RunInBackground"))
return true;
else
return false;
@ -641,8 +647,9 @@ void ViewController::launch(FileData* game)
if (durationString == "disabled") {
// If the game launch screen has been set as disabled, show a simple info popup
// notification instead.
GuiInfoPopup* s = new GuiInfoPopup(mWindow, "LAUNCHING GAME '" +
Utils::String::toUpper(game->metadata.get("name") + "'"), 10000);
GuiInfoPopup* s = new GuiInfoPopup(
mWindow, "LAUNCHING GAME '" + Utils::String::toUpper(game->metadata.get("name") + "'"),
10000);
mWindow->setInfoPopup(s);
duration = 1700;
}
@ -665,16 +672,14 @@ void ViewController::launch(FileData* game)
// This is just a dummy animation in order for the launch screen or notification popup
// to be displayed briefly, and for the navigation sound playing to be able to complete.
// During this time period, all user input is blocked.
setAnimation(new LambdaAnimation([](float t){}, duration), 0, [this, game] {
setAnimation(new LambdaAnimation([](float t) {}, duration), 0, [this, game] {
game->launchGame(mWindow);
// If the launch screen is disabled then this will do nothing.
mWindow->closeLaunchScreen();
onFileChanged(game, true);
// This is a workaround so that any keys or button presses used for exiting the emulator
// are not captured upon returning.
setAnimation(new LambdaAnimation([](float t){}, 1), 0, [this] {
mLockInput = false;
});
setAnimation(new LambdaAnimation([](float t) {}, 1), 0, [this] { mLockInput = false; });
});
}
@ -728,38 +733,41 @@ std::shared_ptr<IGameListView> ViewController::getGameListView(SystemData* syste
}
// Create the view.
switch (selectedViewStyle)
{
case VIDEO:
switch (selectedViewStyle) {
case VIDEO: {
view = std::shared_ptr<IGameListView>(
new VideoGameListView(mWindow, system->getRootFolder()));
new VideoGameListView(mWindow, system->getRootFolder()));
mState.viewstyle = VIDEO;
break;
case DETAILED:
}
case DETAILED: {
view = std::shared_ptr<IGameListView>(
new DetailedGameListView(mWindow, system->getRootFolder()));
new DetailedGameListView(mWindow, system->getRootFolder()));
mState.viewstyle = DETAILED;
break;
case GRID:
}
case GRID: {
view = std::shared_ptr<IGameListView>(
new GridGameListView(mWindow, system->getRootFolder()));
new GridGameListView(mWindow, system->getRootFolder()));
mState.viewstyle = GRID;
break;
case BASIC:
default:
}
case BASIC: {
}
default: {
view = std::shared_ptr<IGameListView>(
new BasicGameListView(mWindow, system->getRootFolder()));
new BasicGameListView(mWindow, system->getRootFolder()));
mState.viewstyle = BASIC;
break;
}
}
view->setTheme(system->getTheme());
std::vector<SystemData*>& sysVec = SystemData::sSystemVector;
int id = static_cast<int>(
std::find(sysVec.cbegin(), sysVec.cend(), system) - sysVec.cbegin());
int id = static_cast<int>(std::find(sysVec.cbegin(), sysVec.cend(), system) - sysVec.cbegin());
view->setPosition(id * static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight() * 2));
static_cast<float>(Renderer::getScreenHeight() * 2));
addChild(view.get());
@ -794,8 +802,8 @@ bool ViewController::input(InputConfig* config, Input input)
// Open the main menu.
if (!(UIModeController::getInstance()->isUIModeKid() &&
!Settings::getInstance()->getBool("EnableMenuKidMode")) &&
config->isMappedTo("start", input) && input.value != 0) {
!Settings::getInstance()->getBool("EnableMenuKidMode")) &&
config->isMappedTo("start", input) && input.value != 0) {
// If we don't stop the scrolling here, it will continue to
// run after closing the menu.
if (mSystemListView->isScrolling())
@ -849,7 +857,7 @@ void ViewController::render(const Transform4x4f& parentTrans)
// Camera position, position + size.
Vector3f viewStart = transInverse.translation();
Vector3f viewEnd = transInverse * Vector3f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight(), 0));
static_cast<float>(Renderer::getScreenHeight(), 0));
// Keep track of UI mode changes.
UIModeController::getInstance()->monitorUIMode();
@ -865,11 +873,11 @@ void ViewController::render(const Transform4x4f& parentTrans)
if (it->second == mCurrentView || (it->second == mPreviousView && isCameraMoving())) {
// Clipping.
Vector3f guiStart = it->second->getPosition();
Vector3f guiEnd = it->second->getPosition() + Vector3f(it->second->getSize().x(),
it->second->getSize().y(), 0);
Vector3f guiEnd = it->second->getPosition() +
Vector3f(it->second->getSize().x(), it->second->getSize().y(), 0);
if (guiEnd.x() >= viewStart.x() && guiEnd.y() >= viewStart.y() &&
guiStart.x() <= viewEnd.x() && guiStart.y() <= viewEnd.y())
guiStart.x() <= viewEnd.x() && guiStart.y() <= viewEnd.y())
it->second->render(trans);
}
}
@ -882,7 +890,7 @@ void ViewController::render(const Transform4x4f& parentTrans)
unsigned int fadeColor = 0x00000000 | static_cast<unsigned char>(mFadeOpacity * 255);
Renderer::setMatrix(parentTrans);
Renderer::drawRect(0.0f, 0.0f, static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()), fadeColor, fadeColor);
static_cast<float>(Renderer::getScreenHeight()), fadeColor, fadeColor);
}
}
@ -890,13 +898,14 @@ void ViewController::preload()
{
unsigned int systemCount = static_cast<int>(SystemData::sSystemVector.size());
for (auto it = SystemData::sSystemVector.cbegin();
it != SystemData::sSystemVector.cend(); it ++) {
for (auto it = SystemData::sSystemVector.cbegin(); it != SystemData::sSystemVector.cend();
it++) {
if (Settings::getInstance()->getBool("SplashScreen") &&
Settings::getInstance()->getBool("SplashScreenProgress")) {
mWindow->renderLoadingScreen("Loading '" + (*it)->getFullName() + "' (" +
std::to_string(std::distance(SystemData::sSystemVector.cbegin(), it)+1) +
"/" + std::to_string(systemCount) + ")");
Settings::getInstance()->getBool("SplashScreenProgress")) {
mWindow->renderLoadingScreen(
"Loading '" + (*it)->getFullName() + "' (" +
std::to_string(std::distance(SystemData::sSystemVector.cbegin(), it) + 1) + "/" +
std::to_string(systemCount) + ")");
}
(*it)->getIndex()->resetFilters();
getGameListView(*it);
@ -1023,7 +1032,7 @@ std::vector<HelpPrompt> ViewController::getHelpPrompts()
prompts = mCurrentView->getHelpPrompts();
if (!(UIModeController::getInstance()->isUIModeKid() &&
!Settings::getInstance()->getBool("EnableMenuKidMode")))
!Settings::getInstance()->getBool("EnableMenuKidMode")))
prompts.push_back(HelpPrompt("start", "menu"));
return prompts;
}

38
es-app/src/views/ViewController.h
View file

@ -13,11 +13,11 @@
#ifndef ES_APP_VIEWS_VIEW_CONTROLLER_H
#define ES_APP_VIEWS_VIEW_CONTROLLER_H
#include "FileData.h"
#include "GuiComponent.h"
#include "guis/GuiComplexTextEditPopup.h"
#include "guis/GuiMsgBox.h"
#include "renderers/Renderer.h"
#include "FileData.h"
#include "GuiComponent.h"
#include <vector>
@ -46,8 +46,10 @@ public:
// If a basic view detected a metadata change, it can request to recreate
// the current gamelist view (as it may change to be detailed).
void reloadGameListView(IGameListView* gamelist, bool reloadTheme = false);
inline void reloadGameListView(SystemData* system, bool reloadTheme = false)
{ reloadGameListView(getGameListView(system).get(), reloadTheme); }
void reloadGameListView(SystemData* system, bool reloadTheme = false)
{
reloadGameListView(getGameListView(system).get(), reloadTheme);
}
// Reload everything with a theme.
// Used when the "ThemeSet" setting changes.
void reloadAll();
@ -67,22 +69,26 @@ public:
void stopScrolling();
void onFileChanged(FileData* file, bool reloadGameList);
void triggerGameLaunch(FileData* game) { mGameToLaunch = game; mLockInput = true; };
bool getGameLaunchTriggered() { return (mGameToLaunch != nullptr); };
void triggerGameLaunch(FileData* game)
{
mGameToLaunch = game;
mLockInput = true;
};
bool getGameLaunchTriggered() { return (mGameToLaunch != nullptr); }
bool input(InputConfig* config, Input input) override;
void update(int deltaTime) override;
void render(const Transform4x4f& parentTrans) override;
enum ViewMode {
NOTHING,
NOTHING, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
START_SCREEN,
SYSTEM_SELECT,
GAME_LIST
};
enum GameListViewStyle {
AUTOMATIC,
AUTOMATIC, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
BASIC,
DETAILED,
GRID,
@ -93,18 +99,18 @@ public:
ViewMode viewing;
GameListViewStyle viewstyle;
inline SystemData* getSystem() const
SystemData* getSystem() const
{
assert(viewing == GAME_LIST || viewing == SYSTEM_SELECT);
return system;
}
private:
friend ViewController;
SystemData* system;
private:
friend ViewController;
SystemData* system;
};
inline const State& getState() const { return mState; }
const State& getState() const { return mState; }
virtual std::vector<HelpPrompt> getHelpPrompts() override;
virtual HelpStyle getHelpStyle() override;
@ -143,6 +149,9 @@ private:
std::map<SystemData*, std::shared_ptr<IGameListView>> mGameListViews;
std::shared_ptr<SystemView> mSystemListView;
FileData* mGameToLaunch;
State mState;
Transform4x4f mCamera;
bool mSystemViewTransition;
bool mWrappedViews;
@ -151,9 +160,6 @@ private:
bool mCancelledTransition; // Needed only for the Fade transition style.
bool mLockInput;
bool mNextSystem;
FileData* mGameToLaunch;
State mState;
};
#endif // ES_APP_VIEWS_VIEW_CONTROLLER_H

95
es-app/src/views/gamelist/BasicGameListView.cpp
View file

@ -8,15 +8,16 @@
#include "views/gamelist/BasicGameListView.h"
#include "utils/FileSystemUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "Settings.h"
#include "SystemData.h"
#include "utils/FileSystemUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
BasicGameListView::BasicGameListView(Window* window, FileData* root)
: ISimpleGameListView(window, root), mList(window)
: ISimpleGameListView(window, root)
, mList(window)
{
mList.setSize(mSize.x(), mSize.y() * 0.8f);
mList.setPosition(0, mSize.y() * 0.2f);
@ -89,16 +90,16 @@ void BasicGameListView::populateList(const std::vector<FileData*>& files, FileDa
}
if ((*it)->getFavorite() && favoriteStar &&
mRoot->getSystem()->getName() != "favorites") {
mRoot->getSystem()->getName() != "favorites") {
if (Settings::getInstance()->getBool("SpecialCharsASCII"))
mList.add(inCollectionPrefix + "* " +
(*it)->getName(), *it, ((*it)->getType() == FOLDER));
mList.add(inCollectionPrefix + "* " + (*it)->getName(), *it,
((*it)->getType() == FOLDER));
else
mList.add(inCollectionPrefix + ViewController::FAVORITE_CHAR + " " +
(*it)->getName(), *it, ((*it)->getType() == FOLDER));
(*it)->getName(),
*it, ((*it)->getType() == FOLDER));
}
else if ((*it)->getType() == FOLDER &&
mRoot->getSystem()->getName() != "collections") {
else if ((*it)->getType() == FOLDER && mRoot->getSystem()->getName() != "collections") {
if (Settings::getInstance()->getBool("SpecialCharsASCII"))
mList.add("# " + (*it)->getName(), *it, true);
else
@ -117,11 +118,6 @@ void BasicGameListView::populateList(const std::vector<FileData*>& files, FileDa
generateFirstLetterIndex(files);
}
FileData* BasicGameListView::getCursor()
{
return mList.getSelected();
}
void BasicGameListView::setCursor(FileData* cursor)
{
if (!mList.setCursor(cursor) && (!cursor->isPlaceHolder())) {
@ -133,6 +129,7 @@ void BasicGameListView::setCursor(FileData* cursor)
if (mCursorStack.empty() || mCursorStack.top() != cursor->getParent()) {
std::stack<FileData*> tmp;
FileData* ptr = cursor->getParent();
while (ptr && ptr != mRoot) {
tmp.push(ptr);
ptr = ptr->getParent();
@ -148,31 +145,6 @@ void BasicGameListView::setCursor(FileData* cursor)
}
}
FileData* BasicGameListView::getNextEntry()
{
return mList.getNext();
}
FileData* BasicGameListView::getPreviousEntry()
{
return mList.getPrevious();
}
FileData* BasicGameListView::getFirstEntry()
{
return mList.getFirst();
}
FileData* BasicGameListView::getLastEntry()
{
return mList.getLast();
}
FileData* BasicGameListView::getFirstGameEntry()
{
return mFirstGameEntry;
}
void BasicGameListView::addPlaceholder(FileData* firstEntry)
{
// Empty list, add a placeholder.
@ -186,18 +158,9 @@ void BasicGameListView::addPlaceholder(FileData* firstEntry)
mList.add(placeholder->getName(), placeholder, (placeholder->getType() == PLACEHOLDER));
}
std::string BasicGameListView::getQuickSystemSelectRightButton()
{
return "right";
}
std::string BasicGameListView::getQuickSystemSelectLeftButton()
{
return "left";
}
void BasicGameListView::launch(FileData* game)
{
// This triggers ViewController to launch the game.
ViewController::get()->triggerGameLaunch(game);
}
@ -235,7 +198,7 @@ void BasicGameListView::remove(FileData* game, bool deleteFile)
if (deleteFile) {
parent->sort(parent->getSortTypeFromString(parent->getSortTypeString()),
Settings::getInstance()->getBool("FavoritesFirst"));
Settings::getInstance()->getBool("FavoritesFirst"));
onFileChanged(parent, false);
}
}
@ -251,8 +214,8 @@ void BasicGameListView::removeMedia(FileData* game)
// If there are no media files left in the directory after the deletion, then remove
// the directory too. Remove any empty parent directories as well.
auto removeEmptyDirFunc = []
(std::string systemMediaDir, std::string mediaType, std::string path) {
auto removeEmptyDirFunc = [](std::string systemMediaDir, std::string mediaType,
std::string path) {
std::string parentPath = Utils::FileSystem::getParent(path);
while (parentPath != systemMediaDir + "/" + mediaType) {
if (Utils::FileSystem::getDirContent(parentPath).size() == 0) {
@ -321,13 +284,13 @@ std::vector<HelpPrompt> BasicGameListView::getHelpPrompts()
std::vector<HelpPrompt> prompts;
if (Settings::getInstance()->getBool("QuickSystemSelect") &&
SystemData::sSystemVector.size() > 1)
SystemData::sSystemVector.size() > 1)
prompts.push_back(HelpPrompt("left/right", "system"));
prompts.push_back(HelpPrompt("up/down", "choose"));
if (mRoot->getSystem()->getThemeFolder() == "custom-collections" && mCursorStack.empty() &&
ViewController::get()->getState().viewing == ViewController::GAME_LIST)
ViewController::get()->getState().viewing == ViewController::GAME_LIST)
prompts.push_back(HelpPrompt("a", "enter"));
else
prompts.push_back(HelpPrompt("a", "launch"));
@ -341,24 +304,24 @@ std::vector<HelpPrompt> BasicGameListView::getHelpPrompts()
prompts.push_back(HelpPrompt("thumbstickclick", "random"));
if (mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
!CollectionSystemsManager::get()->isEditing() && mCursorStack.empty() &&
ViewController::get()->getState().viewing == ViewController::GAME_LIST &&
ViewController::get()->getState().viewstyle != ViewController::BASIC) {
!CollectionSystemsManager::get()->isEditing() && mCursorStack.empty() &&
ViewController::get()->getState().viewing == ViewController::GAME_LIST &&
ViewController::get()->getState().viewstyle != ViewController::BASIC) {
prompts.push_back(HelpPrompt("y", "jump to game"));
}
else if (mRoot->getSystem()->isGameSystem() &&
(mRoot->getSystem()->getThemeFolder() != "custom-collections" ||
!mCursorStack.empty()) &&
!UIModeController::getInstance()->isUIModeKid() &&
!UIModeController::getInstance()->isUIModeKiosk() &&
(Settings::getInstance()->getBool("FavoritesAddButton") ||
CollectionSystemsManager::get()->isEditing())) {
(mRoot->getSystem()->getThemeFolder() != "custom-collections" ||
!mCursorStack.empty()) &&
!UIModeController::getInstance()->isUIModeKid() &&
!UIModeController::getInstance()->isUIModeKiosk() &&
(Settings::getInstance()->getBool("FavoritesAddButton") ||
CollectionSystemsManager::get()->isEditing())) {
std::string prompt = CollectionSystemsManager::get()->getEditingCollection();
prompts.push_back(HelpPrompt("y", prompt));
}
else if (mRoot->getSystem()->isGameSystem() &&
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
CollectionSystemsManager::get()->isEditing()) {
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
CollectionSystemsManager::get()->isEditing()) {
std::string prompt = CollectionSystemsManager::get()->getEditingCollection();
prompts.push_back(HelpPrompt("y", prompt));
}

29
es-app/src/views/gamelist/BasicGameListView.h
View file

@ -21,30 +21,33 @@ public:
virtual void onFileChanged(FileData* file, bool reloadGameList) override;
virtual void onThemeChanged(const std::shared_ptr<ThemeData>& theme) override;
virtual FileData* getCursor() override;
virtual void setCursor(FileData* cursor) override;
virtual FileData* getNextEntry() override;
virtual FileData* getPreviousEntry() override;
virtual FileData* getFirstEntry() override;
virtual FileData* getLastEntry() override;
virtual FileData* getFirstGameEntry() override;
virtual FileData* getCursor() override { return mList.getSelected(); }
virtual FileData* getNextEntry() override { return mList.getNext(); }
virtual FileData* getPreviousEntry() override { return mList.getPrevious(); }
virtual FileData* getFirstEntry() override { return mList.getFirst(); }
virtual FileData* getLastEntry() override { return mList.getLast(); }
virtual FileData* getFirstGameEntry() override { return mFirstGameEntry; }
virtual std::string getName() const override { return "basic"; }
virtual std::vector<HelpPrompt> getHelpPrompts() override;
virtual void launch(FileData* game) override;
virtual bool isListScrolling() override { return mList.isScrolling(); };
virtual void stopListScrolling() override { mList.stopScrolling(); };
virtual bool isListScrolling() override { return mList.isScrolling(); }
virtual void stopListScrolling() override { mList.stopScrolling(); }
virtual const std::vector<std::string>& getFirstLetterIndex() override
{ return mFirstLetterIndex; };
{
return mFirstLetterIndex;
}
virtual void addPlaceholder(FileData* firstEntry = nullptr) override;
virtual void launch(FileData* game) override;
protected:
virtual std::string getQuickSystemSelectRightButton() override;
virtual std::string getQuickSystemSelectLeftButton() override;
virtual std::string getQuickSystemSelectRightButton() override { return "right"; }
virtual std::string getQuickSystemSelectLeftButton() override { return "left"; }
virtual void populateList(const std::vector<FileData*>& files, FileData* firstEntry) override;
virtual void remove(FileData* game, bool deleteFile) override;
virtual void removeMedia(FileData* game) override;

147
es-app/src/views/gamelist/DetailedGameListView.cpp
View file

@ -8,45 +8,40 @@
#include "views/gamelist/DetailedGameListView.h"
#include "animations/LambdaAnimation.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "SystemData.h"
#include "animations/LambdaAnimation.h"
#include "views/ViewController.h"
#define FADE_IN_START_OPACITY 0.5f
#define FADE_IN_TIME 650
DetailedGameListView::DetailedGameListView(
Window* window,
FileData* root)
: BasicGameListView(window, root),
mDescContainer(window),
mDescription(window),
mGamelistInfo(window),
mThumbnail(window),
mMarquee(window),
mImage(window),
mLblRating(window),
mLblReleaseDate(window),
mLblDeveloper(window),
mLblPublisher(window),
mLblGenre(window),
mLblPlayers(window),
mLblLastPlayed(window),
mLblPlayCount(window),
mRating(window),
mReleaseDate(window),
mDeveloper(window),
mPublisher(window),
mGenre(window),
mPlayers(window),
mLastPlayed(window),
mPlayCount(window),
mName(window),
mLastUpdated(nullptr)
DetailedGameListView::DetailedGameListView(Window* window, FileData* root)
: BasicGameListView(window, root)
, mDescContainer(window)
, mDescription(window)
, mGamelistInfo(window)
, mThumbnail(window)
, mMarquee(window)
, mImage(window)
, mLblRating(window)
, mLblReleaseDate(window)
, mLblDeveloper(window)
, mLblPublisher(window)
, mLblGenre(window)
, mLblPlayers(window)
, mLblLastPlayed(window)
, mLblPlayCount(window)
, mRating(window)
, mReleaseDate(window)
, mDeveloper(window)
, mPublisher(window)
, mGenre(window)
, mPlayers(window)
, mLastPlayed(window)
, mPlayCount(window)
, mName(window)
, mLastUpdated(nullptr)
{
const float padding = 0.01f;
@ -114,8 +109,8 @@ DetailedGameListView::DetailedGameListView(
addChild(&mName);
mDescContainer.setPosition(mSize.x() * padding, mSize.y() * 0.65f);
mDescContainer.setSize(mSize.x() * (0.50f - 2 * padding), mSize.y() -
mDescContainer.getPosition().y());
mDescContainer.setSize(mSize.x() * (0.50f - 2.0f * padding),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setAutoScroll(true);
mDescContainer.setDefaultZIndex(40);
addChild(&mDescContainer);
@ -140,20 +135,20 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
using namespace ThemeFlags;
mThumbnail.applyTheme(theme, getName(), "md_thumbnail",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mMarquee.applyTheme(theme, getName(), "md_marquee",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mImage.applyTheme(theme, getName(), "md_image",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mName.applyTheme(theme, getName(), "md_name", ALL);
initMDLabels();
std::vector<TextComponent*> labels = getMDLabels();
assert(labels.size() == 8);
std::vector<std::string> lblElements = {
"md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players", "md_lbl_lastplayed", "md_lbl_playcount"
};
std::vector<std::string> lblElements = { "md_lbl_rating", "md_lbl_releasedate",
"md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players",
"md_lbl_lastplayed", "md_lbl_playcount" };
for (unsigned int i = 0; i < labels.size(); i++)
labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@ -161,19 +156,19 @@ void DetailedGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& them
initMDValues();
std::vector<GuiComponent*> values = getMDValues();
assert(values.size() == 8);
std::vector<std::string> valElements = {
"md_rating", "md_releasedate", "md_developer", "md_publisher",
"md_genre", "md_players", "md_lastplayed", "md_playcount"
};
std::vector<std::string> valElements = { "md_rating", "md_releasedate", "md_developer",
"md_publisher", "md_genre", "md_players",
"md_lastplayed", "md_playcount" };
for (unsigned int i = 0; i < values.size(); i++)
values[i]->applyTheme(theme, getName(), valElements[i], ALL ^ ThemeFlags::TEXT);
mDescContainer.applyTheme(theme, getName(), "md_description",
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.applyTheme(theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mDescription.applyTheme(
theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
// If there is no position defined in the theme for gamelistInfo, then hide it.
@ -205,7 +200,7 @@ void DetailedGameListView::initMDLabels()
}
else {
// Work from the last component.
GuiComponent* lc = components[i-1];
GuiComponent* lc = components[i - 1];
pos = lc->getPosition() + Vector3f(0, lc->getSize().y() + rowPadding, 0);
}
@ -232,13 +227,13 @@ void DetailedGameListView::initMDValues()
float bottom = 0.0f;
const float colSize = (mSize.x() * 0.48f) / 2;
const float colSize = (mSize.x() * 0.48f) / 2.0f;
for (unsigned int i = 0; i < labels.size(); i++) {
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2;
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2.0f;
values[i]->setPosition(labels[i]->getPosition() +
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
values[i]->setSize(colSize - labels[i]->getSize().x(), values[i]->getSize().y());
values[i]->setDefaultZIndex(40);
values[i]->setDefaultZIndex(40.0f);
float testBot = values[i]->getPosition().y() + values[i]->getSize().y();
@ -247,8 +242,8 @@ void DetailedGameListView::initMDValues()
}
mDescContainer.setPosition(mDescContainer.getPosition().x(), bottom + mSize.y() * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x(), mSize.y() -
mDescContainer.getPosition().y());
mDescContainer.setSize(mDescContainer.getSize().x(),
mSize.y() - mDescContainer.getPosition().y());
}
void DetailedGameListView::updateInfoPanel()
@ -267,7 +262,7 @@ void DetailedGameListView::updateInfoPanel()
if (file) {
// Always hide the metadata fields if browsing grouped custom collections.
if (file->getSystem()->isCustomCollection() &&
file->getPath() == file->getSystem()->getName())
file->getPath() == file->getSystem()->getName())
hideMetaDataFields = true;
else
hideMetaDataFields = (file->metadata.get("hidemetadata") == "true");
@ -283,9 +278,9 @@ void DetailedGameListView::updateInfoPanel()
// or if we're in the grouped custom collection view.
if (mList.isScrolling())
if ((mLastUpdated && mLastUpdated->metadata.get("hidemetadata") == "true") ||
(mLastUpdated->getSystem()->isCustomCollection() &&
mLastUpdated->getPath() == mLastUpdated->getSystem()->getName()))
hideMetaDataFields = true;
(mLastUpdated->getSystem()->isCustomCollection() &&
mLastUpdated->getPath() == mLastUpdated->getSystem()->getName()))
hideMetaDataFields = true;
if (hideMetaDataFields) {
mLblRating.setVisible(false);
@ -333,9 +328,9 @@ void DetailedGameListView::updateInfoPanel()
// which will generate a description of three random games and return a pointer to
// the first of these so that we can display its game media.
if (file->getSystem()->isCustomCollection() &&
file->getPath() == file->getSystem()->getName()) {
mRandomGame = CollectionSystemsManager::get()->
updateCollectionFolderMetadata(file->getSystem());
file->getPath() == file->getSystem()->getName()) {
mRandomGame =
CollectionSystemsManager::get()->updateCollectionFolderMetadata(file->getSystem());
if (mRandomGame) {
mThumbnail.setImage(mRandomGame->getThumbnailPath());
mMarquee.setImage(mRandomGame->getMarqueePath());
@ -366,21 +361,21 @@ void DetailedGameListView::updateInfoPanel()
if (mIsFiltered) {
if (mFilteredGameCountAll == mFilteredGameCount)
gamelistInfoString += ViewController::FILTER_CHAR + " " +
std::to_string(mFilteredGameCount) + " / " +
std::to_string(mGameCount);
std::to_string(mFilteredGameCount) + " / " +
std::to_string(mGameCount);
else
gamelistInfoString += ViewController::FILTER_CHAR + " " +
std::to_string(mFilteredGameCount) + " + " +
std::to_string(mFilteredGameCountAll - mFilteredGameCount) + " / " +
std::to_string(mGameCount);
std::to_string(mFilteredGameCount) + " + " +
std::to_string(mFilteredGameCountAll - mFilteredGameCount) +
" / " + std::to_string(mGameCount);
}
else {
gamelistInfoString += ViewController::CONTROLLER_CHAR + " " +
std::to_string(mGameCount);
gamelistInfoString +=
ViewController::CONTROLLER_CHAR + " " + std::to_string(mGameCount);
if (!(file->getSystem()->isCollection() &&
file->getSystem()->getFullName() == "favorites"))
gamelistInfoString += " " + ViewController::FAVORITE_CHAR + " "
+ std::to_string(mFavoritesGameCount);
file->getSystem()->getFullName() == "favorites"))
gamelistInfoString += " " + ViewController::FAVORITE_CHAR + " " +
std::to_string(mFavoritesGameCount);
}
if (mIsFolder && infoAlign != ALIGN_RIGHT)
@ -390,9 +385,9 @@ void DetailedGameListView::updateInfoPanel()
// Fade in the game image.
auto func = [this](float t) {
mImage.setOpacity(static_cast<unsigned char>(Math::lerp(
static_cast<float>(FADE_IN_START_OPACITY), 1.0f, t) * 255));
};
mImage.setOpacity(static_cast<unsigned char>(
Math::lerp(static_cast<float>(FADE_IN_START_OPACITY), 1.0f, t) * 255));
};
mImage.setAnimation(new LambdaAnimation(func, FADE_IN_TIME), 0, nullptr, false);
mDescription.setText(file->metadata.get("desc"));

230
es-app/src/views/gamelist/GridGameListView.cpp
View file

@ -8,48 +8,42 @@
#include "views/gamelist/GridGameListView.h"
#include "animations/LambdaAnimation.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "Settings.h"
#include "Sound.h"
#include "SystemData.h"
#include "animations/LambdaAnimation.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#define FADE_IN_START_OPACITY 0.5f
#define FADE_IN_TIME 650
GridGameListView::GridGameListView(
Window* window,
FileData* root)
: ISimpleGameListView(window, root),
mGrid(window),
mMarquee(window),
mImage(window),
mDescContainer(window),
mDescription(window),
mGamelistInfo(window),
mLblRating(window),
mLblReleaseDate(window),
mLblDeveloper(window),
mLblPublisher(window),
mLblGenre(window),
mLblPlayers(window),
mLblLastPlayed(window),
mLblPlayCount(window),
mRating(window),
mReleaseDate(window),
mDeveloper(window),
mPublisher(window),
mGenre(window),
mPlayers(window),
mLastPlayed(window),
mPlayCount(window),
mName(window)
GridGameListView::GridGameListView(Window* window, FileData* root)
: ISimpleGameListView(window, root)
, mGrid(window)
, mMarquee(window)
, mImage(window)
, mDescContainer(window)
, mDescription(window)
, mGamelistInfo(window)
, mLblRating(window)
, mLblReleaseDate(window)
, mLblDeveloper(window)
, mLblPublisher(window)
, mLblGenre(window)
, mLblPlayers(window)
, mLblLastPlayed(window)
, mLblPlayCount(window)
, mRating(window)
, mReleaseDate(window)
, mDeveloper(window)
, mPublisher(window)
, mGenre(window)
, mPlayers(window)
, mLastPlayed(window)
, mPlayCount(window)
, mName(window)
{
const float padding = 0.01f;
@ -95,8 +89,8 @@ GridGameListView::GridGameListView(
addChild(&mName);
mDescContainer.setPosition(mSize.x() * padding, mSize.y() * 0.65f);
mDescContainer.setSize(mSize.x() * (0.50f - 2 * padding), mSize.y() -
mDescContainer.getPosition().y());
mDescContainer.setSize(mSize.x() * (0.50f - 2.0f * padding),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setAutoScroll(true);
mDescContainer.setDefaultZIndex(40);
addChild(&mDescContainer);
@ -107,7 +101,7 @@ GridGameListView::GridGameListView(
mMarquee.setOrigin(0.5f, 0.5f);
mMarquee.setPosition(mSize.x() * 0.25f, mSize.y() * 0.10f);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2 * padding), mSize.y() * 0.18f);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2.0f * padding), mSize.y() * 0.18f);
mMarquee.setDefaultZIndex(35);
mMarquee.setVisible(false);
addChild(&mMarquee);
@ -130,10 +124,6 @@ GridGameListView::GridGameListView(
updateInfoPanel();
}
GridGameListView::~GridGameListView()
{
}
void GridGameListView::onFileChanged(FileData* file, bool reloadGameList)
{
if (reloadGameList) {
@ -145,11 +135,6 @@ void GridGameListView::onFileChanged(FileData* file, bool reloadGameList)
ISimpleGameListView::onFileChanged(file, reloadGameList);
}
FileData* GridGameListView::getCursor()
{
return mGrid.getSelected();
}
void GridGameListView::setCursor(FileData* cursor)
{
if (!mGrid.setCursor(cursor) && (!cursor->isPlaceHolder())) {
@ -176,47 +161,11 @@ void GridGameListView::setCursor(FileData* cursor)
}
}
FileData* GridGameListView::getNextEntry()
{
return mGrid.getNext();;
}
FileData* GridGameListView::getPreviousEntry()
{
return mGrid.getPrevious();
}
FileData* GridGameListView::getFirstEntry()
{
return mGrid.getFirst();;
}
FileData* GridGameListView::getLastEntry()
{
return mGrid.getLast();
}
FileData* GridGameListView::getFirstGameEntry()
{
return firstGameEntry;
}
std::string GridGameListView::getQuickSystemSelectRightButton()
{
return "rightshoulder";
}
std::string GridGameListView::getQuickSystemSelectLeftButton()
{
return "leftshoulder";
}
bool GridGameListView::input(InputConfig* config, Input input)
{
if (input.value == 0 && (config->isMappedLike("left", input) ||
config->isMappedLike("right", input) ||
(config->isMappedLike("up", input)) ||
(config->isMappedLike("down", input)) ))
if (input.value == 0 &&
(config->isMappedLike("left", input) || config->isMappedLike("right", input) ||
(config->isMappedLike("up", input)) || (config->isMappedLike("down", input))))
NavigationSounds::getInstance()->playThemeNavigationSound(SCROLLSOUND);
if (input.value != 0 && config->isMappedLike("righttrigger", input)) {
@ -288,17 +237,17 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
mGrid.applyTheme(theme, getName(), "gamegrid", ALL);
mName.applyTheme(theme, getName(), "md_name", ALL);
mMarquee.applyTheme(theme, getName(), "md_marquee",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mImage.applyTheme(theme, getName(), "md_image",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
initMDLabels();
std::vector<TextComponent*> labels = getMDLabels();
assert(labels.size() == 8);
std::vector<std::string> lblElements = {
"md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players", "md_lbl_lastplayed", "md_lbl_playcount"
};
std::vector<std::string> lblElements = { "md_lbl_rating", "md_lbl_releasedate",
"md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players",
"md_lbl_lastplayed", "md_lbl_playcount" };
for (unsigned int i = 0; i < labels.size(); i++)
labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@ -306,19 +255,19 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
initMDValues();
std::vector<GuiComponent*> values = getMDValues();
assert(values.size() == 8);
std::vector<std::string> valElements = {
"md_rating", "md_releasedate", "md_developer", "md_publisher",
"md_genre", "md_players", "md_lastplayed", "md_playcount"
};
std::vector<std::string> valElements = { "md_rating", "md_releasedate", "md_developer",
"md_publisher", "md_genre", "md_players",
"md_lastplayed", "md_playcount" };
for (unsigned int i = 0; i < values.size(); i++)
values[i]->applyTheme(theme, getName(), valElements[i], ALL ^ ThemeFlags::TEXT);
mDescContainer.applyTheme(theme, getName(), "md_description",
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.applyTheme(theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mDescription.applyTheme(
theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
// Repopulate list in case a new theme is displaying a different image.
// Preserve selection.
@ -336,6 +285,12 @@ void GridGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
sortChildren();
}
void GridGameListView::onShow()
{
GuiComponent::onShow();
updateInfoPanel();
}
void GridGameListView::initMDLabels()
{
std::vector<TextComponent*> components = getMDLabels();
@ -356,7 +311,7 @@ void GridGameListView::initMDLabels()
}
else {
// Work from the last component.
GuiComponent* lc = components[i-1];
GuiComponent* lc = components[i - 1];
pos = lc->getPosition() + Vector3f(0, lc->getSize().y() + rowPadding, 0);
}
@ -383,11 +338,11 @@ void GridGameListView::initMDValues()
float bottom = 0.0f;
const float colSize = (mSize.x() * 0.48f) / 2;
const float colSize = (mSize.x() * 0.48f) / 2.0f;
for (unsigned int i = 0; i < labels.size(); i++) {
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2;
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2.0f;
values[i]->setPosition(labels[i]->getPosition() +
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
values[i]->setSize(colSize - labels[i]->getSize().x(), values[i]->getSize().y());
values[i]->setDefaultZIndex(40);
@ -397,8 +352,8 @@ void GridGameListView::initMDValues()
}
mDescContainer.setPosition(mDescContainer.getPosition().x(), bottom + mSize.y() * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x(), mSize.y() -
mDescContainer.getPosition().y());
mDescContainer.setSize(mDescContainer.getSize().x(),
mSize.y() - mDescContainer.getPosition().y());
}
void GridGameListView::updateInfoPanel()
@ -465,21 +420,22 @@ void GridGameListView::updateInfoPanel()
if (mIsFiltered) {
if (mFilteredGameCountAll == mFilteredGameCount)
gamelistInfoString += ViewController::FILTER_CHAR + " "
+ std::to_string(mFilteredGameCount) + " / " + std::to_string(mGameCount);
gamelistInfoString += ViewController::FILTER_CHAR + " " +
std::to_string(mFilteredGameCount) + " / " +
std::to_string(mGameCount);
else
gamelistInfoString += ViewController::FILTER_CHAR + " " +
std::to_string(mFilteredGameCount) + " + " +
std::to_string(mFilteredGameCountAll - mFilteredGameCount) + " / " +
std::to_string(mGameCount);
std::to_string(mFilteredGameCount) + " + " +
std::to_string(mFilteredGameCountAll - mFilteredGameCount) +
" / " + std::to_string(mGameCount);
}
else {
gamelistInfoString += ViewController::CONTROLLER_CHAR + " " +
std::to_string(mGameCount);
gamelistInfoString +=
ViewController::CONTROLLER_CHAR + " " + std::to_string(mGameCount);
if (!(file->getSystem()->isCollection() &&
file->getSystem()->getFullName() == "favorites"))
file->getSystem()->getFullName() == "favorites"))
gamelistInfoString += " " + ViewController::FAVORITE_CHAR + " " +
std::to_string(mFavoritesGameCount);
std::to_string(mFavoritesGameCount);
}
if (mIsFolder && infoAlign != ALIGN_RIGHT)
@ -489,9 +445,9 @@ void GridGameListView::updateInfoPanel()
// Fade in the game image.
auto func = [this](float t) {
mImage.setOpacity(static_cast<unsigned char>(Math::lerp(
static_cast<float>(FADE_IN_START_OPACITY), 1.0f, t) * 255));
};
mImage.setOpacity(static_cast<unsigned char>(
Math::lerp(static_cast<float>(FADE_IN_START_OPACITY), 1.0f, t) * 255));
};
mImage.setAnimation(new LambdaAnimation(func, FADE_IN_TIME), 0, nullptr, false);
mDescription.setText(file->metadata.get("desc"));
@ -535,10 +491,10 @@ void GridGameListView::updateInfoPanel()
// An animation is playing, then animate if reverse != fadingOut.
// An animation is not playing, then animate if opacity != our target opacity.
if ((comp->isAnimationPlaying(0) && comp->isAnimationReversed(0) != fadingOut) ||
(!comp->isAnimationPlaying(0) && comp->getOpacity() != (fadingOut ? 0 : 255))) {
(!comp->isAnimationPlaying(0) && comp->getOpacity() != (fadingOut ? 0 : 255))) {
auto func = [comp](float t) {
// TEMPORARY - This does not seem to work, needs to be reviewed later.
// comp->setOpacity(static_cast<unsigned char>(Math::lerp(0.0f, 1.0f, t) * 255));
// TEMPORARY - This does not seem to work, needs to be reviewed later.
// comp->setOpacity(static_cast<unsigned char>(Math::lerp(0.0f, 1.0f, t) * 255));
};
comp->setAnimation(new LambdaAnimation(func, 150), 0, nullptr, fadingOut);
}
@ -560,6 +516,7 @@ void GridGameListView::addPlaceholder(FileData* firstEntry)
void GridGameListView::launch(FileData* game)
{
// This triggers ViewController to launch the game.
ViewController::get()->triggerGameLaunch(game);
}
@ -605,8 +562,8 @@ void GridGameListView::removeMedia(FileData* game)
// If there are no media files left in the directory after the deletion, then remove
// the directory too. Remove any empty parent directories as well.
auto removeEmptyDirFunc = []
(std::string systemMediaDir, std::string mediaType, std::string path) {
auto removeEmptyDirFunc = [](std::string systemMediaDir, std::string mediaType,
std::string path) {
std::string parentPath = Utils::FileSystem::getParent(path);
while (parentPath != systemMediaDir + "/" + mediaType) {
if (Utils::FileSystem::getDirContent(parentPath).size() == 0) {
@ -707,7 +664,7 @@ std::vector<HelpPrompt> GridGameListView::getHelpPrompts()
prompts.push_back(HelpPrompt("up/down/left/right", "choose"));
if (mRoot->getSystem()->getThemeFolder() == "custom-collections" && mCursorStack.empty() &&
ViewController::get()->getState().viewing == ViewController::GAME_LIST)
ViewController::get()->getState().viewing == ViewController::GAME_LIST)
prompts.push_back(HelpPrompt("a", "enter"));
else
prompts.push_back(HelpPrompt("a", "launch"));
@ -715,32 +672,30 @@ std::vector<HelpPrompt> GridGameListView::getHelpPrompts()
prompts.push_back(HelpPrompt("b", "back"));
if (mRoot->getSystem()->isGameSystem() &&
mRoot->getSystem()->getThemeFolder() != "custom-collections")
mRoot->getSystem()->getThemeFolder() != "custom-collections")
prompts.push_back(HelpPrompt("x", "view media"));
if (mRoot->getSystem()->isGameSystem() && !mCursorStack.empty() &&
mRoot->getSystem()->getThemeFolder() == "custom-collections")
mRoot->getSystem()->getThemeFolder() == "custom-collections")
prompts.push_back(HelpPrompt("x", "view media"));
if (!UIModeController::getInstance()->isUIModeKid())
prompts.push_back(HelpPrompt("back", "options"));
if (mRoot->getSystem()->isGameSystem() &&
Settings::getInstance()->getBool("RandomAddButton"))
if (mRoot->getSystem()->isGameSystem() && Settings::getInstance()->getBool("RandomAddButton"))
prompts.push_back(HelpPrompt("thumbstickclick", "random"));
if (mRoot->getSystem()->isGameSystem() &&
(mRoot->getSystem()->getThemeFolder() != "custom-collections" ||
!mCursorStack.empty()) &&
!UIModeController::getInstance()->isUIModeKid() &&
!UIModeController::getInstance()->isUIModeKiosk() &&
(Settings::getInstance()->getBool("FavoritesAddButton") ||
CollectionSystemsManager::get()->isEditing())) {
(mRoot->getSystem()->getThemeFolder() != "custom-collections" || !mCursorStack.empty()) &&
!UIModeController::getInstance()->isUIModeKid() &&
!UIModeController::getInstance()->isUIModeKiosk() &&
(Settings::getInstance()->getBool("FavoritesAddButton") ||
CollectionSystemsManager::get()->isEditing())) {
std::string prompt = CollectionSystemsManager::get()->getEditingCollection();
prompts.push_back(HelpPrompt("y", prompt));
}
else if (mRoot->getSystem()->isGameSystem() &&
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
CollectionSystemsManager::get()->isEditing()) {
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
CollectionSystemsManager::get()->isEditing()) {
std::string prompt = CollectionSystemsManager::get()->getEditingCollection();
prompts.push_back(HelpPrompt("y", prompt));
}
@ -749,11 +704,6 @@ std::vector<HelpPrompt> GridGameListView::getHelpPrompts()
void GridGameListView::update(int deltaTime)
{
// Update.
ISimpleGameListView::update(deltaTime);
}
void GridGameListView::onShow()
{
GuiComponent::onShow();
updateInfoPanel();
}

34
es-app/src/views/gamelist/GridGameListView.h
View file

@ -20,48 +20,50 @@ class GridGameListView : public ISimpleGameListView
{
public:
GridGameListView(Window* window, FileData* root);
virtual ~GridGameListView();
virtual ~GridGameListView() {}
// Called when a FileData* is added, has its metadata changed, or is removed.
virtual void onFileChanged(FileData* file, bool reloadGameList) override;
virtual void onShow() override;
virtual void onThemeChanged(const std::shared_ptr<ThemeData>& theme) override;
virtual FileData* getCursor() override;
virtual void setCursor(FileData* cursor) override;
virtual FileData* getNextEntry() override;
virtual FileData* getPreviousEntry() override;
virtual FileData* getFirstEntry() override;
virtual FileData* getLastEntry() override;
virtual FileData* getFirstGameEntry() override;
virtual bool input(InputConfig* config, Input input) override;
virtual FileData* getCursor() override { return mGrid.getSelected(); }
virtual FileData* getNextEntry() override { return mGrid.getNext(); }
virtual FileData* getPreviousEntry() override { return mGrid.getPrevious(); }
virtual FileData* getFirstEntry() override { return mGrid.getFirst(); }
virtual FileData* getLastEntry() override { return mGrid.getLast(); }
virtual FileData* getFirstGameEntry() override { return firstGameEntry; }
virtual std::string getName() const override { return "grid"; }
virtual bool input(InputConfig* config, Input input) override;
virtual std::vector<HelpPrompt> getHelpPrompts() override;
virtual void launch(FileData* game) override;
virtual bool isListScrolling() override { return mGrid.isScrolling(); };
virtual bool isListScrolling() override { return mGrid.isScrolling(); }
virtual void stopListScrolling() override
{
mGrid.stopAllAnimations();
mGrid.stopScrolling();
};
}
virtual const std::vector<std::string>& getFirstLetterIndex() override
{ return mFirstLetterIndex; };
{
return mFirstLetterIndex;
}
virtual void addPlaceholder(FileData* firstEntry = nullptr) override;
protected:
virtual void update(int deltaTime) override;
virtual std::string getQuickSystemSelectRightButton() override;
virtual std::string getQuickSystemSelectLeftButton() override;
virtual std::string getQuickSystemSelectRightButton() override { return "rightshoulder"; }
virtual std::string getQuickSystemSelectLeftButton() override { return "leftshoulder"; }
virtual void populateList(const std::vector<FileData*>& files, FileData* firstEntry) override;
virtual void remove(FileData* game, bool deleteFile) override;
virtual void removeMedia(FileData* game) override;
virtual void update(int deltaTime) override;
ImageGridComponent<FileData*> mGrid;
// Points to the first game in the list, i.e. the first entry which is of the type 'GAME'.

40
es-app/src/views/gamelist/IGameListView.cpp
View file

@ -8,18 +8,32 @@
#include "views/gamelist/IGameListView.h"
#include "guis/GuiGamelistOptions.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "AudioManager.h"
#include "Sound.h"
#include "Window.h"
#include "guis/GuiGamelistOptions.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
IGameListView::IGameListView(Window* window, FileData* root)
: GuiComponent(window)
, mRoot(root)
{
setSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
}
void IGameListView::setTheme(const std::shared_ptr<ThemeData>& theme)
{
mTheme = theme;
onThemeChanged(theme);
}
bool IGameListView::input(InputConfig* config, Input input)
{
// Select button opens GuiGamelistOptions.
if (!UIModeController::getInstance()->isUIModeKid() &&
config->isMappedTo("back", input) && input.value) {
if (!UIModeController::getInstance()->isUIModeKid() && // Line break.
config->isMappedTo("back", input) && input.value) {
ViewController::get()->cancelViewTransitions();
stopListScrolling();
mWindow->pushGui(new GuiGamelistOptions(mWindow, this->mRoot->getSystem()));
@ -28,9 +42,9 @@ bool IGameListView::input(InputConfig* config, Input input)
// Ctrl-R reloads the view when debugging.
else if (Settings::getInstance()->getBool("Debug") &&
config->getDeviceId() == DEVICE_KEYBOARD &&
(SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL)) &&
input.id == SDLK_r && input.value != 0) {
config->getDeviceId() == DEVICE_KEYBOARD &&
(SDL_GetModState() & (KMOD_LCTRL | KMOD_RCTRL)) && input.id == SDLK_r &&
input.value != 0) {
LOG(LogDebug) << "IGameListView::input(): Reloading view";
ViewController::get()->reloadGameListView(this, true);
return true;
@ -39,12 +53,6 @@ bool IGameListView::input(InputConfig* config, Input input)
return GuiComponent::input(config, input);
}
void IGameListView::setTheme(const std::shared_ptr<ThemeData>& theme)
{
mTheme = theme;
onThemeChanged(theme);
}
HelpStyle IGameListView::getHelpStyle()
{
HelpStyle style;
@ -60,9 +68,9 @@ void IGameListView::render(const Transform4x4f& parentTrans)
float scaleY = trans.r1().y();
Vector2i pos(static_cast<int>(std::round(trans.translation()[0])),
static_cast<int>(std::round(trans.translation()[1])));
static_cast<int>(std::round(trans.translation()[1])));
Vector2i size(static_cast<int>(std::round(mSize.x() * scaleX)),
static_cast<int>(std::round(mSize.y() * scaleY)));
static_cast<int>(std::round(mSize.y() * scaleY)));
Renderer::pushClipRect(pos, size);
renderChildren(trans);

11
es-app/src/views/gamelist/IGameListView.h
View file

@ -9,9 +9,9 @@
#ifndef ES_APP_VIEWS_GAME_LIST_IGAME_LIST_VIEW_H
#define ES_APP_VIEWS_GAME_LIST_IGAME_LIST_VIEW_H
#include "renderers/Renderer.h"
#include "FileData.h"
#include "GuiComponent.h"
#include "renderers/Renderer.h"
class ThemeData;
class Window;
@ -20,12 +20,7 @@ class Window;
class IGameListView : public GuiComponent
{
public:
IGameListView(Window* window, FileData* root) : GuiComponent(window), mRoot(root)
{
setSize(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
}
IGameListView(Window* window, FileData* root);
virtual ~IGameListView() {}
// Called when a FileData* is added, has its metadata changed, or is removed.
@ -35,7 +30,7 @@ public:
virtual void onThemeChanged(const std::shared_ptr<ThemeData>& theme) = 0;
void setTheme(const std::shared_ptr<ThemeData>& theme);
inline const std::shared_ptr<ThemeData>& getTheme() const { return mTheme; }
const std::shared_ptr<ThemeData>& getTheme() const { return mTheme; }
virtual FileData* getCursor() = 0;
virtual void setCursor(FileData*) = 0;

193
es-app/src/views/gamelist/ISimpleGameListView.cpp
View file

@ -8,26 +8,24 @@
#include "views/gamelist/ISimpleGameListView.h"
#include "guis/GuiInfoPopup.h"
#include "utils/StringUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "CollectionSystemsManager.h"
#include "FileFilterIndex.h"
#include "Settings.h"
#include "Sound.h"
#include "SystemData.h"
#include "guis/GuiInfoPopup.h"
#include "utils/StringUtil.h"
#include "views/UIModeController.h"
#include "views/ViewController.h"
#include "Log.h"
ISimpleGameListView::ISimpleGameListView(
Window* window,
FileData* root)
: IGameListView(window, root),
mHeaderText(window),
mHeaderImage(window),
mBackground(window),
mRandomGame(nullptr)
ISimpleGameListView::ISimpleGameListView(Window* window, FileData* root)
: IGameListView(window, root)
, mHeaderText(window)
, mHeaderImage(window)
, mBackground(window)
, mRandomGame(nullptr)
{
mHeaderText.setText("Logo Text");
mHeaderText.setSize(mSize.x(), 0);
@ -124,10 +122,10 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
std::vector<FileData*> listEntries = cursor->getChildrenListToDisplay();
// Check if there is an entry in the cursor stack history matching any entry
// in the currect folder. If so, select that entry.
for (auto it = mCursorStackHistory.begin();
it != mCursorStackHistory.end(); it++) {
for (auto it = mCursorStackHistory.begin(); // Line break.
it != mCursorStackHistory.end(); it++) {
if (std::find(listEntries.begin(), listEntries.end(), *it) !=
listEntries.end()) {
listEntries.end()) {
newCursor = *it;
mCursorStackHistory.erase(it);
break;
@ -155,7 +153,7 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
mCursorStackHistory.push_back(getCursor());
NavigationSounds::getInstance()->playThemeNavigationSound(BACKSOUND);
populateList(mCursorStack.top()->getParent()->getChildrenListToDisplay(),
mCursorStack.top()->getParent());
mCursorStack.top()->getParent());
setCursor(mCursorStack.top());
if (mCursorStack.size() > 0)
mCursorStack.pop();
@ -169,9 +167,9 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
stopListScrolling();
SystemData* systemToView = getCursor()->getSystem();
if (systemToView->isCustomCollection() &&
systemToView->getRootFolder()->getParent())
systemToView->getRootFolder()->getParent())
ViewController::get()->goToSystemView(
systemToView->getRootFolder()->getParent()->getSystem(), true);
systemToView->getRootFolder()->getParent()->getSystem(), true);
else
ViewController::get()->goToSystemView(systemToView, true);
}
@ -184,9 +182,9 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
return true;
}
else if (config->isMappedTo("x", input) &&
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
mCursorStack.empty() && ViewController::get()->getState().viewing ==
ViewController::GAME_LIST) {
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
mCursorStack.empty() &&
ViewController::get()->getState().viewing == ViewController::GAME_LIST) {
NavigationSounds::getInstance()->playThemeNavigationSound(SCROLLSOUND);
// Jump to the randomly selected game.
if (mRandomGame) {
@ -206,7 +204,7 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
}
else if (config->isMappedLike(getQuickSystemSelectRightButton(), input)) {
if (Settings::getInstance()->getBool("QuickSystemSelect") &&
SystemData::sSystemVector.size() > 1) {
SystemData::sSystemVector.size() > 1) {
onPauseVideo();
onFocusLost();
stopListScrolling();
@ -216,7 +214,7 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
}
else if (config->isMappedLike(getQuickSystemSelectLeftButton(), input)) {
if (Settings::getInstance()->getBool("QuickSystemSelect") &&
SystemData::sSystemVector.size() > 1) {
SystemData::sSystemVector.size() > 1) {
onPauseVideo();
onFocusLost();
stopListScrolling();
@ -225,8 +223,8 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
}
}
else if (Settings::getInstance()->getBool("RandomAddButton") &&
(config->isMappedTo("leftthumbstickclick", input) ||
config->isMappedTo("rightthumbstickclick", input))) {
(config->isMappedTo("leftthumbstickclick", input) ||
config->isMappedTo("rightthumbstickclick", input))) {
if (mRoot->getSystem()->isGameSystem() && getCursor()->getType() != PLACEHOLDER) {
stopListScrolling();
// Jump to a random game.
@ -238,21 +236,19 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
}
}
else if (config->isMappedTo("y", input) &&
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
!CollectionSystemsManager::get()->isEditing() &&
mCursorStack.empty() && ViewController::get()->getState().viewing ==
ViewController::GAME_LIST) {
mRoot->getSystem()->getThemeFolder() == "custom-collections" &&
!CollectionSystemsManager::get()->isEditing() && mCursorStack.empty() &&
ViewController::get()->getState().viewing == ViewController::GAME_LIST) {
// Jump to the randomly selected game.
if (mRandomGame) {
NavigationSounds::getInstance()->playThemeNavigationSound(SELECTSOUND);
// If there is already an mCursorStackHistory entry for the collection, then
// remove it so we don't get multiple entries.
std::vector<FileData*> listEntries =
mRandomGame->getSystem()->getRootFolder()->getChildrenListToDisplay();
for (auto it = mCursorStackHistory.begin();
it != mCursorStackHistory.end(); it++) {
mRandomGame->getSystem()->getRootFolder()->getChildrenListToDisplay();
for (auto it = mCursorStackHistory.begin(); it != mCursorStackHistory.end(); it++) {
if (std::find(listEntries.begin(), listEntries.end(), *it) !=
listEntries.end()) {
listEntries.end()) {
mCursorStackHistory.erase(it);
break;
}
@ -265,34 +261,33 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
}
}
else if (config->isMappedTo("y", input) &&
!Settings::getInstance()->getBool("FavoritesAddButton") &&
!CollectionSystemsManager::get()->isEditing()) {
!Settings::getInstance()->getBool("FavoritesAddButton") &&
!CollectionSystemsManager::get()->isEditing()) {
return true;
}
else if (config->isMappedTo("y", input) &&
!UIModeController::getInstance()->isUIModeKid() &&
!UIModeController::getInstance()->isUIModeKiosk()) {
!UIModeController::getInstance()->isUIModeKid() &&
!UIModeController::getInstance()->isUIModeKiosk()) {
// Notify the user if attempting to add a custom collection to a custom collection.
if (CollectionSystemsManager::get()->isEditing() &&
mRoot->getSystem()->isGameSystem() && getCursor()->getType() != PLACEHOLDER &&
getCursor()->getParent()->getPath() == "collections") {
mRoot->getSystem()->isGameSystem() && getCursor()->getType() != PLACEHOLDER &&
getCursor()->getParent()->getPath() == "collections") {
NavigationSounds::getInstance()->playThemeNavigationSound(FAVORITESOUND);
GuiInfoPopup* s;
s = new GuiInfoPopup(mWindow,
"CAN'T ADD CUSTOM COLLECTIONS TO CUSTOM COLLECTIONS", 4000);
s = new GuiInfoPopup(mWindow, "CAN'T ADD CUSTOM COLLECTIONS TO CUSTOM COLLECTIONS",
4000);
mWindow->setInfoPopup(s);
}
// Notify the user if attempting to add a placeholder to a custom collection.
if (CollectionSystemsManager::get()->isEditing() &&
mRoot->getSystem()->isGameSystem() && getCursor()->getType() == PLACEHOLDER) {
mRoot->getSystem()->isGameSystem() && getCursor()->getType() == PLACEHOLDER) {
NavigationSounds::getInstance()->playThemeNavigationSound(FAVORITESOUND);
GuiInfoPopup* s;
s = new GuiInfoPopup(mWindow,
"CAN'T ADD PLACEHOLDERS TO CUSTOM COLLECTIONS", 4000);
s = new GuiInfoPopup(mWindow, "CAN'T ADD PLACEHOLDERS TO CUSTOM COLLECTIONS", 4000);
mWindow->setInfoPopup(s);
}
else if (mRoot->getSystem()->isGameSystem() && getCursor()->getType() != PLACEHOLDER &&
getCursor()->getParent()->getPath() != "collections") {
getCursor()->getParent()->getPath() != "collections") {
if (getCursor()->getType() == GAME || getCursor()->getType() == FOLDER)
NavigationSounds::getInstance()->playThemeNavigationSound(FAVORITESOUND);
// When marking or unmarking a game as favorite, don't jump to the new position
@ -312,13 +307,14 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
foldersOnTop = !getCursor()->getParent()->getOnlyFoldersFlag();
if (mRoot->getSystem()->isCustomCollection() ||
mRoot->getSystem()->getThemeFolder() == "custom-collections")
mRoot->getSystem()->getThemeFolder() == "custom-collections")
favoritesSorting = Settings::getInstance()->getBool("FavFirstCustom");
else
favoritesSorting = Settings::getInstance()->getBool("FavoritesFirst");
if (favoritesSorting && static_cast<std::string>(
mRoot->getSystem()->getName()) != "recent" && !isEditing) {
if (favoritesSorting &&
static_cast<std::string>(mRoot->getSystem()->getName()) != "recent" &&
!isEditing) {
FileData* entryToSelect;
// Add favorite flag.
if (!getCursor()->getFavorite()) {
@ -331,7 +327,7 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
entryToSelect = getNextEntry();
}
else if (getCursor() == getLastEntry() &&
getPreviousEntry()->getFavorite()) {
getPreviousEntry()->getFavorite()) {
entryToSelect = getLastEntry();
selectLastEntry = true;
}
@ -342,14 +338,14 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
// If we mark the second entry as favorite and the first entry is not a
// favorite, then select this entry if they are of the same type.
else if (getPreviousEntry() == getFirstEntry() &&
getCursor()->getType() == getPreviousEntry()->getType()) {
getCursor()->getType() == getPreviousEntry()->getType()) {
entryToSelect = getPreviousEntry();
}
// For all other scenarios try to select the next entry, and if it doesn't
// exist, select the previous entry.
else {
entryToSelect = getCursor() != getNextEntry() ?
getNextEntry() : getPreviousEntry();
entryToSelect =
getCursor() != getNextEntry() ? getNextEntry() : getPreviousEntry();
}
}
// Remove favorite flag.
@ -365,9 +361,10 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
// If we are on the favorite marking boundary, select the previous entry,
// unless folders are sorted on top and the previous entry is a folder.
else if (foldersOnTop &&
getCursor()->getFavorite() != getNextEntry()->getFavorite()) {
getCursor()->getFavorite() != getNextEntry()->getFavorite()) {
entryToSelect = getPreviousEntry()->getType() == FOLDER ?
getCursor() : getPreviousEntry();
getCursor() :
getPreviousEntry();
}
// If we are on the favorite marking boundary, select the previous entry.
else if (getCursor()->getFavorite() != getNextEntry()->getFavorite()) {
@ -376,17 +373,17 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
// For all other scenarios try to select the next entry, and if it doesn't
// exist, select the previous entry.
else {
entryToSelect = getCursor() != getNextEntry() ?
getNextEntry() : getPreviousEntry();
entryToSelect =
getCursor() != getNextEntry() ? getNextEntry() : getPreviousEntry();
}
// If we removed the last favorite marking, set the flag to jump to the
// first list entry after the sorting has been performed.
if (foldersOnTop && getCursor() == getFirstGameEntry() &&
!getNextEntry()->getFavorite())
!getNextEntry()->getFavorite())
removedLastFavorite = true;
else if (getCursor() == getFirstEntry() && !getNextEntry()->getFavorite())
removedLastFavorite = true;
removedLastFavorite = true;
}
setCursor(entryToSelect);
@ -399,22 +396,30 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
if (entryToUpdate->getType() == FOLDER) {
GuiInfoPopup* s;
if (isEditing) {
s = new GuiInfoPopup(mWindow,
"CAN'T ADD FOLDERS TO CUSTOM COLLECTIONS", 4000);
s = new GuiInfoPopup(mWindow, "CAN'T ADD FOLDERS TO CUSTOM COLLECTIONS",
4000);
}
else {
MetaDataList* md = &entryToUpdate->getSourceFileData()->metadata;
if (md->get("favorite") == "false") {
md->set("favorite", "true");
s = new GuiInfoPopup(mWindow, "MARKED FOLDER '" +
s = new GuiInfoPopup(
mWindow,
"MARKED FOLDER '" +
Utils::String::toUpper(Utils::String::removeParenthesis(
entryToUpdate->getName())) + "' AS FAVORITE", 4000);
entryToUpdate->getName())) +
"' AS FAVORITE",
4000);
}
else {
md->set("favorite", "false");
s = new GuiInfoPopup(mWindow, "REMOVED FAVORITE MARKING FOR FOLDER '" +
s = new GuiInfoPopup(
mWindow,
"REMOVED FAVORITE MARKING FOR FOLDER '" +
Utils::String::toUpper(Utils::String::removeParenthesis(
entryToUpdate->getName())) + "'", 4000);
entryToUpdate->getName())) +
"'",
4000);
}
}
@ -422,8 +427,8 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
entryToUpdate->getSourceFileData()->getSystem()->onMetaDataSavePoint();
getCursor()->getParent()->sort(
mRoot->getSortTypeFromString(mRoot->getSortTypeString()),
Settings::getInstance()->getBool("FavoritesFirst"));
mRoot->getSortTypeFromString(mRoot->getSortTypeString()),
Settings::getInstance()->getBool("FavoritesFirst"));
ViewController::get()->onFileChanged(getCursor(), false);
@ -431,16 +436,19 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
// was unmarked. We couldn't do this earlier as we didn't have the list
// sorted yet.
if (removedLastFavorite) {
ViewController::get()->getGameListView(entryToUpdate->
getSystem())->setCursor(ViewController::get()->
getGameListView(entryToUpdate->getSystem())->getFirstEntry());
ViewController::get()
->getGameListView(entryToUpdate->getSystem())
->setCursor(ViewController::get()
->getGameListView(entryToUpdate->getSystem())
->getFirstEntry());
}
return true;
}
else if (isEditing && entryToUpdate->metadata.get("nogamecount") == "true") {
GuiInfoPopup* s = new GuiInfoPopup(mWindow,
"CAN'T ADD ENTRIES THAT ARE NOT COUNTED "
"AS GAMES TO CUSTOM COLLECTIONS", 4000);
"CAN'T ADD ENTRIES THAT ARE NOT COUNTED "
"AS GAMES TO CUSTOM COLLECTIONS",
4000);
mWindow->setInfoPopup(s);
}
else if (CollectionSystemsManager::get()->toggleGameInCollection(entryToUpdate)) {
@ -450,13 +458,15 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
IGameListView* view = ViewController::get()->getGameListView(system).get();
// Jump to the first entry in the gamelist if the last favorite was unmarked.
if (foldersOnTop && removedLastFavorite &&
!entryToUpdate->getSystem()->isCustomCollection()) {
ViewController::get()->getGameListView(entryToUpdate->getSystem())->
setCursor(ViewController::get()->getGameListView(entryToUpdate->
getSystem())->getFirstGameEntry());
!entryToUpdate->getSystem()->isCustomCollection()) {
ViewController::get()
->getGameListView(entryToUpdate->getSystem())
->setCursor(ViewController::get()
->getGameListView(entryToUpdate->getSystem())
->getFirstGameEntry());
}
else if (removedLastFavorite &&
!entryToUpdate->getSystem()->isCustomCollection()) {
!entryToUpdate->getSystem()->isCustomCollection()) {
view->setCursor(view->getFirstEntry());
}
else if (selectLastEntry) {
@ -467,10 +477,9 @@ bool ISimpleGameListView::input(InputConfig* config, Input input)
// onFileChanged() which will trigger populateList().
if (isEditing) {
for (auto it = SystemData::sSystemVector.begin();
it != SystemData::sSystemVector.end(); it++) {
it != SystemData::sSystemVector.end(); it++) {
ViewController::get()->getGameListView((*it))->onFileChanged(
ViewController::get()->getGameListView((*it))->
getCursor(), false);
ViewController::get()->getGameListView((*it))->getCursor(), false);
}
}
return true;
@ -511,13 +520,13 @@ void ISimpleGameListView::generateGamelistInfo(FileData* cursor, FileData* first
if (idx->isFiltered()) {
mIsFiltered = true;
mFilteredGameCount = static_cast<unsigned int>(rootFolder->
getFilesRecursive(GAME, true, false).size());
mFilteredGameCount =
static_cast<unsigned int>(rootFolder->getFilesRecursive(GAME, true, false).size());
// Also count the games that are set to not be counted as games, as the filter may
// apply to such entries as well and this will be indicated with a separate '+ XX'
// in the GamelistInfo field.
mFilteredGameCountAll = static_cast<unsigned int>(rootFolder->
getFilesRecursive(GAME, true, true).size());
mFilteredGameCountAll =
static_cast<unsigned int>(rootFolder->getFilesRecursive(GAME, true, true).size());
}
if (firstEntry->getParent() && firstEntry->getParent()->getType() == FOLDER)
@ -541,7 +550,7 @@ void ISimpleGameListView::generateFirstLetterIndex(const std::vector<FileData*>&
else
favoritesSorting = Settings::getInstance()->getBool("FavoritesFirst");
bool foldersOnTop = Settings::getInstance()->getBool("FoldersOnTop");
bool foldersOnTop = Settings::getInstance()->getBool("FoldersOnTop");
// Find out if there are only favorites and/or only folders in the list.
for (auto it = files.begin(); it != files.end(); it++) {
@ -553,16 +562,20 @@ void ISimpleGameListView::generateFirstLetterIndex(const std::vector<FileData*>&
// Build the index.
for (auto it = files.begin(); it != files.end(); it++) {
if ((*it)->getType() == FOLDER && (*it)->getFavorite() &&
favoritesSorting && !onlyFavorites)
if ((*it)->getType() == FOLDER && (*it)->getFavorite() && favoritesSorting &&
!onlyFavorites) {
hasFavorites = true;
else if ((*it)->getType() == FOLDER && foldersOnTop && !onlyFolders)
}
else if ((*it)->getType() == FOLDER && foldersOnTop && !onlyFolders) {
hasFolders = true;
else if ((*it)->getType() == GAME && (*it)->getFavorite() &&
favoritesSorting && !onlyFavorites)
}
else if ((*it)->getType() == GAME && (*it)->getFavorite() && favoritesSorting &&
!onlyFavorites) {
hasFavorites = true;
else
}
else {
mFirstLetterIndex.push_back(Utils::String::getFirstCharacter((*it)->getSortName()));
}
}
// Sort and make each entry unique.

10
es-app/src/views/gamelist/ISimpleGameListView.h
View file

@ -9,9 +9,9 @@
#ifndef ES_APP_VIEWS_GAME_LIST_ISIMPLE_GAME_LIST_VIEW_H
#define ES_APP_VIEWS_GAME_LIST_ISIMPLE_GAME_LIST_VIEW_H
#include "views/gamelist/IGameListView.h"
#include "components/ImageComponent.h"
#include "components/TextComponent.h"
#include "views/gamelist/IGameListView.h"
#include <stack>
@ -39,9 +39,13 @@ public:
// These functions are used to retain the folder cursor history, for instance
// during a view reload. The calling function stores the history temporarily.
void copyCursorHistory(std::vector<FileData*>& cursorHistory) override
{ cursorHistory = mCursorStackHistory; };
{
cursorHistory = mCursorStackHistory;
};
void populateCursorHistory(std::vector<FileData*>& cursorHistory) override
{ mCursorStackHistory = cursorHistory; };
{
mCursorStackHistory = cursorHistory;
};
protected:
virtual std::string getQuickSystemSelectRightButton() = 0;

186
es-app/src/views/gamelist/VideoGameListView.cpp
View file

@ -10,73 +10,59 @@
#include "animations/LambdaAnimation.h"
#include "components/VideoFFmpegComponent.h"
#if defined(_RPI_)
#include "components/VideoOmxComponent.h"
#endif
#if defined(BUILD_VLC_PLAYER)
#include "components/VideoVlcComponent.h"
#endif
#include "utils/FileSystemUtil.h"
#include "views/ViewController.h"
#include "AudioManager.h"
#include "CollectionSystemsManager.h"
#include "SystemData.h"
#include "utils/FileSystemUtil.h"
#include "views/ViewController.h"
#define FADE_IN_START_OPACITY 0.5f
#define FADE_IN_TIME 650
VideoGameListView::VideoGameListView(
Window* window,
FileData* root)
: BasicGameListView(window, root),
mDescContainer(window),
mDescription(window),
mGamelistInfo(window),
mThumbnail(window),
mMarquee(window),
mImage(window),
mVideo(nullptr),
mVideoPlaying(false),
mLblRating(window),
mLblReleaseDate(window),
mLblDeveloper(window),
mLblPublisher(window),
mLblGenre(window),
mLblPlayers(window),
mLblLastPlayed(window),
mLblPlayCount(window),
mRating(window),
mReleaseDate(window),
mDeveloper(window),
mPublisher(window),
mGenre(window),
mPlayers(window),
mLastPlayed(window),
mPlayCount(window),
mName(window),
mLastUpdated(nullptr)
VideoGameListView::VideoGameListView(Window* window, FileData* root)
: BasicGameListView(window, root)
, mDescContainer(window)
, mDescription(window)
, mGamelistInfo(window)
, mThumbnail(window)
, mMarquee(window)
, mImage(window)
, mVideo(nullptr)
, mVideoPlaying(false)
, mLblRating(window)
, mLblReleaseDate(window)
, mLblDeveloper(window)
, mLblPublisher(window)
, mLblGenre(window)
, mLblPlayers(window)
, mLblLastPlayed(window)
, mLblPlayCount(window)
, mRating(window)
, mReleaseDate(window)
, mDeveloper(window)
, mPublisher(window)
, mGenre(window)
, mPlayers(window)
, mLastPlayed(window)
, mPlayCount(window)
, mName(window)
, mLastUpdated(nullptr)
{
const float padding = 0.01f;
// Create the correct type of video window.
#if defined(_RPI_)
if (Settings::getInstance()->getBool("VideoOmxPlayer"))
mVideo = new VideoOmxComponent(window);
else if (Settings::getInstance()->getString("VideoPlayer") == "vlc")
mVideo = new VideoVlcComponent(window);
else
mVideo = new VideoFFmpegComponent(window);
#elif defined(BUILD_VLC_PLAYER)
#if defined(BUILD_VLC_PLAYER)
if (Settings::getInstance()->getString("VideoPlayer") == "vlc")
mVideo = new VideoVlcComponent(window);
else
mVideo = new VideoFFmpegComponent(window);
#else
#else
mVideo = new VideoFFmpegComponent(window);
#endif
#endif
mList.setPosition(mSize.x() * (0.50f + padding), mList.getPosition().y());
mList.setSize(mSize.x() * (0.50f - padding), mList.getSize().y());
@ -87,21 +73,21 @@ VideoGameListView::VideoGameListView(
mThumbnail.setOrigin(0.5f, 0.5f);
mThumbnail.setPosition(2.0f, 2.0f);
mThumbnail.setVisible(false);
mThumbnail.setMaxSize(mSize.x() * (0.25f - 2 * padding), mSize.y() * 0.10f);
mThumbnail.setMaxSize(mSize.x() * (0.25f - 2.0f * padding), mSize.y() * 0.10f);
mThumbnail.setDefaultZIndex(35);
addChild(&mThumbnail);
// Marquee.
mMarquee.setOrigin(0.5f, 0.5f);
mMarquee.setPosition(mSize.x() * 0.25f, mSize.y() * 0.10f);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2 * padding), mSize.y() * 0.18f);
mMarquee.setMaxSize(mSize.x() * (0.5f - 2.0f * padding), mSize.y() * 0.18f);
mMarquee.setDefaultZIndex(35);
addChild(&mMarquee);
// Video.
mVideo->setOrigin(0.5f, 0.5f);
mVideo->setPosition(mSize.x() * 0.25f, mSize.y() * 0.4f);
mVideo->setSize(mSize.x() * (0.5f - 2 * padding), mSize.y() * 0.4f);
mVideo->setSize(mSize.x() * (0.5f - 2.0f * padding), mSize.y() * 0.4f);
mVideo->setDefaultZIndex(30);
addChild(mVideo);
@ -140,8 +126,8 @@ VideoGameListView::VideoGameListView(
addChild(&mName);
mDescContainer.setPosition(mSize.x() * padding, mSize.y() * 0.65f);
mDescContainer.setSize(mSize.x() * (0.50f - 2 * padding), mSize.y() -
mDescContainer.getPosition().y());
mDescContainer.setSize(mSize.x() * (0.50f - 2.0f * padding),
mSize.y() - mDescContainer.getPosition().y());
mDescContainer.setAutoScroll(true);
mDescContainer.setDefaultZIndex(40);
addChild(&mDescContainer);
@ -160,10 +146,7 @@ VideoGameListView::VideoGameListView(
initMDValues();
}
VideoGameListView::~VideoGameListView()
{
delete mVideo;
}
VideoGameListView::~VideoGameListView() { delete mVideo; }
void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
{
@ -171,22 +154,23 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
using namespace ThemeFlags;
mThumbnail.applyTheme(theme, getName(), "md_thumbnail",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mMarquee.applyTheme(theme, getName(), "md_marquee",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mImage.applyTheme(theme, getName(), "md_image",
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | ROTATION | VISIBLE);
mVideo->applyTheme(theme, getName(), "md_video",
POSITION | ThemeFlags::SIZE | ThemeFlags::DELAY | Z_INDEX | ROTATION | VISIBLE);
POSITION | ThemeFlags::SIZE | ThemeFlags::DELAY | Z_INDEX | ROTATION |
VISIBLE);
mName.applyTheme(theme, getName(), "md_name", ALL);
initMDLabels();
std::vector<TextComponent*> labels = getMDLabels();
assert(labels.size() == 8);
std::vector<std::string> lblElements = {
"md_lbl_rating", "md_lbl_releasedate", "md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players", "md_lbl_lastplayed", "md_lbl_playcount"
};
std::vector<std::string> lblElements = { "md_lbl_rating", "md_lbl_releasedate",
"md_lbl_developer", "md_lbl_publisher",
"md_lbl_genre", "md_lbl_players",
"md_lbl_lastplayed", "md_lbl_playcount" };
for (unsigned int i = 0; i < labels.size(); i++)
labels[i]->applyTheme(theme, getName(), lblElements[i], ALL);
@ -194,19 +178,19 @@ void VideoGameListView::onThemeChanged(const std::shared_ptr<ThemeData>& theme)
initMDValues();
std::vector<GuiComponent*> values = getMDValues();
assert(values.size() == 8);
std::vector<std::string> valElements = {
"md_rating", "md_releasedate", "md_developer", "md_publisher",
"md_genre", "md_players", "md_lastplayed", "md_playcount"
};
std::vector<std::string> valElements = { "md_rating", "md_releasedate", "md_developer",
"md_publisher", "md_genre", "md_players",
"md_lastplayed", "md_playcount" };
for (unsigned int i = 0; i < values.size(); i++)
values[i]->applyTheme(theme, getName(), valElements[i], ALL ^ ThemeFlags::TEXT);
mDescContainer.applyTheme(theme, getName(), "md_description",
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
POSITION | ThemeFlags::SIZE | Z_INDEX | VISIBLE);
mDescription.setSize(mDescContainer.getSize().x(), 0);
mDescription.applyTheme(theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mDescription.applyTheme(
theme, getName(), "md_description",
ALL ^ (POSITION | ThemeFlags::SIZE | ThemeFlags::ORIGIN | TEXT | ROTATION));
mGamelistInfo.applyTheme(theme, getName(), "gamelistInfo", ALL ^ ThemeFlags::TEXT);
// If there is no position defined in the theme for gamelistInfo, then hide it.
@ -238,7 +222,7 @@ void VideoGameListView::initMDLabels()
}
else {
// Work from the last component.
GuiComponent* lc = components[i-1];
GuiComponent* lc = components[i - 1];
pos = lc->getPosition() + Vector3f(0, lc->getSize().y() + rowPadding, 0);
}
@ -265,11 +249,11 @@ void VideoGameListView::initMDValues()
float bottom = 0.0f;
const float colSize = (mSize.x() * 0.48f) / 2;
const float colSize = (mSize.x() * 0.48f) / 2.0f;
for (unsigned int i = 0; i < labels.size(); i++) {
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2;
const float heightDiff = (labels[i]->getSize().y() - values[i]->getSize().y()) / 2.0f;
values[i]->setPosition(labels[i]->getPosition() +
Vector3f(labels[i]->getSize().x(),heightDiff, 0));
Vector3f(labels[i]->getSize().x(), heightDiff, 0));
values[i]->setSize(colSize - labels[i]->getSize().x(), values[i]->getSize().y());
values[i]->setDefaultZIndex(40);
@ -280,8 +264,8 @@ void VideoGameListView::initMDValues()
}
mDescContainer.setPosition(mDescContainer.getPosition().x(), bottom + mSize.y() * 0.01f);
mDescContainer.setSize(mDescContainer.getSize().x(), mSize.y() -
mDescContainer.getPosition().y());
mDescContainer.setSize(mDescContainer.getSize().x(),
mSize.y() - mDescContainer.getPosition().y());
}
void VideoGameListView::updateInfoPanel()
@ -300,7 +284,7 @@ void VideoGameListView::updateInfoPanel()
if (file) {
// Always hide the metadata fields if browsing grouped custom collections.
if (file->getSystem()->isCustomCollection() &&
file->getPath() == file->getSystem()->getName())
file->getPath() == file->getSystem()->getName())
hideMetaDataFields = true;
else
hideMetaDataFields = (file->metadata.get("hidemetadata") == "true");
@ -316,9 +300,9 @@ void VideoGameListView::updateInfoPanel()
// or if we're in the grouped custom collection view.
if (mList.isScrolling())
if ((mLastUpdated && mLastUpdated->metadata.get("hidemetadata") == "true") ||
(mLastUpdated->getSystem()->isCustomCollection() &&
mLastUpdated->getPath() == mLastUpdated->getSystem()->getName()))
hideMetaDataFields = true;
(mLastUpdated->getSystem()->isCustomCollection() &&
mLastUpdated->getPath() == mLastUpdated->getSystem()->getName()))
hideMetaDataFields = true;
if (hideMetaDataFields) {
mLblRating.setVisible(false);
@ -367,9 +351,9 @@ void VideoGameListView::updateInfoPanel()
// which will generate a description of three random games and return a pointer to
// the first of these so that we can display its game media.
if (file->getSystem()->isCustomCollection() &&
file->getPath() == file->getSystem()->getName()) {
mRandomGame = CollectionSystemsManager::get()->
updateCollectionFolderMetadata(file->getSystem());
file->getPath() == file->getSystem()->getName()) {
mRandomGame =
CollectionSystemsManager::get()->updateCollectionFolderMetadata(file->getSystem());
if (mRandomGame) {
mThumbnail.setImage(mRandomGame->getThumbnailPath());
mMarquee.setImage(mRandomGame->getMarqueePath());
@ -398,7 +382,6 @@ void VideoGameListView::updateInfoPanel()
mVideo->setImage(file->getImagePath());
mVideo->onHide();
if (!mVideo->setVideo(file->getVideoPath()))
mVideo->setDefaultVideo();
}
@ -418,21 +401,21 @@ void VideoGameListView::updateInfoPanel()
if (mIsFiltered) {
if (mFilteredGameCountAll == mFilteredGameCount)
gamelistInfoString += ViewController::FILTER_CHAR + " " +
std::to_string(mFilteredGameCount) + " / " +
std::to_string(mGameCount);
std::to_string(mFilteredGameCount) + " / " +
std::to_string(mGameCount);
else
gamelistInfoString += ViewController::FILTER_CHAR + " " +
std::to_string(mFilteredGameCount) + " + " +
std::to_string(mFilteredGameCountAll - mFilteredGameCount) + " / " +
std::to_string(mGameCount);
std::to_string(mFilteredGameCount) + " + " +
std::to_string(mFilteredGameCountAll - mFilteredGameCount) +
" / " + std::to_string(mGameCount);
}
else {
gamelistInfoString += ViewController::CONTROLLER_CHAR + " " +
std::to_string(mGameCount);
gamelistInfoString +=
ViewController::CONTROLLER_CHAR + " " + std::to_string(mGameCount);
if (!(file->getSystem()->isCollection() &&
file->getSystem()->getFullName() == "favorites"))
gamelistInfoString += " " + ViewController::FAVORITE_CHAR + " "
+ std::to_string(mFavoritesGameCount);
file->getSystem()->getFullName() == "favorites"))
gamelistInfoString += " " + ViewController::FAVORITE_CHAR + " " +
std::to_string(mFavoritesGameCount);
}
if (mIsFolder && infoAlign != ALIGN_RIGHT)
@ -442,9 +425,9 @@ void VideoGameListView::updateInfoPanel()
// Fade in the game image.
auto func = [this](float t) {
mVideo->setOpacity(static_cast<unsigned char>(Math::lerp(
static_cast<float>(FADE_IN_START_OPACITY), 1.0f, t) * 255));
};
mVideo->setOpacity(static_cast<unsigned char>(
Math::lerp(static_cast<float>(FADE_IN_START_OPACITY), 1.0f, t) * 255));
};
mVideo->setAnimation(new LambdaAnimation(func, FADE_IN_TIME), 0, nullptr, false);
mDescription.setText(file->metadata.get("desc"));
@ -498,10 +481,7 @@ void VideoGameListView::updateInfoPanel()
}
}
void VideoGameListView::launch(FileData* game)
{
ViewController::get()->triggerGameLaunch(game);
}
void VideoGameListView::launch(FileData* game) { ViewController::get()->triggerGameLaunch(game); }
std::vector<TextComponent*> VideoGameListView::getMDLabels()
{

2
es-core/CMakeLists.txt
View file

@ -48,7 +48,6 @@ set(CORE_HEADERS
${CMAKE_CURRENT_SOURCE_DIR}/src/components/TextListComponent.h
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoComponent.h
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoFFmpegComponent.h
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoOmxComponent.h
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoVlcComponent.h
# GUIs
@ -126,7 +125,6 @@ set(CORE_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/src/components/TextEditComponent.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoComponent.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoFFmpegComponent.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoOmxComponent.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/components/VideoVlcComponent.cpp
# GUIs

25
es-core/src/AsyncHandle.h
View file

@ -12,7 +12,7 @@
#include <string>
enum AsyncHandleStatus {
ASYNC_IN_PROGRESS,
ASYNC_IN_PROGRESS, // Replace with AllowShortEnumsOnASingleLine: false (clang-format >=11.0).
ASYNC_ERROR,
ASYNC_DONE
};
@ -21,17 +21,24 @@ enum AsyncHandleStatus {
class AsyncHandle
{
public:
AsyncHandle() : mStatus(ASYNC_IN_PROGRESS) {};
virtual ~AsyncHandle() {};
AsyncHandle()
: mStatus(ASYNC_IN_PROGRESS)
{
}
virtual ~AsyncHandle() {}
virtual void update() = 0;
// Update and return the latest status.
inline AsyncHandleStatus status() { update(); return mStatus; }
AsyncHandleStatus status()
{
update();
return mStatus;
}
// User-friendly string of our current status.
// Will return error message if status() == SEARCH_ERROR.
inline std::string getStatusString()
std::string getStatusString()
{
switch (mStatus) {
case ASYNC_IN_PROGRESS:
@ -46,8 +53,12 @@ public:
}
protected:
inline void setStatus(AsyncHandleStatus status) { mStatus = status; }
inline void setError(const std::string& error) { setStatus(ASYNC_ERROR); mError = error; }
void setStatus(AsyncHandleStatus status) { mStatus = status; }
void setError(const std::string& error)
{
setStatus(ASYNC_ERROR);
mError = error;
}
std::string mError;
AsyncHandleStatus mStatus;

102
es-core/src/AudioManager.cpp
View file

@ -19,17 +19,20 @@ std::vector<std::shared_ptr<Sound>> AudioManager::sSoundVector;
SDL_AudioDeviceID AudioManager::sAudioDevice = 0;
SDL_AudioSpec AudioManager::sAudioFormat;
SDL_AudioStream* AudioManager::sConversionStream;
bool AudioManager::sMuteStream = false;
bool AudioManager::sHasAudioDevice = true;
bool AudioManager::mIsClearingStream = false;
AudioManager::AudioManager()
{
// Init on construction.
init();
}
AudioManager::~AudioManager()
{
// Deinit on destruction.
deinit();
}
@ -74,7 +77,7 @@ void AudioManager::init()
}
sAudioDevice = SDL_OpenAudioDevice(0, 0, &sRequestedAudioFormat, &sAudioFormat,
SDL_AUDIO_ALLOW_ANY_CHANGE);
SDL_AUDIO_ALLOW_ANY_CHANGE);
if (sAudioDevice == 0) {
LOG(LogError) << "Unable to open audio device: " << SDL_GetError();
@ -82,29 +85,30 @@ void AudioManager::init()
}
if (sAudioFormat.freq != sRequestedAudioFormat.freq) {
LOG(LogDebug) << "AudioManager::init(): Requested sample rate " <<
std::to_string(sRequestedAudioFormat.freq) << " could not be "
"set, obtained " << std::to_string(sAudioFormat.freq);
LOG(LogDebug) << "AudioManager::init(): Requested sample rate "
<< std::to_string(sRequestedAudioFormat.freq)
<< " could not be set, obtained " << std::to_string(sAudioFormat.freq);
}
if (sAudioFormat.format != sRequestedAudioFormat.format) {
LOG(LogDebug) << "AudioManager::init(): Requested format " <<
std::to_string(sRequestedAudioFormat.format) << " could not be "
"set, obtained " << std::to_string(sAudioFormat.format);
LOG(LogDebug) << "AudioManager::init(): Requested format "
<< std::to_string(sRequestedAudioFormat.format)
<< " could not be set, obtained " << std::to_string(sAudioFormat.format);
}
if (sAudioFormat.channels != sRequestedAudioFormat.channels) {
LOG(LogDebug) << "AudioManager::init(): Requested channel count " <<
std::to_string(sRequestedAudioFormat.channels) << " could not be "
"set, obtained " << std::to_string(sAudioFormat.channels);
LOG(LogDebug) << "AudioManager::init(): Requested channel count "
<< std::to_string(sRequestedAudioFormat.channels)
<< " could not be set, obtained " << std::to_string(sAudioFormat.channels);
}
#if defined(_WIN64) || defined(__APPLE__)
#if defined(_WIN64) || defined(__APPLE__)
// Beats me why the buffer size is not divided by the channel count on some operating systems.
if (sAudioFormat.samples != sRequestedAudioFormat.samples) {
#else
#else
if (sAudioFormat.samples != sRequestedAudioFormat.samples / sRequestedAudioFormat.channels) {
#endif
LOG(LogDebug) << "AudioManager::init(): Requested sample buffer size " <<
std::to_string(sRequestedAudioFormat.samples / sRequestedAudioFormat.channels) <<
" could not be set, obtained " << std::to_string(sAudioFormat.samples);
#endif
LOG(LogDebug) << "AudioManager::init(): Requested sample buffer size "
<< std::to_string(sRequestedAudioFormat.samples /
sRequestedAudioFormat.channels)
<< " could not be set, obtained " << std::to_string(sAudioFormat.samples);
}
// Just in case someone changed the es_settings.xml file manually to invalid values.
@ -126,7 +130,7 @@ void AudioManager::deinit()
// user on some operating systems such as macOS, and it's annoying to have a crash at the
// end of debugging session. So we'll simply disable the function until it has been properly
// fixed in the SDL library.
// SDL_FreeAudioStream(sConversionStream);
// SDL_FreeAudioStream(sConversionStream);
SDL_CloseAudio();
SDL_QuitSubSystem(SDL_INIT_AUDIO);
@ -153,9 +157,9 @@ void AudioManager::mixAudio(void* /*unused*/, Uint8* stream, int len)
restLength = len;
}
// Mix sample into stream.
SDL_MixAudioFormat(stream, &(sound->getData()[sound->getPosition()]),
sAudioFormat.format, restLength, static_cast<int>(Settings::getInstance()->
getInt("SoundVolumeNavigation") * 1.28f));
SDL_MixAudioFormat(
stream, &(sound->getData()[sound->getPosition()]), sAudioFormat.format, restLength,
static_cast<int>(Settings::getInstance()->getInt("SoundVolumeNavigation") * 1.28f));
if (sound->getPosition() + restLength < sound->getLength()) {
// Sample hasn't ended yet.
stillPlaying = true;
@ -191,8 +195,8 @@ void AudioManager::mixAudio(void* /*unused*/, Uint8* stream, int len)
std::vector<Uint8> converted(chunkLength);
int processedLength = SDL_AudioStreamGet(sConversionStream,
static_cast<void*>(&converted.at(0)), chunkLength);
int processedLength =
SDL_AudioStreamGet(sConversionStream, static_cast<void*>(&converted.at(0)), chunkLength);
if (processedLength < 0) {
LOG(LogError) << "AudioManager::mixAudio(): Couldn't convert sound chunk:";
@ -201,9 +205,9 @@ void AudioManager::mixAudio(void* /*unused*/, Uint8* stream, int len)
}
// Enable only when needed, as this generates a lot of debug output.
// LOG(LogDebug) << "AudioManager::mixAudio(): chunkLength "
// "/ processedLength / streamLength: " << chunkLength << " / " <<
// " / " << processedLength << " / " << streamLength;
// LOG(LogDebug) << "AudioManager::mixAudio(): chunkLength "
// "/ processedLength / streamLength: " << chunkLength << " / " <<
// " / " << processedLength << " / " << streamLength;
// This mute flag is used to make sure that the audio buffer already sent to the
// stream is not played when the video player has been stopped. Otherwise there would
@ -213,8 +217,9 @@ void AudioManager::mixAudio(void* /*unused*/, Uint8* stream, int len)
SDL_MixAudioFormat(stream, &converted.at(0), sAudioFormat.format, processedLength, 0);
}
else {
SDL_MixAudioFormat(stream, &converted.at(0), sAudioFormat.format, processedLength,
static_cast<int>(Settings::getInstance()->getInt("SoundVolumeVideos") * 1.28f));
SDL_MixAudioFormat(
stream, &converted.at(0), sAudioFormat.format, processedLength,
static_cast<int>(Settings::getInstance()->getInt("SoundVolumeVideos") * 1.28f));
}
// If nothing is playing, pause the device until there is more audio to output.
@ -224,6 +229,7 @@ void AudioManager::mixAudio(void* /*unused*/, Uint8* stream, int len)
void AudioManager::registerSound(std::shared_ptr<Sound>& sound)
{
// Add sound to sound vector.
sSoundVector.push_back(sound);
}
@ -267,7 +273,7 @@ void AudioManager::setupAudioStream(int sampleRate)
// Used for streaming audio from videos.
sConversionStream = SDL_NewAudioStream(AUDIO_F32, 2, sampleRate, sAudioFormat.format,
sAudioFormat.channels, sAudioFormat.freq);
sAudioFormat.channels, sAudioFormat.freq);
if (sConversionStream == nullptr) {
LOG(LogError) << "Failed to create audio conversion stream:";
LOG(LogError) << SDL_GetError();
@ -298,21 +304,39 @@ void AudioManager::clearStream()
// The SDL_AudioStreamClear() function is unstable and causes random crashes, so
// we have to implement a workaround instead where SDL_AudioStreamGet() is used
// to empty the stream.
// SDL_AudioStreamClear(sConversionStream);
// SDL_AudioStreamClear(sConversionStream);
// If sSoundVector is empty it means we are shutting down. In this case don't attempt
// to clear the stream as this could lead to a crash.
if (sSoundVector.empty())
return;
mIsClearingStream = true;
int streamSize;
int length = sAudioFormat.samples * 4;
while ((streamSize = SDL_AudioStreamAvailable(sConversionStream)) > 0) {
std::vector<Uint8> readBuffer(length);
int processedLength = SDL_AudioStreamGet(sConversionStream,
static_cast<void*>(&readBuffer.at(0)), length);
if (processedLength <= 0) {
break;
}
// This code is required as there's seemingly a bug in SDL_AudioStreamAvailable().
// The function sometimes returns 0 even if there is data left in the buffer, possibly
// because the remaining data is less than the configured sample size. It happens almost
// permanently on NetBSD but also on at least Linux from time to time. Adding some data
// to the stream buffer to get above this threshold before calling the function will
// return the proper number. So adding 10000 as we do here would give a return value of
// for instance 10880 instead of 0, assuming there were 880 bytes of data left in the buffer.
// Fortunately the SDL_AudioStreamGet() function acts correctly on any arbitrary sample size
// so we can actually clear the entire buffer. If this workaround was not implemented, there
// would be a sound glitch when some samples from the previous video would play any time a
// new video was started (assuming the issue was triggered be some remaining buffer data).
std::vector<Uint8> writeBuffer(10000);
if (SDL_AudioStreamPut(sConversionStream, reinterpret_cast<const void*>(&writeBuffer.at(0)),
10000) == -1) {
LOG(LogError) << "Failed to put samples in the conversion stream:";
LOG(LogError) << SDL_GetError();
mIsClearingStream = false;
return;
}
int length = SDL_AudioStreamAvailable(sConversionStream);
std::vector<Uint8> readBuffer(length);
SDL_AudioStreamGet(sConversionStream, static_cast<void*>(&readBuffer.at(0)), length);
mIsClearingStream = false;
}

40
es-core/src/CECInput.cpp
View file

@ -33,11 +33,12 @@ extern int SDL_USER_CECBUTTONUP;
CECInput* CECInput::sInstance = nullptr;
#if defined(HAVE_LIBCEC)
static void onAlert(void* /*cbParam*/, const CEC::libcec_alert type,
const CEC::libcec_parameter param)
static void onAlert(void* /*cbParam*/,
const CEC::libcec_alert type,
const CEC::libcec_parameter param)
{
LOG(LogDebug) << "CECInput::onAlert type: " << CECInput::getAlertTypeString(type) <<
" parameter: " << reinterpret_cast<char*>(param.paramData);
LOG(LogDebug) << "CECInput::onAlert type: " << CECInput::getAlertTypeString(type)
<< " parameter: " << reinterpret_cast<char*>(param.paramData);
}
static void onCommand(void* /*cbParam*/, const CEC::cec_command* command)
@ -50,7 +51,7 @@ static void onKeyPress(void* /*cbParam*/, const CEC::cec_keypress* key)
LOG(LogDebug) << "CECInput::onKeyPress keycode: " << CECInput::getKeyCodeString(key->keycode);
SDL_Event event;
event.type = (key->duration > 0) ? SDL_USER_CECBUTTONUP : SDL_USER_CECBUTTONDOWN;
event.type = (key->duration > 0) ? SDL_USER_CECBUTTONUP : SDL_USER_CECBUTTONDOWN;
event.user.code = key->keycode;
SDL_PushEvent(&event);
}
@ -93,14 +94,15 @@ void CECInput::deinit()
}
}
CECInput::CECInput() : mlibCEC(nullptr)
CECInput::CECInput()
: mlibCEC(nullptr)
{
#if defined(HAVE_LIBCEC)
#if defined(_RPI_)
#if defined(HAVE_LIBCEC)
#if defined(_RPI_)
// Restart vchi tv and CEC in case we just came back from another app using CEC (like Kodi).
vchi_tv_and_cec_deinit();
vchi_tv_and_cec_init();
#endif // _RPI_
#endif // _RPI_
CEC::ICECCallbacks callbacks;
CEC::libcec_configuration config;
@ -136,8 +138,8 @@ CECInput::CECInput() : mlibCEC(nullptr)
}
for (int i = 0; i < numAdapters; i++)
LOG(LogDebug) << "CEC adapter: " << i << " path: " << adapters[i].strComPath <<
" name: " << adapters[i].strComName;
LOG(LogDebug) << "CEC adapter: " << i << " path: " << adapters[i].strComPath
<< " name: " << adapters[i].strComName;
if (!mlibCEC->Open(adapters[0].strComName)) {
LOG(LogError) << "CECInput::mAdapter->Open failed";
@ -145,28 +147,29 @@ CECInput::CECInput() : mlibCEC(nullptr)
mlibCEC = nullptr;
return;
}
#endif // HAVE_LIBCEC
#endif // HAVE_LIBCEC
}
CECInput::~CECInput()
{
#if defined(HAVE_LIBCEC)
#if defined(HAVE_LIBCEC)
if (mlibCEC) {
mlibCEC->Close();
UnloadLibCec(mlibCEC);
mlibCEC = nullptr;
}
#if defined(_RPI_)
#if defined(_RPI_)
// Deinit vchi tv and CEC in case we are going to launch another app using CEC (like Kodi).
vchi_tv_and_cec_deinit();
#endif // _RPI_
#endif // HAVE_LIBCEC
#endif // _RPI_
#endif // HAVE_LIBCEC
}
std::string CECInput::getAlertTypeString(const unsigned int _type)
{
// clang-format off
switch (_type) {
#if defined(HAVE_LIBCEC)
case CEC::CEC_ALERT_SERVICE_DEVICE: { return "Service-Device"; } break;
@ -180,10 +183,12 @@ std::string CECInput::getAlertTypeString(const unsigned int _type)
#endif // HAVE_LIBCEC
default: { return "Unknown"; } break;
}
// clang-format on
}
std::string CECInput::getOpCodeString(const unsigned int _opCode)
{
// clang-format off
switch (_opCode) {
#if defined(HAVE_LIBCEC)
case CEC::CEC_OPCODE_ACTIVE_SOURCE: { return "Active-Source"; } break;
@ -261,10 +266,12 @@ std::string CECInput::getOpCodeString(const unsigned int _opCode)
#endif // HAVE_LIBCEC
default: { return "Unknown"; } break;
}
// clang-format on
}
std::string CECInput::getKeyCodeString(const unsigned int _keyCode)
{
// clang-format off
switch (_keyCode) {
#if defined(HAVE_LIBCEC)
case CEC::CEC_USER_CONTROL_CODE_SELECT: { return "Select"; } break;
@ -358,5 +365,6 @@ std::string CECInput::getKeyCodeString(const unsigned int _keyCode)
case 0:
#endif // HAVE_LIBCEC
default: { return "Unknown"; } break;
// clang-format off
}
}

7
es-core/src/CECInput.h
View file

@ -11,7 +11,10 @@
#include <string>
namespace CEC { class ICECAdapter; }
namespace CEC
{
class ICECAdapter;
}
class CECInput
{
@ -23,7 +26,7 @@ public:
static std::string getKeyCodeString(const unsigned int _keyCode);
private:
CECInput();
CECInput();
~CECInput();
static CECInput* sInstance;

262
es-core/src/GuiComponent.cpp
View file

@ -8,31 +8,30 @@
#include "GuiComponent.h"
#include "animations/Animation.h"
#include "animations/AnimationController.h"
#include "renderers/Renderer.h"
#include "Log.h"
#include "ThemeData.h"
#include "Window.h"
#include "animations/Animation.h"
#include "renderers/Renderer.h"
#include <algorithm>
GuiComponent::GuiComponent(Window* window)
: mWindow(window),
mParent(nullptr),
mColor(0),
mColorShift(0),
mColorShiftEnd(0),
mOpacity(255),
mSaturation(1.0),
mPosition(Vector3f::Zero()),
mOrigin(Vector2f::Zero()),
mRotationOrigin(0.5, 0.5),
mSize(Vector2f::Zero()),
mTransform(Transform4x4f::Identity()),
mIsProcessing(false),
mVisible(true),
mEnabled(true)
: mWindow(window)
, mParent(nullptr)
, mColor(0)
, mColorShift(0)
, mColorShiftEnd(0)
, mOpacity(255)
, mSaturation(1.0f)
, mPosition(Vector3f::Zero())
, mOrigin(Vector2f::Zero())
, mRotationOrigin(0.5f, 0.5f)
, mSize(Vector2f::Zero())
, mTransform(Transform4x4f::Identity())
, mIsProcessing(false)
, mVisible(true)
, mEnabled(true)
{
for (unsigned char i = 0; i < MAX_ANIMATIONS; i++)
mAnimationMap[i] = nullptr;
@ -94,105 +93,30 @@ void GuiComponent::renderChildren(const Transform4x4f& transform) const
getChild(i)->render(transform);
}
Vector3f GuiComponent::getPosition() const
{
return mPosition;
}
void GuiComponent::setPosition(float x, float y, float z)
{
mPosition = Vector3f(x, y, z);
onPositionChanged();
}
Vector2f GuiComponent::getOrigin() const
{
return mOrigin;
}
void GuiComponent::setOrigin(float x, float y)
{
mOrigin = Vector2f(x, y);
onOriginChanged();
}
Vector2f GuiComponent::getRotationOrigin() const
{
return mRotationOrigin;
}
void GuiComponent::setRotationOrigin(float x, float y)
{
mRotationOrigin = Vector2f(x, y);
}
Vector2f GuiComponent::getSize() const
{
return mSize;
}
void GuiComponent::setSize(float w, float h)
{
mSize = Vector2f(w, h);
onSizeChanged();
}
float GuiComponent::getRotation() const
{
return mRotation;
}
void GuiComponent::setRotation(float rotation)
{
mRotation = rotation;
}
float GuiComponent::getScale() const
{
return mScale;
}
void GuiComponent::setScale(float scale)
{
mScale = scale;
}
float GuiComponent::getZIndex() const
{
return mZIndex;
}
void GuiComponent::setZIndex(float z)
{
mZIndex = z;
}
float GuiComponent::getDefaultZIndex() const
{
return mDefaultZIndex;
}
void GuiComponent::setDefaultZIndex(float z)
{
mDefaultZIndex = z;
}
bool GuiComponent::isVisible() const
{
return mVisible;
}
void GuiComponent::setVisible(bool visible)
{
mVisible = visible;
}
Vector2f GuiComponent::getCenter() const
{
return Vector2f(mPosition.x() - (getSize().x() * mOrigin.x()) + getSize().x() / 2,
mPosition.y() - (getSize().y() * mOrigin.y()) + getSize().y() / 2);
return Vector2f(mPosition.x() - (getSize().x() * mOrigin.x()) + getSize().x() / 2.0f,
mPosition.y() - (getSize().y() * mOrigin.y()) + getSize().y() / 2.0f);
}
// Children stuff.
void GuiComponent::addChild(GuiComponent* cmp)
{
mChildren.push_back(cmp);
@ -222,11 +146,6 @@ void GuiComponent::removeChild(GuiComponent* cmp)
}
}
void GuiComponent::clearChildren()
{
mChildren.clear();
}
void GuiComponent::sortChildren()
{
std::stable_sort(mChildren.begin(), mChildren.end(), [](GuiComponent* a, GuiComponent* b) {
@ -234,15 +153,10 @@ void GuiComponent::sortChildren()
});
}
unsigned int GuiComponent::getChildCount() const
{
return static_cast<int>(mChildren.size());
}
int GuiComponent::getChildIndex() const
{
std::vector<GuiComponent*>::iterator it =
std::find(getParent()->mChildren.begin(), getParent()->mChildren.end(), this);
std::find(getParent()->mChildren.begin(), getParent()->mChildren.end(), this);
if (it != getParent()->mChildren.end())
return static_cast<int>(std::distance(getParent()->mChildren.begin(), it));
@ -250,26 +164,6 @@ int GuiComponent::getChildIndex() const
return -1;
}
GuiComponent* GuiComponent::getChild(unsigned int i) const
{
return mChildren.at(i);
}
void GuiComponent::setParent(GuiComponent* parent)
{
mParent = parent;
}
GuiComponent* GuiComponent::getParent() const
{
return mParent;
}
unsigned char GuiComponent::getOpacity() const
{
return mOpacity;
}
void GuiComponent::setOpacity(unsigned char opacity)
{
mOpacity = opacity;
@ -277,92 +171,47 @@ void GuiComponent::setOpacity(unsigned char opacity)
(*it)->setOpacity(opacity);
}
unsigned int GuiComponent::getColor() const
{
return mColor;
}
unsigned int GuiComponent::getColorShift() const
{
return mColorShift;
}
void GuiComponent::setColor(unsigned int color)
{
mColor = color;
mColorOpacity = mColor & 0x000000FF;
}
float GuiComponent::getSaturation() const
{
return static_cast<float>(mColor);
}
void GuiComponent::setSaturation(float saturation)
{
mSaturation = saturation;
}
void GuiComponent::setColorShift(unsigned int color)
{
mColorShift = color;
mColorShiftEnd = color;
}
const Transform4x4f& GuiComponent::getTransform()
{
mTransform = Transform4x4f::Identity();
mTransform.translate(mPosition);
if (mScale != 1.0)
if (mScale != 1.0f)
mTransform.scale(mScale);
if (mRotation != 0.0) {
if (mRotation != 0.0f) {
// Calculate offset as difference between origin and rotation origin.
Vector2f rotationSize = getRotationSize();
float xOff = (mOrigin.x() - mRotationOrigin.x()) * rotationSize.x();
float yOff = (mOrigin.y() - mRotationOrigin.y()) * rotationSize.y();
// Transform to offset point.
if (xOff != 0.0 || yOff != 0.0)
mTransform.translate(Vector3f(xOff * -1, yOff * -1, 0.0f));
if (xOff != 0.0f || yOff != 0.0f)
mTransform.translate(Vector3f(xOff * -1.0f, yOff * -1.0f, 0.0f));
// Apply rotation transform.
mTransform.rotateZ(mRotation);
// Transform back to original point.
if (xOff != 0.0 || yOff != 0.0)
if (xOff != 0.0f || yOff != 0.0f)
mTransform.translate(Vector3f(xOff, yOff, 0.0f));
}
mTransform.translate(Vector3f(mOrigin.x() * mSize.x() * -1,
mOrigin.y() * mSize.y() * -1, 0.0f));
mTransform.translate(
Vector3f(mOrigin.x() * mSize.x() * -1.0f, mOrigin.y() * mSize.y() * -1.0f, 0.0f));
return mTransform;
}
std::string GuiComponent::getValue() const
{
return "";
}
void GuiComponent::setValue(const std::string& /*value*/)
{
}
std::string GuiComponent::getHiddenValue() const
{
return "";
}
void GuiComponent::setHiddenValue(const std::string& /*value*/)
{
}
void GuiComponent::textInput(const std::string& text)
{
for (auto iter = mChildren.cbegin(); iter != mChildren.cend(); iter++)
(*iter)->textInput(text);
}
void GuiComponent::setAnimation(Animation* anim, int delay,
std::function<void()> finishedCallback, bool reverse, unsigned char slot)
void GuiComponent::setAnimation(Animation* anim,
int delay,
std::function<void()> finishedCallback,
bool reverse,
unsigned char slot)
{
assert(slot < MAX_ANIMATIONS);
@ -447,29 +296,14 @@ void GuiComponent::cancelAllAnimations()
cancelAnimation(i);
}
bool GuiComponent::isAnimationPlaying(unsigned char slot) const
{
return mAnimationMap[slot] != nullptr;
}
bool GuiComponent::isAnimationReversed(unsigned char slot) const
{
assert(mAnimationMap[slot] != nullptr);
return mAnimationMap[slot]->isReversed();
}
int GuiComponent::getAnimationTime(unsigned char slot) const
{
assert(mAnimationMap[slot] != nullptr);
return mAnimationMap[slot]->getTime();
}
void GuiComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view, const std::string& element, unsigned int properties)
const std::string& view,
const std::string& element,
unsigned int properties)
{
Vector2f scale = getParent() ? getParent()->getSize()
: Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
Vector2f scale = getParent() ? getParent()->getSize() :
Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
const ThemeData::ThemeElement* elem = theme->getElement(view, element, "");
if (!elem)
@ -484,9 +318,9 @@ void GuiComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
if (properties & ThemeFlags::SIZE && elem->has("size"))
setSize(elem->get<Vector2f>("size") * scale);
// Position + size also implies origin
if ((properties & ORIGIN || (properties & POSITION &&
properties & ThemeFlags::SIZE)) && elem->has("origin")) {
// Position + size also implies origin.
if ((properties & ORIGIN || (properties & POSITION && properties & ThemeFlags::SIZE)) &&
elem->has("origin")) {
setOrigin(elem->get<Vector2f>("origin"));
}
@ -521,16 +355,6 @@ void GuiComponent::updateHelpPrompts()
mWindow->setHelpPrompts(prompts, getHelpStyle());
}
HelpStyle GuiComponent::getHelpStyle()
{
return HelpStyle();
}
bool GuiComponent::isProcessing() const
{
return mIsProcessing;
}
void GuiComponent::onShow()
{
for (unsigned int i = 0; i < getChildCount(); i++)

159
es-core/src/GuiComponent.h
View file

@ -9,11 +9,12 @@
#ifndef ES_CORE_GUI_COMPONENT_H
#define ES_CORE_GUI_COMPONENT_H
#include "math/Misc.h"
#include "math/Transform4x4f.h"
#include "HelpPrompt.h"
#include "HelpStyle.h"
#include "InputConfig.h"
#include "animations/AnimationController.h"
#include "math/Misc.h"
#include "math/Transform4x4f.h"
#include <functional>
#include <memory>
@ -65,72 +66,84 @@ public:
// 4. Tell your children to render, based on your component's transform - renderChildren(t).
virtual void render(const Transform4x4f& parentTrans);
Vector3f getPosition() const;
inline void setPosition(const Vector3f& offset)
{ setPosition(offset.x(), offset.y(), offset.z()); }
Vector3f getPosition() const { return mPosition; }
void setPosition(const Vector3f& offset) { setPosition(offset.x(), offset.y(), offset.z()); }
void setPosition(float x, float y, float z = 0.0f);
virtual void onPositionChanged() {};
virtual void onPositionChanged() {}
Vector2f getOrigin() const { return mOrigin; }
// Sets the origin as a percentage of this image.
// (e.g. (0, 0) is top left, (0.5, 0.5) is the center.)
Vector2f getOrigin() const;
void setOrigin(float originX, float originY);
inline void setOrigin(Vector2f origin) { setOrigin(origin.x(), origin.y()); }
virtual void onOriginChanged() {};
void setOrigin(Vector2f origin) { setOrigin(origin.x(), origin.y()); }
virtual void onOriginChanged() {}
Vector2f getRotationOrigin() const { return mRotationOrigin; }
// Sets the rotation origin as a percentage of this image.
// (e.g. (0, 0) is top left, (0.5, 0.5) is the center.)
Vector2f getRotationOrigin() const;
void setRotationOrigin(float originX, float originY);
inline void setRotationOrigin(Vector2f origin)
{ setRotationOrigin(origin.x(), origin.y()); }
void setRotationOrigin(float originX, float originY)
{
mRotationOrigin = Vector2f(originX, originY);
}
void setRotationOrigin(Vector2f origin) { setRotationOrigin(origin.x(), origin.y()); }
virtual Vector2f getSize() const;
inline void setSize(const Vector2f& size) { setSize(size.x(), size.y()); }
virtual Vector2f getSize() const { return mSize; }
void setSize(const Vector2f& size) { setSize(size.x(), size.y()); }
void setSize(float w, float h);
virtual void setResize(float width, float height) {};
virtual void onSizeChanged() {};
virtual void setResize(float width, float height) {}
virtual void onSizeChanged() {}
virtual Vector2f getRotationSize() const { return getSize(); };
virtual Vector2f getRotationSize() const { return getSize(); }
float getRotation() const { return mRotation; }
void setRotation(float rotation) { mRotation = rotation; }
void setRotationDegrees(float rotation)
{
setRotation(static_cast<float>(ES_DEG_TO_RAD(rotation)));
}
float getRotation() const;
void setRotation(float rotation);
inline void setRotationDegrees(float rotation) {
setRotation(static_cast<float>(ES_DEG_TO_RAD(rotation))); }
float getScale() const { return mScale; }
void setScale(float scale) { mScale = scale; }
float getScale() const;
void setScale(float scale);
float getZIndex() const { return mZIndex; }
void setZIndex(float zIndex) { mZIndex = zIndex; }
float getZIndex() const;
void setZIndex(float zIndex);
float getDefaultZIndex() const { return mDefaultZIndex; }
void setDefaultZIndex(float zIndex) { mDefaultZIndex = zIndex; }
float getDefaultZIndex() const;
void setDefaultZIndex(float zIndex);
bool isVisible() const;
void setVisible(bool visible);
bool isVisible() const { return mVisible; }
void setVisible(bool visible) { mVisible = visible; }
// Returns the center point of the image (takes origin into account).
Vector2f getCenter() const;
void setParent(GuiComponent* parent);
GuiComponent* getParent() const;
void setParent(GuiComponent* parent) { mParent = parent; }
GuiComponent* getParent() const { return mParent; }
void addChild(GuiComponent* cmp);
void removeChild(GuiComponent* cmp);
void clearChildren();
void clearChildren() { mChildren.clear(); }
void sortChildren();
unsigned int getChildCount() const;
unsigned int getChildCount() const { return static_cast<int>(mChildren.size()); }
int getChildIndex() const;
GuiComponent* getChild(unsigned int i) const;
GuiComponent* getChild(unsigned int i) const { return mChildren.at(i); }
// Animation will be automatically deleted when it completes or is stopped.
bool isAnimationPlaying(unsigned char slot) const;
bool isAnimationReversed(unsigned char slot) const;
int getAnimationTime(unsigned char slot) const;
void setAnimation(Animation* animation, int delay = 0,
std::function<void()> finishedCallback = nullptr,
bool reverse = false, unsigned char slot = 0);
bool isAnimationPlaying(unsigned char slot) const { return mAnimationMap[slot] != nullptr; }
bool isAnimationReversed(unsigned char slot) const
{
assert(mAnimationMap[slot] != nullptr);
return mAnimationMap[slot]->isReversed();
}
int getAnimationTime(unsigned char slot) const
{
assert(mAnimationMap[slot] != nullptr);
return mAnimationMap[slot]->getTime();
}
void setAnimation(Animation* animation,
int delay = 0,
std::function<void()> finishedCallback = nullptr,
bool reverse = false,
unsigned char slot = 0);
bool stopAnimation(unsigned char slot);
// Like stopAnimation, but doesn't call finishedCallback - only removes the animation, leaving
// things in their current state. Returns true if successful (an animation was in this slot).
@ -143,45 +156,53 @@ public:
void stopAllAnimations();
void cancelAllAnimations();
virtual bool isListScrolling() { return false; };
virtual void stopListScrolling() {};
virtual unsigned char getOpacity() const;
virtual bool isListScrolling() { return false; }
virtual void stopListScrolling() {}
virtual unsigned char getOpacity() const { return mOpacity; }
virtual void setOpacity(unsigned char opacity);
virtual unsigned int getColor() const;
virtual unsigned int getColorShift() const;
virtual void setColor(unsigned int color);
virtual float getSaturation() const;
virtual void setSaturation(float saturation);
virtual void setColorShift(unsigned int color);
virtual void setOriginalColor(unsigned int color) { mColorOriginalValue = color; };
virtual void setChangedColor(unsigned int color) { mColorChangedValue = color; };
virtual unsigned int getColor() const { return mColor; }
virtual unsigned int getColorShift() const { return mColorShift; }
virtual void setColor(unsigned int color)
{
mColor = color;
mColorOpacity = mColor & 0x000000FF;
}
virtual float getSaturation() const { return static_cast<float>(mColor); }
virtual void setSaturation(float saturation) { mSaturation = saturation; }
virtual void setColorShift(unsigned int color)
{
mColorShift = color;
mColorShiftEnd = color;
}
virtual void setOriginalColor(unsigned int color) { mColorOriginalValue = color; }
virtual void setChangedColor(unsigned int color) { mColorChangedValue = color; }
// These functions are used to enable and disable options in menus, i.e. switches and similar.
virtual bool getEnabled() { return mEnabled; };
virtual void setEnabled(bool state) { mEnabled = state; };
virtual bool getEnabled() { return mEnabled; }
virtual void setEnabled(bool state) { mEnabled = state; }
virtual std::shared_ptr<Font> getFont() const { return nullptr; };
virtual std::shared_ptr<Font> getFont() const { return nullptr; }
const Transform4x4f& getTransform();
virtual std::string getValue() const;
virtual void setValue(const std::string& value);
virtual std::string getValue() const { return ""; }
virtual void setValue(const std::string& value) {}
virtual std::string getHiddenValue() const;
virtual void setHiddenValue(const std::string& value);
virtual std::string getHiddenValue() const { return ""; }
virtual void setHiddenValue(const std::string& value) {}
// Used to set the parameters for ScrollableContainer.
virtual void setScrollParameters(float, float, int) {};
virtual void setScrollParameters(float, float, int) {}
virtual void onFocusGained() {};
virtual void onFocusLost() {};
virtual void onFocusGained() {}
virtual void onFocusLost() {}
virtual void onShow();
virtual void onHide();
virtual void onStopVideo();
virtual void onPauseVideo();
virtual void onUnpauseVideo();
virtual bool isVideoPaused() { return false; };
virtual bool isVideoPaused() { return false; }
virtual void onScreensaverActivate();
virtual void onScreensaverDeactivate();
@ -192,18 +213,20 @@ public:
// Default implementation just handles <pos> and <size> tags as normalized float pairs.
// You probably want to keep this behavior for any derived classes as well as add your own.
virtual void applyTheme(const std::shared_ptr<ThemeData>& theme,
const std::string& view, const std::string& element, unsigned int properties);
const std::string& view,
const std::string& element,
unsigned int properties);
// Returns a list of help prompts.
virtual std::vector<HelpPrompt> getHelpPrompts() { return std::vector<HelpPrompt>(); };
virtual std::vector<HelpPrompt> getHelpPrompts() { return std::vector<HelpPrompt>(); }
// Called whenever help prompts change.
void updateHelpPrompts();
virtual HelpStyle getHelpStyle();
virtual HelpStyle getHelpStyle() { return HelpStyle(); }
// Returns true if the component is busy doing background processing (e.g. HTTP downloads).
bool isProcessing() const;
bool isProcessing() const { return mIsProcessing; }
const static unsigned char MAX_ANIMATIONS = 4;

6
es-core/src/HelpStyle.cpp
View file

@ -31,9 +31,9 @@ void HelpStyle::applyTheme(const std::shared_ptr<ThemeData>& theme, const std::s
return;
if (elem->has("pos"))
position = elem->get<Vector2f>("pos") *
Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
position =
elem->get<Vector2f>("pos") * Vector2f(static_cast<float>(Renderer::getScreenWidth()),
static_cast<float>(Renderer::getScreenHeight()));
if (elem->has("origin"))
origin = elem->get<Vector2f>("origin");

40
es-core/src/HttpReq.cpp
View file

@ -10,21 +10,21 @@
#include "HttpReq.h"
#include "Log.h"
#include "resources/ResourceManager.h"
#include "utils/FileSystemUtil.h"
#include "Log.h"
#include <assert.h>
CURLM* HttpReq::s_multi_handle;
std::map<CURL*, HttpReq*> HttpReq::s_requests;
std::string HttpReq::urlEncode(const std::string &s)
std::string HttpReq::urlEncode(const std::string& s)
{
const std::string unreserved =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~";
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~";
std::string escaped="";
std::string escaped = "";
for (size_t i = 0; i < s.length(); i++) {
if (unreserved.find_first_of(s[i]) != std::string::npos) {
escaped.push_back(s[i]);
@ -43,11 +43,13 @@ bool HttpReq::isUrl(const std::string& str)
{
// The worst guess.
return (!str.empty() && !Utils::FileSystem::exists(str) &&
(str.find("http://") != std::string::npos || str.find("https://") !=
std::string::npos || str.find("www.") != std::string::npos));
(str.find("http://") != std::string::npos ||
str.find("https://") != std::string::npos || str.find("www.") != std::string::npos));
}
HttpReq::HttpReq(const std::string& url) : mStatus(REQ_IN_PROGRESS), mHandle(nullptr)
HttpReq::HttpReq(const std::string& url)
: mStatus(REQ_IN_PROGRESS)
, mHandle(nullptr)
{
// The multi-handle is cleaned up via a call from GuiScraperSearch after the scraping
// has been completed for a game, meaning the handle is valid for all cURL requests
@ -57,14 +59,16 @@ HttpReq::HttpReq(const std::string& url) : mStatus(REQ_IN_PROGRESS), mHandle(nul
mHandle = curl_easy_init();
#if defined(_WIN64)
// On Windows, use the bundled cURL TLS/SSL certificates (which actually come from the
// Mozilla project). There is a possibility to use the OS provided Schannel certificates
// but I haven't been able to get this to work and it also seems to be problematic on
// older Windows versions.
#if defined(_WIN64)
curl_easy_setopt(mHandle, CURLOPT_CAINFO, ResourceManager::getInstance()->
getResourcePath(":/certificates/curl-ca-bundle.crt").c_str());
#endif
curl_easy_setopt(mHandle, CURLOPT_CAINFO,
ResourceManager::getInstance()
->getResourcePath(":/certificates/curl-ca-bundle.crt")
.c_str());
#endif
if (mHandle == nullptr) {
mStatus = REQ_IO_ERROR;
@ -140,8 +144,8 @@ HttpReq::~HttpReq()
CURLMcode merr = curl_multi_remove_handle(s_multi_handle, mHandle);
if (merr != CURLM_OK) {
LOG(LogError) << "Error removing curl_easy handle from curl_multi: " <<
curl_multi_strerror(merr);
LOG(LogError) << "Error removing curl_easy handle from curl_multi: "
<< curl_multi_strerror(merr);
}
curl_easy_cleanup(mHandle);
@ -194,16 +198,6 @@ std::string HttpReq::getContent() const
return mContent.str();
}
void HttpReq::onError(const std::string& msg)
{
mErrorMsg = msg;
}
std::string HttpReq::getErrorMsg()
{
return mErrorMsg;
}
// Used as a curl callback.
// size = size of an element, nmemb = number of elements.
// Return value is number of elements successfully read.

Some files were not shown because too many files have changed in this diff Show more