Multi-Graph Mode in the API
uDraw(Graph) is able to visualize more than one graph at a time,
called multi-graph mode.
Please read about multi-graph basics in the
before going on here.
In multi-graph mode, each loaded graph is shown in a different
Operations applied to one graph do not affect the other graphs.
The notion of contexts have been introduced to deal with more
than one concurrent graph at the API level.
Each context has its own scope, so it is not necessary to keep
identifiers unique between two contexts, but of course all
identifiers have to be unique inside a context.
Identifiers are used for nodes and edges in a
term representation or for menus.
In multi-graph mode, each graph has a context with a unique context ID
The context ID is either automatically generated by uDraw(Graph) when a
new context is opened with command
or can be chosen by the application itself when the new context is
opened with the alternative command
Opening a new context creates a fresh and empty base window.
Afterwards, all commands sent to the API are applied to this context
until the current context is set to another one.
So for example, by sending command
directly after opening a new context, the current context will first
switch to the new context automatically and afterwards the graph will
be displayed in the new window.
If the application wants to apply an API command to another graph that
has been previously opened, then first of all it has to set the current
context to the one that belongs to the other graph.
So a context is used to specify one of the currently loaded graphs
that should be affected by subsequent API commands.
The context can be set using API command
Principle of two Answers in Multi-Graph Mode
By default, uDraw(Graph) operates in single-graph mode where setting a
context is not necessary.
After entering the multi-graph mode (i.e. after sending the first
command to the API),
each answer from the API will have a preluding
answer that is used to specify the context where the event happened.
So in multi-graph mode, the application will always get two answers
with each event: first the context and then the event itself.
Note that the preluding context answer does not switch the current
This can only be done by the application itself, as described above.
To guarantee full compatibility with applications designed for
uDraw(Graph) predecessor versions prior to 2.0 (which do not expect a
preluding context), the context answer is only used after entering
the multi-graph mode.
At start-up time, uDraw(Graph) operates in single-graph mode by default.
uDraw(Graph) cannot enter the multi-graph mode by itself with user
interface operations, so only the application can decide to do so.
Entering the Multi-Graph Mode at Initialization Time
If the application intends to enter the multi-graph mode later in
a session, it should open the first context at initialization time,
because for consistency reasons, uDraw(Graph) has to remove a loaded
graph as soon as the first context is opened (i.e. when the
single-graph mode is left).
The application is able to close an opened context by sending command
This is the equivalent operation of menu
After closing a context, all of the windows of the particular graph
will be removed, and the corresponding context ID cannot be used any
Afterwards, the application has to open a new context or specify one
of the remaining contexts to be the new current context.
Sending any other command without changing the context will be
answered with an error message, because the current context is undefined
after closing as long as a new one is not specified.
It is even possible to close the last context without quitting uDraw(Graph).
After closing the last context, no window will be visible any longer,
but the uDraw(Graph) process is still running in the background.
In this situation, the application can open a new first context and a
new base window will come back.
the user can also close a context at any time by using menu
or the equivalent generic window function of the operating system
respective window manager.
The application will receive the answer
from the API after the user or the application has decided to close
If closing a context is not appropriate for the user, then
the application should
redefine the user interface
or at least
take control of the "File" menu
in order to catch these events.
Multi-View Mode in the API
The multi-view mode is used to have different base windows where
the same graph is visualized.
In opposition to
here the base windows show the same graph, so working with one
view manipulates all the other views of the graph, too.
Please refer to multi-view basics in the
Multi-graph and multi-view can be mixed at the same time,
e.g. several graphs can be loaded and each may have different views.
Multi-view is a feature of the user interface level and cannot be
controlled on the API level, except for opening a new view using
So it is not possible for an application to close a particular view,
but you have the option to use the
where all base windows can be controlled.
All views (base windows) of a context (graph) are removed when the
corresponding context is closed with command
The user is able to open and close new views of a graph at any time.
The first (i.e. oldest) view of a context is called master view.
The master view can be closed by the user without closing the whole
context as long as there is one other view of the same graph
which will become the new master view.
For example, if the user opens one additional view with menu
View/Open New View
after starting the system and loading a graph,
then he can work with the same graph in two different base windows.
Now, the user is able to close the first view (master view) with
without closing the whole context/graph.
The second remaining view will serve as the new master view in
Most of the commands dealing with one base window rather than the
whole graph (e.g. setting the scale, focusing nodes or setting
window position/extension, etc.) are applied only to the master
view window of a context and not to all of the other views.
The master view is always the oldest view of a context.
The other views cannot be manipulated with API commands,
because multi-view is a feature of the user interface rather
than the API.
But the multi-window mode can be used to have access to all
individual base windows, read below.
Multi-Window Mode in the API
Usually, the application has no access to individual base windows
(views) of a context (graph).
But this is possible in the alternative multi-window mode where an
application can access all base windows, whether they belong to
multiple graphs or views.
The idea is to add an additional window ID (beside the context ID)
to the relevant API commands and answers.
The multi-window mode is not compatible with previous versions of the
API (where window IDs are not expected), so the application must
be designed to operate in this mode by accepting the special kind of
answers mentioned below.
To avoid compatibility problems, the multi-window mode
has to be explicitly activated using command-line option
After this activation, the multi-window is entered as soon as the
is sent to the API, similar to the
mode described above.
Instead of answer
known from the multi-graph mode, the answer
is used after the multi-window mode has been entered.
Here, the application can find a window ID maintained by uDraw(Graph).
This window ID can be used in command
to restrict all subsequent commands to that particular base window.
In multi-window mode, the application is informed with the answers
about creation and destruction of a base window.
To summarize it, the multi-window mode is an extension of the
multi-graph mode where the application has full control over any
base window. The multi-view mode is not accessible from the API
except of manipulating the master view and opening new views.