Abstract: This document is the specification for the NetBeans windowing system. It defines basic window system elements, their behavior, appearance and interaction with user.
The window system is a visual framework of the IDE. It displays windows and allows to manage them to suit the user needs while performing a concrete task.
Attributes of the new design:
The new window system supports two modes - MDI and SDI. MDI is the default mode presented to the user in GUI as "Compact Windows Mode". SDI is named "Separate Windows Mode". This specification describes the MDI mode in details. The SDI mode is described only in a differences over the MDI mode.
Terminology used in this document:
SDI specific terminology:
User View document provides the foundation concepts for the window system specification.
Main window is a container for application menu, toolbars, status line and windows which are provided and controlled by the window system. All of the windows are always displayed inside the main window, neither user can separate them out of the main window. The windows are shown in two areas depending on a type of displayed window. The areas are a document area and window area. The document area is used for document windows, and the window area lays out all of the other windows.
|Figure 1: Main Window|
The main windows characteristics are following:
Java Look and Feel Advanced Topic defines a window as a basic window system element used for displaying and manipulating with a user interface objects.
IDE windows can be distributed into different categories according to objects they display and their usage. Document windows are essential for this design and are specified separately. All of the other windows (supportive windows and all primary windows except document windows) are covered under the general term "window". Complete distribution of windows into categories is in the user view document.
This section specifies characteristics, interaction and appearance of the windows. The document windows are specified in the next section.
|Figure 2: Window|
The user opens a window through the Window menu. Each window has a menu item in the window menu. Invoking an item either opens and activates a window or selects and activates already open window.
|Figure 3: Window menu - a window items|
| Window | ---------- Window 1 Window 2 Window 3 ... Window n Window A1 Window Category A > Window A2 Window Category B > ... Window Category n > -------------------- ...
|Figure 4: Window menu example|
To close a window, the user either clicks the close button in the window header, or uses the "Close Window" menu item in the main menu or contextual menu.
A window can be maximized. The user can achieve that by invoking the main or contextual menu item "Maximize Window". If a window is maximized the user can restore it to the previous state by invoking the "Restore Window" menu item. The maximize menu item changes to the restore menu item is a window is maximized. Both menu items have the same shortcut.
A window can be maximized also by double-clicking its title bar. If a window is already maximized then double-clicking restores the window to its previous state.
The contextual menu of window is open when the user right-clicks on the window header. It contains following menu items:
Figure 5: Window contextual menu
------------------------- Close Window [Ctrl-F4] Maximize Window [Shift-ESC] -------------------------
Figure 6: Window contextual menu (in maximized state)
------------------------- Close Window [Ctrl-F4] Restore Window [Shift-ESC] -------------------------
A Document window is a special kind of window. It displays a user object that is part of user project, or serves the role of primary window for other kind of objects, for instance the web browser for internet viewing, or the javadoc browser for javadoc viewing.
Some of the objects may have more than one associated document window, for example a form object can be viewed by source editor, form editor, and also by cvs viewers (annotate, diff, ...). One of the multiple document windows of an object is always a base document window of the object. All other document windows of that object are extending document windows. For instance, in case of form object, the source editor is the base document window, and form editor, cvs viewers are the extending document windows.
|Figure 7: Document Window|
The user can save, close and activate the open document windows with a documents dialog.
The user opens a document window using a contextual action of associated object. Default document windows are open with the open action, opening of other document windows depend on a type of contained editor or viewer, e.g. CVS views are open with CVS contextual actions. Default document windows are a windows which are needed for complete object editing. For example the source editor and form editor of a form object should be open at once (source editor focused). If the object is already open it is selected and activated.
Some of the document windows can be open from the main menu. Such windows are a single instance viewer of miscellaneous objects, like web browser or javadoc browser.
The user closes a document window using the close button in the window header or "Close Window" menu item from the main or contextual menu.
The user can save a modified document contained in the document window by using the "Save" action from the main (File|Save) or contextual menu. The Save action is disabled if the document hasn't been modified.
A clonable documents can be cloned using "Clone Document" menu item from the main or contextual menu. Invoking the clone action creates a new document window containing the clone of original document. This action is disabled if the document is not clonable.
A document window can be maximized. The user achieves that by invoking the main or contextual menu item "Maximize Window". If a window is maximized the user can restore it to the previous state by invoking the "Restore Window" menu item. The maximize menu item changes to the restore menu item is a window is maximized. Both menu items have the same shortcut.
A document window can be maximized also by double-clicking its title bar. If a window is already maximized then double-clicking restores the document window to its previous state.
The contextual menu of document window is open when the user right-clicks on the window header. It contains following menu items:
Figure 8: Document Window contextual menu
------------------------------------ Close All Documents [Ctrl+Shift-F4] Close Other Documents ------------------------------------ Save Document [Ctrl+S] Clone Document [N/A] ------------------------------------ Close Window [Ctrl+F4] Maximize Window [Shift-ESC] ------------------------------------
Figure 9: Document Window contextual menu in maximized state
------------------------------------ Close All Documents [Ctrl+Shift-F4] Close Other Documents ------------------------------------ Save Document [Ctrl+S] Clone Document [N/A] ------------------------------------ Close Window [Ctrl+F4] Restore Window [Shift-ESC] ------------------------------------
A window area is a window system area used for laying out windows around a document area which contains document windows.
The Window area is bounded by two bounds. Outer bound is identical to the main window's left, right and bottom bound, and top bound is the same as bottom bound of toolbar area. Inner bound is identical to the document window area bound. The window area lays out windows using a split cell layout.
|Figure 10: Window area|
|Figure 11: Windows in Window area|
The split cell layout allows to open more than one window in a one split cell at the same time. In such case the topmost window overlaps windows beneath, and window tabs are used for showing the overlapped windows and allow the user to select them. Selecting a tab moves a window to front and actives it.
|Figure 12: Window tabs|
A split cell can be maximized, then it overlaps the whole window area, hiding other open windows and document windows. When a maximized window is restored, the window area and document area are shown.
Maximization of a split cell is presented to the user as maximization of window. An appropriate window menu item is "Maximize Window" for maximization. If a window is maximized then the menu item changes name to "Restore Window". Double-clicking a title bar invokes the same maximize/restore action. If any window that is not part of maximized split cell gets activated, then the split cell is restored to the previous state.
The split layout is based on chains of split cells. The chain can be horizontal or vertical. A vertical chain contains vertically divided cells, and horizontal chain contains horizontally divided cells. Each cell in a chain contains one or more windows, document area, or another chain of split cells following this constrain: a cell from a vertical chain of split cells can contain horizontal chain of split cells, and likewise, a cell in horizontal chain can contain a vertical chain. So the layout is a tree hierarchy of nested horizontal and vertical chains of split cells.
|Figure 13: Chain of vertical split cells|
|Figure 14: Chain of horizontal split cells inside vertical split cell|
The resizing behavior of split cell is not completely proportional. The document window area is a component with the maximum resize weight. When a split cell is resized and the document window area is part of split cell's structure (inside split cell's tree), then all split cells on the path to the document window area have a resize weight of 1 and other cells have a weight of 0. This means that only the document window area is resized and other cells either do not resize or modify their size according to the document window area. If the document window area is not in the resized cell's tree, then all cells in the tree have a resize weight of 0.5, meaning that they change size proportionally.
|Figure 15: Before resizing of split cell|
|Figure 16: After resizing of split cell|
When a window is added to the window area the layout have to accommodate that. If a window is added to an existing split cell (some window is already open there) then the layout does not change. Otherwise the split chain the window is added into is resized according to the same rules as when resizing a split cell. The value how it should change depends on the last (default) width of window if it is added into a vertical split chain, and height if added into a horizontal chain. Other cells (depends on position of the document window area) shrink their size and the window can be added into the split chain.
|Figure 17: Before adding a window to window area|
|Figure 18: After adding a window to window area|
When a last window from a split cell is removed from the window area the layout is changed too. It is the opposite action to opening a window. The cells in the split chain that the window is apart of increase their width/height (vertical/horizontal chain) according to the size of closing window.
The user can modify the windows layout by:
Split cells are divided by splitters that can be resized by the user. Dragging with the mouse moves the splitter and releasing the mouse button resizes neighbor split cells (divided by splitters). It is not possible to drag a splitter over neighbor splitters in a split chain. Layout inside cells changes according to description above.
Attaching of windows is performed by DnD. The user can drag a window and drop it:
Attaching is the method of creating chains of split cells. Attaching to the left or right side of a cell in vertical chain adds a new cell to the chain. Attaching to the top or bottom of cell in vertical chain creates a horizontal split chain in the cell. Originally the window area only contains the document window area. The first attachment of a cell creates the first chain, either vertical or horizontal. When a cell is attached to the left side of document window area, the document window area shrinks and a splitter is created between the window and document window area. The window area contains one vertical split chain.
|Figure 19: Window attached to left of document window area|
Attaching to bottom of another window shrinks the window and creates split between the windows.
|Figure 20: Window attached to bottom of another window|
Attaching to left of the document window area shrinks the document window area and creates split between the window and the document window area.
|Figure 21: Window attached to left of document window area|
Drag and Drop is a convenient way for modifying the layout. DnD is performed by dragging a window by a drag source and dropping the window on a possible drop target.
First, we define the drag source where the dragging starts. In case of a window it is the window header. When the dragging starts, the window stays at the same position, only a drop feedback is appearing while the drop is not completed.
|Figure 22: Drag source - Window|
The drop feedback displays border that represents exact position and size of dragged window after DnD completion. If a window is added into tabbed windows, then the drop feedback also draws a tab on a new position (position between existing tabs, not precise location) in the tabs. When the window is dropped, it changes its position and the window area layout accommodates the change.
A drop target can be "Top", "Left", "Bottom", "Right" or "Center" area of window. Dropping to these targets is the same as performing the corresponding attaching action. "Center" creates a tab for the window and adds the window to the cell. The position of mouse cursor in the center target determines position of new tab in existing tab order. This way, the user is able to change order of tabs by DnD.
|Figure 23: Drop target - Window|
A Drop target in the document window area's "Top", "Left", "Bottom", "Right" part corresponds to the attaching to documents area action. The center part of document window area is not allowed drop target. The drop target can also be the outer "Top", "Left", "Bottom", "Right" border of the window area. In such cases it attaches to the top level split cell resulting either in creation of a new top level chain of split cells containing the dragged window and the whole content of window area or addition of a new cell to top level chain. Window can not be dropped outside of the main window area.
|Figure 24: Drop target - Document window area|
A drop target can be also a splitter dividing split cells. In this case the dragged window is added to the chain of split cells that the splitter belongs to, between the split cells.
|Figure 25: Drop target - splitter|
If user changes the layout it is remembered. Therefore, when the user closes a window and opens it back to the window area, then the window is open at the same position. Also order of windows in a same cell is persisted. So the windows are open always in the same tab order.
Document window area is a window system area that keeps all the open document windows. Windows in the document window area are laid out into chains of split cells similarly to how windows are laid out in the window area. Therefore more document windows can be visible at the same time.
Resizing and opening of new document windows and closing the document windows behaves same way as in the window area except that in the document window area the resizing is proportional. It means all split cell have the same resize weight.
Opening and closing a document window doesn't affect the size of the document window area. When the last document window is closed, document window area stays empty at the same size.
Document windows and windows open always on the same place in the document window area - the virtual center of document window area.
More documents in a split cell are displayed in a tabbed pane. A document header actually is a tab. The tabs of tabbed pane are scrollable (read a separate specification describing scrollable tabs behavior).
If a new document window is open it is inserted into the tabbed pane as the last tab. This doesn't apply for cloning of a document window. New document window created by cloning is inserted next to the tab of original window.
A document window is maximizable. When a document window is maximized the cell containing the window is maximized, so it overlaps the whole window area.
Maximization of a split cell is the same as in the window area and is presented to the user as maximization of document window. An appropriate window menu item is "Maximize Window" for maximization. If a window is maximized then the menu item changes name to "Restore Window". Double-clicking a title bar invokes the same maximize/restore action. If any window that is not part of maximized split cell gets activated, then the split cell is restored to the previous state.
The document area split layout works on the same principles as the split layout in window area. Adding, removing and resizing of split cells work the same way.
|Figure 26: Document window opened in the center of document window area|
Resizing of a split cell is achieved be dragging the splitters.
Attaching a document window to the bottom of another document window shrinks the document window and creates a splitter between them.
|Figure 27: Document window attached to bottom of another document window|
Attaching to right part of another document window shrinks the document windows and creates a splitter between them.
|Figure 28: Document window attached to right of document window area|
Drag and drop is preferred method of modifying the layout of the document window area. The user can drag a document window by its header (tab). When a dragging starts it displays a rectangle with tab showing the position of window where a document window will be placed and position of tab in a tabbed pane. The position and size of the rectangle is the same as the position and size of the document window after DnD completion.
|Figure 29: Drag source - Document window|
The drop target can be "Top", "Left", "Bottom", "Right" and "Center" part of a document window. Dropping performs the appropriate attaching action. "Center" creates a tab for the window and adds the window it to the cell. Position of mouse cursor in the center target determines position of new tab in existing tab order. Therefor, the user is able to change order of tabs by DnD.
|Figure 30: Drop target - Document window|
It is also possible to drop a document window to a document window area bound (Top, Left, Bottom, Right). In this case, either a new top level chain of split cells is created (dropping Top/Bottom to vertical chain, or Left/Right to horizontal, or any part if only one document window tabs is there), or the document window is added to the top level chain (dropping Top/Bottom to horizontal chain, or Left/Right to vertical).
|Figure 31: Drop target - Document window area|
If the mouse cursor is not over a possible drop target, the drop feedback rectangle is hidden and the cursor notifies the user about the forbidden operation.
Outside area in MDI is no longer used. All windows are open inside the main window. Only secondary windows (dialog boxes) can be open as separate windows and are implemented as modal or non-modal dialogs.
A Window group is a replacement of workspace. It is a group of windows which is used during a concrete task. For example GUI Editing group of windows consists of the component palette, component inspector (just a components hierarchy) and properties window. Debugging group consists of all debugger windows (local variables, watches, call stack, etc.).
A Windows from a window group are open when the group is opened. But not all windows from a group have to be open. Only those that are defined to open by default, or those which the user wants to open. When a group is opened the user may open or close windows contained in the window group. Then, when the group is closed, the open windows from the window group are remembered and are open when the group is opened again. Closing a window group means closing windows from the window group. An example is the debugger window group, the user may prefer to use the local variables window over the watches, so closes the watches during debugging and opens the local variables, next time when starts the debugger, the watches are open and local variables are not.
Some of windows are not affected by the user customization and are open always (even if the user closed them before). Such windows are considered necessary for a concrete task, thus are open automatically, always. For example, compiler output associated to compile action.
Windows from a window group should be closed automatically when a group is closed. A group is closed when the user finishes an associated task. Only those windows should be closed, which are not relevant for the task after the task completion. It means they do not provide any useful data, or actions that might by used even after the task finish. An example of windows which should be closed are the component palette, and component inspector. The output window is an example of window which provides useful data even after the completion of executed process (= task), thus should not be closed after finishing the executed process.
Only windows which were open by the group or open by the user during the group has been opened are closed when the group is closed. As more window groups can be opened at the same time, it is important to not close a window which belongs to another open group.
A Window groups are always opened and closed automatically. The user doesn't explicitly control the groups. There are two ways how to open a window group. The group is opened by following either selected document windows, or an invoked action. Example of former approach is to open GUI Editing group by selecting a the form editor window. The later is illustrated by opening the debugging group by starting the debugger.
The group is closed accordingly to how it was opened. In case of opening by an action, the group is closed when the process executed by the action finishes. An example is debugger group, which is closed after the finish of the debugger. In other case, the group was opened by selecting a document window, therefor it is closed when the last document window is deselected. For instance, the source editor is selected results in deselecting the form editor what closes the GUI Editing group.
Window groups opened by selected (last one active) document window are exclusive groups, as there is always only one document window selected. Important point is that if one user action results in closing and opening window groups, then for the user it should look like atomic action. The window area, should not be repainted twice. This is mostly important for switching between document window tabs.
|Figure 32: Window base layout|
When the user starts a task that requires the window group A, the window group is opened and windows are open. After finishing the task, the group is closed.
|Figure 33: Window Group A is opened|
The same happens when the user starts the window group B. After finishing the task, the group is closed.
|Figure 34: Window Group B is opened|
If the group B is opened and the user starts the task that requires the group A, it is opened too. Then depending on which of the tasks is finished first, that group is closed and the layout accommodated.
|Figure 35: Window Groups A and B are opened|
When a window group is opened, the user can define which of the windows are open in the group, it means which of the windows would open next time the group is opened. For instance, the user starts the debugger and some of the debugger windows are shown. But the user decides that she prefers using Watches instead of Local variables window. So she opens the Watches window and closes the Locals window. That also means the user defined that the watches window will open and the locals will not open, when next time the debugger group is opened.
There is only one active configuration of main toolbars for the whole IDE. It doesn't change automatically, only the user is able switch the configurations. The user is also able to customize the toolbar configurations.
Each document window should have its own toolbar for document (editor/viewer) specific actions. This toolbar is part of document window. An examples of document windows containing a toolbar are "Java Editor", "Form Editor", "Web Browser", "Javadoc Index Search".
For speeding up the user performance following features are provided:
The user can manage open document windows with a documents dialog. The documents dialog is a non-modal dialog which displays an alphabetically ordered list of all open document windows, and allows the user to activate a document window, close document windows, and save documents.
|Figure 36: Documents dialog|
The main dialog components are:
The list buttons:
The dialog buttons:
The dialog characteristics are:
|Figure 37: The document windows quick list|
The Resize action allows the user to change size of window using the keyboard. The menu item has a submenu with four items labeled "Top", "Left", "Bottom", "Right", corresponding to splitters around the window in the layout. If there is no corresponding splitter around the window, then the item is disabled. Invoking an item draws the black line feedback over the splitter, same as in DnD. The user then uses arrow keys to move the splitter, and confirms new position of the splitter with Enter, or cancels operation with Esc. Mouse can be used for changing the position of splitter too. It works the same way as in DnD, only the user doesn't have to hold down the mouse button. Pressing the mouse button actually confirms the new position of splitter.
The Move action is a keyboard alternative to Drag & Drop. It would allow the user to perform attaching of windows by moving a window directly in the layout by arrow keys. When the user invokes the menu item, move feedback is displayed in the layout, similar to DnD feedback (black rectangle of moved window). When the user hits an arrow key, the rectangle is moved in the direction of the arrow key on a new position of the window. The move action is canceled when the user press' Esc button, and confirmed with Enter button. The window rectangle can be also moved by mouse, same way as in DnD, except the user doesn't have to hold mouse button down. Pressing the mouse button confirms the new position of window.
The window menu is used for manipulation with open windows and document windows. The menu has also a section for opening the windows.
The window menu contains an item for each window in the window system. These items are used for opening and activating a window. If the user invokes an item of a window which is not open, then it is open on the last (or default) position. If the window is already open, then it is activated. If it is open but its tab is not selected, then the tab is selected and the window is activated. The menu items are always enabled.
A manipulation window menu items are following:
Figure 38: Window menu - with mnemonics and shortcuts
| Window | ---------- Window 1 Window 2 Window 3 ... Window n Window A1 Window Category A > Window A2 Window Category B > ... Window Category n > ------------------------------------------------------- Switch to Recent Window (W) [Ctrl-`] Switch to Document (S) [Ctrl-0] Select Document in (n) > ------------------------------------------------------- Close Window (C) [Ctrl-F4] Maximize Window (M / s for Restore) [Shift-ESC] ------------------------------------------------------- Clone Document (l) [N/A] Close All Documents (A) [Ctrl+Shift-F4] Close Other Documents (e) Documents... (D) [Shift+F4] -------------------------------------------------------
The output window is a container window containing the outputs of processes running in the IDE. As more processes in the IDE can be executed at the same time, the output window should display more outputs at once. The tabs are used to achieve that. Each executed processes adds a tab to the output window.
The user discards output tabs manually using "Discard Output Tab" or "Discard All Output Tabs" contextual menu items. "Discard Output Tab" discards the selected output tab. "Discard All Output Tabs" discards all output instances leaving the output window empty. The contextual menu items appear over the output tabs and over the output tab contents.
The old NetBeans windowing system had two modes - MDI and SDI. Also the new windowing system has two modes. The above sections describe mostly the "Compact Windows" mode which is replacement of MDI mode. The old SDI mode is replaced by "Separate Windows" mode, and this section describes the basic characteristics of this mode.
The Separate Windows (SDI) mode is based on the Compact Windows (MDI) mode, therefor it has most of its characteristics. The main difference is that windows in SDI mode can live also outside of the main window in separate native windows. It basically means that it is possible to take one elementary split cell from the window area and put it into a separate native window.
Another difference is that the main window doesn't contain the window area and document area. These areas are displayed in a separate singleton native window named Editor. It means that the SDI mode has two singleton native windows - Main window, Editor window. It can also have multiple other native windows used for displaying windows not contained in window area.
Each native window has a name which corresponds to the name of selected window inside the native window. The native windows (except the editor window) can not be split. It means the user can put more windows into a native window, but these windows will be tabbed.
As the Editor native window represents the whole window and document area, it can be split the same way as the window and document areas in MDI.
The Window Groups and Drag & Drop work also in SDI, with the same characteristics and constraints if they are applicable.
Main window in SDI is a container for main menu, toolbar and status line. All IDE windows are displayed in separate native windows. The document windows are shown inside a special native window named "Editor" and non-document windows are displayed either in Editor window or in native windows named according to the currently selected IDE window inside the native window.
The native windows in SDI mode:
The characteristics, interaction and appearance of window in SDI is the same as of window in MDI.
The characteristics, interaction and appearance of document window in SDI is the same as of window in MDI.
The characteristics and behavior of window area in SDI are the same as characteristics of window area in MDI. The only difference is in DnD behavior.
In SDI, the document area, main window, native windows and an area outside of all native windows are possible drop targets:
The window area split layout works the same way in SDI as window area split layout in MDI.
The document area in SDI is contained inside a native window named Editor. The behavior, interaction and appearance of document area in SDI is the same as in MDI.
The document area split layout works the same way in SDI as document area split layout in MDI.
Native windows are containers for IDE windows. Their characteristics are following:
Multiple windows in native window are shown the same way as multiple windows in an elementary split cell in MDI. It means they are tabbed.
A window can be maximized. This really means that the native window is maximized. When a maximized window is restored, the native window is restored. It means the IDE window maximize/restore actions are only delegated to native window maximize/restore actions.
If a native window is resized, also the IDE windows (one or multiple tabbed windows) inside the native window are resized. The IDE windows inside the native window fill the whole native window real estate.
A native window is open if one or multiple IDE windows contained in native window are open. The native window is closed automatically if the last IDE window contained inside the native window is closed. The user can close the native window using the native window's close button. This would close the contained IDE windows as well.
A native window is open if one or multiple IDE windows contained in native window are open. The native window is closed automatically if the last IDE window contained inside the native window is closed. The user can close the native window using the native window's close button. This would close the native window as well.
Maximization of window is performed the same way as maximization of window in MDI.
The resizing of native window is controlled by native window manager.
An IDE window can be moved to an existing or new native window. If moved to an existing native window, it is added as another tab between IDE windows inside the native window. This doesn't result in changing the size or position of native window. If moved to a new native window (a new window is created to contain the IDE window) the native window is created at the same size as was the size of previous native window the IDE window was in.
In addition to drop targets in window area, which work the same way in SDI as in MDI, the user can drag a window and drop it to:
The difference between window, which is contained in native window, and a window which is contained in window area as a drop target is that inside the native window the user can drop only into the center part of window. The center drop area inside a window works the same way in SDI as in MDI.
In SDI, it is possible to drop a window also to an outside area. The outside area is an area of monitor screen that is not above any NetBeans window (main window, editor, native windows). If a window is dropped in outside area a new native window is created in place, containing the dragged IDE window. The new native window size is the same as the native window the IDE window has been contained in. The position of native window right left corner of new window appears at the mouse cursor position. This is not supported in MDI.
The window groups in SDI work the same way as window groups in MDI.
Toolbars in SDI work the same way as toolbars in MDI.
In SDI, all workflow features from MDI are used and work the same way.
The window menu in SDI is the same as window menu in MDI.
The output window in SDI behaves the same way as output window in MDI.
The user can change the window system mode using the Setup Wizard. During switching of modes a transformation of windows is performed due to existence of native windows in SDI mode.
A window container is a term used for explaining the switching between MDI and SDI modes. A window container is an abstract container containing a window or tabbed windows without any splits. It can be in two states:
The fact that a window belongs to a specific window container is shared between SDI and MDI. It means if user drags a window from window container A to window container B, it appears in window container B in other window system mode when modes are switched.
A window container can be in different state in SDI and in MDI. Also the default states can be different. So for example an "Explorer" window container, can be in elementary split cell state in MDI by default, and in native window state in SDI by default.
The window container is in implementation represented by "Mode".
The following transformation is performed when the SDI mode is used by default (this is possible only when using a special switch):
The following transformation is performed if the MDI mode is the default mode and it is switched to SDI for the first time:
The following transformation is performed if switching from MDI mode to SDI each next time:
The following is performed when the MDI mode is used by default:
The following transformation is performed if the SDI mode is the default mode and it is switched to MDI for the first time:
The following transformation is performed if switching from SDI mode to MDI each next time:
The window system layout is stored into a project. It means when projects are switched from project A to project B the actual layout is stored into project A and the layout from project B is loaded. If project B is a new project than the default layout is loaded.
Switching of projects would happen in following steps: