scriptup 2024.0.7 → 2026.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6597ffd855e1a87875e86744453c200a9aeceee06dd747ac0cb0a6b25607b554
-  data.tar.gz: 2f4ade8f2b5603aa1e00ffe10463c58cac08072fb1a84f82ce4f6a275df72cb3
+  metadata.gz: de7954cf033c906f4d616252f7e97ecfb2af66dabf09e2d2232667fbe2998b46
+  data.tar.gz: 914025ce525683c84f3dd7fd085fe724bea481dc150832142e38450a928d1279
 SHA512:
-  metadata.gz: aa296640ed6edcd606e7ce9c7aacad26b2f23d1fac2e450495ad7c88ccbd1dc281db92c2ef69a97788aebc102bf2a627a79376040fca4a4f989293abbd7acd98
-  data.tar.gz: 3b887ba13ef1f3002218d4a7ea4ff4e6585884e29c01d6f843dabca81ec685841ed74bafedae6ab6b36605c541edc164a102a5f69a79f5291de544a63e4fbdca
+  metadata.gz: 30ff6b2d9eaa4502d60470af7d69f08b7567bffba2ce0ee0d794511dff81ae44c057b70dd89597ede3869d6cd3cb54dfb39f87082a04fcad047401d68e9e49b6
+  data.tar.gz: a97541530c5ce94f7e0f56c80a8ba94c11da95a56f7199694b7163082e54aa4119175f636eba33ff4a3fc62194ac81c78a688a91086da9ae3704c83d4793e44b

data/README.md

@@ -12,13 +12,13 @@ The SketchUp C API is much more limmited than the ruby api.  There is no gui eve
 * Definition List
 * Entity
 * Material
+* Drawingelement
+* Texture
 
 # Partially implemented classes
 * Attribute Dictionaries
 * Behavior
 * Component Instance
-* Drawing Element
 * Entities
 * Materials
-* Model
-* Texture
+* Model

data/ext/attribute_dictionaries.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_ATTRIBUTE_DICTIONARIES_H
+#define SCRIPTUP_ATTRIBUTE_DICTIONARIES_H
+
 #include <ruby.h>
 
-VALUE AttributeDictionaries_Init(VALUE namespace_object, VALUE parent_class);
+VALUE AttributeDictionaries_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_ATTRIBUTE_DICTIONARIES_H

data/ext/attribute_dictionary.c

@@ -153,5 +153,6 @@ VALUE AttributeDictionary_Init(VALUE Sketchup, VALUE Sketchup_Entity)
 	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);
+	rb_define_alias(Sketchup_AttributeDictionary, "count", "size");
 	return Sketchup_AttributeDictionary;
 }

data/ext/attribute_dictionary.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_ATTRIBUTE_DICTIONARY_H
+#define SCRIPTUP_ATTRIBUTE_DICTIONARY_H
+
 #include <ruby.h>
 
-VALUE AttributeDictionary_Init(VALUE namespace_object, VALUE parent_class);
+VALUE AttributeDictionary_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_ATTRIBUTE_DICTIONARY_H

data/ext/behavior.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_BEHAVIOR_H
+#define SCRIPTUP_BEHAVIOR_H
+
 #include <ruby.h>
 
-VALUE Behavior_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Behavior_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_BEHAVIOR_H

data/ext/color.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_COLOR_H
+#define SCRIPTUP_COLOR_H
+
 #include <ruby.h>
 
-void Color_Init(VALUE namespace_object, VALUE parent_class);
+void Color_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_COLOR_H

data/ext/component_definition.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_COMPONENT_DEFINITION_H
+#define SCRIPTUP_COMPONENT_DEFINITION_H
+
 #include <ruby.h>
 
-VALUE ComponentDefinition_Init(VALUE namespace_object, VALUE parent_class);
+VALUE ComponentDefinition_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_COMPONENT_DEFINITION_H

data/ext/component_instance.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_COMPONENT_INSTANCE_H
+#define SCRIPTUP_COMPONENT_INSTANCE_H
+
 #include <ruby.h>
 
-VALUE ComponentInstance_Init(VALUE namespace_object, VALUE parent_class);
+VALUE ComponentInstance_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_COMPONENT_INSTANCE_H

data/ext/definition_list.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_DEFINITION_LIST_H
+#define SCRIPTUP_DEFINITION_LIST_H
+
 #include <ruby.h>
 
