Abstract:
Disclosed is a mechanism to control presentation of visible desktop objects in a graphical user interface (GUI). It is particularly related to a scenario where application windows are masking icons with regard to a window overlaying technique. The concept of the invention is to move hidden icons or windows to visible locations of the desktop when they are obscured by other windows, or other desktop objects like icons themselves. Desktop objects which are provided with the above presence functionality regularly call up a routine which compares the actual positions of all windows or other desktop objects with the own location. Calling-up can be initiated also by changes of the desktop contents. If an icon is covered by an other object, it determines a visible target location and will be presented at the new position. The motion of a desktop object can be performed without need of any interaction by the user. Therefore, this mechanism enables a very intuitive comprehensible solution of the above problems.

Description:
FIELD OF THE INVENTION 
     The invention pertains to presentation of visible desktop objects in a graphical user interface (GUI). It concerns GUIs which utilize viewports for presentation of application programs being in a user&#39;s current focus, and so-called &#34;icons&#34; for presentation of application programs currently being out of the user&#39;s focus, or for presentation of mere data objects, respectively. It is particularly related to a scenario where active application windows are masking icons or other non-active windows with regard to a window overlaying technique. 
     BACKGROUND INFORMATION AND DESCRIPTION OF THE RELATED ART 
     Operating systems like OS/2, Windows95 or MacOS (registered trademarks by IBM Corp., Microsoft Corp. and Apple Computer Inc., respectively) commonly provide a virtual electronic desktop as a human-machine interface. Application programs running under those operating systems and respective data resources are represented as desktop objects, where inactive desktop objects (icons) can be activated by use of a pointer device (mouse pointer) and hereby change into active objects usually represented by application windows (window sessions). In those windows the operations and processes of according application programs are performed. 
     This GUI concept causes the problem that, when a user&#39;s desktop becomes busy and cluttered with multiple icons and windows, the lack of available screen makes it very difficult to navigate between various sessions represented by those icons or windows, because often one or more windows or icons cover one or more icons which are then hidden beneath those windows or icons, respectively. A common way for finding an application window that is not clearly visible, or activating such &#34;hidden&#34; icons, by use of a mouse pointer, is to rearrange the position of a covering window, or to minimize that window to an icon. 
     Thereupon, generic operating systems commonly provide a mechanism to bring an icon to focus by positioning the mouse pointer on the icon and clicking on the mouse select button. Often times, users have a plurality of icons (containers) on their desktop whereby some are viewable and some are obstructed. Therefore users must manually rearrange the position of the icons to view a related set of icons. This can be a tedious job when many icons are on the desktop and some are obstructed by others. In an article by A. Salahshour and M. Williams, published in IBM Technical Disclosure Bulletin, vol. 37, no. 1, January 1994, pages 657-658, a respective desktop rearrangement methodology, based on incoming calls for desktop objects, is proposed. A described control mechanism detects an incoming call and automatically surfaces the icons and windows associated to that call. Further to maximize the usage of the viewing display area, the icons and windows are rearranged and re-sized to best fit the display area. 
     In addition, there exist more adequate approaches for solving the above problem. Some of the known desktop systems like the Presentation Manager (PM) under OS/2 provide a so-called &#34;launchpad&#34; usually comprising smaller icons from which frequently used desktop objects can be activated. Those launchpads have a &#34;float on top&#34; functionality which ensures that they are always visible and can not be masked by an application window. This approach has the disadvantage that the viewport for an active application program is reduced by the permanent visibility of the launchpad. Beyond that such a static solution is less flexible i.e. allows only small adaptations of the desktop, and is only a very reduced representation of a real (physical) desktop. Further that static approach does not allow a full-screen view of a window with a high priority for visibility. 
     Another approach enables activation of an application program by a specific combination of key strokes or mouse operations. For instance, OS/2 provides a general-purpose window (&#34;icon park&#34;) for displaying icons which are currently active. In the icon park all icons can be visualized whether the window itself is visible or not. The icon park is a functional window that can be moved, scrolled and re-sized. In particular, the icon park has the capability to re-surface an open but hidden window from the background screen. More detailed information about the icon park concept is contained in an article by R. Hillis et al. published in IBM Technical Disclosure Bulletin, vol. 9, no. 11, Nov. 1991, entitled &#34;Icon Park&#34;. 
     There exist a number of solutions specifically concerning the problem of hidden windows. A first approach is disclosed in U.S. application for Ser. No. 923,698 (IBM docketno. DA992016) assigned to the present assignee and entitled &#34;Method of and Apparatus for Providing Navigation to a Hidden Desktop Window&#34;. Hereby a user is provided a capability to automatically pop into the foreground of the desktop a hidden window or a plurality of hidden windows. The selection of which hidden window to pop into the foreground is based on a priority queue which may depend on the area of a window covered by other windows and/or the number of other windows covering a window. 
     A second approach, a method and system which allow to identify a window on the desktop even when the title bar and list objects are covered up by other windows, is disclosed in a publication by W. Johnson and O. Weber published in IBM Technical Disclosure Bulletin, vol. 36, no. 8, Aug. 1993, pages 143-144. The system causes the title bar of a hidden window to move to another position on that window which is still visible to the user. Further, when only the title bar is masked by another window, the title bar is repositioned at a visible portion of that partially hidden window. 
     A further method to reveal hidden icons which are displayed within a viewport (window) and obscured behind other windows is disclosed in U.S. application for Ser. No. 703,434 (IBM docketno. DA991001) assigned to the present assignee and entitled &#34;Method to Reveal Hidden Target Objects During Graphic User Interface Drag and Drop Operations&#34;. That approach is particularly related to a drag and drop scenario where an icon shall be moved from one (source) viewport to another (target) viewport, wherein the target viewport is not visible since being hidden by another viewport, for example the source viewport. Hereby it is particularly assumed that one of a set of selectable visual icons is to be relocated to an exposed portion of the target viewport. That movement between the viewports triggers an automatic rearranging of the order in which the viewports overlap, causing the target viewport to be raised to a topmost position relative to all the other viewports. 
     An alternative solution for the problem of icons hidden by windows is disclosed in an article by G. Fitzpatrick et al. published in IBM Technical Disclosure Bulletin vol 36, no. 6A, June 1993, pages 135-136. The authors propose a so-called &#34;Translucent Window Attribute&#34; where a translucent window allows objects immediately below it to show through. Hereby confusion and screen clutter of a busy desktop can be minimized. 
     A so-called &#34;Icon Safe Zone&#34; approach is disclosed in an article by L. Cahill et al. published in IBM Technical Disclosure Bulletin no. 6, Nov. 1992, pages 34-35. This safe zone is visually differentiated from the rest of the desktop through the use of shading which, for instance, can be displayed at the bottom of the desktop, wherein a user can decide which icons, e.g. those he works with the most, are placed in that safe zone. Those icons are protected from being covered by other windows. 
     A kind of &#34;ghost icon&#34; approach is disclosed in an article by J. Doran and G. Koets published in IBM Research Disclosure no. 312, April 1990 and entitled &#34;Hidden Icon Notification&#34;. According to that approach, icons are shown briefly in a faded manner which does not obstruct the view of the current window but still can inform the user of an icon change. The proposed method allows a user to communicate with an icon hidden beneath a window although being covered. 
     A more particular solution concerning mobile trainable icons is disclosed in U.S. application for Ser. No. 227,149 (IBM docketno. Y0993077) assigned to the present assignee and entitled &#34;A Method and System for Facilitating the Selection of Icons&#34;. It is proposed that those icons which are next likely to be used are selected and automatically moved towards a cursor thereby facilitating selection of the icons. The likeliness that one or more icons will be used within a predefined amount of time is determined. The appearance of those icons determined not likely to be used within that time is gradually changed. Additionally, those icons likely to be used, or other icons selected by a user, may track the cursor such that those icons are always close to the cursor and capable of being easily selected. In addition, it is possible to reduce the amount of clutter on a computer display so that icons may be easily selected. In order to clean up the computer display, icons which are least likely to be used are faded, eliminated or shrunk to a smaller size. The above approaches all have the drawback of troublesome operability and a missing realization of a virtual desktop and its desktop objects which normally can be activated by simple mouse operations. 
     The objective of the present invention, therefore, is to provide a mechanism to control visibility of icons in a viewport (window) environment, which allows improved visibility of icons and windows and simple and user-friendly adaptation like on a real desktop. Further the mechanism should re-organize the desktop of the GUI automatically with respect to a changing windows environment. 
     The underlying concept of the present invention, to solve the above objective, is that desktop objects, i.e. icons or windows, are moving to visible locations of the desktop when they are obscured by active (opened) windows which usually are a user&#39;s current focus, or other desktop objects like icons themselves. That motion can be advantageously performed without need of any interaction by the user. The proposed basic functionality can be arbitrarily adapted to different technical requirements of the GUI desktop or needs of the respective user of the GUI. In particular the invention is a very intuitive comprehensible solution of the above problems. 
     It is emphasized that a user&#39;s current focus on an application (program) is not restricted with regard to &#34;opened&#34; or &#34;closed&#34; viewports since icons can also be active programs running in the background, and thus an application currently focussed by a user is not only characterized by its active or non-active state. 
     In a first embodiment of the invention desktop objects which are provided with the above functionality regularly call up a routine which compares the actual positions of all windows or other desktop objects with the own location. Calling-up can be initiated also by changes of the desktop contents. If an icon is covered by an other object, it determines a visible target location and will be presented at the new position. A particular advantage of the proposed concept is that the development tools, programming languages and system interfaces required for implementation of the proposed mechanism are already provided by known operating systems which support mouse pointers together with windows-oriented desktop objects. 
     In a further embodiment of the mechanism according to the invention the user equips multiple desktop objects with self-controlling presence (visibility) functionality by use of a common &#34;notebook&#34; which is already provided for example by OS/2 for configuration of objects. In such a notebook the user can also activate or inactivate the presence functionality for one or more objects. 
     In another embodiment, the direction of motion of the objects can be controlled by priority. For instance, the desktop can be partitioned into a number (e.g. 4) quadrants each of which having assigned a different weight by the user. If a self-controlled icon is covered by an other object, it first will try to be presented at a visible portion of the desktop corresponding to a quadrant with the largest weight. The order for selecting a visible portion of the desktop can also be controlled by points of the compass or clockwise direction. 
     According to a further embodiment of the invention the motion of the icons can be adjusted with respect to the habit of the respective user and with respect to a most clearly arranged desktop. For instance, moving objects can be presented discreet with regard to shape, brightness or contrast of non-moved objects in order not to irritate the user who is busy with an active window. The motion of icons can also be presented invisible to the user wherein moved icons only appear at the target location. 
     Furthermore, the user is free in configuration of the behavior of desktop objects after close of a previously masking window. Hereby the following rules can be implemented: 
     The &#34;moved&#34; object remains at the target position; the moved object appears at the origin position which becomes visible again due to the close of the window; 
     the object has not really &#34;moved&#34; to the target position, but only a copy of that object was generated at a visible portion of the desktop, wherein after close of the window the origin object as well as the copy are presented, or only the copy is discarded. 
     The essential features of the invention will now be explained through the embodiment examples in the following illustrations, and within the framework of a comparison with the relevant state of the art. 
     SUMMARY OF THE INVENTION 
     Disclosed is a mechanism to control presentation of visible desktop objects in a graphical user interface (GUI). It is particularly related to a scenario where application windows are masking icons with regard to a window overlaying technique. Known GUI concepts have the disadvantage that, when a user&#39;s desktop becomes busy and cluttered with multiple icons and windows, the lack of available screen makes it very difficult to navigate between various sessions and windows because often one or more windows cover one or more icons which are hidden beneath those windows. The concept of the invention is to move hidden icons or windows to visible locations of the desktop when they are obscured by other windows, or other desktop objects like icons themselves. Desktop objects which are provided with the above presence functionality regularly call up a routine which compares the actual positions of all windows or other desktop objects with the own location. Calling-up can be initiated also by changes of the desktop contents. If an icon is covered by an other object, it determines a visible target location and will be presented at the new position. A particular advantage of the proposed concept is that the development tools, programming languages and system interfaces required for implementation of the proposed mechanism are already provided by known operating systems. The motion of a desktop object can be performed without need of any interaction by the user. Therefore, this mechanism enables a very intuitive comprehensible solution of the above problems. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIG. 1 is a flow chart diagram depicting the principle control mechanism for presentation of visually hidden icons (inactive desktop objects) in a graphical user interface (GUI) according to the invention; 
     FIG. 2 is a flow chart diagram as in FIG. 1, but with an additional functionality for adapting the desktop object&#39;s size to the available desktop space of the GUI; 
     FIGS. 3-5 show different embodiments for segmentation of the display screen of the GUI for presentation of visually hidden icons; and 
     FIGS. 6-13 are typical display screen shots for a common scenario in a GUI concurrently displaying several icons and application windows, illustrating the benefits through use of the invention vis-a-vis prior art approaches. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     Referring to FIG. 1, the control mechanism proposed by the invention is illustrated by way of a flow chart diagram where the necessary control steps for determination of a hidden state of an icon and for a non-hidden presentation of such an icon is shown. That control mechanism can be performed, for instance, by a supervisor control program running on an operating system level. An alternative way of implementation and configuration of the control mechanism by a user is use of existing functionality provided by operating systems like OS/2 for the configuration of desktop (window) objects. Such an implementation is described below in more detail. 
     The control mechanism involves a step of determining 1 hidden states of the icons on the desktop, i.e. their visibility on the desktop, wherein an activation of that mechanism, in a first embodiment, can be triggered periodically dependent on a &#34;timer elapsed&#34; signal. That signal can be delivered by an internal timer routine, e.g. a wait loop 2, which can be provided by the operating system or can be implemented as a separate application program. In another embodiment the control mechanism can be triggered by current changes of the desktop contents i.e. on an event basis 2. 
     In case of a hidden icon, the next step is determining 3 a non-hidden portion of the desktop where the hidden icon can be presented non-masked. Hereby a user can configure the details of that search. For example, in case of a priority-controlled segmentation of the desktop, the user can determine the sequence of how the desktop segments are checked for availability to allow a non-hidden presentation of the icon. In case of such a visible desktop area being found, the next step is visibly presenting 4 the icon at the new desktop area. 
     Concerning the details of the new presentation of an icon, multiple embodiments are suitable. In a first embodiment the icon can be presented immediately, e.g. as a copy of the original hidden icon, or as a moved original icon. In another embodiment, the movement of the icon to the new presentation area can be visualized by means of displaying a continuous moving trace or displaying a shorter trace like a tail of a comet. Beyond that the moving trace can be displayed in a more discreet manner by means of shading. The moving style can be configured by the user individually for each icon or jointly for all the icons. Besides the herein disclosed embodiments, a variety of other implementations of the proposed control mechanism are possible. 
     FIG. 2 includes a further functionality 10 through which icons can be scaled down in size if the visible portion of the desktop is not sufficient for presentation of all icons. The necessary step is to check out 11 whether icons are overlapping with other icons or windows (partially hidden desktop objects) within the destination area for a new presentation of the &#34;moved&#34; icon. In case of overlapping desktop objects, the size of each icon displayed at the respective portion of the desktop is reduced 12 in order to enable presentation of all icons without overlaps. Hereby the sizes can be changed jointly or individually for each or some of the icons. 
     For an implementation of the control mechanism under the Presentation Manager (PM) of OS/2 existing information and functionality can be utilized as will be illustrated now. First some principles of PM which provide information and functionalities to implement the described invention are summarized: 
     PM creates at start-up a window known as the desktop window or &#34;workplace&#34;. This desktop window serves as base window for all applications and as the parent of all top-level windows. To perform functions with the desktop window a predefined identifier HWND --  DESKTOP can be used or the WinQueryDesktop Window API (Application Program Interface) can be queried as follows: 
     HAB hab: /&#34;Anchor-block handle*/HDC hdc: /&#34;Device-context handle*/HWND hwndDeskTop: /Desktop-window handle*/HWND hwndDeskTop=WinQuery Desktop Window (hab, hdc); 
     Other useful API functions (without parameters) for the implementation of the invention under OS/2 are: 
     WinQueryActiveWindow 
     /*This function obtains the handle to the active window*/ 
     WinBeginEnum Windows 
     /*This function begins the enumeration process for all of the immediate child windows of a specified window. (WinEndEnum Windows ends the enumeration)*/ 
     WinQueryWindowPos 
     /*this function queries the window size and position of a visible window*/ 
     WinSetWindowPos 
     /*This function allows the general positioning of a window*/ 
     WinQueryWindowRect 
     /*This function returns a window rectangle*/ 
     WinIsWindowShowing 
     /*This function determines whether any part of the specified window is physically visible*/ 
     WinWindowFromPoint 
     /*This function finds the window below a specified point  or returns NULL on failure|!*/ 
     It is noteworthy that an icon is defined as a minimized window and thus particularly can be moved like a window. Therefore all the above and the following functions can be performed on icons too. By means of the above API functions the PM can be programmed by the user. Similar functions are also provided by other operating systems like Microsoft Windows (registered trademark by Microsoft Corp.). The PM counterpart under Windows is a so-called Desktop Manager. 
     Further the current minimized or maximized state of a window can be retrieved by checking the window style parameter by use of an API function WinQueryWindowUlong as follows: 
     ULONG ulStyle; 
     ulStyle=WinQueryWindowUlong (hwndwindow, QWL --  STYLE); 
     BOOL bisicon=ulstyle &amp; WS --  MINIMIZED; 
     BOOL bisMaximized=ulStyle &amp; WS --  MAXIMIZED; 
     OS/2 as a multitasking operating system thereupon provides messages and message queues for desktop objects.Related to the invention PM generates the following useful messages: 
     WM --  SIZE 
     /*Sent if the size of the window has changed, after the change has been made. This message specifies both the old and new window size*/ 
     WM --  MOVE 
     /*Sent when a window moves its absolute position*/. 
     There are several possibilities to realize the described functionality of the invention. A very efficient implementation is the maintaining of a globally accessible 2-dimensional array which contains the coordinates of all visible windows (including minimized windows=icons). With this method only one background process is necessary for the whole desktop. 
     The process initializes and updates the entries of the array. For the updating the process only needs to filter the PM message queue for WM --  SIZE and WM --  MOVE messages. The next step is to detect a violation of the visibility state of the windows marked &#34;present&#34;. This can be accomplished by performing a numeric algorithm on the data array which detects the overlapping of borderlines in a set of 2-dimensional fields. Those algorithms are well-known in that field of 2-dimensional arithmetic. 
     In contrast to the above 2-dimensional calculations, a much easier way to detect overlapping is the using of a further OS/2 API query named WinIsWindowShowing. In this case the condition for the visibility is very weak since WinIsWindowShowing returns a logical false only in case of full overlapping. In the same manner the coordinates of free areas is determined, and if necessary one or a several icons are moved (using WinSetwindowPos). It is possible to move and size the window in a single call (when a minimization is necessary). As an example, to move a window to position (10,10) and to change the size to 75 pels by 50 pels the following call can be performed: 
     WinSetWindowPos (hwndwindow, 0 L, 10 L, 10 L, 75 L, 50L, SWP --  MOVE|SWP --  SIZE); 
     In the precited operating systems this function is available for windows in general. Alternatively, icons can be sized with the following method. For each (maximized) window several icon bitmaps in different sizes (and designs, if desired) are hold. Depending on the available desktop area the bitmap with the best size can be used to represent a minimized window as icon. 
     The following exemplary code represents a recursive procedure that can be used to initialize an array which contains the positions of all visible windows on the desktop. 
     #define INCL --  WINWINDOWMGR/*WindowManager Functions*/#include &lt;os2.h&gt; 
     VOID EnumerateImmediateChilds (HWND hwndParent)/*hwndParent: Handle of the window whose child windows are to be enumerated*/{HWND hwndChild; /*current enumeration handle*/HENUM henum; /*enumeration handle*/SWP swp; /*SWP-structure, containing window&#39;s size, position and state)*/henum=WinBeginEnumwindows(hwndParent); 
     while ((hwndChild=WinGetNextWindow(henum))|=NULLHANDLE){ . . . /*Determine window position and size*/WinQueryWindowPos(hwndChild,&amp;swp) . . . /*add current window data to global array*/AddData to Array(hwndChild, swp);/user-defined function*/ . . . 
     EnumerateImmediateChilds(hwndChild); /*recursive call to detectall windows*/ . . . } 
     WinEndEnumWindows(henum); 
     return; 
     To enumerate and determine all windows in the system (taking a snapshot of the desktop) this procedure must be called with HWND --  DESKTOP, i.e. 
     EnumerateImmediateChilds(HWND --  DESKTOP). That call-up provides for all windows the respective &#34;handle&#34; i.e. the sought data. The inner &#34;while&#34; loop of the above procedure is executed for each window of the desktop. The function WinGetNextWindow(henum) provides all child windows of a parent window and is recursive insofar as child windows themselves can have &#34;children&#34; again. The parent window can be represented by the desktop (window) itself. 
     For all icons for which the presence functionality according to the invention is provided, the above depicted procedure needs only one process running in the background, i.e. one process for one desktop. As an alternative embodiment of the invention, one process per icon can be implemented where multiple processes of the same kind have to be run in parallel in the background. In that fully object-oriented implementation, the above procedure is performed independently by each icon what is advantageous insofar as the described functionality belongs to each icon. Thereupon other properties of object-oriented technology like &#34;inheritance&#34; can be advantageously used. 
     A further approach--instead of an implementation based on existing functionality of the underlying operating system--is to implement a separate application program which includes the beforehand discussed concepts with regard to the array approach. 
     Furthermore as described above, the &#34;moving&#34; behavior of icons according to the invention can be configured, for instance with respect to the working habits of the user of the GUI. In a preferred embodiment the desktop is segmented into multiple partitions each of them having assigned a different priority to become a target portion of the desktop for displaying a previously hidden icon, or several hidden icons, respectively. Various embodiments for segmentation of the desktop are suitable and FIGS. 3-5 depict only preferred embodiments. In FIG. 3 the desktop is subdivided into four quadrants wherein the priority of each quadrant to become the destination area is controlled by a clockwise priority chain. In FIG. 4 the desktop is segmented into four quadrants which are aligned to the points of a compass. In a further embodiment according to FIG. 5 the segmentation is accomplished similar to a clock-face. 
     The screenshots shown in FIGS. 6-13 show typical situations of a GUI desktop where the invention can be advantageously applied. In FIG. 6 on top of a desktop screen 40 a number of icons 41 is visible. In order to set the advantages of the invention against prior art solutions, at the bottom of the desktop screen 40 a launchpad 42 is displayed where frequently used icons i.e. application programs can be picked up as reduced icons. 
     It is now assumed that an application program like that represented by the icon &#34;MYTEXT.TXT&#34; is called up by applying the mouse pointer to that icon, which thus becomes the user&#39;s current focus. By calling up the text file &#34;MYTEXT&#34;, according to the principles of object-oriented technology, a respective system editor is started which enables to edit in that text file. The editor 50 displaying the text file 51 is shown in FIG. 7. The text file 51 is indicated at the title bar of the editor 50. As can be seen at the top left side of the desktop 54, the icons displayed at the top left side of in FIG. 6, in particular the icon for the application program &#34;MY-PROGRAM&#34; 52, are now hidden beneath the application window of the editor 50. 
     In particular the icon &#34;MY-PROGRAM&#34; is obstructed and can not be called up immediately. As described with regard to FIG. 8, according to a known approach, the icon representing the program &#34;MY-PROGRAM&#34; 60 can be picked up in a launchpad 42. Those &#34;hot areas&#34; can be configured to have a &#34;float on top&#34; characteristic, i.e. they are always viewed in the foreground of the desktop, nevertheless they are active or not. The disadvantage of that solution is evident from FIG. 9 where the launchpad 42 is displayed together with the editor 50. Free accessibility of the active window 51 is substantially reduced by the area of the desktop reserved for the launchpad. 
     A preferred mode of operation for the invention is illustrated with reference to FIG. 10. The desktop object &#34;MY-PROGRAM&#34; 70 is now displayed at a non-hidden portion of the desktop at the right top. In this example it is assumed that the quadrant &#34;I&#34; of FIG. 3 has the highest priority for displaying that &#34;hidden&#34; icon. Thereupon the launchpad 71 for enabling a call-up of the icon &#34;MY-PROGRAM&#34; is no longer needed and thus can be displayed beneath the active window 72. 
     In case of quadrant &#34;I&#34; also being hidden beneath e.g. another window 80, the hidden icon 81 will be displayed at quadrant &#34;II&#34; at the top left side according to its succeeding priority. This behavior is shown by FIG. 11. 
     FIGS. 12 and 13 show an operation mode of the proposed control mechanism with regard to the optional icon diminution function. In FIG. 12 a scenario is shown where a previously hidden icon 90 has been already moved to a non-hidden portion at the right top of the desktop. In a next stage (FIG. 13) it is assumed that a further application window 91 has been activated which now covers the icon 90 thus the latter becoming hidden again. As in FIG. 11, it is assumed that quadrant &#34;II&#34; has the following priority after quadrant &#34;I&#34; and therefore the control mechanism tries to display the hidden icon 90 at that portion of the desktop. Since that portion is already occupied by two other icons 93, 94 the hidden icon 90 can not be displayed together with those icons without any overlap. Therefore the optional &#34;icon resize&#34; functionality as being part of the proposed mechanism becomes active and resizes all those icons 92-94 in order to get them displayed without overlaps.