In Files

  • win32ole/win32ole.c

WIN32OLE_TYPELIB

WIN32OLE_TYPELIB objects represent OLE tyblib information.

Public Class Methods

new(typelib [, version1, version2]) → WIN32OLE_TYPELIB object click to toggle source

Returns a new WIN32OLE_TYPELIB object.

The first argument typelib specifies OLE type library name or GUID or OLE library file. The second argument is major version or version of the type library. The third argument is minor version. The second argument and third argument are optional. If the first argument is type library name, then the second and third argument are ignored.

tlib1 = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library') 
tlib2 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}')
tlib3 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}', 1.3)
tlib4 = WIN32OLE_TYPELIB.new('{00020813-0000-0000-C000-000000000046}', 1, 3)
tlib5 = WIN32OLE_TYPELIB.new("C:\\WINNT\\SYSTEM32\\SHELL32.DLL")
puts tlib1.name  # -> 'Microsoft Excel 9.0 Object Library'
puts tlib2.name  # -> 'Microsoft Excel 9.0 Object Library'
puts tlib3.name  # -> 'Microsoft Excel 9.0 Object Library'
puts tlib4.name  # -> 'Microsoft Excel 9.0 Object Library'
puts tlib5.name  # -> 'Microsoft Shell Controls And Automation'
 
               static VALUE
foletypelib_initialize(VALUE self, VALUE args)
{
    VALUE found = Qfalse;
    VALUE typelib = Qnil;
    int len = 0;
    OLECHAR * pbuf;
    ITypeLib *pTypeLib;
    HRESULT hr = S_OK;

    len = RARRAY_LEN(args);
    if (len < 1 || len > 3) {
        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..3)", len);
    }

    typelib = rb_ary_entry(args, 0);

    Check_SafeStr(typelib);

    found = oletypelib_search_registry(self, typelib);
    if (found == Qfalse) {
        found = oletypelib_search_registry2(self, args);
    }
    if (found == Qfalse) {
        pbuf = ole_vstr2wc(typelib);
        hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
        SysFreeString(pbuf);
        if (SUCCEEDED(hr)) {
            found = Qtrue;
            oletypelib_set_member(self, pTypeLib);
        }
    }

    if (found == Qfalse) {
        rb_raise(eWIN32OLERuntimeError, "not found type library `%s`",
                 StringValuePtr(typelib));
    }
    return self;
}
            
typelibs click to toggle source

Returns the array of WIN32OLE_TYPELIB object.

tlibs = WIN32OLE_TYPELIB.typelibs
 
               static VALUE
foletypelib_s_typelibs(VALUE self)
{
    HKEY htypelib, hguid;
    DWORD i, j;
    LONG err;
    VALUE guid;
    VALUE version;
    VALUE name = Qnil;
    VALUE typelibs = rb_ary_new();
    VALUE typelib = Qnil;
    HRESULT hr;
    ITypeLib *pTypeLib;

    err = reg_open_key(HKEY_CLASSES_ROOT, "TypeLib", &htypelib);
    if(err != ERROR_SUCCESS) {
        return typelibs;
    }
    for(i = 0; ; i++) {
        guid = reg_enum_key(htypelib, i);
        if (guid == Qnil)
            break;
        err = reg_open_vkey(htypelib, guid, &hguid);
        if (err != ERROR_SUCCESS)
            continue;
        for(j = 0; ; j++) {
            version = reg_enum_key(hguid, j);
            if (version == Qnil)
                break;
            if ( (name = reg_get_val2(hguid, StringValuePtr(version))) != Qnil ) {
                hr = oletypelib_from_guid(guid, version, &pTypeLib);
                if (SUCCEEDED(hr)) {
                    typelib = rb_funcall(cWIN32OLE_TYPELIB, rb_intern("allocate"), 0);
                    oletypelib_set_member(typelib, pTypeLib);
                    rb_ary_push(typelibs, typelib);
                }
            }
        }
        RegCloseKey(hguid);
    }
    RegCloseKey(htypelib);
    return typelibs;
}
            