-VALUE DefinitionList_Init(VALUE namespace_object, VALUE parent_class);
+VALUE DefinitionList_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_DEFINITION_LIST_H

data/ext/drawing_element.c

@@ -1,11 +1,146 @@
 #include <stdbool.h>
 #include <drawing_element.h>
+#include <not_implemented.h>
 #include <utils.h>
 #include <SketchUpAPI/sketchup.h>
 
+static VALUE Sketchup_DrawingElement_bounds(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	struct SUBoundingBox3D* bbox = 0;
+	SUDrawingElementGetBoundingBox(drawing_element, bbox);
+	return Data_Make_Struct(rb_path2class(GEOM_BOUNDINGBOX), struct SUBoundingBox3D, 0, RUBY_DEFAULT_FREE, bbox);
+}
+
+static VALUE Sketchup_DrawingElement_Get_casts_shadows(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	bool casts_shadows_flag = false;
+	SUDrawingElementGetCastsShadows(drawing_element, &casts_shadows_flag);
+	return casts_shadows_flag ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_DrawingElement_Set_casts_shadows(VALUE self, VALUE casts_shadows_flag)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	SUDrawingElementSetCastsShadows(drawing_element, RTEST(casts_shadows_flag));
+	return casts_shadows_flag;
+}
+
+static VALUE Sketchup_DrawingElement_Get_receives_shadows(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	bool receives_shadows_flag = false;
+	SUDrawingElementGetReceivesShadows(drawing_element, &receives_shadows_flag);
+	return receives_shadows_flag ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_DrawingElement_Set_receives_shadows(VALUE self, VALUE receives_shadows_flag)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	SUDrawingElementSetReceivesShadows(drawing_element, RTEST(receives_shadows_flag));
+	return receives_shadows_flag;
+}
+
+static VALUE Sketchup_DrawingElement_Get_hidden(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	bool hide_flag = false;
+	SUDrawingElementGetHidden(drawing_element, &hide_flag);
+	return hide_flag ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_DrawingElement_Set_hidden(VALUE self, VALUE hide_flag)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	SUDrawingElementSetHidden(drawing_element, RTEST(hide_flag));
+	return hide_flag;
+}
+
+static VALUE Sketchup_DrawingElement_Get_visible(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	bool hide_flag = false;
+	SUDrawingElementGetHidden(drawing_element, &hide_flag);
+	return hide_flag ? Qfalse : Qtrue;
+}
+
+static VALUE Sketchup_DrawingElement_Set_visible(VALUE self, VALUE visible_flag)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	SUDrawingElementSetHidden(drawing_element, RTEST(visible_flag));
+	return visible_flag;
+}
+
+static VALUE Sketchup_DrawingElement_Get_material(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	SUMaterialRef material = SU_INVALID;
+	SUDrawingElementGetMaterial(drawing_element, &material);
+	if (SUIsInvalid(material))
+		return Qnil;
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_MATERIAL), 0, 0, material.ptr);
+}
+
+static VALUE Sketchup_DrawingElement_Set_material(VALUE self, VALUE material)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	if (rb_type(material) == T_NIL)
+	{
+		SUMaterialRef empty_material = SU_INVALID;
+		SUDrawingElementSetMaterial(drawing_element, empty_material);
+		return Qnil;
+	}
+	if (!rb_obj_is_kind_of(material, rb_path2class(SKETCHUP_MATERIAL)))
+		rb_raise(rb_eTypeError, "Wrong type of object given");
+
+	SUMaterialRef drawing_element_material = {DATA_PTR(material)};
+	SUDrawingElementSetMaterial(drawing_element, drawing_element_material);
+	return material;
+}
+
+static VALUE Sketchup_DrawingElement_Get_layer(VALUE self)
+{
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};
+	SULayerRef layer = SU_INVALID;
+	SUDrawingElementGetLayer(drawing_element, &layer);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_LAYER), 0, 0, layer.ptr);
+}
+
+static VALUE Sketchup_DrawingElement_Set_layer(VALUE self, VALUE layer)
+{
+	if (rb_type(layer) == T_NIL)
+	{
+		SUDrawingElementRef drawing_element = {DATA_PTR(self)};	
+		SULayerRef drawing_element_layer = SU_INVALID;
+		SUDrawingElementSetLayer(drawing_element, drawing_element_layer);
+		return Qnil;
+	}
+	if (!rb_obj_is_kind_of(layer, rb_path2class(SKETCHUP_LAYER)))
+		rb_raise(rb_eArgError, "Wrong type of object given");
+
+	SUDrawingElementRef drawing_element = {DATA_PTR(self)};	
+	SULayerRef drawing_element_layer = {DATA_PTR(layer)};
+	SUDrawingElementSetLayer(drawing_element, drawing_element_layer);
+	return layer;
+}
+
 VALUE DrawingElement_Init(VALUE Sketchup, VALUE Sketchup_Entity)
 {
 	VALUE Sketchup_DrawingElement = rb_define_class_under(Sketchup, DRAWINGELEMENT, Sketchup_Entity);
 	rb_undef_alloc_func(Sketchup_DrawingElement);
+	rb_define_method(Sketchup_DrawingElement, "bounds", Sketchup_DrawingElement_bounds, 0);
+	rb_define_method(Sketchup_DrawingElement, "casts_shadows?", Sketchup_DrawingElement_Get_casts_shadows, 0);
+	rb_define_method(Sketchup_DrawingElement, "casts_shadows=", Sketchup_DrawingElement_Set_casts_shadows, 1);
+	rb_define_method(Sketchup_DrawingElement, "receives_shadows?", Sketchup_DrawingElement_Get_receives_shadows, 0);
+	rb_define_method(Sketchup_DrawingElement, "receives_shadows=", Sketchup_DrawingElement_Set_receives_shadows, 1);
+	rb_define_method(Sketchup_DrawingElement, "hidden?", Sketchup_DrawingElement_Get_hidden, 0);
+	rb_define_method(Sketchup_DrawingElement, "hidden=", Sketchup_DrawingElement_Set_hidden, 1);
+	rb_define_method(Sketchup_DrawingElement, "visible?", Sketchup_DrawingElement_Get_visible, 0);
+	rb_define_method(Sketchup_DrawingElement, "visible=", Sketchup_DrawingElement_Set_visible, 1);
+	rb_define_method(Sketchup_DrawingElement, "material", Sketchup_DrawingElement_Get_material, 0);
+	rb_define_method(Sketchup_DrawingElement, "material=", Sketchup_DrawingElement_Set_material, 1);
+	rb_define_method(Sketchup_DrawingElement, "layer", Sketchup_DrawingElement_Get_layer, 0);
+	rb_define_method(Sketchup_DrawingElement, "layer=", Sketchup_DrawingElement_Set_layer, 1);
 	return Sketchup_DrawingElement;
 }

data/ext/drawing_element.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_DRAWING_ELEMENT_H
+#define SCRIPTUP_DRAWING_ELEMENT_H
+
 #include <ruby.h>
 
-VALUE DrawingElement_Init(VALUE namespace_object, VALUE parent_class);
+VALUE DrawingElement_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_DRAWING_ELEMENT_H

data/ext/entities.c

@@ -3,10 +3,23 @@
 #include <SketchUpAPI/sketchup.h>
 #include <utils.h>
 
+void Sketchup_Entities_Iterator(SUFaceRef face, void* _)
+{
+	rb_yield(Data_Wrap_Struct(rb_path2class(SKETCHUP_FACE), 0, 0, face.ptr));
+}
+
+static VALUE Sketchup_Entities_each(VALUE self)
+{
+	SUEntitiesRef entities = {DATA_PTR(self)};
+	FOREACH(SUEntitiesGetNumFaces, SUEntitiesGetFaces, SUFaceRef, entities, Sketchup_Entities_Iterator, 0);
+	return self;
+}
 
 VALUE Entities_Init(VALUE Sketchup, VALUE rb_cObject)
 {
 	VALUE Sketchup_Entities = rb_define_class_under(Sketchup, ENTITIES, rb_cObject);
 	rb_undef_alloc_func(Sketchup_Entities);
+	rb_include_module(Sketchup_Entities, rb_mEnumerable);
+	rb_define_method(Sketchup_Entities, "each", Sketchup_Entities_each, 0);
 	return Sketchup_Entities;
 }

data/ext/entities.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_ENTITIES_H
+#define SCRIPTUP_ENTITIES_H
+
 #include <ruby.h>
 
-VALUE Entities_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Entities_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_ENTITIES_H

data/ext/entity.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_ENTITY_H
+#define SCRIPTUP_ENTITY_H
+
 #include <ruby.h>
 
-VALUE Entity_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Entity_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_ENTITY_H

data/ext/material.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_MATERIAL_H
+#define SCRIPTUP_MATERIAL_H
+
 #include <ruby.h>
 
-void Material_Init(VALUE namespace_object, VALUE parent_class);
+void Material_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_MATERIAL_H

data/ext/materials.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_MATERIALS_H
+#define SCRIPTUP_MATERIALS_H
+
 #include <ruby.h>
 
-VALUE Materials_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Materials_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_MATERIALS_H

data/ext/model.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_MODEL_H
+#define SCRIPTUP_MODEL_H
+
 #include <ruby.h>
 
-VALUE Model_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Model_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_MODEL_H

data/ext/not_implemented.c

@@ -0,0 +1,88 @@
+#include <stdbool.h>
+#include <not_implemented.h>
+#include <utils.h>
+#include <SketchUpAPI/sketchup.h>
+
+VALUE BoundingBox_Init(VALUE Geom, VALUE Sketchup_Object)
+{
+	VALUE Geom_BoundingBox = rb_define_class_under(Geom, BOUNDINGBOX, Sketchup_Object);
+	rb_undef_alloc_func(Geom_BoundingBox);
+	return Geom_BoundingBox;
+}
+
+VALUE Face_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_Face = rb_define_class_under(Sketchup, FACE, DrawingElement);
+	rb_undef_alloc_func(Sketchup_Face);
+	return Sketchup_Face;
+}
+
+VALUE Layer_Init(VALUE Sketchup, VALUE Entity)
+{
+	VALUE Sketchup_Layer = rb_define_class_under(Sketchup, LAYER, Entity);
+	rb_undef_alloc_func(Sketchup_Layer);
+	return Sketchup_Layer;
+}
+
+VALUE ConstructionLine_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_ConstructionLine = rb_define_class_under(Sketchup, CONSTRUCTIONLINE, DrawingElement);
+	rb_undef_alloc_func(Sketchup_ConstructionLine);
+	return Sketchup_ConstructionLine;
+}
+
+VALUE ConstructionPoint_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_ConstructionPoint = rb_define_class_under(Sketchup, CONSTRUCTIONPOINT, DrawingElement);
+	rb_undef_alloc_func(Sketchup_ConstructionPoint);
+	return Sketchup_ConstructionPoint;
+}
+
+VALUE Dimension_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_Dimension = rb_define_class_under(Sketchup, DIMENSION, DrawingElement);
+	rb_undef_alloc_func(Sketchup_Dimension);
+	return Sketchup_Dimension;
+}
+
+VALUE Edge_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_Edge = rb_define_class_under(Sketchup, EDGE, DrawingElement);
+	rb_undef_alloc_func(Sketchup_Edge);
+	return Sketchup_Edge;
+}
+
+VALUE Group_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_Group = rb_define_class_under(Sketchup, GROUP, DrawingElement);
+	rb_undef_alloc_func(Sketchup_Group);
+	return Sketchup_Group;
+}
+
+VALUE Image_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_Image = rb_define_class_under(Sketchup, IMAGE, DrawingElement);
+	rb_undef_alloc_func(Sketchup_Image);
+	return Sketchup_Image;
+}
+
+VALUE SectionPlane_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_SectionPlane = rb_define_class_under(Sketchup, SECTIONPLANE, DrawingElement);
+	rb_undef_alloc_func(Sketchup_SectionPlane);
+	return Sketchup_SectionPlane;
+}
+
+VALUE Text_Init(VALUE Sketchup, VALUE DrawingElement)
+{
+	VALUE Sketchup_Text = rb_define_class_under(Sketchup, TEXT, DrawingElement);
+	rb_undef_alloc_func(Sketchup_Text);
+	return Sketchup_Text;
+}
+
+VALUE ImageRep_Init(VALUE Sketchup, VALUE Sketchup_Object)
+{
+	VALUE Sketchup_ImageRep = rb_define_class_under(Sketchup, IMAGEREP, Sketchup_Object);
+	rb_undef_alloc_func(Sketchup_ImageRep);
+	return Sketchup_ImageRep;
+}

data/ext/not_implemented.h

@@ -0,0 +1,20 @@
+#ifndef SCRIPTUP_NOT_IMPLEMENTED_H
+#define SCRIPTUP_NOT_IMPLEMENTED_H
+
+#include <ruby.h>
+
+VALUE BoundingBox_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Face_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Layer_Init(VALUE namespace_object, VALUE parent_class);
+VALUE ConstructionLine_Init(VALUE namespace_object, VALUE parent_class);
+VALUE ConstructionPoint_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Dimension_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Edge_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Group_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Image_Init(VALUE namespace_object, VALUE parent_class);
+VALUE SectionPlane_Init(VALUE namespace_object, VALUE parent_class);
+VALUE Text_Init(VALUE namespace_object, VALUE parent_class);
+VALUE ImageRep_Init(VALUE namespace_object, VALUE parent_class);
+
+
+#endif // SCRIPTUP_NOT_IMPLEMENTED_H

data/ext/sketchup.c

@@ -15,6 +15,7 @@
 #include <definition_list.h>
 #include <drawing_element.h>
 #include <behavior.h>
+#include <not_implemented.h>
 #include <utils.h>
 
 SUModelRef active_model = SU_INVALID;
@@ -72,6 +73,7 @@ void Init_sketchup() {
 
 	Model_Init(Sketchup, rb_cObject);
 	Color_Init(Sketchup, rb_cObject);
+	ImageRep_Init(Sketchup, rb_cObject);
 
 	Entities_Init(Sketchup, rb_cObject);
 	VALUE Sketchup_Entity = Entity_Init(Sketchup, rb_cObject);
@@ -82,8 +84,21 @@ void Init_sketchup() {
 	AttributeDictionaries_Init(Sketchup, Sketchup_Entity);
 	Texture_Init(Sketchup, Sketchup_Entity);
 	Behavior_Init(Sketchup, Sketchup_Entity);
+	Layer_Init(Sketchup, Sketchup_Entity);
 	
+	VALUE Geom = rb_define_module(GEOM);
+	BoundingBox_Init(Geom, rb_cObject);
+
 	VALUE Sketchup_DrawingElement = DrawingElement_Init(Sketchup, Sketchup_Entity);
 	ComponentInstance_Init(Sketchup, Sketchup_DrawingElement);
 	ComponentDefinition_Init(Sketchup, Sketchup_DrawingElement);
+	Face_Init(Sketchup, Sketchup_DrawingElement);
+	ConstructionLine_Init(Sketchup, Sketchup_DrawingElement);
+	ConstructionPoint_Init(Sketchup, Sketchup_DrawingElement);
+	Dimension_Init(Sketchup, Sketchup_DrawingElement);
+	Edge_Init(Sketchup, Sketchup_DrawingElement);
+	Group_Init(Sketchup, Sketchup_DrawingElement);
+	Image_Init(Sketchup, Sketchup_DrawingElement);
+	SectionPlane_Init(Sketchup, Sketchup_DrawingElement);
+	Text_Init(Sketchup, Sketchup_DrawingElement);
 }

data/ext/sketchup.h

@@ -1,4 +1,9 @@
+#ifndef SCRIPTUP_SKETCHUP_H
+#define SCRIPTUP_SKETCHUP_H
+
 #include <SketchUpAPI/sketchup.h>
 
 SUModelRef Sketchup_get_active_model();
-void Sketchup_set_active_model(SUModelRef model);
+void Sketchup_set_active_model(SUModelRef model);
+
+#endif // SCRIPTUP_SKETCHUP_H

data/ext/texture.c

@@ -1,10 +1,109 @@
 #include <stdbool.h>
 #include <texture.h>
 #include <SketchUpAPI/sketchup.h>
+#include <not_implemented.h>
 #include <utils.h>
 
+static VALUE Sketchup_Texture_average_color(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	VALUE c = rb_obj_alloc(rb_path2class(SKETCHUP_COLOR));
+	SUColor* color = DATA_PTR(c);
+	enum SUResult result = SUTextureGetAverageColor(texture, color);
+	if (result != SU_ERROR_NONE)
+		return Qnil;
+	return c;
+}
+
+static VALUE Sketchup_Texture_filename(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	VALUE output;
+	GETSTRING(SUTextureGetFileName, texture, output);
+	return output;
+}
+
+static VALUE Sketchup_Texture_image_height(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	size_t width = 0;
+	size_t height = 0;
+	double s_scale = 0.0;
+	double t_scale = 0.0;
+	SUTextureGetDimensions(texture, &width, &height, &s_scale, &t_scale);
+	return ULL2NUM(height);
+}
+
+static VALUE Sketchup_Texture_height(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	size_t width = 0;
+	size_t height = 0;
+	double s_scale = 0.0;
+	double t_scale = 0.0;
+	SUTextureGetDimensions(texture, &width, &height, &s_scale, &t_scale);
+	return DBL2NUM(1.0 / t_scale);
+}
+
+static VALUE Sketchup_Texture_width(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	size_t width = 0;
+	size_t height = 0;
+	double s_scale = 0.0;
+	double t_scale = 0.0;
+	SUTextureGetDimensions(texture, &width, &height, &s_scale, &t_scale);
+	return DBL2NUM(1.0 / s_scale);
+}
+
+static VALUE Sketchup_Texture_image_width(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	size_t width = 0;
+	size_t height = 0;
+	double s_scale = 0.0;
+	double t_scale = 0.0;
+	SUTextureGetDimensions(texture, &width, &height, &s_scale, &t_scale);
+	return ULL2NUM(width);
+}
+
+static VALUE Sketchup_Texture_image_rep(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	SUImageRepRef image = SU_INVALID;
+	SUTextureGetImageRep(texture, &image);
+	return Data_Wrap_Struct(rb_path2class(SKETCHUP_IMAGEREP), 0, 0, image.ptr);
+}
+
+static VALUE Sketchup_Texture_Get_valid(VALUE self)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	return SUIsValid(texture) ? Qtrue : Qfalse;
+}
+
+static VALUE Sketchup_Texture_write(VALUE self, VALUE path, VALUE colorize)
+{
+	SUTextureRef texture = {DATA_PTR(self)};
+	const char* path_ptr = StringValuePtr(path);
+	enum SUResult result = SU_ERROR_UNSUPPORTED;
+	if (RTEST(colorize))
+		result = SUTextureWriteToFile(texture, path_ptr);
+	else
+		result = SUTextureWriteOriginalToFile(texture, path_ptr);
+	return result != SU_ERROR_NONE ? Qfalse : Qtrue;
+}
+
 void Texture_Init(VALUE Sketchup, VALUE Sketchup_Entity)
 {
 	VALUE Sketchup_Texture = rb_define_class_under(Sketchup, TEXTURE, Sketchup_Entity);
 	rb_undef_alloc_func(Sketchup_Texture);
+	rb_define_method(Sketchup_Texture, "average_color", Sketchup_Texture_average_color, 0);
+	rb_define_method(Sketchup_Texture, "filename", Sketchup_Texture_filename, 0);
+	rb_define_method(Sketchup_Texture, "image_height", Sketchup_Texture_image_height, 0);
+	rb_define_method(Sketchup_Texture, "height", Sketchup_Texture_height, 0);
+	rb_define_method(Sketchup_Texture, "image_width", Sketchup_Texture_image_width, 0);
+	rb_define_method(Sketchup_Texture, "width", Sketchup_Texture_width, 0);
+	rb_define_method(Sketchup_Texture, "image_rep", Sketchup_Texture_image_rep, 0);
+	rb_define_method(Sketchup_Texture, "valid?", Sketchup_Texture_Get_valid, 0);
+	rb_define_method(Sketchup_Texture, "write", Sketchup_Texture_write, 2);
 }

data/ext/texture.h

@@ -1,3 +1,8 @@
+#ifndef SCRIPTUP_TEXTURE_H
+#define SCRIPTUP_TEXTURE_H
+
 #include <ruby.h>
 
-void Texture_Init(VALUE namespace_object, VALUE parent_class);
+void Texture_Init(VALUE namespace_object, VALUE parent_class);
+
+#endif // SCRIPTUP_TEXTURE_H

data/ext/typed_value.h

@@ -1,5 +1,11 @@
+#ifndef SCRIPTUP_TYPED_VALUE_H
+#define SCRIPTUP_TYPED_VALUE_H
+
 #include <ruby.h>
 #include <SketchUpAPI/sketchup.h>
 
 VALUE TypedValue_get_value_type(SUTypedValueRef* typedValue);
 VALUE TypedValue_set_value_type(SUTypedValueRef* typedValue, VALUE value);
+
+
+#endif // SCRIPTUP_TYPED_VALUE_H

data/ext/utils.h

@@ -1,7 +1,13 @@
+#ifndef SCRIPTUP_UTILS_H
+#define SCRIPTUP_UTILS_H
+
 #include <ruby.h>
 
-#ifndef UTILS_H
+#ifdef TEXT
+#undef TEXT
+#endif //TEXT
 #define SKETCHUP "Sketchup"
