Class: Sketchup::ModelObserver

Inherits:
Object
  • Object
show all

Overview

This observer interface is implemented to react to model events. To implement this observer, create a Ruby class of this type, override the desired methods, and add an instance of the observer to the model.

Note that the observers related to transactions (aka undoable operations) are primarily for reporting and debugging. Performing any edit operations of your own (such as modifying the model) inside the observer callback should be avoided, as it could cause crashes or model corruption. The most common use for these callbacks is to help debug problems where your Ruby script's Sketchup::Model#start_operation and Sketchup::Model#commit_operation calls are somehow conflicting with SketchUp's native undo operations. You can set up an observer set to watch precisely what is going on.

Examples:

# This is an example of an observer that watches the
# component placement event.
class MyModelObserver < Sketchup::ModelObserver
  def onPlaceComponent(instance)
    puts "onPlaceComponent: #{instance}"
  end
end

# Attach the observer.
Sketchup.active_model.add_observer(MyModelObserver.new)

Version:

  • SketchUp 6.0

Instance Method Summary # collapse

Instance Method Details

#onActivePathChanged(model) ⇒ nil

The #onActivePathChanged method is invoked when the user opens or closes a ComponentInstance or Group for editing.

When the user opens an instance for editing the positions and transformations of the entities in the opened instance will be relative to global world coordinates instead of the local coordinates relative to their parent.

See Sketchup::Model#active_path and Sketchup::Model#edit_transform for methods that report the current edit origin vs. the global origin, etc.

By using this observer callback, you can keep track of the various nested transformations as your users double click to drill into and out of component edits.

Examples:

# As the user double clicks into component edits, show the "path" along
# the model hierarchy they have followed to get here.
def onActivePathChanged(model)
  puts "onActivePathChanged: #{model}"
end

Parameters:

Returns:

  • (nil)

See Also:

#onAfterComponentSaveAs(model) ⇒ nil

The #onAfterComponentSaveAs method is invoked when the user context-clicks > Save As on a component instance. It is called just after the component is written to disk, so you can restore the component to some state before returning control to the user.

Examples:

def onAfterComponentSaveAs(model)
  puts "onAfterComponentSaveAs: #{model}"
end

Parameters:

Returns:

  • (nil)

See Also:

Version:

  • SketchUp 7.0

#onBeforeComponentSaveAs(model) ⇒ nil

The #onBeforeComponentSaveAs method is invoked when the user context-clicks > Save As on a component instance. It is called just before the component is written to disk, so you can make changes within the handler and it will make it into the save.

For example, you may decide that you want to add some attribute to every component that is saved out, but you do not want that attribute sticking around inside the current model. Within #onBeforeComponentSaveAs you could add the attribute, and within #onAfterComponentSaveAs you could delete that attribute.

The callback is not sent the component that is to be saved, but the model's selection will contain it.

Examples:

def onBeforeComponentSaveAs(model)
  puts "onBeforeComponentSaveAs: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 7.0

#onDeleteModel(model) ⇒ nil

The #onDeleteModel method is invoked when a model is deleted.

Examples:

def onDeleteModel(model)
  puts "onDeleteModel: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 6.0

#onEraseAll(model) ⇒ nil

The #onEraseAll method is invoked when everything in a model is erased.

Examples:

def onEraseAll(model)
  puts "onEraseAll: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 6.0

#onExplode(model) ⇒ nil

The method is invoked whenever a component anywhere in this model is exploded. This is an easier way to watch explode events vs. attaching an InstanceObserver to every instance in the model.

Since the callback does not return what was exploded, one solution is to place a selection observer that keeps track of which entities whose explosion you are interested in are in the selection. Since SketchUp's user interface only provides a means of exploding the selection, this method is a reliable way to know what was just exploded.

Another method would be to watch ComponentDefinition.count_instances to determine what just changed, as any components that were exploded will now be less an instance.

Examples:

def onExplode(model)
  puts "onExplode: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 7.0

#onPidChanged(model, old_pid, new_pid) ⇒ nil

The #onPidChanged method is invoked when a persistent id in the model changes. For example when entities are grouped.

Examples:

def onPidChanged(model, old_pid, new_pid)
  puts "onPidChanged: #{model}, #{old_pid} => #{new_pid}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 2017

#onPlaceComponent(model) ⇒ nil

The #onPlaceComponent method is invoked when a component is “placed” into the model, meaning it is dragged from the Component Browser.

Examples:

def onPlaceComponent(model)
  puts "onPlaceComponent: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 7.0

#onPostSaveModel(model) ⇒ nil

The #onPostSaveModel method is invoked after a model has been saved to disk.

Examples:

def onPostSaveModel(model)
  puts "onPostSaveModel: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 8.0

#onPreSaveModel(model) ⇒ nil

The #onPreSaveModel method is invoked before a model is saved to disk.

Examples:

def onPreSaveModel(model)
  puts "onPreSaveModel: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 8.0

#onSaveModel(model) ⇒ nil

The #onSaveModel method is invoked after a model has been saved to disk.

Examples:

def onSaveModel(model)
  puts "onSaveModel: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 6.0

#onTransactionAbort(model) ⇒ nil

The #onTransactionAbort method is invoked when a transaction is aborted.

Examples:

def onTransactionAbort(model)
  puts "onTransactionAbort: #{model}"
end

Parameters:

Returns:

  • (nil)

See Also:

Version:

  • SketchUp 6.0

#onTransactionCommit(model) ⇒ nil

The #onTransactionCommit method is invoked when a transaction is completed.

Examples:

def onTransactionCommit(model)
  puts "onTransactionCommit: #{model}"
end

Parameters:

Returns:

  • (nil)

See Also:

Version:

  • SketchUp 6.0

#onTransactionEmpty(model) ⇒ nil

The #onTransactionEmpty method is invoked when a transaction (aka an undoable operation) starts and then is committed without anything being altered in between.

Examples:

def onTransactionEmpty(model)
  puts "onTransactionEmpty: #{model}"
end

Parameters:

Returns:

  • (nil)

See Also:

Version:

  • SketchUp 6.0

#onTransactionRedo(model) ⇒ nil

The #onTransactionRedo method is invoked when the user “redoes” a transaction (aka undo operation.) You can programmatically fire a redo by calling Sketchup.sendAction(“editRedo”).

Examples:

def onTransactionRedo(model)
  puts "onTransactionRedo: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 6.0

#onTransactionStart(model) ⇒ nil

The #onTransactionStart method is invoked when a transaction (aka an undoable operation) starts.

Examples:

def onTransactionStart(model)
  puts "onTransactionStart: #{model}"
end

Parameters:

Returns:

  • (nil)

See Also:

Version:

  • SketchUp 6.0

#onTransactionUndo(model) ⇒ nil

The method is invoked when the user “undoes” a transaction (aka undo operation.) You can programmatically fire an undo by calling Sketchup.sendAction(“editUndo”).

Examples:

def onTransactionUndo(model)
  puts "onTransactionUndo: #{model}"
end

Parameters:

Returns:

  • (nil)

Version:

  • SketchUp 6.0