fzeet 0.6.5 → 0.6.6

data/lib/fzeet/windows/oleaut/SafeArray.rb

@@ -0,0 +1,104 @@
+require_relative 'Common'
+
+module Fzeet
+	module Windows
+		class SAFEARRAYBOUND < FFI::Struct
+			layout \
+				:cElements, :ulong,
+				:lLbound, :long
+		end
+
+		class SAFEARRAY < FFI::Struct
+			include Enumerable
+
+			layout \
+				:cDims, :ushort,
+				:fFeatures, :ushort,
+				:cbElements, :ulong,
+				:cLocks, :ulong,
+				:pvData, :pointer,
+				:rgsabound, [SAFEARRAYBOUND, 1]
+
+			def self.vector(length, vt = :variant)
+				raise 'Not implemented.' if vt != :variant
+
+				raise 'SafeArrayCreateVector failed.' if
+					(psa = Windows.SafeArrayCreateVector(Windows.const_get("VT_#{vt.upcase}"), 0, length)).null?
+
+				sa = new(psa)
+
+				if block_given?
+					yield sa; sa.dispose; return nil
+				end
+
+				sa
+			end
+
+			def length(dim = 0) raise 'Not implemented.' if dim != 0; self[:rgsabound][dim][:cElements] end
+
+			def vt
+				FFI::MemoryPointer.new(:ushort) { |pvt|
+					Windows.DetonateHresult(:SafeArrayGetVartype, self, pvt)
+
+					return pvt.get_ushort(0)
+				}
+			end
+
+			alias old_get []
+
+			def [](i)
+				return old_get(i) if i.kind_of?(Symbol)
+
+				FFI::MemoryPointer.new(:long) { |pi|
+					pi.put_long(0, i)
+
+					Windows.DetonateHresult(:SafeArrayGetElement, self, pi, v = VARIANT.new)
+
+					return v
+				}
+			end
+
+			alias get []
+
+			alias old_put []=
+
+			def []=(i, v)
+				return old_put(i, v) if i.kind_of?(Symbol)
+
+				FFI::MemoryPointer.new(:long) { |pi|
+					pi.put_long(0, i)
+
+					Windows.DetonateHresult(:SafeArrayPutElement, self, pi, v)
+				}
+
+				self
+			end
+
+			alias put []=
+
+			def destroy; Windows.DetonateHresult(:SafeArrayDestroy, self) end
+			alias dispose destroy
+
+			def each; length.times { |i| yield self[i] }; self end
+		end
+
+		attach_function :SafeArrayCreateVector, [:ushort, :long, :uint], :pointer
+		attach_function :SafeArrayCreate, [:ushort, :uint, :pointer], :pointer
+		attach_function :SafeArrayDestroy, [:pointer], :long
+
+		attach_function :SafeArrayGetVartype, [:pointer, :pointer], :long
+
+		attach_function :SafeArrayGetElement, [:pointer, :pointer, :pointer], :long
+		attach_function :SafeArrayPutElement, [:pointer, :pointer, :pointer], :long
+
+		attach_function :SafeArrayLock, [:pointer], :long
+		attach_function :SafeArrayUnlock, [:pointer], :long
+
+		attach_function :SafeArrayPtrOfIndex, [:pointer, :pointer, :pointer], :long
+
+		attach_function :SafeArrayAccessData, [:pointer, :pointer], :long
+		attach_function :SafeArrayUnaccessData, [:pointer], :long
+	end
+
+	SafeArray = Windows::SAFEARRAY
+end

data/lib/fzeet/windows/oleaut/Variant.rb

