group.material=material Where the given material is a reference to a material already available in the model, or perhaps it's the name of an existing material, or the name of one of the standard 'color' - that might be not yet loaded: So e.g. material=Sketchup.active_model.materials['truss_wood']Where material returns 'nil' if it's not found, or a reference to that named material otherwise. Or alternatively: material='truss_wood' which will work if you know that the material named 'truss_wood' is already in the model, or perhaps... material='brown' Which uses the material named 'brown', or it makes the new material then uses it otherwise. There is a preset list of 'colors' [à la html]: http://www.sketchup.com/intl/en/developer/docs/ourdoc/color If you want a material with another color or transparent, or a texture, then you must add it to the model.materials before referencing it. http://www.sketchup.com/intl/en/developer/docs/ourdoc/materials#add You then create a new color and apply it to that new material, which by default would be black with no transparency [0,0,0,0] http://www.sketchup.com/intl/en/developer/docs/ourdoc/material#color= If you also want to add a texture to the material, use http://www.sketchup.com/intl/en/developer/docs/ourdoc/material#texture= Which specifies the image file to use, then you can edit the texture's details with texture=material.texture Using:http://www.sketchup.com/intl/en/developer/docs/ourdoc/texture#size= etc...

No pattern. The various ways that the user can manipulate the selection set makes any order meaningless. Ie: single pick, single pick + CTRL, single pick + SHIFT, Window Right-to-Left pick, Window Right-to-Left pick + CTRL, Window Right-to-Left pick + SHIFT, Window Left-to-Right pick, Window Left-to-Right pick + CTRL, and Window Left-to-Right pick + SHIFT. Any of these, followed by any other number of them, in whatever order the user may use them, creates a selection set in which the pick order has no importance. That said, ... You question indicates you are perhaps trying to program a workflow that would better be implemented as a Ruby Tool, using a Sketchup::PickHelper. Another alternative might be a Sketchup::SelectionObserver subclass.

I guess Fredo is occupied with Animator these days. It would be great if more extensions could be made available on GitHub, BitBucket with open source licenses - allowing people to add to existing extensions instead of re-implementing similar functions.

@thomthom said: What would the use case for that be? If you know in advance that there will be long operation, you can prepare a message box which will come after e.g. 5-10 min. " It seems to much time to process, do you want to abort or go ahead?" The UI:messagebox is suspending the operation and the code is continuing if it is closed. (At least in windows...) But if the user is not responding for e.g. 30-60sec the message box will close automaticly and the code is continuing to process. You can't use webdialog, because in long operation SU (including WD) is not responding at all. For sure there is other workaround, or possible to do your code on other way, but this could be an "easy" solution... (I'm just an amateur engineer, not a programmer ... )

My solution: def thickness(obj) ents =( obj.definition.entities rescue obj.entities ) tran =( obj.transformation rescue IDENTITY ) edges = ents.grep(Sketchup;;Edge).find_all {|e| e.start.position == ORIGIN || e.end.position == ORIGIN } if edges.size < 3 return 0.to_l # not a 3D object or edges array empty end shortest = edges.min_by {|e| e.length } shortest.start.position.transform(tran).distance( shortest.end.position.transform(tran) ) end This should work with an argument that is a definition, group or component instance. If a ComponentDefinition is passed, the transform will be the IDENTITY transform, otherwise an instance or group will be it's transform (which also might be == IDENTITY.) Within the entities the local origin is == ORIGIN, so there is no need to create any temporary point object for comparison, just to select the 3 edges. Once we have the shortest (untransformed) edge, we apply the transformation to both it's vertex positions, to account for any rotation and scaling (either uniform or not.) Now, this assumes that the shortest definition edge is always to be considered the thickness, even in the instances. But what if someone does non-uniform scaling and makes one of the longer edges shorter than the one that is supposed to be the shortest ? I suppose, if you control the definitions, you could attach an attribute to the "thickness" edge, and find it by attribute.

