fzeet 0.4.2 → 0.5.0

data/lib/fzeet/ControlCommon.rb

@@ -0,0 +1,64 @@
+require_relative 'WindowMethods'
+
+module Fzeet
+	class Control < Handle
+		include WindowMethods
+
+		Windows::NONCLIENTMETRICS.new.tap { |ncm|
+			ncm[:cbSize] = ncm.size
+
+			Windows.DetonateLastError(0, :SystemParametersInfo, Windows::SPI_GETNONCLIENTMETRICS, ncm.size, ncm, 0)
+
+			Font = IndirectFont.new(ncm[:lfMenuFont])
+
+			at_exit { Font.dispose }
+		}
+
+		def self.crackNotification(args) end
+
+		def initialize(className, parent, id, opts = {})
+			@parent = parent
+			@id = Command[id]
+
+			handlers = {}
+
+			opts.delete_if { |k, v|
+				next false unless v.kind_of?(Proc)
+
+				handlers[k] = v; true
+			}
+
+			_opts = {
+				xstyle: [],
+				caption: id.capitalize,
+				style: [],
+				x: Windows::CW_USEDEFAULT,
+				y: Windows::CW_USEDEFAULT,
+				width: Windows::CW_USEDEFAULT,
+				height: Windows::CW_USEDEFAULT,
+			}
+			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
+			_opts.merge!(opts)
+
+			_opts[:xstyle] = Fzeet.flags(_opts[:xstyle], *self.class::Prefix[:xstyle])
+			_opts[:caption] = _opts[:caption].to_s
+			_opts[:style] = Fzeet.flags([:child, :visible, :tabstop], :ws_) | Fzeet.flags(_opts[:style], *self.class::Prefix[:style])
+
+			@handle = Windows.DetonateLastError(FFI::Pointer::NULL, :CreateWindowEx,
+				_opts[:xstyle], className, _opts[:caption], _opts[:style],
+				_opts[:x], _opts[:y], _opts[:width], _opts[:height],
+				@parent.handle, FFI::Pointer.new(@id), Windows.GetModuleHandle(nil), nil
+			)
+
+			attach
+
+			sendmsg(:setfont, Font.handle, 1)
+
+			handlers.each { |k, v| on(k, &v) }
+		end
+
+		attr_reader :parent, :id
+
+		def dispose; detach end
+	end
+end

data/lib/fzeet/Dialog.rb

@@ -0,0 +1 @@
+require_relative 'DialogFileDialog'

data/lib/fzeet/DialogCommon.rb

@@ -0,0 +1,5 @@
+require_relative 'WindowDialog'
+
+module Fzeet
+
+end

data/lib/fzeet/DialogFileDialog.rb

