fzeet 0.5.2 → 0.5.3

data/lib/fzeet/Menu.rb

@@ -1,86 +1,86 @@
-require_relative 'common'
+require_relative 'Common'
 
 module Fzeet
-	class MenuItem
-		include Toggle
-
-		def initialize(menu, id) @menu, @id = menu, Command[id] end
-
-		attr_reader :menu, :id
-
-		def enabled?
-			flags = Windows.DetonateLastError(-1, :GetMenuState, @menu.handle, @id, 0)
-
-			(flags & Windows::MF_GRAYED) != Windows::MF_GRAYED
-		end
-
-		def enabled=(enabled)
-			Windows.DetonateLastError(-1, :EnableMenuItem,
-				@menu.handle,
-				@id,
-				(enabled) ? Windows::MF_ENABLED : Windows::MF_GRAYED
-			)
-		end
-
-		def checked?
-			flags = Windows.DetonateLastError(-1, :GetMenuState, @menu.handle, @id, 0)
-
-			(flags & Windows::MF_CHECKED) == Windows::MF_CHECKED
-		end
-
-		def checked=(checked)
-			Windows.DetonateLastError(-1, :CheckMenuItem,
-				@menu.handle,
-				@id,
-				(checked) ? Windows::MF_CHECKED : Windows::MF_UNCHECKED
-			)
-		end
-
-		def select(first, last)
-			Windows.DetonateLastError(0, :CheckMenuRadioItem,
-				@menu.handle, Command[first], Command[last], @id, 0
-			)
-
-			self
-		end
+	module MenuMethods
+		def rdetach; submenus.each(&:rdetach); detach end
 
-		def info(mask)
-			Windows.DetonateLastError(0, :GetMenuItemInfo,
-				@menu.handle,
-				@id,
-				0,
-				info = Windows::MENUITEMINFO.new.tap { |mii|
-					mii[:cbSize] = mii.size
-					mii[:fMask] = Fzeet.constant(mask, :miim_)
+		class Item
+			include Toggle
+
+			def initialize(menu, id) @menu, @id = menu, Command[id] end
+
+			attr_reader :menu, :id
+
+			def enabled?
+				flags = Windows.DetonateLastError(-1, :GetMenuState, @menu.handle, @id, 0)
+
+				(flags & Windows::MF_GRAYED) != Windows::MF_GRAYED
+			end
+
+			def enabled=(enabled)
+				Windows.DetonateLastError(-1, :EnableMenuItem,
+					@menu.handle,
+					@id,
+					(enabled) ? Windows::MF_ENABLED : Windows::MF_GRAYED
+				)
+			end
+
+			def checked?
+				flags = Windows.DetonateLastError(-1, :GetMenuState, @menu.handle, @id, 0)
+
+				(flags & Windows::MF_CHECKED) == Windows::MF_CHECKED
+			end
+
+			def checked=(checked)
+				Windows.DetonateLastError(-1, :CheckMenuItem,
+					@menu.handle,
+					@id,
+					(checked) ? Windows::MF_CHECKED : Windows::MF_UNCHECKED
+				)
+			end
+
+			def select(first, last)
+				Windows.DetonateLastError(0, :CheckMenuRadioItem,
+					@menu.handle, Command[first], Command[last], @id, 0
+				)
+
+				self
+			end
+
+			def info(mask)
+				Windows.DetonateLastError(0, :GetMenuItemInfo,
+					@menu.handle,
+					@id,
+					0,
+					info = Windows::MENUITEMINFO.new.tap { |mii|
+						mii[:cbSize] = mii.size
+						mii[:fMask] = Fzeet.constant(mask, :miim_)
+					}
+				)
+
+				info
+			end
+
+			def info=(mii)
+				Windows.DetonateLastError(0, :SetMenuItemInfo,
+					@menu.handle,
+					@id,
+					0,
+					mii.tap { mii[:cbSize] = mii.size }
+				)
+			end
+
+			def image; (Handle.instance?(handle = info(:bitmap)[:hbmpItem])) ? Handle.instance(handle) : nil end
+
+			def image=(image)
+				self.info = Windows::MENUITEMINFO.new.tap { |mii|
+					mii[:fMask] = Windows::MIIM_BITMAP
+					mii[:hbmpItem] = image.handle
 				}
-			)
-
-			info
-		end
-
-		def info=(mii)
-			Windows.DetonateLastError(0, :SetMenuItemInfo,
-				@menu.handle,
-				@id,
-				0,
-				mii.tap { mii[:cbSize] = mii.size }
-			)
-		end
-
-		def image; (Handle.instance?(handle = info(:bitmap)[:hbmpItem])) ? Handle.instance(handle) : nil end
-
-		def image=(image)
-			self.info = Windows::MENUITEMINFO.new.tap { |mii|
-				mii[:fMask] = Windows::MIIM_BITMAP
-				mii[:hbmpItem] = image.handle
-			}
+			end
 		end
-	end
-
-	module MenuMethods
-		def rdetach; submenus.each(&:rdetach); detach end
 
-		def [](id) MenuItem.new(self, id) end
+		def [](id) Item.new(self, id) end
 
 		def append(flags, item = nil, id = 0)
 			Windows.DetonateLastError(0, :AppendMenu,

data/lib/fzeet/UIRibbon.rb

@@ -1,6 +1,14 @@
-require_relative 'WindowCommon'
+require_relative 'Common'
 
 module Fzeet
+	class Windows::PropertyStore
+		def uiprop(*args)
+			args[0] = Windows.const_get("UI_PKEY_#{args[0]}")
+
+			prop(*args)
+		end
+	end
+
 	class UIRibbon
 		class Command
 			include Toggle
@@ -20,6 +28,77 @@ module Fzeet
 
 		def [](id) Command.new(self, id) end
 
+		module Color
+			def self.enhance(hsb, ribbon, method)
+				hsb.instance_variable_set(:@ribbon, ribbon)
+				hsb.instance_variable_set(:@method, method)
+
+				class << hsb
+					attr_reader :ribbon, :method
+
+					include Color
+				end
+
+				hsb
+			end
+
+			def darken(amount) self[2] -= amount; ribbon.send("#{method}=", self); self end
+			def lighten(amount) self[2] += amount; ribbon.send("#{method}=", self); self end
+
+			def saturate(amount) self[1] += amount; ribbon.send("#{method}=", self); self end
+			def bleach(amount) self[1] -= amount; ribbon.send("#{method}=", self); self end
+
+			def shift(amount) self[0] += amount; ribbon.send("#{method}=", self); self end
+		end
+
+		def background
+			hsb = nil
+
+			uif.QueryInstance(Windows::PropertyStore) { |ps|
+				hsb = ps.uiprop(:GlobalBackgroundColor).uint
+			}
+
+			Color.enhance([Windows::UI_GetHValue(hsb), Windows::UI_GetSValue(hsb), Windows::UI_GetBValue(hsb)], self, __method__)
+		end
+
+		def background=(hsb)
+			uif.QueryInstance(Windows::PropertyStore) { |ps|
+				ps.uiprop(:GlobalBackgroundColor, Windows::PROPVARIANT[:uint, Windows::UI_HSB(*hsb)]).commit
+			}
+		end
+
+		def color
+			hsb = nil
+
+			uif.QueryInstance(Windows::PropertyStore) { |ps|
+				hsb = ps.uiprop(:GlobalTextColor).uint
+			}
+
+			Color.enhance([Windows::UI_GetHValue(hsb), Windows::UI_GetSValue(hsb), Windows::UI_GetBValue(hsb)], self, __method__)
+		end
+
+		def color=(hsb)
+			uif.QueryInstance(Windows::PropertyStore) { |ps|
+				ps.uiprop(:GlobalTextColor, Windows::PROPVARIANT[:uint, Windows::UI_HSB(*hsb)]).commit
+			}
+		end
+
+		def highlight
+			hsb = nil
+
+			uif.QueryInstance(Windows::PropertyStore) { |ps|
+				hsb = ps.uiprop(:GlobalHighlightColor).uint
+			}
+
+			Color.enhance([Windows::UI_GetHValue(hsb), Windows::UI_GetSValue(hsb), Windows::UI_GetBValue(hsb)], self, __method__)
+		end
+
+		def highlight=(hsb)
+			uif.QueryInstance(Windows::PropertyStore) { |ps|
+				ps.uiprop(:GlobalHighlightColor, Windows::PROPVARIANT[:uint, Windows::UI_HSB(*hsb)]).commit
+			}
+		end
+
 		def initialize(window, name = Application.name, resname = 'APPLICATION_RIBBON')
 			@executesAllVerbs = {}
 
@@ -101,5 +180,11 @@ module Fzeet
 
 			self
 		end
+
+		def contextualUI(id, x, y)
+			uif.UseInstance(Windows::UIContextualUI, :GetView, id) { |view|
+				view.ShowAtLocation(x, y)
+			}
+		end
 	end
 end

data/lib/fzeet/{WindowCommon.rb → Window/Common.rb}

@@ -1,6 +1,56 @@
 require_relative 'WindowMethods'
 
 module Fzeet
+	class WindowClass < Windows::WNDCLASSEX
+		def initialize(prototype, name, opts = {})
+			@prototype = prototype
+			@name = name
+			className = FFI::MemoryPointer.from_string(@name)
+
+			_opts = {
+				style: [],
+				wndProc: BasicWindow::WindowProc,
+				clsExtra: 0,
+				wndExtra: 0,
+				icon: SystemIcon.new(:application),
+				cursor: SystemCursor.new(:arrow),
+				background: SystemBrush.new(:window),
+				iconSm: nil
+			}
+			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
+
+			self[:cbSize] = Windows::WNDCLASSEX.size
+			self[:hInstance] = Windows.GetModuleHandle(nil)
+			self[:lpszClassName] = className
+
+			if @prototype
+				self[:style] = Fzeet.flags(opts[:style] || [], :cs_) | @prototype[:style]
+				self[:lpfnWndProc] = opts[:wndProc] || @prototype[:lpfnWndProc]
+				self[:cbClsExtra] = (opts[:clsExtra] || 0) + @prototype[:cbClsExtra]
+				self[:cbWndExtra] = (opts[:wndExtra] || 0) + @prototype[:cbWndExtra]
+				self[:hIcon] = (opts[:icon] && opts[:icon].handle) || @prototype[:hIcon]
+				self[:hCursor] = (opts[:cursor] && opts[:cursor].handle) || @prototype[:hCursor]
+				self[:hbrBackground] = (opts[:background] && opts[:background].handle) || @prototype[:hbrBackground]
+				self[:hIconSm] = (opts[:iconSm] && _opts[:iconSm].handle) || @prototype[:hIconSm]
+			else
+				_opts.merge(opts)
+
+				self[:style] = Fzeet.flags(_opts[:style], :cs_)
+				self[:lpfnWndProc] = _opts[:wndProc]
+				self[:cbClsExtra] = _opts[:clsExtra]
+				self[:cbWndExtra] = _opts[:wndExtra]
+				self[:hIcon] = _opts[:icon].handle
+				self[:hCursor] = _opts[:cursor].handle
+				self[:hbrBackground] = _opts[:background].handle
+				self[:hIconSm] = _opts[:iconSm] && _opts[:iconSm].handle
+			end
+
+			Windows.DetonateLastError(0, :RegisterClassEx, self) { className.free }
+		end
+
+		attr_reader :prototype, :name
+	end
+
 	class BasicWindow < Handle
 		include WindowMethods
 
@@ -64,8 +114,8 @@ module Fzeet
 		WindowClass = Fzeet::WindowClass.new(nil, 'Fzeet.BasicWindow')
 
 		def self.[](name, opts = {})
-			Class.new(self) { |klass|
-				klass.const_set(:WindowClass, Fzeet::WindowClass.new(self::WindowClass, name, opts))
+			Class.new(self) {
+				const_set(:WindowClass, Fzeet::WindowClass.new(self::WindowClass, name, opts))
 			}
 		end
 

data/lib/fzeet/{WindowDialog.rb → Window/Dialog.rb}

@@ -1,4 +1,4 @@
-require_relative 'WindowCommon'
+require_relative 'Common'
 
 module Fzeet
 	Dialog = BasicWindow['Fzeet.Dialog',
@@ -45,24 +45,24 @@ module Fzeet
 
 			on(:initdialog, &block) if block
 
-			if _opts[:modal]
-				@result = Windows.DetonateLastError([-1, 0], :DialogBoxIndirectParam,
+			unless _opts[:modal]
+				@handle = Windows.DetonateLastError(FFI::Pointer::NULL, :CreateDialogIndirectParam,
 					Windows.GetModuleHandle(nil),
 					dt,
 					@parent && @parent.handle,
 					BasicWindow::DialogProc,
 					object_id
 				)
+
+				self.dialog = true
 			else
-				@handle = Windows.DetonateLastError(FFI::Pointer::NULL, :CreateDialogIndirectParam,
+				@result = Windows.DetonateLastError([-1, 0], :DialogBoxIndirectParam,
 					Windows.GetModuleHandle(nil),
 					dt,
 					@parent && @parent.handle,
 					BasicWindow::DialogProc,
 					object_id
 				)
-
-				self.dialog = true
 			end
 		end
 

data/lib/fzeet/{WindowWindow.rb → Window/Window.rb}

@@ -1,4 +1,4 @@
-require_relative 'WindowCommon'
+require_relative 'Common'
 
 module Fzeet
 	Window = BasicWindow['Fzeet.Window']

data/lib/fzeet/{WindowMethods.rb → Window/WindowMethods.rb}

@@ -1,9 +1,44 @@
-require_relative 'common'
+require_relative '../Common'
 
 module Fzeet
 	module WindowMethods
 		include Toggle
 
+		def message(message, opts = {window: self}) Fzeet.message(message, opts) end
+		def question(message, opts = {window: self}) Fzeet.question(message, opts) end
+
+		def sendmsg(msg, wParam = 0, lParam = 0)
+			Windows.SendMessage(
+				@handle,
+				Fzeet.constant(msg, *self.class::Prefix[:message]),
+				wParam.to_i,
+				((lparam = lParam.to_i) > 0x7fff_ffff) ? lparam - 0x1_0000_0000 : lparam
+			)
+		end
+
+		def postmsg(msg, wParam = 0, lParam = 0)
+			Windows.DetonateLastError(0, :PostMessage,
+				@handle,
+				Fzeet.constant(msg, *self.class::Prefix[:message]),
+				wParam.to_i,
+				((lparam = lParam.to_i) > 0x7fff_ffff) ? lparam - 0x1_0000_0000 : lparam
+			)
+
+			self
+		end
+
+		def dialog?; Application.dialogs.include?(self) end
+
+		def dialog=(dialog)
+			if dialog
+				Application.dialogs << self unless dialog?
+			else
+				Application.dialogs.delete(self)
+			end
+		end
+
+		def dlgmsg?(msg) Windows.IsDialogMessage(@handle, msg) != 0 end
+
 		class Long
 			def initialize(window) @window = window end
 
@@ -61,7 +96,14 @@ module Fzeet
 			)
 		end
 
+		def enabled?; Windows.IsWindowEnabled(@handle) != 0 end
+		def enabled=(enabled) Windows.EnableWindow(@handle, (enabled) ? 1 : 0) end
+
+		def visible?; Windows.IsWindowVisible(@handle) != 0 end
+		def visible=(visible) show((visible) ? Windows::SW_SHOWNORMAL : Windows::SW_HIDE) end
+
 		def show(cmdShow = :shownormal) Windows.ShowWindow(@handle, Fzeet.constant(cmdShow, :sw_)); self end
+
 		def update; Windows.DetonateLastError(0, :UpdateWindow, @handle); self end
 
 		def textlen; Windows.GetWindowTextLength(@handle) end
@@ -80,9 +122,6 @@ module Fzeet
 
 		def text=(text) Windows.DetonateLastError(0, :SetWindowText, @handle, text) end
 
-		def enabled?; Windows.IsWindowEnabled(@handle) != 0 end
-		def enabled=(enabled) Windows.EnableWindow(@handle, (enabled) ? 1 : 0) end
-
 		def rect; Windows.DetonateLastError(0, :GetClientRect, @handle, r = Rect.new); r end
 
 		def position; Windows.DetonateLastError(0, :GetWindowRect, @handle, r = Rect.new); r end
@@ -108,14 +147,6 @@ module Fzeet
 		def capture?; Windows.GetCapture().to_i == @handle.to_i end
 		def capture=(capture) (capture) ? Windows.SetCapture(@handle) : Windows.DetonateLastError(0, :ReleaseCapture) end
 
-		def [](id) Handle.instance(Windows.DetonateLastError(FFI::Pointer::NULL, :GetDlgItem, @handle, Command[id])) end
-
-		EnumChildProc = FFI::Function.new(:int, [:pointer, :long], convention: :stdcall) { |hwnd, lParam|
-			ObjectSpace._id2ref(lParam).call(Handle.instance(hwnd)) if Handle.instance?(hwnd); 1
-		}
-
-		def eachChild(&block) Windows.EnumChildWindows(@handle, EnumChildProc, block.object_id); self end
-
 		def menu; (Handle.instance?(handle = Windows.GetMenu(@handle))) ? Handle.instance(handle) : nil end
 
 		def menu=(menu)
@@ -124,39 +155,14 @@ module Fzeet
 			Windows.DetonateLastError(0, :SetMenu, @handle, menu.handle) if menu
 		end
 
-		def sendmsg(msg, wParam = 0, lParam = 0)
-			Windows.SendMessage(
-				@handle,
-				Fzeet.constant(msg, *self.class::Prefix[:message]),
-				wParam.to_i,
-				((lparam = lParam.to_i) > 0x7fff_ffff) ? lparam - 0x1_0000_0000 : lparam
-			)
-		end
+		def drawMenuBar; Windows.DetonateLastError(0, :DrawMenuBar, @handle); self end
 
-		def postmsg(msg, wParam = 0, lParam = 0)
-			Windows.DetonateLastError(0, :PostMessage,
-				@handle,
-				Fzeet.constant(msg, *self.class::Prefix[:message]),
-				wParam.to_i,
-				((lparam = lParam.to_i) > 0x7fff_ffff) ? lparam - 0x1_0000_0000 : lparam
-			)
-
-			self
-		end
-
-		def dlgmsg?(msg) Windows.IsDialogMessage(@handle, msg) != 0 end
-
-		def dialog?; Application.dialogs.include?(self) end
+		def [](id) Handle.instance(Windows.DetonateLastError(FFI::Pointer::NULL, :GetDlgItem, @handle, Command[id])) end
 
-		def dialog=(dialog)
-			if dialog
-				Application.dialogs << self unless dialog?
-			else
-				Application.dialogs.delete(self)
-			end
-		end
+		EnumChildProc = FFI::Function.new(:int, [:pointer, :long], convention: :stdcall) { |hwnd, lParam|
+			ObjectSpace._id2ref(lParam).call(Handle.instance(hwnd)) if Handle.instance?(hwnd); 1
+		}
 
-		def message(message, opts = {window: self}) Fzeet.message(message, opts) end
-		def question(message, opts = {window: self}) Fzeet.question(message, opts) end
+		def eachChild(&block) Windows.EnumChildWindows(@handle, EnumChildProc, block.object_id); self end
 	end
 end

data/lib/fzeet/Window.rb

@@ -1,2 +1,2 @@
-require_relative 'WindowWindow'
-require_relative 'WindowDialog'
+require_relative 'Window/Window'
+require_relative 'Window/Dialog'

data/lib/fzeet/windows/com.rb

@@ -6,9 +6,19 @@ module Fzeet
 		ffi_convention :stdcall
 
 		S_OK = 0
+		S_FALSE = 1
 
+		E_UNEXPECTED = 0x8000FFFF - 0x1_0000_0000
 		E_NOTIMPL = 0x80004001 - 0x1_0000_0000
+		E_OUTOFMEMORY = 0x8007000E - 0x1_0000_0000
+		E_INVALIDARG = 0x80070057 - 0x1_0000_0000
 		E_NOINTERFACE = 0x80004002 - 0x1_0000_0000
+		E_POINTER = 0x80004003 - 0x1_0000_0000
+		E_HANDLE = 0x80070006 - 0x1_0000_0000
+		E_ABORT = 0x80004004 - 0x1_0000_0000
+		E_FAIL = 0x80004005 - 0x1_0000_0000
+		E_ACCESSDENIED = 0x80070005 - 0x1_0000_0000
+		E_PENDING = 0x8000000A - 0x1_0000_0000
 
 		def SUCCEEDED(hr) hr >= 0 end
 		def FAILED(hr) hr < 0 end
@@ -17,6 +27,16 @@ module Fzeet
 			:SUCCEEDED,
 			:FAILED
 
+		def DetonateHresult(name, *args)
+			failed = FAILED(result = send(name, *args)) and raise "#{name} failed (hresult #{format('%#08x', result)})."
+
+			result
+		ensure
+			yield failed if block_given?
+		end
+
+		module_function :DetonateHresult
+
 		class GUID < FFI::Struct
 			layout \
 				:Data1, :ulong,
@@ -41,6 +61,30 @@ module Fzeet
 		end
 
 		CLSCTX_INPROC_SERVER = 0x1
+		CLSCTX_INPROC_HANDLER = 0x2
+		CLSCTX_LOCAL_SERVER = 0x4
+		CLSCTX_INPROC_SERVER16 = 0x8
+		CLSCTX_REMOTE_SERVER = 0x10
+		CLSCTX_INPROC_HANDLER16 = 0x20
+		CLSCTX_RESERVED1 = 0x40
+		CLSCTX_RESERVED2 = 0x80
+		CLSCTX_RESERVED3 = 0x100
+		CLSCTX_RESERVED4 = 0x200
+		CLSCTX_NO_CODE_DOWNLOAD = 0x400
+		CLSCTX_RESERVED5 = 0x800
+		CLSCTX_NO_CUSTOM_MARSHAL = 0x1000
+		CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000
+		CLSCTX_NO_FAILURE_LOG = 0x4000
+		CLSCTX_DISABLE_AAA = 0x8000
+		CLSCTX_ENABLE_AAA = 0x10000
+		CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000
+		CLSCTX_ACTIVATE_32_BIT_SERVER = 0x40000
+		CLSCTX_ACTIVATE_64_BIT_SERVER = 0x80000
+		CLSCTX_ENABLE_CLOAKING = 0x100000
+		CLSCTX_PS_DLL = -0x80000000
+		CLSCTX_INPROC = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
+		CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+		CLSCTX_SERVER = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
 
 		attach_function :CoCreateInstance, [:pointer, :pointer, :ulong, :pointer, :pointer], :long
 
@@ -51,25 +95,61 @@ module Fzeet
 
 					spec.each { |name, signature| signature[0].unshift(:pointer) }
 
-					Class.new(FFI::Struct) { |iface|
-						iface.const_set(:IID, iid)
+					Class.new(FFI::Struct) {
+						const_set(:IID, iid)
 
-						iface.const_set(:VTBL, Class.new(FFI::Struct) { |vtbl|
-							vtbl.const_set(:SPEC, Hash[(ifaces.map { |iface| iface::VTBL::SPEC.to_a } << spec.to_a).flatten(1)])
+						const_set(:VTBL, Class.new(FFI::Struct) {
+							const_set(:SPEC, Hash[(ifaces.map { |iface| iface::VTBL::SPEC.to_a } << spec.to_a).flatten(1)])
 
-							vtbl.layout \
-								*vtbl::SPEC.map { |name, signature| [name, callback(*signature)] }.flatten
+							layout \
+								*self::SPEC.map { |name, signature| [name, callback(*signature)] }.flatten
 						})
 
-						iface.layout \
+						layout \
 							:lpVtbl, :pointer
 					}
 				end
 			end
 
+			module Helpers
+				def QueryInstance(klass)
+					instance = nil
+
+					FFI::MemoryPointer.new(:pointer) { |ppv|
+						QueryInterface(klass::IID, ppv)
+
+						instance = klass.new(ppv.read_pointer)
+					}
+
+					begin
+						yield instance; return self
+					ensure
+						instance.Release
+					end if block_given?
+
+					instance
+				end
+
+				def UseInstance(klass, name, *args)
+					instance = nil
+
+					FFI::MemoryPointer.new(:pointer) { |ppv|
+						send(name, *args, klass::IID, ppv)
+
+						yield instance = klass.new(ppv.read_pointer)
+					}
+
+					self
+				ensure
+					instance.Release if instance
+				end
+			end
+
 			module Instance
 				def self.[](iface)
-					Class.new(iface) { |klass|
+					Class.new(iface) {
+						send(:include, Helpers)
+
 						def initialize(pointer)
 							self.pointer = pointer
 
@@ -89,8 +169,10 @@ module Fzeet
 
 			module Factory
 				def self.[](iface, clsid)
-					Class.new(iface) { |klass|
-						klass.const_set(:CLSID, clsid)
+					Class.new(iface) {
+						send(:include, Helpers)
+
+						const_set(:CLSID, clsid)
 
 						def initialize(opts = {})
 							@opts = opts
@@ -120,7 +202,9 @@ module Fzeet
 
 			module Callback
 				def self.[](iface)
-					Class.new(iface) { |klass|
+					Class.new(iface) {
+						send(:include, Helpers)
+
 						def initialize(opts = {})
 							@vtbl, @refc = self.class::VTBL.new, 1
 
@@ -144,7 +228,7 @@ module Fzeet
 						attr_reader :vtbl, :refc
 
 						def QueryInterface(riid, ppv)
-							if [IID_IUnknown, self.class::IID].any? { |iid| Windows.memcmp(riid, iid, iid.size) == 0 }
+							if [IUnknown::IID, self.class::IID].any? { |iid| Windows.memcmp(riid, iid, iid.size) == 0 }
 								ppv.write_pointer(self)
 							else
 								ppv.write_pointer(0); return E_NOINTERFACE
@@ -171,10 +255,8 @@ module Fzeet
 			end
 		end
 
-		IID_IUnknown = GUID['00000000-0000-0000-C000-000000000046']
-
 		IUnknown = COM::Interface[
-			IID_IUnknown,
+			GUID['00000000-0000-0000-C000-000000000046'],
 
 			QueryInterface: [[:pointer, :pointer], :long],
 			AddRef: [[], :ulong],

data/lib/fzeet/windows/{comctlbutton.rb → comctl/Button.rb}

@@ -1,4 +1,4 @@
-require_relative 'comctlcommon'
+require_relative 'Common'
 
 module Fzeet
 	module Windows