exerb 6.0.1

data/example/vr/contrib/vrwincomponent.rb

@@ -0,0 +1,54 @@
+###############################
+#
+# contrib/vrwincomponent.rb
+#
+# These modules/classes are contributed by Yuya-san.
+# Modified by nyasu <nyasu@osk.3web.ne.jp>
+# Distributed at http://vruby.sourceforge.net/index.html
+#
+###############################
+
+#====================================================================#
+# VRWinComponent Class
+class VRWinComponent
+
+  #==================================================================#
+  # Instance Methods
+
+  def maximizebox
+    return self.winstyle.getter(WStyle::WS_MAXIMIZEBOX)
+  end
+
+  def maximizebox=(bool)
+    self.winstyle.setter(WStyle::WS_MAXIMIZEBOX, bool)
+  end
+
+  def minimizebox
+    return self.winstyle.getter(WStyle::WS_MINIMIZEBOX)
+  end
+
+  def minimizebox=(bool)
+    self.winstyle.setter(WStyle::WS_MINIMIZEBOX, bool)
+  end
+
+  def sizebox
+    return self.winstyle.getter(WStyle::WS_SIZEBOX)
+  end
+
+  def sizebox=(bool)
+    self.winstyle.setter(WStyle::WS_SIZEBOX, bool)
+  end
+
+  def tabstop
+    return self.winstyle.getter(WStyle::WS_TABSTOP)
+  end
+
+  def tabstop=(bool)
+    self.winstyle.setter(WStyle::WS_TABSTOP, bool)
+  end
+
+end
+
+#====================================================================#
+# End of source.
+#====================================================================#

data/example/vr/dragdropformat.rb

