fzeet 0.6.5 → 0.6.6

data/lib/fzeet/windows/core/Rect.rb

@@ -0,0 +1,114 @@
+require_relative 'Point'
+
+module Fzeet
+	module Windows
+		class RECT < FFI::Struct
+			layout \
+				:left, :long,
+				:top, :long,
+				:right, :long,
+				:bottom, :long
+
+			def self.[](*args)
+				case args.length
+				when 2 # location, size
+					new.set(args[0][:x], args[0][:y], args[0][:x] + args[1][:cx], args[0][:y] + args[1][:cy])
+				when 4 # left, top, right, bottom
+					new.set(*args)
+				else raise ArgumentError
+				end
+			end
+
+			class << self
+				alias from []
+				alias wrap new
+			end
+
+			def dup; self.class[self[:left], self[:top], self[:right], self[:bottom]] end
+
+			def get; [self[:left], self[:top], self[:right], self[:bottom]] end
+			alias to_a get
+
+			def set(l, t, r, b) tap { |rect| rect[:left], rect[:top], rect[:right], rect[:bottom] = l, t, r, b } end
+
+			def clear; set(0, 0, 0, 0) end
+
+			def lt; POINT[self[:left], self[:top]] end
+			def lt=(pt) self[:left], self[:top] = pt[:x], pt[:y] end
+			alias location lt
+			alias location= lt=
+
+			def lb; POINT[self[:left], self[:bottom]] end
+			def lb=(pt) self[:left], self[:bottom] = pt[:x], pt[:y] end
+
+			def rt; POINT[self[:right], self[:top]] end
+			def rt=(pt) self[:right], self[:top] = pt[:x], pt[:y] end
+
+			def rb; POINT[self[:right], self[:bottom]] end
+			def rb=(pt) self[:right], self[:bottom] = pt[:x], pt[:y] end
+
+			def width; self[:right] - self[:left] end
+			def width=(width) self[:right] = self[:left] + width end
+
+			def height; self[:bottom] - self[:top] end
+			def height=(height) self[:bottom] = self[:top] + height end
+
+			alias structSize size
+
+			def size; SIZE[width, height] end
+			def size=(s) self.width, self.height = s[:cx], s[:cy] end
+
+			def ==(other) Windows.EqualRect(self, other) != 0 end
+			def empty?; Windows.IsRectEmpty(self) != 0 end
+
+			def include?(*args)
+				return args.all? { |arg| include?(arg) } if args.length > 1
+
+				case args[0]
+				when POINT; Windows.PtInRect(self, args[0]) != 0
+				when RECT; [args[0].lt, args[0].lb, args[0].rt, args[0].rb].all? { |pt| include?(pt) }
+				else raise ArgumentError
+				end
+			end
+
+			def exclude?(arg) !include?(arg) end
+
+			def normalized?; self[:left] <= self[:right] && self[:top] <= self[:bottom] end
+
+			def normalize; dup.normalize! end
+
+			def normalize!
+				self[:left], self[:right] = self[:right], self[:left] if self[:left] > self[:right]
+				self[:top], self[:bottom] = self[:bottom], self[:top] if self[:top] > self[:bottom]
+
+				self
+			end
+
+			def offset(dx, dy) dup.offset!(dx, dy) end
+			def offset!(dx, dy) tap { |r| Windows.Detonate(0, :OffsetRect, r, dx, dy) } end
+
+			def inflate(dx, dy) dup.inflate!(dx, dy) end
+			def inflate!(dx, dy) tap { |r| Windows.Detonate(0, :InflateRect, r, dx, dy) } end
+
+			def |(other) self.class.new.tap { |r| Windows.UnionRect(r, self, other) } end
+			def &(other) self.class.new.tap { |r| Windows.IntersectRect(r, self, other) } end
+			def -(other) self.class.new.tap { |r| Windows.SubtractRect(r, self, other) } end
+		end
+
+		ffi_lib 'user32'
+		ffi_convention :stdcall
+
+		attach_function :EqualRect, [:pointer, :pointer], :int
+		attach_function :IsRectEmpty, [:pointer], :int
+		attach_function :PtInRect, [:pointer, POINT.by_value], :int
+
+		attach_function :OffsetRect, [:pointer, :int, :int], :int
+		attach_function :InflateRect, [:pointer, :int, :int], :int
+
+		attach_function :UnionRect, [:pointer, :pointer, :pointer], :int
+		attach_function :IntersectRect, [:pointer, :pointer, :pointer], :int
+		attach_function :SubtractRect, [:pointer, :pointer, :pointer], :int
+	end
+
+	Rect = Windows::RECT
+end

