Class enthought.​envisage.​resource.​resource_type.​ResourceType

The base class for all resource types.

A resource type represents a *kind* of resource (i.e., domain object) such
as a log, log suite, well, mixing tank etc.  It could also represent a
'primitive' type such as an int, float, or more probably in our case, a
numeric array.

A resource type describes how to manage the following aspects of its
resources:

1) Visualization

Resources can be visualized in a number of ways, in trees, tables, lists
etc.  To do this we need information such as icons, label text etc. and
this is provided by the resource type's node type.  Although the node type
has its roots in the tree world, it can obviously be reused across widgets
such as tables and lists etc by simply not displaying the resource's
children.

2) Serialization

A resource type can provide a serializer to control how its resources are
persisted (e.g., to the project naming system).  By default, all objects
are pickled using cPickle, but for example, a log suite resource type could
provide a serializer that would read and write log suites as LAS (log ASCII
standard) files.

3) Naming

Envisage uses naming systems heavily, and importantly, the project
workspace is simply a persistent naming system that uses the file system
(see 'enthought.naming.PyFSContext').  If required, a resource type can
describe how naming resolution can proceed 'into' the namespace of an
individual resource e.g., a log suite resource type could allow name
resolution into its logs.  This comes in handy in the project workspace
view so that the user can navigate to any item displayed in the project
tree using the same naming mechanism.

4) Editing

A resource type can specify a class that will be used to create editors its
resource.

fixme: This should probably be the common pattern of:- a factory or a
class where the default factory just creates an instance of the class.

5) Traits UI handlers.

Resource types contain a dictionary of traits UI handlers that can be used
to create user interfaces for resources.

Contents:
• Base classes
• Attributes
• Methods

Inherits from

• HasTraits: enthought.traits.has_traits.HasTraits

Attributes

• context_adapter_factory

  Naming (#3)

  The (optional) context adapter factory creates (not surprisingly) adapters that describe how resources of this type participate in name resolution. If no context adapter is specified name resolution is not allowed to proceed 'into' the namespace of a resource.

  context_adapter_factory = Instance(ContextAdapterFactory)
  
  

• editor

  Editing (#4)

  The class used to create editors for resources of this type.

  editor = Any
  
  

• id

  The type's unique Id (where 'unique' means unique within the resource manager that the type is in. In Envisage we have exactly one resource manager so this effectively needs to be globally unique).

  id = Str
  
  

• node_type

  Visualization (#1)

  The node type describes how to visualize resources of this type.

  node_type = Instance(NodeType)
  
  

• resource_manager

  The resource manager that the resource type is part of.

  resource_manager = Instance(ResourceManager)
  
  

• serializer

  Serialization (#2)

  The (optional) serializer describes how resources of this type are persisted. If no serializer is specified then the resources will be pickled using 'cPickle'.

  serializer = Instance(ObjectSerializer)
  
  

• type

  A trait that describes the kind of domain object that the resource type represents.

  type = Any
  
  

• views

  Views (#5).

  fixme: These are actually traits UI handlers at the moment. I think this needs some more thought.

  views = Dict
  
  

Method summary

• clone(self, obj)
• copy(self, context, name, obj)
• create_editor(self, obj, *args, **kw)
• get_id(self, obj)
• get_name(self, obj)
• get_reference(self, obj)
• is_type_for(self, obj)
• set_name(self, obj, name)

Methods

• clone(self, obj)

  Returns a clone of an object.

• copy(self, context, name, obj)

  Copies a resource into the specified context.

• create_editor(self, obj, *args, **kw)

  Creates an editor for a resource.

  By default this just calls the class referred to by the 'editor' trait.

• get_id(self, obj)

  Returns a unique identifier for a resource.

  Unique here means, 'unique within the current process'.

• get_name(self, obj)

  Returns the name of an object.

• get_reference(self, obj)

  Returns a pickleable reference to a resource.

  By default this returns the object itself. This is only acceptable for SMALL resources!

• is_type_for(self, obj)

  Returns True if the resource type 'recognizes' an object.

• set_name(self, obj, name)

  Sets the name of an object.