The TabularEditor
=================

Traits 3.0 introduces a new editor, called the **TabularEditor**, located in the
*traitsui.wx.extras.tabular_editor* module that can be used for many
of the same purposes as the existing **TableEditor**. However, while similar in
function, each editor has its own particular strengths and weaknesses.

Some of the strengths of the new **TabularEditor** are:

- **Very fast**. The editor uses a *virtual* model which only accesses data
  from the underlying data model as needed. For example, if you have a million
  element array, but can only view 50 rows at a time, the editor will only
  request 50 rows at a time.

- **Very flexible data model**. The editor uses a new adapter model for
  interfacing with your underlying data that allows it to easily deal with many
  types of data representation: from lists of objects, to arrays of numbers, to
  tuples of tuples, and many other formats as well.

- **Supports a useful set of data operations**. The editor includes built-in
  support for a number of useful data operations, including:

  - Moving the selection up and down using the keyboard arrow keys.
  - Moving rows up and down using the keyboard arrow keys.
  - Inserting and deleting rows using the keyboard.
  - Begin editing table rows using the keyboard.
  - Drag and drop of table items to and from the editor, including support for
    both *copy* and *move* operations for single or multiple table items.

- **Visually appealing**. The editor, in general, uses the underlying OS's
  native table or grid control, and as a result often looks better than the
  control used by the **TableEditor**.

- **Supports displaying text and images in any cell**. Note however that
  the images displayed must all be the same size for optimal results.

Some of the weaknesses of the **TabularEditor** compared to the **TableEditor**
are:

- **Not as full-featured**. The **TableEditor** includes support for arbitrary
  data filters and searches and different types of data sorting. The differences
  here may narrow over time as new features get added to the **TabularEditor**.

- **Limited data editing capabilities**: The **TabularEditor** only supports
  editing textual values, unlike the **TableEditor**, which supports a wide
  variety of column editors and can be extended with more as needed. This is
  due to limitations of the underlying native OS control used by the editor.

Setting up a **TabularEditor** for use in a Traits UI is divided into two main
parts:

- Configuring the **TabularEditor** object.
- Creating a suitable adapter (or adapters) for use with the editor.

We'll start off first with a description of the **TabularEditor** class, and
describe the adapter interface in a later section.

The TabularEditor Class
-----------------------

The **TabularEditor** class defines a large number of traits which are used to
configure the editor. We'll divide the set of traits into several categories,
and describe each in turn.

Visual Traits
-------------

show_titles
    A boolean value which specifies whether or not column headers should be
    displayed at the top of the table. It defaults to **True**.

horizontal_lines
    A boolean value which specifies whether or not horizontal lines should be
    drawn between rows in the table. It defaults to **True**.

vertical_lines
    A boolean value which specifies whether or not vertical lines should be
    drawn between columns in the table. It defaults to **True**.

Control Traits
--------------

editable
    A boolean value that specifies whether or not the user is allowed to edit
    data in the table. It defaults to **True**.

multi_select
    A boolean value that specifies whether or not the user is allowed to select
    multiple rows in the table at once. It defaults to **False**.

operations
    A list of strings that specify what operations the user is allowed to
    perform on items in the table. The possible values are:

    - **delete**: The user can delete table rows.
    - **insert**: The user can insert new table rows at any position in the
      table.
    - **append**: The user can append new table rows to the end of the table.
    - **edit**: The user can edit the contents of table rows.
    - **move**: The user can move table rows within the table.

    You should include in the list all operations that you want to allow the
    user to perform (e.g. *['delete','insert','append']*).

drag_move
    A boolean value that specifies whether *drag move* operations are allowed
    (**True**), or should all drag operations be treated as *drag copy*
    operations (**False**). The default is **False**.

adapter
    An instance of **TabularAdapter** that the editor uses to interface to the
    underlying **Item** data supplied to the editor. This is normally an
    instance of a subclass of **TabularAdapter** specially written for the type
    of data being edited. This will be described more fully in the
    **TabularAdapter** section.

adapter_name
    An optional string that specifies the extended trait name of a trait that
    contains the **TabularAdapter** the editor should used. If the value of the
    trait changes while the editor is active, the editor will automatically
    start using the new adapter. Normally you will use either the *adapter*
    trait *or* the *adapter_name* trait, but not both. However, it is possible
    to use both together if needed.

images
    An optional list of **ImageResource** objects describing a set of images
    that can be displayed in the table's cells. Specifying a set here allows you
    to refer to the images by name within the adapter. However, it is also
    possible for the adapter to supply the **ImageResource** object directly
    for any image it wants to display.

Event Handling Traits
---------------------

selected
    An optional string that specifies the extended trait name of a trait that
    contains the currently selected table items. For a single-select mode
    editor, this should be a scalar trait, and for a multi-select mode editor,
    it should be a list trait. The type of the trait should be the same as the
    type of data being displayed in the table. This trait can be used to both
    set and get the current table selection.

selected_row
    An optional string that specifies the extended trait name of a trait that
    contains the currently selected table item indices. For a single-select mode
    editor this should be an **Int** value, and for a multi-select mode editor
    it should be a **List(Int)** value. This trait can be used to both set and
    get the current table selection.

activated
    An optional string that specifies the extended trait name of a trait that
    contains the currently activated table item. It should be an instance of the
    table item data type. The trait can only be used to get the value of
    the most recently activated table item. An item is activated either by the
    user double-clicking on it or by pressing the **Enter** key when the item
    is selected.

activated_row
    An optional string that specifies the extended trait name of a trait that
    contains the currently activated table item index. It should be an **Int**
    value. The trait can only be used to get the index of the most recently
    activated table item. An item is activated either by the user
    double-clicking on it or by pressing the **Enter** key when the item is
    selected.

clicked
    An optional string that specifies the extended trait name of a trait that
    contains a **TabularEditorEvent** object containing the information
    associated with the most recent left mouse button click within the editor.
    The trait can only be used to get the **TabularEditorEvent** object. The
    **TabularEditorEvent** object is described in the next section.

dclicked
    An optional string that specifies the extended trait name of a trait that
    contains a **TabularEditorEvent** object containing the information
    associated with the most recent left mouse button double-click within the
    editor. The trait can only be used to get the **TabularEditorEvent**
    object. The **TabularEditorEvent** object is described in the next section.

right_clicked
    An optional string that specifies the extended trait name of a trait that
    contains a **TabularEditorEvent** object containing the information
    associated with the most recent right mouse button click within the editor.
    The trait can only be used to get the **TabularEditorEvent** object. The
    **TabularEditorEvent** object is described in the next section.

right_dclicked
    An optional string that specifies the extended trait name of a trait that
    contains a **TabularEditorEvent** object containing the information
    associated with the most recent right mouse button double-click within the
    editor. The trait can only be used to get the **TabularEditorEvent**
    object. The **TabularEditorEvent** object is described in the next section.

The TabularEditorEvent Class
----------------------------

Objects of the **TabularEditorEvent** class contain information related to a
mouse button click that occurs within the editor. The class has no methods,
but does define the following traits:

row
    An integer specifying the index of the table item that was clicked on.

column
    A value specifying the column id of the table cell that was clicked on.
    This value will correspond to the second element of the tuple used to
    define the column in the **TabularEditor** adapter supplied to the editor.
    This will be described in a later section.

item
    The data item corresponding to the table row that was clicked on. The type
    of this data will depend upon the type of data contained in the underlying
    data model.

The TabularEditor User Interface
--------------------------------

Depending upon how you have configured the **TabularEditor** and its associated
adapter, the following user interface features may be available:

- **Up arrow**: Move the selection up one line.
- **Down arrow**: Move the selection down one line.
- **Page down**: Append a new item to the end of the list (*'append'*).
- **Left arrow**: Move the current selection up one line (*'move'*).
- **Right arrow**: Move the current selection down one line (*'move'*).
- **Backspace, Delete**: Delete all items in the current selection from the
  list (*'delete'*).
- **Enter, Escape**: Edit the current selection (*'edit'*).
- **Insert**: Insert a new item before the current selection (*'insert'*).

In the preceding list, the values in parentheses refer to the operation that
must be included in the **TabularEditor** *operations* trait in order for the
specified key to have any effect.

The *append*, *move*, *edit* and *insert* operations are only available if a
single item is selected. The *delete* operation works when the selection has
one or more items.

Depending upon how the **TabularEditor** and adapter are specified, drag and
drop operations may also be available. If multiple items are selected and the
user drags one of the selected items, all selected items will be included in
the drag operation. If the user drags a non-selected item, only that item will
be dragged.

The editor also supports both *drag-move* and *drag-copy* semantics. A
*drag-move* operation means that the dragged items will be sent to the target
and removed from the list data. A *drag-copy* operation means that the
dragged items will be sent to the target, but will *not* be deleted from the
**Item** data. Note that in a *drag-copy* operation, if you do not want the
target to receive the same data contained in the list, then you must return a
copy or clone of the data when the editor requests the drag data from the
adapter.

You can prevent *drag-move* operations by making sure that the
**TabularEditor** *drag_move* trait is set to **False** (the default).

Note that the default operation when a user begins a drag operation is
*drag_move*. A *drag-copy* operation occurs when the user also holds the
*Ctrl* key down during the drag operation (the mouse pointer changes to indicate
the change in drag semantics). If *drag_move* operations are disabled by
setting the **TabularEditor** *drag_move* trait to **False**, any *drag-move*
operation is automatically treated as a *drag_copy*.

The tabular editor only allows the user to edit the first column of data in the
table (a restriction imposed by the underlying OS widget). If the *'edit'*
operation is enabled, the user can begin editing the first column either by
clicking on the row twice, or by selecting the row and pressing the **Enter** or
**Escape** key.

Finally, the user can resize columns in the table by dragging the column title
dividers left or right with the mouse. Once resized in this manner, the column
remains that size until the user resizes the column again. This is true
even if you assigned a dynamic width to the column (see the **TabularAdapter**
section for more information about what this means). If the user wants to allow
a previously user-sized column to be restored to its original developer
specified size again, they must right-click on the column title to *release*
its user specified size and restore its original size.

If you enable *persistence* for the editor by specifying a non-empty *id* trait
for the editor's **Item** and **View** objects, any user specified column
widths will be saved across application sessions.

The TabularAdapter Class
------------------------

The power and flexibility of the tabular editor is mostly a result of the
**TabularAdapter** class, which is the base class from which all tabular editor
adapters must be derived.

The **TabularEditor** object interfaces between the underlying toolkit widget
and your program, while the **TabularAdapter** object associated with the
editor interfaces between the editor and your data.

The design of the **TabularAdapter** base class is such that it tries to make
simple cases simple and complex cases possible. How it accomplishes this is what
we'll be discussing in the following sections.

The TabularAdapter *columns* Trait
----------------------------------

First up is the **TabularAdapter** *columns* trait, which is a list of values
which define, in presentation order, the set of columns to be displayed by the
associated **TabularEditor**.

Each entry in the *columns* list can have one of two forms:

- string
- ( string, any )

where *string* is the user interface name of the column (which will appear in
the table column header) and *any* is any value that you want to use to
identify that column to your adapter. Normally this value is either a trait name
or an integer index value, but it can be any value you want. If only *string*
is specified, then *any* is the index of the *string* within *columns*.

For example, say you want to display a table containing a list of tuples, each
of which has three values: a name, an age, and a weight. You could then use
the following value for the *columns* trait::

    columns = [ 'Name', 'Age', 'Weight' ]

By default, the *any* values (also referred to in later sections as the
*column ids*) for the columns will be the corresponding tuple index values.

Say instead that you have a list of **Person** objects, with *name*, *age* and
*weight* traits that you want to display in the table. Then you could use the
following *columns* value instead::

    columns = [ ( 'Name',   'name' ),
                ( 'Age',    'age' ),
                ( 'Weight', 'weight' ) ]

In this case, the *column ids* are the names of the traits you want to display
in each column.

Note that it is possible to dynamically modify the contents of the *columns*
trait while the **TabularEditor** is active. The **TabularEditor** will
automatically modify the table to show the new set of defined columns.

The Core TabularAdapter Interface
---------------------------------

In this section, we'll describe the core interface to the **TabularAdapter**
class. This is the actual interface used by the **TabularEditor** to access your
data and display attributes. In the most complex data representation cases,
these are the methods that you must override in order to have the greatest
control over what the editor sees and does.

However, the base **TabularAdapter** class provides default implementations for
all of these methods. In subsequent sections, we'll look at how these default
implementations provide simple means  of customizing the adapter to your needs.
But for now, let's start by covering the details of the core interface itself.

To reduce the amount of repetition, we'll use the following definitions in all
of the method argument lists that follow in this section:

object
    The object whose trait is being edited by the **TabularEditor**.

trait
    The name of the trait the **TabularEditor** is editing.

row
    The row index (starting with 0) of a table item.

column
    The column index (starting with 0) of a table column.

The adapter interface consists of a number of methods which can be divided into
two main categories: those which are sensitive to the type of a particular table
item, and those which are not. We'll begin with the methods that are
sensitive to an item's type:

get_alignment ( object, trait, column )
    Returns the alignment style to use for a specified column.

    The possible values that can be returned are: *'left'*, *'center'* or
    *'right'*. All table items share the same alignment for a specified column.

get_width ( object, trait, column )
    Returns the width to use for a specified column. The result can either be a
    float or integer value.

    If the value is <= 0, the column will have a *default* width, which is the
    same as specifying a width of *0.1*.

    If the value is > 1.0, it is converted to an integer and the result is
    the width of the column in pixels. This is referred to as a *fixed width*
    column.

    If the value is a float such that 0.0 < value <= 1.0, it is treated as the
    *unnormalized fraction of the available space* that is to be assigned to the
    column. What this means requires a little explanation.

    To arrive at the size in pixels of the column at any given time, the editor
    adds together all of the *unnormalized fraction* values returned for all
    columns in the table to arrive at a total value. Each
    *unnormalized fraction* is then divided by the total to create a
    *normalized fraction*. Each column is then assigned an amount of space in
    pixels equal to the maximum of 30 or its *normalized fraction* multiplied
    by the *available space*. The *available space* is defined as the actual
    width of the table minus the width of all *fixed width* columns. Note that
    this calculation is performed each time the table is resized in the user
    interface, thus allowing columns of this type to increase or decrease their
    width dynamically, while leaving *fixed width* columns unchanged.

get_can_edit ( object, trait, row )
    Returns a boolean value indicating whether the user can edit a specified
    *object.trait[row]* item.

    A **True** result indicates that the value can be edited, while a **False**
    result indicates that it cannot.

get_drag ( object, trait, row )
    Returns the value to be *dragged* for a specified *object.trait[row]* item.
    A result of **None** means that the item cannot be dragged. Note that the
    value returned does not have to be the actual row item. It can be any
    value that you want to drag in its place. In particular, if you want the
    drag target to receive a copy of the row item, you should return a copy or
    clone of the item in its place.

    Also note that if multiple items are being dragged, and this method returns
    **None** for any item in the set, no drag operation is performed.

get_can_drop ( object, trait, row, value )
    Returns whether the specified *value* can be dropped on the specified
    *object.trait[row]* item. A value of **True** means the *value* can be
    dropped; and a value of **False** indicates that it cannot be dropped.

    The result is used to provide the user positive or negative drag feedback
    while dragging items over the table. *Value* will always be a single value,
    even if multiple items are being dragged. The editor handles multiple drag
    items by making a separate call to *get_can_drop* for each item being
    dragged.

get_dropped ( object, trait, row, value )
    Returns how to handle a specified *value* being dropped on a specified
    *object.trait[row]* item. The possible return values are:

    - **'before'**: Insert the specified *value* before the dropped on item.
    - **'after'**: Insert the specified *value* after the dropped on item.

    Note there is no result indicating *do not drop* since you will have already
    indicated that the *object* can be dropped by the result returned from a
    previous call to *get_can_drop*.

get_font ( object, trait, row )
    Returns the font to use for displaying a specified *object.trait[row]* item.

    A result of **None** means use the default font; otherwise a **wx.Font**
    object should be returned. Note that all columns for the specified table row
    will use the font value returned.

get_text_color ( object, trait, row )
    Returns the text color to use for a specified *object.trait[row]* item.

    A result of **None** means use the default text color; otherwise a
    **wx.Colour** object should be returned. Note that all columns for the
    specified table row will use the text color value returned.

get_bg_color ( object, trait, row )
    Returns the background color to use for a specified *object.trait[row]*
    item.

    A result of **None** means use the default background color; otherwise a
    **wx.Colour** object should be returned. Note that all columns for the
    specified table row will use the background color value returned.

get_image ( object, trait, row, column )
    Returns the image to display for a specified *object.trait[row].column*
    item.

    A result of **None** means no image will be displayed in the specified table
    cell. Otherwise the result should either be the name of the image, or an
    **ImageResource** object specifying the image to display.

    A name is allowed in the case where the image is specified in the
    **TabularEditor** *images* trait. In that case, the name should be the same
    as the string specified in the **ImageResource** constructor.

get_format ( object, trait, row, column )
    Returns the Python formatting string to apply to the specified
    *object.trait[row].column* item in order to display it in the table.

    The result can be any Python string containing exactly one Python formatting
    sequence, such as *'%.4f'* or *'(%5.2f)'*.

get_text ( object, trait, row, column )
    Returns a string containing the text to display for a specified
    *object.trait[row].column* item.

    If the underlying data representation for a specified item is not a string,
    then it is your responsibility to convert it to one before returning it as
    the result.

set_text ( object, trait, row, text ):
    Sets the value for the specified *object.trait[row].column* item to the
    string specified by *text*.

    If the underlying data does not store the value as text, it is your
    responsibility to convert *text* to the correct representation used. This
    method is called when the user completes an editing operation on a table
    cell.

get_tooltip ( object, trait, row, column )
    Returns a string containing the tooltip to display for a specified
    *object.trait[row].column* item.

    You should return the empty string if you do not wish to display a tooltip.

The following are the remaining adapter methods, which are not sensitive to the
type of item or column data:

get_item ( object, trait, row )
    Returns the specified *object.trait[row]* item.

    The value returned should be the value that exists (or *logically* exists)
    at the specified *row* in your data. If your data is not really a list or
    array, then you can just use *row* as an integer *key* or *token* that
    can be used to retrieve a corresponding item. The value of *row* will
    always be in the range: 0 <= row < *len( object, trait )* (i.e. the result
    returned by the adapter *len* method).

len ( object, trait )
    Returns the number of row items in the specified *object.trait* list.

    The result should be an integer greater than or equal to 0.

delete ( object, trait, row )
    Deletes the specified *object.trait[row]* item.

    This method is only called if the *delete* operation is specified in the
    **TabularEditor** *operation* trait, and the user requests that the item be
    deleted from the table. The adapter can still choose not to delete the
    specified item if desired, although that may prove confusing to the user.

insert ( object, trait, row, value )
    Inserts *value* at the specified *object.trait[row]* index. The specified
    *value* can be:

    - An item being moved from one location in the data to another.
    - A new item created by a previous call to *get_default_value*.
    - An item the adapter previously approved via a call to *get_can_drop*.

    The adapter can still choose not to insert the item into the data, although
    that may prove confusing to the user.

get_default_value ( object, trait )
    Returns a new default value for the specified *object.trait* list.

    This method is called when *insert* or *append* operations are allowed and
    the user requests that a new item be added to the table. The result should
    be a new instance of whatever underlying representation is being used for
    table items.

Creating a Custom TabularAdapter
--------------------------------

Having just taken a look at the core **TabularAdapter** interface, you might now
be thinking that there are an awful lot of methods that need to be specified to
get an adapter up and running. But as we mentioned earlier, **TabularAdapter**
is not an abstract base class. It is a concrete base class with implementations
for each of the methods in its interface. And the implementations are written
in such a way that you will hopefully hardly ever need to override them.

In this section, we'll explain the general implementation style used by these
methods, and how you can take advantage of them in creating your own adapters.

One of the things you probably noticed as you read through the core adapter
interface section is that most of the methods have names of the form:
*get_xxx* or *set_xxx*, which is similar to the familiar *getter/setter* pattern
used when defining trait properties. The adapter interface is purposely defined
this way so that it can expose and leverage a simple set of design rules.

The design rules are followed consistently in the implementations of all of the
adapter methods described in the first section of the core adapter interface, so
that once you understand how they work, you can easily apply the design pattern
to all items in that section. Then, only in the case where the design rules will
not work for your application will you ever have to override any of those
**TabularAdapter** base class method implementations.

So the first thing to understand is that if an adapter method name has the form:
*get_xxx* or *set_xxx* it really is dealing with some kind of trait called
*xxx*, or which contains *xxx* in its name. For example, the *get_alignment*
method retrieves the value of some *alignment* trait defined on the adapter.
In the following discussion we'll simply refer to an attribute name generically
as *attribute*, but you will need to replace it by an actual attribute name
(e.g. *alignment*) in your adapter.

The next thing to keep in mind is that the adapter interface is designed to
easily deal with items that are not all of the same type. As we just said, the
design rules apply to all adapter methods in the first group, which were
defined as methods which are sensitive to an item's type. Item type sensitivity
plays an important part in the design rules, as we will see shortly.

With this in mind, we now describe the simple design rules used by the first
group of methods in the **TabularAdapter** class:

- When getting or setting an adapter attribute, the method first retrieves the
  underlying item for the specified data row. The item, and type (i.e. class) of
  the item, are then used in the next rule.

- The method gets or sets the first trait it finds on the adapter that matches
  one of the following names:

  - *classname_columnid_attribute*
  - *classsname_attribute*
  - *columnid_attribute*
  - *attribute*

  where:

  - *classname* is the name of the class of the item found in the first step, or
    one of its base class names, searched in the order defined by the *mro*
    (**method resolution order**) for the item's class.
  - *columnid* is the column id specified by the developer in the adapter's
    *column* trait for the specified table column.
  - *attribute* is the attribute name as described previously (e.g.
    *alignment*).

Note that this last rule always finds a matching trait, since the
**TabularAdapter** base class provides traits that match the simple *attribute*
form for all attributes these rules apply to. Some of these are simple traits,
while others are properties. We'll describe the behavior of all these *default*
traits shortly.

The basic idea is that rather than override the first group of core adapter
methods, you simply define one or more simple traits or trait properties on your
**TabularAdapter** subclass that provide or accept the specified information.

All of the adapter methods in the first group provide a number of arguments,
such as *object*, *trait*, *row* and *column*. In order to define a trait
property, which cannot be passed this information directly, the adapter always
stores the arguments and values it computes in the following adapter traits,
where they can be easily accessed by a trait getter or setter method:

- *row*: The table row being accessed.
- *column*: The column id of the table column being accessed (not its index).
- *item*: The data item for the specified table row (i.e. the item determined
  in the first step described above).
- *value*: In the case of a *set_xxx* method, the value to be set; otherwise it
  is **None**.

As mentioned previously, the **TabularAdapter** class provides trait definitions
for all of the attributes these rules apply to. You can either use the
default values as they are, override the default, set a new value, or completely
replace the trait definition in a subclass. A description of the default trait
implementation for each attribute is as follows:

default_value = Any( '' )
    The default value for a new row.

    The default value is the empty string, but you will normally need to assign
    a different (default) value.

format = Str( '%s' )
    The default Python formatting string for a column item.

    The default value is *'%s'* which will simply convert the column item to a
    displayable string value.

text = Property()
    The text to display for the column item.

    The implementation of the property checks the type of the column's
    *column id*:

    - If it is an integer, it returns *format%item[column_id]*.
    - Otherwise, it returns *format%item.column_id*.

    Note that *format* refers to the value returned by a call to *get_format*
    for the current column item.

text_color = Property()
    The text color for a row item.

    The property implementation checks to see if the current table row is even
    or odd, and based on the result returns the value of the *even_text_color*
    or *odd_text_color* trait if the value is not **None**, and the value of the
    *default_text_color* trait if it is. The definition of these additional
    traits are as follows:

    - odd_text_color = Color( None )
    - even_text_color = Color( None )
    - default_text_color = Color( None )

    Remember that a **None** value means use the default text color.

bg_color = Property()
    The background color for a row item.

    The property implementation checks to see if the current table row is even
    or odd, and based on the result returns the value of the *even_bg_color* or
    *odd_bg_color* trait if the value is not **None**, and the value of the
    *default_bg_color* trait if it is. The definition of these additional
    traits are as follows:

    - odd_bg_color = Color( None )
    - even_bg_color = Color( None )
    - default_bg_color = Color( None )

    Remember that a **None** value means use the default background color.

alignment = Enum( 'left', 'center', 'right' )
    The alignment to use for a specified column.

    The default value is *'left'*.

width = Float( -1 )
    The width of a specified column.

    The default value is *-1*, which means a dynamically sized column with an
    *unnormalized fractional* value of *0.1*.

can_edit = Bool( True )
    Specifies whether the text value of the current item can be edited.

    The default value is **True**, which means that the user can edit the value.

drag = Property()
    A property which returns the value to be dragged for a specified row item.

    The property implementation simply returns the current row item.

can_drop = Bool( False )
    Specifies whether the specified value be dropped on the current item.

    The default value is **False**, meaning that the value cannot be dropped.

dropped = Enum( 'after', 'before' )
    Specifies where a dropped item should be placed in the table relative to
    the item it is dropped on.

    The default value is *'after'*.

font = Font
    The font to use for the current item.

    The default value is the standard default Traits font value.

image = Str( None )
    The name of the default image to use for a column.

    The default value is **None**, which means that no image will be displayed
    for the column.

    # The text of a row/column item:
    text = Property()

tooltip = Str()
    The tooltip information for a column item.

    The default value is the empty string, which means no tooltip information
    will be displayed for the column.

The preceding discussion applies to all of the methods defined in the first
group of **TabularAdapter** interface methods. However, the design rules do not
apply to the remaining five adapter methods, although they all provide a useful
default implementation:

get_item ( object, trait, row )
    Returns the value of the *object.trait[row]* item.

    The default implementation assumes the trait defined by *object.trait* is a
    *sequence* and attempts to return the value at index *row*. If an error
    occurs, it returns **None** instead. This definition should work correctly
    for lists, tuples and arrays, or any other object that is indexable, but
    will have to be overridden for all other cases.

    Note that this method is the one called in the first design rule described
    previously to retrieve the item at the current table row.

len ( object, trait )
    Returns the number of items in the specified *object.trait* list.

    Again, the default implementation assumes the trait defined by
    *object.trait* is a *sequence* and attempts to return the result of calling
    *len( object.trait )*. It will need to be overridden for any type of data
    which for which *len* will not work.

delete ( object, trait, row )
    Deletes the specified *object.trait[row]* item.

    The default implementation assumes the trait defined by *object.trait* is a
    mutable sequence and attempts to perform a *del object.trait[row]*
    operation.

insert ( object, trait, row, value )
    Inserts a new value at the specified *object.trait[row]* index.

    The default implementation assumes the trait defined by *object.trait* is a
    mutable sequence and attempts to perform an *object.trait[row:row]=[value]*
    operation.

get_default_value ( object, trait )
    Returns a new default value for the specified *object.trait* list.

    The default implementation simply returns the value of the adapter's
    *default_value* trait.

A TabularAdapter Example
------------------------

Having now learned about the core adapter interface as well as the design rules
supported by the default method implementations, you're probably wondering how
you can use a **TabularAdapter** for creating a real user interface.

So in this section we'll cover a simple example of creating a **TabularAdapter**
subclass to try and show how all of the pieces fit together.

In subsequent tutorials, we'll provide complete examples of creating
user interfaces using both the **TabularEditor** and **TabularAdapter** in
combination.

For this example, let's assume we have the following two classes::

    class Person( HasTraits ):

        name = Str()
        age = Int()
        address = Str()

    class MarriedPerson( Person ):

        partner = Instance( Person )

where **Person** represents a single person, and **MarriedPerson** represents
a married person and is derived from **Person** but adds the *partner* trait to
reference the person they are married to.

Now, assume we also have the following additional class::

    class Report( HasTraits ):

        people = List( Person )

which has a *people* trait which contains a list of both **Person** and
**MarriedPerson** objects, and we want to create a tabular display showing the
following information:

- Name of the person
- Age of the person
- The person's address
- The name of the person's spouse (if any)

In addition:

- We want to use a Courier 10 point font for each line in the table.
- We want the age column to be right, instead of left, justified
- If the person is a minor (age < 18) and married, we want to show a red flag
  image in the age column.
- If the person is married, we want to make the background color for that row
  a light blue.

Given this set of requirements, we can now define the following
**TabularAdapter** subclass::

    class ReportAdapter( TabularAdapter ):

        columns = [ ( 'Name',    'name' ),
                    ( 'Age',     'age' ),
                    ( 'Address', 'address' )
                    ( 'Spouse',  'spouse' ) ]

        font                      = 'Courier 10'
        age_alignment             = Constant( 'right' )
        MarriedPerson_age_image = Property()
        MarriedPerson_bg_color    = Color( 0xE0E0FF )
        MarriedPerson_spouse_text = Property()
        Person_spouse_text        = Constant( '' )

        def _get_MarriedPerson_age_image ( self ):
            if self.item.age < 18:
                return 'red_flag'
            return None

        def _get_MarriedPerson_spouse_text ( self ):
            return self.item.partner.name

Hopefully, this simple example conveys some of the power and flexibility that
the **TabularAdapter** class provides you. But, just in case it doesn't, let's
go over some of the more interesting details:

- Note the values in the *columns* trait. The first three values define
  *column ids* which map directly to traits defined on our data objects, while
  the last one defines an arbitrary string which we define so that we can
  reference it in the *MarriedPerson_spouse_text* and *Person_spouse_text* trait
  definitions.

- Since the font we want to use applies to all table rows, we just specify a
  new default value for the existing **TabularAdapter** *font* trait.

- Since we only want to override the default left alignment for the age column,
  we simply define an *age_alignment* trait as a constant *'right'* value. We
  could have also used *age_alignment = Str('right')*, but *Constant* never
  requires storage to be used in an object.

- We define the *MarriedPerson_age_image* property to handle putting the
  *red flag* image in the age column. By including the class name of the items
  it applies to, we only need to check the *age* value in determining what
  value to return.

- Similary, we use the *MarriedPerson_bg_color* trait to ensure that each
  **MarriedPerson** object has the correct background color in the table.

- Finally, we use the *MarriedPerson_spouse_text* and *Person_spouse_text*
  traits, one a property and the other a simple constant value, to determine
  what text to display in the *Spouse* column for the different object types.
  Note that even though a **MarriedPerson** is both a **Person** and a
  **MarriedPerson**, it will correctly use the *MarriedPerson_spouse_text* trait
  since the search for a matching trait is always made in *mro* order.

Although this is completely subjective, some of the things that the author
feels stand out about this approach are:

- The class definition is short and sweet. Less code is good.
- The bulk of the code is declarative. Less room for logic errors.
- There is only one bit of logic in the class (the *if* statement in the
  *MarriedPerson_age_image* property implementation). Again, less logic usually
  translates into more reliable code).
- The defined traits and even the property implementation method names read
  very descriptively. *_get_MarriedPerson_age_image* pretty much says what you
  would write in a comment or doc string. The implementation almost is the
  documentation.

Look for a complete traits UI example based on this sample problem definition in
the *Single and Married Person Example* tutorial in this section.

Now, as the complexity of a tabular view increases, the definition of the
**TabularAdapter** class could possibly start to get large and unwieldy. At
this point we could begin refactoring our design to use the **ITabularAdapter**
interface and **AnITabularAdapter** implementation class to create
*sub-adapters* that can be added to our **TabularAdapter** subclass to extend
its functionality even further. Creating sub-adapters and adding them via the
**TabularAdapter** *adapters* trait is a topic covered in a follow-on tutorial.

