The build script has to be upgraded to work with Gulp 4.

The window manager is able to provide various kinds of view ports to applications.
For the first implementation we're going to provide two types of windows / viewports.

1. FullScreen covers the entire screen and can be configured to stay allways front or allway back.
2. MainWindow behaves like a window, can be moved, maximized, minimized and closed.

• implement window <==> application association
• implement FullScreen window
• create window manager template
• I think some styling is also required
• wire it up so the main window for a application can be requested

Call the dockIconClicked function to let the application handle it and e.g. open a new window or show the current one.

• implement public application interface
• notify application about the icon trigger if there is no open window
• focus the last application window in case there is a open one

Currently, the main menu items are all selectable but shouldn't be.

Implement a window focus

• create focus and blur style
• bring window to front on focus
• emit focus and blur event on the window
• handle focus for input elements of windows

The basic workspace should provide a full screen background with icon grid and a main window with a simple info text, mainly to give a prove of concept.

• create WorkSpace application module
• create template for the background
• add application icon grid to the background
• add one main window
• create template for the main window with some text and styling

It should be possible to drag and move windows on the workspace.

• refactor window layout to window header and content are clearly separated
• implement drag on MouseDown event
• release window with MouseUp event
• don't let windows be moved below screenBlocking windows
• don't let windows get completely moved outside the workspace

Create a basic application doc.

• create the WorkSpaceBorderToolWindow window type
• expose basic application information to other applications
• emit an applicationLaunched event in the ApplicationManager
• implement appearanceMode(mode) in Window with four modes normal, alwaysOnTop, alwaysBelow, screenBlocking.
• set the Doc window to alwaysOnTop

it should be possible to close a window.

• show a x in the windows close action on hover
• trigger an windowClose event before closing
• destroy the window and remove it from the view port

Create the main menu. Windows need to be able to connect and expose their entries. The correct menu entries should be available for the currently focused window.

• create MainMenuWindow of type WorkspaceBorderToolWindow
• set MainMenuWindow to screenBlocking
• design the way the main menu is registered in the system
• create API to retrieve the current mainmenu
• emit an windowFocusChanged event to update the current menu
• populate the menu with the entries for the currently focused window

We want a dock context menu with at least an entry to kill a running application.

the workspace also holds the file manager. In the doc the workspace should identify it self as filemanager.

• create FileManager window
• add icon grid in the Filemanager
• add a back and forward button at the top toolbar
• display folders and files on the grid
• make folders clickable so it is possible to navigate into it
• keep track of the navigation history
• make the back button work to go back through the history
• make the forward button work to navigate forward through the history

Create a service worker so we can control requests and the cache. As soon as we have control over the cache we are able to implement packages! yay

• create service worker
• make sure ApplicationFrame can handle the service worker
• implement caching of the core system files
• design the future steps for packages

The current implementation of threads and their interfaces is really confusing. The problem is that both the Thread interfaces / proxy objects and the CurrentThread API, come from the Thread prototype which gives them the same capabilities.

This has to be separated. CurrentThread should only be able to declare interfaces and be aware when they get invoked by other threads. CurrentThread should also have access to the parent thread.
The Thread prototype on the other hand should not be able to declare interfaces, but only act as a proxy object to invoke functions of its target thread. IOThread is then only a shortcut to access the global thread proxy of the io thread.

Implement the FileSystem module. The file system should be UNIX like and provide the ability to mount different volumes.
The first implementation is intended to instantly mount the main virtual volume from the IndexedDB.

• create volume type "indexedDB"
• build connection to the ApplicationFrame Virtual Filesystem Driver
• check the Filesystem driver and update weak parts
• implement ls function to read directories
• implement writeFile, to write basic text files
• test FileSystem in the Core module with ls and writeFile
• implement readFile to read any type of file from the file system

make windows resize able!!

• add border elements to capture the cursor
• handle the events for resizing
• create API to disable resizing and maximize

Create a System Handler for not implemented methods.

• create SystemHandler namespace in System namespace
• create ErrorHandler Object
• create methodNotImplemented function in the ErrorHandler Object