Not exactly sure what size they end up as with the extra column, but from my research medium tile templates are 150x150, and wide tiles are 310x150. Small tiles look pretty good at 70x70. This StackOverflow post says WP8.0 tile sizes are 210x210 for medium, 430x210 for wide, and 100x100 for small if you're on a 480x800 device: https://stackoverflow.com/questions/12837720/windows-phone-8-startscreen-tile-sizes-and-margins

Could be useful as a backup, though it won't do anything under Windows unless the user provides a WSL command.

Not sure how to see whether it's docked or not, but if I figure that out, it'll be useful. Probably will have to test to see whether the .desktop file has X-Purism-FormFactor=Workstation;Mobile; in it and show it, or if it lacks Mobile;, hide it in undocked mode. May have to simulate docked mode unless the PinePhone's docked mode starts working soon, as it doesn't seem to work for me.

The 8.0 animations made me sick to my stomach after using 8.1 for a while, so that's why I'm doing the 8.1 ones. There are also transition animations when opening apps or going back to the previous app from the Start screen, so I have to be sure to implement those as well.

Pressing either the Back button or the Windows button on the Start screen will take you to the top, as will pressing the Windows key no matter where you are. Adding a tile scrolls you down to show the tile being added.

Not sure if I'd actually try to make this unless I'm bored with all other projects, but I'm just putting this here just in case. I'd have to give credit to Microsoft for the original version and that I got the idea from that one.

I think this should go in its own repo since it's not necessarily directly related to everything else in Retiled, even though it was a Windows Phone game. I'll see. Maybe there will be a "RetiledGames" folder in this repo.

Using Godot 2D would probably work well and be simple enough. I want this to run well on the PinePhone, so Unity is out of the question.

I'd add several features, mainly:

• Multiple environments (like adding a forest-style area)
• More control options in addition to tilting the device
  • Touch-and-drag and click-and-drag input
    • Touching and dragging or clicking and dragging will both simulate tilting the phone in whichever direction was dragged in.
    • Dragging back to the center will put the ball in neutral.
    • It would be useful to allow people to change the draggable area to whatever space they need, for better accessibility.
  • Arrow keys
    • Simulates tilting, just like dragging.
    • The keys used can be changed.
    • Spacebar (or another key of the player's choosing) is used to put the ball in neutral, as if simulating returning the phone to where it was.
  • PineTime tilt controls would be cool as another way to use tilt controls without tilting the phone itself. Would help with accessibility, as people would be able to continue to see the screen no matter how the watch is tilted. I found I had to move around a lot to continue to see the screen when I played it several years ago.
  • Anything anyone else implements
• Boss levels
  • One idea is that there can be an "evil ball" that'll cause your balls to split, and if you don't have any to split, then you'll have to try the level again. The "evil ball" could be glowing red and be spiky. You'll have to avoid it as you move your own ball(s) around, as it'll have similar physics to yours.

Microsoft's Selawik should be a decent enough alternative to Segoe UI to use for the text, though there needs to be a way to ensure the possibility of changing the default font: https://github.com/Microsoft/Selawik

There's also a "Symbols" font that's like Selawik but for icons as a fallback for Segoe UI Symbol and the MDL2 icon font: https://github.com/microsoft/fonts

If it's possible, I may just fork the Fluent font icons and alter the SVG files so they're more squared like the WP8 ones, considering there are things like battery charge icons, Wi-Fi status, and other stuff: https://github.com/microsoft/fluentui-system-icons

(This will be edited to be more concise; just copying over things for now.)

(note Oct. 3, 2023: I'm relicensing to the GPL, so I'll just use the idea with the Generic Driver thing I have to support multiple devices)

Discussed in #16

These would have to be exposed as properties so that they can be changed when doing things like rotating the tile resize button. Maybe I should just override the text content item to have more control over how the text is positioned on rotation.

I forgot to do that, but I need to go to sleep soon.

I don't think Windows Phone had that issue. Only noticed that when watching the landscape demo.

This would be done on a per-app basis, though I'd like to integrate this into an API of some sort if possible. Some apps like Start wouldn't have this, but instead would go to the most recently-activated app if there's anything else open. Likewise, apps that don't support this API at all will go back to the previously-activated app.

Hopefully something can be integrated for Firefox and other browsers so people can use the Back button to go to the previous page or close the tab if they can't go back further. Maybe an extension can be written to implement this API, similar to the Plasma browser integration one. There will have to be some way to know if Escape will be fine to use, such as for popups and menus.

This one seems pretty good:
https://nicolasdeory.medium.com/simple-ipc-using-named-pipes-in-net-core-7cb1b29f6dab

Here's the GitHub page for it:
https://github.com/RandomEngy/PipeMethodCalls

Not entirely sure how different applications would connect to the same named pipe as what the navigation bar would use to allow for navigating back if possible or closing the program, though. Stuff like Firefox wouldn't work with it and I'd need to figure out a way to send backward navigation commands to everything that can use them, unless it would just detect if a program can use the back button to go back and not do anything if that's not possible.

Edit: see the latest reply here on how the Back button is basically the Escape key, so we'll use that: #4 (comment)

Edit 2: D-Bus will allow for the enhanced Back button functionality in apps that support it, as well as a way to check if the navigation bar is currently running and display an emergency Back button if it's not, as described in this comment: #4 (comment)

Currently, this causes the All Apps list to break on Phosh due to at least one app having the x-purism-formfactor thing in its .desktop file.

These are places .desktop files often are. They need to be searched by RetiledStart, so this is an issue and will be given its own wiki page if it ends up being useful enough. Source for some locations: https://linmob.net/phosh-0-12-app-drawer/

• /usr/share/applications
• /usr/local/share/applications
• Flatpak apps: /var/lib/flatpak/exports/share/applications
• ~/.local/share/applications

See also #23 regarding an option to use dex instead of the exec key's value-cleanup code in my library after porting it to Python. I'm keeping that open because an option to switch between my code and dex would still be useful. The only problem with not including the cleanup code in my own library is RetiledStart won't work on Windows if dex isn't available, but that's not really an issue outside debugging as I'm not trying to make a UI for Windows.

Since my level of experience with Python is minute compared to my level of experience with VB.NET, my port may not nearly be as stable or reliable as the original code and may take a lot longer to be usable (mainly the key cleanup part), which is why I'm trying to save time by having RetiledStart use dex for the launching part for now. I'll have to store the .desktop file path for each All Apps list entry and tile to pass to it, as that's how dex works.

Even though I'm not including the exec key's value-cleanup code right away, I'll still have to at least port the code for getting key values, as that's what I use to show the names of each app plus determine whether that app should be shown in the list.

The Python port will be developed in the DotDesktop4Win repo, as the original is already there and I don't want to go into deeper folders to modify its code. Preferably there would be a way to have them all in the same folder like DLL files, but that would require having them be compiled, and I don't know how easy it is to do .NET-style references with Python. Might be complicated or require other libraries, so I want to keep it simple.

Not sure how to add a restart option. It should exist to give the user choice and encourage them to safely restart rather than forcing it (unless the display driver locks up).

Here's the documentation:
https://pyyaml.org/wiki/PyYAMLDocumentation

It appears that my YAML file is most similar to the block mapping example where it's nested in a block sequence. This gets a list of dictionaries, described here:
https://pythonexamples.org/python-list-of-dictionaries/

At least that way it should kinda work, even with smaller tiles. Maybe the FluidWrapPanel described here will work and I can use full-size tiles: https://wpfspark.wordpress.com/2016/04/27/dynamic-fluidwrappanel/

Edit: Here's an animation showing stuff being moved around in FluidWrapPanel: https://wpfspark.wordpress.com/2016/07/16/compositionprotoolkit-v0-3/

It would be cool to support custom themes, so as the issue title states, I'll have to do templated controls so that it's easy to have themes only change the appearance of specific controls, even if those controls are functionally the same underneath due to inheritance.

Besides custom themes, it would just be way easier having a specific control that can be called for things like Tiles instead of having to make sure the properties are set up correctly in the RetiledStart code, for example.

The main button-like controls that aren't a direct analog of System.Windows.Forms.Button in appearance that I can think of off the top of my head are:

• Tiles
• Action Center buttons
  • The main ones at the top you can configure
  • "Clear Notifications" and "Settings" (these two look different from the ones at the top)
• Navigation Bar buttons (Back, Start, and Search)
• CommandBar buttons (the part at the bottom of Windows Phone apps that have icons with circles around them)
• The Apps List "Search" button (magnifying glass inside a circle at the top of the App List's left margin)
• The "All Apps" arrow button (specifically the one with an arrow in a circle that was last seen in WP8.1 Update 1)
• Not sure if they count as button-like, but the "letter filter" buttons that show a list of letters you can use to get to specific parts of a list quickly
  • KDE Plasma's default application launcher menu now has a "letter filter" jumplist feature, so if it's under a license that I can use easily, I could probably just borrow and modify that code since it's obviously using QML. That way I don't have to try to figure it out myself. If it's (L)GPL, then I might end up having to change the license anyway, sadly, because it may be difficult to figure it out myself, but code reuse is good.
• Buttons that are only made from text and maybe an icon on the side, such as the apps themselves in the Apps List and items in the system and apps pages of Settings (though these may be part of a ListView so they might not count).

That might fix the disappearing scrollbars issue.

My XAML code uses an ItemsRepeater inside a Grid, so I'm not quite sure what to do. Hopefully the QML Repeater is light enough and doesn't make things too slow if it's not a virtualized list.

This project may help: https://github.com/tripolskypetr/qml-flexbox

I'll have to fork it on my computer (Safari doesn't give me the real desktop site, and I can't get to the Fork button through the Milestones tab anymore) and add a line to remove Repeaters, as detailed here:
tripolskypetr/qml-flexbox#1

I'll have to check the resulting Exec key and separate the "gapplication launch" part from the "org.gnome.Maps" part when running the app. The best way to do this would be to check if the resulting Exec key has that gapplication command in it, and if so, create a ProcessStartInfo thing for it.

Update 3 (the other two were deleted due to being outdated): I ran the PySide6 Qt Quick Controls gallery and found that, with some changes, the progress bar, progress ring (called "BusyIndicator" here), SwipeView, and TabBar controls will probably work well just going from the Universal style.

• Most buttons have their background color changed to the accent color when pressed.
• Some buttons such as the "All Apps" button have the fill color as white instead of the accent color.
• Support for accent colors other than Cobalt needs to be added.
  • While not yet available in a released build, it is available on main and you just have to edit "RetiledSettings/configs/themes.config" in the repo or "~/.config/Retiled/RetiledSettings/configs/themes.config" if it's copied there whether by you to prepare for the next version (it'll support Accent colors; changing them in a UI will take longer), or by an unofficial tweaks program that makes it easier to change stuff that doesn't have a GUI available for yet.
  • Please note that apps don't listen for Accent color changes yet, and as such must be restarted for your changes to take effect.
• Custom accent color support as seen on desktop Windows 10 needs to exist.
  • Again, this must be done by editing the config file for now.
  • Qt has a QML color picker now that should work.
• Support for the light theme.
  • Light/dark is an option in the config file, but it's not yet implemented. You can change it to light now if you want to have the light theme as soon as a version with support for it is installed.
• "Light Cobalt" should be added as an option in case people prefer the lighter variation from some phones (#3e65ff instead of #0050ef according to WindowSpy)
• Apparently there's another variant of Cobalt that the Visual Studio Designer displays in the Device pane, that being #0B6CF8. In case it's necessary, the full code is #FF0B6CF8, but GitHub doesn't display a preview for that one. This color may be the real "Light Cobalt" that some devices displayed instead of the real Cobalt, as it looks less purple to me.
• Here's a full list of the colors as defined/displayed by Visual Studio. I don't know if people will want to use these, or the colors in the other list I have somewhere.
  
• There needs to be a way to reference the styles for controls from multiple applications.
  • Should be possible by referencing a library and specifying the assembly when adding the styles to the page.
  • I guess this is technically supported due to how QML classes work.
• Toggle switches have padding inside them so the accent color doesn't fill the entire thing:
  
• Toggle switches also slide over and can even be dragged over manually.
• Progress bars are really thin and use the accent color as their fill color.
• Opening the appbar has a nice transition for the buttons in it to slide into place.
• A common page transition is the "barndoor swing", for lack of a better phrase. I may have mentioned these two transitions in the long document with what features there'll be.
• The "Unpin Tile" button has a black (or white, if using the light theme) outline when pressed, while the "Resize Tile" button doesn't:
  
• Apps with really long names just show whatever can fit in the tile:
  
• Items in the All Apps list go behind the statusbar, which appears to have reserved space, unlike on the Start screen:
  
  
• While there is a gap at the top of the All Apps list, items go above it but stop at a point. This is related to the "reserved space" thing above.
  
  • I think the "reserved space" thing should be handled by creating either an extension for Wayland or something with D-bus that apps that support it can use to specify how the status bar area should act, whether it should automatically reserve space like a LayerShell component (for compatibility with basically everything that's not designed for Retiled, but also apps that can just have space at the top; the only concern is if an app needs to have a loading indicator at the top, there needs to be a D-bus thing to specify that the status bar icons need to hide and something else like the "Loading..." dots needs to be shown [maybe there can be a way to have the status bar be in LayerShell mode and also change what's displayed up there, so app developers don't have to manually do spacing if they don't want to, but they can also do manual spacing and the "loading..." dots if they want]) or if the app can handle it so it's more immersive. Hiding the status bar is also important, but I think that's already been discussed in the large document in /docs.
• As shown in the screenshots above, the All Apps list has headers for the first letter of each item. Microsoft has an example on how to do that with a ListView here, which will need to be altered to work with Avalonia: https://docs.microsoft.com/en-us/windows/apps/design/controls/lists#examples-1
  
  This SO page may help point me in the right direction for doing this under QML:
  https://stackoverflow.com/questions/48923148/qml-creating-a-re-usable-listview-header-component
• WP buttons will turn toward where the user pressed them. This issue is being tracked here, though I figured that it would be a good idea to add it to this list, too: #37
• Most phones had different positions for their navigation buttons, so there should be a way to allow the user to customize the spacing between them if desired.
• There's a gap below the "uninstall" button in the All Apps List app context menu and unless I said this somewhere else, context menus have a black outline on the top and bottom and are the width of the screen.
• They also "push" the rest of the apps into the "background" with an animation when they open.
  
• Location services has an icon in the statusbar when it's active that looks like a big dot with a circle around it.
• App bar buttons rotate when the screen is rotated:
  
• Not sure if I wrote this somewhere else, but the statusbar icons are grey and slightly transparent as shown below comparing the statusbar when the Action Center is closed and open. You can see where the battery icon overlaps with the IE logo that the fill color isn't opaque. This may be different in different applications though, so I don't know how to handle that yet. Maybe it'll just be slightly transparent for everything.
  
• Dropdown boxes usually have black backgrounds and white outlines in the dark theme, but pressing them changes them to a white background and an accent color outline. When open, they show the currently-selected item with an accent color highlight and the outline remains the accent color as well. In the light theme, the dropdown box always has a white background, and a black outline unless pressed or open.
  
• I was just messing around in the Windows Phone emulator, and found out that the "Loading..." dots are squares, not circles (perhaps there should be an option to toggle between circles and squares, in case someone prefers the appearance of real circles over squares despite squares being more authentic and true-to-form for Windows Phone?):
  
• Not sure where to put this, but at 100% scale, the 720p emulator image doesn't have borders on tiles, which is good to know because I thought they did so I just didn't keep them on the buttons back when I was making them into tiles (except the OneNote icon, for some reason, has a border, which I guess it just has its own background with its own specific border color; sorry these are so large):
  
  Here's the All Apps list too, for reference:
  
  Those screenshots just above this are also available in ./docs/images/reference if you need to look at them in an image editor more easily.

You might read that title and go, "Yeah, of course they'll use QML, it's what the Start screen is built with," but the interesting thing is that this could be set up in a way that an app would specify how the data would be shown on the tile. The Live Tile developer would (recommended) base their Live Tile off one of the templates, just like they would on Windows Phone (except it's like LiveTiles.FlipTile or something), or (if this makes sense) they could completely change their Live Tile to be more like an Android widget (if the button doesn't override everything) with a bunch of buttons and stuff to use. It'll probably just be based on the templates, though.

I don't exactly know how I'd store the customized Live Tile QML code inside the regular Tile QML code, but I'm sure there's a way to do it.

I'd have to figure out how to connect all the properties in the Live Tile's QML file so it displays properly. Might have to have an If statement that uses something in the .desktop file that says what kind of Live Tile is being used, since I might not know what everything is supposed to connect to. Actually, I probably wouldn't know, so it would be a super complicated problem to figure out. Maybe there's some way to connect all the properties without having to know what they are, for stuff like weather (unless the weather apps just used pictures on flipping around, which would be a lot simpler; stuff like emails and events could be lists of dictionaries).

I need to both look for open-source WP apps that are license-compatible and have Live Tiles to see how to implement my own ones. I also need to read Microsoft's documentation on Live Tiles to know what kinds there are, but that's a given.

Too tired to decide on which is the best, so this is just here for now. SO page:
https://stackoverflow.com/questions/5545187/wpf-how-to-bind-a-command-to-the-listboxitem-using-mvvm

Basically, the battery percentage and everything would be rotated just like the time. For notifications, the part of the Action Center that shows them would also rotate, but they'll be to the side of the Quick Actions instead of below them. The Quick Actions would change to a vertical list.

As cool as this is, thinking about it more makes it sound like it might not work, or at least be easy to do. Doing it iOS-style where you pull it down from the top may be necessary, unless I can figure out a way to rotate the controls when the display is wider than it is tall, or however rotation would be checked.

I need to check that, but I think it does show up if Action Center is open. Usually it's hidden because the clock is already on the lock screen in the bottom-left.

That button may be important if I can't figure out a good way to refresh the All Apps list right away, considering the user can now swipe over to it and it doesn't have to take time to load from the button like it did before. I was thinking that maybe there could be code that runs via Python that compares the currently-loaded list to a new one, and it updates if it doesn't match, or it just ignores the new list and keeps with the current one. That code would have to be async to keep things fast and fluid.

It's far enough along at this point.

There should probably be a way to specify that the screenshot shouldn't be taken, for apps like password managers. Not sure exactly how an app would signal to not have a screenshot taken, but maybe the multitasking view would just have to show the app's current state, like Plasma Mobile seems to do when Nota has a file in a git repo open and you update the file from the terminal. Continuing to show the currently-running app's current state might be a good idea too, but it may be difficult. I think Windows Phone used the screenshot method, though.

Here's the repo with the build script:
https://gitlab.manjaro.org/manjaro-arm/applications/manjaro-arm-tools

As I said in another comment somewhere here, I'll have to host the packages somewhere, and I'll likely have to use Linnode if I can't get things to work using the AUR.

Only issue is if MadMilkman.Ini isn't compatible with .NET Core. Might be able to port it manually if no one else did.

I don't know where Plasma Mobile puts them, but I know GNOME puts them in the same place as Android and iOS: the notification area. I'll have to figure out accessibility so as many people as possible can change media stuff.

Edit: Maybe there can be an option to also display media controls in the Action Center, in addition to an Action Center Quick Action to display the volume control UI. See issues #124 and #125.

Took a while to find this, but this SO page may help: https://stackoverflow.com/questions/19855920/wpf-scrollviewer-consuming-touch-before-longpress

Edit: This answer may be more useful: https://stackoverflow.com/a/40786899

Edit again: This other answer may be closer to what's needed, though it may need to be modified to work with Avalonia and putting it in a control library would be useful so that scrolling with the mouse like Windows Phone would be possible in more places:
https://stackoverflow.com/a/42288914

Archive from the original answer by TheBigSot if it gets deleted:
>I did this class to scroll while keeping the scrollviewer buttons. From the code from user110777, but this works with vertical instead of horizontally, and works well with the viewer (Since I'm now only capturing the content). Plus I'm using MouseLeftButtonDown instead of the preview in order to allow the user to click things like the combobox without causing a drag. (If you want label or Textblock to drag set their IsHitTestVisible=false)

public class ScrollDragger
{
    private readonly ScrollViewer _scrollViewer;
    private readonly UIElement _content;
    private Point _scrollMousePoint;
    private double _hOff = 1;

    public ScrollDragger(UIElement content, ScrollViewer scrollViewer)
    {
        _scrollViewer = scrollViewer;
        _content = content;
        content.MouseLeftButtonDown += scrollViewer_MouseLeftButtonDown;
        content.PreviewMouseMove += scrollViewer_PreviewMouseMove;
        content.PreviewMouseLeftButtonUp += scrollViewer_PreviewMouseLeftButtonUp;
    }

    private void scrollViewer_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        _content.CaptureMouse();
        _scrollMousePoint = e.GetPosition(_scrollViewer);
        _hOff = _scrollViewer.VerticalOffset;
    }

    private void scrollViewer_PreviewMouseMove(object sender, MouseEventArgs e)
    {
        if (_content.IsMouseCaptured)
        {
            var newOffset = _hOff + (_scrollMousePoint.Y - e.GetPosition(_scrollViewer).Y);
            _scrollViewer.ScrollToVerticalOffset(newOffset);
        }
    }

    private void scrollViewer_PreviewMouseLeftButtonUp(object sender, MouseButtonEventArgs e)
    {
        _content.ReleaseMouseCapture();
    } 
}

That code either doesn't work in .NET Core both in a WPF project and when converted to Avalonia, or I couldn't figure out how to use it correctly.

I'll add an option so that the user can choose whether to replace the back button with a camera button on the Lock Screen, as I personally don't like it but there probably are people who want it. Remember that you press and hold the camera button to open the camera, I think. Perhaps I should also allow the user to swipe from the right to go to the camera, like on iOS, as well as a button in the Action Center so the user can have multiple ways of opening it. Also allow the user to turn off the side-swipe and hide the Action Center camera button if they want.

Edit: It was the back button that it replaced, not the search button. I saw a picture showing the lock screen on a phone that lacked a camera button just now, and it reminded me.

That feature is a really good idea, so I'm going to copy it. Hopefully there's enough room on the navigation bar, but if not, there should be a button in the Action Center at least. I'm trying to figure out an accessible way to add the button, and I think it'll only work with an extra button on the navigation bar, for four buttons total. The user should have the option to turn off the keyboard button and replace it with swiping up on the navigation bar (when the phone is vertical; when horizontal, from the edge the navigation bar is on to the physical top of the device) to open the keyboard. There should also be a way to just turn off both the button and the swipe gesture, as well as a way to change the gesture to whatever the user wants.

I'd like to have a way for people to use their own XAML themes, but there first needs to be a way to store preferences like accent color, default search engine, and tile positions. Each of those three things will probably have to be their own files to make things easier if people want to change things manually or backup or share their changes.

Something using YAML files for configuration would allow would be building a program just for search configuration and allow it to be accessed from both the Search app and a Settings app.

Source for some items: https://twitter.com/DrewTNaylor/status/1415110624561045505

• Sort the All Apps list according to their "Name" key
• Make pinning and unpinning tiles work
  • Pinning tiles
  • Unpinning tiles
  • Unpinning tiles is fine, but pinning tiles can have some issues as described in #85.
• I never did fully implement tile resizing with a context menu and went directly to the corner buttons once I verified the buttons in the context menus could get stuff into Python. Until tile resizing can be done from an arrow on the corner of the tiles, I should add two extra "pin to start" items to the list, in addition to the medium one:
  - pin to start (medium)
  - pin to start (small)
  - pin to start (wide)
  - They're in that order because medium was the default on WP, and changing tile sizes with the arrow button on WP would go from starting at medium: small, wide, medium.
  - Resizing from the tile itself may require Avalonia Behaviors.

In addition to the items above, I also need to do these:

• Modify the appbar in RetiledSearch so it looks correct.
• [-] Add the scrollbar to the All Apps list Delayed until v0.1-DP2.
• Get the All Apps list entry item context menu looking close enough to what it should be.
• Filter out everything in the Exec key that's unnecessary so that opening programs works generally as expected.
• [-] Pass the .desktop file assigned to each All Apps list entry and tile to dex for now as described in #52. A future version, likely the version right after, will include a port of libdotdesktop_standard to Python which I'll use. That port will only contain the code for removing extra stuff like %F, as I want to keep it as light as possible and I don't really need the heavier features that are supposed to be available in the original version but aren't implemented yet there, either. We're just using the Python port of libdotdesktop_standard (libdotdesktop_py) by default. Not sure about support for dex.
• Guess I can just add an item for cleaning exec keys with libdotdesktop_py.
• [-] (Moved to DP2) Allow the user to set their accent color in a config file and figure out a way to bind background color values for the All Apps list items and the textbox and button in the Search app. This value will be used as a fallback in case tiles don't have their accent color specified in the layout file (likely startlayout.yaml), but if the accent color is also not specified, it'll fallback to Cobalt. To make things easier, I'll probably use a separate file to store values for accent colors and the theme, probably themeconfig.yaml. Actually, the light theme vs dark theme switching may be a little difficult to do right away, though this code should help when I get around to add light theme support: https://github.com/nullvoid-creations/Jaya/blob/dev/src/Jaya.Shared/ThemeManager.cs Eventually I'll also add support for third-party themes.

Some phones have notches or cameras on the left or right side of the top of the phone instead of the usual placement of the center, so I should add an option to let people add a space to move stuff away from that part of the phone. I'll need to ensure that the items in the second line of the status bar that appears at the top of the Action Center (like the date and battery percentage) are moved over to line up with the new position of the relevant status bar items (like the time and battery icon).

Center notches shouldn't be a problem because everything is already on the left or right, but people may want a way to hide the notch by spacing the statusbar down from the notch, so there should be a separate option to add a spacer between the physical top of the phone and the statusbar. I'll also have to figure out a way to make sure the window manager/Wayland compositor keeps everything out of the way of the notch area.

When rotated, the notch spacers will still be in the same physical areas, so things should work but with status bar items just rotated.

Simulating the backlight wouldn't be the default, but instead it would be white or black based on the theme being used. There will however be a dropdown letting the user choose between using the theme color, simulating the backlight, applying their accent color, and setting a custom color. With backlight simulation, there can be a dropdown for commonly-used backlight colors on Windows Phones, like Lumias. Applying the accent color has no options and just sets the navigation bar buttons to the user's accent color. Custom colors will just be an option to choose a custom color, like in Paint.

On top of those options, there should be one to have the start button change to the accent color when pressed because people may want that.

I really don't like Windows 10 Mobile's dropdown, so having the rest of the buttons that aren't at the top of the list and also aren't completely hidden be on a horizontally-scrolling panel is a good solution to showing more than the max amount in WP8.1 (almost put "8.x" and forgot that Action Center was added in 8.1, which shows how important it was).

The buttons that appear at the top of the Action Center will be configurable, and I think one way to do that will be to have a vertical list the user can click and drag items up or down on, kinda like the Windows 10 one but only vertical.

Note: This is similar to how Ubuntu Touch/UBPorts has the notification area action tabs in that the tabs scroll horizontally. Those aren't buttons, though.

This is important because the XDG spec says some .desktop files go under $HOME/.local/share, and says to search there first. There's one more directory I think, but I need to look at the spec again because I forgot. Maybe I can check the list when adding a file to it to see if it's already accounted for, and not add a duplicate. Checking to see if something should be shown would help to optimize it, as would "OnlyShowIn" and "NoShowIn".

Maybe it's a limitation of .NET in Xwayland or something. This'll have to be investigated. Maybe it's just Mobian that has that issue. I ran both of them by adding "&" to the end of the command, so maybe that has something to do with it.

This way I can use something I know relatively well and not have to figure out why C# and stuff like xdg-open are having issues, and instead focus on figuring out only xdg-open for example. As I learn C# more this may not be as useful, but I may as well take advantage of it.

These measurements work really well on the PinePhone, and I think these are also the correct dimensions that are used in WP8.1.

Hopefully I can figure that technique out to implement it into Retiled for a more authentic experience. It's kinda weird not having the buttons rotate/transform toward the mouse and instead just go inward.

I need to change the margins or something.

I'm thinking something based on what I usually did with two-column layouts, with medium tiles for Phone and Messages on the top left and top right, then an email client on the next row on the left, with the browser and app store on the right, etc. Once four small tiles can be in a square together, the default should be able to almost copy my personal two-column layouts, aside from the actual apps themselves.

As the title says, if the user pins or unpins an app (resizes or moves as well, once supported), then the default layout will be copied to the local user data folder area. The default layout will only be used if there's no layout file already there. I'll have to ensure the user's modified file is written to when modifying the tiles, and if it doesn't exist, first copy the default, then modify.

Due to testing this mostly with Plasma Mobile, I think I'll use Plasma apps for the default pinned tiles. It would be a good idea to provide a default layout with Phosh apps for testers, though.

May be difficult to provide both layouts early on, but I could add two YAML files with the only difference being the apps that are pinned and just do a check to see which UI is running somehow, or an easier way to do it would just be to ask the user whether they use Plasma Mobile or Phosh with a message that says it determines which apps are pinned to the default layout.

It's getting really long now, and I didn't think it would end up like this when originally adding to each item.