@@ -0,0 +1,116 @@
+require_relative 'DialogCommon'
+
+module Fzeet
+	class FileDialog
+		def initialize(opts = {})
+			_opts = {
+				filter: nil,
+				customFilter: nil,
+				filterIndex: 0,
+				fileTitle: nil,
+				initialDir: nil,
+				title: nil,
+				flags: 0,
+				fileExtension: nil,
+				defExt: nil,
+				custData: 0,
+				hook: nil,
+				templateName: nil,
+				xflags: 0
+			}
+			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
+			_opts.merge!(opts)
+
+			@ofn = Windows::OPENFILENAME.new
+
+			@ofn[:lStructSize] = @ofn.size
+			@ofn[:hInstance] = Windows.GetModuleHandle(nil)
+		end
+
+		attr_reader :ofn
+
+		def path; @path && @path.dup end
+	end
+
+	class OpenFileDialog < FileDialog
+		def initialize(opts = {})
+			super
+		end
+
+		def show(window = Application.window)
+			ofn[:hwndOwner] = window.handle
+			ofn[:nMaxFile] = 4096
+			ofn[:lpstrFile] = path = FFI::MemoryPointer.new(:char, ofn[:nMaxFile])
+
+			@path = nil
+
+			DialogResult.new((Windows.GetOpenFileName(ofn) == 0) ? Windows::IDCANCEL : Windows::IDOK).tap { |result|
+				@path = ofn[:lpstrFile].read_string if result.ok?
+			}
+		ensure
+			path.free
+		end
+	end
+
+	class SaveFileDialog < FileDialog
+		def initialize(opts = {})
+			super
+		end
+
+		def show(window = Application.window)
+			ofn[:hwndOwner] = window.handle
+			ofn[:nMaxFile] = 4096
+			ofn[:lpstrFile] = path = FFI::MemoryPointer.new(:char, ofn[:nMaxFile])
+
+			@path = nil
+
+			DialogResult.new((Windows.GetSaveFileName(ofn) == 0) ? Windows::IDCANCEL : Windows::IDOK).tap { |result|
+				@path = ofn[:lpstrFile].read_string if result.ok?
+			}
+		ensure
+			path.free
+		end
+	end
+
+	class FolderDialog
+		def initialize(opts = {})
+			_opts = {
+				root: nil,
+				displayName: nil,
+				title: nil,
+				flags: 0,
+				hook: nil,
+				param: 0,
+				image: 0
+			}
+			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
+			_opts.merge!(opts)
+
+			@bi = Windows::BROWSEINFO.new
+
+			@bi[:ulFlags] = Fzeet.flags([:returnonlyfsdirs, :usenewui], :bif_)
+		end
+
+		attr_reader :bi
+
+		def path; @path && @path.dup end
+
+		def show(window = Application.window)
+			bi[:hwndOwner] = window.handle
+
+			@path = nil
+
+			DialogResult.new(((pidl = Windows.SHBrowseForFolder(bi)).null?) ? Windows::IDCANCEL : Windows::IDOK).tap { |result|
+				next unless result.ok?
+
+				FFI::MemoryPointer.new(:char, 4096) { |p|
+					Windows.SHGetPathFromIDList(pidl, p)
+
+					@path = p.read_string
+				}
+			}
+		ensure
+			Windows.CoTaskMemFree(pidl)
+		end
+	end
+end

data/lib/fzeet/UIRibbon.rb

