* Don't hide irrelevant elements in Windows, disable them and use them as information
* Create the `Manifests` folder in ProgramData if its parent exists.
Instead of loading images in the showEvent of the MainWindow,
load them in the showEvent of each widget. It seems to reduce
the startup stuttering this way. With some more work
we can only load the images for the widgets that are currently
visible and reduce the stutter even more.
At the same time, reduce the number of concurrent downloads
in the image manager and add a timeout so we won't halt.
The exception from the timeout is just logged at this point,
and the download is not requeued.
After the PathEdit change that stopped it from emitting the
textChanged signal when instatiated, the available space
calculation wouldn't take place, so do it when the dialog
becomes visible.
Previously a lot of things would start running concurrently at
startup as we were setting up the UI. This removes a considerable
amount of perceived delay.
Note: there are better ways to make sure forms are populated when they
are viewed, such as each widget's `showEvent()`
* Load and populate Ubisoft information when the page is shown instead of startup.
* List all Ubisoft games, and differentiate based on whether they been redeemed.
Removed some superfluous variables that were already exposed through
RareGame and moved around some block to correct initialization errors
after moving to instance attributes
Truncate the widget's text down to the command only without the arguments.
Show the full command with the arguments in the tooltip instead.
Update some text.
The order was determined by the order of the container dictionary entries.
Re-order them before returning the list by their index in the container
widget.
Fixes#304
* Check for updates each time the page is visited
* Updated links, developers and contributors.
* Use a less difficult to read color for links
The check for updates still happens at startup, there is now a
subsequent check every time the about label is visited.
The update check should be moved into RareCore itself in the future.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
Check if there is a `keyImages` attribute before accessing it, and return
an empty list in case it isn't available. Fixes a recent crash with
`Prison Architect - eureka Update 1` DLC.
Exit early from `download_image` if the requested image is currently being
downloaded. This avoids multiple preparations and loading callbacks for
queued images.
Remove checking for supported OS when creating the icon. Now we create
icons in `icns` format for `Darwin` irregardless the fact we don't use them
for anything.
By making the attribute into a set, we avoid adding already existing dlcs
back into it when refreshing the library. Fixes duplicated entries in
the DLC page.
The workers where co-dependent anyways as the non-asset worker
was started after the games worker had sent back its results.
By combining them we can move any data manipulations to the worker
and simplify the handling in RareCore.
When the user navigates to a different game info page, the dlc widgets
get deleted. Because the signal was connected to a lambda, the connection
wasn't severed upon deletion and once the DLC would finish downloading,
Rare would crash because the object with the piggyback signal was already
deleted. By using a dedicated slot to emit the signal we ensure that the
connction is severed at Qt object deletion
https://discord.com/channels/826881530310819914/884510635642216499/1111321692703305729
There is a tab character in the appId of Fallout New Vegas: Honest Hearts DLC, this breaks metadata storage
on Windows as they can't handle tabs at the end of the filename (?)
Legendary and Heroic are also affected, but it completed breaks Rare, so dodge it for now pending a fix.
Fortnite specifically doesn't provide `FolderName` in `customAttributes`, meaning we can't create the shortcut. If the attribute is not provided, assume that it is safe to use the application title.
Fixes: #283
Previously the unchanged contents check tested both `key` and `value`
at the same time, so the following case was not accepted.
`ENV_VAR=ENV_VAR`
No matter how unlikely it is for the key to be equal to the value, there
is no reason to restrict it.
For the `key` ("0") column, protecting against existing keys also handles
this case. For the `value` ("1") column, a check has been added.
Previously the `setGeometry()` method was called explicitly. In this
procedure the self-centering widget installs an `eventFilter` on its
parent to react to `Resize` events of the parent.
This breaks centering on the list widgets a bit, pending an investigation
In case a widget uses its own scrollareas for dynamic resizing
(for example the store), setting `implements_scrollarea` to `True`
will avoid the encapsulating scrollarea of the container.
Also partition the space to left and right layouts, left layout being the
image and the space below it (pending future usage), and right the
information.
Using a ChainMap and this custom model, we can display global environ
variables in the per-game settings, allowin better overview and
simpler override.
CloudSaves: don't save `save_path` in case it hasn't changed
IconGameWidget/ListGameWidget: Remove dead code
RareCore: add string translations
utils/paths: Use `AppDataLocation` instead of deprecated `DataLocation`
This allows to complete from relative paths, such use exe override
Fix constructor argument names to follow Qt's types.
Set the same filters as the dialog for the completer.
Use the completer's icon provider for the dialog.
Force Rare to use Qt's file dialog instead of the native one.
`egl_unintall` and `egl_export` try to access EGL's programdata folder which raises an exception if the folder doesn't exist (Windows) or it isn't specified (Linux). Copy the relevant bits from LegendaryCore to LgndrCore and create two new methods that only manipulate the `.egstore` folder.
If the save path wasn't known at startup, dt_local will be None. This led
to the UI displaying wrong information about the local save. Detect that
case and resolve the save's status again.
This specifically helps with games that have selectable downloads.
If we import a game with SDLs without any `install_tags` in the config
we will verify against the full game, meaning that files missing will
cause the verification to fail despite the game being correct. Since the
game is correct, resolving the download will result in a 0 size update.
This change will allow the InstallDialog to finish through the Install
button successfully despite having nothing to install.
On the `lgndr` side things are more complicated. Due to minor oversights
in legendary, the `install_tags` in the above example wouldn't be written
to the configuration file, causing a verification loop because the file
list wouldn't be filtered. To fix that, we also save legendary's config
file at the end of cleaning after a 0 size download.
When importing a game, the first thing being checked for import information
is `<install_dir>/.egstore`. Due to erroneous handling, that directory can
contain multiples of `.mancpn` and `.manifest` files. This could lead to
importing an older version as legendary expects only one pair of these
files to exist in that directory.
The `.egstore` folder is normally updated/created as part of synchronizing
with EGL. To aid with importing games in the future, we always export this
data for Rare to be able to import games between different OSes
We don't need to know if Origin is installed before launching the window,
so we can save on startup time by executing the worker after the window
has become visible.
To save time and requests, bulk get saves for all games and
load them into each respective RareGame.
Co-authored-by: Dummerle <44114474+dummerle@users.noreply.github.com>
Seems like Epic are changing their API again, and some image types have been renamed. This made the list of updates to be empty after filtering it for image types we could handle. This also had the side effect of an infinite recursion when downloading images, as the resulting pixmap would be null.
To fix this situation, the new image type has been added, and the image loading in RareGame has become two methods, one for loading and one for setting it.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
- Show text on widget if save is not up-to-date
- Fix text in game info -> cloud saves
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
This is the last change of the `backend_refactor` branch. This makes
`RareCore` the centerpiece of Rare by moving initialization before the UI
is brought up. RareCore is now in control of creating and querying `RareGame`
objects, re-introducing the ability (incomplete) to refresh the games library.
As a result, ApiResults has been removed.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
The reason is that `sys.excepthook` is a global attribute which we
have to unset for threads because we show a Qt dialog in it and we
can't do that from threads. Before this change, we used to unset
it in threads, but since it is a global attr, that was unsetting it
for the whole application. We cannot reliably reset it because we
can have multiple threads executing and there will be race conditions.
To fix this situation, `RareAppException` implements a callback to
be patched into `sys.excepthook` which emits a signal to be serviced
by the the `RareAppException` instance in the main thread.
`RareAppException` can be subclassed to implement the
`RareAppException._handler` method for domain specific handling.
The `RareApp` base class instantiates its own `RareAppException`
instance for early basic handling. `RareAppException` is subclassed
into `RareException` and `RareLauncherExcpetion` in `Rare` and `RareLauncher`
respectively to implement the aforemention domain specific handling.
Each of these classes deletes the previous instance and replace it
with their specialized handlers.
When the button gets clicked on, it receives keyboard focus. Disabling the button
afterwards leads to `focusNextChild` getting called. This makes the scrollarea
trying to ensure that `nextChild` is visible, essentially scrolling to a random widget
The static stylesheet properties are always applied. If there is a theme
stylesheet to be applied, they are appended in the end of the theme
stylesheet.
This removes stylesheet properties from the library widgets, some special
buttons and the queue worker labels.
To update the static stylesheet first edit `rare/resources/static_css/stylesheet.py`
and then execute it as a script.
Widgets that need to implement a title should be of a dual subclass
of any `QWidget` subclass and the `SideTabContents` class which provides
the signal.
Word wrapping allows ElideLabel to resize first inside flexible sized
areas such as the contents widget of a scrollarea. This allows the contents
widget to properly resize itself to avoid horizontal scrolling.
Word-wrapping also enables the widget to resize vertically. To avoid that
ElideLabel is set to a fixed height based on font metrics. An overloaded
method `setFixedHeight` has been added to disable it when desired.
EglSyncGroup: Replace estimated path label with a ElideLabel because
the displayed message was expanding the scrollarea.
Execute the edit callback function in a thread. By executing it in a thread
we don't have to wait for longer validation procedures to finish to
continue updating the UI. This is most notable in the MoveGamePopUp
which is heavy on disk IO.
Because we cannot use special text formatting in a thread, the
indicator messages have been reworked while also becoming extensible.
A dictionary of extended reasons can be specified through the
`IndicatorLineEdit.extend_reasons()` method.
The dictionary has to follow the following format
```
python
{
MyIndicatorReasons.REASON: self.tr("Reason message")
MyIndicatorReasons.OTHER_REASON: self.tr("Other reason message")
}
```
In the above example `MyIndicatorReasons` is a subclass of `IndicatorReasons`
which should be specified as follows
```
python
MyIndicatorReasons(IndicatorReasons):
REASON = auto()
OTHER_REASON = auto()
```
There are DLCs (for example KingletAztec) which are essentially
entitlements, a single file the allows access to already downloaded
content. Updates for such DLCs only change the metadata version number
without any actual new data. These DLCs are handled correctly by the
DLM, but our dialog would refuse to allow installing them due to 0 download
size. This change allows them to pass through the InstallDialog.
The other issue, which I don't know if it was only a result of our faulty
validation at startup or could occur in legendary too, is that a DLC might
be marked with needing verification. Currently we don't have a way of
verifying DLCs, so when verifying the game, we will also set the same
state for any installed DLCs. In effect verifying the game successfully
will also mark any DLCs as correct.
The active workers are placed in a static container on the left side.
The queued workers are placed in a scrollarea on the right side of the
status bar. The scrollbars are disabled but dragging works.
Exiting with active workers will pop up a message for confirmation. Rare
will clean the queued workers but the active ones will be waited on until
they finish.
Note: the `__update_widget()` method, while it doesn't have any visible delay
has the potential for improvement. I didn't do it because it felt like
premature optimization.
MoveGamePopUp: update it to use RareGame and it's signals
RareGame: Add `install_path` attribute and change `needs_verification` setter
Now both setters will update the local `igame` attribute and save it too.
MoveWorker: Update it to use RareGame.
Other changes include moving "same-drive" moving into the worker and using
`os.path` methods instead of `PathLib`
SteamGrades: Remove worker, it is implemented in RareGame now.
The `status_label` displays what is currently going on with the game.
It reflects the current operation running on it or if it requires special
attention (update, needs verification etc)
The `tooltip_label` displays hover information such as what happens
if a part of the widget is clicked or in the case of the launch button if
the game can run (without version check, offline etc)
The context menu on the widgets will be updated and populated according
to the installation state of the game. Since the context menu was revised
the shortcut creation code was revised too to make it more compact.
the `create_desktop_link` and `get_rare_executable` functions are moved
from `rare.utils.misc` to `rare.utils.paths` to avoid cyclical imports and
better grouping. Two functions are added, `desktop_link_path` to uniformly
calculate the path of the shortcut and `desktop_links_supported` which
checks if Rare supports creating shortcuts on the current platform.
`desktop_links_supported` should be used as safeguard before `desktop_link_path`.
Desktop links are currently untested on Windows but if `shortcut.Description`
works as expected, it should be good to go.
`LegendaryCore.get_non_asset_library_items()` returns the same tuple
for `game_list, dlc_dict` as for regular games with assets, so
keep the result for API completeness, since `RareGame` can handle those
games properly.
While not sure if it is required, add an expiration date to the prepared
download 30 minutes after it was prepared. If a download has been in the
queue for more than 30 minutes, the download will be prepared again silently
before starting.
Return only the `InstallOptionsModel` in the result of the download thread
to avoid the potential mistake of re-using it. This required for the tray
notification signal to operate on the `app_name` instead of the `app_title`.
As a result, the notification slot was moved into the TrayIcon class for
better encapsulation.
They are used to insert and remove updates from downloads when
the installation of a game changes through `RareGame.set_installed`.
They piggy-back the signals with the same names in `GlobalSignals`
When importing a game from EGL, also check
By preparing the download inside the widget, the delay after stopping
the running download and visual feedback of adding the widget is
reduced. The widget will now appear containing the basic information
and will be populated with the information about the download
when it is ready. The widget is disabled in the meantime.
Move `InstallInfoWorker` to `rare.shared.workers` module and
revert it to emitting a `InstallDownloadItem` model only
instead of a `InstallQueueItemModel.`
By using a QToolBox, we can better utilize the available space for
long lists of DLCs. `GameDlcWidget` is now responsible for handling
installing and uninstalling the DLC based on RareGame's functionality.
Since `GameUtils` is not used for uninstalling any more, remove it the
arguments of `GameInfoTabs` completely.
The widgets are not destroyed immediately so toggling based on
counting children in containers didn't work while in the same function.
Using the `destroyed` signal makes it clear when the change should happen.
Properly set object names for install and uninstall buttons in dialogs
Change margins on widgets that are put into scrollareas
Add top margin only on checkable QGroupBox
Remove padding from QToolBox
The `objectName()` of onstall and uninstall buttons should be set
to `InstallButton` and `UninstallButton` respectively for them to
pick up their special CSS properties.
Make QToolBox tab text bold
Clean-up deprecated widget object names in the CSS
Because `deleteLater()` doesn't delete the widget immediately (duh!)
`count()` and `contains()` can report false results while the widget
is queued for deletion.
Hide container and list/queue by name mangling.
Remove test code.
Similarly to the installation procedure, when an uninstall is
requested, an `UninstallOptionsModel` is emitted by the `RareGame`.
`DownloadsTab` handles the signal and spawns the `UninstallDialog`.
After the `UninstallDialog` is closed, a worker thread handles
uninstalling the application to avoid UI lock-ups when a large
number of files is deleted.
Allows for uninstall actions to be spawned from anything having
access to the `RareGame` instance.
LaunchDialog: Don't check health on DLCs, they always will require
verification if they don't specify an executable.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
instead of adding them again to the layout. Move game should still
switch to RareGame, similar to the way it works for verifing.
Also add non-functional "Import Game" button
Also remove attributes tracking the state of each application, those
are handled by `RareGame`
Temporarily disable save syncing related code, pending the move to
the game launcher process
When `Uninstall` is used from the widgets, it will take the user to
the `GameInfo` page similar to how `Install` works.
`GameInfo` is not connected to the `RareGame` instance's `installed`
and `uninstalled` signals to refresh the contents of the page based
on the related functionality.
When updates are queued, they are removed from the update's list. An exceptions is made
when the queued item comes from repairing (without updating), in which case the update is
disabled for the runtime.
A queued item can be either removed (if it is an update it will be added back to the
updates groups) or forced to be updated now. If a queued item is forced, the currently
running item will be added to the front of the queue. Downloads will be queued if
there is no active download but there is a queue already.
The download thread is now responsible for emitting the progress to `RareGame`
InstallDialog: Pass `RareGame` and `InstallOptionsModel` only as arguments.
The `update`, `repair` and `silent` arguments are already part of `InstallOptionsModel`
`RareGame` is used to query information about the game.
InstallInfoWorker: Pass only `InstallOptionsModel` as argument
Emit `InstallQueueItemModel` as result, to re-use the worker when queuing stopped games
RareGame: Query and store metadata property about entitlement grant date
RareGame: Add `RareEosOverlay` class that imitates `RareGame` to handle the overlay
LibraryWidgetController: Remove dead signal routing code, these signals are handled by `RareGame`
Directly parent library widgets instead of reparenting them
GameWidgets: Remove unused signals
EOSGroup: Set install location based on preferences and use EOSOverlayApp from legendary
GamesTab: Connect the `progress` signals of dlcs to the base game's signals
GamesTab: Remove dead code
GlobalSignals: Remove `ProgresSignals`
RareCore: Mangle internal signleton's names
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
Since pyuic5 doesn't handle `connectSlotByName=False` in ui files
use sed in `misc/ui2py.sh` to remove those lines
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
Subclass `EGLSyncListGroup` and `EGLSyncListItem` into import/export
specific classes. This way we don't have to specify the type of
operation at instatiation and improves code clarity and intention.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
The `GameProcess` class now acts as a persistent member of `RareGame`
that can be re-used for launching games. Its signals are handled and
repeated by `RareGame`.
Implements launching directly into `RareGame`
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
In the same vain, move `rare/game_launch_helper/message_models` into `rare/modes` since it is used in both the server and the client side.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
Consistency is achieved by always updating the shared metadata dictionary
before writing it to the disk.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
This merges a few of the internal features of RareCore such us
RareGame filtering and thus game grouping based on attributes.
This is required to properly connect a single signal from RareCore to
the downloads tab for game installation. This also includes filtering
games based on updates and other attributes.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
The original status_label is used to reflect the state of the game,
the tooltip_label is used to reflect the action of the current hovered
widget.
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
Removed `rare.utils.legendary_utils`, the `uninstall_game` function
was moved to `rare.shared.game_utils` for now
Signed-off-by: loathingKernel <142770+loathingKernel@users.noreply.github.com>
Currently this is achieved by toggling the checked state twice
in a programmatic way. This ensures correct animations until
a better solution is found.
In addition, now both CollapsibleFrame and CollapsibleGroupBox
inherit their common methods from the abstract class CollapsibleBase.
Signals, if they carry the same datatype, can be chained simply
with `signal.connect(othersignal)` without the need to use a `lambda`
expression and `emit()`
TabWidget: Fix error because the `exit_app` signal was called directly
This change makes it more inline with how QScrollArea operates on a central widget.
Other changes include using a QFrame instead of a QWidget as a base and
adding a QLabel for the title instead of the horizontal line.
The advanced options were split into their own separate widget. Right now
their class operates only as a container with the logic remaining in the
InstallDialog.