@@ -0,0 +1,209 @@
+###################################
+#
+# dragdropformat.rb
+# Programmed by nyasu <nyasu@osk.3web.ne.jp>
+# Copyright 2002-2005  Nishikawa,Yasuhiro
+#
+# More information at http://vruby.sourceforge.net/index.html
+#
+###################################
+
+VR_DIR="vr/" unless defined?(::VR_DIR)
+require VR_DIR+'sysmod'
+require 'Win32API'
+
+module ClipboardFormat
+  RegisterClipboardFormat = 
+      Win32API.new("user32","RegisterClipboardFormat","P","I")
+
+  CF_URL = RegisterClipboardFormat.call("UniformResourceLocator")
+
+end
+
+class DragDropObject
+=begin
+== DragDropObject
+A capsule for OLE Drag and Drop
+This is just a base class. Don't use this directly.
+
+=== Methods
+--- handle
+    Returns a global heap handle containing the file pathes.
+--- free_handle
+    Tries to free the handle.
+    Please check you really need to free it, because sometimes your OS will 
+    free it automatically at the appropriate timing.
+=end
+
+  def initialize
+    @__binarydata=""
+  end
+  def handle
+    @handle=GMEM::AllocStr(0x2000,@__binarydata)
+  end
+  def free_handle
+    GMEM::Free(@handle)
+    @handle=0
+  end
+
+  def objectformat
+    self.class::FormatId
+  end
+
+end
+
+class DragDropText < DragDropObject
+=begin
+== DragDropText
+   This class deals the structure for drag-and-drop files.
+
+=== Class Methods
+--- set(files)
+    Creates object and sets the file pathes in ((|files|)) to the object.
+--- get(handle)
+    Create object and sets the file pathes containing in ((|handle|)).
+    The ((|handle|)) is a global heap handle.
+=== Methods
+--- text
+    Returns the text.
+=end
+
+  FormatName="CF_TEXT"
+  FormatId=ClipboardFormat::CF_TEXT
+
+  def initialize(text,handle=0)
+    @__binarydata = @__texts = text.to_str.dup
+    @handle=handle
+  end
+
+  def self.set(texts)
+    self.new(texts)
+  end
+
+  def self.get(handle)
+    self.new(GMEM::Get(handle),handle)
+  end
+
+  def text
+    @__texts.dup
+  end
+end
+
+class DragDropFiles < DragDropObject
+=begin
+== DragDropFiles
+   This class deals the structure for drag-and-drop files.
+
+=== Class Methods
+--- set(files)
+    Creates object and sets the file pathes in ((|files|)) to the object.
+--- get(handle)
+    Create object and sets the file pathes containing in ((|handle|)).
+    The ((|handle|)) is a global heap handle.
+=== Methods
+--- files
+    Returns the file pathes.
+=end
+
+  FormatName = "CF_HDROP"
+  FormatId = ClipboardFormat::CF_HDROP
+
+  DragQueryFile   = Win32API.new("shell32","DragQueryFile", ["I","I","P","I"],"I")
+
+  def initialize(files,handle=0)
+    @__files = files.dup
+    @handle=handle
+    @__binarydata="\0"*0x14+@__files.join("\0")+"\0"
+    @__binarydata[0]=0x14
+  end
+
+  def self.set(files)
+    self.new(files)
+  end
+
+  def self.get(handle)
+    __fnbuffer = "                "*16 #256bytes
+    n=DragQueryFile.call(handle,-1,__fnbuffer,__fnbuffer.size)
+    r=[]
+    0.upto(n-1) do |i|
+      s=DragQueryFile.call(handle,i,__fnbuffer,__fnbuffer.size)
+      r.push __fnbuffer[0,s]
+    end
+    self.new(r,handle)
+  end
+
+  def files
+    @__files.dup
+  end
+end
+
+
+module DragDropRubyObjectFactory
+=begin
+== DragDropRubyObjectFactory
+This class' feature is to register new clipboard format into your system for 
+drag&drop ruby object.
+
+=== Class Methods
+--- declare_dndclass(classname,registername)
+    Registers new format and create new wrapper class for ruby.
+    The format is registered as ((|registername|)) and
+    the wrapper class is declared as DragDropRubyObjectFactory::((|classname|)).
+    This methods returns the wrapper class.
+=end
+
+
+  class DragDropRubyObject < DragDropObject
+=begin
+== DragDropRubyObjectFactory::DragDropRubyObject
+This is a base class of wrapper classes created by 
+DragDropRubyObjectFactory.declare_dndclass()
+
+=== Class Methods
+--- new(binstr,handle=0)
+    No need to use this. (maybe)
+--- set(obj)
+    Returns new wrapper object of ((|obj|)) for drag&drop.
+--- get(handle)
+    Returns wrapper object using global heap of ((|handle|)).
+=== Method
+--- object
+    returns the wrapped object.
+=end
+
+    include ClipboardFormat
+    FormatName = "DumpedRubyObjectForDnD"
+    FormatId = RegisterClipboardFormat.call(FormatName)
+
+    def initialize(bin,handle=0)
+      @objectformat = ClipboardFormat::CF_TEXT # only for base class
+      @__binarydata = bin
+      @handle=handle
+    end
+
+    def self.set(obj)
+      self.new(Marshal.dump(obj))
+    end
+
+    def self.get(handle)
+      bin =  GMEM::Get(handle)
+      self.new(bin,handle)
+    end
+
+    def object
+      Marshal.load(@__binarydata)
+    end
+  end
+
+  def self.declare_dndclass(classname,registername)
+    str = <<"EEOOFF"
+        class #{classname} < DragDropRubyObject
+          FormatName = '#{registername}'
+          FormatId = RegisterClipboardFormat.call(FormatName)
+        end
+EEOOFF
+    eval(str)
+    eval("#{classname} ")
+  end
+
+end

data/example/vr/rscutil.rb

