Archive for 5月, 2012

  1. Hello, COM(Go) World!

    Posted on 5月 31st, 2012 by cx20

    COM(Go)

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は Go言語 による COM クライアントの例となっている。

    ソースコード

    package main
     
    import (
        "syscall" 
        "unsafe" 
    )
     
    const (
        CLSCTX_INPROC_SERVER   = 1
        CLSCTX_LOCAL_SERVER    = 4
     
        DISPATCH_METHOD        = 1
        DISPATCH_PROPERTYGET   = 2
        DISPATCH_PROPERTYPUT   = 4
     
        VT_EMPTY           = 0x0
        VT_NULL            = 0x1
        VT_I2              = 0x2
        VT_I4              = 0x3
        VT_R4              = 0x4
        VT_R8              = 0x5
        VT_CY              = 0x6
        VT_DATE            = 0x7
        VT_BSTR            = 0x8
        VT_DISPATCH        = 0x9
        VT_ERROR           = 0xa
        VT_BOOL            = 0xb
        VT_VARIANT         = 0xc
        VT_UNKNOWN         = 0xd
        VT_DECIMAL         = 0xe
        VT_I1              = 0x10
        VT_UI1             = 0x11
        VT_UI2             = 0x12
        VT_UI4             = 0x13
        VT_I8              = 0x14
        VT_UI8             = 0x15
        VT_INT             = 0x16
        VT_UINT            = 0x17
        VT_VOID            = 0x18
        VT_VECTOR          = 0x1000
        VT_ARRAY           = 0x2000
        VT_BYREF           = 0x4000
        VT_RESERVED        = 0x8000
    )
     
    type DISPPARAMS struct {
        rgvarg              uintptr
        rgdispidNamedArgs   uintptr
        cArgs               uint32
        cNamedArgs          uint32
    }
     
    type VARIANT struct {
        VT                  uint16
        wReserved1          uint16
        wReserved2          uint16
        wReserved3          uint16
        Val                 int64
    }
     
    type GUID struct {
        Data1               uint32
        Data2               uint16
        Data3               uint16
        Data4               [8]byte
    }
     
    type IDispatch struct {
        lpVtbl *pIDispatchVtbl
    }
     
    type pIDispatchVtbl struct {
        pQueryInterface     uintptr
        pAddRef             uintptr
        pRelease            uintptr
        pGetTypeInfoCount   uintptr
        pGetTypeInfo        uintptr
        pGetIDsOfNames      uintptr
        pInvoke             uintptr
    }
     
    var ( 
        ole32, _                  = syscall.LoadLibrary("ole32.dll")
        oleaut32, _               = syscall.LoadLibrary("oleaut32.dll")
        kernel32, _               = syscall.LoadLibrary("kernel32.dll")
     
        procCoInitialize, _       = syscall.GetProcAddress(ole32, "CoInitialize")
        procCoUninitialize, _     = syscall.GetProcAddress(ole32, "CoUninitialize")
        procCoCreateInstance, _   = syscall.GetProcAddress(ole32, "CoCreateInstance")
        procCLSIDFromProgID, _    = syscall.GetProcAddress(ole32, "CLSIDFromProgID")
     
        procVariantInit, _        = syscall.GetProcAddress(oleaut32, "VariantInit")
        procSysAllocString, _     = syscall.GetProcAddress(oleaut32, "SysAllocString")
        procSysFreeString, _      = syscall.GetProcAddress(oleaut32, "SysFreeString")
     
        procGetUserDefaultLCID, _ = syscall.GetProcAddress(kernel32, "GetUserDefaultLCID")
     
        IID_NULL                  = &GUID{ 0x00000000, 0x0000, 0x0000, [8]byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }
        IID_IDispatch             = &GUID{ 0x00020400, 0x0000, 0x0000, [8]byte{ 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } }
    )
     
    func CoInitialize(p uintptr) (hr uintptr) {
        hr, _, _ = syscall.Syscall(uintptr(procCoInitialize), 1, p, 0, 0)
        return
    }
     
    func CoUninitialize() {
        syscall.Syscall(uintptr(procCoUninitialize), 0, 0, 0, 0)
    }
     
    func CLSIDFromProgID(progId string) (clsid *GUID, hr uintptr) {
        var guid GUID
        hr, _, _ = syscall.Syscall( uintptr(procCLSIDFromProgID), 2,
            uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId))),
            uintptr(unsafe.Pointer(&guid)), 0)
        clsid = &guid
        return
    }
     
    func CreateInstance(clsid *GUID, iid *GUID) (unk *IDispatch, hr uintptr) {
        hr, _, _ = syscall.Syscall6( uintptr(procCoCreateInstance), 5,
            uintptr(unsafe.Pointer(clsid)),
            0,
            CLSCTX_INPROC_SERVER,
            uintptr(unsafe.Pointer(iid)),
            uintptr(unsafe.Pointer(&unk)),
            0)
        return
    }
     
    func (disp *IDispatch) GetIDsOfNames(names []string) (dispid []int32, hr uintptr) {
        wnames := make([]*uint16, len(names))
        for i := 0; i < len(names); i++ {
            wnames[i] = syscall.StringToUTF16Ptr(names[i])
        }
        dispid = make([]int32, len(names))
        hr, _, _ = syscall.Syscall6( disp.lpVtbl.pGetIDsOfNames, 6,
            uintptr(unsafe.Pointer(disp)),
            uintptr(unsafe.Pointer(IID_NULL)),
            uintptr(unsafe.Pointer(&wnames[0])),
            uintptr(len(names)),
            uintptr(GetUserDefaultLCID()),
            uintptr(unsafe.Pointer(&dispid[0])) )
        return
    }
     
    func (disp *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, hr uintptr) {
        var dispparams DISPPARAMS
        var vargs []VARIANT
        if len(params) > 0 {
            vargs = make([]VARIANT, len(params))
            for i, v := range params {
                n := len(params) - i - 1
                VariantInit(&vargs[n])
                switch v.(type) {
                case bool:
                    if v.(bool) {
                        vargs[n] = VARIANT{VT_BOOL, 0, 0, 0, 0xffff}
                    } else {
                        vargs[n] = VARIANT{VT_BOOL, 0, 0, 0, 0}
                    }
                case int16:
                    vargs[n] = VARIANT{VT_I2, 0, 0, 0, int64(v.(int16))}
                case float32:
                    vargs[n] = VARIANT{VT_R4, 0, 0, 0, int64(v.(float32))}
                case float64:
                    vargs[n] = VARIANT{VT_R8, 0, 0, 0, int64(v.(float64))}
                case byte:
                    vargs[n] = VARIANT{VT_I1, 0, 0, 0, int64(v.(byte))}
                case uint16:
                    vargs[n] = VARIANT{VT_UI2, 0, 0, 0, int64(v.(int16))}
                case int, int32:
                    vargs[n] = VARIANT{VT_UI4, 0, 0, 0, int64(v.(int))}
                case uint, uint32:
                    vargs[n] = VARIANT{VT_UI4, 0, 0, 0, int64(v.(uint))}
                case string:
                    vargs[n] = VARIANT{VT_BSTR, 0, 0, 0, int64(uintptr(unsafe.Pointer(SysAllocString(v.(string)))))}
                case *IDispatch:
                    vargs[n] = VARIANT{VT_DISPATCH, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*IDispatch))))}
                case *bool:
                    vargs[n] = VARIANT{VT_BOOL | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*bool))))}
                case *byte:
                    vargs[n] = VARIANT{VT_I1 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*byte))))}
                case *int16:
                    vargs[n] = VARIANT{VT_I2 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*int16))))}
                case *uint16:
                    vargs[n] = VARIANT{VT_UI2 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*uint16))))}
                case *int, *int32:
                    vargs[n] = VARIANT{VT_I4 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*int))))}
                case *uint, *uint32:
                    vargs[n] = VARIANT{VT_UI4 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*uint))))}
                case *float32:
                    vargs[n] = VARIANT{VT_R4 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*float32))))}
                case *float64:
                    vargs[n] = VARIANT{VT_R8 | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*float64))))}
                case *string:
                    vargs[n] = VARIANT{VT_BSTR | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*string))))}
                case **IDispatch:
                    vargs[n] = VARIANT{VT_DISPATCH | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(**IDispatch))))}
                case *VARIANT:
                    vargs[n] = VARIANT{VT_VARIANT | VT_BYREF, 0, 0, 0, int64(uintptr(unsafe.Pointer(v.(*VARIANT))))}
                case nil:
                    vargs[n] = VARIANT{VT_NULL, 0, 0, 0, 0}
                default:
                    panic("unknown type")
                }
            }
            dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0]))
            dispparams.cArgs = uint32(len(params))
        }
     
        result = new(VARIANT)
        VariantInit(result)
        hr, _, _ = syscall.Syscall9( disp.lpVtbl.pInvoke, 9,
            uintptr(unsafe.Pointer(disp)),
            uintptr(dispid),
            uintptr(unsafe.Pointer(IID_NULL)),
            uintptr(GetUserDefaultLCID()),
            uintptr(dispatch),
            uintptr(unsafe.Pointer(&dispparams)),
            uintptr(unsafe.Pointer(result)),
            0,
            0)
        for _, varg := range vargs {
            if varg.VT == VT_BSTR && varg.Val != 0 {
                SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val)))))
            }
        }
        return
    }
     
    func GetUserDefaultLCID() (lcid uint32) {
        ret, _, _ := syscall.Syscall(uintptr(procGetUserDefaultLCID), 0, 0, 0, 0)
        lcid = uint32(ret)
        return
    }
     
    func VariantInit(v *VARIANT) (hr uintptr) {
        hr, _, _ = syscall.Syscall( uintptr(procVariantInit), 1, uintptr(unsafe.Pointer(v)), 0, 0)
        return
    }
     
    func SysAllocString(v string) (ss *int16) {
        pss, _, _ := syscall.Syscall( uintptr(procSysAllocString), 1, uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))), 0, 0)
        ss = (*int16)(unsafe.Pointer(pss))
        return
    }
     
    func SysFreeString(v *int16) (hr uintptr) {
        hr, _, _ = syscall.Syscall( uintptr(procSysFreeString), 1, uintptr(unsafe.Pointer(v)), 0, 0)
        return
    }
     
    func main() {
        CoInitialize(0)
     
        clsid, _ := CLSIDFromProgID("Shell.Application")
        disp, _ := CreateInstance(clsid, IID_IDispatch)
        dispid, _ := disp.GetIDsOfNames([]string{"BrowseForFolder"})
        disp.Invoke(dispid[0], DISPATCH_METHOD, 0, "Hello, COM(Go) World!", 0, 36)
     
        CoUninitialize()
    }

    実行方法

    C:¥> go build hello.go

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(Go) Wolrd!                  |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  2. Hello, COM(Delphi) World!

    Posted on 5月 30th, 2012 by cx20

    COM(Delphi)

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は Delphi による COM クライアントの例となっている。

    ソースコード

    program hello;
     
    uses
        Windows, ComObj, ActiveX;
     
    var
        shell: Variant;
        folder: Variant;
     
    begin
        CoInitialize(0);
     
        shell := CreateOleObject('Shell.Application');
        folder := shell.BrowseForFolder( 0, 'Hello, COM(Delphi) World!', 0, 36 );
     
        CoUninitialize();
    end.

    実行方法

    C:¥> dcc32 hello.pas

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(Delphi) Wolrd!              |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  3. Hello, COM(D言語) World!

    Posted on 5月 29th, 2012 by cx20

    COM(D言語)

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は D言語 による COM クライアントの例となっている。

    ソースコード

    import std.c.stdio;
    import std.c.windows.windows;
    import std.c.windows.com;
    import std.stdio;
    import std.variant;
     
    pragma(lib, "ole32.lib");
    pragma(lib, "oleaut32.lib");
     
    GUID CLSID_Shell         = { 0x13709620, 0xC279, 0x11CE, [0xA4, 0x9E, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00] };
    GUID IID_Folder          = { 0xBBCBDE60, 0xC3FF, 0x11CE, [0x83, 0x50, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00] };
    GUID IID_FolderItem      = { 0xFAC32C80, 0xCBE4, 0x11CE, [0x83, 0x50, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00] };
    GUID IID_FolderItems     = { 0x744129E0, 0xCBE5, 0x11CE, [0x83, 0x50, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00] };
    GUID IID_IShellDispatch  = { 0xD8F015C0, 0xC278, 0x11CE, [0xA4, 0x9E, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00] };
     
    alias DWORD* DWORD_PTR;
    alias uint LCID;
    alias uint REFIID;
    alias uint DISPID;
    alias uint DISPPARAMS;
    alias uint EXCEPINFO;
    alias wchar*  BSTR;
    alias uint ITypeInfo;
    alias short VARIANT_BOOL;
    alias double DATE;
     
    enum /*VARENUM*/ : ushort {
      VT_I4               = 3
    }
     
    struct VARIANT {
     
      union {
        struct {
          /// Describes the type of the instance.
          ushort vt;
          ushort wReserved1;
          ushort wReserved2;
          ushort wReserved3;
          union {
            int lVal;
          }
        }
      }
    }
     
    extern (System) {
        interface IDispatch : IUnknown {
            HRESULT GetTypeInfoCount(UINT *pctinfo);
            HRESULT GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo);
            HRESULT GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId);
            HRESULT Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr);
        }
     
        interface FolderItemVerb : IDispatch
        {
            HRESULT Application (IDispatch **ppid);
            HRESULT Parent(IDispatch **ppid);
            HRESULT Name(BSTR *pbs);
            HRESULT DoIt();
        }
     
        interface FolderItemVerbs : IDispatch
        {
            HRESULT Count(LONG *plCount);
            HRESULT Application (IDispatch **ppid);
            HRESULT Parent(IDispatch **ppid);
            HRESULT Item(VARIANT index, FolderItemVerb **ppid);
            HRESULT _NewEnum(IUnknown **ppunk);
        }
     
        interface FolderItem : IDispatch
        {
            alias FolderItem* LPFOLDERITEM;      // For C callers
            HRESULT Application (IDispatch **ppid);
            HRESULT Parent(IDispatch **ppid);
            HRESULT Name(BSTR *pbs);
            HRESULT Name(BSTR bs);
            HRESULT Path(BSTR *pbs);
            HRESULT GetLink(IDispatch **ppid);
            HRESULT GetFolder(IDispatch **ppid);
            HRESULT IsLink(VARIANT_BOOL *pb);
            HRESULT IsFolder(VARIANT_BOOL *pb);
            HRESULT IsFileSystem(VARIANT_BOOL *pb);
            HRESULT IsBrowsable(VARIANT_BOOL *pb);
            HRESULT ModifyDate(DATE *pdt);
            HRESULT ModifyDate(DATE dt);
            HRESULT Size(LONG *pul);
            HRESULT Type(BSTR *pbs);
            HRESULT Verbs(FolderItemVerbs **ppfic);
            HRESULT InvokeVerb(VARIANT vVerb);
        }
     
        interface FolderItems : IDispatch
        {
            HRESULT Count(LONG *plCount);
            HRESULT Application (IDispatch **ppid);
            HRESULT Parent(IDispatch **ppid);
            HRESULT Item(VARIANT index, FolderItem **ppid);
            HRESULT _NewEnum(IUnknown **ppunk);
        }
     
        interface Folder : IDispatch
        {
            HRESULT Title(BSTR *pbs);
            HRESULT Application (IDispatch **ppid);
            HRESULT Parent(IDispatch **ppid);
            HRESULT ParentFolder(Folder **ppsf);
            HRESULT Items(FolderItems **ppid);
            HRESULT ParseName(BSTR bName, FolderItem **ppid);
            HRESULT NewFolder(BSTR bName, VARIANT vOptions);
            HRESULT MoveHere(VARIANT vItem, VARIANT vOptions);
            HRESULT CopyHere(VARIANT vItem, VARIANT vOptions);
            HRESULT GetDetailsOf(VARIANT vItem, LONG iColumn, BSTR *pbs);
        }
     
        interface IShellDispatch : IDispatch
        {
            HRESULT get_Application( IDispatch **ppid);
            HRESULT get_Parent( IDispatch **ppid);
            HRESULT NameSpace( VARIANT vDir, Folder **ppsdf);
            HRESULT BrowseForFolder( LONG Hwnd, BSTR Title, LONG Options, VARIANT RootFolder /*, Folder **ppsdf */);
            HRESULT Windows( IDispatch **ppid);
            HRESULT Open( VARIANT vDir);
            HRESULT Explore( VARIANT vDir);
            HRESULT MinimizeAll();
            HRESULT UndoMinimizeALL();
            HRESULT FileRun();
            HRESULT CascadeWindows();
            HRESULT TileVertically();
            HRESULT TileHorizontally();
            HRESULT ShutdownWindows();
            HRESULT Suspend();
            HRESULT EjectPC();
            HRESULT SetTime();
            HRESULT TrayProperties();
            HRESULT Help();
            HRESULT FindFiles();
            HRESULT FindComputer();
            HRESULT RefreshMenu();
            HRESULT ControlPanelItem( BSTR bstrDir);
        }
    }
     
    int main( char[][] args )
    {
        HRESULT hr;
        IShellDispatch pShell;
     
        VARIANT vRootFolder;
        vRootFolder.vt = VT_I4;
        vRootFolder.lVal = 36;
        vRootFolder.wReserved1 = 0;
        vRootFolder.wReserved2 = 0;
        vRootFolder.wReserved3 = 0;
     
        hr = CoInitialize(null);
        hr = CoCreateInstance(&CLSID_Shell, null, CLSCTX_ALL, &IID_IShellDispatch, &pShell);
        hr = pShell.BrowseForFolder( 0, cast(wchar*)"Hello, COM(D) World!", 0, vRootFolder );
     
        CoUninitialize();
        return 0;
    }

    実行方法

    C:¥> dmd hello.d

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(D) Wolrd!                   |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  4. Hello, COM(Java) World!

    Posted on 5月 28th, 2012 by cx20

    COM(Java)

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    Java 自身には、COM を呼び出す機能を持っていないが、別途ライブラリを経由することで呼び出すことが可能である。
    以下は Java より JACOB(JAVA-COM Bridge) ライブラリを使用した COM クライアントの例となっている。

    ソースコード

    import com.jacob.com.Variant;
    import com.jacob.activeX.ActiveXComponent;
     
    public class Hello {
        public static void main(String[] args) {
            ActiveXComponent shell = new ActiveXComponent("Shell.Application"); 
            Variant hwnd = new Variant(0);
            Variant title = new Variant("Hello, COM(JACOB) World!");
            Variant option = new Variant(0);
            Variant rootFolder = new Variant(36);
            Variant[] params= new Variant[] { hwnd, title, option, rootFolder };
            Object folder = shell.invoke( "BrowseForFolder", params );
        }
    }

    コンパイル&実行方法

    C:¥> javac -cp "jacob.jar;." Hello.java
    C:¥> java -cp "jacob.jar;." Hello

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(JACOB) Wolrd!               |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  5. Hello, COM(UWSC) World!

    Posted on 5月 27th, 2012 by cx20

    COM(UWSC)

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は UWSC による COM クライアントの例となっている。

    ソースコード

    Option Explicit
     
    Main()
     
    Procedure Main()
        Dim folder
        Dim shell
        shell = CreateOleObj("Shell.Application")
        folder = shell.BrowseForFolder( 0, "Hello, COM(UWSC) World!", 0, 36 )
    Fend

    実行方法

    C:¥> uwsc /K hello.uws
    

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(UWSC) Wolrd!                |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  6. Hello, COM(Lua) World!

    Posted on 5月 26th, 2012 by cx20

    COM(Lua)

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は Lua による COM クライアントの例となっている。

    ソースコード

    require "luacom"
     
    shell = luacom.CreateObject("Shell.Application")
    folder = shell:BrowseForFolder( 0, "Hello, COM(LUA) World!", 0, 36 )

    実行方法

    C:¥> lua hello.lua

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(Lua) Wolrd!                 |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  7. Hello, COM(Python) World!

    Posted on 5月 25th, 2012 by cx20

    Python

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は Python による COM クライアントの例となっている。

    ソースコード

    import win32com.client
     
    shell = win32com.client.Dispatch('Shell.Application')
    folder = shell.BrowseForFolder( 0, "Hello, COM(Python) World!", 0, 36 )

    実行方法

    C:¥> python hello.py

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(Python) Wolrd!              |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  8. Hello, COM(PHP) World!

    Posted on 5月 25th, 2012 by cx20

    PHP

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は PHP による COM クライアントの例となっている。
    なお、PHP 5.4.5 / 5.3.15 より、COM サポートは既定では組み込まれていない為、使用するには、以下の設定を追加する必要がある。

    PHP 設定

    [COM_DOT_NET]
    extension = php_com_dotnet.dll

    ソースコード

    <?php
    $shell = new COM("Shell.Application");
    $folder = $shell->BrowseForFolder(0, "Hello, COM(PHP) World!", 0, 36 );
    ?>

    実行方法

    C:¥> php -f hello.php

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(PHP) Wolrd!                 |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  9. Hello, COM(Ruby) World!

    Posted on 5月 24th, 2012 by cx20

    Ruby

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は Ruby による COM クライアントの例となっている。

    ソースコード

    require 'win32ole'
     
    shell = WIN32OLE.new('Shell.Application')
    folder = shell.BrowseForFolder( 0, "Hello, COM(Ruby) World!", 0, 36 )

    実行方法

    C:¥> ruby hello.rb

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(Ruby) Wolrd!                |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+
  10. Hello, COM(Perl) World!

    Posted on 5月 23rd, 2012 by cx20

    Perl

    COM(Component Object Model)はマイクロソフトの提唱するプログラム部品の仕様である。
    COM を用いて開発された部品であれば言語を問わず利用することができる。
    以下は Perl による COM クライアントの例となっている。

    ソースコード

    use strict;
    use Win32::OLE;
     
    my $shell = Win32::OLE->new('Shell.Application');
    my $folder = $shell->BrowseForFolder( 0, 'Hello, COM(Perl) World!', 0, 36 );

    実行方法

    C:¥> perl hello.pl

    実行結果

    +----------------------------------------+
    |Browse For Folder                    [X]|
    +----------------------------------------+
    | Hello, COM(Perl) Wolrd!                |
    |                                        |
    | +------------------------------------+ |
    | |[Windows]                           | |
    | | +[addins]                          | |
    | | +[AppCompat]                       | |
    | | +[AppPatch]                        | |
    | | +[assembly]                        | |
    | |     :                              | |
    | |     :                              | |
    | |     :                              | |
    | +------------------------------------+ |
    | [Make New Folder]    [  OK  ] [Cancel] |
    +----------------------------------------+