Are the original pt1 and pt2 created in the model.active_entities context ? If pt1 is always the ORIGIN then you really only need pt2 ? Why not use a transformation ? You can store the initial truss.transformation.to_a as an attribute with the truss. Then... when you next need to assess the current truss location/rotation just get the current truss.transformation and then modify [transform!] it OR even the saved point [or 2 points] - having adjusted it by the transformation that was stored as it was created - recreated from the attribute array back into a transformation. http://www.sketchup.com/intl/en/developer/docs/ourdoc/transformation

Hi people, Able to replace the texture of a object without upsetting the Mapping. But if I duplicate that object, I am unable to assign a different/separate/unique texture where each object can be assigned a different texture image jpeg. I am unable to DE-LINK the image textures of the two objects. Pls Note: I am able to do this only by applying the texture image as a fresh unmapped material and then fix the mapping all over again.

I like to keep my data in a structure and I like to save structures to disk and / or store them as a complete record in a dictionary. So you can either parse the file / or parse the dictionary in the same exact way. Actually very simple and extremely future proof as they are key pairs. New versions that introduce new fields (elements) need only provide a reasonable default. I can provide you with examples if you want to PM me.

And to have an email form filled out, but not automatically sent: UI;;WebDialog;;new( "Email...",true,nil,200,100,300,200,false ).instance_eval { email = "mailto;//someone@example.com"<< "?subject=This%20is%20the%20subject"<< "&cc=someone_else@example.com"<< "&body=This%20is%20the%20body" set_html( "<!DOCTYPE html>\n<html>\n <head>\n </head>\n"<< " <body>\n <br/>"<< " <a id='elink' href='#{email}'>Firing an email!</a>\n"<< " </body>\n"<< "</html>" ) show() { execute_script("elink.click();") } } http://en.wikipedia.org/wiki/Mailto But there must be a registered email client for the system. Ie, it does not work on my machine because I use browser based gmail, and never registered any email client application on this machine. (So for me two error messages popup stating there is no registered email client.)

Thanks that worked and after seeing it correct it makes sence. KeitH

You can't do it wholly within Ruby. But you could probably make a set of 'system' calls in Ruby to do it [it'll differ between MAC & PC].

An olde typo - use 1 for the second test...

@dan rathbun said: Then you'll need to follow: http://extensions.sketchup.com/en/developer_center/ew_developer#rbz I've read through same and I plan to do so again more thoroughly again after I get this next layer of magic nailed down. I think I now understand the two file format well enough to give it a spin in a bit but am momentarily busy prepping prototype parts for shapeways. Its been tool, prototype, tool, proto in a kind of recursive spiral! Need one for the other and round about we go...

@thomthom said: https://github.com/thomthom/SKUI Could you add version to README.md? Pretty please with a cookie?

Example: appspy_w_fco.rb # encoding; UTF-8 module Author   module PluginName        class AppSpy < Sketchup;;AppObserver       @@attached = false unless defined?(@@attached)       def self.attached?()         @@attached ? true ; false       end       def attach()         detach() if @@attached         Sketchup;;add_observer(self)       end       def detach()         Sketchup;;remove_observer(self)         @@attached = false       end       def initialize()         @fco = nil         @watched = []         @@attached = attach()         return self       end       def expectsStartupModelNotifications         return true       end       def frameChange(fromPage, toPage, percent_done)         # Actual code here.       end       def ignore_frames()         if @fco           Sketchup;;Pages;;remove_frame_change_observer(@fco)           @fco = nil         end         @watched.keep_if {|model| model.valid? rescue false }       end       def ignore_model(model)         @watched.delete(model)         ignore_frames() if model == Sketchup.active_model       end       def watch_frames(model)         ignore_frames() if @fco         @fco = Sketchup;;Pages;;add_frame_change_observer(self)         @watched << model unless @watched.include?(model)       end       def watching?(model)         @watched.include?(model)       end       # AppObserver Callbacks here can call the above methods.       def onActivateModel(model) # Mac only         if watching?(model)           watch_frames(model)         else           ignore_frames()         end       end       def onNewModel(model)         watch_frames(model)       end       def onOpenModel(model)         watch_frames(model)       end       def onQuit()         ignore_frames()       end       def onUnloadExtension(extension_name)         ignore_frames()       end     end # AppSpy     PluginSpy = AppSpy;;new unless AppSpy.attached?      end # extension module end # toplevel module  

I use a modified template that Dan Rathburn created. I also use his file naming convention for the loader etc. You could strip this down. But I like to place my plugins in a shared folder so I can test a single plugin on 6 versions of Sketchup SU7 through SU2016 require('extensions.rb') module YourCompany # Proprietary TopLevel Namespace; No Trespassing! module ThisPlugin # Namespace for THIS plugin # Create an entry in the Extension list that loads script called; # "gkware_doormaker_loader.rb" APP_VERSION = '1.0.1' @plugin = SketchupExtension.new('Company Plugin Description', File.join('PluginName', 'Company_PluginName_loader')) @plugin.creator = 'Your Name' @plugin.copyright = '(c)2013-2016 by YourCompany' @plugin.version = APP_VERSION @plugin.description = 'Plugin does something - optional url to your website' unless @plugin.class.method_defined?(;path) # # Define a singleton method for @plugin to access the @path attribute. # (... because the API did not do it in extensions.rb !!) # def @plugin.path() instance_variable_get(;@path) end end # unless # Create local path and filename constants; PATH = @plugin.path() LOADER_SUFFIX = '_loader' LOADER = File.basename(PATH) tmp = LOADER.split('_') RBSFILE = tmp[0] + '_' + tmp[1] + '.rbs' # RELDIR is relative to Plugins dir, OR the dir from # the $LOAD_PATH array that require used to find it. RELDIR = File.dirname(PATH) ROOT = $LOAD_PATH.find(false) do |abspath| Kernel.test(?d, File.join(abspath, RELDIR)) end if ROOT ABSDIR = File.join(ROOT, RELDIR) else # assume the target dir is directly below, the dir that THIS file is in. ABSDIR = File.join(File.dirname(__FILE__), RELDIR) end # Register this extension with the Sketchup;;ExtensionManager Sketchup.register_extension(@plugin, true) end # module YourCompany;;ThisPlugin end # module YourCompany

I've been coding all the way back to my assembler days (pre 1980). Various flavors of (Basic, Cobol, C, C++, Pascal, C#, Java), many database scripting languages such as (dBase, MSAcces, Paradox), other scripting languages such as javascript, jquery, PHP, Ruby, CSS, SQL. AWK, TCL ... I usually go with the flow. Borland built a very good library called the VCL (Visual Components Library), which makes use of an absolutely excellent object oriented set of classes. Easy to follow and very consistent stylisticly. This library is used by Delphi (object oriented pascal) and by C++ Builder. Microsoft built a terrible interface called MFC (Microsoft Foundation Classes). So when I had to use Microsoft for various early mobile devices I skipped it and used the Win API. With Sketchup I use a mix of both Classes (for tools) and simple reusable methods for helper functions. Even though I prefer using pointers with C, C++ etc. it just isn't possible with ruby (although under the hood most everything is passed as a reference). Having said all that - Ruby is quite good - although there are a few too many ways to do anything. This just means it is often a bit slower reading other code as the programmer often chooses a different way to do things. So I'm a bit more formal and like to use terse syntax where possible. ! instead of not, || instead of or, immediate if = ? :, parenthesis for all methods, lots of white space etc. For me it is all about readability so I can come back and speed read code I wrote months or years ago. But I do like some of Ruby's ways. "#{var}" the use of if after an assignment etc.

yes I will try... i would wish skp would be a format only visible in the viewer as suggestion SKV sketchup viewer file

@deanby7 said: I know I'm missing something basic here but trying to get the vertices of a selected face.... @mod = Sketchup.active_model > sel = @mod.selection > verts = sel.grep(Sketchup;;Face) {|f|f.vertices} > v = verts.position > Doesn't give me an array of 3d point values as expected? Interrogate the Ruby documentation for each method used. The Sketchup::Selection class (as well as most other API collection classes,) mix in the Enumerable library module. This is where grep() comes from. Enumerable#grep() http://ruby-doc.org/core-2.0.0/Enumerable.html#method-i-grep The grep() method always returns an array, either of the collection members matching the pattern, or the results of the block (if given.) It is similar to using a combination of find_all(), followed by map(). Your pattern was all Sketchup::Face objects, and you used a block which passed each face into the block in turn. Your block then called Sketchup::Face#vertices() upon each, which always returns an Array of Sketchup::Vertex objects. So at the very least, your verts reference could point to an empty array (if no faces were grep'ed, and therefore the block is never called.) If the collection does hold face references, there will be a nested array of vertices, for each face found. Now, there is a difference between a vertex and a point. Sketchup::Vertex objects are model entity objects (and subclass of Sketchup::Drawingelement, which is subclass of Sketchup::Entity.) Meaning they are entities that are saved within the model geometric database. They, in turn have a position property. Accessing that, returns a Geom::Point3d object, which in a virtual geometry "helper" object. Anyway, if you want points, then call position upon the vertices, within the block: point_arys = sel.grep(Sketchup;;Face) {|f| f.vertices.map{|v| v.position } } ... which now gives you an array of nested arrays of points (for each face.) Or, ... access the points in two steps: vert_arys = sel.grep(Sketchup;;Face) {|f| f.vertices } for face_verts in vert_arys face_points = face_verts.map {|v| v.position } # do something with the array of face_points end

I'll post the code here, because it's where I searched for a solution first and couldn't find one... [image: 8ARS_working_edges_centre.gif] I striped out the colouring but left the selection add, as a progress bar substitute... # with Tig's advice from PM ... model = Sketchup.active_model sel = model.selection ents = model.active_entities view = model.active_view mats = model.materials # cylindrical sine wave pair on a unit radius with 24 sides... wave = [[1.0, 0.0, 0.0], [0.9659258262890683, 0.25881904510252074, 0.050799999999999984], [0.8660254037844387, 0.49999999999999994, 0.08798818102449896], [0.7071067811865476, 0.7071067811865475, 0.1016], [0.5000000000000001, 0.8660254037844386, 0.08798818102449898], [0.25881904510252096, 0.9659258262890682, 0.05080000000000003], [6.123233995736766e-17, 1.0, 1.2442411479337108e-17], [-0.25881904510252063, 0.9659258262890683, -0.05079999999999998], [-0.4999999999999998, 0.8660254037844388, -0.08798818102449893], [-0.7071067811865475, 0.7071067811865476, -0.1016], [-0.8660254037844385, 0.5000000000000003, -0.087988181024499], [-0.9659258262890682, 0.258819045102521, -0.050800000000000047], [-1.0, 1.2246467991473532e-16, -2.4884822958674216e-17], [-0.9659258262890684, -0.25881904510252035, 0.05079999999999989], [-0.8660254037844388, -0.4999999999999998, 0.08798818102449892], [-0.7071067811865479, -0.7071067811865471, 0.1016], [-0.5000000000000004, -0.8660254037844384, 0.08798818102449903], [-0.25881904510252146, -0.9659258262890681, 0.05080000000000014], [-1.8369701987210297e-16, -1.0, 3.267705224142925e-17], [0.2588190451025203, -0.9659258262890684, -0.050799999999999915], [0.4999999999999993, -0.866025403784439, -0.08798818102449889], [0.7071067811865475, -0.7071067811865477, -0.1016], [0.8660254037844384, -0.5000000000000004, -0.08798818102449901], [0.9659258262890681, -0.2588190451025215, -0.05080000000000014], [1.0, 0.0, -0.0]] # waves have an additional point to complete the circle... segments = wave.length - 1 # single undo model.start_operation('wave') # Make the empty 'container' group. container = ents.add_group() cont_ents = container.entities # add the empty surf_grp() to cont_ents surf_grp = cont_ents.add_group() surf_ents = surf_grp.entities # Add Surface soft edges and faces using offset points... i = 0 segments.times do f = surf_ents.add_face(ORIGIN, wave[i], wave[i + 1]) view.refresh f.edges.each{|e| e.soft="true" e.smooth="true" sel.add(e) } i += 1 view.refresh end # add the wave to cont_ents... cont_ents.add_curve(wave) # and explode the surface faces... surf_grp.explode sel.clear model.commit_operation EDIT: after getting the other working using add_face I made a few adjustment to this code... john