+#define GEOM "Geom"
 #define MODEL "Model"
 #define MATERIAL "Material"
 #define MATERIALS "Materials"
@@ -16,6 +22,18 @@
 #define ATTRIBUTEDICTIONARIES "AttributeDictionaries"
 #define DRAWINGELEMENT "DrawingElement"
 #define BEHAVIOR "Behavior"
+#define BOUNDINGBOX "BoundingBox"
+#define FACE "Face"
+#define LAYER "Layer"
+#define CONSTRUCTIONLINE "ConstructionLine"
+#define CONSTRUCTIONPOINT "ConstructionPoint"
+#define DIMENSION "Dimension"
+#define EDGE "Edge"
+#define IMAGE "Image"
+#define SECTIONPLANE "SectionPlane"
+#define GROUP "Group"
+#define TEXT "Text"
+#define IMAGEREP "ImageRep"
 #define SKETCHUP_MATERIAL SKETCHUP "::" MATERIAL
 #define SKETCHUP_MATERIALS SKETCHUP "::" MATERIALS
 #define SKETCHUP_TEXTURE SKETCHUP "::" TEXTURE
@@ -28,6 +46,18 @@
 #define SKETCHUP_ATTRIBUTEDICTIONARIES SKETCHUP "::" ATTRIBUTEDICTIONARIES
 #define SKETCHUP_DEFINITIONLIST SKETCHUP "::" DEFINITIONLIST
 #define SKETCHUP_BEHAVIOR SKETCHUP "::" BEHAVIOR
+#define GEOM_BOUNDINGBOX GEOM "::" BOUNDINGBOX
+#define SKETCHUP_FACE SKETCHUP "::" FACE
+#define SKETCHUP_LAYER SKETCHUP "::" LAYER
+#define SKETCHUP_CONSTRUCTIONLINE SKETCHUP "::" CONSTRUCTIONLINE
+#define SKETCHUP_CONSTRUCTIONPOINT SKETCHUP "::" CONSTRUCTIONPOINT
+#define SKETCHUP_DIMENSION SKETCHUP "::" DIMENSION
+#define SKETCHUP_EDGER SKETCHUP "::" EDGE
+#define SKETCHUP_IMAGE SKETCHUP "::" IMAGE
+#define SKETCHUP_SECTIONPLANE SKETCHUP "::" SECTIONPLANE
+#define SKETCHUP_GROUP SKETCHUP "::" GROUP
+#define SKETCHUP_TEXT SKETCHUP "::" TEXT
+#define SKETCHUP_IMAGEREP SKETCHUP "::" IMAGEREP
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wbackslash-newline-escape"
@@ -75,6 +105,7 @@
 	GETUTF8FROMSTRING(name, output); \
 	SUStringRelease(&name); \
 }
-#endif // UTILS_H
 
-#pragma clang diagnostic pop
+#pragma clang diagnostic pop
+
+#endif // SCRIPTUP_UTILS_H

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scriptup
 version: !ruby/object:Gem::Version
-  version: 2024.0.7
+  version: 2026.0.0
 platform: ruby
 authors:
 - Noel Warren
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-07 00:00:00.000000000 Z
+date: 2025-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,6 +77,8 @@ files:
 - ext/materials.h
 - ext/model.c
 - ext/model.h
+- ext/not_implemented.c
+- ext/not_implemented.h
 - ext/sketchup.c
 - ext/sketchup.h
 - ext/texture.c
@@ -339,7 +341,7 @@ homepage: https://git.chaosgroup.com/sketchup/sketchup-ruby-bindings
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -355,7 +357,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Ruby bindings for the SketchUp C API
 test_files: []