vruby 2004.08.07

data/lib/vr/handlers.rd

@@ -0,0 +1,5 @@
+=begin
+The names of event handlers includes '????', which is its user-defined name
+declared at argument for addControl method (VRParent.)
+=end
+

data/lib/vr/rscutil.rb

@@ -0,0 +1,170 @@
+###################################
+#
+# rscutil.rb
+# Programmed by  nyasu <nyasu@osk.3web.ne.jp>
+# Copyright 2000-2001 Nishikawa,Yasuhiro
+#
+# More information at http://www.osk.3web.ne.jp/~nyasu/software/vrproject.html
+# (in Japanese)
+#
+#
+#
+###################################
+
+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/lib/vr/sysmod.rb

@@ -0,0 +1,250 @@
+###################################
+#
+# sysmod.rb
+# Programmed by  nyasu <nyasu@osk.3web.ne.jp>
+# Copyright 1999-2001 Nishikawa,Yasuhiro
+#
+# More information at http://www.threeweb.ad.jp/~nyasu/software/vrproject.html
+# (in Japanese)
+#
+###################################
+
+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

data/lib/vr/vractivex.rb

@@ -0,0 +1,56 @@
+###################################
+#
+# vractivex.rb
+# Programmed by  nyasu <nyasu@osk.3web.ne.jp>
+# Copyright 2003 Nishikawa,Yasuhiro
+#
+# More information at http://www.threeweb.ad.jp/~nyasu/software/vrproject.html
+# (in Japanese)
+#
+###################################
+
+require 'vr/vruby'
+require 'Win32API'
+require 'win32ole'
+
+class VRActiveXControl < VRControl
+  Win32API.new("atl.dll","AtlAxWinInit","","I").call
+
+  WINCLASSINFO=["AtlAxWin",0]
+  ACTIVEXCINFO=["",""] # PROGID,EVENTSINK
+
+  alias :progId :caption
+  alias :progId= :caption=
+  def caption() "" end
+  def caption=(arg) arg end
+
+  def initialize
+    self.progId = self.class::ACTIVEXCINFO[0]
+    class <<self
+      undef_method :progId=
+    end
+  end
+
+  def vrinit
+    super
+	@_vr_win32ole = self.get_oleinterface
+    if self.class::ACTIVEXCINFO[1] then
+      @_vr_win32ole_event = 
+        WIN32OLE_EVENT.new(@_vr_win32ole,self.class::ACTIVEXCINFO[1])
+    end
+  end
+
+  def ole_interface() @_vr_win32ole; end
+  def ole_events() @_vr_win32ole_event; end
+
+  def add_oleeventhandler(evname,handlername=evname.downcase)
+    ole_events.on_event(evname) do |*args|
+      @parent.controlmsg_dispatching(self,handlername,*args)
+    end
+  end
+
+  def _invoke(*args) @_vr_win32ole._invoke(*args) end
+  def _setproperty(*args) @_vr_win32ole._setproperty(*args) end
+  def _getproperty(*args) @_vr_win32ole._getproperty(*args) end
+
+end