Public Instance Methods

WIN32OLE_TYPELIB#guid → The guid string. click to toggle source

Returns guid string which specifies type library.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
guid = tlib.guid # -> '{00020813-0000-0000-C000-000000000046}'
 
               static VALUE
foletypelib_guid(VALUE self)
{
    struct oletypelibdata *ptlib;
    ITypeLib *pTypeLib;
    HRESULT hr;
    OLECHAR bstr[80];
    VALUE guid = Qnil;
    int len;
    TLIBATTR *pTLibAttr;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;
    hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, &pTLibAttr);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to GetLibAttr from ITypeLib");
    }
    len = StringFromGUID2(&pTLibAttr->guid, bstr, sizeof(bstr)/sizeof(OLECHAR));
    if (len > 3) {
        guid = ole_wc2vstr(bstr, FALSE);
    }
    pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    return guid;
}
            
WIN32OLE_TYPELIB#inspect → String click to toggle source

Returns the type library name with class name.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
tlib.inspect # => "<#WIN32OLE_TYPELIB:Microsoft Excel 9.0 Object Library>"
 
               static VALUE
foletypelib_inspect(VALUE self)
{
    return default_inspect(self, "WIN32OLE_TYPELIB");
}
            
WIN32OLE_TYPELIB#library_name click to toggle source

Returns library name. If the method fails to access library name, WIN32OLERuntimeError is raised.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
tlib.library_name # => Excel
 
               static VALUE
foletypelib_library_name(VALUE self)
{
    HRESULT hr;
    ITypeLib *pTypeLib = NULL;
    VALUE libname = Qnil;
    BSTR bstr;

    struct oletypelibdata *ptlib;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;
    hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
                                            &bstr, NULL, NULL, NULL);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to get library name");
    }
    libname = WC2VSTR(bstr);
    return libname;
}
            
WIN32OLE_TYPELIB#major_version → The type library major version. click to toggle source

Returns the type library major version.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
puts tlib.major_version # -> 1
 
               static VALUE
foletypelib_major_version(VALUE self)
{
    TLIBATTR *pTLibAttr;
    VALUE major;
    HRESULT hr = S_OK; 
    struct oletypelibdata *ptlib;
    ITypeLib *pTypeLib;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;

    hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, &pTLibAttr);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to GetLibAttr from ITypeLib");
    }
    major =  INT2NUM(pTLibAttr->wMajorVerNum);
    pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    return major;
}
            
WIN32OLE_TYPELIB#minor_version → The type library minor version. click to toggle source

Returns the type library minor version.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
puts tlib.minor_version # -> 3
 
               static VALUE
foletypelib_minor_version(VALUE self)
{
    TLIBATTR *pTLibAttr;
    VALUE minor;
    HRESULT hr = S_OK; 
    struct oletypelibdata *ptlib;
    ITypeLib *pTypeLib;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;

    hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, &pTLibAttr);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to GetLibAttr from ITypeLib");
    }
    minor =  INT2NUM(pTLibAttr->wMinorVerNum);
    pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    return minor;
}
            
WIN32OLE_TYPELIB#name → The type library name click to toggle source

Returns the type library name.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
name = tlib.name # -> 'Microsoft Excel 9.0 Object Library'
 
               static VALUE
foletypelib_name(VALUE self)
{
    struct oletypelibdata *ptlib;
    ITypeLib *pTypeLib;
    HRESULT hr;
    BSTR bstr;
    BSTR bstr2;
    VALUE name;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;
    hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
                                            &bstr, &bstr2, NULL, NULL);
    
    if (SUCCEEDED(hr)) {
        name = WC2VSTR(bstr2);
        return rb_enc_str_new(StringValuePtr(name), strlen(StringValuePtr(name)), cWIN32OLE_enc);
    } else {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to get name from ITypeLib");
    }
}
            
