Hi,

I'm planning on writing a window manager with the following
characteristics:

- Windows are represented as the leaves of a binary tree.
- To each leaf corresponds exactly one window.
- The only nodes which can be focused are the leaves.
- The leaves are called *window nodes*.
- The other nodes are called *container nodes*.
- Only two methods of node insertion will be provided: *replace* and *pair*.

    Example: insertion of a new node (number 4) into the given tree with the
    *replace* method:

                 b                                   c 
                / \                                 / \
               3   a              -->              4   b    
               ^  / \                              ^  / \   
                 2   1                               3   a
                                                        / \
                                                       2   1

    +-------------------------+         +-------------------------+
    |            |            |         |            |            |
    |            |     2      |         |            |     3      |
    |            |            |         |            |            |
    |     3      |------------|   -->   |     4      |------------|
    |     ^      |            |         |     ^      |     |      |
    |            |     1      |         |            |  2  |  1   |
    |            |            |         |            |     |      |
    +-------------------------+         +-------------------------+

    And with the *pair* method:

                 b                                   b
                / \                                 / \ 
               3   a              -->              c   a 
               ^  / \                             / \ / \
                 2   1                           4  3 2  1
                                                 ^

    +-------------------------+         +-------------------------+
    |            |            |         |            |            |
    |            |     2      |         |     4      |     2      |
    |            |            |         |     ^      |            |
    |     3      |------------|   -->   |------------|------------|
    |     ^      |            |         |            |            |
    |            |     1      |         |     3      |     1      |
    |            |            |         |            |            |
    +-------------------------+         +-------------------------+

- Each container node is a split rectangle.
- The splitting method of a container node is either *automatic* or *manual*.
- In the *automatic* splitting mode, the split type is vertical if the width of
  the rectangle of the node is greater that its height and horizontal
  otherwise.
- Several tree transformations will be provided: directional leaf swap, node
  pulling, rotation, contraction, dilatation...

Greetings,
-- 
 b.d
(| |)
 ^ ^

Reply via email to