LibreOffice Developer's Guide: Glossary
- The term abstraction denotes the process or the result of a generalization. Generalization describes objects by qualities common to all objects of a certain class of objects. The principle of the generalization is to disregard individual properties of the objects, consequently it is impossible that an abstract object exists anywhere but in theory.
- Ability of an application to provide its functionality also in situations where the usage of input and output devices is restricted for some reason. For instance, this can be due to restrictions of the devices, the environment or a physical disability of the user. Often assistive technology is used to provide accessibility, for instance screen readers or braille terminals. From version OpenOffice 1.1.0, LibreOffice has an API for accessibility, which can be used with Java and Gnome accessibility.
- An add-in is a functional extension for the LibreOffice application on the basis of UNO components, which interact with parts of the application that were especially laid out to be extended. Examples of Add-Ins are Chart and Calc Add-Ins.
- All purpose data type for variables in UNOIDL. An any variable contains whichever data type is specified for UNOIDL.
- Application Programming Interface. The entirety of published methods, properties and other means for software developers to access an application through software they write using this application.
- Devices which can be used to improve accessibility, see Accessibility.
- Assistive Technology, devices which can be used to improve accessibility. See Accessibility.
- Communication protocol between OLE automation objects. See OLE Automation.
- Abstract Window Toolkit. The LibreOffice API contains a module <idlmodule>com.sun.star.awt</idlmodule> with abstract specifications for a window toolkit that handles graphical devices, window environments and user interfaces. In the current implementation of this specification, the specified features are mapped to platform-specific window systems, such as Windows, X Windows or Java AWT. The current C++ implementation is based on the Visual Component Library, a platform independent C++ library for GUIs, which is part of LibreOffice.
Binary UNO Interface
- When method calls are transported over a UNO bridge, a single generic C method is used to dispatch all method calls across the bridge. This method and its parameters is also known as the binary UNO interface.
- Code that connects different language environments, such as C++, Java and indirectly LibreOffice Basic, with each other. The connection is exclusively used to transport method calls with their parameters, and return values back and forth between the language environments.
- Calendaring information in an internationally used application pose the problem to translate between the various calendar systems used in the world. In the context of LibreOffice, local calendars are supported through the I18N API.
- LibreOffice spreadsheet document or components of the LibreOffice application containing the functionality necessary for spreadsheet documents in LibreOffice. Although there might be an scalc executable on some platforms, it does not contain the Calc functionality, it starts up a calc document using soffice.exe and its dependencies.
- Embedded diagram document or components of the LibreOffice application containing the functionality necessary for embedded diagrams in LibreOffice. These diagrams visualize numeric and textual data, such as lines, bars, and pies.
- China-Japan-Korea. A group of Asian languages that require similar treatment in user interfaces for common principles, such as the writing direction and other features of Asian document editing.
- Class is the description of the common qualities of individual objects in object-oriented languages. This description can be expressed in an object-oriented programming language. A class description may be abstract where it does not contain sufficient implementation to create fully functional instances of a class, or it can be fully implemented. Fully implemented classes are used to create individual instances of objects that act according to the class description.
- An object using the services of a server. See server.
- The clipboard is common storage place on a computer platform. Information is copied or cut from one application context and transferred to this storage where users paste it into another application context. A variety of file formats can be written to the clipboard making the information useful in many different contexts.
- In the context of LibreOffice, ordering of textual information according to ordering rules local to a cultural community. The rules for alphabetical ordering in Latin writing differ from country to country, and there are completely different ordering rules in other cultural communities. LibreOffice supports localized collation through its I18N API.
Collection (UNO Collection)
- UNO collections are gatherings of objects that are retrieved by enumeration, index or name through collection interfaces. UNO collections are not necessarily UNO containers, because they do not support the addition of new objects to the collection - though a collection can be a container too.
- Component Object Model. An object communication framework created as a part of OLE by Microsoft (R) . See OLE.
- A string containing a command in the LibreOffice dispatch framework. See URL.
- Acknowledgment of an open transaction. See transaction.
Complex Text Layout
- Complex Text Layout Languages: In CTL languages (such as Thai, Hebrew, Arabic and Indian) multiple characters may combine to form a display cell
- The term component has two uses in the UNO context. There are UNO components and XComponents, that is, objects implementing the interface <idl>com.sun.star.lang.XComponent</idl>.
- UNO components are shared libraries containing implementations of UNO objects that are registered with and instantiated by a UNO service manager or service factory. If the component only uses a UNO environment, it is a well formed component.
XComponentis a UNO object that allows its owner object to control its lifetime and a user object to register as a listener to be informed when the owner disposes of the
XComponent. Occasionally, the term component is used as a short form for
XComponent. For example, since LibreOffice documents loaded by the desktop must always support
XComponent, it has become customary to call them components or desktop components. Loaded documents are not UNO components in the sense of a well formed component. They have no shared libraries and cannot be registered and instantiated at a service manager. It should always be clear from the context if the term component means well formed UNO component or
- In the context of LibreOffice often used for XML based configuration files. LibreOffice has an API to access this configuration, the Extension Manager can insert configuration items, and users can edit the files manually.
- A named value in a computer program that does not change during runtime. Constants are used to handle cryptic parameters in an understandable manner as in <idlm> com.sun.star.text.HoriOrientation:LEFT</idlm>. Furthermore, if constants are used. it is possible to alter the internal value of a constant without changing every occurrence of this value in written code. But it is not possible to change the value of UNO IDL constants.
- A named group of constant values, for example, the group <idl>com.sun.star.text.HoriOrientation</idl> contains constant values that describe possible horizontal orientations, such as LEFT, CENTER, and RIGHT. See constant.
Container (UNO Container)
- UNO collection of objects with the additional option to add new objects to the collection and to remove objects. See collection.
- An UNO Connection is an open communication channel between a UNO client and server. For example., if a Java program uses LibreOffice over the Java language binding, the Java client program connects to the LibreOffice application, which then acts as server for the Java client.
- A Database Connection is an open communication channel between a database management system and an authenticated user.
- A controller in the frame-controller-model paradigm of LibreOffice is a service that controls a visual representation of a LibreOffice document model. It may offer interfaces to access the visual representation, but it is not used to change the model it presents. In the frame-controller-model paradigm the view is a hidden implementation detail behind the controller. See frame-controller-model paradigm.
- Common Object Request Broker Architecture. Platform independent architecture for object communication. CORBA served as one of the examples for UNO.
- see Complex Text Layout
- Abbreviation for database.
- Database Management System
- Distributed Component Object Model. It adds to COM objects the ability to communicate with COM objects on other machines.
- A Windows protocol allowing applications to exchange data automatically. The LibreOffice supports DDE through the Edit - Paste Special command. LibreOffice Basic also uses DDE.
- Data Definition Language. Parts of SQL used to create and alter tables, and modify rules for relational integrity.
- A state where two processes wait for another so that they can continue their work. They have to wait until the deadlock is released from outside. For example this can happen if process A locks resource X and process B locks resource Y, and then process B tries to lock resource X and process A tries to lock resource Y.
- Central management instance for viewable components in the LibreOffice application.
Dialog (UNO Dialog)
- A UNO dialog shows a window for user input. A dialog contains control elements, such as text fields, buttons, list boxes, and combo boxes. Currently, UNO dialogs are always modal, which means that they must be closed before the process displaying the dialog can continue with its tasks. Furthermore, UNO dialogs do not support data aware controls, rather database connectivity has to be implemented manually. If you want to offer a non-modal window or work with data, consider using a UNO form.
- LibreOffice has a mechanism that sees documents as targets for uniform command tokens, which are handled for example by documents with methods specific to the document. This alleviates writing a user interface that does not need to know about the internal structure of a document. The user interface asks the document the command tokens it supports, and displays matching menus and toolbars. A toolbar icon like Background Color is used for many different objects without knowing in advance about the target object.
- The command tokens have to be written in URL notation, therefore they are called command URLs, and are sent or dispatched to a target frame. The corresponding specification is called Dispatch API.
- Data Manipulation Language. Part of SQL.
- LibreOffice drawing document or components of the LibreOffice application which contain the functionality necessary for drawing in LibreOffice. Although there might be an sdraw executable on some platforms, it does not contain the actual Draw functionality, it merely starts up a Draw document, using soffice.exe and its dependencies.
- A layer for graphical objects in LibreOffice documents. Each of the document types Writer, Calc, Draw, and Impress have one or multiple draw pages for shapes. Most graphical shapes on a drawpage are geometrical objects, but embedded documents and forms are also located on the draw page of a document.
- A part of the frame-controller-model paradigm in LibreOffice. The controller of a document is responsible for screen presentation, display control and the current view status of a document.
- A named group of predefined values in the LibreOffice API comprising all plausible values for a variable in a certain context. Only one enum value can apply at a time. An example for an enum is
com.sun.star.text.PageNumberTypewith the possible values
- A collection of UNO objects supporting the interface <idl>com.sun.star.container.XEnumeration</idl> accessed one by one using a loop construction. An XEnumeration has to be created at a <idl>com.sun.star.container.XEnumerationAccess</idl> interface.
- In the LibreOffice API, an event is an incident between an observable and an observer. The observable sends a message that something has happened that the observer wanted to know about. See listener.
- The exception is a concept for error handling that separates the normal program flow from error conditions. Instead of returning error values as function return codes, an exception interrupts the normal program flow at anytime, transports detailed information about the error and passes it along the chain of callers until it is handled in code. This is helpful for the user to achieve a low-level function, therefore react appropriately, while it is still able to find out exactly what went wrong.
- An extension is a file intended for the distribution of code and / or data which is to be used by LibreOffice. The file has the file extension "oxt" (formerly .uno.pkg and .zip), and it acts as a container for various items, such as libraries, JARs, configuration data, type libraries, Basic libraries, Basic dialogs, etc. Before OOo can use any content of the extension, it needs to be installed by the Extension Manager.
- The Extension Manager is a tool for managing extensions and other deployable items, such as separate libraries, JARs, configuration data files. This includes adding, removing, enabling and disabling of these items.
- Frame-Controller-Model paradigm. See frame-controller-model.
- There are two kinds of filters in LibreOffice, data filters and import/export filters.
- Data filters reduce the number of records in a list or database to those records that match the given filter criteria. Examples of filters are those filters in a spreadsheet or database form.
- The import and export filters read and write document data for specific file formats. They create LibreOffice documents from the files they support in a running LibreOffice instance, and create a target file in a supported format from a loaded document.
- A form is a LibreOffice document with a set of controls that allows users to enter data, and submit the data to a web server or store them in a database.
- Data-aware forms support data-aware controls that display data from a database and write changes to a database automatically. Furthermore, they have built-in filtering and sorting capabilities. It is also possible to create subforms in forms.
- Without a connection to a server, forms are only partially useful, because the integration with the surrounding document is still incomplete. Forms cannot be printed well, because text boxes do not shrink or grow, and list boxes and subforms are cut off in printing. It is not possible to have control borders in the user interface and hide them in printing.
- Part of the frame-controller-model paradigm in LibreOffice. See frame-controller-model paradigm.
Frame-Controller-Model Paradigm (FCM)
- The architectural separation of content, visual representation, and binding to the surrounding window system in LibreOffice. Loaded office documents consist of:
- a model object for document data with document manipulation methods
- one or more controllers for screen presentation, display control and current view status of a document model
- one frame per controller that links the controller with the surrounding windowing system, and dispatches command URLs it receives. It makes the document environment exchangeable. For instance, aside from the standard document windows there can be frames for documents in JavaBeans, Browser Plug-ins, MDI Windows, and embedded windows.
- Programming with the FCM paradigm is simple: To change the document, use the model. To access the visual representation, ask the controller. To work with the window, obtain the frame.
- If you know the Smalltalk model-view-controller paradigm (MVC), it is probably best to see frame-controller-model as a different concept with a few similarities to MVC. The main differences are:
- The controller in FCM incorporates the visual presentation layer: Controller and visual representation are no different objects on API level. It controls the visual representation such as the current page or the visual cursor position, but it is generally not used to control the document content.
- FCM has a frame, which is unknown in MVC.
- Graphical User Interface, as opposed to a command line interface. A user interface is the point where a user and a software application meet and interact. A graphical user interface uses graphical representations of commands, status feedbacks and data of an application, and offers methods to interact with it through graphical devices, such as a mouse or tablets.
- Classes or methods with ready-to-use implementations that are used to implement fully functional UNO components. The goal is that implementers of UNO components can concentrate on the functionality they want to deliver, without having to cope with the intricacies of UNO.
- Internationalization, written I18N because of the 18 letters between the 'i' and 'n' in internationalization. It provides the functionality to adapt a software to the needs of an international community with their deviating standards. For example, documents should be fully interchangeable, that is, a date should be the same date no matter where the document is edited, but the date needs to be displayed and edited according to the conventions followed in the user's country. Also, the user should be able to combine documents from other countries with his own documents without having to convert date formats.
- Integrated Development Environment is a tool used for software development that integrates editing, debugging, graphical interface design and online help, and advanced features, such as version control, object browsing and project management in a unified user interface. LibreOffice contains a small IDE for LibreOffice Basic.
- Interface Definition Language is used in environments where interfaces are used for object communication. An interface definition language is frequently used to describe interfaces independently of a particular target language. For instance, CORBA and OLE have their own interface definition languages. UNO does not stand behind these component technologies and specifies its own IDL called UNO IDL.
- The process of writing a fully functional software according to a specification. Implementation also means the concrete, realized thing as opposed to an abstract concept. For instance, the current version of LibreOffice is one possible implementation of the LibreOffice API.
- LibreOffice presentation document or components of the LibreOffice application that contains the functionality necessary for presentation documents in LibreOffice. Although there might be an simpress executable on some platforms, it does not contain the Impress functionality, it starts up a presentation document using soffice.exe and its dependencies.
Initialization of UNO Services
- UNO objects are initialized when they are instantiated by a service manager if they support the interface <idl>com.sun.star.lang.XInitialization</idl>. The service manager automatically passes the arguments given in
createInstanceWithArgumentsAndContext()to the method
initialize()of the new UNO object. The service specification for the object documents the arguments if
- An instance is a concrete, individual object specimen created on the basis of an implemented class. In UNO, it is common to ask a service manager for an instance of a service. The service manager chooses a suitable implementation and sets up an object in memory on the basis of this implementation.
- In object-oriented programming environments, the term interface is used for sets of methods that describe aspects of external object behavior in terms of method definitions. The term interface implies that the described aspects abstract from the described functionality. Thus, an interface for a functionality is completely independent of the inner workings of an object that is necessary to support functionality. Interfaces lead to exchangeable implementations, that is, code that is based on stable interfaces works across product versions, while it is relatively easy to extend or replace existing interface implementations.
- UNO interfaces have a common base interface <idl>com.sun.star.uno.XInterface</idl> that introduces basic lifetime control by reference counting, and the ability to query an object for an interface it supports.
- Input/Output. The I/O is the physical transfer of byte stream between random access memory and devices that provide data or process data.
J / K
- Reusable software component that can be visually manipulated in builder tools.
- UNO component that is set off upon an event. A job component must support the services <idl>com.sun.star.task.Job</idl> and/or <idl>com.sun.star.task.AsyncJob</idl>. Currently there are two ways to activate a job: either by triggering an event at the job executor service or by dispatching a specialized command URL of the protocol vnd.sun.star.jobs: at the dispatch framework.
Job Execution Environment
- Environment in LibreOffice for generic jobs that are implemented as UNO components. A job can be executed upon an event and use configuration data for arbitrary purposes. It is guarded by the job execution environment which takes care of the job during its lifetime and writes back configuration data after the job has finished its work.
- Localization, written L10N because of the 10 letters between the 'l' and 'n' in localization. It is the process of adapting a software to the requirements of users in a cultural community or country. For example, this includes translation of user interfaces and the necessary adaptation to the writing used in that community.
- Programming language or programming environment that is used with UNO. It is possible to access LibreOffice from component technologies, such as OLE, through programming languages.
- Listeners are objects that are set up to receive method calls when predefined events occur at other objects. They follow the observer pattern, that is, an object wants to update itself whenever it observes a change in another object registers with the object it wants to observe, and is called back when the prearranged event occurs at the observed object. The observable maintains a list of observers that want to be notified about certain events. This pattern avoids constant polling and ensures that observers are always up-to-date. Listeners in LibreOffice are specialized for the UNO environment. A listener implements a UNO listener interface with predefined call back methods. This interface is passed to the corresponding event broadcaster in an
addXXXListener()method. The broadcaster calls methods on this interface on listener-specific events. The callback methods of a listener take an object that is derived from the base event struct <idl>com.sun.star.lang.EventObject</idl>. This object contains additional information about the event that lead to the listener callback.
- A locale is a string which uniquely identifies a specific cultural community, defined by the country where a community lives, and by the language spoken. In the I18N API of LibreOffice, a locale consists of two parts encoded as
<language>_>COUNTRY>:a two-letter language code (ISO-639) and a two-letter country code (ISO-3166). Examples are en_US for American English with American date, time, measuring and currency conventions, en_UK for British English and British conventions, de_DE for German as spoken in Germany with German conventions, es_ES for Spanish as spoken in Spain, es_MX for Spanish as spoken in Mexico. Locales sometimes occur with a third variant part which is used to denote further sub-divisions and variants, such as es_ES_TRADICIONAL for Spanish with traditional collation rules, as opposed to modern collation. The variant part is user-dependent.
M / N
- Math is the embedded formula document or components of the LibreOffice application that contains the functionality necessary for embedded formulas in LibreOffice. Formula documents create mathematical formulas based on a meta description.
- The Model is an object representing document data and document manipulation methods, and is part of the frame-controller-model paradigm. See frame-controller-model paradigm.
- In UNO IDL, a module is a namespace for type definitions. The LibreOffice API is divided in 55 modules, such as awt, uno, lang, util, lang, text, sheet, drawing, presentation, chart, and sdb. The modules text, sheet drawing and presentation do not map directly to Writer, Calc, Draw and Impress documents, but the interfaces in these modules are used across all document types.
- The Model-View-Controller paradigm that is the separation of document data, presentation and user interaction into independent functional areas. The frame-controller-model paradigm in LibreOffice has been designed with MVC in mind.
- As a general term, an object in the context of this manual is an implemented class that is instantiated and has methods you can call. A UNO object is an object with the ability to be instantiated in the UNO context and to communicate with other UNO objects. For this purpose, it supports the UNO base interface <idl>com.sun.star.uno.XInterface</idl> in addition to the interfaces for the individual functionality it offers.
- In UNO, a comparison of object references must be true for all references to an identical object. This rule is called object identity.
- Object Linking and Embedding. It is a set of various technologies offering an infrastructure for object communication across language environments, and is indigenous on the Windows platform. In Inside OLE (Redmond 1995), Kraig Brockschmidt defines OLE "OLE is a unified environment of object-based services with the capability of both customizing those services and arbitrarily extending the architecture through custom services, with the overall purpose of enabling rich integration between components."
- Among others, OLE comprises compound documents, visual editing, OLE Automation, the Component Object Model and OLE controls. Moreover, the term OLE as a collective term for a number of technologies has been superseded by ActiveX, which comprises even more technologies.
- Although there are implementations for certain aspects of OLE on other platforms, Windows is the primary OLE platform. LibreOffice supports a certain aspect of OLE Automation,that is, LibreOffice is an OLE Automation server that offers the complete [PRODUCTNAME] API to Automation clients.
- The term OLE is sometimes used for document embedding techniques within LibreOffice. LibreOffice documents are embedded into each other, and appear as "OLE Objects" on draw pages. That means, they are edited in place, and act like embedded OLE documents, but the platform infrastructure for OLE is not used. Therefore, this also works on platforms other than Windows. Real OLE objects are handled differently, the embedded object is handed to the application which is registered for the embedded document and opened in an independent application window.
- Automation is the part of the OLE technology that allows developers to call methods in applications supporting OLE automation. An OLE application publishes methods to be used from other OLE enabled applications. The called application acts as server, and the caller as client in this relationship. Under Windows, a LibreOffice application object is available that offers almost the complete LibreOffice API to automation clients.
- Legacy command-line tool of the Extension Manager. See unopkg.
- Precompiled SQL statement that are parameterized and sent to a DBMS.
- UNO component that handles custom URL protocols. A URL protocol is the part of a URL that stands before the colon, as in ftp: (file transfer protocol) or http: (hypertext transfer protocol). This mechanism is used as of OpenOffice.org 1.1.0 to integrate extensions into the user interface. For example, a menu item can be configured to dispatch a command URL
vnd.company.oo.newcomponent:NewFunction. A protocol handler for the protocol
vnd.company.oo.newcomponent:could route this command to the corresponding routine
newFunction(). This technique also forms the basis for the job execution environment, where
vnd.sun.star.jobs:URLs are routed to components that support suitable job interfaces.
- See database query, query interfaces, query adapter.
- Text portion in a text document that reflects changes to a text document.
Reference Counting, Ref Counting
- Controlling the lifetime of an object by counting the number of external references to the object. A ref counted object is destroyed automatically when the number of external references drops to zero.
- Backend repository that contains information about UNO components registered with the service manager.
- Is the rejection of an open transaction. The data are restored to the state before the transaction was started. See transaction.
- Asian text layout feature, similar to superscript and subscript in western text. See www.w3.org/TR/ruby/.
- System Abstraction Layer. C++ wrappers to system-dependent functionality. UNO objects written in C++ use the types and methods of SAL to create platform-independent code.
- Sequence is a set of UNO data types accessed directly without using any interface calls. The sequence maps to arrays in most language bindings.
- A server is an object that offers services to clients. LibreOffice frequently acts as server when it is accessed through UNO, but it can also be a client to UNO components, instantiating and using UNO objects in another application. The simplest use for LibreOffice calling objects in other processes are listener callbacks. See client.
Service (UNO Service)
- A UNO service describes a UNO object by combining interfaces and properties into an abstract object specification. This definition of the term service is specific to UNO, therefore do not confuse it with the general meaning of the word service in "a server offers services to its clients".
- Factory for UNO services. A service manager supports the service <idl>com.sun.star.lang.ServiceManager</idl>, and its main task is to provide instances of UNO objects by their service name. This is done by factory methods that take a service name and optional arguments. The service manager looks in its registry database for UNO components that implement the requested service, chooses an implementation and uses a component loader to instantiate the implementation. It finally returns the interface <idl>com.sun.star.uno.XInterface</idl> of the new instance.
- Singletons specify named objects. Only one instance exists during the lifetime of a UNO component context. A singleton references one service and specifies that the only existing instance of this service is reached over the component context using the name of the singleton. If no instance of the service exists, the component context instantiates a new one.
- Is an abstract description of qualities required for a certain task. The realization of a specification is its implementation.
- Structured Query Language, pronounce SEE-KWEL. A standard language for defining databases, and for editing data in a database. SQL is used with relational database management systems.
- An object in the sdbc module of the LibreOffice API that encapsulates a static SQL statements. See prepared statement.
- The server-side process on a SQL server that executes several SQL commands in a single step, and is embedded in a server language for stored procedures with enhanced control capabilities.
- A predefined package of format settings applied to objects in LibreOffice documents.
- Database form that depends on a main form. Usually a subform is used to display selected data, matching to the current record of the subform, for example, a main form could show a company address, and a subform could list the contact persons in that company. When a user browses through the companies in the main form, the subform is constantly updated to show only the contacts in the current company. This is achieved by a parameterized query in the subform, which takes a unique key from the main form and selects multiple records that match this key.
- Scalable Vector Graphics format. A W3C specification for a language describing two-dimensional vector, and mixed vector or raster graphics in XML. See www.w3.org/TR/SVG/.
- Computer programs in single-task operating systems have a predefined course with a defined starting and ending point. Between these points, it is clear which instruction the CPU is currently executing, and that the next instruction in the program will be executed next by the CPU. On pre-emptive multi-tasking systems, the ability of modern CPUs to switch their current execution context is used to spawn sub-processes that run simultaneously with the original process. These sub-processes are called threads. In this situation, the CPU always knows which instruction it executes next, but the applications do not know if the CPU will execute their next instruction after the current instruction. Other threads might alter commonly used data. This makes it necessary to write thread-safe programs. A thread-safe program is aware that other threads might interfere with the current thread, and take precautions to shield commonly used data from other threads.
- A batch of SQL commands that are considered a unity. All commands must be executed successfully, or the data must be restored to the state before the transaction was started. When using transactions, you tell the DBMS that it should start a transaction, then issue all SQL commands you need. After all the commands have been executed, commit the transaction. If an error occurred during one of the commands, restore the previous state by telling the DBMS to roll back the transaction. Transactions can become tricky, because your process or other processes can have open transactions in which they are altering data and locking rows. Therefore, plan carefully if you want to see changes before they are committed, or ensure that the data does not change when you read them again (transaction isolation).
- Conversion of characters according to conversion rules that are valid for a cultural community, such as case conversions, conversions between Hiragana and Katagana, and Half-width and Full-width.
- The UNO interface definition language uses meta types for its type definitions are mapped to types of a real programming language. How the UNO IDL types are mapped is defined by the language binding for a target language.
- Universal Content Provider. Subystem of the UCB for one particular storage system or data source.
- Universal Content Broker. Unification layer for access to storage systems or data sources, such as file, ftp, and webDAV.
- User Interface. See GUI.
- Unicode is a standardization effort by the Unicode consortium to provide a unique number for every character, regardless of platform, program and language. See https://www.unicode.org.
- UNO Interface Definition Language. See IDL.
- Universal Network Objects. Platform-independent component technology used as a basis for LibreOffice.
- See component.
- See collection.
- See container.
- See dialog.
- See object.
- The command-line tool of the Extension Manager.
- A UNO proxy (proxy is used as a shortform) is created by a bridge and is a language object that represents a UNO object in the target language. It provides the same functionality as the original UNO object. There are two terms which further specialize a UNO proxy. The UNO interface proxy is a UNO proxy that represents exactly one interface of a UNO object, whereas a UNO object proxy represents an UNO object with all of its interfaces.
- Uniform Resource Locator. In addition to the public URL schemes, formerly, defined in RFC 1738, LibreOffice uses several URL schemes of its own, such as command URLs for the dispatch API, UNO Connection URLs for the <idl>com.sun.star.bridge.UnoUrlResolver</idl> service, private:factory URLs for the interface <idl>com.sun.star.frame.XComponentLoader</idl> and database URLs to create database connections, <idl>com.sun.star.sdbc.XDriverManager</idl>.
- Visual Component Library. Platform-independent C++ library that handles GUI elements. Part of LibreOffice.
- A view is the presentation of document data in a GUI. In the LibreOffice frame-controller-model paradigm, there are no view objects separate from controllers, but the controller contains the view it controls.
- Reference to a UNO object which has to be converted to a hard reference before it can be used. A weak reference automatically turns into a null reference when the referred object is destroyed, and it does not keep the referred object alive.
- The Writer is the LibreOffice word processor document or components of the LibreOffice application containing the functionality necessary for word processing in LibreOffice. Although there might be an swriter executable on some platforms, it does not contain the actual Writer functionality, it starts up a Writer document using soffice.exe and its dependencies.
X / Y / Z
- Prefix for UNO Interfaces.
- Extensible Markup Language. Multitude of standards developed by the W3C for the definition and the processing of structured file formats. See www.w3.org/XML/