democracy 0.0.56

data/crystal-gobject/src/g_i_repository/info/object_info.cr

@@ -0,0 +1,170 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:34 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 63 of 16 source files
+module GIRepository
+require_relative "string__"
+    class ObjectInfo < BaseInfo
+    include RegisteredTypeInfo
+    include WrapperGenerator
+
+    each_converted object_info, constant, ConstantInfo
+    each_converted object_info, field, FieldInfo
+    each_converted object_info, method, FunctionInfo
+    each_converted object_info, interface, InterfaceInfo
+    each_converted object_info, property, PropertyInfo, properties
+    each_converted object_info, signal, SignalInfo
+    each_converted object_info, vfunc, VFuncInfo
+
+    def parent
+      ptr = GIRepository.object_info_get_parent self
+      BaseInfo.wrap(ptr).as(ObjectInfo) if ptr
+    end
+
+    def abstract?
+      GIRepository.object_info_get_abstract self
+    end
+
+    def all_properties
+      properties = self.properties # start with our own
+
+      parent = self.parent
+      while parent
+        parent.properties.each do |property|
+          properties << property unless properties.any?(&.name.==(property.name))
+        end
+
+        parent = parent.parent
+      end
+
+      each_interface do |interface|
+        interface.properties.each do |property|
+          properties << property unless properties.any?(&.name.==(property.name))
+        end
+
+      end
+
+      properties.sort_by(&.name.not_nil!)
+    end
+
+    def class_struct
+      info = GIRepository.object_info_get_class_struct(self)
+      BaseInfo.wrap(info).as(StructInfo) if info
+    end
+
+    def lib_definition(builder)
+      builder.end_of_line_comment "object"
+      builder.def_struct(name) do
+        each_field &.lib_definition(builder)
+        field_binding "_data", "UInt8[0]" if fields_size == 0
+
+        each_signal &.lib_definition(builder)
+        each_vfunc &.lib_definition(builder)
+        each_property &.lib_definition(builder)
+      end
+
+      type_init_lib_definition(builder)
+      each_method &.lib_definition(builder)
+    end
+
+    def wrapper_definition(builder, libname)
+      parent_object = parent
+      parent = parent_object.constant if parent_object && parent_object.namespace == namespace
+      parent ||= parent_object.full_constant if parent_object
+
+      builder.def_class(name, parent: parent) do
+        section do
+          add_include "GObject::WrappedType" unless parent
+
+          each_interface do |interface|
+            add_include(interface.full_constant) unless interface.info_type.unresolved?
+          end
+        end
+
+        write_gtype_constant builder, libname
+        write_constructor builder, libname
+        write_to_unsafe builder, libname
+
+        unless abstract?
+          constructor_properties = all_properties.select { |property| property.setter? }
+          constructor_args = constructor_properties.map { |property|
+            arg(property.arg_name, type: "#{property.type.wrapper_definition(libname)}?", default: literal(nil))
+          }
+
+          if !constructor_properties.empty?
+            constructor_args.unshift arg("", prefix: :splat)
+            def_method("initialize", constructor_args) do
+              names = line assign_var "[] of UInt8*"
+              values = line assign_var "[] of LibGObject::Value"
+
+              constructor_properties.each do |property|
+                line def_if(negate(call("nil?", receiver: property.arg_name))) { |b|
+                  b.line b.call("<<", b.call("to_unsafe", receiver: b.literal(property.name)), receiver: names)
+                  gvalue = b.call("to_gvalue", receiver: property.arg_name)
+                  ptr = b.call("to_unsafe", receiver: gvalue)
+                  strct = b.call("value", receiver: ptr)
+                  b.line b.call("<<", strct, receiver: values)
+                }
+              end
+
+              names_size = call "size", receiver: names
+              object = call("new_with_properties", wrapper_gtype(builder, libname), names_size, names, values, receiver: "LibGObject")
+              ptr = call("as", "Void*", receiver: object)
+              line assign "@pointer", ptr
+            end
+          elsif !has_any_constructor?
+            def_method("initialize") do
+              object = call("new_with_properties", wrapper_gtype(builder, libname), literal(0), literal(nil), literal(nil), receiver: "LibGObject")
+              ptr = call("as", "Void*", receiver: object)
+              line assign "@pointer", ptr
+            end
+          end
+        end
+
+        write_methods builder, libname
+
+        each_property do |property|
+          next if has_method_getter_or_setter?(property.crystal_name)
+          next if property.private?
+          property.wrapper_definition builder, libname
+        end
+
+        each_signal(&.wrapper_definition(builder, libname))
+      end
+    end
+
+    Dumper.def do |dumper|
+      dumper.puts "* abstract = #{abstract?}"
+      Dumper.dump_child parent
+      Dumper.dump_child class_struct
+      Dumper.dump_childs constant
+      Dumper.dump_childs interface
+      Dumper.dump_childs field
+      Dumper.dump_childs property, properties
+      Dumper.dump_childs method
+      Dumper.dump_childs vfunc
+      Dumper.dump_childs signal
+    end
+  end
+end
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/g_i_repository/info/property_info.cr

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:34 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 49 of 16 source files
+module GIRepository
+require_relative "string__"
+ require_relative "./object"
+  class PropertyInfo < BaseInfo
+    def crystal_name
+      name = self.name
+      name.tr("-", "_") if name
+    end
+
+    def arg_name
+      name = crystal_name
+      name = "_#{name}" if name[0].uppercase? if name
+      name = "_#{name}" if ArgInfo::KEYWORDS.includes? name
+      name.gsub(/_+$/, "") if name
+      name
+    end
+
+    def type
+      BaseInfo.wrap(GIRepository.property_info_get_type(self)).as(TypeInfo)
+    end
+
+    def flags
+      GIRepository.property_info_get_flags self
+    end
+
+    def getter?
+      flags.readable?
+    end
+
+    def setter?
+      flags.writable?
+    end
+
+    def construct_only?
+      flags.construct_only?
+    end
+
+    def private?
+      flags.private?
+    end
+
+    def lib_definition(builder)
+      builder.comment "Property #{name} : #{type.lib_definition(builder)}"
+    end
+
+    def wrapper_definition(builder, libname)
+      ptr = builder.call("as", "LibGObject::Object*", receiver: "@pointer")
+      if getter?
+        builder.def_method(crystal_name, return_type: type.wrapper_definition(builder, libname)) do
+          gvalue = line assign_var call("new", {type: type.gvalue_type}, receiver: "GObject::Value")
+          line call("object_get_property", ptr, literal(name), gvalue, receiver: "LibGObject")
+          line type.unwrap_gvalue(gvalue)
+        end
+      end
+
+      if setter? && !construct_only?
+        builder.def_method("#{crystal_name}=", builder.arg("value", type: type.wrapper_definition(builder, libname))) do
+          line call("object_set_property", ptr, literal(name), call("to_gvalue", receiver: "value"), receiver: "LibGObject")
+        end
+      end
+    end
+
+    Dumper.def do
+      dumper.puts "* flags = #{flags}"
+      Dumper.dump_child type
+    end
+  end
+end
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/g_i_repository/info/registered_type_info.cr

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:34 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 51 of 16 source files
+module GIRepository
+require_relative "string__"
+    module RegisteredTypeInfo
+    def type_lib_definition
+      "Lib#{namespace}::#{name}*"
+    end
+
+    def type_name
+      ptr = LibGIRepository.registered_type_info_get_type_name(self)
+      String.new ptr if ptr
+    end
+
+    def type_init_symbol
+      ptr = LibGIRepository.registered_type_info_get_type_init(self)
+      symbol = String.new ptr if ptr
+      symbol == "intern" ? nil : symbol
+    end
+
+    def type_init
+      symbol = type_init_symbol
+      "_#{type_init_symbol}" if type_init_symbol
+    end
+
+    def type_init_lib_definition(builder)
+      type_init = self.type_init
+      builder.fun_binding type_init_symbol, name: type_init, return_type: "UInt64" if type_init
+    end
+
+    def wrapper_gtype(builder, libname)
+      if type_init = self.type_init
+        builder.call(type_init, receiver: libname)
+      elsif type_name = self.type_name
+        builder.call("type_from_name", builder.literal(type_name), receiver: "GObject")
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/g_i_repository/info/signal_info.cr

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:34 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 61 of 16 source files
+module GIRepository
+require_relative "string__"
+ require_relative "./object"
+  class SignalInfo < BaseInfo
+    include CallableInfo
+
+    def flags
+      GIRepository.signal_info_get_flags(self)
+    end
+
+    def true_stops_emit?
+      GIRepository.signal_info_true_stops_emit(self)
+    end
+
+    def lib_definition(builder)
+      builder.comment "Signal #{name}"
+    end
+
+    def wrapper_definition(builder, libname)
+      ret_type = return_type.wrapper_definition(libname)
+      ret_type = "Nil" if ret_type == "Void*"
+      proc = builder.proc_type(args.map { |arg|
+        type = arg.type.wrapper_definition(builder, libname)
+        arg.nilable? ? "#{type}?" : type
+      }, return_type: ret_type)
+      alias_name = "#{self.alias_name}Signal"
+      builder.attach_to_next_section { builder.def_alias alias_name, proc }
+
+      proc_arguments = args.each.with_index.map { |ai|
+        arg, i = ai
+        builder.arg("arg#{i}", type: arg.type.signal_lib_definition(builder))
+      }.to_a
+      proc_arguments << builder.arg("box", type: "Void*") # We pass the trampoline user data
+      block_arguments = args.each.with_index.map { |ai|
+        arg, i = ai
+        value = arg.type.convert_to_crystal(builder, "arg#{i}")
+        if arg.type.is_pointer_in_signal?
+          null_check = builder.call("null?", receiver: "arg#{i}")
+          unexpected_null = builder.call("raise_unexpected_null", builder.literal("#{arg.name} in #{identifier}"), receiver: "GObject")
+          arg.nilable? ? builder.ternary(null_check, builder.literal(nil), value) : builder.ternary(null_check, unexpected_null, value)
+        else
+          value
+        end
+      }.to_a
+      trampoline_args = Array.new(args.size) { |i| "arg#{i}" }
+      builder.def_method(
+        "on_#{identifier}",
+        builder.arg(nil, prefix: :splat),
+        builder.arg("after", default: "false"),
+        builder.arg("block", type: alias_name, prefix: :block_capture)) do
+        callback = line assign_var def_proc(proc_arguments) { |b|
+          trampoline = b.call("unbox", "box", receiver: "::Box(#{alias_name})")
+          return_value = b.call("call", block_arguments, receiver: trampoline)
+          b.line return_type.convert_from_crystal(return_value)
+        }
+
+        trampoline = call("new", receiver: alias_name, block_args: trampoline_args) { |b|
+          b.line b.call("call", trampoline_args, receiver: "block")
+        }
+        trampoline_box = line assign_var call("box", trampoline, receiver: "::Box")
+
+        this = call("as", "LibGObject::Object*", receiver: "@pointer")
+        callback_ptr = call("new", call("pointer", receiver: callback),
+          call("null", receiver: "Pointer(Void)"), receiver: "LibGObject::Callback")
+        register_box = call("register", trampoline_box, receiver: "GObject::ClosureDataManager")
+        deregister_box = "->#{call("deregister", receiver: "GObject::ClosureDataManager")}"
+
+        flags = ternary("after", "GObject::ConnectFlags::AFTER", "GObject::ConnectFlags::None")
+        line call("signal_connect_data",
+          this, literal(name), callback_ptr, register_box,
+          deregister_box, flags, receiver: "LibGObject")
+      end
+
+      builder.def_method("after_#{identifier}", builder.arg("block", type: alias_name, prefix: :block_capture)) do
+        line call("on_#{identifier}", {after: literal(true)}, "&block")
+      end
+    end
+
+    private def alias_name
+      name.try &.split("-").map(&.capitalize).join
+    end
+
+    private def identifier
+      name = self.name.try &.tr("-", "_")
+      name += "_" if name && {"begin", "end"}.includes? name
+      name
+    end
+
+    Dumper.def do
+      dumper.puts "* flags = #{flags}"
+      dumper.puts "* true_stops_emit = #{true_stops_emit?}"
+    end
+  end
+end
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)