data/lib/fzeet/windows/core/Size.rb

@@ -0,0 +1,34 @@
+require_relative 'Common'
+
+module Fzeet
+	module Windows
+		class SIZE < FFI::Struct
+			layout \
+				:cx, :long,
+				:cy, :long
+
+			def self.[](cx, cy) new.set(cx, cy) end
+
+			class << self
+				alias from []
+				alias wrap new
+			end
+
+			def dup; self.class[self[:cx], self[:cy]] end
+
+			def get; [self[:cx], self[:cy]] end
+			alias to_a get
+
+			def set(cx, cy) tap { |s| s[:cx], s[:cy] = cx, cy } end
+
+			def clear; set(0, 0) end
+
+			def ==(other) self[:cx] == other[:cx] && self[:cy] == other[:cy] end
+
+			def inflate(dx, dy) dup.inflate!(dx, dy) end
+			def inflate!(dx, dy) tap { |s| s[:cx] += dx; s[:cy] += dy } end
+		end
+	end
+
+	Size = Windows::SIZE
+end

data/lib/fzeet/windows/core/SystemTime.rb

@@ -0,0 +1,46 @@
+require_relative 'Common'
+
+module Fzeet
+	module Windows
+		class SYSTEMTIME < FFI::Struct
+			layout \
+				:wYear, :ushort,
+				:wMonth, :ushort,
+				:wDayOfWeek, :ushort,
+				:wDay, :ushort,
+				:wHour, :ushort,
+				:wMinute, :ushort,
+				:wSecond, :ushort,
+				:wMilliseconds, :ushort
+
+			def self.[](time) new.set(time) end
+
+			class << self
+				alias from []
+				alias wrap new
+			end
+
+			def dup; self.class.new.tap { |st| st.members.each { |member| st[member] = self[member] } } end
+
+			def get(as = :local)
+				Time.send(as,
+					self[:wYear], self[:wMonth], self[:wDay],
+					self[:wHour], self[:wMinute], self[:wSecond], self[:wMilliseconds] * 1000
+				)
+			end
+
+			def set(time)
+				tap { |st|
+					st[:wYear], st[:wMonth], st[:wDay],
+					st[:wHour], st[:wMinute], st[:wSecond], st[:wMilliseconds] =
+					time.year, time.month, time.day,
+					time.hour, time.min, time.sec, (time.usec.to_f / 1000).round
+				}
+			end
+
+			def ==(other) members.all? { |member| self[member] == other[member] } end
+		end
+	end
+
+	SystemTime = Windows::SYSTEMTIME
+end

data/lib/fzeet/windows/core/Version.rb

@@ -0,0 +1,57 @@
+require_relative 'Common'
+
+module Fzeet
+	module Windows
+		class OSVERSIONINFOEX < FFI::Struct
+			layout \
+				:dwOSVersionInfoSize, :ulong,
+				:dwMajorVersion, :ulong,
+				:dwMinorVersion, :ulong,
+				:dwBuildNumber, :ulong,
+				:dwPlatformId, :ulong,
+				:szCSDVersion, [:char, 128],
+				:wServicePackMajor, :ushort,
+				:wServicePackMinor, :ushort,
+				:wSuiteMask, :ushort,
+				:wProductType, :uchar,
+				:wReserved, :uchar
+
+			def get!; tap { |ovi| ovi[:dwOSVersionInfoSize] = size; Windows.DetonateLastError(0, :GetVersionEx, ovi) } end
+
+			def major; self[:dwMajorVersion] end
+			def minor; self[:dwMinorVersion] end
+			def build; self[:dwBuildNumber] end
+			def sp; self[:wServicePackMajor] end
+
+			def hex; (major << 8) + minor end
+
+			def <=>(version)
+				hex <=> case version
+				when '2000', 2000; 0x0500
+				when 'xp', :xp; 0x0501
+				when 'vista', :vista; 0x0600
+				when '7', 7; 0x0601
+				else raise ArgumentError
+				end
+			end
+
+			include Comparable
+
+			def name
+				case hex
+				when 0x0500...0x0501; 'Windows 2000'
+				when 0x0501...0x0600; 'Windows XP'
+				when 0x0600...0x0601; 'Windows Vista'
+				when 0x0601...0x0700; 'Windows 7'
+				else 'Unknown'
+				end
+			end
+
+			def to_s; "#{major}.#{minor}.#{build} SP#{sp} (#{name})" end
+		end
+
+		attach_function :GetVersionEx, :GetVersionExA, [:pointer], :int
+
+		Version = OSVERSIONINFOEX.new.get!
+	end
+end

data/lib/fzeet/windows/gdi.rb

@@ -1,62 +1 @@
-require_relative 'common'
-
-module Fzeet
-	module Windows
-		ffi_lib 'gdi32'
-		ffi_convention :stdcall
-
-		def GetRValue(rgb) LOBYTE(rgb) end
-		def GetGValue(rgb) LOBYTE(rgb >> 8) end
-		def GetBValue(rgb) LOBYTE(rgb >> 16) end
-		def RGB(r, g, b) r | (g << 8) | (b << 16) end
-
-		module_function \
-			:GetRValue, :GetGValue, :GetBValue, :RGB
-
-		LOGPIXELSX = 88
-		LOGPIXELSY = 90
-
-		attach_function :GetDeviceCaps, [:pointer, :int], :int
-
-		DEFAULT_GUI_FONT = 17
-
-		attach_function :GetStockObject, [:int], :pointer
-
-=begin
-		class LOGFONT < FFI::Struct
-			layout \
-				:lfHeight, :long,
-				:lfWidth, :long,
-				:lfEscapement, :long,
-				:lfOrientation, :long,
-				:lfWeight, :long,
-				:lfItalic, :uchar,
-				:lfUnderline, :uchar,
-				:lfStrikeOut, :uchar,
-				:lfCharSet, :uchar,
-				:lfOutPrecision, :uchar,
-				:lfClipPrecision, :uchar,
-				:lfQuality, :uchar,
-				:lfPitchAndFamily, :uchar,
-				:lfFaceName, [:char, 32]
-		end
-=end
-
-		attach_function :CreateFontIndirect, :CreateFontIndirectA, [:pointer], :pointer
-
-		attach_function :DeleteObject, [:pointer], :int
-
-		attach_function :SelectObject, [:pointer, :pointer], :pointer
-
-		attach_function :GetTextExtentPoint, :GetTextExtentPointA, [:pointer, :string, :int, :pointer], :int
-
-		attach_function :GetTextColor, [:pointer], :ulong
-		attach_function :SetTextColor, [:pointer, :ulong], :ulong
-
-		attach_function :GetBkColor, [:pointer], :ulong
-		attach_function :SetBkColor, [:pointer, :ulong], :ulong
-
-		attach_function :MoveToEx, [:pointer, :int, :int, :pointer], :int
-		attach_function :LineTo, [:pointer, :int, :int], :int
-	end
-end
+require_relative 'gdi/Font'

data/lib/fzeet/windows/gdi/Common.rb

