fzeet 0.6.5 → 0.6.6

data/lib/fzeet/windows/shdocvw.rb

@@ -115,4 +115,154 @@ module Fzeet
 
 		WebBrowser = COM::Factory[IWebBrowser, GUID['EAB22AC3-30C1-11CF-A7EB-0000C05BAE0B']]
 	end
+
+	class WebBrowser < Windows::WebBrowser
+		def initialize(parent)
+			@parent = parent
+
+			@oips = Windows::OleInPlaceSite.new
+
+			@oips.instance_variable_set(:@browser, self)
+
+			class << @oips
+				attr_reader :browser
+
+				def CanInPlaceActivate
+					Windows::S_OK
+				end
+
+				def GetWindow(phwnd)
+					phwnd.write_pointer(browser.parent.handle)
+
+					Windows::S_OK
+				end
+
+				def GetWindowContext(pframe, pdoc, prPos, prClip, pinfo)
+					pframe.write_pointer(0)
+					pdoc.write_pointer(0)
+					Windows.GetClientRect(browser.parent.handle, prPos)
+					Windows.GetClientRect(browser.parent.handle, prClip)
+
+					Windows::S_OK
+				end
+
+				def OnPosRectChange(prPos)
+					browser.QueryInstance(Windows::OleInPlaceObject) { |oipo|
+						oipo.SetObjectRects(prPos, prPos)
+					}
+
+					Windows::S_OK
+				end
+			end
+
+			@ocs = Windows::OleClientSite.new
+
+			@ocs.instance_variable_set(:@browser, self)
+
+			class << @ocs
+				attr_reader :browser
+
+				def QueryInterface(piid, ppv)
+					if Windows::GUID.new(piid) == Windows::IOleInPlaceSite::IID
+						ppv.write_pointer(browser.oips); browser.oips.AddRef
+
+						return Windows::S_OK
+					end
+
+					super
+				end
+			end
+
+			super()
+
+			@events = Windows::WebBrowserEvents.new
+
+			@events.instance_variable_set(:@browser, self)
+
+			class << @events
+				attr_reader :browser
+
+				(self::VTBL.members - Windows::IDispatch::VTBL.members).each { |name|
+					define_method(name) { |dispParams|
+						(handlers = browser.handlers && browser.handlers[name]) && handlers.each { |handler|
+							(handler.arity == 0) ? handler.call : handler.call(dispParams)
+						}
+					}
+				}
+			end
+
+			QueryInstance(Windows::ConnectionPointContainer) { |cpc|
+				FFI::MemoryPointer.new(:pointer) { |pcp|
+					cpc.FindConnectionPoint(Windows::WebBrowserEvents::IID, pcp)
+
+					@cp = Windows::ConnectionPoint.new(pcp.read_pointer)
+				}
+			}
+
+			@cookie = nil
+			FFI::MemoryPointer.new(:ulong) { |p| @cp.Advise(@events, p); @cookie = p.get_ulong(0) }
+
+			QueryInstance(Windows::OleObject) { |oo|
+				oo.SetClientSite(@ocs)
+				oo.DoVerb(Windows::OLEIVERB_INPLACEACTIVATE, nil, @ocs, 0, @parent.handle, @parent.rect)
+			}
+
+			@parent.
+				on(:size) {
+					r = @parent.rect
+
+					put_Top(r[:top]); put_Left(r[:left]); put_Width(r[:right]); put_Height(r[:bottom])
+				}.
+
+				on(:destroy) {
+					@oips.Release
+					@ocs.Release
+					@cp.Unadvise(@cookie)
+					@events.Release
+					@cp.Release
+					Release()
+				}.
+
+				instance_variable_set(:@__WebBrowser__, self)
+		end
+
+		attr_reader :parent, :oips, :ocs, :events, :cp, :handlers
+
+		def on(event, &block)
+			((@handlers ||= {})[event] ||= []) << block
+
+			self
+		end
+
+		def goto(where)
+			where = Windows.SysAllocString("#{where}\0".encode('utf-16le'))
+
+			Navigate(where, nil, nil, nil, nil)
+
+			self
+		ensure
+			Windows.SysFreeString(where)
+		end
+
+		def back; GoBack(); self; rescue; self end
+		def forward; GoForward(); self; rescue; self end
+		def home; GoHome(); self end
+		def search; GoSearch(); self end
+
+		def refresh; Refresh(); self end
+
+		def document
+			disp = nil
+
+			FFI::MemoryPointer.new(:pointer) { |pdisp|
+				get_Document(pdisp)
+
+				disp = Windows::Dispatch.new(pdisp.read_pointer)
+
+				return disp.QueryInstance(Windows::HTMLDocument2)
+			}
+		ensure
+			disp.Release if disp
+		end
+	end
 end

data/lib/fzeet/windows/shell.rb

@@ -1,2 +1,2 @@
 require_relative 'shell/BrowseForFolder'
-require_relative 'shell/FileDialog' if Fzeet::Windows::WINVER.AtLeastWindowsVista?
+require_relative 'shell/FileDialog' if Fzeet::Windows::Version >= :vista

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

@@ -6,6 +6,29 @@ module Fzeet
 		ffi_lib 'shell32'
 		ffi_convention :stdcall
 
+		class PROPERTYKEY < FFI::Struct
+			layout \
+				:fmtid, GUID,
+				:pid, :ulong
+
+			def self.[](type, index)
+				new.tap { |key|
+					key[:fmtid].tap { |guid|
+						guid[:Data1] = 0x00000000 + index
+						guid[:Data2] = 0x7363
+						guid[:Data3] = 0x696e
+						[0x84, 0x41, 0x79, 0x8a, 0xcf, 0x5a, 0xeb, 0xb7].each_with_index { |part, i|
+							guid[:Data4][i] = part
+						}
+					}
+
+					key[:pid] = type
+				}
+			end
+
+			def ==(other) Windows.memcmp(other, self, size) == 0 end
+		end
+
 		attach_function :ShellExecute, :ShellExecuteA, [:pointer, :string, :string, :string, :string, :int], :pointer
 
 		attach_function :SHGetPathFromIDList, :SHGetPathFromIDListA, [:pointer, :pointer], :int
@@ -137,7 +160,7 @@ module Fzeet
 
 			Initialize: [[:pointer, :pointer, :pointer], :long],
 			Destroy: [[], :long],
-			SetRect: [[:pointer, RECT], :long],
+			SetRect: [[:pointer, RECT.by_value], :long],
 			SetPropertyBag: [[:buffer_in], :long],
 			SetEmptyText: [[:buffer_in], :long],
 			SetFolderSettings: [[:pointer], :long],
@@ -257,7 +280,7 @@ module Fzeet
 		FOLDERID_UserPinned = GUID['9e3995ab-1f9c-4f13-b827-48b24b6c7174']
 		FOLDERID_ImplicitAppShortcuts = GUID['bcb5256f-79f6-4cee-b725-dc34e402fd46']
 
-		if WINVER.AtLeastWindowsVista?
+		if Version >= :vista
 			attach_function :SHGetKnownFolderIDList, [:pointer, :ulong, :pointer, :pointer], :long
 		end
 
@@ -290,4 +313,73 @@ module Fzeet
 		SBSP_REDIRECT = 0x40000000
 		SBSP_INITIATEDBYHLINKFRAME = 0x80000000
 	end
+
+	def shell(name, args = nil, dir = nil, verb = 'open')
+		raise 'ShellExecute failed.' unless Windows.ShellExecute(nil, verb, name, args, dir, Windows::SW_NORMAL).to_i > 32
+	end
+
+	module_function :shell
+
+	class ExplorerBrowser < Windows::ExplorerBrowser
+		def initialize(parent)
+			@parent = parent
+
+			super()
+
+			@events = Windows::ExplorerBrowserEvents.new
+
+			@events.instance_variable_set(:@browser, self)
+
+			class << @events
+				attr_reader :browser
+
+				(self::VTBL.members - Windows::IUnknown::VTBL.members).each { |name|
+					define_method(name) { |*args|
+						(handlers = browser.handlers && browser.handlers[name]) && handlers.each { |handler|
+							(handler.arity == 0) ? handler.call : handler.call(*args)
+						}
+
+						Windows::S_OK
+					}
+				}
+			end
+
+			@cookie = nil
+			FFI::MemoryPointer.new(:ulong) { |p| Advise(@events, p); @cookie = p.get_ulong(0) }
+
+			Initialize(@parent.handle, parent.rect, nil)
+
+			@parent.
+				on(:size) { SetRect(nil, @parent.rect) }.
+				on(:destroy) { Unadvise(@cookie); @events.Release; Destroy(); Release() }.
+
+				instance_variable_set(:@__ExplorerBrowser__, self)
+		end
+
+		attr_reader :parent, :events, :handlers
+
+		def on(event, &block)
+			((@handlers ||= {})["On#{event}".to_sym] ||= []) << block
+
+			self
+		end
+
+		def goto(where)
+			pidl = nil
+
+			FFI::MemoryPointer.new(:pointer) { |p|
+				Windows.SHGetKnownFolderIDList(Windows.const_get("FOLDERID_#{where}"), 0, nil, p)
+
+				BrowseToIDList(pidl = p.read_pointer, 0)
+			}
+
+			self
+		ensure
+			Windows.CoTaskMemFree(pidl)
+		end
+
+		def back; BrowseToIDList(nil, Windows::SBSP_NAVIGATEBACK); self end
+		def forward; BrowseToIDList(nil, Windows::SBSP_NAVIGATEFORWARD); self end
+		def up; BrowseToIDList(nil, Windows::SBSP_PARENT); self end
+	end
 end

data/lib/fzeet/windows/shlwapi.rb

@@ -1,4 +1,4 @@
-require_relative 'common'
+require_relative 'core'
 
 module Fzeet
 	module Windows

data/lib/fzeet/windows/uiribbon.rb

@@ -1,4 +1,6 @@
 require_relative 'ole'
+require_relative 'oleaut'
+require_relative 'shell'
 
 module Fzeet
 	module Windows
@@ -385,4 +387,418 @@ module Fzeet
 
 		module_function :UI_MAKEAPPMODE
 	end
+
+	class Windows::PropertyStore
+		def uiprop(*args)
+			args[0] = Windows.const_get("UI_PKEY_#{args[0]}")
+
+			prop(*args)
+		end
+
+		def update(from)
+			case from
+			when Windows::LOGFONT
+				uiprop(:FontProperties_Family, Windows::PROPVARIANT[:wstring, from.face])
+				uiprop(:FontProperties_Size, Windows::PROPVARIANT[:decimal, from.size.round])
+				uiprop(:FontProperties_Bold, Windows::PROPVARIANT[:uint, (from.bold?) ? 2 : 1])
+				uiprop(:FontProperties_Italic, Windows::PROPVARIANT[:uint, (from.italic?) ? 2 : 1])
+				uiprop(:FontProperties_Underline, Windows::PROPVARIANT[:uint, (from.underline?) ? 2 : 1])
+				uiprop(:FontProperties_Strikethrough, Windows::PROPVARIANT[:uint, (from.strikeout?) ? 2 : 1])
+			else raise ArgumentError
+			end
+
+			self
+		end
+	end
+
+	class Windows::UISimplePropertySet
+		def get(k) Windows::PROPVARIANT.new.tap { |v| GetValue(k, v) } end
+
+		def prop(*args)
+			case args.length
+			when 1; get(*args)
+			else raise ArgumentError
+			end
+		end
+
+		def uiprop(*args)
+			args[0] = Windows.const_get("UI_PKEY_#{args[0]}")
+
+			prop(*args)
+		end
+	end
+
+	class UIRibbon
+		class Command
+			include Toggle
+
+			def initialize(ribbon, id)
+				@ribbon, @id = ribbon, id
+			end
+
+			attr_reader :ribbon, :id
+
+			def [](k) Windows::PROPVARIANT.new.tap { |v| ribbon.uif.GetUICommandProperty(id, k, v) } end
+			def []=(k, v) ribbon.uif.SetUICommandProperty(id, k, v) end
+
+			def enabled?; self[Windows::UI_PKEY_Enabled].bool end
+			def enabled=(enabled) self[Windows::UI_PKEY_Enabled] = Windows::PROPVARIANT[:bool, enabled] end
+
+			def checked?; self[Windows::UI_PKEY_BooleanValue].bool end
+			def checked=(checked) self[Windows::UI_PKEY_BooleanValue] = Windows::PROPVARIANT[:bool, checked] end
+		end
+
+		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
+
+		class GalleryItem < Windows::UISimplePropertySetCallback
+			def initialize(label, categoryId = 0, image = nil)
+				@label, @categoryId, @image = label, categoryId, image
+
+				super()
+			end
+
+			attr_reader :label, :categoryId, :image
+
+			def GetValue(pkey, pvalue)
+				key, value = Windows::PROPERTYKEY.new(pkey), Windows::PROPVARIANT.new(pvalue)
+
+				case key
+				when Windows::UI_PKEY_CategoryId
+					value.uint = @categoryId; Windows::S_OK
+				when Windows::UI_PKEY_Label
+					value.wstring = @label; Windows::S_OK
+				when Windows::UI_PKEY_ItemImage
+					FFI::MemoryPointer.new(:pointer) { |punk|
+						Windows::UIImageFromBitmap.new.CreateImage(PARGB32.new(@image).handle, Windows::UI_OWNERSHIP_TRANSFER, punk)
+
+						unk = Windows::Unknown.new(punk.read_pointer)
+						value.unknown = unk
+						unk.Release
+					}
+
+					Windows::S_OK
+				else
+					Windows::E_NOTIMPL
+				end
+			end
+		end
+
+		def initialize(_window, opts = {})
+			handlers = {}
+
+			opts.delete_if { |k, v|
+				next false unless v.kind_of?(Proc)
+
+				handlers[k] = v; true
+			}
+
+			_opts = {
+				name: Application.name,
+				resname: 'APPLICATION_RIBBON'
+			}
+			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
+			_opts.merge!(opts)
+
+			@creates = []
+			@destroys = []
+			@sizes = []
+			@executesAllVerbs = {}
+			@executesExecute = {}
+			@executesPreview = {}
+			@executesCancelPreview = {}
+			@updatesAllKeys = {}
+
+			@window = _window
+
+			window.instance_variable_set(:@ribbon, self)
+
+			class << window
+				attr_reader :ribbon
+			end
+
+			@uich = Windows::UICommandHandler.new
+
+			uich.instance_variable_set(:@ribbon, self)
+
+			class << uich
+				attr_reader :ribbon
+
+				def Execute(*args) ribbon.execute(*args); Windows::S_OK end
+				def UpdateProperty(*args) ribbon.update(*args); Windows::S_OK end
+			end
+
+			@uia = Windows::UIApplication.new
+
+			uia.instance_variable_set(:@uich, @uich)
+
+			class << uia
+				attr_reader :uich, :uir
+
+				def OnViewChanged(viewId, typeId, view, verb, reason)
+					return Windows::S_OK unless typeId == Windows::UI_VIEWTYPE_RIBBON
+
+					args = {
+						viewId: viewId,
+						typeId: typeId,
+						view: view,
+						verb: verb,
+						reason: reason,
+						ribbon: self,
+						sender: self
+					}
+
+					case verb
+					when Windows::UI_VIEWVERB_CREATE
+						@uir = Windows::Unknown.new(view).QueryInstance(Windows::UIRibbon)
+
+						uir.instance_variable_set(:@height, 0)
+
+						class << uir
+							attr_accessor :height
+						end
+
+						uich.ribbon.instance_variable_get(:@creates).each { |handler|
+							(handler.arity == 0) ? handler.call : handler.call(args)
+						}
+					when Windows::UI_VIEWVERB_DESTROY
+						uich.ribbon.instance_variable_get(:@destroys).each { |handler|
+							(handler.arity == 0) ? handler.call : handler.call(args)
+						}
+
+						uir.Release
+					when Windows::UI_VIEWVERB_SIZE
+						FFI::MemoryPointer.new(:uint) { |p| uir.GetHeight(p); uir.height = p.read_int }
+
+						uich.ribbon.instance_variable_get(:@sizes).each { |handler|
+							(handler.arity == 0) ? handler.call : handler.call(args)
+						}
+					end
+
+					Windows::S_OK
+				rescue
+					Fzeet.message %Q{#{$!}\n\n#{$!.backtrace.join("\n")}}, icon: :error
+
+					Windows::S_OK
+				end
+
+				def OnCreateUICommand(*args) uich.QueryInterface(uich.class::IID, args[-1]); Windows::S_OK end
+			end
+
+			@hdll = Windows.LoadRibbonDll(_opts[:name])
+
+			handlers.each { |k, v|
+				k[1] = Object.const_get(k[1]) if k.length > 1
+
+				on(*k, &v)
+			}
+
+			@uif = Windows::UIFramework.new
+
+			uif.Initialize(window.handle, uia)
+			uif.LoadUI(@hdll, "#{_opts[:resname]}\0".encode('utf-16le'))
+
+			window.on(:destroy) {
+				raise unless uif.Destroy == Windows::S_OK; raise unless uif.Release == 0
+				raise unless uia.Release == 0
+				raise unless uich.Release == 0
+			}
+		end
+
+		attr_reader :hdll, :window, :uich, :uia, :uif
+
+		def height; uia.uir.height end
+
+		def execute(commandId, verb, key, value, props)
+			args = {
+				commandId: commandId,
+				verb: verb,
+				key: (key.null?) ? nil : Windows::PROPERTYKEY.new(key),
+				value: (value.null?) ? nil : Windows::PROPVARIANT.new(value),
+				props: (props.null?) ? nil : Windows::UISimplePropertySet.new(props),
+				ribbon: self,
+				sender: Command.new(self, commandId)
+			}
+
+			(handlers = @executesAllVerbs[commandId]) and handlers.each { |handler|
+				(handler.arity == 0) ? handler.call : handler.call(args)
+			}
+
+			case verb
+			when Windows::UI_EXECUTIONVERB_EXECUTE
+				(handlers = @executesExecute[commandId]) and handlers.each { |handler|
+					(handler.arity == 0) ? handler.call : handler.call(args)
+				}
+			when Windows::UI_EXECUTIONVERB_PREVIEW
+				(handlers = @executesPreview[commandId]) and handlers.each { |handler|
+					(handler.arity == 0) ? handler.call : handler.call(args)
+				}
+			when Windows::UI_EXECUTIONVERB_CANCELPREVIEW
+				(handlers = @executesCancelPreview[commandId]) and handlers.each { |handler|
+					(handler.arity == 0) ? handler.call : handler.call(args)
+				}
+			end
+
+			self
+		rescue
+			Fzeet.message %Q{#{$!}\n\n#{$!.backtrace.join("\n")}}, icon: :error
+
+			self
+		end
+
+		def update(commandId, key, value, newValue)
+			args = {
+				commandId: commandId,
+				key: (key.null?) ? nil : Windows::PROPERTYKEY.new(key),
+				value: (value.null?) ? nil : Windows::PROPVARIANT.new(value),
+				newValue: (newValue.null?) ? nil : Windows::PROPVARIANT.new(newValue),
+				ribbon: self,
+				sender: Command.new(self, commandId)
+			}
+
+			(handlers = @updatesAllKeys[commandId]) and handlers.each { |handler|
+				(handler.arity == 0) ? handler.call : handler.call(args)
+			}
+
+			self
+		rescue
+			Fzeet.message %Q{#{$!}\n\n#{$!.backtrace.join("\n")}}, icon: :error
+
+			self
+		end
+
+		def invalidate(commandId, flags = Windows::UI_INVALIDATIONS_ALLPROPERTIES, key = nil)
+			@uif.InvalidateUICommand(commandId, flags, key)
+
+			self
+		end
+
+		def on(*args, &block)
+			case args.size
+			when 1
+				case args[0]
+				when /^create$/i; @creates << block
+				when /^destroy$/i; @destroys << block
+				when /^size$/i; @sizes << block
+				when Integer; (@executesAllVerbs[args[0]] ||= []) << block
+				else raise ArgumentError
+				end
+			when 2
+				case args[0]
+				when /^execute$/i; (@executesExecute[args[1]] ||= []) << block
+				when /^preview$/i; (@executesPreview[args[1]] ||= []) << block
+				when /^cancelpreview$/i; (@executesCancelPreview[args[1]] ||= []) << block
+				when /^update$/i; (@updatesAllKeys[args[1]] ||= []) << block
+				else raise ArgumentError
+				end
+			else raise ArgumentError
+			end
+
+			self
+		end
+
+		def fontPropsUpdate(args)
+			return self unless args[:key] == Windows::UI_PKEY_FontProperties
+
+			args[:value].unknown { |current|
+				current.QueryInstance(Windows::PropertyStore) { |ps|
+					yield ps
+
+					args[:newValue].unknown = current
+				}
+			}
+
+			self
+		end
+
+		def fontPropsChanged(args)
+			return self unless args[:key] == Windows::UI_PKEY_FontProperties
+
+			args[:props].uiprop(:FontProperties_ChangedProperties).unknown { |changed|
+				changed.QueryInstance(Windows::PropertyStore) { |ps|
+					yield ps
+				}
+			}
+
+			self
+		end
+
+		def contextualUI(id, x, y)
+			uif.UseInstance(Windows::UIContextualUI, :GetView, id) { |view|
+				view.ShowAtLocation(x, y)
+			}
+
+			self
+		end
+	end
 end