data/crystal-gobject/src/g_i_repository/info/struct_info.cr

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+#
+# Democracy software compilation VERSION 0.0., created on 2021-11-14 17:41:34 -0500
+# Get all of this code, and all of these files, with
+# gem install democracy
+# Linux ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-linux-gnu]
+#
+# Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+
+
+
+# 64 of 16 source files
+module GIRepository
+require_relative "string__"
+    class StructInfo < BaseInfo
+    include RegisteredTypeInfo
+    include WrapperGenerator
+
+    each_converted struct_info, field, FieldInfo
+    each_converted struct_info, method, FunctionInfo
+
+    def gtype?
+      GIRepository.struct_info_is_gtype_struct(self)
+    end
+
+    def name
+      name = super
+      'A' <= name[0] <= 'Z' ? name : "#{namespace}#{name}" if name
+    end
+
+    def size
+      GIRepository.struct_info_get_size(self)
+    end
+
+    def alignment
+      GIRepository.struct_info_get_alignment(self)
+    end
+
+    def foreign?
+      GIRepository.struct_info_is_foreign(self)
+    end
+
+    def lib_definition(builder)
+      builder.end_of_line_comment "struct"
+      builder.def_struct(name) do
+        field_definition(builder)
+      end
+      type_init_lib_definition(builder)
+      each_method &.lib_definition(builder)
+    end
+
+    def field_definition(builder)
+      each_field &.lib_definition(builder)
+      builder.field_binding "_data", "UInt8[#{size}]" if fields_size == 0
+    end
+
+    def wrapper_definition(builder, libname)
+      builder.def_class(name) do
+        section { add_include "GObject::WrappedType" }
+
+        writable_fields = fields.select(&.writable?)
+        if !writable_fields.empty?
+          constructor_args = writable_fields.map { |field|
+            arg(field.name,
+              external: field.wrapper_name != field.name ? field.wrapper_name : nil,
+              default: literal(nil),
+              type: "#{field.type.wrapper_definition(libname)}?")
+          }
+          def_method("new", constructor_args, class_method: true, return_type: "self") do
+            ptr = call("malloc", literal(size), literal(0u8), receiver: "Pointer(UInt8)")
+            ptr = call("as", ptr_type(libname), receiver: ptr)
+            object = line assign_var call("new", ptr)
+            writable_fields.each do |field|
+              not_nil = negate(call("nil?", receiver: field.name))
+              conditional_line not_nil, assign("#{object}.#{field.wrapper_name}", field.name)
+            end
+            line object
+          end
+        elsif size != 0 # if size is 0 it's opaque to us, there should be a constructor function
+          def_method("new", class_method: true, return_type: "self") do
+            ptr = call("malloc", literal(size), literal(0u8), receiver: "Pointer(UInt8)")
+            ptr = call("as", ptr_type(libname), receiver: ptr)
+            line call("new", ptr)
+          end
+        end
+
+        write_gtype_constant builder, libname
+        write_constructor builder, libname
+        write_to_unsafe builder, libname
+        write_methods builder, libname
+
+        each_field do |field|
+          next if has_method_getter_or_setter?(field.name)
+
+          if field.readable?
+            def_method(field.wrapper_name) do
+              ptr = call("to_unsafe")
+              ptr = call("as", ptr_type(libname), receiver: ptr)
+              strct = call("value", receiver: ptr)
+              value = call(field.name, receiver: strct)
+              line field.type.convert_to_crystal(builder, value)
+            end
+          end
+
+          if field.writable?
+            def_method("#{field.wrapper_name}=", arg("value", type: field.type.wrapper_definition(libname))) do
+              ptr = call("to_unsafe")
+              ptr = call("as", ptr_type(libname), receiver: ptr)
+              strct = call("value", receiver: ptr)
+              line assign call(field.name, receiver: strct), field.type.convert_from_crystal("value")
+            end
+          end
+        end
+      end
+    end
+
+    Dumper.def do
+      dumper.puts "* size = #{size}"
+      dumper.puts "* alignment = #{alignment}"
+      dumper.puts "* foreign = #{foreign?}"
+      dumper.puts "* gtype = #{gtype?}"
+      Dumper.dump_childs field
+      Dumper.dump_childs method
+    end
+  end
+end
+
+
+
+
+
+
+
+
+# Feedback and donation to gregorycohen2@gmail.com (money transfer or Paypal)