@@ -0,0 +1,269 @@
+require_relative 'Common'
+
+module Fzeet
+	module Windows
+		VT_EMPTY = 0
+		VT_NULL = 1
+		VT_I2 = 2
+		VT_I4 = 3
+		VT_R4 = 4
+		VT_R8 = 5
+		VT_CY = 6
+		VT_DATE = 7
+		VT_BSTR = 8
+		VT_DISPATCH = 9
+		VT_ERROR = 10
+		VT_BOOL = 11
+		VT_VARIANT = 12
+		VT_UNKNOWN = 13
+		VT_DECIMAL = 14
+		VT_I1 = 16
+		VT_UI1 = 17
+		VT_UI2 = 18
+		VT_UI4 = 19
+		VT_I8 = 20
+		VT_UI8 = 21
+		VT_INT = 22
+		VT_UINT = 23
+		VT_VOID = 24
+		VT_HRESULT = 25
+		VT_PTR = 26
+		VT_SAFEARRAY = 27
+		VT_CARRAY = 28
+		VT_USERDEFINED = 29
+		VT_LPSTR = 30
+		VT_LPWSTR = 31
+		VT_RECORD = 36
+		VT_INT_PTR = 37
+		VT_UINT_PTR = 38
+		VT_FILETIME = 64
+		VT_BLOB = 65
+		VT_STREAM = 66
+		VT_STORAGE = 67
+		VT_STREAMED_OBJECT = 68
+		VT_STORED_OBJECT = 69
+		VT_BLOB_OBJECT = 70
+		VT_CF = 71
+		VT_CLSID = 72
+		VT_VERSIONED_STREAM = 73
+		VT_BSTR_BLOB = 0xfff
+		VT_VECTOR = 0x1000
+		VT_ARRAY = 0x2000
+		VT_BYREF = 0x4000
+		VT_RESERVED = 0x8000
+		VT_ILLEGAL = 0xffff
+		VT_ILLEGALMASKED = 0xfff
+		VT_TYPEMASK = 0xfff
+
+		class VARIANT < FFI::Union
+			include AnonymousSupport
+
+			layout \
+				:_, Class.new(FFI::Struct) {
+					layout \
+						:vt, :ushort,
+						:wReserved1, :ushort,
+						:wReserved2, :ushort,
+						:wReserved3, :ushort,
+						:_, Class.new(FFI::Union) {
+							layout \
+								:llVal, :long_long, # VT_I8
+								:lVal, :long, # VT_I4
+								:bVal, :uchar, # VT_UI1
+								:iVal, :short, # VT_I2
+								:fltVal, :float, # VT_R4
+								:dblVal, :double, # VT_R8
+								:boolVal, :short, # VT_BOOL
+								:bool, :short, # obsolete
+								:scode, :long, # VT_ERROR
+								:cyVal, :long_long, # VT_CY
+								:date, :double, # VT_DATE
+								:bstrVal, :pointer, # VT_BSTR
+								:punkVal, :pointer, # VT_UNKNOWN
+								:pdispVal, :pointer, # VT_DISPATCH
+								:parray, :pointer, # VT_ARRAY
+								:pbVal, :pointer, # VT_BYREF | VT_UI1
+								:piVal, :pointer, # VT_BYREF | VT_I2
+								:plVal, :pointer, # VT_BYREF | VT_I4
+								:pllVal, :pointer, # VT_BYREF | VT_I8
+								:pfltVal, :pointer, # VT_BYREF | VT_R4
+								:pdblVal, :pointer, # VT_BYREF | VT_R8
+								:pboolVal, :pointer, # VT_BYREF | VT_BOOL
+								:pbool, :pointer, # obsolete
+								:pscode, :pointer, # VT_BYREF | VT_ERROR
+								:pcyVal, :pointer, # VT_BYREF | VT_CY
+								:pdate, :pointer, # VT_BYREF | VT_DATE
+								:pbstrVal, :pointer, # VT_BYREF | VT_BSTR
+								:ppunkVal, :pointer, # VT_BYREF | VT_UNKNOWN
+								:ppdispVal, :pointer, # VT_BYREF | VT_DISPATCH
+								:pparrayv, :pointer, # VT_BYREF | VT_ARRAY
+								:pvarVal, :pointer, # VT_BYREF | VT_VARIANT
+								:byref, :pointer, # VT_BYREF
+								:cVal, :char, # VT_I1
+								:uiVal, :ushort, # VT_UI2
+								:ulVal, :ulong, # VT_UI4
+								:ullVal, :ulong_long, # VT_UI8
+								:intVal, :int, # VT_INT
+								:uintVal, :uint, # VT_UINT
+								:pdecVal, :pointer, # VT_BYREF | VT_DECIMAL
+								:pcVal, :pointer, # VT_BYREF | VT_I1
+								:puiVal, :pointer, # VT_BYREF | VT_UI2
+								:pulVal, :pointer, # VT_BYREF | VT_UI4
+								:pullVal, :pointer, # VT_BYREF | VT_UI8
+								:pintVal, :pointer, # VT_BYREF | VT_INT
+								:puintVal, :pointer, # VT_BYREF | VT_UINT
+								:_, Class.new(FFI::Struct) { # VT_RECORD
+									layout \
+										:pvRecord, :pointer,
+										:pRecInfo, :pointer
+								}
+ 						}
+				},
+
+				:decVal, DECIMAL # VT_DECIMAL
+
+			def self.[](type, value) new.tap { |variant| variant.send("#{type}=", value) } end
+
+			def bool; raise 'Wrong type tag.' unless self[:vt] == VT_BOOL; self[:boolVal] != 0 end
+			def bool=(bool) clear; self[:vt] = VT_BOOL; self[:boolVal] = (bool) ? -1 : 0 end
+
+			%w{int    uint    i1   ui1  i2   ui2   i4   ui4   i8    ui8    error r4     r8}.zip(
+			%w{intVal uintVal cVal bVal iVal uiVal lVal ulVal llVal ullVal scode fltVal dblVal}).each { |vt, val|
+				define_method(vt) {
+					raise 'Wrong type tag.' unless self[:vt] == Windows.const_get("VT_#{vt.upcase}"); self[val.to_sym]
+				}
+
+				define_method("#{vt}=") { |value|
+					clear; self[:vt] = Windows.const_get("VT_#{vt.upcase}"); self[val.to_sym] = value
+				}
+			}
+
+			alias char i1
+			alias uchar ui1; alias byte uchar
+			alias short i2
+			alias ushort ui2; alias word ushort
+			alias long i4
+			alias ulong ui4; alias dword ulong
+			alias longlong i8
+			alias ulonglong ui8; alias qword ulonglong
+			alias float r4
+			alias double r8
+
+			alias char= i1=
+			alias uchar= ui1=; alias byte= uchar=
+			alias short= i2=
+			alias ushort= ui2=; alias word= ushort=
+			alias long= i4=
+			alias ulong= ui4=; alias dword= ulong=
+			alias longlong= i8=
+			alias ulonglong= ui8=; alias qword= ulonglong=
+			alias float= r4=
+			alias double= r8=
+
+			def bstr; raise 'Wrong type tag.' unless self[:vt] == VT_BSTR; BSTR.new(self[:bstrVal]).multibyte end
+			def bstr=(str) clear; self[:vt] = VT_BSTR; self[:bstrVal] = BSTR[str].pointer end
+
+			alias string bstr
+			alias string= bstr=
+
+			def date
+				raise 'Wrong type tag.' unless self[:vt] == VT_DATE
+
+				raise 'VariantTimeToSystemTime failed.' if Windows.VariantTimeToSystemTime(self[:date], st = SYSTEMTIME.new) == 0
+
+				st.get
+			end
+
+			def date=(date)
+				clear
+
+				self[:vt] = VT_DATE
+
+				FFI::MemoryPointer.new(:double) { |pdate|
+					raise 'SystemTimeToVariantTime failed.' if Windows.SystemTimeToVariantTime(SYSTEMTIME[date], pdate) == 0
+
+					self[:date] = pdate.get_double(0)
+				}
+			end
+
+			alias time date
+			alias time= date=
+
+			def decimal(as = :double)
+				raise 'Wrong type tag.' unless self[:vt] == VT_DECIMAL
+
+				DECIMAL.new(self[:decVal].pointer).send(as)
+			end
+
+			def decimal=(decimal)
+				clear
+
+				self[:vt] = VT_DECIMAL
+
+				DECIMAL[decimal].tap { |dec|
+					self[:decVal].members.each { |member|
+						next if member == :wReserved # This is self[:vt]
+
+						self[:decVal][member] = dec[member]
+					}
+				}
+			end
+
+			%w{unknown dispatch}.zip(
+			%w{punkVal pdispVal}).each { |vt, val|
+				define_method(vt) {
+					raise 'Wrong type tag.' unless self[:vt] == Windows.const_get("VT_#{vt.upcase}")
+
+					Windows.const_get(vt.capitalize).new(self[val.to_sym]).tap { |instance|
+						instance.AddRef
+					}
+				}
+
+				define_method("#{vt}=") { |instance|
+					clear
+
+					self[:vt] = Windows.const_get("VT_#{vt.upcase}")
+
+					self[val.to_sym] = instance
+
+					instance.AddRef
+				}
+			}
+
+			def array
+				raise 'Wrong type tag.' unless self[:vt] & VT_ARRAY == VT_ARRAY
+
+				SAFEARRAY.new(self[:parray])
+			end
+
+			def array=(array) clear; self[:vt] = VT_ARRAY | VT_VARIANT; self[:parray] = array end
+
+			def byref(deref = nil)
+				raise 'Wrong type tag.' unless self[:vt] & VT_BYREF == VT_BYREF
+
+				(deref) ? self[:byref].send("get_#{deref}", 0) : self[:byref]
+			end
+
+			def byref=(byref) clear; self[:vt] = VT_BYREF; self[:byref] = byref end
+
+			def object; ObjectSpace._id2ref(i4) end
+			def object=(object) self.i4 = object.object_id end
+
+			def clear; Windows.DetonateHresult(:VariantClear, self); self end
+		end
+
+		attach_function :VariantInit, [:pointer], :void
+		attach_function :VariantClear, [:pointer], :long
+
+		attach_function :SystemTimeToVariantTime, [:pointer, :pointer], :int
+		attach_function :VariantTimeToSystemTime, [:double, :pointer], :int
+
+		attach_function :VarDecFromI8, [:long_long, :pointer], :long
+		attach_function :VarI8FromDec, [:pointer, :pointer], :long
+
+		attach_function :VarDecFromR8, [:double, :pointer], :long
+		attach_function :VarR8FromDec, [:pointer, :pointer], :long
+	end
+
+	Variant = Windows::VARIANT
+end

