--- /dev/null
+=======
+Modules
+=======
+
+.. toctree::
+ :maxdepth: 2
+
+ 03_module_dev_01
+ 03_module_dev_02
+ 03_module_dev_03
+ 03_module_dev_04
+ 03_module_dev_05
--- /dev/null
+Module development
+==================
+
+Module Structure
++++++++++++++++++
+
+All the modules are located in the source/addons directory. The following
+steps are necessary to create a new module:
+
+ * create a subdirectory in the source/addons directory
+ * create the import **__init__.py** file
+ * create a module description file: **__openerp__.py**
+ * create the **Python** file containing the **objects**
+ * create **.xml files** that create the data (views, menu entries, demo data, ...)
+ * optionally create **reports**, **wizards** or **workflows**.
+
+Python Module Descriptor File __init__.py
+-----------------------------------------
+
+The ``__init__.py`` file is, like any Python module, executed at the start
+of the program. It needs to import the Python files that need to be loaded.
+
+So, if you create a "module.py" file, containing the description of your
+objects, you have to write one line in __init__.py::
+
+ import module
+
+OpenERP Module Descriptor File __openerp__.py
+---------------------------------------------
+
+In the created module directory, you must add a **__openerp__.py** file.
+This file, which must be in Python format, is responsible to
+
+ 1. determine the *XML files that will be parsed* during the initialization
+ of the server, and also to
+ 2. determine the *dependencies* of the created module.
+
+This file must contain a Python dictionary with the following values:
+
+**name**
+
+ The (Plain English) name of the module.
+
+**version**
+
+ The version of the module.
+
+**description**
+
+ The module description (text).
+
+**author**
+
+ The author of the module.
+
+**website**
+
+ The website of the module.
+
+**license**
+
+ The license of the module (default:GPL-2).
+
+**depends**
+
+ List of modules on which this module depends. The base module must
+ almost always be in the dependencies because some necessary data for
+ the views, reports, ... are in the base module.
+
+**init_xml**
+
+ List of .xml files to load when the server is launched with the "--init=module"
+ argument. Filepaths must be relative to the directory where the module is.
+ OpenERP XML File Format is detailed in this section.
+
+**update_xml**
+
+ List of .xml files to load when the server is launched with the "--update=module"
+ launched. Filepaths must be relative to the directory where the module is.
+ OpenERP XML File Format is detailed in this section. The files in **update_xml**
+ concern: views, reports and wizards.
+
+**installable**
+
+ True or False. Determines if the module is installable or not.
+
+**active**
+
+ True or False (default: False). Determines the modules that are installed
+ on the database creation.
+
+**Example**
+
+Here is an example of __openerp__.py file for the product module
+
+.. code-block:: python
+
+ {
+ "name" : "Products & Pricelists",
+ "version" : "1.1",
+ "author" : "Open",
+ "category" : "Generic Modules/Inventory Control",
+ "depends" : ["base", "account"],
+ "init_xml" : [],
+ "demo_xml" : ["product_demo.xml"],
+ "update_xml" : ["product_data.xml", "product_report.xml", "product_wizard.xml",
+ "product_view.xml", "pricelist_view.xml"],
+ "installable": True,
+ "active": True
+ }
+
+The files that must be placed in init_xml are the ones that relate to the
+workflow definition, data to load at the installation of the software and
+the data for the demonstrations.
+
+
+XML Files
++++++++++
+
+XML files located in the module directory are used to modify the structure of
+the database. They are used for many purposes, among which we can cite :
+
+ * initialization and demonstration data declaration,
+ * views declaration,
+ * reports declaration,
+ * wizards declaration,
+ * workflows declaration.
+
+General structure of OpenERP XML files is more detailed in the
+:ref:`xml-serialization` section. Look here if you are interested in learning
+more about *initialization* and *demonstration data declaration* XML files. The
+following section are only related to XML specific to *actions, menu entries,
+reports, wizards* and *workflows* declaration.
+
+
+Objects
++++++++
+
+All OpenERP resources are objects: menus, actions, reports, invoices, partners, ... OpenERP is based on an object relational mapping of a database to control the information. Object names are hierarchical, as in the following examples:
+
+ * account.transfer : a money transfer
+ * account.invoice : an invoice
+ * account.invoice.line : an invoice line
+
+Generally, the first word is the name of the module: account, stock, sale.
+
+Other advantages of an ORM;
+
+ * simpler relations : invoice.partner.address[0].city
+ * objects have properties and methods: invoice.pay(3400 EUR),
+ * inheritance, high level constraints, ...
+
+It is easier to manipulate one object (example, a partner) than several tables (partner address, categories, events, ...)
+
+
+.. figure:: images/pom_3_0_3.png
+ :scale: 50
+ :align: center
+
+ *The Physical Objects Model of [OpenERP version 3.0.3]*
+
+
+PostgreSQL and ORM
+------------------
+
+The ORM of OpenERP is constructed over PostgreSQL. It is thus possible to
+query the object used by OpenERP using the object interface or by directly
+using SQL statements.
+
+But it is dangerous to write or read directly in the PostgreSQL database, as
+you will shortcut important steps like constraints checking or workflow
+modification.
+
+.. note::
+
+ The Physical Database Model of OpenERP
+
+Pre-Installed Data
+------------------
+
+Data can be inserted or updated into the PostgreSQL tables corresponding to the
+OpenERP objects using XML files. The general structure of an OpenERP XML file
+is as follows:
+
+.. code-block:: xml
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ <record model="model.name_1" id="id_name_1">
+ <field name="field1">
+ "field1 content"
+ </field>
+ <field name="field2">
+ "field2 content"
+ </field>
+ (...)
+ </record>
+ <record model="model.name_2" id="id_name_2">
+ (...)
+ </record>
+ (...)
+ </data>
+ </openerp>
+
+Fields content are strings that must be encoded as *UTF-8* in XML files.
+
+Let's review an example taken from the OpenERP source (base_demo.xml in the base module):
+
+.. code-block:: xml
+
+ <record model="res.company" id="main_company">
+ <field name="name">Tiny sprl</field>
+ <field name="partner_id" ref="main_partner"/>
+ <field name="currency_id" ref="EUR"/>
+ </record>
+
+.. code-block:: xml
+
+ <record model="res.users" id="user_admin">
+ <field name="login">admin</field>
+ <field name="password">admin</field>
+ <field name="name">Administrator</field>
+ <field name="signature">Administrator</field>
+ <field name="action_id" ref="action_menu_admin"/>
+ <field name="menu_id" ref="action_menu_admin"/>
+ <field name="address_id" ref="main_address"/>
+ <field name="groups_id" eval="[(6,0,[group_admin])]"/>
+ <field name="company_id" ref="main_company"/>
+ </record>
+
+This last record defines the admin user :
+
+ * The fields login, password, etc are straightforward.
+ * The ref attribute allows to fill relations between the records :
+
+.. code-block:: xml
+
+ <field name="company_id" ref="main_company"/>
+
+The field **company_id** is a many-to-one relation from the user object to the company object, and **main_company** is the id of to associate.
+
+ * The **eval** attribute allows to put some python code in the xml: here the groups_id field is a many2many. For such a field, "[(6,0,[group_admin])]" means : Remove all the groups associated with the current user and use the list [group_admin] as the new associated groups (and group_admin is the id of another record).
+
+ * The **search** attribute allows to find the record to associate when you do not know its xml id. You can thus specify a search criteria to find the wanted record. The criteria is a list of tuples of the same form than for the predefined search method. If there are several results, an arbitrary one will be chosen (the first one):
+
+.. code-block:: xml
+
+ <field name="partner_id" search="[]" model="res.partner"/>
+
+This is a classical example of the use of **search** in demo data: here we do not really care about which partner we want to use for the test, so we give an empty list. Notice the **model** attribute is currently mandatory.
+
+Record Tag
+//////////
+
+**Description**
+
+The addition of new data is made with the record tag. This one takes a mandatory attribute : model. Model is the object name where the insertion has to be done. The tag record can also take an optional attribute: id. If this attribute is given, a variable of this name can be used later on, in the same file, to make reference to the newly created resource ID.
+
+A record tag may contain field tags. They indicate the record's fields value. If a field is not specified the default value will be used.
+
+**Example**
+
+.. code-block:: xml
+
+ <record model="ir.actions.report.xml" id="l0">
+ <field name="model">account.invoice</field>
+ <field name="name">Invoices List</field>
+ <field name="report_name">account.invoice.list</field>
+ <field name="report_xsl">account/report/invoice.xsl</field>
+ <field name="report_xml">account/report/invoice.xml</field>
+ </record>
+
+Field tag
+/////////
+
+The attributes for the field tag are the following:
+
+name : mandatory
+ the field name
+
+eval : optional
+ python expression that indicating the value to add
+
+ref
+ reference to an id defined in this file
+
+model
+ model to be looked up in the search
+
+search
+ a query
+
+Function tag
+////////////
+
+A function tag can contain other function tags.
+
+model : mandatory
+ The model to be used
+
+name : mandatory
+ the function given name
+
+eval
+ should evaluate to the list of parameters of the method to be called, excluding cr and uid
+
+**Example**
+
+.. code-block:: xml
+
+ <function model="ir.ui.menu" name="search" eval="[[('name','=','Operations')]]"/>
+
+Getitem tag
+///////////
+
+Takes a subset of the evaluation of the last child node of the tag.
+
+type : mandatory
+ int or list
+
+index : mandatory
+ int or string (a key of a dictionary)
+
+**Example**
+
+Evaluates to the first element of the list of ids returned by the function node
+
+.. code-block:: xml
+
+ <getitem index="0" type="list">
+ <function model="ir.ui.menu" name="search" eval="[[('name','=','Operations')]]"/>
+ </getitem>
+
+i18n
+""""
+
+Improving Translations
+//////////////////////
+
+.. describe:: Translating in launchpad
+
+Translations are managed by
+the `Launchpad Web interface <https://translations.launchpad.net/openobject>`_. Here, you'll
+find the list of translatable projects.
+
+Please read the `FAQ <https://answers.launchpad.net/rosetta/+faqs>`_ before asking questions.
+
+.. describe:: Translating your own module
+
+.. versionchanged:: 5.0
+
+Contrary to the 4.2.x version, the translations are now done by module. So,
+instead of an unique ``i18n`` folder for the whole application, each module has
+its own ``i18n`` folder. In addition, OpenERP can now deal with ``.po`` [#f_po]_
+files as import/export format. The translation files of the installed languages
+are automatically loaded when installing or updating a module. OpenERP can also
+generate a .tgz archive containing well organised ``.po`` files for each selected
+module.
+
+.. [#f_po] http://www.gnu.org/software/autoconf/manual/gettext/PO-Files.html#PO-Files
+
+Process
+"""""""
+
+Defining the process
+////////////////////
+
+Through the interface and module recorder.
+Then, put the generated XML in your own module.
+
+Views
+"""""
+
+Technical Specifications - Architecture - Views
+///////////////////////////////////////////////
+
+Views are a way to represent the objects on the client side. They indicate to the client how to lay out the data coming from the objects on the screen.
+
+There are two types of views:
+
+ * form views
+ * tree views
+
+Lists are simply a particular case of tree views.
+
+A same object may have several views: the first defined view of a kind (*tree, form*, ...) will be used as the default view for this kind. That way you can have a default tree view (that will act as the view of a one2many) and a specialized view with more or less information that will appear when one double-clicks on a menu item. For example, the products have several views according to the product variants.
+
+Views are described in XML.
+
+If no view has been defined for an object, the object is able to generate a view to represent itself. This can limit the developer's work but results in less ergonomic views.
+
+
+Usage example
+/////////////
+
+When you open an invoice, here is the chain of operations followed by the client:
+
+ * An action asks to open the invoice (it gives the object's data (account.invoice), the view, the domain (e.g. only unpaid invoices) ).
+ * The client asks (with XML-RPC) to the server what views are defined for the invoice object and what are the data it must show.
+ * The client displays the form according to the view
+
+.. figure:: images/arch_view_use.png
+ :scale: 50
+ :align: center
+
+To develop new objects
+//////////////////////
+
+The design of new objects is restricted to the minimum: create the objects and optionally create the views to represent them. The PostgreSQL tables do not have to be written by hand because the objects are able to automatically create them (or adapt them in case they already exist).
+
+Reports
+"""""""
+
+OpenERP uses a flexible and powerful reporting system. Reports are generated either in PDF or in HTML. Reports are designed on the principle of separation between the data layer and the presentation layer.
+
+Reports are described more in details in the `Reporting <http://openobject.com/wiki/index.php/Developers:Developper%27s_Book/Reports>`_ chapter.
+
+Wizards
+"""""""
+
+Here's an example of a .XML file that declares a wizard.
+
+.. code-block:: xml
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ <wizard string="Employee Info"
+ model="hr.employee"
+ name="employee.info.wizard"
+ id="wizard_employee_info"/>
+ </data>
+ </openerp>
+
+A wizard is declared using a wizard tag. See "Add A New Wizard" for more information about wizard XML.
+
+also you can add wizard in menu using following xml entry
+
+.. code-block:: xml
+
+ <?xml version="1.0"?>
+ </openerp>
+ <data>
+ <wizard string="Employee Info"
+ model="hr.employee"
+ name="employee.info.wizard"
+ id="wizard_employee_info"/>
+ <menuitem
+ name="Human Resource/Employee Info"
+ action="wizard_employee_info"
+ type="wizard"
+ id="menu_wizard_employee_info"/>
+ </data>
+ </openerp>
+
+Workflow
+""""""""
+
+The objects and the views allow you to define new forms very simply, lists/trees and interactions between them. But that is not enough, you must define the dynamics of these objects.
+
+A few examples:
+
+ * a confirmed sale order must generate an invoice, according to certain conditions
+ * a paid invoice must, only under certain conditions, start the shipping order
+
+The workflows describe these interactions with graphs. One or several workflows may be associated to the objects. Workflows are not mandatory; some objects don't have workflows.
+
+Below is an example workflow used for sale orders. It must generate invoices and shipments according to certain conditions.
+
+.. figure:: images/arch_workflow_sale.png
+ :scale: 85
+ :align: center
+
+
+In this graph, the nodes represent the actions to be done:
+
+ * create an invoice,
+ * cancel the sale order,
+ * generate the shipping order, ...
+
+The arrows are the conditions;
+
+ * waiting for the order validation,
+ * invoice paid,
+ * click on the cancel button, ...
+
+The squared nodes represent other Workflows;
+
+ * the invoice
+ * the shipping
+
+
+Profile Module
+++++++++++++++
+
+The purpose of a profile is to initialize OpenERP with a set of modules directly after the database has been created. A profile is a special kind of module that contains no code, only *dependencies on other modules*.
+
+In order to create a profile, you only have to create a new directory in server/addons (you *should* call this folder profile_modulename), in which you put an *empty* __init__.py file (as every directory Python imports must contain an __init__.py file), and a __openerp__.py whose structure is as follows :
+
+.. code-block:: python
+
+ {
+ "name":"''Name of the Profile'',
+ "version":"''Version String''",
+ "author":"''Author Name''",
+ "category":"Profile",
+ "depends":[''List of the modules to install with the profile''],
+ "demo_xml":[],
+ "update_xml":[],
+ "active":False,
+ "installable":True,
+ }
+
+Here's the code of the file source/addons/profile_tools/__openerp__.py,
+which corresponds to the tools profile in OpenERP.
+
+.. code-block:: python
+
+ {
+ "name" : "Miscellaneous Tools",
+ "version" : "1.0",
+ "depends" : ["base", "base_setup"],
+ "author" : "OpenERP SA",
+ "category" : "Hidden/Dependency",
+ 'complexity': "easy",
+ "description": """
+ Installer for extra Hidden like lunch, survey, idea, share, etc.
+ ================================================================
+
+ Makes the Extra Hidden Configuration available from where you can install
+ modules like share, lunch, pad, idea, survey and subscription.
+ """,
+ 'website': 'http://www.openerp.com',
+ 'init_xml': [],
+ 'update_xml': [
+ ],
+ 'demo_xml': [],
+ 'installable': True,
+ 'auto_install': False,
+ 'certificate' : '00557100228403879621',
+ 'images': ['images/config_extra_Hidden.jpeg'],
+ }
+
+
+
+
+
+Action creation
+---------------
+
+Linking events to action
+++++++++++++++++++++++++
+
+The available type of events are:
+
+ * **client_print_multi** (print from a list or form)
+ * **client_action_multi** (action from a list or form)
+ * **tree_but_open** (double click on the item of a tree, like the menu)
+ * **tree_but_action** (action on the items of a tree)
+
+To map an events to an action:
+
+.. code-block:: xml
+
+ <record model="ir.values" id="ir_open_journal_period">
+ <field name="key2">tree_but_open</field>
+ <field name="model">account.journal.period</field>
+ <field name="name">Open Journal</field>
+ <field name="value" eval="'ir.actions.wizard,%d'%action_move_journal_line_form_select"/>
+ <field name="object" eval="True"/>
+ </record>
+
+If you double click on a journal/period (object: account.journal.period), this will open the selected wizard. (id="action_move_journal_line_form_select").
+
+You can use a res_id field to allow this action only if the user click on a specific object.
+
+.. code-block:: xml
+
+ <record model="ir.values" id="ir_open_journal_period">
+ <field name="key2">tree_but_open</field>
+ <field name="model">account.journal.period</field>
+ <field name="name">Open Journal</field>
+ <field name="value" eval="'ir.actions.wizard,%d'%action_move_journal_line_form_select"/>
+ <field name="res_id" eval="3"/>
+ <field name="object" eval="True"/>
+ </record>
+
+The action will be triggered if the user clicks on the account.journal.period n°3.
+
+When you declare wizard, report or menus, the ir.values creation is automatically made with these tags:
+
+ * <wizard... />
+ * <menuitem... />
+ * <report... />
+
+So you usually do not need to add the mapping by yourself.
--- /dev/null
+Objects, Fields and Methods
+===========================
+
+OpenERP Objects
+---------------
+
+.. This chapter is dedicated to detailed objects definition:
+ all fields
+ all objects
+ inheritancies
+
+All the ERP's pieces of data are accessible through "objects". As an example, there is a res.partner object to access the data concerning the partners, an account.invoice object for the data concerning the invoices, etc...
+
+Please note that there is an object for every type of resource, and not an
+object per resource. We have thus a res.partner object to manage all the
+partners and not a *res.partner* object per partner. If we talk in "object
+oriented" terms, we could also say that there is an object per level.
+
+The direct consequences is that all the methods of objects have a common parameter: the "ids" parameter. This specifies on which resources (for example, on which partner) the method must be applied. Precisely, this parameter contains a list of resource ids on which the method must be applied.
+
+For example, if we have two partners with the identifiers 1 and 5, and we want to call the res_partner method "send_email", we will write something like::
+
+ res_partner.send_email(... , [1, 5], ...)
+
+We will see the exact syntax of object method calls further in this document.
+
+In the following section, we will see how to define a new object. Then, we will check out the different methods of doing this.
+
+For developers:
+
+* OpenERP "objects" are usually called classes in object oriented programming.
+* A OpenERP "resource" is usually called an object in OO programming, instance of a class.
+
+It's a bit confusing when you try to program inside OpenERP, because the language used is Python, and Python is a fully object oriented language, and has objects and instances ...
+
+Luckily, an OpenERP "resource" can be converted magically into a nice Python object using the "browse" class method (OpenERP object method).
+
+
+The ORM - Object-relational mapping - Models
+--------------------------------------------
+
+The ORM, short for Object-Relational Mapping, is a central part of OpenERP.
+
+In OpenERP, the data model is described and manipulated through Python classes
+and objects. It is the ORM job to bridge the gap -- as transparently as
+possible for the developer -- between Python and the underlying relational
+database (PostgreSQL), which will provide the persistence we need for our
+objects.
+
+
+OpenERP Object Attributes
+-------------------------
+
+Objects Introduction
+++++++++++++++++++++
+
+To define a new object, you must define a new Python class then instantiate it. This class must inherit from the osv class in the osv module.
+
+Object definition
++++++++++++++++++
+
+The first line of the object definition will always be of the form::
+
+ class name_of_the_object(osv.osv):
+ _name = 'name.of.the.object'
+ _columns = { ... }
+ ...
+ name_of_the_object()
+
+An object is defined by declaring some fields with predefined names in the
+class. Two of them are required (_name and _columns), the rest are optional.
+The predefined fields are:
+
+Predefined fields
++++++++++++++++++
+
+`_auto`
+ Determines whether a corresponding PostgreSQL table must be generated
+ automatically from the object. Setting _auto to False can be useful in case
+ of OpenERP objects generated from PostgreSQL views. See the "Reporting From
+ PostgreSQL Views" section for more details.
+
+`_columns (required)`
+ The object fields. See the :ref:`fields <fields-link>` section for further details.
+
+`_constraints`
+ The constraints on the object. See the constraints section for details.
+
+`_sql_constraints`
+ The SQL Constraint on the object. See the SQL constraints section for further details.
+
+`_defaults`
+ The default values for some of the object's fields. See the default value section for details.
+
+`_inherit`
+ The name of the osv object which the current object inherits from. See the :ref:`object inheritance section<inherit-link>`
+ (first form) for further details.
+
+`_inherits`
+ The list of osv objects the object inherits from. This list must be given in
+ a python dictionary of the form: {'name_of_the_parent_object':
+ 'name_of_the_field', ...}. See the :ref:`object inheritance section<inherits-link>`
+ (second form) for further details. Default value: {}.
+
+`_log_access`
+ Determines whether or not the write access to the resource must be logged.
+ If true, four fields will be created in the SQL table: create_uid,
+ create_date, write_uid, write_date. Those fields represent respectively the
+ id of the user who created the record, the creation date of record, the id
+ of the user who last modified the record, and the date of that last
+ modification. This data may be obtained by using the perm_read method.
+
+`_name (required)`
+ Name of the object. Default value: None.
+
+`_order`
+ Name of the fields used to sort the results of the search and read methods.
+
+ Default value: 'id'.
+
+ Examples::
+
+ _order = "name"
+ _order = "date_order desc"
+
+`_rec_name`
+ Name of the field in which the name of every resource is stored. Default
+ value: 'name'. Note: by default, the name_get method simply returns the
+ content of this field.
+
+`_sequence`
+ Name of the SQL sequence that manages the ids for this object. Default value: None.
+
+`_sql`
+ SQL code executed upon creation of the object (only if _auto is True). It means this code gets executed after the table is created.
+
+`_table`
+ Name of the SQL table. Default value: the value of the _name field above
+ with the dots ( . ) replaced by underscores ( _ ).
+
+
+.. _inherit-link:
+
+Object Inheritance - _inherit
+-----------------------------
+
+Introduction
+++++++++++++
+
+Objects may be inherited in some custom or specific modules. It is better to
+inherit an object to add/modify some fields.
+
+It is done with::
+
+ _inherit='object.name'
+
+Extension of an object
+++++++++++++++++++++++
+
+There are two possible ways to do this kind of inheritance. Both ways result in
+a new class of data, which holds parent fields and behaviour as well as
+additional fields and behaviour, but they differ in heavy programatical
+consequences.
+
+While Example 1 creates a new subclass "custom_material" that may be "seen" or
+"used" by any view or tree which handles "network.material", this will not be
+the case for Example 2.
+
+This is due to the table (other.material) the new subclass is operating on,
+which will never be recognized by previous "network.material" views or trees.
+
+Example 1::
+
+ class custom_material(osv.osv):
+ _name = 'network.material'
+ _inherit = 'network.material'
+ _columns = {
+ 'manuf_warranty': fields.boolean('Manufacturer warranty?'),
+ }
+ _defaults = {
+ 'manuf_warranty': lambda *a: False,
+ }
+ custom_material()
+
+.. tip:: Notice
+
+ _name == _inherit
+
+In this example, the 'custom_material' will add a new field 'manuf_warranty' to
+the object 'network.material'. New instances of this class will be visible by
+views or trees operating on the superclasses table 'network.material'.
+
+This inheritancy is usually called "class inheritance" in Object oriented
+design. The child inherits data (fields) and behavior (functions) of his
+parent.
+
+
+Example 2::
+
+ class other_material(osv.osv):
+ _name = 'other.material'
+ _inherit = 'network.material'
+ _columns = {
+ 'manuf_warranty': fields.boolean('Manufacturer warranty?'),
+ }
+ _defaults = {
+ 'manuf_warranty': lambda *a: False,
+ }
+ other_material()
+
+.. tip:: Notice
+
+ _name != _inherit
+
+In this example, the 'other_material' will hold all fields specified by
+'network.material' and it will additionally hold a new field 'manuf_warranty'.
+All those fields will be part of the table 'other.material'. New instances of
+this class will therefore never been seen by views or trees operating on the
+superclasses table 'network.material'.
+
+This type of inheritancy is known as "inheritance by prototyping" (e.g.
+Javascript), because the newly created subclass "copies" all fields from the
+specified superclass (prototype). The child inherits data (fields) and behavior
+(functions) of his parent.
+
+
+.. _inherits-link:
+
+Inheritance by Delegation - _inherits
+-------------------------------------
+
+ **Syntax :**::
+
+ class tiny_object(osv.osv)
+ _name = 'tiny.object'
+ _table = 'tiny_object'
+ _inherits = {
+ 'tiny.object_a': 'object_a_id',
+ 'tiny.object_b': 'object_b_id',
+ ... ,
+ 'tiny.object_n': 'object_n_id'
+ }
+ (...)
+
+The object 'tiny.object' inherits from all the columns and all the methods from
+the n objects 'tiny.object_a', ..., 'tiny.object_n'.
+
+To inherit from multiple tables, the technique consists in adding one column to
+the table tiny_object per inherited object. This column will store a foreign
+key (an id from another table). The values *'object_a_id' 'object_b_id' ...
+'object_n_id'* are of type string and determine the title of the columns in
+which the foreign keys from 'tiny.object_a', ..., 'tiny.object_n' are stored.
+
+This inheritance mechanism is usually called " *instance inheritance* " or "
+*value inheritance* ". A resource (instance) has the VALUES of its parents.
+
+
+.. _fields-link:
+
+Fields Introduction
+-------------------
+
+Objects may contain different types of fields. Those types can be divided into
+three categories: simple types, relation types and functional fields. The
+simple types are integers, floats, booleans, strings, etc ... ; the relation
+types are used to represent relations between objects (one2one, one2many,
+many2one). Functional fields are special fields because they are not stored in
+the database but calculated in real time given other fields of the view.
+
+Here's the header of the initialization method of the class any field defined
+in OpenERP inherits (as you can see in server/bin/osv/fields.py)::
+
+ def __init__(self, string='unknown', required=False, readonly=False,
+ domain=None, context="", states=None, priority=0, change_default=False, size=None,
+ ondelete="set null", translate=False, select=False, **args) :
+
+There are a common set of optional parameters that are available to most field
+types:
+
+:change_default:
+ Whether or not the user can define default values on other fields depending
+ on the value of this field. Those default values need to be defined in
+ the ir.values table.
+:help:
+ A description of how the field should be used: longer and more descriptive
+ than `string`. It will appear in a tooltip when the mouse hovers over the
+ field.
+:ondelete:
+ How to handle deletions in a related record. Allowable values are:
+ 'restrict', 'no action', 'cascade', 'set null', and 'set default'.
+:priority: Not used?
+:readonly: `True` if the user cannot edit this field, otherwise `False`.
+:required:
+ `True` if this field must have a value before the object can be saved,
+ otherwise `False`.
+:size: The size of the field in the database: number characters or digits.
+:states:
+ Lets you override other parameters for specific states of this object.
+ Accepts a dictionary with the state names as keys and a list of name/value
+ tuples as the values. For example: `states={'posted':[('readonly',True)]}`
+:string:
+ The field name as it should appear in a label or column header. Strings
+ containing non-ASCII characters must use python unicode objects.
+ For example: `'tested': fields.boolean(u'Testé')`
+:translate:
+ `True` if the *content* of this field should be translated, otherwise
+ `False`.
+
+There are also some optional parameters that are specific to some field types:
+
+:context:
+ Define a variable's value visible in the view's context or an on-change
+ function. Used when searching child table of `one2many` relationship?
+:domain:
+ Domain restriction on a relational field.
+
+ Default value: [].
+
+ Example: domain=[('field','=',value)])
+:invisible: Hide the field's value in forms. For example, a password.
+:on_change:
+ Default value for the `on_change` attribute in the view. This will launch
+ a function on the server when the field changes in the client. For example,
+ `on_change="onchange_shop_id(shop_id)"`.
+:relation:
+ Used when a field is an id reference to another table. This is the name of
+ the table to look in. Most commonly used with related and function field
+ types.
+:select:
+ Default value for the `select` attribute in the view. 1 means basic search,
+ and 2 means advanced search.
+
+
+Type of Fields
+--------------
+
+Basic Types
++++++++++++
+
+:boolean:
+
+ A boolean (true, false).
+
+ Syntax::
+
+ fields.boolean('Field Name' [, Optional Parameters]),
+
+:integer:
+
+ An integer.
+
+ Syntax::
+
+ fields.integer('Field Name' [, Optional Parameters]),
+
+:float:
+
+ A floating point number.
+
+ Syntax::
+
+ fields.float('Field Name' [, Optional Parameters]),
+
+ .. note::
+
+ The optional parameter digits defines the precision and scale of the
+ number. The scale being the number of digits after the decimal point
+ whereas the precision is the total number of significant digits in the
+ number (before and after the decimal point). If the parameter digits is
+ not present, the number will be a double precision floating point number.
+ Warning: these floating-point numbers are inexact (not any value can be
+ converted to its binary representation) and this can lead to rounding
+ errors. You should always use the digits parameter for monetary amounts.
+
+ Example::
+
+ 'rate': fields.float(
+ 'Relative Change rate',
+ digits=(12,6) [,
+ Optional Parameters]),
+
+:char:
+
+ A string of limited length. The required size parameter determines its size.
+
+ Syntax::
+
+ fields.char(
+ 'Field Name',
+ size=n [,
+ Optional Parameters]), # where ''n'' is an integer.
+
+ Example::
+
+ 'city' : fields.char('City Name', size=30, required=True),
+
+:text:
+
+ A text field with no limit in length.
+
+ Syntax::
+
+ fields.text('Field Name' [, Optional Parameters]),
+
+:date:
+
+ A date.
+
+ Syntax::
+
+ fields.date('Field Name' [, Optional Parameters]),
+
+:datetime:
+
+ Allows to store a date and the time of day in the same field.
+
+ Syntax::
+
+ fields.datetime('Field Name' [, Optional Parameters]),
+
+:binary:
+
+ A binary chain
+
+:selection:
+
+ A field which allows the user to make a selection between various predefined values.
+
+ Syntax::
+
+ fields.selection((('n','Unconfirmed'), ('c','Confirmed')),
+ 'Field Name' [, Optional Parameters]),
+
+ .. note::
+
+ Format of the selection parameter: tuple of tuples of strings of the form::
+
+ (('key_or_value', 'string_to_display'), ... )
+
+ .. note::
+ You can specify a function that will return the tuple. Example ::
+
+ def _get_selection(self, cursor, user_id, context=None):
+ return (
+ ('choice1', 'This is the choice 1'),
+ ('choice2', 'This is the choice 2'))
+
+ _columns = {
+ 'sel' : fields.selection(
+ _get_selection,
+ 'What do you want ?')
+ }
+
+ *Example*
+
+ Using relation fields **many2one** with **selection**. In fields definitions add::
+
+ ...,
+ 'my_field': fields.many2one(
+ 'mymodule.relation.model',
+ 'Title',
+ selection=_sel_func),
+ ...,
+
+ And then define the _sel_func like this (but before the fields definitions)::
+
+ def _sel_func(self, cr, uid, context=None):
+ obj = self.pool.get('mymodule.relation.model')
+ ids = obj.search(cr, uid, [])
+ res = obj.read(cr, uid, ids, ['name', 'id'], context)
+ res = [(r['id'], r['name']) for r in res]
+ return res
+
+Relational Types
+++++++++++++++++
+
+:one2one:
+
+ A one2one field expresses a one:to:one relation between two objects. It is
+ deprecated. Use many2one instead.
+
+ Syntax::
+
+ fields.one2one('other.object.name', 'Field Name')
+
+:many2one:
+
+ Associates this object to a parent object via this Field. For example
+ Department an Employee belongs to would Many to one. i.e Many employees will
+ belong to a Department
+
+ Syntax::
+
+ fields.many2one(
+ 'other.object.name',
+ 'Field Name',
+ optional parameters)
+
+ Optional parameters:
+
+ - ondelete: What should happen when the resource this field points to is deleted.
+ + Predefined value: "cascade", "set null", "restrict", "no action", "set default"
+ + Default value: "set null"
+ - required: True
+ - readonly: True
+ - select: True - (creates an index on the Foreign Key field)
+
+ *Example* ::
+
+ 'commercial': fields.many2one(
+ 'res.users',
+ 'Commercial',
+ ondelete='cascade'),
+
+:one2many:
+
+ TODO
+
+ Syntax::
+
+ fields.one2many(
+ 'other.object.name',
+ 'Field relation id',
+ 'Fieldname',
+ optional parameter)
+
+ Optional parameters:
+ - invisible: True/False
+ - states: ?
+ - readonly: True/False
+
+ *Example* ::
+
+ 'address': fields.one2many(
+ 'res.partner.address',
+ 'partner_id',
+ 'Contacts'),
+
+:many2many:
+
+ TODO
+
+ Syntax::
+
+ fields.many2many('other.object.name',
+ 'relation object',
+ 'actual.object.id',
+ 'other.object.id',
+ 'Field Name')
+
+ Where:
+ - other.object.name is the other object which belongs to the relation
+ - relation object is the table that makes the link
+ - actual.object.id and other.object.id are the fields' names used in the relation table
+
+ Example::
+
+ 'category_ids':
+ fields.many2many(
+ 'res.partner.category',
+ 'res_partner_category_rel',
+ 'partner_id',
+ 'category_id',
+ 'Categories'),
+
+ To make it bidirectional (= create a field in the other object)::
+
+ class other_object_name2(osv.osv):
+ _inherit = 'other.object.name'
+ _columns = {
+ 'other_fields': fields.many2many(
+ 'actual.object.name',
+ 'relation object',
+ 'actual.object.id',
+ 'other.object.id',
+ 'Other Field Name'),
+ }
+ other_object_name2()
+
+ Example::
+
+ class res_partner_category2(osv.osv):
+ _inherit = 'res.partner.category'
+ _columns = {
+ 'partner_ids': fields.many2many(
+ 'res.partner',
+ 'res_partner_category_rel',
+ 'category_id',
+ 'partner_id',
+ 'Partners'),
+ }
+ res_partner_category2()
+
+:related:
+
+ Sometimes you need to refer to the relation of a relation. For example,
+ supposing you have objects: City -> State -> Country, and you need to refer to
+ the Country from a City, you can define a field as below in the City object::
+
+ 'country_id': fields.related(
+ 'state_id',
+ 'country_id',
+ type="many2one",
+ relation="res.country",
+ string="Country",
+ store=False)
+
+ Where:
+ - The first set of parameters are the chain of reference fields to
+ follow, with the desired field at the end.
+ - :guilabel:`type` is the type of that desired field.
+ - Use :guilabel:`relation` if the desired field is still some kind of
+ reference. :guilabel:`relation` is the table to look up that
+ reference in.
+
+
+Functional Fields
++++++++++++++++++
+
+A functional field is a field whose value is calculated by a function (rather
+than being stored in the database).
+
+**Parameters:** ::
+
+ fnct, arg=None, fnct_inv=None, fnct_inv_arg=None, type="float",
+ fnct_search=None, obj=None, method=False, store=False, multi=False
+
+where
+
+ * :guilabel:`fnct` is the function or method that will compute the field
+ value. It must have been declared before declaring the functional field.
+ * :guilabel:`fnct_inv` is the function or method that will allow writing
+ values in that field.
+ * :guilabel:`type` is the field type name returned by the function. It can
+ be any field type name except function.
+ * :guilabel:`fnct_search` allows you to define the searching behaviour on
+ that field.
+ * :guilabel:`method` whether the field is computed by a method (of an
+ object) or a global function
+ * :guilabel:`store` If you want to store field in database or not. Default
+ is False.
+ * :guilabel:`multi` is a group name. All fields with the same `multi`
+ parameter will be calculated in a single function call.
+
+fnct parameter
+""""""""""""""
+If *method* is True, the signature of the method must be::
+
+ def fnct(self, cr, uid, ids, field_name, arg, context):
+
+otherwise (if it is a global function), its signature must be::
+
+ def fnct(cr, table, ids, field_name, arg, context):
+
+Either way, it must return a dictionary of values of the form
+**{id'_1_': value'_1_', id'_2_': value'_2_',...}.**
+
+The values of the returned dictionary must be of the type specified by the type
+argument in the field declaration.
+
+If *multi* is set, then *field_name* is replaced by *field_names*: a list
+of the field names that should be calculated. Each value in the returned
+dictionary is also a dictionary from field name to value. For example, if the
+fields `'name'`, and `'age'` are both based on the `vital_statistics` function,
+then the return value of `vital_statistics` might look like this when `ids` is
+`[1, 2, 5]`::
+
+ {
+ 1: {'name': 'Bob', 'age': 23},
+ 2: {'name': 'Sally', 'age', 19},
+ 5: {'name': 'Ed', 'age': 62}
+ }
+
+fnct_inv parameter
+""""""""""""""""""
+If *method* is true, the signature of the method must be::
+
+ def fnct(self, cr, uid, ids, field_name, field_value, arg, context):
+
+
+otherwise (if it is a global function), it should be::
+
+ def fnct(cr, table, ids, field_name, field_value, arg, context):
+
+fnct_search parameter
+"""""""""""""""""""""
+If method is true, the signature of the method must be::
+
+ def fnct(self, cr, uid, obj, name, args, context):
+
+otherwise (if it is a global function), it should be::
+
+ def fnct(cr, uid, obj, name, args, context):
+
+The return value is a list containing 3-part tuples which are used in search function::
+
+ return [('id','in',[1,3,5])]
+
+*obj* is the same as *self*, and *name* receives the field name. *args* is a list
+of 3-part tuples containing search criteria for this field, although the search
+function may be called separately for each tuple.
+
+Example
+"""""""
+Suppose we create a contract object which is :
+
+.. code-block:: python
+
+ class hr_contract(osv.osv):
+ _name = 'hr.contract'
+ _description = 'Contract'
+ _columns = {
+ 'name' : fields.char('Contract Name', size=30, required=True),
+ 'employee_id' : fields.many2one('hr.employee', 'Employee', required=True),
+ 'function' : fields.many2one('res.partner.function', 'Function'),
+ }
+ hr_contract()
+
+If we want to add a field that retrieves the function of an employee by looking its current contract, we use a functional field. The object hr_employee is inherited this way:
+
+.. code-block:: python
+
+ class hr_employee(osv.osv):
+ _name = "hr.employee"
+ _description = "Employee"
+ _inherit = "hr.employee"
+ _columns = {
+ 'contract_ids' : fields.one2many('hr.contract', 'employee_id', 'Contracts'),
+ 'function' : fields.function(
+ _get_cur_function_id,
+ type='many2one',
+ obj="res.partner.function",
+ method=True,
+ string='Contract Function'),
+ }
+ hr_employee()
+
+.. note:: three points
+
+ * :guilabel:`type` ='many2one' is because the function field must create
+ a many2one field; function is declared as a many2one in hr_contract also.
+ * :guilabel:`obj` ="res.partner.function" is used to specify that the
+ object to use for the many2one field is res.partner.function.
+ * We called our method :guilabel:`_get_cur_function_id` because its role
+ is to return a dictionary whose keys are ids of employees, and whose
+ corresponding values are ids of the function of those employees. The
+ code of this method is:
+
+.. code-block:: python
+
+ def _get_cur_function_id(self, cr, uid, ids, field_name, arg, context):
+ for i in ids:
+ #get the id of the current function of the employee of identifier "i"
+ sql_req= """
+ SELECT f.id AS func_id
+ FROM hr_contract c
+ LEFT JOIN res_partner_function f ON (f.id = c.function)
+ WHERE
+ (c.employee_id = %d)
+ """ % (i,)
+
+ cr.execute(sql_req)
+ sql_res = cr.dictfetchone()
+
+ if sql_res: #The employee has one associated contract
+ res[i] = sql_res['func_id']
+ else:
+ #res[i] must be set to False and not to None because of XML:RPC
+ # "cannot marshal None unless allow_none is enabled"
+ res[i] = False
+ return res
+
+The id of the function is retrieved using a SQL query. Note that if the query
+returns no result, the value of sql_res['func_id'] will be None. We force the
+False value in this case value because XML:RPC (communication between the server
+and the client) doesn't allow to transmit this value.
+
+store Parameter
+"""""""""""""""
+It will calculate the field and store the result in the table. The field will be
+recalculated when certain fields are changed on other objects. It uses the
+following syntax:
+
+.. code-block:: python
+
+ store = {
+ 'object_name': (
+ function_name,
+ ['field_name1', 'field_name2'],
+ priority)
+ }
+
+It will call function function_name when any changes are written to fields in the
+list ['field1','field2'] on object 'object_name'. The function should have the
+following signature::
+
+ def function_name(self, cr, uid, ids, context=None):
+
+Where `ids` will be the ids of records in the other object's table that have
+changed values in the watched fields. The function should return a list of ids
+of records in its own table that should have the field recalculated. That list
+will be sent as a parameter for the main function of the field.
+
+Here's an example from the membership module:
+
+.. code-block:: python
+
+ 'membership_state':
+ fields.function(
+ _membership_state,
+ method=True,
+ string='Current membership state',
+ type='selection',
+ selection=STATE,
+ store={
+ 'account.invoice': (_get_invoice_partner, ['state'], 10),
+ 'membership.membership_line': (_get_partner_id,['state'], 10),
+ 'res.partner': (
+ lambda self, cr, uid, ids, c={}: ids,
+ ['free_member'],
+ 10)
+ }),
+
+Property Fields
++++++++++++++++
+
+.. describe:: Declaring a property
+
+A property is a special field: fields.property.
+
+.. code-block:: python
+
+ class res_partner(osv.osv):
+ _name = "res.partner"
+ _inherit = "res.partner"
+ _columns = {
+ 'property_product_pricelist':
+ fields.property(
+ 'product.pricelist',
+ type='many2one',
+ relation='product.pricelist',
+ string="Sale Pricelist",
+ method=True,
+ view_load=True,
+ group_name="Pricelists Properties"),
+ }
+
+
+Then you have to create the default value in a .XML file for this property:
+
+.. code-block:: xml
+
+ <record model="ir.property" id="property_product_pricelist">
+ <field name="name">property_product_pricelist</field>
+ <field name="fields_id" search="[('model','=','res.partner'),
+ ('name','=','property_product_pricelist')]"/>
+ <field name="value" eval="'product.pricelist,'+str(list0)"/>
+ </record>
+
+..
+
+.. tip::
+
+ if the default value points to a resource from another module, you can use the ref function like this:
+
+ <field name="value" eval="'product.pricelist,'+str(ref('module.data_id'))"/>
+
+**Putting properties in forms**
+
+To add properties in forms, just put the <properties/> tag in your form. This will automatically add all properties fields that are related to this object. The system will add properties depending on your rights. (some people will be able to change a specific property, others won't).
+
+Properties are displayed by section, depending on the group_name attribute. (It is rendered in the client like a separator tag).
+
+**How does this work ?**
+
+The fields.property class inherits from fields.function and overrides the read and write method. The type of this field is many2one, so in the form a property is represented like a many2one function.
+
+But the value of a property is stored in the ir.property class/table as a complete record. The stored value is a field of type reference (not many2one) because each property may point to a different object. If you edit properties values (from the administration menu), these are represented like a field of type reference.
+
+When you read a property, the program gives you the property attached to the instance of object you are reading. If this object has no value, the system will give you the default property.
+
+The definition of a property is stored in the ir.model.fields class like any other fields. In the definition of the property, you can add groups that are allowed to change to property.
+
+**Using properties or normal fields**
+
+When you want to add a new feature, you will have to choose to implement it as a property or as normal field. Use a normal field when you inherit from an object and want to extend this object. Use a property when the new feature is not related to the object but to an external concept.
+
+
+Here are a few tips to help you choose between a normal field or a property:
+
+Normal fields extend the object, adding more features or data.
+
+A property is a concept that is attached to an object and have special features:
+
+* Different value for the same property depending on the company
+* Rights management per field
+* It's a link between resources (many2one)
+
+**Example 1: Account Receivable**
+
+The default "Account Receivable" for a specific partner is implemented as a property because:
+
+ * This is a concept related to the account chart and not to the partner, so it is an account property that is visible on a partner form. Rights have to be managed on this fields for accountants, these are not the same rights that are applied to partner objects. So you have specific rights just for this field of the partner form: only accountants may change the account receivable of a partner.
+
+ * This is a multi-company field: the same partner may have different account receivable values depending on the company the user belongs to. In a multi-company system, there is one account chart per company. The account receivable of a partner depends on the company it placed the sale order.
+
+ * The default account receivable is the same for all partners and is configured from the general property menu (in administration).
+
+.. note::
+ One interesting thing is that properties avoid "spaghetti" code. The account module depends on the partner (base) module. But you can install the partner (base) module without the accounting module. If you add a field that points to an account in the partner object, both objects will depend on each other. It's much more difficult to maintain and code (for instance, try to remove a table when both tables are pointing to each others.)
+
+**Example 2: Product Times**
+
+The product expiry module implements all delays related to products: removal date, product usetime, ... This module is very useful for food industries.
+
+This module inherits from the product.product object and adds new fields to it:
+
+.. code-block:: python
+
+ class product_product(osv.osv):
+
+ _inherit = 'product.product'
+ _name = 'product.product'
+ _columns = {
+
+ 'life_time': fields.integer('Product lifetime'),
+ 'use_time': fields.integer('Product usetime'),
+ 'removal_time': fields.integer('Product removal time'),
+ 'alert_time': fields.integer('Product alert time'),
+ }
+
+ product_product()
+
+..
+
+This module adds simple fields to the product.product object. We did not use properties because:
+
+ * We extend a product, the life_time field is a concept related to a product, not to another object.
+ * We do not need a right management per field, the different delays are managed by the same people that manage all products.
+
+
+ORM methods
+-----------
+
+Keeping the context in ORM methods
+++++++++++++++++++++++++++++++++++
+
+In OpenObject, the context holds very important data such as the language in
+which a document must be written, whether function field needs updating or not,
+etc.
+
+When calling an ORM method, you will probably already have a context - for
+example the framework will provide you with one as a parameter of almost
+every method.
+If you do have a context, it is very important that you always pass it through
+to every single method you call.
+
+This rule also applies to writing ORM methods. You should expect to receive a
+context as parameter, and always pass it through to every other method you call..
--- /dev/null
+Views and Events
+================
+
+Introduction to Views
+---------------------
+
+As all data of the program is stored in objects, as explained in the Objects section, how are these objects exposed to the user ? We will try to answer this question in this section.
+
+First of all, let's note that every resource type uses its own interface. For example, the screen to modify a partner's data is not the same as the one to modify an invoice.
+
+Then, you have to know that the OpenERP user interface is dynamic, it means that it is not described "statically" by some code, but dynamically built from XML descriptions of the client screens.
+
+From now on, we will call these screen descriptions views.
+
+A notable characteristic of these views is that they can be edited at any moment (even during the program execution). After a modification to a displayed view has occurred, you simply need to close the tab corresponding to that 'view' and re-open it for the changes to appear.
+
+Views principles
+++++++++++++++++
+
+Views describe how each object (type of resource) is displayed. More precisely, for each object, we can define one (or several) view(s) to describe which fields should be drawn and how.
+
+There are two types of views:
+
+ #. form views
+ #. tree views
+
+.. note:: Since OpenERP 4.1, form views can also contain graphs.
+
+
+Form views
+----------
+
+The field disposition in a form view always follows the same principle. Fields are distributed on the screen following the rules below:
+
+ * By default, each field is preceded by a label, with its name.
+ * Fields are placed on the screen from left to right, and from top to bottom, according to the order in which they are declared in the view.
+ * Every screen is divided into 4 columns, each column being able to contain either a label, or an "edition" field. As every edition field is preceded (by default) by a label with its name, there will be two fields (and their respective labels) on each line of the screen. The green and red zones on the screen-shot below, illustrate those 4 columns. They designate respectively the labels and their corresponding fields.
+
+.. figure:: images/sale_order.png
+ :scale: 50
+ :align: center
+
+
+Views also support more advanced placement options:
+
+ * A view field can use several columns. For example, on the screen-shot below, the zone in the blue frame is, in fact, the only field of a "one to many". We will come back later on this note, but let's note that it uses the whole width of the screen and not only one column.
+
+ .. figure:: images/sale_order_sale_order_lines.png
+ :scale: 50
+ :align: center
+
+ * We can also make the opposite operation: take a columns group and divide it in as many columns as desired. The surrounded green zones of the screen above are good examples. Precisely, the green framework up and on the right side takes the place of two columns, but contains 4 columns.
+
+As we can see below in the purple zone of the screen, there is also a way to distribute the fields of an object on different tabs.
+
+.. figure:: images/sale_order_notebook.png
+ :scale: 50
+ :align: center
+
+
+Tree views
+-----------
+
+These views are used when we work in list mode (in order to visualize several resources at once) and in the search screen. These views are simpler than the form views and thus have less options.
+
+.. figure:: images/tree_view.png
+ :scale: 50
+ :align: center
+
+Graph views
+--------------
+
+A graph is a new mode of view for all views of type form. If, for example, a sale order line must be visible as list or as graph, define it like this in the action that open this sale order line. Do not set the view mode as "tree,form,graph" or "form,graph" - it must be "graph,tree" to show the graph first or "tree,graph" to show the list first. (This view mode is extra to your "form,tree" view and should have a separate menu item):
+
+.. code-block:: xml
+
+ <field name="view_type">form</field>
+ <field name="view_mode">tree,graph</field>
+
+view_type::
+
+ tree = (tree with shortcuts at the left), form = (switchable view form/list)
+
+view_mode::
+
+ tree,graph : sequences of the views when switching
+
+Then, the user will be able to switch from one view to the other. Unlike forms and trees, OpenERP is not able to automatically create a view on demand for the graph type. So, you must define a view for this graph:
+
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_order_line_graph">
+ <field name="name">sale.order.line.graph</field>
+ <field name="model">sale.order.line</field>
+ <field name="type">graph</field>
+ <field name="arch" type="xml">
+ <graph string="Sales Order Lines">
+ <field name="product_id" group="True"/>
+ <field name="price_unit" operator="*"/>
+ </graph>
+ </field>
+ </record>
+
+
+The graph view
+
+A view of type graph is just a list of fields for the graph.
+
+Graph tag
+++++++++++
+
+The default type of the graph is a pie chart - to change it to a barchart change **<graph string="Sales Order Lines">** to **<graph string="Sales Order Lines" type="bar">** You also may change the orientation.
+
+:Example :
+
+.. code-block:: xml
+
+ <graph string="Sales Order Lines" orientation="horizontal" type="bar">
+
+Field tag
++++++++++
+
+The first field is the X axis. The second one is the Y axis and the optional third one is the Z axis for 3 dimensional graphs. You can apply a few attributes to each field/axis:
+
+ * **group**: if set to true, the client will group all item of the same value for this field. For each other field, it will apply an operator
+ * **operator**: the operator to apply is another field is grouped. By default it's '+'. Allowed values are:
+
+ + +: addition
+ + \*: multiply
+ + \**: exponent
+ + min: minimum of the list
+ + max: maximum of the list
+
+:Defining real statistics on objects:
+
+The easiest method to compute real statistics on objects is:
+
+ 1. Define a statistic object which is a postgresql view
+ 2. Create a tree view and a graph view on this object
+
+You can get en example in all modules of the form: report\_.... Example: report_crm.
+
+
+Search views
+--------------
+
+Search views are a new feature of OpenERP supported as of version 6.0
+It creates a customized search panel, and is declared quite similarly to a form view,
+except that the view type and root element change to ``search`` instead of ``form``.
+
+.. image:: images/search.png
+ :scale: 50
+ :align: center
+
+Following is the list of new elements and features supported in search views.
+
+Group tag
++++++++++
+
+Unlike form group elements, search view groups support unlimited number of widget(fields or filters)
+in a row (no automatic line wrapping), and only use the following attributes:
+
+ + ``expand``: turns on the expander icon on the group (1 for expanded by default, 0 for collapsed)
+ + ``string``: label for the group
+
+.. code-block:: xml
+
+ <group expand="1" string="Group By...">
+ <filter string="Users" icon="terp-project" domain="[]" context="{'group_by':'user_id'}"/>
+ <filter string="Project" icon="terp-project" domain="[]" context="{'group_by':'project_id'}"/>
+ <separator orientation="vertical"/>
+ <filter string="Deadline" icon="terp-project" domain="[]" context="{'group_by':'date_deadline'}"/>
+ </group>
+
+In the screenshot above the green area is an expandable group.
+
+Filter tag
++++++++++++
+Filters are displayed as a toggle button on search panel
+Filter elements can add new values in the current domain or context of the search view.
+Filters can be added as a child element of field too, to indicate that they apply specifically
+to that field (in this case the button's icon will smaller)
+
+In the picture above the red area contains filters at the top of the form while
+the blue area highlights a field and it's child filter.
+
+.. code-block:: xml
+
+ <filter string="Current" domain="[('state','in',('open','draft'))]" help="Draft, Open and Pending Tasks" icon="terp-project"/>
+ <field name="project_id" select="1" widget="selection">
+ <filter domain="[('project_id.user_id','=',uid)]" help="My Projects" icon="terp-project"/>
+ </field>
+
+Group By
+++++++++
+
+.. code-block:: xml
+
+ <filter string="Project" icon="terp-project" domain="[]" context="{'group_by':'project_id'}"/>
+
+Above filters groups records sharing the same ``project_id`` value. Groups are loaded
+lazily, so the inner records are only loaded when the group is expanded.
+The group header lines contain the common values for all records in that group, and all numeric
+fields currently displayed in the view are replaced by the sum of the values in that group.
+
+It is also possible to group on multiple values by specifying a list of fields instead of a single string.
+In this case nested groups will be displayed::
+
+ <filter string="Project" icon="terp-project" domain="[]" context="{'group_by': ['project_id', 'user_id'] }"/>
+
+Fields
+++++++
+
+Field elements in search views are used to get user-provided values
+for searches. As a result, as for group elements, they are quite
+different than form view's fields:
+
+* a search field can contain filters, which generally indicate that
+ both field and filter manage the same field and are related.
+
+ Those inner filters are rendered as smaller buttons, right next to
+ the field, and *must not* have a ``string`` attribute.
+
+* a search field really builds a domain composed of ``[(field_name,
+ operator, field_value)]``. This domain can be overridden in two
+ ways:
+
+ * ``@operator`` replaces the default operator for the field (which
+ depends on its type)
+
+ * ``@filter_domain`` lets you provide a fully custom domain, which
+ will replace the default domain creation
+
+* a search field does not create a context by default, but you can
+ provide an ``@context`` which will be evaluated and merged into the
+ wider context (as with a ``filter`` element).
+
+To get the value of the field in your ``@context`` or
+``@filter_domain``, you can use the variable ``self``:
+
+.. code-block:: xml
+
+ <field name="location_id" string="Location"
+ filter_domain="['|',('location_id','ilike',self),('location_dest_id','ilike',self)]"/>
+
+or
+
+.. code-block:: xml
+
+ <field name="journal_id" widget="selection"
+ context="{'journal_id':self, 'visible_id':self, 'normal_view':False}"/>
+
+Range fields (date, datetime, time)
+"""""""""""""""""""""""""""""""""""
+
+The range fields are composed of two input widgets (from and two)
+instead of just one.
+
+This leads to peculiarities (compared to non-range search fields):
+
+* It is not possible to override the operator of a range field via
+ ``@operator``, as the domain is built of two sections and each
+ section uses a different operator.
+
+* Instead of being a simple value (integer, string, float) ``self``
+ for use in ``@filter_domain`` and ``@context`` is a ``dict``.
+
+ Because each input widget of a range field can be empty (and the
+ field itself will still be valid), care must be taken when using
+ ``self``: it has two string keys ``"from"`` and ``"to"``, but any of
+ these keys can be either missing entirely or set to the value
+ ``False``.
+
+Actions for Search view
++++++++++++++++++++++++
+
+After declaring a search view, it will be used automatically for all tree views on the same model.
+If several search views exist for a single model, the one with the highest priority (lowest sequence) will
+be used. Another option is to explicitly select the search view you want to use, by setting the
+``search_view_id`` field of the action.
+
+In addition to being able to pass default form values in the context of the action, OpenERP 6.0 now
+supports passing initial values for search views too, via the context. The context keys need to match the
+``search_default_XXX`` format. ``XXX`` may refer to the ``name`` of a ``<field>`` or ``<filter>``
+in the search view (as the ``name`` attribute is not required on filters, this only works for filters that have
+an explicit ``name`` set). The value should be either the initial value for search fields, or
+simply a boolean value for filters, to toggle them
+
+.. code-block:: xml
+
+ <record id="action_view_task" model="ir.actions.act_window">
+ <field name="name">Tasks</field>
+ <field name="res_model">project.task</field>
+ <field name="view_type">form</field>
+ <field name="view_mode">tree,form,calendar,gantt,graph</field>
+ <field eval="False" name="filter"/>
+ <field name="view_id" ref="view_task_tree2"/>
+ <field name="context">{"search_default_current":1,"search_default_user_id":uid}</field>
+ <field name="search_view_id" ref="view_task_search_form"/>
+ </record>
+
+Custom Filters
+++++++++++++++
+
+As of v6.0, all search views also features custom search filters, as show below.
+Users can define their own custom filters using any of the fields available on the current model,
+combining them with AND/OR operators. It is also possible to save any search context (the combination
+of all currently applied domain and context values) as a personal filter, which can be recalled
+at any time. Filters can also be turned into Shortcuts directly available in the User's homepage.
+
+.. image:: images/filter.png
+ :scale: 50
+ :align: center
+
+
+In above screenshot we filter Partner where Salesman = Demo user and Country = Belgium,
+We can save this search criteria as a Shortcut or save as Filter.
+
+Filters are user specific and can be modified via the Manage Filters option in the filters drop-down.
+
+
+Calendar Views
+--------------
+
+Calendar view provides timeline/schedule view for the data.
+
+View Specification
+++++++++++++++++++
+
+Here is an example view:
+
+.. code-block:: xml
+
+ <calendar color="user_id" date_delay="planned_hours" date_start="date_start" string="Tasks">
+ <field name="name"/>
+ <field name="project_id"/>
+ </calendar>
+
+Here is the list of supported attributes for ``calendar`` tag:
+
+ ``string``
+ The title string for the view.
+
+ ``date_start``
+ A ``datetime`` field to specify the starting date for the calendar item. This
+ attribute is required.
+
+ ``date_stop``
+ A ``datetime`` field to specify the end date. Ignored if ``date_delay``
+ attribute is specified.
+
+ ``date_delay``
+ A ``numeric`` field to specify time in hours for a record. This attribute
+ will get preference over ``date_stop`` and ``date_stop`` will be ignored.
+
+ ``day_length``
+ An ``integer`` value to specify working day length. Default is ``8`` hours.
+
+ ``color``
+ A field, generally ``many2one``, to colorize calendar/gantt items.
+
+ ``mode``
+ A string value to set default view/zoom mode. For ``calendar`` view, this can be
+ one of following (default is ``month``):
+
+ * ``day``
+ * ``week``
+ * ``month``
+
+Screenshots
++++++++++++
+
+Month Calendar:
+
+.. figure:: images/calendar_month.png
+ :scale: 50%
+ :align: center
+
+Week Calendar:
+
+.. figure:: images/calendar_week.png
+ :scale: 50%
+ :align: center
+
+
+Gantt Views
+-----------
+
+Gantt view provides timeline view for the data. Generally, it can be used to display
+project tasks and resource allocation.
+
+A Gantt chart is a graphical display of all the tasks that a project is composed of.
+Each bar on the chart is a graphical representation of the length of time the task is
+planned to take.
+
+A resource allocation summary bar is shown on top of all the grouped tasks,
+representing how effectively the resources are allocated among the tasks.
+
+Color coding of the summary bar is as follows:
+
+ * `Gray` shows that the resource is not allocated to any task at that time
+ * `Blue` shows that the resource is fully allocated at that time.
+ * `Red` shows that the resource is overallocated
+
+View Specification
+++++++++++++++++++
+
+Here is an example view:
+
+.. code-block:: xml
+
+ <gantt color="user_id" date_delay="planned_hours" date_start="date_start" string="Tasks">
+ <level object="project.project" link="project_id" domain="[]">
+ <field name="name"/>
+ </level>
+ </gantt>
+
+The ``attributes`` accepted by the ``gantt`` tag are similar to ``calendar`` view tag. The
+``level`` tag is used to group the records by some ``many2one`` field. Currently, only
+one level is supported.
+
+Here is the list of supported attributes for ``gantt`` tag:
+
+ ``string``
+ The title string for the view.
+
+ ``date_start``
+ A ``datetime`` field to specify the starting date for the gantt item. This
+ attribute is required.
+
+ ``date_stop``
+ A ``datetime`` field to specify the end date. Ignored if ``date_delay``
+ attribute is specified.
+
+ ``date_delay``
+ A ``numeric`` field to specify time in hours for a record. This attribute
+ will get preference over ``date_stop`` and ``date_stop`` will be ignored.
+
+ ``day_length``
+ An ``integer`` value to specify working day length. Default is ``8`` hours.
+
+ ``color``
+ A field, generally ``many2one``, to colorize calendar/gantt items.
+
+ ``mode``
+ A string value to set default view/zoom mode. For ``gantt`` view, this can be
+ one of following (default is ``month``):
+
+ * ``day``
+ * ``3days``
+ * ``week``
+ * ``3weeks``
+ * ``month``
+ * ``3months``
+ * ``year``
+ * ``3years``
+ * ``5years``
+
+The ``level`` tag supports following attributes:
+
+ ``object``
+ An openerp object having many2one relationship with view object.
+
+ ``link``
+ The field name in current object that links to the given ``object``.
+
+ ``domain``
+ The domain to be used to filter the given ``object`` records.
+
+Drag and Drop
++++++++++++++
+
+The left side pane displays list of the tasks grouped by the given ``level`` field.
+You can reorder or change the group of any records by dragging them.
+
+The main content pane displays horizontal bars plotted on a timeline grid. A group
+of bars are summarized with a top summary bar displaying resource allocation of all
+the underlying tasks.
+
+You can change the task start time by dragging the tasks horizontally. While
+end time can be changed by dragging right end of a bar.
+
+.. note::
+
+ The time is calculated considering ``day_length`` so a bar will span more
+ then one day if total time for a task is greater then ``day_length`` value.
+
+Screenshots
++++++++++++
+
+.. figure:: images/gantt.png
+ :scale: 50%
+ :align: center
+
+
+Design Elements
+---------------
+
+The files describing the views are of the form:
+
+:Example:
+
+.. code-block:: xml
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ [view definitions]
+ </data>
+ </openerp>
+
+The view definitions contain mainly three types of tags:
+
+ * **<record>** tags with the attribute model="ir.ui.view", which contain the view definitions themselves
+ * **<record>** tags with the attribute model="ir.actions.act_window", which link actions to these views
+ * **<menuitem>** tags, which create entries in the menu, and link them with actions
+
+New : You can specify groups for whom the menu is accessible using the groups
+attribute in the `menuitem` tag.
+
+New : You can now add shortcut using the `shortcut` tag.
+
+:Example:
+
+.. code-block:: xml
+
+ <shortcut
+ name="Draft Purchase Order (Proposals)"
+ model="purchase.order"
+ logins="demo"
+ menu="m"/>
+
+Note that you should add an id attribute on the `menuitem` which is referred by
+menu attribute.
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="v">
+ <field name="name">sale.order.form</field>
+ <field name="model">sale.order</field>
+ <field name="priority" eval="2"/>
+ <field name="arch" type="xml">
+ <form string="Sale Order">
+ .........
+ </form>
+ </field>
+ </record>
+
+Default value for the priority field : 16. When not specified the system will use the view with the lower priority.
+
+View Types
+++++++++++
+
+Tree View
+"""""""""
+You can specify the columns to include in the list, along with some details of
+the list's appearance. The search fields aren't specified here, they're
+specified by the `select` attribute in the form view fields.
+
+.. code-block:: xml
+
+ <record id="view_location_tree2" model="ir.ui.view">
+ <field name="name">stock.location.tree</field>
+ <field name="model">stock.location</field>
+ <field name="type">tree</field>
+ <field name="priority" eval="2"/>
+ <field name="arch" type="xml">
+ <tree
+ colors="blue:usage=='view';darkred:usage=='internal'">
+
+ <field name="complete_name"/>
+ <field name="usage"/>
+ <field
+ name="stock_real"
+ invisible="'product_id' not in context"/>
+ <field
+ name="stock_virtual"
+ invisible="'product_id' not in context"/>
+ </tree>
+ </field>
+ </record>
+
+That example is just a flat list, but you can also display a real tree structure
+by specifying a `field_parent`. The name is a bit misleading, though; the field
+you specify must contain a list of all **child** entries.
+
+.. code-block:: xml
+
+ <record id="view_location_tree" model="ir.ui.view">
+ <field name="name">stock.location.tree</field>
+ <field name="model">stock.location</field>
+ <field name="type">tree</field>
+ <field name="field_parent">child_ids</field>
+ <field name="arch" type="xml">
+ <tree toolbar="1">
+ <field icon="icon" name="name"/>
+ </tree>
+ </field>
+ </record>
+
+
+On the `tree` element, the following attributes are supported:
+
+colors
+ Conditions for applying different colors to items in the list. The default
+ is black.
+toolbar
+ Set this to 1 if you want a tree structure to list the top level entries
+ in a separate toolbar area. When you click on an entry in the toolbar, all
+ its descendants will be displayed in the main tree. The value is ignored
+ for flat lists.
+
+Grouping Elements
++++++++++++++++++
+
+Separator
+"""""""""
+
+Adds a separator line
+
+:Example:
+
+.. code-block:: xml
+
+ <separator string="Links" colspan="4"/>
+
+The string attribute defines its label and the colspan attribute defines his horizontal size (in number of columns).
+
+Notebook
+""""""""
+
+<notebook>: With notebooks you can distribute the view fields on different tabs (each one defined by a page tag). You can use the tabpos properties to set tab at: up, down, left, right.
+
+:Example:
+
+.. code-block:: xml
+
+ <notebook colspan="4">....</notebook>
+
+Group
+"""""
+
+<group>: groups several columns and split the group in as many columns as desired.
+
+ * **colspan**: the number of columns to use
+ * **rowspan**: the number of rows to use
+ * **expand**: if we should expand the group or not
+ * **col**: the number of columns to provide (to its children)
+ * **string**: (optional) If set, a frame will be drawn around the group of fields, with a label containing the string. Otherwise, the frame will be invisible.
+
+:Example:
+
+.. code-block:: xml
+
+ <group col="3" colspan="2">
+ <field name="invoiced" select="2"/>
+ <button colspan="1" name="make_invoice" states="confirmed" string="Make Invoice"
+ type="object"/>
+ </group>
+
+Page
+""""
+
+Defines a new notebook page for the view.
+
+:Example:
+
+.. code-block:: xml
+
+ <page string="Order Line"> ... </page>:
+
+* **string**: defines the name of the page.
+
+Data Elements
++++++++++++++
+
+Field
+"""""
+
+:guilabel:`attributes for the "field" tag`
+
+ * ``select="1"``: mark this field as being one of the search criteria for
+ this resource's search view. A value of 1 means that the field is
+ included in the basic search, and a value of 2 means that it is in
+ the advanced search.
+
+ * ``colspan="4"``: the number of columns on which a field must extend.
+
+ * ``readonly="1"``: set the widget as read only
+
+ * ``required="1"``: the field is marked as required. If a field is marked as required, a user has to fill it the system won't save the resource if the field is not filled. This attribute supersede the required field value defined in the object.
+
+ * ``nolabel="1"``: hides the label of the field (but the field is not hidden in the search view).
+
+ * ``invisible="True"``: hides both the label and the field.
+
+ * ``password="True"``: replace field values by asterisks, "*".
+
+ * ``string=""``: change the field label. Note that this label is also used in the search view: see select attribute above).
+
+ * ``domain``: can restrict the domain.
+ + Example: domain="[('partner_id','=',partner_id)]"
+
+ * ``widget``: can change the widget.
+ + Example: widget="one2many_list"
+ - one2one_list
+ - one2many_list
+ - many2one_list
+ - many2many
+ - url
+ - email
+ - image
+ - float_time
+ - reference
+
+ * ``mode``: sequences of the views when switching.
+ + Example: mode="tree,graph"
+
+ * ``on_change``: define a function that is called when the content of the field changes.
+ + Example: on_change="onchange_partner(type,partner_id)"
+ + See ViewsSpecialProperties for details
+
+ * ``attrs``: Permits to define attributes of a field depends on other fields of the same window. (It can be use on page, group, button and notebook tag also)
+ + Format: "{'attribute':[('field_name','operator','value'),('field_name','operator','value')],'attribute2':[('field_name','operator','value'),]}"
+ + where attribute will be readonly, invisible, required
+ + Default value: {}.
+ + Example: (in product.product)
+
+ .. code-block:: xml
+
+ <field digits="(14, 3)" name="volume" attrs="{'readonly':[('type','=','service')]}"/>
+
+ * ``eval``: evaluate the attribute content as if it was Python code (see :ref:`below <eval-attribute-link>` for example)
+
+ * ``default_focus``: set to ``1`` to put the focus (cursor position) on this field when the form is first opened.
+ There can only be one field within a view having this attribute set to ``1`` **(new as of 5.2)**
+
+ .. code-block:: xml
+
+ <field name="name" default_focus=”1”/>
+
+
+Example
+
+Here's the source code of the view of a sale order object. This is the same object as the object shown on the screen shots of the presentation.
+
+:Example:
+
+.. code-block:: xml
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ <record id="view_partner_form" model="ir.ui.view">
+ <field name="name">res.partner.form</field>
+ <field name="model">res.partner</field>
+ <field name="type">form</field>
+ <field name="arch" type="xml">
+ <form string="Partners">
+ <group colspan="4" col="6">
+ <field name="name" select="1"/>
+ <field name="ref" select="1"/>
+ <field name="customer" select="1"/>
+ <field domain="[('domain', '=', 'partner')]" name="title"/>
+ <field name="lang" select="2"/>
+ <field name="supplier" select="2"/>
+ </group>
+ <notebook colspan="4">
+ <page string="General">
+ <field colspan="4" mode="form,tree" name="address"
+ nolabel="1" select="1">
+ <form string="Partner Contacts">
+ <field name="name" select="2"/>
+ <field domain="[('domain', '=', 'contact')]" name="title"/>
+ <field name="function"/>
+ <field name="type" select="2"/>
+ <field name="street" select="2"/>
+ <field name="street2"/>
+ <newline/>
+ <field name="zip" select="2"/>
+ <field name="city" select="2"/>
+ <newline/>
+ <field completion="1" name="country_id" select="2"/>
+ <field name="state_id" select="2"/>
+ <newline/>
+ <field name="phone"/>
+ <field name="fax"/>
+ <newline/>
+ <field name="mobile"/>
+ <field name="email" select="2" widget="email"/>
+ </form>
+ <tree string="Partner Contacts">
+ <field name="name"/>
+ <field name="zip"/>
+ <field name="city"/>
+ <field name="country_id"/>
+ <field name="phone"/>
+ <field name="email"/>
+ </tree>
+ </field>
+ <separator colspan="4" string="Categories"/>
+ <field colspan="4" name="category_id" nolabel="1" select="2"/>
+ </page>
+ <page string="Sales & Purchases">
+ <separator string="General Information" colspan="4"/>
+ <field name="user_id" select="2"/>
+ <field name="active" select="2"/>
+ <field name="website" widget="url"/>
+ <field name="date" select="2"/>
+ <field name="parent_id"/>
+ <newline/>
+ </page>
+ <page string="History">
+ <field colspan="4" name="events" nolabel="1" widget="one2many_list"/>
+ </page>
+ <page string="Notes">
+ <field colspan="4" name="comment" nolabel="1"/>
+ </page>
+ </notebook>
+ </form>
+ </field>
+ </record>
+ <menuitem
+ action="action_partner_form"
+ id="menu_partner_form"
+ parent="base.menu_base_partner"
+ sequence="2"/>
+ </data>
+ </openerp>
+
+.. _eval-attribute-link:
+
+The eval attribute
+//////////////////
+
+The **eval** attribute evaluate its content as if it was Python code. This
+allows you to define values that are not strings.
+
+Normally, content inside *<field>* tags are always evaluated as strings.
+
+.. describe:: Example 1:
+
+.. code-block:: xml
+
+ <field name="value">2.3</field>
+
+This will evaluate to the string ``'2.3'`` and not the float ``2.3``
+
+.. describe:: Example 2:
+
+.. code-block:: xml
+
+ <field name="value">False</field>
+
+This will evaluate to the string ``'False'`` and not the boolean
+``False``. This is especially tricky because Python's conversion rules
+consider any non-empty string to be ``True``, so the above code will
+end up storing the opposite of what is desired.
+
+If you want to evaluate the value to a float, a boolean or another
+type, except string, you need to use the **eval** attribute:
+
+.. code-block:: xml
+
+ <field name="value" eval="2.3" />
+ <field name="value" eval="False" />
+
+Button
+""""""
+
+Adds a button to the current view. Allows the user to perform various
+actions on the current record.
+
+After a button has been clicked, the record should always be reloaded.
+
+Buttons have the following attributes:
+
+``@type``
+ Defines the type of action performed when the button is activated:
+
+ ``workflow`` (default)
+ The button will send a workflow signal [#]_ on the current model
+ using the ``@name`` of the button as workflow signal name and
+ providing the record id as parameter (in a list).
+
+ The workflow signal may return an action descriptor, which should
+ be executed. Otherwise it will return ``False``.
+
+ ``object``
+ The button will execute the method of name ``@name`` on the
+ current model, providing the record id as parameter (in a
+ list). This call may return an action descriptor to execute.
+
+ ``action``
+ The button will trigger the execution of an action
+ (``ir.actions.actions``). The ``id`` of this action is the
+ ``@name`` of the button.
+
+ From there, follows the normal action-execution workflow.
+
+``@special``
+ Only has one possible value currently: ``cancel``, which indicates
+ that the popup should be closed without performing any RPC call or
+ action resolution.
+
+ .. note::
+ Only meaningful within a popup-type window (e.g. a
+ wizard). Otherwise, is a noop.
+
+ .. warning::
+
+ ``@special`` and ``@type`` are incompatible.
+
+``@name``
+ The button's identifier, used to indicate which method should be
+ called, which signal sent or which action executed.
+
+``@confirm``
+ A confirmation popup to display before executing the button's
+ task. If the confirmation is dismissed the button's task *must not*
+ be executed.
+
+``@string``
+ The label which should be displayed on the button [#]_.
+
+``@icon``
+ Display an icon on the button, if absent the button is text-only
+ [#]_.
+
+``@states``, ``@attrs``, ``@invisible``
+ Standard OpenERP meaning for those view attributes
+
+``@default_focus``
+ If set to a truthy value (``1``), automatically selects that button
+ so it is used if ``RETURN`` is pressed while on the form.
+
+ May be ignored by the client.
+
+ .. versionadded:: 6.0
+
+:Example:
+
+.. code-block:: xml
+
+ <button name="order_confirm" states="draft" string="Confirm Order" icon="gtk-execute"/>
+ <button name="_action_open_window" string="Open Margins" type="object" default_focus=”1”/>
+
+Label
+"""""
+
+Adds a simple label using the string attribute as caption.
+
+:Example:
+
+.. code-block:: xml
+
+ <label string="Test"/>
+
+New Line
+""""""""
+
+Force a return to the line even if all the columns of the view are not filled in.
+
+:Example:
+
+.. code-block:: xml
+
+ <newline/>
+
+.. [#] via ``exec_workflow`` on the ``object`` rpc endpoint
+
+.. [#] in form view, in list view buttons have no label
+
+.. [#] behavior in list view is undefined, as list view buttons don't
+ have labels.
+
+
+Inheritance in Views
+--------------------
+
+When you create and inherit objects in some custom or specific modules, it is better to inherit (than to replace) from an existing view to add/modify/delete some fields and preserve the others.
+
+:Example:
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form">
+ <field name="name">res.partner.form.inherit</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <notebook position="inside">
+ <page string="Relations">
+ <field name="relation_ids" colspan="4" nolabel="1"/>
+ </page>
+ </notebook>
+ </field>
+ </record>
+
+This will add a page to the notebook of the ``res.partner.form`` view in the
+base module.
+
+The inheritance engine will parse the existing view and search for the root nodes of
+
+.. code-block:: xml
+
+ <field name="arch" type="xml">
+
+It will append or edit the content of this tag. If this tag has some attributes,
+it will look in the parent view for a node with matching attributes (except
+position).
+
+You can use these values in the position attribute:
+
+ * inside (default): your values will be appended inside the tag
+ * after: add the content after the tag
+ * before: add the content before the tag
+ * replace: replace the content of the tag.
+
+Replacing Content
++++++++++++++++++
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form1">
+ <field name="name">res.partner.form.inherit1</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <page string="Extra Info" position="replace">
+ <field name="relation_ids" colspan="4" nolabel="1"/>
+ </page>
+ </field>
+ </record>
+
+Will replace the content of the Extra Info tab of the notebook with the ``relation_ids`` field.
+
+The parent and the inherited views are correctly updated with ``--update=all`` argument like any other views.
+
+Deleting Content
+++++++++++++++++
+
+To delete a field from a form, an empty element with ``position="replace"`` attribute is used. Example:
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form2">
+ <field name="name">res.partner.form.inherit2</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <field name="lang" position="replace"/>
+ </field>
+ </record>
+
+Inserting Content
++++++++++++++++++
+
+To add a field into a form before the specified tag use ``position="before"`` attribute.
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form3">
+ <field name="name">res.partner.form.inherit3</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <field name="lang" position="before">
+ <field name="relation_ids"/>
+ </field>
+ </field>
+ </record>
+
+Will add ``relation_ids`` field before the ``lang`` field.
+
+To add a field into a form after the specified tag use ``position="after"`` attribute.
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form4">
+ <field name="name">res.partner.form.inherit4</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <field name="lang" position="after">
+ <field name="relation_ids"/>
+ </field>
+ </field>
+ </record>
+
+Will add ``relation_ids`` field after the ``lang`` field.
+
+
+Multiple Changes
+++++++++++++++++
+
+To make changes in more than one location, wrap the fields in a data element.
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form5">
+ <field name="name">res.partner.form.inherit5</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <data>
+ <field name="lang" position="replace"/>
+ <field name="website" position="after">
+ <field name="lang"/>
+ </field>
+ </data>
+ </field>
+ </record>
+
+Will delete the ``lang`` field from its usual location, and display it after
+the ``website`` field.
+
+.. _xpath-element-inheritance:
+
+XPath Element
++++++++++++++
+
+Sometimes a view is too complicated to let you simply identify a target field
+by name. For example, the field might appear in two places. When that happens,
+you can use an ``xpath`` element to describe where your changes should be
+placed.
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="view_partner_form6">
+ <field name="name">res.partner.form.inherit6</field>
+ <field name="model">res.partner</field>
+ <field name="inherit_id" ref="base.view_partner_form"/>
+ <field name="arch" type="xml">
+ <data>
+ <xpath
+ expr="//field[@name='address']/form/field[@name='email']"
+ position="after">
+ <field name="age"/>
+ </xpath>
+ <xpath
+ expr="//field[@name='address']/tree/field[@name='email']"
+ position="after">
+ <field name="age"/>
+ </xpath>
+ </data>
+ </field>
+ </record>
+
+Will add the ``age`` field after the ``email`` field in both the form and tree
+view of the address list.
+
+
+Specify the views you want to use
+---------------------------------
+
+There are some cases where you would like to specify a view other than the default:
+
+- If there are several form or tree views for an object.
+- If you want to change the form or tree view used by a relational field
+ (one2many for example).
+
+Using the priority field
+++++++++++++++++++++++++
+
+This field is available in the view definition, and is 16 by default. By
+default, OpenERP will display a model using the view with the highest priority
+(the smallest number). For example, imagine we have two views for a simple model.
+The model *client* with two fields : **firstname** and **lastname**. We will define
+two views, one which shows the firstname first, and the other one which shows
+the lastname first.
+
+.. code-block:: xml
+ :linenos:
+
+ <!--
+ Here is the first view for the model 'client'.
+ We don't specify a priority field, which means
+ by default 16.
+ -->
+ <record model="ir.ui.view" id="client_form_view_1">
+ <field name="name">client.form.view1</field>
+ <field name="model">client</field>
+ <field name="type">form</fiel>
+ <field name="arch" type="xml">
+ <field name="firstname"/>
+ <field name="lastname"/>
+ </field>
+ </record>
+
+ <!--
+ A second view, which show fields in an other order.
+ We specify a priority of 15.
+ -->
+ <record model="ir.ui.view" id="client_form_view_2">
+ <field name="name">client.form.view2</field>
+ <field name="model">client</field>
+ <field name="priority" eval="15"/>
+ <field name="type">form</fiel>
+ <field name="arch" type="xml">
+ <field name="lastname"/>
+ <field name="firstname"/>
+ </field>
+ </record>
+
+Now, each time OpenERP will have to show a form view for our object *client*, it will have the choice between two views.
+**It will always use the second one, because it has a higher priority !** Unless you tell it to use the first one !
+
+Specify per-action view
++++++++++++++++++++++++
+
+To illustrate this point, we will create 2 menus which show a form view for this *client* object :
+
+.. code-block:: xml
+ :linenos:
+
+ <!--
+ This action open the default view (in our case,
+ the view with the highest priority, the second one)
+ -->
+ <record
+ model="ir.actions.act_window"
+ id="client_form_action">
+ <field name="name">client.form.action</field>
+ <field name="res_model">client</field>
+ <field name="view_type">form</field>
+ <field name="view_mode">form</field>
+ </record>
+
+ <!--
+ This action open the view we specify.
+ -->
+ <record
+ model="ir.actions.act_window"
+ id="client_form_action1">
+ <field name="name">client.form.action1</field>
+ <field name="res_model">client</field>
+ <field name="view_type">form</field>
+ <field name="view_mode">form</field>
+ <field name="view_id" ref="client_form_view_1"/>
+ </record>
+
+ <menuitem id="menu_id" name="Client main menu"/>
+ <menuitem
+ id="menu_id_1"
+ name="Here we don't specify the view"
+ action="client_form_action" parent="menu_id"/>
+ <menuitem
+ id="menu_id_1"
+ name="Here we specify the view"
+ action="client_form_action1" parent="menu_id"/>
+
+As you can see on line *19*, we can specify a view. That means that when we open
+the second menu, OpenERP will use the form view *client_form_view_1*, regardless
+of its priority.
+
+.. note::
+
+ Remember to use the module name (*module.view_id*) in the *ref* attribute if
+ you are referring to a view defined in another module.
+
+Specify views for related fields
+++++++++++++++++++++++++++++++++
+
+Using the context
+"""""""""""""""""
+
+The *view_id* method works very well for menus/actions, but how can you specify the view to use for a one2many
+field, for example? When you have a one2many field, two views are used, a tree view (**in blue**), and a form view when
+you click on the add button (**in red**).
+
+.. figure:: images/one2many_views.png
+ :scale: 70%
+ :align: center
+
+When you add a one2many field in a form view, you do something like this :
+
+.. code-block:: xml
+
+ <field name="order_line" colspan="4" nolabel="1"/>
+
+If you want to specify the views to use, you can add a *context* attribute, and
+specify a view id for each type of view supported, exactly like the action's
+*view_id* attribute:
+
+.. code-block:: xml
+
+ <field name="order_line" colspan="4" nolabel="1"
+ context="{'form_view_ref' : 'module.view_id', 'tree_view_ref' : 'model.view_id'}"/>
+
+If you don't specify the views, OpenERP will choose one in this order :
+
+1. It will use the <form> or <tree> view defined **inside** the field (see below)
+2. Else, it will use the views with the highest priority for this object.
+3. Finally, it will generate default empty views, with all fields.
+
+.. note::
+
+ The context keys are named <view_type>_view_ref.
+
+.. note::
+
+ By default, OpenERP will never use a view that is not defined for your object. If you have two models, with the
+ same fields, but a different model name, OpenERP will never use the view of one for the other,
+ even if one model inherit an other.
+
+ You can force this by manually specifying the view, either in the action or in the context.
+
+Using subviews
+""""""""""""""
+
+In the case of relational fields, you can create a view directly inside a field :
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="some_view">
+ <field name="name">some.view</field>
+ <field name="type">form</field>
+ <field name="model">some.model.with.one2many</field>
+ <field name="arch" type="xml">
+ <field name="..."/>
+
+ <!-- <=== order_line is a one2many field -->
+ <field name="order_line" colspan="4" nolabel="1">
+ <form>
+ <field name="qty"/>
+ ...
+ </form>
+ <tree>
+ <field name="qty"/>
+ ...
+ </tree>
+ </field>
+ </field>
+
+If you or another developer want to inherit from this view in another module,
+you need to inherit from the parent view and then modify the child fields.
+With child views, you'll often need to use an :ref:`xpath-element-inheritance`
+to describe exactly where to place your new fields.
+
+.. code-block:: xml
+
+ <record model="ir.ui.view" id="some_inherited_view">
+ <field name="name">some.inherited.view</field>
+ <field name="type">form</field>
+ <field name="model">some.model.with.one2many</field>
+ <field name="inherit_id" ref="core_module.some_view"/>
+ <field name="arch" type="xml">
+ <data>
+ <xpath
+ expr="//field[@name='order_line']/form/field[@name='qty']"
+ position="after">
+ <field name="size"/>
+ </xpath>
+ <xpath
+ expr="//field[@name='order_line']/tree/field[@name='qty']"
+ position="after">
+ <field name="size"/>
+ </xpath>
+ </data>
+ </field>
+
+One down side of defining a subview like this is that it can't be inherited on
+its own, it can only be inherited with the parent view. Your views will be more
+flexible if you define the child views separately and then specify which child
+view to use as part of the one2many field.
+
+
+Events
+------
+
+On Change
++++++++++
+
+The on_change attribute defines a method that is called when the content of a view field has changed.
+
+This method takes at least arguments: cr, uid, ids, which are the three classical arguments and also the context dictionary. You can add parameters to the method. They must correspond to other fields defined in the view, and must also be defined in the XML with fields defined this way::
+
+ <field name="name_of_field" on_change="name_of_method(other_field'_1_', ..., other_field'_n_')"/>
+
+The example below is from the sale order view.
+
+You can use the 'context' keyword to access data in the context that can be used as params of the function.::
+
+ <field name="shop_id" on_change="onchange_shop_id(shop_id)"/>
+
+.. code-block:: python
+
+ def onchange_shop_id(self, cr, uid, ids, shop_id):
+
+ v={}
+ if shop_id:
+
+ shop=self.pool.get('sale.shop').browse(cr,uid,shop_id)
+ v['project_id']=shop.project_id.id
+ if shop.pricelist_id.id:
+
+ v['pricelist_id']=shop.pricelist_id.id
+
+ v['payment_default_id']=shop.payment_default_id.id
+
+ return {'value':v}
+
+
+When editing the shop_id form field, the onchange_shop_id method of the sale_order object is called and returns a dictionary where the 'value' key contains a dictionary of the new value to use in the 'project_id', 'pricelist_id' and 'payment_default_id' fields.
+
+Note that it is possible to change more than just the values of
+fields. For example, it is possible to change the value of some fields
+and the domain of other fields by returning a value of the form:
+return {'domain': d, 'value': value}
+
+:returns: a dictionary with any mix of the following keys:
+
+ ``domain``
+ A mapping of ``{field: domain}``.
+
+ The returned domains should be set on the fields instead of the
+ default ones.
+
+ ``value``
+ A mapping of ``{field: value}}``, the values will be set on the
+ corresponding fields and may trigger new onchanges or attrs
+ changes
+
+ ``warning`` A dict with the keys ``title`` and ``message``. Both
+ are mandatory. Indicate that an error message should be
+ displayed to the user.
--- /dev/null
+================
+Menu and Actions
+================
+
+Menus
+=====
+
+Here's the template of a menu item :
+::
+
+ <menuitem id="menuitem_id"
+ name="Position/Of/The/Menu/Item/In/The/Tree"
+ action="action_id"
+ icon="NAME_FROM_LIST"
+ groups="groupname"
+ sequence="<integer>"/>
+
+Where
+
+ * id specifies the identifier of the menu item in the menu items table. This identifier must be unique. Mandatory field.
+ * name defines the position of the menu item in the menu hierarchy. Elements are separated by slashes ("/"). A menu item name with no slash in its text is a top level menu. Mandatory field.
+ * action specifies the identifier of the action that must have been defined in the action table (ir.actions.act_window). Note that this field is not mandatory : you can define menu elements without associating actions to them. This is useful when defining custom icons for menu elements that will act as folders (for example this is how custom icons for "Projects", "Human Resources" in OpenERP are defined).
+ * icon specifies which icon will be displayed for the menu item using the menu item. The default icon is STOCK_OPEN.
+ - The available icons are : STOCK_ABOUT, STOCK_ADD, STOCK_APPLY, STOCK_BOLD, STOCK_CANCEL, STOCK_CDROM, STOCK_CLEAR, STOCK_CLOSE, STOCK_COLOR_PICKER, STOCK_CONNECT, STOCK_CONVERT, STOCK_COPY, STOCK_CUT, STOCK_DELETE, STOCK_DIALOG_AUTHENTICATION, STOCK_DIALOG_ERROR, STOCK_DIALOG_INFO, STOCK_DIALOG_QUESTION, STOCK_DIALOG_WARNING, STOCK_DIRECTORY, STOCK_DISCONNECT, STOCK_DND, STOCK_DND_MULTIPLE, STOCK_EDIT, STOCK_EXECUTE, STOCK_FILE, STOCK_FIND, STOCK_FIND_AND_REPLACE, STOCK_FLOPPY, STOCK_GOTO_BOTTOM, STOCK_GOTO_FIRST, STOCK_GOTO_LAST, STOCK_GOTO_TOP, STOCK_GO_BACK, STOCK_GO_DOWN, STOCK_GO_FORWARD, STOCK_GO_UP, STOCK_HARDDISK, STOCK_HELP, STOCK_HOME, STOCK_INDENT, STOCK_INDEX, STOCK_ITALIC, STOCK_JUMP_TO, STOCK_JUSTIFY_CENTER, STOCK_JUSTIFY_FILL, STOCK_JUSTIFY_LEFT, STOCK_JUSTIFY_RIGHT, STOCK_MEDIA_FORWARD, STOCK_MEDIA_NEXT, STOCK_MEDIA_PAUSE, STOCK_MEDIA_PLAY, STOCK_MEDIA_PREVIOUS, STOCK_MEDIA_RECORD, STOCK_MEDIA_REWIND, STOCK_MEDIA_STOP, STOCK_MISSING_IMAGE, STOCK_NETWORK, STOCK_NEW, STOCK_NO, STOCK_OK, STOCK_OPEN, STOCK_PASTE, STOCK_PREFERENCES, STOCK_PRINT, STOCK_PRINT_PREVIEW, STOCK_PROPERTIES, STOCK_QUIT,STOCK_REDO, STOCK_REFRESH, STOCK_REMOVE, STOCK_REVERT_TO_SAVED, STOCK_SAVE, STOCK_SAVE_AS, STOCK_SELECT_COLOR, STOCK_SELECT_FONT, STOCK_SORT_ASCENDING, STOCK_SORT_DESCENDING, STOCK_SPELL_CHECK, STOCK_STOP, STOCK_STRIKETHROUGH, STOCK_UNDELETE, STOCK_UNDERLINE, STOCK_UNDO, STOCK_UNINDENT, STOCK_YES, STOCK_ZOOM_100, STOCK_ZOOM_FIT, STOCK_ZOOM_IN, STOCK_ZOOM_OUT, terp-account, terp-crm, terp-mrp, terp-product, terp-purchase, terp-sale, terp-tools, terp-administration, terp-hr, terp-partner, terp-project, terp-report, terp-stock
+ * **groups** specifies which group of user can see the menu item (example : groups="admin"). See section " Management of Access Rights" for more information. Multiple groups should be separated by a ',' (example: groups="admin,user")
+ * **sequence** is an integer that is used to sort the menu item in the menu. The higher the sequence number, the downer the menu item. This argument is not mandatory: if sequence is not specified, the menu item gets a default sequence number of 10. Menu items with the same sequence numbers are sorted by order of creation (*_order =* "*sequence,id*").
+
+Example
+-------
+
+In server/bin/addons/sale/sale_view.xml, we have, for example
+::
+
+ <menuitem name="Sales Management/Sales Order/Sales Order in Progress" id="menu_action_order_tree4" action="action_order_tree4"/>
+
+To change the icon of menu item :
+::
+
+ * Highlight the menu with the icon you want to change.
+ * Select the "Switch to list/form" option from the "Form" menu. This will take you to the Menu editor.
+ * From here you can change the icon of the selected menu.
+
+
+Actions
+=======
+
+Introduction
+------------
+
+The actions define the behavior of the system in response to the actions of the users ; login of a new user, double-click on an invoice, click on the action button, ...
+
+There are different types of simple actions:
+
+ * Window: Opening of a new window
+ * Report: The printing of a report
+ o Custom Report: The personalized reports
+ o RML Report: The XSL:RML reports
+ * Wizard: The beginning of a Wizard
+ * Execute: The execution of a method on the server side
+ * Group: Gather some actions in one group
+
+The actions are used for the following events;
+
+ * User connection,
+ * The user double-clicks on the menu,
+ * The user clicks on the icon 'print' or 'action'.
+
+Example of events
+-----------------
+
+In OpenERP, all the actions are described and not configured. Two examples:
+
+ * Opening of a window when double-clicking in the menu
+ * User connection
+
+Opening of the menu
++++++++++++++++++++
+
+When the user open the option of the menu "Operations > Partners > Partners Contact", the next steps are done to give the user information on the action to undertake.
+
+ 1. Search the action in the IR.
+ 2. Execution of the action
+ 1. If the action is the type Opening the Window; it indicates to the user that a new window must be opened for a selected object and it gives you the view (form or list) and the filed to use (only the pro-forma invoice).
+ 2. The user asks the object and receives information necessary to trace a form; the fields description and the XML view.
+
+User connection
++++++++++++++++
+
+When a new user is connected to the server, the client must search the action to use for the first screen of this user. Generally, this action is: open the menu in the 'Operations' section.
+
+The steps are:
+
+ 1. Reading of a user file to obtain ACTION_ID
+ 2. Reading of the action and execution of this one
+
+The fields
+++++++++++
+
+**Action Name**
+ The action name
+**Action Type**
+ Always 'ir.actions.act_window'
+**View Ref**
+ The view used for showing the object
+**Model**
+ The model of the object to post
+**Type of View**
+ The type of view (Tree/Form)
+**Domain Value**
+ The domain that decreases the visible data with this view
+
+The view
+--------
+The view describes how the edition form or the data tree/list appear on screen. The views can be of 'Form' or 'Tree' type, according to whether they represent a form for the edition or a list/tree for global data viewing.
+
+A form can be called by an action opening in 'Tree' mode. The form view is generally opened from the list mode (like if the user pushes on 'switch view').
+
+The domain
+----------
+
+This parameter allows you to regulate which resources are visible in a selected view.(restriction)
+
+For example, in the invoice case, you can define an action that opens a view that shows only invoices not paid.
+
+The domains are written in python; list of tuples. The tuples have three elements;
+
+ * the field on which the test must be done
+ * the operator used for the test (<, >, =, like)
+ * the tested value
+
+For example, if you want to obtain only 'Draft' invoice, use the following domain; [('state','=','draft')]
+
+In the case of a simple view, the domain define the resources which are the roots of the tree. The other resources, even if they are not from a part of the domain will be posted if the user develop the branches of the tree.
+
+Window Action
+-------------
+
+Actions are explained in more detail in section "Administration Modules - Actions". Here's the template of an action XML record :
+::
+
+ <record model="ir.actions.act_window" id="action_id_1">
+ <field name="name">action.name</field>
+ <field name="view_id" ref="view_id_1"/>
+ <field name="domain">["list of 3-tuples (max 250 characters)"]</field>
+ <field name="context">{"context dictionary (max 250 characters)"}</field>
+ <field name="res_model">Open.object</field>
+ <field name="view_type">form|tree</field>
+ <field name="view_mode">form,tree|tree,form|form|tree</field>
+ <field name="usage">menu</field>
+ <field name="target">new</field>
+ </record>
+
+**Where**
+
+ * **id** is the identifier of the action in the table "ir.actions.act_window". It must be unique.
+ * **name** is the name of the action (mandatory).
+ * **view_id** is the name of the view to display when the action is activated. If this field is not defined, the view of a kind (list or form) associated to the object res_model with the highest priority field is used (if two views have the same priority, the first defined view of a kind is used).
+ * **domain** is a list of constraints used to refine the results of a selection, and hence to get less records displayed in the view. Constraints of the list are linked together with an AND clause : a record of the table will be displayed in the view only if all the constraints are satisfied.
+ * **context** is the context dictionary which will be visible in the view that will be opened when the action is activated. Context dictionaries are declared with the same syntax as Python dictionaries in the XML file. For more information about context dictionaries, see section " The context Dictionary".
+ * **res_model** is the name of the object on which the action operates.
+ * **view_type** is set to form when the action must open a new form view, and is set to tree when the action must open a new tree view.
+ * **view_mode** is only considered if view_type is form, and ignored otherwise. The four possibilities are :
+ - **form,tree** : the view is first displayed as a form, the list view can be displayed by clicking the "alternate view button" ;
+ - **tree,form** : the view is first displayed as a list, the form view can be displayed by clicking the "alternate view button" ;
+ - **form** : the view is displayed as a form and there is no way to switch to list view ;
+ - **tree** : the view is displayed as a list and there is no way to switch to form view.
+
+(version 5 introduced **graph** and **calendar** views)
+
+ * **usage** is used [+ ***TODO*** +]
+ * **target** the view will open in new window like wizard.
+ * **context** will be passed to the action itself and added to its global context
+
+ .. code-block:: xml
+
+ <record model="ir.actions.act_window" id="a">
+ <field name="name">account.account.tree1</field>
+ <field name="res_model">account.account</field>
+ <field name="view_type">tree</field>
+ <field name="view_mode">form,tree</field>
+ <field name="view_id" ref="v"/>
+ <field name="domain">[('code','=','0')]</field>
+ <field name="context">{'project_id': active_id}</field>
+ </record>
+
+
+
+They indicate at the user that he has to open a new window in a new 'tab'.
+
+Administration > Custom > Low Level > Base > Action > Window Actions
+
+.. figure:: images/module_base_action_window.png
+ :scale: 85
+ :align: center
+
+Examples of actions
++++++++++++++++++++
+
+This action is declared in server/bin/addons/project/project_view.xml.
+::
+
+ <record model="ir.actions.act_window" id="open_view_my_project">
+ <field name="name">project.project</field>
+ <field name="res_model">project.project</field>
+ <field name="view_type">tree</field>
+ <field name="domain">[('parent_id','=',False), ('manager', '=', uid)]</field>
+ <field name="view_id" ref="view_my_project" />
+ </record>
+
+This action is declared in server/bin/addons/stock/stock_view.xml.
+::
+
+ <record model="ir.actions.act_window" id="action_picking_form">
+ <field name="name">stock.picking</field>
+ <field name="res_model">stock.picking</field>
+ <field name="type">ir.actions.act_window</field>
+ <field name="view_type">form</field>
+ <field name="view_id" ref="view_picking_form"/>
+ <field name="context">{'contact_display': 'partner'}</field>
+ </record>
+
+Url Action
+-----------
+
+
+Wizard Action
+-------------
+
+Here's an example of a .XML file that declares a wizard.
+::
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ <wizard string="Employee Info"
+ model="hr.employee"
+ name="employee.info.wizard"
+ id="wizard_employee_info"/>
+ </data>
+ </openerp>
+
+A wizard is declared using a wizard tag. See "Add A New Wizard" for more information about wizard XML.
+
+also you can add wizard in menu using following xml entry
+::
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ <wizard string="Employee Info"
+ model="hr.employee"
+ name="employee.info.wizard"
+ id="wizard_employee_info"/>
+ <menuitem
+ name="Human Resource/Employee Info"
+ action="wizard_employee_info"
+ type="wizard"
+ id="menu_wizard_employee_info"/>
+ </data>
+ </openerp>
+
+
+Report Action
+-------------
+
+Report declaration
+++++++++++++++++++
+
+Reports in OpenERP are explained in chapter "Reports Reporting". Here's an example of a XML file that declares a RML report :
+::
+
+ <?xml version="1.0"?>
+ <openerp>
+ <data>
+ <report id="sale_category_print"
+ string="Sales Orders By Categories"
+ model="sale.order"
+ name="sale_category.print"
+ rml="sale_category/report/sale_category_report.rml"
+ menu="True"
+ auto="False"/>
+ </data>
+ </openerp>
+
+A report is declared using a **report tag** inside a "data" block. The different arguments of a report tag are :
+
+ * **id** : an identifier which must be unique.
+ * **string** : the text of the menu that calls the report (if any, see below).
+ * **model** : the OpenERP object on which the report will be rendered.
+ * **rml** : the .RML report model. Important Note : Path is relative to addons/ directory.
+ * **menu** : whether the report will be able to be called directly via the client or not. Setting menu to False is useful in case of reports called by wizards.
+ * **auto** : determines if the .RML file must be parsed using the default parser or not. Using a custom parser allows you to define additional functions to your report.
+
+
+Security
+========
+
+Three concepts are differentiated into OpenERP;
+
+ 1. The users: person identified by his login/password
+ 2. The groups: define the access rights of the resources
+ 3. The roles: determine the roles/duties of the users
+
+.. figure:: images/module_base_user.png
+ :scale: 120
+ :align: center
+
+
+**The users**
+
+They represent physical persons. These are identified with a login and a password. A user may belong to several groups and may have several roles.
+
+A user must have an action set up. This action is executed when the user connects to the program with his login and password. An example of action would be to open the menu at 'Operations'.
+
+The preferences of the user are available with the preference icon. You can, for example, through these preferences, determine the working language of this user. English is set by default.
+
+A user can modify his own preferences while he is working with OpenERP. To do that, he clicks on this menu: User > Preferences. The OpenERP administrator can also modify some preferences of each and every user.
+
+**The groups**
+
+The groups determine the access rights to the different resources. There are three types of right:
+
+ * The writing access: recording & creation,
+ * The reading access: reading of a file,
+ * The execution access: the buttons of workflows or wizards.
+
+A user can belong to several groups. If he belongs to several groups, we always use the group with the highest rights for a selected resource.
+
+**The roles**
+
+The roles define a hierarchical structure in tree. They represent the different jobs/roles inside the company. The biggest role has automatically the rights of all the inferior roles.
+
+**Example:**
+
+CEO
+
+ + Technical manager
+
+ - Chief of projects
+
+ - Developers
+ - Testers
+
+ + Commercial manager
+
+ - Salesmen
+ - ...
+
+If we want to validate the test of a program (=role Testers), it may be done by a user having one of the following roles: Testers, Chief of the project, Technical manager, CEO.
+
+The roles are used for the transition of Workflow actions into confirmation, choice or validation actions. Their implications will be detailed in the Workflow section.
+
+
+Menu Access
+-----------
+
+It's easy (but risky) to grant grained access to menu based on the user's groups.
+
+First of all, you should know that if a menu is not granted to any group then it is accessible to everybody ! If you want to grant access to some groups just go to **Menu > Administration > Security > Define access to Menu-items** and select the groups that can use this menu item.
+
+.. figure:: images/grant_access.png
+ :scale: 85
+ :align: center
+
+Beware ! If the Administrator does not belong to one of the group, he will not be able to reach this menu again.
--- /dev/null
+
+==========================
+Example of module creation
+==========================
+
+Getting the skeleton directory
+++++++++++++++++++++++++++++++
+
+Create a ``travel`` directory, that will contain our addon. Create **__init__.py** file and **__openerp__.py** files.
+
+Edit the **__openerp__.py** module configuration file:
+
+.. code-block:: python
+
+ {
+ "name" : "Travel agency module",
+ "version" : "1.1",
+ "author" : "Tiny",
+ "category" : "Generic Modules/Others",
+ "website" : "http://www.openerp.com",
+ "description": "A module to manage hotel bookings and a few other useful features.",
+ "depends" : ["base"],
+ "init_xml" : [],
+ "update_xml" : ["travel_view.xml"],
+ "active": True,
+ "installable": True
+ }
+
+Changing the main module file
++++++++++++++++++++++++++++++
+
+Now you need to update the travel.py script to suit the needs of your module.
+We suggest you follow the Flash tutorial for this or download the travel agency
+module from the 20 minutes tutorial page. ::
+
+ The documentation below is overlapping the two next step in this wiki tutorial,
+ so just consider them as a help and head towards the next two pages first...
+
+The travel.py file should initially look like this:
+
+.. code-block:: python
+
+ from osv import osv, fields
+
+ class travel_hostel(osv.osv):
+ _name = 'travel.hostel'
+ _inherit = 'res.partner'
+ _columns = {
+ 'rooms_id': fields.one2many('travel.room', 'hostel_id', 'Rooms'),
+ 'quality': fields.char('Quality', size=16),
+ }
+ _defaults = {
+ }
+ travel_hostel()
+
+Ideally, you would copy that bunch of code several times to create all the
+entities you need (travel_airport, travel_room, travel_flight). This is what
+will hold the database structure of your objects, but you don't really need to
+worry too much about the database side. Just filling this file will create the
+system structure for you when you install the module.
+
+Customizing the view
+++++++++++++++++++++
+
+You can now move on to editing the views. To do this, edit the custom_view.xml file. It should first look like this:
+
+.. code-block:: xml
+
+ <openerp>
+ <data>
+ <record model="res.groups" id="group_compta_user">
+ <field name="name">grcompta</field>
+ </record>
+ <record model="res.groups" id="group_compta_admin">
+ <field name="name">grcomptaadmin</field>
+ </record>
+ <menuitem name="Administration" groups="admin,grcomptaadmin"
+ icon="terp-stock" id="menu_admin_compta"/>
+ </data>
+ </openerp>
+
+This is, as you can see, an example taken from an accounting system (French
+people call accounting "comptabilité", which explains the compta bit).
+
+Defining a view is defining the interfaces the user will get when accessing
+your module. Just defining a bunch of fields here should already get you
+started on a complete interface. However, due to the complexity of doing it
+right, we recommend, once again, that download the travel agency module example from this link http://www.openerp.com/download/modules/5.0/.
+
+Next you should be able to create different views using other files to separate
+them from your basic/admin view.
into one of the WSGI entry points of the server.
.. versionadded:: 6.1
-
:orphan:
+========================================
OpenERP Server Developers Documentation
========================================
OpenERP Server Documentation
-'''''''''''''''''''''''''''''
+''''''''''''''''''''''''''''
.. toctree::
:maxdepth: 2
01_getting_started
02_architecture
+ 03_module_dev
99_test_framework
+OPenERP Server API
+''''''''''''''''''
+
+.. toctree::
+ :maxdepth: 1
+
+ api/core
+ api/models
+ api/startup
+
Main revisions and new features
-++++++++++++++++++++++++++++++++
+'''''''''''''''''''''''''''''''
.. toctree::
:maxdepth: 1
projects / odoo / odoo.git / commitdiff