Proposal overview

General idea

The general idea of Focus-n is to build a document-centered database-oriented framework that empowers the user to work with hierarchic documents (books, reports, web pages, mails, presentations, films, etc.) made of information objects (texts, images, tables, plots, formulas, graphics 2D & 3D, videos, audio, etc.).

User objects

User objects are 'information pieces' created by users. The following illustration shows three examples:

User objects

In Focus-n, all information is built upon user objects.


Focus-n types specify which data and metadata fields contain each kind of user object. The following illustration shows an example of some of the fields defined for a text object:

Text object

Since each user object stores its type ID, the system can provide with the specific tools and options relative to the corresponding kind of information.

Metadata fields help to keep track of the specific characteristics of each user object: language, author, data of creation or modification, permissions, etc. All user objects have a unique Object_ID/Type_ID pair, as well as a name and description of the content of the object. Besides, the data fields contain the information of the object, obviously.

Furthermore, Focus-n types are defined as user objects (of type <Type>). Therefore, the types of the system can be easily expanded or reduced, just by adding or removing the corresponding type objects.


Any user object can be inserted in any page of any kind of document. For each insertion, Focus-n automatically defines a 'frame', which is a software structure that records all information necessary to lay out the content of the associated object inside the page. Since the same object can be inserted in many different pages, frames allow to perform a different lay out of the object data in each page. The following illustration is an example of this feature:

Object frames

In the example above, Text 1 is inserted in two pages. Hence, there are two frames for this object, that render different text attributes (font, size, etc.) in each page. Moreover, other objects in Page B can modify the lay out (margins) of Text 1.

Another important observation is that the data and metadata of Text 1 exists only once in the system database. Therefore, it is the same object inserted in two different places, not two copies of the same text. Consequently, a change in the text will be automatically updated in every place it is inserted in.

Hierarchic frames

Any kind of document can be represented as a group of pages in which user can insert objects. But we can also insert objects inside other objects. For example, we may want to insert a text inside an image, or an expression inside a text, and so on. Focus-n allows to insert any kind of user object inside any other user object. This is accomplished by frame hierarchies, since each frame includes a recursive list of inner frames (inner frames inside inner frames), which defines a tree-like hierarchy. The following illustration is an example of such hierarchical organization:

Frame hierarchy

Indeed, any document is another type of user objects, and so it is any page. Therefore, in Focus-n there is no distinction between highly-structured documents and primitive objects. Consequently, we can devise new structures of information, for example, a book may be composed of sections, which may be composed of chapters, which may be composed of DIN-A4 sized pages, while a web page can be defined as a single infinite-length page containing all the information entries (again, user objects).

On the other hand, any basic object can include a whole structured object, for example, the text portion of an e-mail can include a whole book, without the need of applying copy&paste or attaching any file.

Interfaces and toolboxes

Interfaces are groups of menus, which are groups of menu entries, which in turn are references to toolbox routines. Toolboxes are groups of executable routines, so-called 'actions', that operate on any user object of a certain type. The next illustration shows an example of an unfolded menu of an image interface, jointly with its relation with routines in two toolboxes:

Interface toolbox

Our system allows to select among the interfaces suitable to the type of user object that is in focus. Therefore, all menu interfaces in Focus-n are contextual.

Moreover, the user will be able to configure the layout of menus, as well as the menu entries, in relation with the available toolbox actions for each specific type of object. Finally, the user will be able to install (or deinstall) the toolboxes that he/she is interested in, downloading them from the Focus-n servers or from third-party developers.

Sets and subsets

To deal with lots of user objects of many different types, we propose 'sets'. Focus-n sets are collections of user objects of one specific type. For example, a set of images only admit image objects inside. Focus-n 'subsets' are sets (thus associated to a certain type) that collect a group of user objects from a general set, according to certain criteria. The following illustration shows an example of a set and an associated subset of type <Documents>:

Sets subsets

The list of general sets (left column of the left diagram) is defined automatically by Focus-n according to the types available in the system (the name {Universal} is explained below). The list of subsets (right column of the left diagram) for each general set must be defined by the user. The user is either responsible for manually “moving” objects from the general set into each subset, or to define a group of rules that specifies which of the objects of the general set will be automatically contained in the subset (note the inverted 'A' in the <Emails> subsets).

From the two tables in the illustration, it shall be noticed that objects in a subset still belong to the general set. Therefore, one object must be included in the general set and can be included in several subsets, but the object is the same, i.e., there are not “file copies” inside different “pseudo-folders”.


A Focus-n project is a grouping of all user objects related to a certain task, activity or subject that the user may need to handle with. Indeed, every project is the collection of general sets of all possible types, as well as the associated subsets, which will contain the user objects involved in the project. For example, if the user is planing a travel to Canada, he/she may want to collect all documents, emails, images, and so on related to that travel, but all those info objects must be contained in their intrinsic set and optional subsets, hence the user needs a project to hold all those sets and subsets. The following illustration shows the general 'Info Panel' of Focus-n, which allows the user to deal with his/her projects, sets and subsets:


In the previous example, the user has selected the project [Internet Essay] (highlighted in purple), which is intended for writing a report about Internet for a given course. The name of the general sets is the same than the name of the project, while the name of each subset is chosen by the user.

Besides, there is a [Universal] project that will contain all objects of the user. This is performed automatically by the system, so when the user creates an object inside a subset, Focus-n will place a reference to that object inside the corresponding general set of the selected project, as well as inside the corresponding general set of the [Universal] project, which is logically named as {Universal}.


Focus-n viewers are software modules responsible for displaying all objects contained in a given set. The user shall choose which of the available viewers for the set is best for his/her aim. The following illustration shows four different viewers for the same set of user objects:


Viewers can be oriented to a specific type of information. This kind of viewers will only be accessible for sets of the specific type, or for a derived type. Viewers can also be generalist, and can display all objects that have a field of a specific format, e.g., an integer, a date, a place, a thumbnail, etc. The user will be able to install (or deinstall) the required viewers in the system, downloading them from the Focus-n servers or from third-party developers.

Besides, the example above introduce a curious type of information: <Hotels>. This is a user-defined type composed of several fields specified by the user, such as number of stars, date of arrival, number of nights, address, and so on, each of which must be of a type already installed in the system. In this manner, Focus-n allows to easily define new types from existing ones, similarly to the declaration of a new entity in a database. Therefore, objects are like registers, sets are like tables and viewers are like views. Queries can be implemented as filters integrated in viewers.

Other features

So far we have shown an overview of some of the key points of our system. More details about the implementation and working paths of the exposed ideas will be available in the following pages of the "Proposals" section. Moreover, the "Simulations" section is intended to give an idea of how the software should behave. To end up this page, however, we want to mention some other features of Focus-n, to provide a thorough understanding of the possibilities of our system.

  • Three-panel workflow: the user will switch the display through three kinds of panels, the 'Info panel', the 'Set content panel' and the 'Object content panel', to go from the view of projects and sets, to a view of the objects in a set, and to the edition/viewing of the content of an object (back and forth, except for the last transition).


  • Multi-platform operability: Focus-n will be available for execute in any platform, as a classical computer application, as a web app or as a mobile app; the user will be able to view and edit his/her information from everywhere, and of course everything will be kept in synch through the Focus-n servers, though the apps will be able to run offline and perform deferred synchs.

  • Zoomable interface: the Focus-n display will be a window in the host operating system, or a web page in a browser, or the full screen of a mobile device, but everything in the display will be zoomable, i.e., the system will scale it up or down to accommodate to the available space; besides, when selecting an inner or outer object, the system will perform a gradual scaling to keep track of the context of the focused object.

  • Non-overlapping areas: in devices with large screens, the user will be able to split the Focus-n display into several non-overlapping areas, to edit an object in one area while having a simultaneous view of other referential objects.

  • Simplified interaction: we aimed to simplify user interaction (as much as possible) by removing redundant “actions” over the interface, such as double-clicking, mouse right button, etc.; other actions that can be challenging for disabled or elder people, such as drag&drop, can be bypassed with alternative less arduous (but lengthy) methods.

  • Language independence: all user objects have a language code as a metadata field, which will allow Focus-n to perform accurate grammar corrections but also to link together different linguistic versions of the same object, which we call as 'Babel bubbles', so the user could choose one of the available languages to view the content of an object, or could easily introduce a translation of a given object.

  • Import and export: of course, it will be necessary to devise mechanisms to transform the existing information stored in files into Focus-n hierarchic documents and vice versa, to enable the information transfer with the rest of the world.

  • Per-object operations: although we have explained so far that our system is soundly based on objects, it is interesting to think about how much the common operations (undo, search, copy&paste, etc.) will be empowered by this approach; for example, the user can undo actions made in each object independently from the actions made in other objects.

  • Version control: Babel bubbles are indeed a method to track different versions of the same object, but it will be necessary to perform a historic version control of the objects in order to manage object synchronization through several platforms; besides, the user can explicitly register the current status of his/her work as a “stable version” for future references.

  • Collaborative work: all user objects have a user code, a version code and permissions codes as metadata fields, which will allow several Focus-n users to work collaboratively on the same objects of information.

  • Rights management: digital signatures, copyrights and license management will be easily handled in a per-object basis with metadata fields, which means that legal aspects of information will be attached forever to each user object, with independence of the legal aspects of other objects contained in the same document.

  • And many, many more...

Finally, we want to stress that the whole system is internally defined by another kind of objects that we call 'system objects', that allow to describe the system to itself (reflection); this will provide for flexible configuration and programming of all parts of Focus-n.