@@ -0,0 +1,168 @@
+###################################
+#
+# rscutil.rb
+# Programmed by nyasu <nyasu@osk.3web.ne.jp>
+# Copyright 2000-2005  Nishikawa,Yasuhiro
+#
+# More information at http://vruby.sourceforge.net/index.html
+#
+#
+###################################
+
+require 'swin'
+
+
+=begin
+= rscutil.rb
+Utilities for resources
+
+== Base64dumper
+The module to use binary data with base64
+=== Class Method
+--- loadString(str)
+    Load a object from base64 encoded string.
+=== Method
+--- dumpString
+    Dumps an object into base64 encoded string.
+=end
+
+module Base64dumper
+  def self.loadString(str)
+    Marshal.load(str.unpack("m")[0])
+  end
+  
+  def dumpString
+    [Marshal.dump(self)].pack("m")
+  end
+end
+
+
+
+module SWin
+  class Bitmap
+    include Base64dumper
+    def self.loadString(str) Base64dumper.loadString(str) end
+  end
+end
+
+#####
+
+module SWin
+  class Font
+    STRIKEOUT=4
+    UNDERLINE=2
+    ITALIC=1
+  end
+end
+
+## ####--------------------
+
+# FontStruct for handling fonts and text attributes.
+
+=begin
+== FontStruct
+Subclass of Struct for representing text attributes.
+
+=== Attributes
+--- fontface
+--- height
+--- style
+--- weight
+--- width
+--- escapement
+--- orientation
+--- pitch_family
+--- charset
+--- point
+--- color
+
+=== Class Method
+--- new2(args)
+    Use new2 instead of new.
+
+=== Methods
+--- params
+    Returns parameters that can be used for parameter of 
+    SWin::LWFactory.newfont()
+--- spec
+    Returns text attributes for parameter of SWin::CommonDialog.chooseFont
+--- bold?
+    Returns whether the attributes means bold style
+--- bold=(flag)
+    Sets or resets bold style.
+--- italic?
+    Returns whether the attributes means italic style
+--- italic=(flag)
+    Sets or resets italic style.
+--- underlined?
+    Returns whether the attributes means underline style
+--- underlined=(flag)
+    Sets or resets underline style.
+--- striked?
+    Returns whether the attributes means strike-out style
+--- striked=(flag)
+    Sets or resets strike-out style.
+=end
+
+FontStruct = Struct.new("FontStruct",
+           :fontface,:height,:style,:weight,:width,:escapement,
+           :orientation,:pitch_family,:charset,
+           :point,:color)
+
+class FontStruct
+  private_class_method :new
+
+  def self.new2(*args)
+    new(*args.flatten)
+  end
+
+  def params
+    to_a[0,9]
+  end
+
+  def spec
+    a=self.to_a
+    [ a[0,9],a[9],a[10] ]
+  end
+
+  def bold=(flag)
+    self.weight = if flag then 600 else 300 end
+  end
+  def bold?
+    (@weight>400)
+  end
+  
+  def italic=(flag)
+    if flag then
+      self.style |= 1  # 1=SWINFONT_ITALIC
+    else
+      self.style &= 0xfffffffe
+    end
+  end
+  def italic?
+    (self.style&1)>0
+  end
+
+  def underlined=(flag)
+    if flag then
+      self.style |= 2  # 2=SWINFONT_ULINE
+    else
+      self.style &= 0xfffffffd
+    end
+  end
+  def underlined?
+    (self.style&2)>0
+  end
+
+  def striked=(flag)
+    if flag then
+      self.style |= 4  # 4=SWINFONT_STRIKE
+    else
+      self.style &= 0xfffffffb
+    end
+  end
+  def striked?
+    (self.style&4)>0
+  end
+end
+

data/example/vr/sysmod.rb

@@ -0,0 +1,249 @@
+###################################
+#
+# sysmod.rb
+# Programmed by nyasu <nyasu@osk.3web.ne.jp>
+# Copyright 1999-2005  Nishikawa,Yasuhiro
+#
+# More information at http://vruby.sourceforge.net/index.html
+#
+###################################
+
+require 'Win32API'
+
+=begin
+= sysmod.rb
+Win32 Utilities
+=end
+
+module MEMCOPY  #Thanks, ruby-chan :)
+=begin
+== MEMCOPY
+This is for copying string and memory each other.
+
+=== Class Methods
+--- MEMCOPY::Str2Mem(dst,src,len)
+    Copies src (String) into memory at address dst (Integer).
+--- MEMCOPY::Mem2Str(dst,src,len)
+    Copies contents from address dst (Integer) into src (String).
+=end
+  begin
+    ## Windows2000
+    Pmemcpy1 = Win32API.new("NTDLL", "memcpy", ['P', 'L', 'I'], 'L')
+    Pmemcpy2 = Win32API.new("NTDLL", "memcpy", ['L', 'P', 'I'], 'L')
+  rescue
+    ## Windows95/98
+    Pmemcpy1 = Win32API.new("CRTDLL", "memcpy", ['P', 'L', 'I'], 'L')
+    Pmemcpy2 = Win32API.new("CRTDLL", "memcpy", ['L', 'P', 'I'], 'L')
+  end
+
+  def MEMCOPY::Str2Mem(dst,src,len)
+    Pmemcpy2.call(dst,src,len)
+  end
+  def MEMCOPY::Mem2Str(dst,src,len=dst.length)
+    Pmemcpy1.call(dst,src,len)
+  end
+end
+
+module GAtom
+=begin
+== GAtom
+This is for utilizing Global Atoms.
+
+--- GAtom::Add(text)
+    Create a new global atom whose name is ((|text|)).
+--- GAtom::Delete(atm)
+    Delete ((|atm|)) of global atom.
+--- GAtom::GetName(atm)
+    Returns name of ((|atm|)) of global atom.
+=end
+
+  GlobalAddAtom = Win32API.new("kernel32","GlobalAddAtom",["P"],"I")
+  GlobalDeleteAtom=Win32API.new("kernel32","GlobalDeleteAtom",["I"],"I")
+  GlobalGetAtomName=Win32API.new("kernel32","GlobalGetAtomName",["I","P","I"],"I")
+
+  def GAtom::Add(text) (0xffff & GlobalAddAtom.call(text.to_s)) end
+  def GAtom::Delete(atm) GlobalDeleteAtom.call(atm) end
+
+  def GAtom::GetName(atm)
+    buffer=" "*256
+    r = GlobalGetAtomName.call(atm,buffer,256)
+    buffer[0,r]
+  end
+end
+
+module GMEM
+=begin
+== GMEM
+This is for utilizing Global memories.
+
+=== Class Methods
+--- GMEM::AllocStr(mode,text)
+    Allocates a global memory and set its contents as ((|text|)).
+--- GMEM::Set(gmem,text,len)
+    Sets the contents of global memory gmem as ((|text|)).
+--- GMEM::Get(gmem)
+    Gets the contents of gmem.
+
+--- GMEM::Alloc(size)
+    Allocates a global memory.
+--- GMEM::Lock(gmem)
+    Locks gmem to access it.
+--- GMEM::Unlock(gmem)
+    Unlocks gmem.
+--- GMEM::Free(gmem)
+    Frees gmem.
+--- GMEM::Size(gmem)
+    Returns the size of gmem.
+=end
+
+  #GlobalAlloc(method,size)
+  GlobalAlloc = Win32API.new("kernel32","GlobalAlloc",["I","I"],"I")
+
+  GlobalLock = Win32API.new("kernel32","GlobalLock",["I"],"I")
+  GlobalUnlock = Win32API.new("kernel32","GlobalUnlock",["I"],"")
+  GlobalFree = Win32API.new("kernel32","GlobalFree",["I"],"I")
+  GlobalSize = Win32API.new("kernel32","GlobalSize",["I"],"I")
+  GlobalFlags= Win32API.new("kernel32","GlobalFlags",["I"],"I")
+
+  def GMEM::Alloc(*arg)  GlobalAlloc.call(*arg) end
+  def GMEM::Lock(*arg)   GlobalLock.call(*arg) end
+  def GMEM::Unlock(*arg) GlobalUnlock.call(*arg) end
+  def GMEM::Free(*arg)   GlobalFree.call(*arg) end
+  def GMEM::Size(*arg)   GlobalSize.call(*arg) end
+
+  def GMEM::AllocStr(mode,text)
+    mem = GlobalAlloc.call(mode,text.length+1)
+    Set(mem,text,text.size+1)
+    mem
+  end
+
+  def GMEM::Set(hglb,text,siz=nil)
+    len= if siz then siz.to_i else [size,Size(hglb)].min end
+    lp = GlobalLock.call(hglb)
+    MEMCOPY::Str2Mem(lp,text.to_s,len)
+    GlobalUnlock.call(hglb)
+  end
+  def GMEM::Get(hglb)
+    lp = GlobalLock.call(hglb)
+    len = GlobalSize.call(hglb)
+#p format "%x %d, %x",hglb, lp, GlobalFlags.call(hglb)
+    raise "Memory not accessible" if len==0
+    str = " " * (len+1)
+    MEMCOPY::Mem2Str(str,lp,len)
+    GlobalUnlock.call(hglb)
+    str
+  end
+end
+
+module SMSG
+=begin
+== SMSG
+This is for Windows Messaging.
+
+=== Class Methods
+--- sendMessage(hwnd,uMsg,wParam,lParam)
+    Calls SendMessage(). see Windows SDK document.
+    ((|lParam|)) can be both type of Integer and String
+--- postMessage(hwnd,uMsg,wParam,lParam)
+    Calls PostMessage(). see Windows SDK document.
+    ((|lParam|)) can be both type of Integer and String
+=end
+
+  SendMessage = Win32API.new("user32","SendMessage",["I","I","I","I"],"I")
+  PostMessage = Win32API.new("user32","PostMessage",["I","I","I","I"],"I")
+  SendMessage2 = Win32API.new("user32","SendMessage",["I","I","I","P"],"I")
+  PostMessage2 = Win32API.new("user32","PostMessage",["I","I","I","P"],"I")
+
+  def SMSG.sendMessage(*arg)
+    if arg[3].is_a?(Integer) then
+      SendMessage.call(*arg)
+    else
+      SendMessage2.call(*arg)
+    end
+  end
+
+  def SMSG.postMessage(*arg)
+    if arg[3].is_a?(Integer) then
+      PostMessage.call(*arg)
+    else
+      PostMessage2.call(*arg)
+    end
+  end
+end
+
+module Cursor
+=begin
+== Cursor
+This is for System cursor handling.
+
+=== Class Methods
+--- get_screenposition
+    Returns x,y in the screen coordinate.
+--- set_screenposition(x,y)
+    Sets cursor position into (x,y) in the screen coordinate.
+=end
+
+  GetCursorPos = Win32API.new("user32","GetCursorPos","P","I")
+  SetCursorPos = Win32API.new("user32","SetCursorPos","II","I")
+  POINTSTRUCT="II"
+
+  def self.get_screenposition
+    r=[0,0].pack(POINTSTRUCT)
+    GetCursorPos.call(r)
+    r.unpack(POINTSTRUCT)
+  end
+  
+  def self.set_screenposition(x,y)
+    SetCursorPos.call(x.to_i,y.to_i)
+  end
+end
+
+module LastError
+=begin
+== LastError
+This is for handling LastError.
+
+=== Class Methods
+--- set(ecode)
+    Sets lasterror code as ((|ecode|)).
+--- code
+--- get
+    Gets last error code.
+--- code2msg(ecode,msgarg=0)
+    Get the error message of ((|ecode|)). 
+    ((|msgarg|)) is optional argument for message formatting.
+--- message(arg=0)
+    Returns last error message.
+=end
+
+  GetLastError = Win32API.new('kernel32','GetLastError','V','L')
+  SetLastError = Win32API.new('kernel32','SetLastError','L','V')
+  FormatMessage = Win32API.new('kernel32','FormatMessageA','LPLLPLP','L')
+  FORMAT_MESSAGE_FROM_SYSTEM = 4096
+
+  def self.set(ecode)
+    SetLastError.call(ecode)
+  end
+
+  def self.code
+    GetLastError.call()
+  end
+  def self.get() self.code end
+
+  def self.code2msg(scode,msg=0)
+    buffer = " "*(2048)
+    len = FormatMessage.call FORMAT_MESSAGE_FROM_SYSTEM,0,scode,0,
+                             buffer,buffer.size,msg
+    buffer[0,len]
+  end
+
+  def self.message(msg=0)
+    self.code2msg(self.code,msg)
+  end
+end
+
+module ClipboardFormat
+  CF_TEXT    =  1 
+  CF_OEMTEXT =  7
+  CF_HDROP   = 15
+end