Class: Sketchup::ModelObserver Abstract

Inherits:
Object
  • Object
show all
Defined in:
lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb

Overview

This class is abstract.

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.

This observer interface is implemented to react to model events.

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:



64
65
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 64

def onActivePathChanged(model)
end

#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



84
85
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 84

def onAfterComponentSaveAs(model)
end

#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



111
112
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 111

def onBeforeComponentSaveAs(model)
end

#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



126
127
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 126

def onDeleteModel(model)
end

#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



141
142
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 141

def onEraseAll(model)
end

#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



168
169
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 168

def onExplode(model)
end

#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



188
189
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 188

def onPidChanged(model, old_pid, new_pid)
end

#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



204
205
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 204

def onPlaceComponent(model)
end

#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



219
220
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 219

def onPostSaveModel(model)
end

#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



234
235
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 234

def onPreSaveModel(model)
end

#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



249
250
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 249

def onSaveModel(model)
end

#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



266
267
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 266

def onTransactionAbort(model)
end

#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



283
284
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 283

def onTransactionCommit(model)
end

#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



302
303
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 302

def onTransactionEmpty(model)
end

#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



319
320
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 319

def onTransactionRedo(model)
end

#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



337
338
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 337

def onTransactionStart(model)
end

#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



354
355
 
# File 'lib/sketchup-api-stubs/stubs/Sketchup/ModelObserver.rb', line 354

def onTransactionUndo(model)
end