Class: Model

• Inheritance
• Description
• Related information
• Class protocol
  • queries
• Instance protocol
  • converting
  • copying
  • copying-private
  • dependents access
  • dependents access (non weak)
  • suppressing updates
• Private classes

Inheritance:

   Object
   |
   +--Model
      |
      +--ApplicationModel
      |
      +--HTTPServerSettingsAppl::PluggableServicesSettingsAppl::AvailableServiceItem
      |
      +--Menu
      |
      +--Plug
      |
      +--SelectionInHierarchy
      |
      +--SelectionInTree
      |
      +--TabItem
      |
      +--TabulatorSpecification
      |
      +--Tools::Inspector2::NavigationState
      |
      +--ValueModel

Package:

stx:libview2

Category:

Interface-Support-Models

Version:

rev: 1.48 date: 2019/05/27 13:16:15

user: cg

file: Model.st directory: libview2

module: stx stc-classLibrary: libview2

Author:

Claus Gittinger

Description:

Models are things which represent information models, i.e. something
which holds the data for user interface components and on which these operate.
Basically, instances keep track of which components depend on them and 
inform the dependents of any changes.

The Model class itself is abstract and not too useful, see subclasses,
especially, ValueHolder and SelectionInList.

Notice:
  Actually the Model class is not really needed; since the dependency
  mechanism is inherited by Object, you can take any object as a model.
  However, instances of Model (and subclasses) keep the dependents locally
  in an instance variable; thus speeding up access a bit.

  Model redefines the dependency methods to use non-weak dependencies
  (in contrast to weak dependencies used by Object).  

[Instance variables:]
    dependents      <Collection>    those objects which depend on me.
                                    To save some storage, a single dependent 
                                    is kept directly here.
                                    Otherwise, if there are multiple dependents,
                                    a collection of dependents is held here.

Related information:

    ValueHolder
    SelectionInList
    [introduction to view programming]

Class protocol:

 isAbstract

Instance protocol:

 skippedInLiteralEncoding

define the inst-slots which are skipped when generating a literalArrayEncoding;
(to skip the ones with default values.)

 skipInstvarIndexInDeepCopy: index

a helper for deepCopy; only indices for which this method returns
false are copied in a deep copy.

 postCopy

release dependents after copying

 addDependent: anObject

make the argument, anObject be a dependent of the receiver

 breakDependents

remove all dependencies from the receiver

 dependents

return a Collection of dependents

 dependents: aCollectionOrNil

set the collection of dependents

 dependentsDo: aBlock

evaluate aBlock for all of my dependents

 removeDependent: anObject

make the argument, anObject be independent of the receiver

 addNonWeakDependent: anObject

make the argument, anObject be a dependent of the receiver.
Since all dependencies are nonWeak in Model, this is simply
forwarded to addDependent:

 interests

return a Collection of interests - empty if there is none.
Here, we use the normal dependents collection for interests.

 nonWeakDependents

return a Collection of dependents - empty if there is none.
Since all dependencies are nonWeak in Model, this is a dummy.

 removeNonWeakDependent: anObject

make the argument, anObject be independent of the receiver.
Since all dependencies are nonWeak in Model, this is simply
forwarded to removeDependent:

 isLocked

ask the updateLocked query.

 withUpdatesLockedDo: aBlock

execute aBlock with updates to myself temporarily suppressed,
(i.e. by answering true to the updateLocked query)
This is a cooperative interface - i.e. possible updaters MUST
check me via isLocked, before sending #value

 withoutSendingUpdatesDo: aBlock

execute aBlock with updates to dependents temporarily suppressed
(i.e. I will not notify the dependents during aBlock)
Warning:
do not change any dependencies inside the block,
as the original dependencies from before will be restored and such changes
are lost then.

Private classes:

    ModelUpdateLockedQuery