Archive for the ‘COM’ Category

  1. Hello, COM(Go) World!

    Posted on 5月 31st, 2012 by cx20

    COM(Go)

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

    ソースコード

    hello.go
    raw download
    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 クライアントの例となっている。

    ソースコード

    hello.pas
    raw download
    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 クライアントの例となっている。

    ソースコード

    hello.d
    raw download
    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 クライアントの例となっている。

    ソースコード

    Hello.java
    raw download
    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 クライアントの例となっている。

    ソースコード

    hello.uwsc
    raw download
    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 クライアントの例となっている。

    ソースコード

    hello.lua
    raw download
    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 クライアントの例となっている。

    ソースコード

    hello.py
    raw download
    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 設定

    php.ini
    raw download
    [COM_DOT_NET]
extension = php_com_dotnet.dll

    ソースコード

    hello.php
    raw download
    <?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 クライアントの例となっている。

    ソースコード

    hello.rb
    raw download
    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 クライアントの例となっている。

    ソースコード

    hello.pl
    raw download
    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] |
+----------------------------------------+
« Older Entries Newer Entries »