@@ -0,0 +1,99 @@
+require_relative 'WindowCommon'
+
+module Fzeet
+	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
+		end
+
+		def [](id) Command.new(self, id) end
+
+		def initialize(window, name = Application.name, resname = 'APPLICATION_RIBBON')
+			@executesAllVerbs = {}
+
+			@window = window
+
+			@uich = Windows::UICommandHandler.new
+
+			@uich.instance_variable_set(:@ribbon, self)
+
+			class << @uich
+				attr_reader :ribbon
+
+				def Execute(*args) @ribbon.execute(*args) end
+			end
+
+			@uia = Windows::UIApplication.new
+
+			@uia.instance_variable_set(:@uich, @uich)
+
+			class << @uia
+				attr_reader :uich
+
+				def OnCreateUICommand(*args) @uich.QueryInterface(@uich.class::IID, args[-1]); Windows::S_OK end
+			end
+
+			@uif = Windows::UIFramework.new
+
+			@uif.Initialize(@window.handle, @uia)
+			@uif.LoadUI(@hdll = Windows.LoadRibbonDll(name), "#{resname}\0".encode('utf-16le'))
+
+			@window.on(:destroy) {
+				@uich.Release
+				@uia.Release
+				@uif.Destroy; @uif.Release
+			}
+		end
+
+		attr_reader :window, :uich, :uia, :uif
+
+		def execute(commandId, verb, key, value, props)
+			args = {
+				commandId: commandId,
+				ribbon: self,
+				sender: Command.new(self, commandId)
+			}
+
+			result = Windows::E_NOTIMPL
+
+			begin
+				if @executesAllVerbs.include?(commandId)
+					@executesAllVerbs[commandId].each { |handler|
+						(handler.arity == 0) ? handler.call : handler.call(args)
+					}
+
+					result = Windows::S_OK
+				end
+			rescue
+				Fzeet.message %Q{#{$!}\n\n#{$!.backtrace.join("\n")}}, icon: :error
+			end
+
+			result
+		end
+
+		def on(*args, &block)
+			case args.size
+			when 1
+				case args[0]
+				when Integer; (@executesAllVerbs[args[0]] ||= []) << block
+				else raise ArgumentError
+				end
+			else raise ArgumentError
+			end
+
+			self
+		end
+	end
+end

data/lib/fzeet/Window.rb

@@ -1,336 +1,2 @@
-require_relative 'WindowMethods'
-
-module Fzeet
-	class BasicWindow < Handle
-		include WindowMethods
-
-		Prefix = {
-			xstyle: [:ws_ex_],
-			style: [:ws_, :ds_],
-			message: [:wm_],
-			notification: []
-		}
-
-		WindowProc = FFI::Function.new(:long, [:pointer, :uint, :uint, :long], convention: :stdcall) { |hwnd, uMsg, wParam, lParam|
-			begin
-				if uMsg == Windows::WM_NCCREATE
-					@@instances[hwnd.to_i] = ObjectSpace._id2ref(
-						Windows::CREATESTRUCT.new(FFI::Pointer.new(lParam))[:lpCreateParams].to_i
-					)
-
-					@@instances[hwnd.to_i].instance_variable_set(:@handle, hwnd)
-				end
-
-				result = @@instances[hwnd.to_i].windowProc(hwnd, uMsg, wParam, lParam) if @@instances[hwnd.to_i]
-			rescue
-				answer = Fzeet.message %Q{#{$!}\n\n#{$!.backtrace.join("\n")}}, buttons: [:abort, :retry, :ignore], icon: :error
-
-				Application.quit if answer.abort?
-			ensure
-				if uMsg == Windows::WM_NCDESTROY
-					@@instances[hwnd.to_i].dialog = false
-
-					@@instances.delete(hwnd.to_i)
-				end
-			end
-
-			result || Windows.DefWindowProc(hwnd, uMsg, wParam, lParam)
-		}
-
-		DialogProc = FFI::Function.new(:int, [:pointer, :uint, :uint, :long], convention: :stdcall) { |hwnd, uMsg, wParam, lParam|
-			begin
-				if uMsg == Windows::WM_INITDIALOG
-					@@instances[hwnd.to_i] = ObjectSpace._id2ref(lParam)
-
-					@@instances[hwnd.to_i].instance_variable_set(:@handle, hwnd)
-				end
-
-				result = @@instances[hwnd.to_i].windowProc(hwnd, uMsg, wParam, lParam) if @@instances[hwnd.to_i]
-			rescue
-				answer = Fzeet.message %Q{#{$!}\n\n#{$!.backtrace.join("\n")}}, buttons: [:abort, :retry, :ignore], icon: :error
-
-				Application.quit if answer.abort?
-			ensure
-				if uMsg == Windows::WM_NCDESTROY
-					@@instances[hwnd.to_i].dialog = false
-
-					@@instances.delete(hwnd.to_i)
-				end
-			end
-
-			(result.nil?) ? 0 : 1
-		}
-
-		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))
-			}
-		end
-
-		def self.crackMessage(hwnd, uMsg, wParam, lParam)
-			window = @@instances[hwnd.to_i]
-
-			args = {
-				hwnd: hwnd,
-				uMsg: uMsg,
-				wParam: wParam,
-				lParam: lParam,
-				result: (window.kind_of?(Dialog)) ? 1 : 0,
-				window: window,
-				sender: window
-			}
-
-			case uMsg
-			when Windows::WM_CREATE
-				args[:cs] = Windows::CREATESTRUCT.new(FFI::Pointer.new(lParam))
-			when Windows::WM_NCCREATE
-				args[:result] = 1
-				args[:cs] = Windows::CREATESTRUCT.new(FFI::Pointer.new(lParam))
-			when Windows::WM_COMMAND
-				args[:command], args[:notification], args[:hctl] = Windows.LOWORD(wParam), Windows.HIWORD(wParam), FFI::Pointer.new(lParam)
-				args[:sender] = @@instances[args[:hctl].to_i] unless args[:hctl].null?
-			when Windows::WM_NOTIFY
-				args[:nmh] = Windows::NMHDR.new(FFI::Pointer.new(lParam))
-				args[:command], args[:notification], args[:hctl] = args[:nmh][:idFrom], args[:nmh][:code], args[:nmh][:hwndFrom]
-				(args[:sender] = @@instances[args[:hctl].to_i]).class.crackNotification(args)
-			when \
-				Windows::WM_MOUSEMOVE,
-				Windows::WM_LBUTTONDOWN, Windows::WM_LBUTTONUP, Windows::WM_LBUTTONDBLCLK,
-				Windows::WM_RBUTTONDOWN, Windows::WM_RBUTTONUP, Windows::WM_RBUTTONDBLCLK,
-				Windows::WM_MBUTTONDOWN, Windows::WM_MBUTTONUP, Windows::WM_MBUTTONDBLCLK,
-				Windows::WM_CONTEXTMENU
-
-				args[:x], args[:y] = Windows.GET_X_LPARAM(lParam), Windows.GET_Y_LPARAM(lParam)
-
-				if uMsg == Windows::WM_CONTEXTMENU && args[:x] == -1
-					Windows.DetonateLastError(0, :GetCursorPos, pt = Point.new)
-
-					args[:keyboard], args[:x], args[:y] = true, pt[:x], pt[:y]
-				end
-			end
-
-			args
-		end
-
-		def initialize(opts = {})
-			_opts = {
-				xstyle: [],
-				caption: Application.name,
-				style: [],
-				x: Windows::CW_USEDEFAULT,
-				y: Windows::CW_USEDEFAULT,
-				width: Windows::CW_USEDEFAULT,
-				height: Windows::CW_USEDEFAULT,
-				parent: nil,
-				menu: nil
-			}
-			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
-			_opts.merge!(opts)
-
-			yield self, _opts if block_given?
-
-			_opts[:xstyle] = Fzeet.flags(_opts[:xstyle], *self.class::Prefix[:xstyle])
-			_opts[:caption] = _opts[:caption].to_s
-			_opts[:style] = Fzeet.flags(_opts[:style], *self.class::Prefix[:style])
-
-			@messages ||= {}
-			@commands ||= {}
-			@notifies ||= {}
-
-			@processed = [0, 0]
-
-			@handle = Windows.CreateWindowEx(
-				_opts[:xstyle],  self.class::WindowClass.name, _opts[:caption], _opts[:style],
-				_opts[:x], _opts[:y], _opts[:width], _opts[:height],
-				_opts[:parent] && _opts[:parent].handle, nil, Windows.GetModuleHandle(nil), FFI::Pointer.new(object_id)
-			)
-
-			if @handle.null?
-				raise "CreateWindowEx failed (last error #{Windows.GetLastError()})." unless [
-					[Windows::WM_NCCREATE, 0], [Windows::WM_CREATE, -1],
-					[Windows::WM_DESTROY, 0], [Windows::WM_NCDESTROY, 0]
-				].include?(@processed)
-			else
-				@parent = _opts[:parent]
-				self.menu = _opts[:menu] if _opts[:menu]
-
-				on(:destroy) {
-					menu.rdetach if self.menu
-
-					eachChild(&:dispose)
-				}
-			end
-		end
-
-		attr_reader :parent
-
-		def dispose; Windows.DestroyWindow(@handle) end
-
-		def windowProc(hwnd, uMsg, wParam, lParam)
-			args, result = nil, nil
-
-			if (handlers = @messages[uMsg])
-				args ||= self.class.crackMessage(hwnd, uMsg, wParam, lParam)
-
-				handlers.each { |handler|
-					(handler.arity == 0) ? handler.call : handler.call(args)
-
-					result = args[:result]; @processed[0], @processed[1] = uMsg, result
-				}
-			end
-
-			if uMsg == Windows::WM_COMMAND && (handlers = @commands[Windows.LOWORD(wParam)])
-				args ||= self.class.crackMessage(hwnd, uMsg, wParam, lParam)
-
-				handlers[:all].each { |handler|
-					(handler.arity == 0) ? handler.call : handler.call(args)
-
-					result = args[:result]; @processed[0], @processed[1] = uMsg, result
-				} if handlers[:all]
-
-				handlers[Windows.HIWORD(wParam)].each { |handler|
-					(handler.arity == 0) ? handler.call : handler.call(args)
-
-					result = args[:result]; @processed[0], @processed[1] = uMsg, result
-				} if handlers[Windows.HIWORD(wParam)]
-			end
-
-			if uMsg == Windows::WM_NOTIFY && (handlers = @notifies[(nmh = Windows::NMHDR.new(FFI::Pointer.new(lParam)))[:idFrom]])
-				args ||= self.class.crackMessage(hwnd, uMsg, wParam, lParam)
-
-				handlers[:all].each { |handler|
-					(handler.arity == 0) ? handler.call : handler.call(args)
-
-					result = args[:result]; @processed[0], @processed[1] = uMsg, result
-				} if handlers[:all]
-
-				handlers[nmh[:code]].each { |handler|
-					(handler.arity == 0) ? handler.call : handler.call(args)
-
-					result = args[:result]; @processed[0], @processed[1] = uMsg, result
-				} if handlers[nmh[:code]]
-			end
-
-			result
-		end
-
-		def onMessage(msg, &block)
-			((@messages ||= {})[Fzeet.constant(msg, :wm_)] ||= []) << block
-
-			self
-		end
-
-		def onCommand(cmd, notification = :all, &block)
-			notification = Fzeet.constant(notification, *self[cmd].class::Prefix[:notification]) unless
-				notification.kind_of?(Integer) || notification == :all
-
-			(((@commands ||= {})[Command[cmd]] ||= {})[notification] ||= []) << block
-
-			self
-		end
-
-		def onNotify(cmd, notification = :all, &block)
-			notification = Fzeet.constant(notification, *self[cmd].class::Prefix[:notification]) unless
-				notification.kind_of?(Integer) || notification == :all
-
-			(((@notifies ||= {})[Command[cmd]] ||= {})[notification] ||= []) << block
-
-			self
-		end
-
-		def on(*args, &block)
-			case args.length
-			when 1; onMessage(*args, &block)
-			when 2, 3
-				case Fzeet.constant(args.shift, :wm_)
-				when Windows::WM_COMMAND; onCommand(*args, &block)
-				when Windows::WM_NOTIFY; onNotify(*args, &block)
-				else raise ArgumentError
-				end
-			else raise ArgumentError
-			end
-		end
-	end
-
-	Window = BasicWindow['Fzeet.Window']
-
-	class Window
-		def initialize(opts = {})
-			(opts[:style] ||= []) << :overlappedwindow << :clipchildren
-
-			super
-		end
-	end
-
-	Dialog = BasicWindow['Fzeet.Dialog',
-		wndProc: BasicWindow::DialogProc
-	]
-
-	class Dialog
-		def initialize(parent, opts = {}, &block)
-			@parent = parent
-
-			_opts = {
-				xstyle: [:noparentnotify],
-				caption: Application.name,
-				style: [:sysmenu, :visible],
-				x: 0,
-				y: 0,
-				width: 200,
-				height: 150,
-				modal: false
-			}
-			badopts = opts.keys - _opts.keys; raise "Bad option(s): #{badopts.join(', ')}." unless badopts.empty?
-			_opts.merge!(opts)
-
-			_opts[:xstyle] = Fzeet.flags(_opts[:xstyle], *self.class::Prefix[:xstyle])
-			_opts[:caption] = _opts[:caption].to_s
-			_opts[:style] = Fzeet.flags(_opts[:style], *self.class::Prefix[:style])
-
-			@messages ||= {}
-			@commands ||= {}
-			@notifies ||= {}
-
-			@processed = [0, 0]
-
-			dt = Windows::DLGTEMPLATE.new
-
-			dt[:style] = _opts[:style]
-			dt[:dwExtendedStyle] = _opts[:xstyle]
-			dt[:x] = _opts[:x]
-			dt[:y] = _opts[:y]
-			dt[:cx] = _opts[:width]
-			dt[:cy] = _opts[:height]
-
-			on(:initdialog) { self.text = _opts[:caption] }
-
-			on(:initdialog, &block) if block
-
-			if _opts[:modal]
-				@result = Windows.DetonateLastError([-1, 0], :DialogBoxIndirectParam,
-					Windows.GetModuleHandle(nil),
-					dt,
-					@parent && @parent.handle,
-					BasicWindow::DialogProc,
-					object_id
-				)
-			else
-				@handle = Windows.DetonateLastError(FFI::Pointer::NULL, :CreateDialogIndirectParam,
-					Windows.GetModuleHandle(nil),
-					dt,
-					@parent && @parent.handle,
-					BasicWindow::DialogProc,
-					object_id
-				)
-
-				self.dialog = true
-			end
-		end
-
-		def end(result) Windows.DetonateLastError(0, :EndDialog, @handle, Command[result]); self end
-
-		def result; DialogResult.new(@result) end
-	end
-end
+require_relative 'WindowWindow'
+require_relative 'WindowDialog'