@@ -0,0 +1,40 @@
+require_relative '../core'
+
+module Fzeet
+	module Windows
+		ffi_lib 'gdi32'
+		ffi_convention :stdcall
+
+		def GetRValue(rgb) LOBYTE(rgb) end
+		def GetGValue(rgb) LOBYTE(rgb >> 8) end
+		def GetBValue(rgb) LOBYTE(rgb >> 16) end
+		def RGB(r, g, b) r | (g << 8) | (b << 16) end
+
+		module_function \
+			:GetRValue, :GetGValue, :GetBValue, :RGB
+
+		LOGPIXELSX = 88
+		LOGPIXELSY = 90
+
+		attach_function :GetDeviceCaps, [:pointer, :int], :int
+
+		DEFAULT_GUI_FONT = 17
+
+		attach_function :GetStockObject, [:int], :pointer
+
+		attach_function :DeleteObject, [:pointer], :int
+
+		attach_function :SelectObject, [:pointer, :pointer], :pointer
+
+		attach_function :GetTextExtentPoint, :GetTextExtentPointA, [:pointer, :string, :int, :pointer], :int
+
+		attach_function :GetTextColor, [:pointer], :ulong
+		attach_function :SetTextColor, [:pointer, :ulong], :ulong
+
+		attach_function :GetBkColor, [:pointer], :ulong
+		attach_function :SetBkColor, [:pointer, :ulong], :ulong
+
+		attach_function :MoveToEx, [:pointer, :int, :int, :pointer], :int
+		attach_function :LineTo, [:pointer, :int, :int], :int
+	end
+end

data/lib/fzeet/windows/gdi/Font.rb

@@ -0,0 +1,64 @@
+require_relative 'Common'
+
+module Fzeet
+	module Windows
+		class LOGFONT < FFI::Struct
+			layout \
+				:lfHeight, :long,
+				:lfWidth, :long,
+				:lfEscapement, :long,
+				:lfOrientation, :long,
+				:lfWeight, :long,
+				:lfItalic, :uchar,
+				:lfUnderline, :uchar,
+				:lfStrikeOut, :uchar,
+				:lfCharSet, :uchar,
+				:lfOutPrecision, :uchar,
+				:lfClipPrecision, :uchar,
+				:lfQuality, :uchar,
+				:lfPitchAndFamily, :uchar,
+				:lfFaceName, [:char, 32]
+
+			def face; self[:lfFaceName].to_s end
+			def face=(face) self[:lfFaceName] = face end
+
+			def size; -Rational(self[:lfHeight] * 72, Application.devcaps[:logpixelsy]) end
+			def size=(size) self[:lfHeight] = -Windows.MulDiv((size * 10).to_i, Application.devcaps[:logpixelsy], 720) end
+
+			def bold?; self[:lfWeight] >= 700 end
+			def bold=(bold) self[:lfWeight] = (bold) ? 700 : 0 end
+
+			def italic?; self[:lfItalic] == 1 end
+			def italic=(italic) self[:lfItalic] = (italic) ? 1 : 0 end
+
+			def underline?; self[:lfUnderline] == 1 end
+			def underline=(underline) self[:lfUnderline] = (underline) ? 1 : 0 end
+
+			def strikeout?; self[:lfStrikeOut] == 1 end
+			def strikeout=(strikeout) self[:lfStrikeOut] = (strikeout) ? 1 : 0 end
+
+			def update(from)
+				case from
+				when PropertyStore
+					from.each { |k, v|
+						case k
+						when UI_PKEY_FontProperties_Family; self.face = v.wstring
+						when UI_PKEY_FontProperties_Size; self.size = v.decimal.to_f
+						when UI_PKEY_FontProperties_Bold; self.bold = v.uint == 2
+						when UI_PKEY_FontProperties_Italic; self.italic = v.uint == 2
+						when UI_PKEY_FontProperties_Underline; self.underline = v.uint == 2
+						when UI_PKEY_FontProperties_Strikethrough; self.strikeout = v.uint == 2
+						end
+					}
+				else raise ArgumentError
+				end
+
+				self
+			end
+		end
+
+		attach_function :CreateFontIndirect, :CreateFontIndirectA, [:pointer], :pointer
+	end
+
+	Windows::LOGFONT.send(:include, Toggle)
+end

data/lib/fzeet/windows/kernel.rb

@@ -1,92 +1 @@
-require_relative 'common'
-
-module Fzeet
-	module Windows
-		ffi_lib 'kernel32'
-		ffi_convention :stdcall
-
-		attach_function :GetModuleHandle, :GetModuleHandleA, [:string], :pointer
-
-		attach_function :LoadLibrary, :LoadLibraryA, [:string], :pointer
-		attach_function :FreeLibrary, [:pointer], :int
-
-		attach_function :GetSystemDefaultLCID, [], :ulong
-
-		if WINVER.AtLeastWindowsXP?
-			class ACTCTX < FFI::Struct
-				layout \
-					:cbSize, :ulong,
-					:dwFlags, :ulong,
-					:lpSource, :pointer,
-					:wProcessorArchitecture, :ushort,
-					:wLangId, :ushort,
-					:lpAssemblyDirectory, :pointer,
-					:lpResourceName, :pointer,
-					:lpApplicationName, :pointer,
-					:hModule, :pointer
-			end
-
-			attach_function :CreateActCtx, :CreateActCtxA, [:pointer], :pointer
-			attach_function :ReleaseActCtx, [:pointer], :void
-
-			attach_function :ActivateActCtx, [:pointer, :pointer], :int
-			attach_function :DeactivateActCtx, [:ulong, :ulong], :int
-
-			COMMON_CONTROLS_ACTCTX = {
-				handle: INVALID_HANDLE_VALUE,
-				cookie: FFI::MemoryPointer.new(:ulong),
-				activated: false
-			}
-
-			at_exit {
-				DeactivateActCtx(0, COMMON_CONTROLS_ACTCTX[:cookie].get_ulong(0)) if
-					COMMON_CONTROLS_ACTCTX[:activated]
-
-				COMMON_CONTROLS_ACTCTX[:cookie].free
-
-				ReleaseActCtx(COMMON_CONTROLS_ACTCTX[:handle]) unless
-					COMMON_CONTROLS_ACTCTX[:handle] == INVALID_HANDLE_VALUE
-			}
-		end
-
-		def EnableVisualStyles
-			return unless WINVER.AtLeastWindowsXP?
-
-			raise 'Visual styles already enabled.' if COMMON_CONTROLS_ACTCTX[:activated]
-
-			manifest = "#{ENV['TEMP']}/Fzeet.Common-Controls.manifest"
-
-			File.open(manifest, 'w:utf-8') { |file|
-				file << <<-XML
-<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
-<assembly xmlns='urn:schemas-microsoft-com:asm.v1' manifestVersion='1.0'>
-	<dependency>
-		<dependentAssembly>
-			<assemblyIdentity type='Win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*' />
-		</dependentAssembly>
-	</dependency>
-</assembly>
-				XML
-			}
-
-			ac = ACTCTX.new
-
-			ac[:cbSize] = ac.size
-			ac[:lpSource] = source = FFI::MemoryPointer.from_string(File.expand_path(manifest))
-
-			COMMON_CONTROLS_ACTCTX[:handle] = DetonateLastError(INVALID_HANDLE_VALUE, :CreateActCtx, ac) { source.free }
-
-			DetonateLastError(0, :ActivateActCtx, COMMON_CONTROLS_ACTCTX[:handle], COMMON_CONTROLS_ACTCTX[:cookie]) { |failed|
-				next unless failed
-
-				ReleaseActCtx(COMMON_CONTROLS_ACTCTX[:handle]); COMMON_CONTROLS_ACTCTX[:handle] = INVALID_HANDLE_VALUE
-			}
-
-			COMMON_CONTROLS_ACTCTX[:activated] = true
-		end
-
-		module_function :EnableVisualStyles
-
-		attach_function :MulDiv, [:int, :int, :int], :int
-	end
-end
+require_relative 'kernel/Common'