data/lib/fzeet/windows/scintilla.rb

@@ -2,7 +2,7 @@ require_relative 'user'
 
 module Fzeet
 	module Windows
-		ffi_lib "#{File.dirname(File.expand_path(__FILE__))}/SciLexer.dll"
+		ffi_lib "#{File.dirname(File.expand_path(__FILE__))}/scintilla/SciLexer.dll"
 		ffi_convention :stdcall
 
 		callback :SciFnDirect, [:long, :uint, :uint, :long], :long
@@ -2276,4 +2276,118 @@ module Fzeet
 		SCE_TXT2TAGS_PREPROC = 24
 		SCE_TXT2TAGS_POSTPROC = 25
 	end
+
+	module ScintillaMethods
+		def text
+			FFI::MemoryPointer.new(:uchar, len = sendmsg(:gettextlength) + 1) { |p|
+				sendmsg(:gettext, len, p)
+
+				return p.read_string
+			}
+		end
+
+		def text=(text)
+			p = FFI::MemoryPointer.from_string(text)
+
+			sendmsg(:settext, 0, p)
+		ensure
+			p.free
+		end
+
+		def font
+			FFI::MemoryPointer.new(:uchar, 33) { |p|
+				sendmsg(:stylegetfont, Windows::STYLE_DEFAULT, p)
+
+				return p.read_string
+			}
+		end
+
+		def font=(name)
+			p = FFI::MemoryPointer.from_string(name)
+
+			sendmsg(:stylesetfont, Windows::STYLE_DEFAULT, p)
+		ensure
+			p.free
+		end
+
+		def fontSize; sendmsg(:stylegetsize, Windows::STYLE_DEFAULT) end
+		def fontSize=(size) sendmsg(:stylesetsize, Windows::STYLE_DEFAULT, size) end
+
+		def tabWidth; sendmsg(:gettabwidth) end
+		def tabWidth=(tabWidth) sendmsg(:settabwidth, tabWidth) end
+
+		def dirty?; @dirty end
+		def dirty=(dirty) (dirty) ? @dirty = true : sendmsg(:setsavepoint) end
+	end
+
+	class Scintilla < Control
+		include ScintillaMethods
+
+		Prefix = {
+			xstyle: [:ws_ex_],
+			style: [:ws_],
+			message: [:sci_, :wm_],
+			notification: [:scn_, :scen_, :nm_]
+		}
+
+		def self.crackNotification(args)
+			case args[:notification]
+			when \
+				Windows::SCN_STYLENEEDED,
+				Windows::SCN_CHARADDED,
+				Windows::SCN_SAVEPOINTREACHED,
+				Windows::SCN_SAVEPOINTLEFT,
+				Windows::SCN_MODIFYATTEMPTRO,
+				Windows::SCN_KEY,
+				Windows::SCN_DOUBLECLICK,
+				Windows::SCN_UPDATEUI,
+				Windows::SCN_MODIFIED,
+				Windows::SCN_MACRORECORD,
+				Windows::SCN_MARGINCLICK,
+				Windows::SCN_NEEDSHOWN,
+				Windows::SCN_PAINTED,
+				Windows::SCN_USERLISTSELECTION,
+				Windows::SCN_URIDROPPED,
+				Windows::SCN_DWELLSTART,
+				Windows::SCN_DWELLEND,
+				Windows::SCN_ZOOM,
+				Windows::SCN_HOTSPOTCLICK,
+				Windows::SCN_HOTSPOTDOUBLECLICK,
+				Windows::SCN_CALLTIPCLICK,
+				Windows::SCN_AUTOCSELECTION,
+				Windows::SCN_INDICATORCLICK,
+				Windows::SCN_INDICATORRELEASE,
+				Windows::SCN_AUTOCCANCELLED,
+				Windows::SCN_AUTOCCHARDELETED
+
+				args[:scn] = Windows::SCNotification.new(FFI::Pointer.new(args[:lParam]))
+			end
+		end
+
+		def initialize(parent, id, opts = {}, &block)
+			super('Scintilla', parent, id, opts)
+
+			@dirty = false
+
+			on(:savepointleft) { @dirty = true }
+			on(:savepointreached) { @dirty = false }
+
+			@parent.on(:notify, @id, &block) if block
+		end
+
+		def on(notification, &block)
+			case c = Fzeet.constant(notification, *self.class::Prefix[:notification])
+			when \
+				Windows::SCEN_CHANGE,
+				Windows::SCEN_SETFOCUS,
+				Windows::SCEN_KILLFOCUS
+
+				@parent.on(:command, @id, c, &block)
+			else
+				@parent.on(:notify, @id, c, &block)
+			end
+
+			self
+		end
+	end
 end