Also aliased as: to_s
ole_classes() click to toggle source
Alias for: ole_types
WIN32OLE_TYPELIB#ole_types → The array of WIN32OLE_TYPE object included the type library. click to toggle source

Returns the type library file path.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
classes = tlib.ole_types.collect{|k| k.name} # -> ['AddIn', 'AddIns' ...]
 
               static VALUE
foletypelib_ole_types(VALUE self)
{
    ITypeLib *pTypeLib = NULL;
    VALUE classes = rb_ary_new();
    struct oletypelibdata *ptlib;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;
    ole_types_from_typelib(pTypeLib, classes);
    return classes;
}
            
Also aliased as: ole_classes
WIN32OLE_TYPELIB#path → The type library file path. click to toggle source

Returns the type library file path.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
puts tlib.path #-> 'C:\...\EXCEL9.OLB'
 
               static VALUE
foletypelib_path(VALUE self)
{
    TLIBATTR *pTLibAttr;
    int len = 0;
    HRESULT hr = S_OK; 
    BSTR bstr;
    LCID lcid = cWIN32OLE_lcid;
    VALUE path;
    struct oletypelibdata *ptlib;
    ITypeLib *pTypeLib;

    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;
    hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, &pTLibAttr);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to get TLIBATTR information");
    }
    hr = QueryPathOfRegTypeLib(&pTLibAttr->guid, 
                               pTLibAttr->wMajorVerNum,
                               pTLibAttr->wMinorVerNum,
                               lcid,
                               &bstr);
    if (FAILED(hr)) {
        pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
        ole_raise(hr, eWIN32OLERuntimeError, "failed to QueryPathOfRegTypeTypeLib");
    }

    pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    path = WC2VSTR(bstr);
    return rb_enc_str_new(StringValuePtr(path), strlen(StringValuePtr(path)), cWIN32OLE_enc);
}
            
to_s() click to toggle source
Alias for: name
WIN32OLE_TYPELIB#version → The type library version. click to toggle source

Returns the type library version.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
puts tlib.version #-> 1.3
 
               static VALUE
foletypelib_version(VALUE self)
{
    TLIBATTR *pTLibAttr;
    VALUE major;
    VALUE minor;
    HRESULT hr = S_OK; 
    struct oletypelibdata *ptlib;
    ITypeLib *pTypeLib;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;

    hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, &pTLibAttr);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to GetLibAttr from ITypeLib");
    }
    major = INT2NUM(pTLibAttr->wMajorVerNum);
    minor = INT2NUM(pTLibAttr->wMinorVerNum);
    pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    return rb_Float(make_version_str(major, minor));
}
            
WIN32OLE_TYPELIB#visible? click to toggle source

Returns true if the type library information is not hidden. If wLibFlags of TLIBATTR is 0 or LIBFLAG_FRESTRICTED or LIBFLAG_FHIDDEN, the method returns false, otherwise, returns true. If the method fails to access the TLIBATTR information, then WIN32OLERuntimeError is raised.

tlib = WIN32OLE_TYPELIB.new('Microsoft Excel 9.0 Object Library')
tlib.visible? # => true
 
               static VALUE
foletypelib_visible(VALUE self)
{
    HRESULT hr;
    ITypeLib *pTypeLib = NULL;
    VALUE visible = Qtrue;
    TLIBATTR *pTLibAttr;

    struct oletypelibdata *ptlib;
    Data_Get_Struct(self, struct oletypelibdata, ptlib);
    pTypeLib = ptlib->pTypeLib;

    hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, &pTLibAttr);
    if (FAILED(hr)) {
        ole_raise(hr, eWIN32OLERuntimeError, "failed to get TLIBATTR information");
    }
    if ((pTLibAttr->wLibFlags == 0) ||
        (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
        (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
        visible = Qfalse;
    }
    pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
    return visible;
}
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus