scriptup 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a13a9ca166d58d914b19c46a4bbe165e08cc10aab1312505f0b86e8b974ab480
+  data.tar.gz: b56fd89ad25a6ee7db43e4827e0b2caf9efc4f5176dc8624d1f747c802e56b07
+SHA512:
+  metadata.gz: cfb285fdc4173fba7d43bee92b5841794bb05de03f3cbd537bb059a512de19409bdfbaa63eb1246853d3f04581f1b33e76e31a7ffc27c6d508a62f2540ef0130
+  data.tar.gz: 0dbe242f90fb8a119ae4709e9e1df5ffa56e7474e7b95bbdad62c7e36ed2e3a9acef48644bbd50fac2320d420753138cb1d32b33f939917147aa00da9cf7daaf

data/LICENSE.txt

@@ -0,0 +1,11 @@
+Copyright 2024 Chaos Software LTD EOOD
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,5 @@
+# About
+
+This project provides ruby bindings for the SketchUp C API. They are designed to mimmic the SketchUp [**ruby api**](https://ruby.sketchup.com) for use in Sketchup extension tests outside the SketchUp application.  You can however use them for general purpouse scripting.
+
+The SketchUp C API is much more limmited than the ruby api.  There is no gui event loop, nor observers, nor view, nor does this extension aim to provide such functionality.

data/ext/attribute_dictionaries.c

@@ -0,0 +1,45 @@
+#include <stdbool.h>
+#include <attribute_dictionaries.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+static VALUE Sketchup_AttributeDictionaries_get(VALUE self, VALUE key)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	SUAttributeDictionaryRef dictionary = SU_INVALID;
+	enum SUResult result = SUModelGetAttributeDictionary(model, StringValuePtr(key), &dictionary);
+	if (result != SU_ERROR_NONE)
+		return Qnil;
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARY), 0, 0, dictionary.ptr);
+}
+
+void Sketchup_AttributeDictionaries_Iterator(SUAttributeDictionaryRef group, void* _)
+{
+	rb_yield(Data_Wrap_Struct(rb_path2class(SKETCHUP_ATTRIBUTEDICTIONARY), 0, 0, group.ptr));
+}
+
+static VALUE Sketchup_AttributeDictionaries_each(VALUE self)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	FOREACH(SUModelGetNumAttributeDictionaries, SUModelGetAttributeDictionaries, SUAttributeDictionaryRef, model, Sketchup_AttributeDictionaries_Iterator, 0);
+	return self;
+}
+
+static VALUE Sketchup_AttributeDictionaries_length(VALUE self)
+{
+	SUModelRef model = {DATA_PTR(self)};
+	size_t count;
+	SUModelGetNumAttributeDictionaries(model, &count);
+	return INT2NUM(count);
+}
+
+VALUE AttributeDictionaries_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_AttributeDictionaries = rb_define_class_under(Sketchup, ATTRIBUTEDICTIONARIES, Sketchup_Entity);
+	rb_include_module(Sketchup_AttributeDictionaries, rb_mEnumerable);
+	rb_define_method(Sketchup_AttributeDictionaries, "[]", Sketchup_AttributeDictionaries_get, 1);
+	rb_define_method(Sketchup_AttributeDictionaries, "each", Sketchup_AttributeDictionaries_each, 0);
+	rb_define_method(Sketchup_AttributeDictionaries, "length", Sketchup_AttributeDictionaries_length, 0);
+	rb_define_method(Sketchup_AttributeDictionaries, "size", Sketchup_AttributeDictionaries_length, 0);
+	return Sketchup_AttributeDictionaries;
+}

data/ext/attribute_dictionaries.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE AttributeDictionaries_Init(VALUE namespace_object, VALUE parent_class);

data/ext/attribute_dictionary.c

@@ -0,0 +1,156 @@
+#include <stdbool.h>
+#include <attribute_dictionary.h>
+#include <typed_value.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+static VALUE Sketchup_AttributeDictionary_get(VALUE self, VALUE key)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	SUTypedValueRef typedValue = SU_INVALID;
+	SUTypedValueCreate(&typedValue);
+	enum SUResult result = SUAttributeDictionaryGetValue(dictionary, StringValuePtr(key), &typedValue);
+	if (result != SU_ERROR_NONE)
+	{
+		SUTypedValueRelease(&typedValue);
+		return Qnil;
+	}
+	VALUE output = TypedValue_get_value_type(&typedValue);
+	SUTypedValueRelease(&typedValue);
+	return output;
+}
+
+static VALUE Sketchup_AttributeDictionary_set(VALUE self, VALUE key, VALUE value)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	SUTypedValueRef typedValue = SU_INVALID;
+	SUTypedValueCreate(&typedValue);
+	TypedValue_set_value_type(&typedValue, value);
+	enum SUResult result = SUAttributeDictionarySetValue(dictionary, StringValuePtr(key), typedValue);
+	SUTypedValueRelease(&typedValue);
+	if (result != SU_ERROR_NONE)
+		return Qnil;
+	return TypedValue_get_value_type(&typedValue);
+}
+
+void Sketchup_AttributeDictionary_Iterator(SUStringRef dictionary_key, SUAttributeDictionaryRef dictionary)
+{
+	VALUE key;
+	GETUTF8FROMSTRING(dictionary_key, key);
+	SUTypedValueRef value = SU_INVALID;
+	SUTypedValueCreate(&value);
+	SUAttributeDictionaryGetValue(dictionary, StringValuePtr(key), &value);
+	VALUE output = TypedValue_get_value_type(&value);
+	SUTypedValueRelease(&value);
+	rb_yield_values(2, key, output);
+}
+
+static VALUE Sketchup_AttributeDictionary_each(VALUE self)
+{
+
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	FOREACHSTRING(SUAttributeDictionaryGetNumKeys, SUAttributeDictionaryGetKeys, SUStringRef, dictionary, Sketchup_AttributeDictionary_Iterator, dictionary);
+	return self;
+}
+
+void Sketchup_AttributeDictionary_each_key_Iterator(SUStringRef dictionary_key, void* _)
+{
+	VALUE key;
+	GETUTF8FROMSTRING(dictionary_key, key);
+	rb_yield(key);
+}
+
+static VALUE Sketchup_AttributeDictionary_each_key(VALUE self)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	FOREACHSTRING(SUAttributeDictionaryGetNumKeys, SUAttributeDictionaryGetKeys, SUStringRef, dictionary, Sketchup_AttributeDictionary_each_key_Iterator, 0);
+	return self;
+}
+
+static VALUE Sketchup_AttributeDictionary_name(VALUE self)
+{
+	VALUE output;
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	GETSTRING(SUAttributeDictionaryGetName, dictionary, output)
+	return output;
+}
+
+static VALUE Sketchup_AttributeDictionary_length(VALUE self)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	size_t count;
+	SUAttributeDictionaryGetNumKeys(dictionary, &count);	
+	return INT2FIX(count);
+}
+
+void Sketchup_AttributeDictionary_keys_Iterator(SUStringRef dictionary_key, VALUE ary)
+{
+	VALUE key;
+	GETUTF8FROMSTRING(dictionary_key, key);
+	rb_ary_push(ary, key);
+}
+
+static VALUE Sketchup_AttributeDictionary_keys(VALUE self)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	VALUE ary = rb_ary_new();
+	FOREACHSTRING(SUAttributeDictionaryGetNumKeys, SUAttributeDictionaryGetKeys, SUStringRef, dictionary, Sketchup_AttributeDictionary_keys_Iterator, ary);
+	return ary;
+}
+
+struct AttributeDictionary_Struct
+{
+	VALUE ary;
+	SUAttributeDictionaryRef dictionary;
+};
+
+void Sketchup_AttributeDictionary_values_Iterator(SUStringRef dictionary_key, struct AttributeDictionary_Struct attributeDictionary_struct)
+{
+	VALUE key;
+	GETUTF8FROMSTRING(dictionary_key, key);
+	SUTypedValueRef value = SU_INVALID;
+	SUTypedValueCreate(&value);
+	SUAttributeDictionaryGetValue(attributeDictionary_struct.dictionary, StringValuePtr(key), &value);
+	VALUE output = TypedValue_get_value_type(&value);
+	SUTypedValueRelease(&value);
+	rb_ary_push(attributeDictionary_struct.ary, output);
+}
+
+static VALUE Sketchup_AttributeDictionary_values(VALUE self)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	VALUE ary = rb_ary_new();
+	struct AttributeDictionary_Struct values_struct = {ary, dictionary};
+	FOREACHSTRING(SUAttributeDictionaryGetNumKeys, SUAttributeDictionaryGetKeys, SUStringRef, dictionary, Sketchup_AttributeDictionary_values_Iterator, values_struct);
+	return ary;
+}
+
+static VALUE Sketchup_AttributeDictionary_delete_key(VALUE self, VALUE key)
+{
+	SUAttributeDictionaryRef dictionary = {DATA_PTR(self)};
+	SUTypedValueRef value = SU_INVALID;
+	SUTypedValueCreate(&value);
+	SUAttributeDictionaryGetValue(dictionary, StringValuePtr(key), &value);
+	VALUE output = TypedValue_get_value_type(&value);
+	SUTypedValueRelease(&value);
+	// ToDo:: delete the key and its value from the attribute dictionary
+	return output;
+}
+
+VALUE AttributeDictionary_Init(VALUE Sketchup, VALUE Sketchup_Entity)
+{
+	VALUE Sketchup_AttributeDictionary = rb_define_class_under(Sketchup, ATTRIBUTEDICTIONARY, Sketchup_Entity);
+	rb_include_module(Sketchup_AttributeDictionary, rb_mEnumerable);
+	rb_define_method(Sketchup_AttributeDictionary, "[]", Sketchup_AttributeDictionary_get, 1);
+	rb_define_method(Sketchup_AttributeDictionary, "[]=", Sketchup_AttributeDictionary_set, 2);
+	rb_define_method(Sketchup_AttributeDictionary, "each", Sketchup_AttributeDictionary_each, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "each_pair", Sketchup_AttributeDictionary_each, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "each_key", Sketchup_AttributeDictionary_each_key, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "name", Sketchup_AttributeDictionary_name, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "length", Sketchup_AttributeDictionary_length, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "size", Sketchup_AttributeDictionary_length, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "keys", Sketchup_AttributeDictionary_keys, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "values", Sketchup_AttributeDictionary_values, 0);
+	rb_define_method(Sketchup_AttributeDictionary, "delete_key", Sketchup_AttributeDictionary_delete_key, 1);
+	return Sketchup_AttributeDictionary;
+}

data/ext/attribute_dictionary.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE AttributeDictionary_Init(VALUE namespace_object, VALUE parent_class);

data/ext/behavior.c

@@ -0,0 +1,10 @@
+#include <stdbool.h>
+#include <behavior.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+VALUE Behavior_Init(VALUE Sketchup, VALUE Entity)
+{
+	VALUE Sketchup_Behavior = rb_define_class_under(Sketchup, BEHAVIOR, Entity);
+	return Sketchup_Behavior;
+}

data/ext/behavior.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE Behavior_Init(VALUE namespace_object, VALUE parent_class);

data/ext/color.c

@@ -0,0 +1,211 @@
+#include <stdbool.h>
+#include <color.h>
+#include <SketchUpAPI/sketchup.h>
+#include <utils.h>
+
+static int GETCOLOR(VALUE obj)
+{
+	int color = FIX2INT(obj);
+	if (color > 255)
+		return 255;
+	else if (color < 0)
+		return 0;
+	else
+		return color;
+}
+
+static float GETALPHA(VALUE obj)
+{
+	float alpha = NUM2DBL(obj);
+	if (alpha > 1.0)
+		return 1.0;
+	else if (alpha < 0.0)
+		return 0.0;
+	else
+		return alpha;
+}
+
+static VALUE alloc(VALUE self)
+{
+	SUColor* color;
+	VALUE obj = Data_Make_Struct(self, SUColor, 0, RUBY_DEFAULT_FREE, color);
+	color->red = 0;
+	color->green = 0;
+	color->blue = 0;
+	color->alpha = 255;
+	return obj;
+}
+
+static VALUE Sketchup_Color_names(VALUE self)
+{
+	size_t count = 0;
+	SUColorGetNumNames(&count);
+	SUStringRef* names = malloc(count * sizeof(SUStringRef));
+	for (int i = 0; i < count; i++)
+	{
+		names[i].ptr = 0;
+		SUStringCreate(&names[i]);
+	}
+	SUColorGetNames(names, count);
+	VALUE ary = rb_ary_new2(count);
+	for (int i = 0; i < count; i++)
+	{
+		VALUE name;
+		GETUTF8FROMSTRING(names[i], name);
+		rb_ary_push(ary, name);
+	}
+	for (int i = 0; i < count; i++)
+	{
+		SUStringRelease(&names[i]);
+	}
+	free(names);
+	return ary;
+}
+
+static VALUE Sketchup_Color_initialize(int argc, VALUE* argv, VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	if (argc == 1)
+	{
+		if (rb_type(argv[0]) == T_STRING) // && check if string is part of the list
+		{
+			SUColorSetByName(color, StringValuePtr(argv[0]));
+		}
+		else if (rb_type(argv[0]) == T_FIXNUM) // && check if its hex
+		{
+			SUColorSetByValue(color, NUM2INT(argv[0]));
+		}
+	}
+	else if (argc == 3)
+	{
+		color->red = GETCOLOR(argv[0]);
+		color->green = GETCOLOR(argv[1]);
+		color->blue = GETCOLOR(argv[2]);
+		color->alpha = 255;
+	}
+	else if (argc == 4)
+	{
+		color->red = GETCOLOR(argv[0]);
+		color->green = GETCOLOR(argv[1]);
+		color->blue = GETCOLOR(argv[2]);
+		color->alpha = GETALPHA(argv[3]);
+	}
+	return self;
+}
+
+static VALUE Sketchup_Color_equ(VALUE self, VALUE other)
+{
+	SUColor* color = DATA_PTR(self);
+	SUColor* otherColor = DATA_PTR(other);
+	return (color->red == otherColor->red && color->green == otherColor->green && color->blue == otherColor->blue && color->alpha == otherColor->alpha)
+		? Qtrue
+		: Qfalse;
+}
+
+static VALUE Sketchup_Color_Get_alpha(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	return INT2NUM(color->alpha);
+}
+
+static VALUE Sketchup_Color_Set_alpha(VALUE self, VALUE alpha)
+{
+	SUColor* color = DATA_PTR(self);
+	color->alpha = NUM2INT(alpha);
+	return alpha;
+}
+
+static VALUE Sketchup_Color_blend(VALUE self, VALUE other, VALUE weight)
+{
+	SUColor* color = DATA_PTR(self);
+	SUColor* otherColor = DATA_PTR(other);
+	VALUE output = rb_obj_alloc(rb_path2class(SKETCHUP_COLOR));
+	SUColor* outputColor = DATA_PTR(output);
+	SUColorBlend(*color, *otherColor, NUM2DBL(weight), outputColor);
+	return output;
+}
+
+static VALUE Sketchup_Color_Get_blue(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	return INT2NUM(color->blue);
+}
+
+static VALUE Sketchup_Color_Set_blue(VALUE self, VALUE blue)
+{
+	SUColor* color = DATA_PTR(self);
+	color->blue = NUM2INT(blue);
+	return blue;
+}
+
+static VALUE Sketchup_Color_Get_green(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	return INT2NUM(color->green);
+}
+
+static VALUE Sketchup_Color_Set_green(VALUE self, VALUE green)
+{
+	SUColor* color = DATA_PTR(self);
+	color->green = NUM2INT(green);
+	return green;
+}
+
+static VALUE Sketchup_Color_Get_red(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	return INT2NUM(color->red);
+}
+
+static VALUE Sketchup_Color_Set_red(VALUE self, VALUE red)
+{
+	SUColor* color = DATA_PTR(self);
+	color->red = NUM2INT(red);
+	return red;
+}
+
+static VALUE Sketchup_Color_to_a(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	VALUE ary = rb_ary_new2(4);
+	rb_ary_push(ary, INT2NUM(color->red));
+	rb_ary_push(ary, INT2NUM(color->green));
+	rb_ary_push(ary, INT2NUM(color->blue));
+	rb_ary_push(ary, INT2NUM(color->alpha));
+	return ary;
+}
+
+static VALUE Sketchup_Color_to_i(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	return INT2NUM(color->red | color->green << 8 | color->blue << 16);
+}
+
+static VALUE Sketchup_Color_to_s(VALUE self)
+{
+	SUColor* color = DATA_PTR(self);
+	VALUE output;
+	output = rb_sprintf("Color(%d, %d, %d, %d)", color->red, color->green, color->blue, color->alpha);
+	return output;
+}
+
+void Color_Init(VALUE Sketchup, VALUE Sketchup_Object)
+{
+	VALUE Sketchup_Color = rb_define_class_under(Sketchup, COLOR, Sketchup_Object);
+	rb_define_alloc_func(Sketchup_Color, alloc);
+	rb_define_singleton_method(Sketchup_Color, "names", Sketchup_Color_names, 0);
+	rb_define_method(Sketchup_Color, "initialize", Sketchup_Color_initialize, -1);
+	rb_define_method(Sketchup_Color, "==", Sketchup_Color_equ, 1);
+	rb_define_method(Sketchup_Color, "alpha", Sketchup_Color_Get_alpha, 0);
+	rb_define_method(Sketchup_Color, "alpha=", Sketchup_Color_Set_alpha, 1);
+	rb_define_method(Sketchup_Color, "blend", Sketchup_Color_blend, 2);
+	rb_define_method(Sketchup_Color, "blue", Sketchup_Color_Get_blue, 0);
+	rb_define_method(Sketchup_Color, "blue=", Sketchup_Color_Set_blue, 1);
+	rb_define_method(Sketchup_Color, "green", Sketchup_Color_Get_green, 0);
+	rb_define_method(Sketchup_Color, "green=", Sketchup_Color_Set_green, 1);
+	rb_define_method(Sketchup_Color, "red", Sketchup_Color_Get_red, 0);
+	rb_define_method(Sketchup_Color, "red=", Sketchup_Color_Set_red, 1);
+	rb_define_method(Sketchup_Color, "to_a", Sketchup_Color_to_a, 0);
+	rb_define_method(Sketchup_Color, "to_i", Sketchup_Color_to_i, 0);
+	rb_define_method(Sketchup_Color, "to_s", Sketchup_Color_to_s, 0);
+}

data/ext/color.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+void Color_Init(VALUE namespace_object, VALUE parent_class);

data/ext/component_definition.c

@@ -0,0 +1,188 @@
+#include <stdbool.h>
+#include <component_definition.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+static VALUE Sketchup_ComponentDefinition_Get_name(VALUE self)
+{
+	VALUE output;
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	GETSTRING(SUComponentDefinitionGetName, definition, output);
+	return output;
+}
+
+static VALUE Sketchup_ComponentDefinition_Set_name(VALUE self, VALUE name)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	SUComponentDefinitionSetName(definition, StringValuePtr(name));
+	return name;
+}
+
+static VALUE Sketchup_ComponentDefinition_Name_equ(VALUE self, VALUE other)
+{
+	if (!rb_obj_is_kind_of(other, rb_path2class(SKETCHUP_COMPONENTDEFINITION)))
+		return Qnil;
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wcompound-token-split-by-macro"
+	return rb_funcall(Sketchup_ComponentDefinition_Get_name(self), rb_intern("<=>"), 1, Sketchup_ComponentDefinition_Get_name(other));
+#pragma clang diagnostic pop
+}
+
+static VALUE Sketchup_ComponentDefinition_Object_equ(VALUE self, VALUE other)
+{
+	if (!rb_obj_is_kind_of(other, rb_path2class(SKETCHUP_COMPONENTDEFINITION)))
+		return Qfalse;
+	SUComponentDefinitionRef definition1 = {DATA_PTR(self)};
+	SUComponentDefinitionRef definition2 = {DATA_PTR(other)};
+	return definition1.ptr == definition2.ptr;
+}
+
+void Sketchup_ComponentDefinition_instances_Iterator(SUComponentInstanceRef componentInstance, VALUE ary)
+{
+	rb_ary_push(ary, Data_Wrap_Struct(rb_path2class(SKETCHUP_COMPONENTINSTANCE), 0, 0, componentInstance.ptr));
+}
+
+static VALUE Sketchup_ComponentDefinition_instances(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	VALUE ary = rb_ary_new();
+	FOREACH(
+		SUComponentDefinitionGetNumInstances,
+		SUComponentDefinitionGetInstances,
+		SUComponentInstanceRef,
+		definition,
+		Sketchup_ComponentDefinition_instances_Iterator,
+		ary);
+	return ary;
+}
+
+static VALUE Sketchup_ComponentDefinition_count_instances(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	size_t count = 0;
+	SUComponentDefinitionGetNumInstances(definition, &count);
+	return INT2NUM(count);
+}
+
+static VALUE Sketchup_ComponentDefinition_count_used_instances(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	size_t count = 0;
+	SUComponentDefinitionGetNumUsedInstances(definition, &count);
+	return INT2NUM(count);
+}
+
+static VALUE Sketchup_ComponentDefinition_live_component(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	bool output = false;
+	SUComponentDefinitionIsLiveComponent(definition, &output);
+	return output ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_ComponentDefinition_internal(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	bool is_internal = false;
+	SUComponentDefinitionIsInternal(definition, &is_internal);
+	return is_internal ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_ComponentDefinition_entities(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	SUEntitiesRef entities;
+	SUComponentDefinitionGetEntities(definition, &entities);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_ENTITIES), 0, 0, entities.ptr);
+}
+
+static VALUE Sketchup_ComponentDefinition_path(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	VALUE output;
+	GETSTRING(SUComponentDefinitionGetPath, definition, output);
+	return output;
+}
+
+static VALUE Sketchup_ComponentDefinition_guid(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	VALUE output;
+	GETSTRING(SUComponentDefinitionGetGuid, definition, output);
+	return output;
+}
+
+static VALUE Sketchup_ComponentDefinition_group(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	enum SUComponentType type = SUComponentType_Normal;
+	SUComponentDefinitionGetType(definition, &type);
+	return type == SUComponentType_Group ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_ComponentDefinition_Get_description(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	VALUE output;
+	GETSTRING(SUComponentDefinitionGetDescription, definition, output);
+	return output;
+}
+
+static VALUE Sketchup_ComponentDefinition_Set_description(VALUE self, VALUE description)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	SUComponentDefinitionSetDescription(definition, StringValuePtr(description));
+	return description;
+}
+
+static VALUE Sketchup_ComponentDefinition_image(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	SUImageRef image = SUImageFromDrawingElement(SUComponentDefinitionToDrawingElement(definition));
+	return SUIsValid(image) ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_ComponentDefinition_behavior(VALUE self)
+{
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	struct SUComponentBehavior behavior;
+	SUComponentDefinitionGetBehavior(definition, &behavior);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_BEHAVIOR), 0, 0, &behavior);
+}
+
+static VALUE Sketchup_ComponentDefinition_save_as(int argc, VALUE* argv, VALUE self)
+{
+	VALUE path;
+	VALUE version;
+	rb_scan_args(argc, argv, "11", &path, &version);
+
+	SUComponentDefinitionRef definition = {DATA_PTR(self)};
+	enum SUResult result = SUComponentDefinitionSaveToFile(definition, StringValuePtr(path), NIL_P(version) ? SUModelVersion_Current : NUM2INT(version));
+	if (result != SU_ERROR_NONE)
+		return Qnil;
+	return Qtrue;
+}
+
+VALUE ComponentDefinition_Init(VALUE Sketchup, VALUE Sketchup_DrawingElement)
+{
+	VALUE Sketchup_ComponentDefinition = rb_define_class_under(Sketchup, COMPONENTDEFINITION, Sketchup_DrawingElement);
+	rb_define_method(Sketchup_ComponentDefinition, "name", Sketchup_ComponentDefinition_Get_name, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "name=", Sketchup_ComponentDefinition_Set_name, 1);
+	rb_define_method(Sketchup_ComponentDefinition, "==", Sketchup_ComponentDefinition_Object_equ, 1);
+	rb_define_method(Sketchup_ComponentDefinition, "<=>", Sketchup_ComponentDefinition_Name_equ, 1);
+	rb_define_method(Sketchup_ComponentDefinition, "instances", Sketchup_ComponentDefinition_instances, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "count_instances", Sketchup_ComponentDefinition_count_instances, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "count_used_instances", Sketchup_ComponentDefinition_count_used_instances, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "live_component?", Sketchup_ComponentDefinition_live_component, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "internal?", Sketchup_ComponentDefinition_internal, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "entities", Sketchup_ComponentDefinition_entities, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "path", Sketchup_ComponentDefinition_path, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "guid", Sketchup_ComponentDefinition_guid, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "group?", Sketchup_ComponentDefinition_group, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "description", Sketchup_ComponentDefinition_Get_description, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "description=", Sketchup_ComponentDefinition_Set_description, 1);
+	rb_define_method(Sketchup_ComponentDefinition, "image?", Sketchup_ComponentDefinition_image, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "behavior", Sketchup_ComponentDefinition_behavior, 0);
+	rb_define_method(Sketchup_ComponentDefinition, "save_as", Sketchup_ComponentDefinition_save_as, -1);
+	return Sketchup_ComponentDefinition;
+}

data/ext/component_definition.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE ComponentDefinition_Init(VALUE namespace_object, VALUE parent_class);

data/ext/component_instance.c

@@ -0,0 +1,10 @@
+#include <stdbool.h>
+#include <component_instance.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+VALUE ComponentInstance_Init(VALUE Sketchup, VALUE Sketchup_DrawingElement)
+{
+	VALUE Sketchup_ComponentInstance = rb_define_class_under(Sketchup, COMPONENTINSTANCE, Sketchup_DrawingElement);
+	return Sketchup_ComponentInstance;
+}

data/ext/component_instance.h

@@ -0,0 +1,3 @@
+#include <ruby.h>
+
+VALUE ComponentInstance_Init(VALUE namespace_object, VALUE parent_class);