texlive[54174] Master/tlpkg/tlperl/site/lib: Temporarily re-add
commits+siepo at tug.org
commits+siepo at tug.org
Sun Mar 8 18:43:21 CET 2020
Revision: 54174
http://tug.org/svn/texlive?view=revision&revision=54174
Author: siepo
Date: 2020-03-08 18:43:21 +0100 (Sun, 08 Mar 2020)
Log Message:
-----------
Temporarily re-add Win32::OLE module
Added Paths:
-----------
trunk/Master/tlpkg/tlperl/site/lib/OLE.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Const.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Enum.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Lite.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NEWS.pod
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NLS.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TPJ.pod
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TypeInfo.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Variant.pm
trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE.pm
trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/
trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/.packlist
trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/OLE.dll
Added: trunk/Master/tlpkg/tlperl/site/lib/OLE.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/OLE.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/OLE.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,177 @@
+# Compatibility layer for applications using the old toplevel OLE.pm.
+# New code should use Win32::OLE
+
+# This file is based on ../lib/OLE.pm from ActiveState build 315.
+
+# Compatibility notes:
+# - "GetObject" -> "GetActiveObject"
+# - "keys %$collection" -> "Win32::OLE::Enum->All($collection)"
+# or "in $Collection"
+# - "unnamed" default method retries
+
+########################################################################
+# package Win32;
+########################################################################
+
+*Win32::OLELastError = sub { return OLE->LastError() };
+
+
+########################################################################
+package OLE::Variant;
+########################################################################
+
+use Win32::OLE qw(CP_ACP);
+use Win32::OLE::Variant;
+
+use strict;
+use vars qw($AUTOLOAD @ISA $LCID $CP $Warn $LastError $_NewEnum $_Unique);
+ at ISA = qw(Win32::OLE::Variant);
+
+$Warn = 0;
+$LCID = 2 << 10; # LOCALE_SYSTEM_DEFAULT
+$CP = CP_ACP;
+$_NewEnum = 0;
+$_Unique = 0;
+
+sub new {
+ my $self = shift;
+ my $variant = $self->SUPER::new(@_);
+ $OLE::LastError = $Win32::OLE->LastError unless defined $variant;
+ return $variant;
+}
+
+
+########################################################################
+package OLE::Tie;
+########################################################################
+use strict;
+use vars qw(@ISA);
+ at ISA = qw(Win32::OLE::Tie);
+
+# !!! It is VERY important that Win32::OLE::Tie::DESTROY gets called. !!!
+# If you subclass DESTROY, don't forget to call $self->SUPER::DESTROY.
+# Otherwise the OLE interfaces will not be released until process termination!
+
+# Retry default method if property doesn't exist
+sub FETCH {
+ my ($self,$key) = @_;
+ return $self->SUPER::Fetch($key, 1);
+}
+
+sub STORE {
+ my ($self,$key,$value) = @_;
+ $self->SUPER::Store($key, $value, 1);
+}
+
+# Enumerate collection members, not object properties
+*FIRSTKEY = *Win32::OLE::Tie::FIRSTENUM;
+*NEXTKEY = *Win32::OLE::Tie::NEXTENUM;
+
+
+########################################################################
+package OLE;
+########################################################################
+use Win32::OLE qw(CP_ACP);
+
+# Use OleInitialize() instead of CoInitializeEx:
+Win32::OLE->Initialize(Win32::OLE::COINIT_OLEINITIALIZE);
+
+use strict;
+
+# Disable overload; unfortunately "no overload" doesn't do it :-(
+# Overloading is no longer enabled by default in Win32::OLE
+#use overload '""' => sub {overload::StrVal($_[0])},
+# '0+' => sub {overload::StrVal($_[0])};
+
+use vars qw($AUTOLOAD @ISA $LCID $CP $Warn $LastError $Tie);
+ at ISA = qw(Win32::OLE);
+
+$Warn = 0;
+$LCID = 2 << 10; # LOCALE_SYSTEM_DEFAULT
+$CP = CP_ACP;
+$Tie = 'OLE::Tie';
+
+sub new {
+ my $class = shift;
+ $class = shift if $class eq 'OLE';
+ return OLE->SUPER::new($class);
+}
+
+sub copy {
+ my $class = shift;
+ $class = shift if $class eq 'OLE';
+ return OLE->SUPER::GetActiveObject($class);
+}
+
+sub AUTOLOAD {
+ my $self = shift;
+ my $retval;
+ $AUTOLOAD =~ s/.*:://o;
+
+ Carp::croak("Cannot autoload class method \"$AUTOLOAD\"")
+ unless ref($self) && UNIVERSAL::isa($self,'OLE');
+
+ local $^H = 0; # !hack alert!
+ unless (defined $self->Dispatch($AUTOLOAD, $retval, @_)) {
+ # Retry default method
+ $self->Dispatch(undef, $retval, $AUTOLOAD, @_);
+ }
+ return $retval;
+}
+
+*CreateObject = \&new;
+*GetObject = \©
+
+# Automation data types.
+
+sub VT_EMPTY {0;}
+sub VT_NULL {1;}
+sub VT_I2 {2;}
+sub VT_I4 {3;}
+sub VT_R4 {4;}
+sub VT_R8 {5;}
+sub VT_CY {6;}
+sub VT_DATE {7;}
+sub VT_BSTR {8;}
+sub VT_DISPATCH {9;}
+sub VT_ERROR {10;}
+sub VT_BOOL {11;}
+sub VT_VARIANT {12;}
+sub VT_UNKNOWN {13;}
+sub VT_I1 {16;}
+sub VT_UI1 {17;}
+sub VT_UI2 {18;}
+sub VT_UI4 {19;}
+sub VT_I8 {20;}
+sub VT_UI8 {21;}
+sub VT_INT {22;}
+sub VT_UINT {23;}
+sub VT_VOID {24;}
+sub VT_HRESULT {25;}
+sub VT_PTR {26;}
+sub VT_SAFEARRAY {27;}
+sub VT_CARRAY {28;}
+sub VT_USERDEFINED {29;}
+sub VT_LPSTR {30;}
+sub VT_LPWSTR {31;}
+sub VT_FILETIME {64;}
+sub VT_BLOB {65;}
+sub VT_STREAM {66;}
+sub VT_STORAGE {67;}
+sub VT_STREAMED_OBJECT {68;}
+sub VT_STORED_OBJECT {69;}
+sub VT_BLOB_OBJECT {70;}
+sub VT_CF {71;}
+sub VT_CLSID {72;}
+
+sub TKIND_ENUM {0;}
+sub TKIND_RECORD {1;}
+sub TKIND_MODULE {2;}
+sub TKIND_INTERFACE {3;}
+sub TKIND_DISPATCH {4;}
+sub TKIND_COCLASS {5;}
+sub TKIND_ALIAS {6;}
+sub TKIND_UNION {7;}
+sub TKIND_MAX {8;}
+
+1;
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/OLE.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Const.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Const.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Const.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,201 @@
+# The documentation is at the __END__
+
+package Win32::OLE::Const;
+
+use strict;
+use Carp;
+use Win32::OLE;
+
+my $Typelibs;
+sub _Typelib {
+ my ($clsid,$title,$version,$langid,$filename) = @_;
+ # Filenames might have a resource index appended to it.
+ $filename = $1 if $filename =~ /^(.*\.(?:dll|exe))(\\\d+)$/i;
+ # Ignore if it looks like a file but doesn't exist.
+ # We don't verify existence of monikers or filenames
+ # without a full pathname.
+ return if $filename =~ /^\w:\\.*\.(exe|dll)$/ && !-f $filename;
+ push @$Typelibs, \@_;
+}
+unless (__PACKAGE__->_Typelibs("TypeLib")) {
+ warn("Cannot access HKEY_CLASSES_ROOT\\Typelib");
+}
+# Enumerate 32bit type libraries on Win64
+__PACKAGE__->_Typelibs("Wow6432Node\\TypeLib");
+
+sub import {
+ my ($self,$name,$major,$minor,$language,$codepage) = @_;
+ return unless defined($name) && $name !~ /^\s*$/;
+ $self->Load($name,$major,$minor,$language,$codepage,scalar caller);
+}
+
+sub EnumTypeLibs {
+ my ($self,$callback) = @_;
+ foreach (@$Typelibs) { &$callback(@$_) }
+ return;
+}
+
+sub Load {
+ my ($self,$name,$major,$minor,$language,$codepage,$caller) = @_;
+
+ if (UNIVERSAL::isa($name,'Win32::OLE')) {
+ my $typelib = $name->GetTypeInfo->GetContainingTypeLib;
+ return _Constants($typelib, undef);
+ }
+
+ undef $minor unless defined $major;
+ my $typelib = $self->LoadRegTypeLib($name,$major,$minor,
+ $language,$codepage);
+ return _Constants($typelib, $caller);
+}
+
+sub LoadRegTypeLib {
+ my ($self,$name,$major,$minor,$language,$codepage) = @_;
+ undef $minor unless defined $major;
+
+ unless (defined($name) && $name !~ /^\s*$/) {
+ carp "Win32::OLE::Const->Load: No or invalid type library name";
+ return;
+ }
+
+ my @found;
+ foreach my $Typelib (@$Typelibs) {
+ my ($clsid,$title,$version,$langid,$filename) = @$Typelib;
+ next unless $title =~ /^$name/;
+ next unless $version =~ /^([0-9a-fA-F]+)\.([0-9a-fA-F]+)$/;
+ my ($maj,$min) = (hex($1), hex($2));
+ next if defined($major) && $maj != $major;
+ next if defined($minor) && $min < $minor;
+ next if defined($language) && $language != $langid;
+ push @found, [$clsid,$maj,$min,$langid,$filename];
+ }
+
+ unless (@found) {
+ carp "No type library matching \"$name\" found";
+ return;
+ }
+
+ @found = sort {
+ # Prefer greater version number
+ my $res = $b->[1] <=> $a->[1];
+ $res = $b->[2] <=> $a->[2] if $res == 0;
+ # Prefer default language for equal version numbers
+ $res = -1 if $res == 0 && $a->[3] == 0;
+ $res = 1 if $res == 0 && $b->[3] == 0;
+ $res;
+ } @found;
+
+ #printf "Loading %s\n", join(' ', @{$found[0]});
+ return _LoadRegTypeLib(@{$found[0]},$codepage);
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Win32::OLE::Const - Extract constant definitions from TypeLib
+
+=head1 SYNOPSIS
+
+ use Win32::OLE::Const 'Microsoft Excel';
+ printf "xlMarkerStyleDot = %d\n", xlMarkerStyleDot;
+
+ my $wd = Win32::OLE::Const->Load("Microsoft Word 8\\.0 Object Library");
+ foreach my $key (keys %$wd) {
+ printf "$key = %s\n", $wd->{$key};
+ }
+
+=head1 DESCRIPTION
+
+This modules makes all constants from a registered OLE type library
+available to the Perl program. The constant definitions can be
+imported as functions, providing compile time name checking.
+Alternatively the constants can be returned in a hash reference
+which avoids defining lots of functions of unknown names.
+
+=head2 Functions/Methods
+
+=over 4
+
+=item use Win32::OLE::Const
+
+The C<use> statement can be used to directly import the constant names
+and values into the users namespace.
+
+ use Win32::OLE::Const (TYPELIB,MAJOR,MINOR,LANGUAGE);
+
+The TYPELIB argument specifies a regular expression for searching
+through the registry for the type library. Note that this argument is
+implicitly prefixed with C<^> to speed up matches in the most common
+cases. Use a typelib name like ".*Excel" to match anywhere within the
+description. TYPELIB is the only required argument.
+
+The MAJOR and MINOR arguments specify the requested version of
+the type specification. If the MAJOR argument is used then only
+typelibs with exactly this major version number will be matched. The
+MINOR argument however specifies the minimum acceptable minor version.
+MINOR is ignored if MAJOR is undefined.
+
+If the LANGUAGE argument is used then only typelibs with exactly this
+language id will be matched.
+
+The module will select the typelib with the highest version number
+satisfying the request. If no language id is specified then a the default
+language (0) will be preferred over the others.
+
+Note that only constants with valid Perl variable names will be exported,
+i.e. names matching this regexp: C</^[a-zA-Z_][a-zA-Z0-9_]*$/>.
+
+=item Win32::OLE::Const->Load
+
+The Win32::OLE::Const->Load method returns a reference to a hash of
+constant definitions.
+
+ my $const = Win32::OLE::Const->Load(TYPELIB,MAJOR,MINOR,LANGUAGE);
+
+The parameters are the same as for the C<use> case.
+
+This method is generally preferable when the typelib uses a non-english
+language and the constant names contain locale specific characters not
+allowed in Perl variable names.
+
+Another advantage is that all available constants can now be enumerated.
+
+The load method also accepts an OLE object as a parameter. In this case
+the OLE object is queried about its containing type library and no registry
+search is done at all. Interestingly this seems to be slower.
+
+=back
+
+=head1 EXAMPLES
+
+The first example imports all Excel constants names into the main namespace
+and prints the value of xlMarkerStyleDot (-4118).
+
+ use Win32::OLE::Const ('Microsoft Excel 8.0 Object Library');
+ print "xlMarkerStyleDot = %d\n", xlMarkerStyleDot;
+
+The second example returns all Word constants in a hash ref.
+
+ use Win32::OLE::Const;
+ my $wd = Win32::OLE::Const->Load("Microsoft Word 8.0 Object Library");
+ foreach my $key (keys %$wd) {
+ printf "$key = %s\n", $wd->{$key};
+ }
+ printf "wdGreen = %s\n", $wd->{wdGreen};
+
+The last example uses an OLE object to specify the type library:
+
+ use Win32::OLE;
+ use Win32::OLE::Const;
+ my $Excel = Win32::OLE->new('Excel.Application', 'Quit');
+ my $xl = Win32::OLE::Const->Load($Excel);
+
+
+=head1 AUTHORS/COPYRIGHT
+
+This module is part of the Win32::OLE distribution.
+
+=cut
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Const.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Enum.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Enum.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Enum.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,95 @@
+# The documentation is at the __END__
+
+package Win32::OLE::Enum;
+1;
+
+# everything is pure XS in Win32::OLE::Enum
+# - new
+# - DESTROY
+#
+# - All
+# - Clone
+# - Next
+# - Reset
+# - Skip
+
+__END__
+
+=head1 NAME
+
+Win32::OLE::Enum - OLE Automation Collection Objects
+
+=head1 SYNOPSIS
+
+ my $Sheets = $Excel->Workbooks(1)->Worksheets;
+ my $Enum = Win32::OLE::Enum->new($Sheets);
+ my @Sheets = $Enum->All;
+
+ while (defined(my $Sheet = $Enum->Next)) { ... }
+
+=head1 DESCRIPTION
+
+This module provides an interface to OLE collection objects from
+Perl. It defines an enumerator object closely mirroring the
+functionality of the IEnumVARIANT interface.
+
+Please note that the Reset() method is not available in all implementations
+of OLE collections (like Excel 7). In that case the Enum object is good
+only for a single walk through of the collection.
+
+=head2 Functions/Methods
+
+=over 8
+
+=item Win32::OLE::Enum->new($object)
+
+Creates an enumerator for $object, which must be a valid OLE collection
+object. Note that correctly implemented collection objects must support
+the C<Count> and C<Item> methods, so creating an enumerator is not always
+necessary.
+
+=item $Enum->All()
+
+Returns a list of all objects in the collection. You have to call
+$Enum->Reset() before the enumerator can be used again. The previous
+position in the collection is lost.
+
+This method can also be called as a class method:
+
+ my @list = Win32::OLE::Enum->All($Collection);
+
+=item $Enum->Clone()
+
+Returns a clone of the enumerator maintaining the current position within
+the collection (if possible). Note that the C<Clone> method is often not
+implemented. Use $Enum->Clone() in an eval block to avoid dying if you
+are not sure that Clone is supported.
+
+=item $Enum->Next( [$count] )
+
+Returns the next element of the collection. In a list context the optional
+$count argument specifies the number of objects to be returned. In a scalar
+context only the last of at most $count retrieved objects is returned. The
+default for $count is 1.
+
+=item $Enum->Reset()
+
+Resets the enumeration sequence to the beginning. There is no guarantee that
+the exact same set of objects will be enumerated again (e.g. when enumerating
+files in a directory). The methods return value indicates the success of the
+operation. (Note that the Reset() method seems to be unimplemented in some
+applications like Excel 7. Use it in an eval block to avoid dying.)
+
+=item $Enum->Skip( [$count] )
+
+Skip the next $count elements of the enumeration. The default for $count is 1.
+The functions returns TRUE if at least $count elements could be skipped. It
+returns FALSE if not enough elements were left.
+
+=back
+
+=head1 AUTHORS/COPYRIGHT
+
+This module is part of the Win32::OLE distribution.
+
+=cut
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Enum.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Lite.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Lite.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Lite.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,224 @@
+package Win32::OLE;
+
+sub _croak { require Carp; Carp::croak(@_) }
+
+unless (defined &Dispatch) {
+ DynaLoader::boot_DynaLoader('DynaLoader')
+ unless defined(&DynaLoader::dl_load_file);
+ my $file;
+ foreach my $dir (@INC) {
+ my $try = "$dir/auto/Win32/OLE/OLE.dll";
+ last if $file = (-f $try && $try);
+ }
+ _croak("Can't locate loadable object for module Win32::OLE".
+ " in \@INC (\@INC contains: @INC)")
+ unless $file; # wording similar to error from 'require'
+
+ my $libref = DynaLoader::dl_load_file($file, 0) or
+ _croak("Can't load '$file' for module Win32::OLE: ".
+ DynaLoader::dl_error()."\n");
+
+ my $boot_symbol_ref = DynaLoader::dl_find_symbol($libref, "boot_Win32__OLE")
+ or _croak("Can't find 'boot_Win32__OLE' symbol in $file\n");
+
+ my $xs = DynaLoader::dl_install_xsub("Win32::OLE::bootstrap",
+ $boot_symbol_ref, $file);
+ &$xs('Win32::OLE');
+}
+
+if (defined &DB::sub && !defined $_Unique) {
+ warn "Win32::OLE operating in debugging mode: _Unique => 1\n";
+ $_Unique = 1;
+}
+
+$Warn = 1;
+
+sub CP_ACP {0;} # ANSI codepage
+sub CP_OEMCP {1;} # OEM codepage
+sub CP_MACCP {2;}
+sub CP_UTF7 {65000;}
+sub CP_UTF8 {65001;}
+
+sub DISPATCH_METHOD {1;}
+sub DISPATCH_PROPERTYGET {2;}
+sub DISPATCH_PROPERTYPUT {4;}
+sub DISPATCH_PROPERTYPUTREF {8;}
+
+sub COINIT_MULTITHREADED {0;} # Default
+sub COINIT_APARTMENTTHREADED {2;} # Use single threaded apartment model
+
+# Bogus COINIT_* values to indicate special cases:
+sub COINIT_OLEINITIALIZE {-1;} # Use OleInitialize instead of CoInitializeEx
+sub COINIT_NO_INITIALIZE {-2;} # We are already initialized, just believe me
+
+sub HRESULT {
+ my $hr = shift;
+ $hr -= 2**32 if $hr & 0x80000000;
+ return $hr;
+}
+
+# CreateObject is defined here only because it is documented in the
+# "Learning Perl on Win32 Systems" Gecko book. Please use Win32::OLE->new().
+sub CreateObject {
+ if (ref($_[0]) && UNIVERSAL::isa($_[0],'Win32::OLE')) {
+ $AUTOLOAD = ref($_[0]) . '::CreateObject';
+ goto &AUTOLOAD;
+ }
+
+ # Hack to allow C<$obj = CreateObject Win32::OLE 'My.App';>. Although this
+ # is contrary to the Gecko, we just make it work since it doesn't hurt.
+ return Win32::OLE->new($_[1]) if $_[0] eq 'Win32::OLE';
+
+ # Gecko form: C<$success = Win32::OLE::CreateObject('My.App',$obj);>
+ $_[1] = Win32::OLE->new($_[0]);
+ return defined $_[1];
+}
+
+sub LastError {
+ unless (defined $_[0]) {
+ # Win32::OLE::LastError() will always return $Win32::OLE::LastError
+ return $LastError;
+ }
+
+ if (ref($_[0]) && UNIVERSAL::isa($_[0],'Win32::OLE')) {
+ $AUTOLOAD = ref($_[0]) . '::LastError';
+ goto &AUTOLOAD;
+ }
+
+ #no strict 'refs';
+ my $LastError = "$_[0]::LastError";
+ $$LastError = $_[1] if defined $_[1];
+ return $$LastError;
+}
+
+my $Options = "^(?:CP|LCID|Warn|Variant|_NewEnum|_Unique)\$";
+
+sub Option {
+ if (ref($_[0]) && UNIVERSAL::isa($_[0],'Win32::OLE')) {
+ $AUTOLOAD = ref($_[0]) . '::Option';
+ goto &AUTOLOAD;
+ }
+
+ my $class = shift;
+
+ if (@_ == 1) {
+ my $option = shift;
+ return ${"${class}::$option"} if $option =~ /$Options/o;
+ _croak("Invalid $class option: $option");
+ }
+
+ while (@_) {
+ my ($option,$value) = splice @_, 0, 2;
+ _croak("Invalid $class option: $option") if $option !~ /$Options/o;
+ ${"${class}::$option"} = $value;
+ $class->_Unique() if $option eq "_Unique";
+ }
+}
+
+sub Invoke {
+ my ($self,$method, at args) = @_;
+ $self->Dispatch($method, my $retval, @args);
+ return $retval;
+}
+
+sub LetProperty {
+ my ($self,$method, at args) = @_;
+ $self->Dispatch([DISPATCH_PROPERTYPUT, $method], my $retval, @args);
+ return $retval;
+}
+
+sub SetProperty {
+ my ($self,$method, at args) = @_;
+ my $wFlags = DISPATCH_PROPERTYPUT;
+ if (@args) {
+ # If the value is an object then it will be set by reference!
+ my $value = $args[-1];
+ if (UNIVERSAL::isa($value, 'Win32::OLE')) {
+ $wFlags = DISPATCH_PROPERTYPUTREF;
+ }
+ elsif (UNIVERSAL::isa($value,'Win32::OLE::Variant')) {
+ my $type = $value->Type & ~0xfff; # VT_TYPEMASK
+ # VT_DISPATCH and VT_UNKNOWN represent COM objects
+ $wFlags = DISPATCH_PROPERTYPUTREF if $type == 9 || $type == 13;
+ }
+ }
+ $self->Dispatch([$wFlags, $method], my $retval, @args);
+ return $retval;
+}
+
+sub AUTOLOAD {
+ my $self = shift;
+ my $autoload = substr $AUTOLOAD, rindex($AUTOLOAD, ':')+1;
+ _croak("Cannot autoload class method \"$autoload\"")
+ unless ref($self) && UNIVERSAL::isa($self, 'Win32::OLE');
+ my $success = $self->Dispatch($autoload, my $retval, @_);
+ unless (defined $success || ($^H & 0x200) != 0) {
+ # Retry default method if C<no strict 'subs';>
+ $self->Dispatch(undef, $retval, $autoload, @_);
+ }
+ return $retval;
+}
+
+sub in {
+ my @res;
+ while (@_) {
+ my $this = shift;
+ if (UNIVERSAL::isa($this, 'Win32::OLE')) {
+ push @res, Win32::OLE::Enum->All($this);
+ }
+ elsif (ref($this) eq 'ARRAY') {
+ push @res, @$this;
+ }
+ else {
+ push @res, $this;
+ }
+ }
+ return @res;
+}
+
+sub valof {
+ my $arg = shift;
+ if (UNIVERSAL::isa($arg, 'Win32::OLE')) {
+ require Win32::OLE::Variant;
+ my ($class) = overload::StrVal($arg) =~ /^([^=]+)=/;
+ #no strict 'refs';
+ local $Win32::OLE::CP = ${"${class}::CP"};
+ local $Win32::OLE::LCID = ${"${class}::LCID"};
+ #use strict 'refs';
+ # VT_EMPTY variant for return code
+ my $variant = Win32::OLE::Variant->new;
+ $arg->Dispatch(undef, $variant);
+ return $variant->Value;
+ }
+ $arg = $arg->Value if UNIVERSAL::can($arg, 'Value');
+ return $arg;
+}
+
+sub with {
+ my $object = shift;
+ while (@_) {
+ my $property = shift;
+ $object->{$property} = shift;
+ }
+}
+
+########################################################################
+
+package Win32::OLE::Tie;
+
+# Only retry default method under C<no strict 'subs';>
+sub FETCH {
+ my ($self,$key) = @_;
+ if ($key eq "_NewEnum") {
+ (my $class = ref $self) =~ s/::Tie$//;
+ return [Win32::OLE::Enum->All($self)] if ${"${class}::_NewEnum"};
+ }
+ $self->Fetch($key, !$Win32::OLE::Strict);
+}
+
+sub STORE {
+ my ($self,$key,$value) = @_;
+ $self->Store($key, $value, !$Win32::OLE::Strict);
+}
+
+1;
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Lite.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NEWS.pod
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NEWS.pod (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NEWS.pod 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,380 @@
+=pod
+
+=head1 NAME
+
+Win32::OLE::NEWS - What's new in Win32::OLE
+
+This file contains a history of user visible changes to the
+Win32::OLE::* modules. Only new features and major bug fixes that
+might affect backwards compatibility are included.
+
+=head1 Version 0.18
+
+=head2 VT_CY and VT_DECIMAL return values handled differently
+
+The new C<Variant> option enables values of VT_CY or VT_DECIMAL type
+to be returned as Win32::OLE::Variant objects instead of being
+converted into strings and numbers respectively. This is similar to
+the change in Win32::OLE version 0.12 to VT_DATE and VT_ERROR values.
+The Win32::OLE::Variant module must be included to make sure that
+VT_CY and VT_DECIMAL values behave as before in numeric or string
+contexts.
+
+Because the new behavior is potentially incompatible, it must be
+explicitly enabled:
+
+ Win32::OLE->Option(Variant => 1);
+
+
+=head1 Version 0.17
+
+=head2 New nullstring() function in Win32::OLE::Variant
+
+The nullstring() function returns a VT_BSTR variant containing a NULL
+string pointer. Note that this is not the same as a VT_BSTR variant
+containing the empty string "".
+
+The nullstring() return value is equivalent to the Visual Basic
+C<vbNullString> constant.
+
+
+=head1 Version 0.16
+
+=head2 Improved Unicode support
+
+Passing Unicode strings to methods and properties as well as returning
+Unicode strings back to Perl works now with both Perl 5.6 and 5.8.
+Note that the Unicode support in 5.8 is much more complete than in 5.6
+or 5.6.1.
+
+C<Unicode::String> objects can now be passed to methods or assigned to
+properties.
+
+You must enable Unicode support by switching Win32::OLE to the UTF8
+codepage:
+
+ Win32::OLE->Option(CP => Win32::OLE::CP_UTF8());
+
+
+=head1 Version 0.13
+
+=head2 New nothing() function in Win32::OLE::Variant
+
+The nothing() function returns an empty VT_DISPATCH variant. It can be
+used to clear an object reference stored in a property
+
+ use Win32::OLE::Variant qw(:DEFAULT nothing);
+ # ...
+ $object->{Property} = nothing;
+
+This has the same effect as the Visual Basic statement
+
+ Set object.Property = Nothing
+
+=head2 New _NewEnum and _Unique options
+
+There are two new options available for the Win32::OLE->Option class
+method: C<_NewEnum> provides the elements of a collection object
+directly as the value of a C<_NewEnum> property. The C<_Unique>
+option guarantees that Win32::OLE will not create multiple proxy
+objects for the same underlying COM/OLE object.
+
+Both options are only really useful to tree traversal programs or
+during debugging.
+
+
+=head1 Version 0.12
+
+=head2 Additional error handling functionality
+
+The Warn option can now be set to a CODE reference too. For example,
+
+ Win32::OLE->Option(Warn => 3);
+
+could now be written as
+
+ Win32::OLE->Option(Warn => \&Carp::croak);
+
+This can even be used to emulate the VisualBasic C<On Error Goto
+Label> construct:
+
+ Win32::OLE->Option(Warn => sub {goto CheckError});
+ # ... your normal OLE code here ...
+
+ CheckError:
+ # ... your error handling code here ...
+
+=head2 Builtin event loop
+
+Processing OLE events required a polling loop before, e.g.
+
+ my $Quit;
+ #...
+ until ($Quit) {
+ Win32::OLE->SpinMessageLoop;
+ Win32::Sleep(100);
+ }
+ package BrowserEvents;
+ sub OnQuit { $Quit = 1 }
+
+This is inefficient and a bit odd. This version of Win32::OLE now
+supports a standard messageloop:
+
+ Win32::OLE->MessageLoop();
+
+ package BrowserEvents;
+ sub OnQuit { Win32::OLE->QuitMessageLoop }
+
+=head2 Free unused OLE libraries
+
+Previous versions of Win32::OLE would call the CoFreeUnusedLibraries()
+API whenever an OLE object was destroyed. This made sure that OLE
+libraries would be unloaded as soon as they were no longer needed.
+Unfortunately, objects implemented in Visual Basic tend to crash
+during this call, as they pretend to be ready for unloading, when in
+fact, they aren't.
+
+The unloading of object libraries is really only important for long
+running processes that might instantiate a huge number of B<different>
+objects over time. Therefore this API is no longer called
+automatically. The functionality is now available explicitly to those
+who want or need it by calling a Win32::OLE class method:
+
+ Win32::OLE->FreeUnusedLibraries();
+
+=head2 The "Win32::OLE" article from "The Perl Journal #10"
+
+The article is Copyright 1998 by I<The Perl
+Journal>. http://www.tpj.com
+
+It originally appeared in I<The Perl Journal> # 10 and appears here
+courtesy of Jon Orwant and I<The Perl Journal>. The sample code from
+the article is in the F<eg/tpj.pl> file.
+
+=head2 VARIANT->Put() bug fixes
+
+The Put() method didn't work correctly for arrays of type VT_BSTR,
+VT_DISPATH or VT_UNKNOWN. This has been fixed.
+
+=head2 Error message fixes
+
+Previous versions of Win32::OLE gave a wrong argument index for some
+OLE error messages (the number was too large by 1). This should be
+fixed now.
+
+=head2 VT_DATE and VT_ERROR return values handled differently
+
+Method calls and property accesses returning a VT_DATE or VT_ERROR
+value would previously translate the value to string or integer
+format. This has been changed to return a Win32::OLE::Variant object.
+The return values will behave as before if the Win32::OLE::Variant
+module is being used. This module overloads the conversion of
+the objects to strings and numbers.
+
+
+=head1 Version 0.11 (changes since 0.1008)
+
+=head2 new DHTML typelib browser
+
+The Win32::OLE distribution now contains a type library browser. It
+is written in PerlScript, generating dynamic HTML. It requires
+Internet Explorer 4.0 or later. You'll find it in
+F<browser/Browser.html>. It should be available in the ActivePerl
+HTML help under Win32::OLE::Browser.
+
+After selecting a library, type or member you can press F1 to call up
+the corresponding help file at the appropriate location.
+
+=head2 VT_DECIMAL support
+
+The Win32::OLE::Variant module now supports VT_DECIMAL variants too.
+They are not "officially" allowed in OLE Automation calls, but even
+Microsoft's "ActiveX Data Objects" sometimes returns VT_DECIMAL
+values.
+
+VT_DECIMAL variables are stored as 96-bit integers scaled by a
+variable power of 10. The power of 10 scaling factor specifies the
+number of digits to the right of the decimal point, and ranges from 0
+to 28. With a scale of 0 (no decimal places), the largest possible
+value is +/-79,228,162,514,264,337,593,543,950,335. With a 28 decimal
+places, the largest value is +/-7.9228162514264337593543950335 and the
+smallest, non-zero value is +/-0.0000000000000000000000000001.
+
+=head1 Version 0.1008
+
+=head2 new LetProperty() object method
+
+In Win32::OLE property assignment using the hash syntax is equivalent
+to the Visual Basic C<Set> syntax (I<by reference> assignment):
+
+ $Object->{Property} = $OtherObject;
+
+corresponds to this Visual Basic statement:
+
+ Set Object.Property = OtherObject
+
+To get the I<by value> treatment of the Visual Basic C<Let> statement
+
+ Object.Property = OtherObject
+
+you have to use the LetProperty() object method in Perl:
+
+ $Object->LetProperty($Property, $OtherObject);
+
+=head2 new HRESULT() function
+
+The HRESULT() function converts an unsigned number into a signed HRESULT
+error value as used by OLE internally. This is necessary because Perl
+treats all hexadecimal constants as unsigned. To check if the last OLE
+function returned "Member not found" (0x80020003) you can write:
+
+ if (Win32::OLE->LastError == HRESULT(0x80020003)) {
+ # your error recovery here
+ }
+
+=head1 Version 0.1007 (changes since 0.1005)
+
+=head2 OLE Event support
+
+This version of Win32::OLE contains B<ALPHA> level support for OLE events. The
+user interface is still subject to change. There are ActiveX objects / controls
+that don't fire events under the current implementation.
+
+Events are enabled for a specific object with the Win32::OLE->WithEvents()
+class method:
+
+ Win32::OLE->WithEvents(OBJECT, HANDLER, INTERFACE)
+
+Please read further documentation in Win32::OLE.
+
+=head2 GetObject() and GetActiveObject() now support optional DESTRUCTOR argument
+
+It is now possible to specify a DESTRUCTOR argument to the GetObject() and
+GetActiveObject() class methods. They work identical to the new() DESTRUCTOR
+argument.
+
+=head2 Remote object instantiation via DCOM
+
+This has actually been in Win32::OLE since 0.0608, but somehow never got
+documented. You can provide an array reference in place of the usual PROGID
+parameter to Win32::OLE->new():
+
+ OBJ = Win32::OLE->new([MACHINE, PRODID]);
+
+The array must contain two elements: the name of the MACHINE and the PROGID.
+This will try to create the object on the remote MACHINE.
+
+=head2 Enumerate all Win32::OLE objects
+
+This class method returns the number Win32::OLE objects currently in
+existence. It will call the optional CALLBACK function for each of
+these objects:
+
+ $Count = Win32::OLE->EnumAllObjects(sub {
+ my $Object = shift;
+ my $Class = Win32::OLE->QueryObjectType($Object);
+ printf "# Object=%s Class=%s\n", $Object, $Class;
+ });
+
+The EnumAllObjects() method is primarily a debugging tool. It can be
+used e.g. in an END block to check if all external connections have
+been properly destroyed.
+
+=head2 The VARIANT->Put() method now returns the VARIANT object itself
+
+This allows chaining of Put() method calls to set multiple values in an
+array variant:
+
+ $Array->Put(0,0,$First_value)->Put(0,1,$Another_value);
+
+=head2 The VARIANT->Put(ARRAYREF) form allows assignment to a complete SAFEARRAY
+
+This allows automatic conversion from a list of lists to a SAFEARRAY.
+You can now write:
+
+ my $Array = Variant(VT_ARRAY|VT_R8, [1,2], 2);
+ $Array->Put([[1,2], [3,4]]);
+
+instead of the tedious:
+
+ $Array->Put(1,0,1);
+ $Array->Put(1,1,2);
+ $Array->Put(2,0,3);
+ $Array->Put(2,1,4);
+
+=head2 New Variant formatting methods
+
+There are four new methods for formatting variant values: Currency(), Date(),
+Number() and Time(). For example:
+
+ my $v = Variant(VT_DATE, "April 1 99");
+ print $v->Date(DATE_LONGDATE), "\n";
+ print $v->Date("ddd',' MMM dd yy"), "\n";
+
+will print:
+
+ Thursday, April 01, 1999
+ Thu, Apr 01 99
+
+=head2 new Win32::OLE::NLS methods: SendSettingChange() and SetLocaleInfo()
+
+SendSettingChange() sends a WM_SETTINGCHANGE message to all top level windows.
+
+SetLocaleInfo() allows changing elements in the user override section of the
+locale database. Unfortunately these changes are not automatically available
+to further Variant formatting; you have to call SendSettingChange() first.
+
+=head2 Win32::OLE::Const now correctly treats version numbers as hex
+
+The minor and major version numbers of type libraries have been treated as
+decimal. This was wrong. They are now correctly decoded as hex.
+
+=head2 more robust global destruction of Win32::OLE objects
+
+The final destruction of Win32::OLE objects has always been somewhat fragile.
+The reason for this is that Perl doesn't honour reference counts during global
+destruction but destroys objects in seemingly random order. This can lead
+to leaked database connections or unterminated external objects. The only
+solution was to make all objects lexical and hope that no object would be
+trapped in a closure. Alternatively all objects could be explicitly set to
+C<undef>, which doesn't work very well with exception handling.
+
+With version 0.1007 of Win32::OLE this problem should be gone: The module
+keeps a list of active Win32::OLE objects. It uses an END block to destroy
+all objects at program termination I<before> the Perl's global destruction
+starts. Objects still existing at program termination are now destroyed in
+reverse order of creation. The effect is similar to explicitly calling
+Win32::OLE->Uninitialize() just prior to termination.
+
+=head1 Version 0.1005 (changes since 0.1003)
+
+Win32::OLE 0.1005 has been release with ActivePerl build 509. It is also
+included in the I<Perl Resource Kit for Win32> Update.
+
+=head2 optional DESTRUCTOR for GetActiveObject() GetObject() class methods
+
+The GetActiveObject() and GetObject() class method now also support an
+optional DESTRUCTOR parameter just like Win32::OLE->new(). The DESTRUCTOR
+is executed when the last reference to this object goes away. It is
+generally considered C<impolite> to stop applications that you did not
+start yourself.
+
+=head2 new Variant object method: $object->Copy()
+
+See L<Win32::OLE::Variant/Copy([DIM])>.
+
+=head2 new Win32::OLE->Option() class method
+
+The Option() class method can be used to inspect and modify
+L<Win32::OLE/Module Options>. The single argument form retrieves
+the value of an option:
+
+ my $CP = Win32::OLE->Option('CP');
+
+A single call can be used to set multiple options simultaneously:
+
+ Win32::OLE->Option(CP => CP_ACP, Warn => 3);
+
+Currently the following options exist: CP, LCID and C<Warn>.
+
+=cut
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NEWS.pod
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NLS.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NLS.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NLS.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,968 @@
+# The documentation is at the __END__
+
+package Win32::OLE::NLS;
+require Win32::OLE; # Make sure the XS bootstrap has been called
+
+use strict;
+use vars qw(@EXPORT @EXPORT_OK %EXPORT_TAGS @ISA);
+
+use Exporter;
+ at ISA = qw(Exporter);
+
+ at EXPORT = qw(
+ CompareString
+ LCMapString
+ GetLocaleInfo
+ GetStringType
+ GetSystemDefaultLangID
+ GetSystemDefaultLCID
+ GetUserDefaultLangID
+ GetUserDefaultLCID
+
+ MAKELANGID
+ PRIMARYLANGID
+ SUBLANGID
+ LANG_SYSTEM_DEFAULT
+ LANG_USER_DEFAULT
+ MAKELCID
+ LANGIDFROMLCID
+ LOCALE_SYSTEM_DEFAULT
+ LOCALE_USER_DEFAULT
+ );
+
+ at EXPORT_OK = qw(SetLocaleInfo SendSettingChange);
+
+%EXPORT_TAGS =
+(
+ CT => [qw(CT_CTYPE1 CT_CTYPE2 CT_CTYPE3)],
+ C1 => [qw(C1_UPPER C1_LOWER C1_DIGIT C1_SPACE C1_PUNCT
+ C1_CNTRL C1_BLANK C1_XDIGIT C1_ALPHA)],
+ C2 => [qw(C2_LEFTTORIGHT C2_RIGHTTOLEFT C2_EUROPENUMBER
+ C2_EUROPESEPARATOR C2_EUROPETERMINATOR C2_ARABICNUMBER
+ C2_COMMONSEPARATOR C2_BLOCKSEPARATOR C2_SEGMENTSEPARATOR
+ C2_WHITESPACE C2_OTHERNEUTRAL C2_NOTAPPLICABLE)],
+ C3 => [qw(C3_NONSPACING C3_DIACRITIC C3_VOWELMARK C3_SYMBOL C3_KATAKANA
+ C3_HIRAGANA C3_HALFWIDTH C3_FULLWIDTH C3_IDEOGRAPH C3_KASHIDA
+ C3_ALPHA C3_NOTAPPLICABLE)],
+ NORM => [qw(NORM_IGNORECASE NORM_IGNORENONSPACE NORM_IGNORESYMBOLS
+ NORM_IGNOREWIDTH NORM_IGNOREKANATYPE NORM_IGNOREKASHIDA)],
+ LCMAP => [qw(LCMAP_LOWERCASE LCMAP_UPPERCASE LCMAP_SORTKEY LCMAP_HALFWIDTH
+ LCMAP_FULLWIDTH LCMAP_HIRAGANA LCMAP_KATAKANA)],
+ LANG => [qw(LANG_NEUTRAL LANG_ALBANIAN LANG_ARABIC LANG_BAHASA
+ LANG_BULGARIAN LANG_CATALAN LANG_CHINESE LANG_CZECH LANG_DANISH
+ LANG_DUTCH LANG_ENGLISH LANG_FINNISH LANG_FRENCH LANG_GERMAN
+ LANG_GREEK LANG_HEBREW LANG_HUNGARIAN LANG_ICELANDIC
+ LANG_ITALIAN LANG_JAPANESE LANG_KOREAN LANG_NORWEGIAN
+ LANG_POLISH LANG_PORTUGUESE LANG_RHAETO_ROMAN LANG_ROMANIAN
+ LANG_RUSSIAN LANG_SERBO_CROATIAN LANG_SLOVAK LANG_SPANISH
+ LANG_SWEDISH LANG_THAI LANG_TURKISH LANG_URDU)],
+ SUBLANG => [qw(SUBLANG_NEUTRAL SUBLANG_DEFAULT SUBLANG_SYS_DEFAULT
+ SUBLANG_CHINESE_SIMPLIFIED SUBLANG_CHINESE_TRADITIONAL
+ SUBLANG_DUTCH SUBLANG_DUTCH_BELGIAN SUBLANG_ENGLISH_US
+ SUBLANG_ENGLISH_UK SUBLANG_ENGLISH_AUS SUBLANG_ENGLISH_CAN
+ SUBLANG_ENGLISH_NZ SUBLANG_ENGLISH_EIRE SUBLANG_FRENCH
+ SUBLANG_FRENCH_BELGIAN SUBLANG_FRENCH_CANADIAN
+ SUBLANG_FRENCH_SWISS SUBLANG_GERMAN SUBLANG_GERMAN_SWISS
+ SUBLANG_GERMAN_AUSTRIAN SUBLANG_ITALIAN SUBLANG_ITALIAN_SWISS
+ SUBLANG_NORWEGIAN_BOKMAL SUBLANG_NORWEGIAN_NYNORSK
+ SUBLANG_PORTUGUESE SUBLANG_PORTUGUESE_BRAZILIAN
+ SUBLANG_SERBO_CROATIAN_CYRILLIC SUBLANG_SERBO_CROATIAN_LATIN
+ SUBLANG_SPANISH SUBLANG_SPANISH_MEXICAN
+ SUBLANG_SPANISH_MODERN)],
+ CTRY => [qw(CTRY_DEFAULT CTRY_AUSTRALIA CTRY_AUSTRIA CTRY_BELGIUM
+ CTRY_BRAZIL CTRY_CANADA CTRY_DENMARK CTRY_FINLAND CTRY_FRANCE
+ CTRY_GERMANY CTRY_ICELAND CTRY_IRELAND CTRY_ITALY CTRY_JAPAN
+ CTRY_MEXICO CTRY_NETHERLANDS CTRY_NEW_ZEALAND CTRY_NORWAY
+ CTRY_PORTUGAL CTRY_PRCHINA CTRY_SOUTH_KOREA CTRY_SPAIN
+ CTRY_SWEDEN CTRY_SWITZERLAND CTRY_TAIWAN CTRY_UNITED_KINGDOM
+ CTRY_UNITED_STATES)],
+ LOCALE => [qw(LOCALE_NOUSEROVERRIDE LOCALE_ILANGUAGE LOCALE_SLANGUAGE
+ LOCALE_SENGLANGUAGE LOCALE_SABBREVLANGNAME
+ LOCALE_SNATIVELANGNAME LOCALE_ICOUNTRY LOCALE_SCOUNTRY
+ LOCALE_SENGCOUNTRY LOCALE_SABBREVCTRYNAME LOCALE_SNATIVECTRYNAME
+ LOCALE_IDEFAULTLANGUAGE LOCALE_IDEFAULTCOUNTRY
+ LOCALE_IDEFAULTCODEPAGE LOCALE_IDEFAULTANSICODEPAGE LOCALE_SLIST
+ LOCALE_IMEASURE LOCALE_SDECIMAL LOCALE_STHOUSAND
+ LOCALE_SGROUPING LOCALE_IDIGITS LOCALE_ILZERO LOCALE_INEGNUMBER
+ LOCALE_SNATIVEDIGITS LOCALE_SCURRENCY LOCALE_SINTLSYMBOL
+ LOCALE_SMONDECIMALSEP LOCALE_SMONTHOUSANDSEP LOCALE_SMONGROUPING
+ LOCALE_ICURRDIGITS LOCALE_IINTLCURRDIGITS LOCALE_ICURRENCY
+ LOCALE_INEGCURR LOCALE_SDATE LOCALE_STIME LOCALE_SSHORTDATE
+ LOCALE_SLONGDATE LOCALE_STIMEFORMAT LOCALE_IDATE LOCALE_ILDATE
+ LOCALE_ITIME LOCALE_ITIMEMARKPOSN LOCALE_ICENTURY LOCALE_ITLZERO
+ LOCALE_IDAYLZERO LOCALE_IMONLZERO LOCALE_S1159 LOCALE_S2359
+ LOCALE_ICALENDARTYPE LOCALE_IOPTIONALCALENDAR
+ LOCALE_IFIRSTDAYOFWEEK LOCALE_IFIRSTWEEKOFYEAR LOCALE_SDAYNAME1
+ LOCALE_SDAYNAME2 LOCALE_SDAYNAME3 LOCALE_SDAYNAME4
+ LOCALE_SDAYNAME5 LOCALE_SDAYNAME6 LOCALE_SDAYNAME7
+ LOCALE_SABBREVDAYNAME1 LOCALE_SABBREVDAYNAME2
+ LOCALE_SABBREVDAYNAME3 LOCALE_SABBREVDAYNAME4
+ LOCALE_SABBREVDAYNAME5 LOCALE_SABBREVDAYNAME6
+ LOCALE_SABBREVDAYNAME7 LOCALE_SMONTHNAME1 LOCALE_SMONTHNAME2
+ LOCALE_SMONTHNAME3 LOCALE_SMONTHNAME4 LOCALE_SMONTHNAME5
+ LOCALE_SMONTHNAME6 LOCALE_SMONTHNAME7 LOCALE_SMONTHNAME8
+ LOCALE_SMONTHNAME9 LOCALE_SMONTHNAME10 LOCALE_SMONTHNAME11
+ LOCALE_SMONTHNAME12 LOCALE_SMONTHNAME13 LOCALE_SABBREVMONTHNAME1
+ LOCALE_SABBREVMONTHNAME2 LOCALE_SABBREVMONTHNAME3
+ LOCALE_SABBREVMONTHNAME4 LOCALE_SABBREVMONTHNAME5
+ LOCALE_SABBREVMONTHNAME6 LOCALE_SABBREVMONTHNAME7
+ LOCALE_SABBREVMONTHNAME8 LOCALE_SABBREVMONTHNAME9
+ LOCALE_SABBREVMONTHNAME10 LOCALE_SABBREVMONTHNAME11
+ LOCALE_SABBREVMONTHNAME12 LOCALE_SABBREVMONTHNAME13
+ LOCALE_SPOSITIVESIGN LOCALE_SNEGATIVESIGN LOCALE_IPOSSIGNPOSN
+ LOCALE_INEGSIGNPOSN LOCALE_IPOSSYMPRECEDES LOCALE_IPOSSEPBYSPACE
+ LOCALE_INEGSYMPRECEDES LOCALE_INEGSEPBYSPACE)],
+ TIME => [qw(TIME_NOMINUTESORSECONDS TIME_NOSECONDS TIME_NOTIMEMARKER
+ TIME_FORCE24HOURFORMAT)],
+ DATE => [qw(DATE_SHORTDATE DATE_LONGDATE DATE_USE_ALT_CALENDAR
+ DATE_YEARMONTH DATE_LTRREADING DATE_RTLREADING)],
+);
+
+foreach my $tag (keys %EXPORT_TAGS) {
+ push @EXPORT_OK, @{$EXPORT_TAGS{$tag}};
+}
+
+# Character Type Flags
+sub CT_CTYPE1 { 0x0001 }
+sub CT_CTYPE2 { 0x0002 }
+sub CT_CTYPE3 { 0x0004 }
+
+# Character Type 1 Bits
+sub C1_UPPER { 0x0001 }
+sub C1_LOWER { 0x0002 }
+sub C1_DIGIT { 0x0004 }
+sub C1_SPACE { 0x0008 }
+sub C1_PUNCT { 0x0010 }
+sub C1_CNTRL { 0x0020 }
+sub C1_BLANK { 0x0040 }
+sub C1_XDIGIT { 0x0080 }
+sub C1_ALPHA { 0x0100 }
+
+# Character Type 2 Bits
+sub C2_LEFTTORIGHT { 0x1 }
+sub C2_RIGHTTOLEFT { 0x2 }
+sub C2_EUROPENUMBER { 0x3 }
+sub C2_EUROPESEPARATOR { 0x4 }
+sub C2_EUROPETERMINATOR { 0x5 }
+sub C2_ARABICNUMBER { 0x6 }
+sub C2_COMMONSEPARATOR { 0x7 }
+sub C2_BLOCKSEPARATOR { 0x8 }
+sub C2_SEGMENTSEPARATOR { 0x9 }
+sub C2_WHITESPACE { 0xA }
+sub C2_OTHERNEUTRAL { 0xB }
+sub C2_NOTAPPLICABLE { 0x0 }
+
+# Character Type 3 Bits
+sub C3_NONSPACING { 0x0001 }
+sub C3_DIACRITIC { 0x0002 }
+sub C3_VOWELMARK { 0x0004 }
+sub C3_SYMBOL { 0x0008 }
+sub C3_KATAKANA { 0x0010 }
+sub C3_HIRAGANA { 0x0020 }
+sub C3_HALFWIDTH { 0x0040 }
+sub C3_FULLWIDTH { 0x0080 }
+sub C3_IDEOGRAPH { 0x0100 }
+sub C3_KASHIDA { 0x0200 }
+sub C3_ALPHA { 0x8000 }
+sub C3_NOTAPPLICABLE { 0x0 }
+
+# String Flags
+sub NORM_IGNORECASE { 0x0001 }
+sub NORM_IGNORENONSPACE { 0x0002 }
+sub NORM_IGNORESYMBOLS { 0x0004 }
+sub NORM_IGNOREWIDTH { 0x0008 }
+sub NORM_IGNOREKANATYPE { 0x0040 }
+sub NORM_IGNOREKASHIDA { 0x40000}
+
+# Locale Dependent Mapping Flags
+sub LCMAP_LOWERCASE { 0x0100 }
+sub LCMAP_UPPERCASE { 0x0200 }
+sub LCMAP_SORTKEY { 0x0400 }
+sub LCMAP_HALFWIDTH { 0x0800 }
+sub LCMAP_FULLWIDTH { 0x1000 }
+sub LCMAP_HIRAGANA { 0x2000 }
+sub LCMAP_KATAKANA { 0x4000 }
+
+# Primary Language Identifier
+sub LANG_NEUTRAL { 0x00 }
+sub LANG_ALBANIAN { 0x1c }
+sub LANG_ARABIC { 0x01 }
+sub LANG_BAHASA { 0x21 }
+sub LANG_BULGARIAN { 0x02 }
+sub LANG_CATALAN { 0x03 }
+sub LANG_CHINESE { 0x04 }
+sub LANG_CZECH { 0x05 }
+sub LANG_DANISH { 0x06 }
+sub LANG_DUTCH { 0x13 }
+sub LANG_ENGLISH { 0x09 }
+sub LANG_FINNISH { 0x0b }
+sub LANG_FRENCH { 0x0c }
+sub LANG_GERMAN { 0x07 }
+sub LANG_GREEK { 0x08 }
+sub LANG_HEBREW { 0x0d }
+sub LANG_HUNGARIAN { 0x0e }
+sub LANG_ICELANDIC { 0x0f }
+sub LANG_ITALIAN { 0x10 }
+sub LANG_JAPANESE { 0x11 }
+sub LANG_KOREAN { 0x12 }
+sub LANG_NORWEGIAN { 0x14 }
+sub LANG_POLISH { 0x15 }
+sub LANG_PORTUGUESE { 0x16 }
+sub LANG_RHAETO_ROMAN { 0x17 }
+sub LANG_ROMANIAN { 0x18 }
+sub LANG_RUSSIAN { 0x19 }
+sub LANG_SERBO_CROATIAN { 0x1a }
+sub LANG_SLOVAK { 0x1b }
+sub LANG_SPANISH { 0x0a }
+sub LANG_SWEDISH { 0x1d }
+sub LANG_THAI { 0x1e }
+sub LANG_TURKISH { 0x1f }
+sub LANG_URDU { 0x20 }
+
+# Sublanguage Identifier
+sub SUBLANG_NEUTRAL { 0x00 }
+sub SUBLANG_DEFAULT { 0x01 }
+sub SUBLANG_SYS_DEFAULT { 0x02 }
+sub SUBLANG_CHINESE_SIMPLIFIED { 0x02 }
+sub SUBLANG_CHINESE_TRADITIONAL { 0x01 }
+sub SUBLANG_DUTCH { 0x01 }
+sub SUBLANG_DUTCH_BELGIAN { 0x02 }
+sub SUBLANG_ENGLISH_US { 0x01 }
+sub SUBLANG_ENGLISH_UK { 0x02 }
+sub SUBLANG_ENGLISH_AUS { 0x03 }
+sub SUBLANG_ENGLISH_CAN { 0x04 }
+sub SUBLANG_ENGLISH_NZ { 0x05 }
+sub SUBLANG_ENGLISH_EIRE { 0x06 }
+sub SUBLANG_FRENCH { 0x01 }
+sub SUBLANG_FRENCH_BELGIAN { 0x02 }
+sub SUBLANG_FRENCH_CANADIAN { 0x03 }
+sub SUBLANG_FRENCH_SWISS { 0x04 }
+sub SUBLANG_GERMAN { 0x01 }
+sub SUBLANG_GERMAN_SWISS { 0x02 }
+sub SUBLANG_GERMAN_AUSTRIAN { 0x03 }
+sub SUBLANG_ITALIAN { 0x01 }
+sub SUBLANG_ITALIAN_SWISS { 0x02 }
+sub SUBLANG_NORWEGIAN_BOKMAL { 0x01 }
+sub SUBLANG_NORWEGIAN_NYNORSK { 0x02 }
+sub SUBLANG_PORTUGUESE { 0x02 }
+sub SUBLANG_PORTUGUESE_BRAZILIAN { 0x01 }
+sub SUBLANG_SERBO_CROATIAN_CYRILLIC { 0x02 }
+sub SUBLANG_SERBO_CROATIAN_LATIN { 0x01 }
+sub SUBLANG_SPANISH { 0x01 }
+sub SUBLANG_SPANISH_MEXICAN { 0x02 }
+sub SUBLANG_SPANISH_MODERN { 0x03 }
+
+# Country codes
+sub CTRY_DEFAULT { 0 }
+sub CTRY_AUSTRALIA { 61 }
+sub CTRY_AUSTRIA { 43 }
+sub CTRY_BELGIUM { 32 }
+sub CTRY_BRAZIL { 55 }
+sub CTRY_CANADA { 2 }
+sub CTRY_DENMARK { 45 }
+sub CTRY_FINLAND { 358 }
+sub CTRY_FRANCE { 33 }
+sub CTRY_GERMANY { 49 }
+sub CTRY_ICELAND { 354 }
+sub CTRY_IRELAND { 353 }
+sub CTRY_ITALY { 39 }
+sub CTRY_JAPAN { 81 }
+sub CTRY_MEXICO { 52 }
+sub CTRY_NETHERLANDS { 31 }
+sub CTRY_NEW_ZEALAND { 64 }
+sub CTRY_NORWAY { 47 }
+sub CTRY_PORTUGAL { 351 }
+sub CTRY_PRCHINA { 86 }
+sub CTRY_SOUTH_KOREA { 82 }
+sub CTRY_SPAIN { 34 }
+sub CTRY_SWEDEN { 46 }
+sub CTRY_SWITZERLAND { 41 }
+sub CTRY_TAIWAN { 886 }
+sub CTRY_UNITED_KINGDOM { 44 }
+sub CTRY_UNITED_STATES { 1 }
+
+# Locale Types
+sub LOCALE_NOUSEROVERRIDE { 0x80000000 }
+sub LOCALE_ILANGUAGE { 0x0001 }
+sub LOCALE_SLANGUAGE { 0x0002 }
+sub LOCALE_SENGLANGUAGE { 0x1001 }
+sub LOCALE_SABBREVLANGNAME { 0x0003 }
+sub LOCALE_SNATIVELANGNAME { 0x0004 }
+sub LOCALE_ICOUNTRY { 0x0005 }
+sub LOCALE_SCOUNTRY { 0x0006 }
+sub LOCALE_SENGCOUNTRY { 0x1002 }
+sub LOCALE_SABBREVCTRYNAME { 0x0007 }
+sub LOCALE_SNATIVECTRYNAME { 0x0008 }
+sub LOCALE_IDEFAULTLANGUAGE { 0x0009 }
+sub LOCALE_IDEFAULTCOUNTRY { 0x000A }
+sub LOCALE_IDEFAULTCODEPAGE { 0x000B }
+sub LOCALE_IDEFAULTANSICODEPAGE { 0x1004 }
+sub LOCALE_SLIST { 0x000C }
+sub LOCALE_IMEASURE { 0x000D }
+sub LOCALE_SDECIMAL { 0x000E }
+sub LOCALE_STHOUSAND { 0x000F }
+sub LOCALE_SGROUPING { 0x0010 }
+sub LOCALE_IDIGITS { 0x0011 }
+sub LOCALE_ILZERO { 0x0012 }
+sub LOCALE_INEGNUMBER { 0x1010 }
+sub LOCALE_SNATIVEDIGITS { 0x0013 }
+sub LOCALE_SCURRENCY { 0x0014 }
+sub LOCALE_SINTLSYMBOL { 0x0015 }
+sub LOCALE_SMONDECIMALSEP { 0x0016 }
+sub LOCALE_SMONTHOUSANDSEP { 0x0017 }
+sub LOCALE_SMONGROUPING { 0x0018 }
+sub LOCALE_ICURRDIGITS { 0x0019 }
+sub LOCALE_IINTLCURRDIGITS { 0x001A }
+sub LOCALE_ICURRENCY { 0x001B }
+sub LOCALE_INEGCURR { 0x001C }
+sub LOCALE_SDATE { 0x001D }
+sub LOCALE_STIME { 0x001E }
+sub LOCALE_SSHORTDATE { 0x001F }
+sub LOCALE_SLONGDATE { 0x0020 }
+sub LOCALE_STIMEFORMAT { 0x1003 }
+sub LOCALE_IDATE { 0x0021 }
+sub LOCALE_ILDATE { 0x0022 }
+sub LOCALE_ITIME { 0x0023 }
+sub LOCALE_ITIMEMARKPOSN { 0x1005 }
+sub LOCALE_ICENTURY { 0x0024 }
+sub LOCALE_ITLZERO { 0x0025 }
+sub LOCALE_IDAYLZERO { 0x0026 }
+sub LOCALE_IMONLZERO { 0x0027 }
+sub LOCALE_S1159 { 0x0028 }
+sub LOCALE_S2359 { 0x0029 }
+sub LOCALE_ICALENDARTYPE { 0x1009 }
+sub LOCALE_IOPTIONALCALENDAR { 0x100B }
+sub LOCALE_IFIRSTDAYOFWEEK { 0x100C }
+sub LOCALE_IFIRSTWEEKOFYEAR { 0x100D }
+sub LOCALE_SDAYNAME1 { 0x002A }
+sub LOCALE_SDAYNAME2 { 0x002B }
+sub LOCALE_SDAYNAME3 { 0x002C }
+sub LOCALE_SDAYNAME4 { 0x002D }
+sub LOCALE_SDAYNAME5 { 0x002E }
+sub LOCALE_SDAYNAME6 { 0x002F }
+sub LOCALE_SDAYNAME7 { 0x0030 }
+sub LOCALE_SABBREVDAYNAME1 { 0x0031 }
+sub LOCALE_SABBREVDAYNAME2 { 0x0032 }
+sub LOCALE_SABBREVDAYNAME3 { 0x0033 }
+sub LOCALE_SABBREVDAYNAME4 { 0x0034 }
+sub LOCALE_SABBREVDAYNAME5 { 0x0035 }
+sub LOCALE_SABBREVDAYNAME6 { 0x0036 }
+sub LOCALE_SABBREVDAYNAME7 { 0x0037 }
+sub LOCALE_SMONTHNAME1 { 0x0038 }
+sub LOCALE_SMONTHNAME2 { 0x0039 }
+sub LOCALE_SMONTHNAME3 { 0x003A }
+sub LOCALE_SMONTHNAME4 { 0x003B }
+sub LOCALE_SMONTHNAME5 { 0x003C }
+sub LOCALE_SMONTHNAME6 { 0x003D }
+sub LOCALE_SMONTHNAME7 { 0x003E }
+sub LOCALE_SMONTHNAME8 { 0x003F }
+sub LOCALE_SMONTHNAME9 { 0x0040 }
+sub LOCALE_SMONTHNAME10 { 0x0041 }
+sub LOCALE_SMONTHNAME11 { 0x0042 }
+sub LOCALE_SMONTHNAME12 { 0x0043 }
+sub LOCALE_SMONTHNAME13 { 0x100E }
+sub LOCALE_SABBREVMONTHNAME1 { 0x0044 }
+sub LOCALE_SABBREVMONTHNAME2 { 0x0045 }
+sub LOCALE_SABBREVMONTHNAME3 { 0x0046 }
+sub LOCALE_SABBREVMONTHNAME4 { 0x0047 }
+sub LOCALE_SABBREVMONTHNAME5 { 0x0048 }
+sub LOCALE_SABBREVMONTHNAME6 { 0x0049 }
+sub LOCALE_SABBREVMONTHNAME7 { 0x004A }
+sub LOCALE_SABBREVMONTHNAME8 { 0x004B }
+sub LOCALE_SABBREVMONTHNAME9 { 0x004C }
+sub LOCALE_SABBREVMONTHNAME10 { 0x004D }
+sub LOCALE_SABBREVMONTHNAME11 { 0x004E }
+sub LOCALE_SABBREVMONTHNAME12 { 0x004F }
+sub LOCALE_SABBREVMONTHNAME13 { 0x100F }
+sub LOCALE_SPOSITIVESIGN { 0x0050 }
+sub LOCALE_SNEGATIVESIGN { 0x0051 }
+sub LOCALE_IPOSSIGNPOSN { 0x0052 }
+sub LOCALE_INEGSIGNPOSN { 0x0053 }
+sub LOCALE_IPOSSYMPRECEDES { 0x0054 }
+sub LOCALE_IPOSSEPBYSPACE { 0x0055 }
+sub LOCALE_INEGSYMPRECEDES { 0x0056 }
+sub LOCALE_INEGSEPBYSPACE { 0x0057 }
+
+# GetTimeFormat Flags
+sub TIME_NOMINUTESORSECONDS { 0x0001 }
+sub TIME_NOSECONDS { 0x0002 }
+sub TIME_NOTIMEMARKER { 0x0004 }
+sub TIME_FORCE24HOURFORMAT { 0x0008 }
+
+# GetDateFormat Flags
+sub DATE_SHORTDATE { 0x0001 }
+sub DATE_LONGDATE { 0x0002 }
+sub DATE_USE_ALT_CALENDAR { 0x0004 }
+sub DATE_YEARMONTH { 0x0008 }
+sub DATE_LTRREADING { 0x0010 }
+sub DATE_RTLREADING { 0x0020 }
+
+# Language Identifier Functions
+sub MAKELANGID { my ($p,$s) = @_; (($s & 0xffff) << 10) | ($p & 0xffff); }
+sub PRIMARYLANGID { my $lgid = shift; $lgid & 0x3ff; }
+sub SUBLANGID { my $lgid = shift; ($lgid >> 10) & 0x3f; }
+
+sub LANG_SYSTEM_DEFAULT { MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT); }
+sub LANG_USER_DEFAULT { MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT); }
+
+# Locale Identifier Functions
+sub MAKELCID { my $lgid = shift; $lgid & 0xffff; }
+sub LANGIDFROMLCID { my $lcid = shift; $lcid & 0xffff; }
+
+sub LOCALE_SYSTEM_DEFAULT { MAKELCID(LANG_SYSTEM_DEFAULT); }
+sub LOCALE_USER_DEFAULT { MAKELCID(LANG_USER_DEFAULT); }
+
+1;
+
+__END__
+
+=head1 NAME
+
+Win32::OLE::NLS - OLE National Language Support
+
+=head1 SYNOPSIS
+
+ missing
+
+=head1 DESCRIPTION
+
+This module provides access to the national language support features
+in the F<OLENLS.DLL>.
+
+=head2 Functions
+
+=over 8
+
+=item CompareString(LCID,FLAGS,STR1,STR2)
+
+Compare STR1 and STR2 in the LCID locale. FLAGS indicate the character
+traits to be used or ignored when comparing the two strings.
+
+ NORM_IGNORECASE Ignore case
+ NORM_IGNOREKANATYPE Ignore hiragana/katakana character differences
+ NORM_IGNORENONSPACE Ignore accents, diacritics, and vowel marks
+ NORM_IGNORESYMBOLS Ignore symbols
+ NORM_IGNOREWIDTH Ignore character width
+
+Possible return values are:
+
+ 0 Function failed
+ 1 STR1 is less than STR2
+ 2 STR1 is equal to STR2
+ 3 STR1 is greater than STR2
+
+Note that you can subtract 2 from the return code to get values
+comparable to the C<cmp> operator.
+
+=item LCMapString(LCID,FLAGS,STR)
+
+LCMapString translates STR using LCID dependent translation.
+Flags contains a combination of the following options:
+
+ LCMAP_LOWERCASE Lowercase
+ LCMAP_UPPERCASE Uppercase
+ LCMAP_HALFWIDTH Narrow characters
+ LCMAP_FULLWIDTH Wide characters
+ LCMAP_HIRAGANA Hiragana
+ LCMAP_KATAKANA Katakana
+ LCMAP_SORTKEY Character sort key
+
+The following normalization options can be combined with C<LCMAP_SORTKEY>:
+
+ NORM_IGNORECASE Ignore case
+ NORM_IGNOREKANATYPE Ignore hiragana/katakana character differences
+ NORM_IGNORENONSPACE Ignore accents, diacritics, and vowel marks
+ NORM_IGNORESYMBOLS Ignore symbols
+ NORM_IGNOREWIDTH Ignore character width
+
+The return value is the translated string.
+
+=item GetLocaleInfo(LCID,LCTYPE)
+
+Retrieve locale setting LCTYPE from the locale specified by LCID. Use
+LOCALE_NOUSEROVERRIDE | LCTYPE to always query the locale database.
+Otherwise user changes to C<win.ini> through the windows control panel
+take precedence when retrieving values for the system default locale.
+See the documentation below for a list of valid LCTYPE values.
+
+The return value is the contents of the requested locale setting.
+
+=item GetStringType(LCID,TYPE,STR)
+
+Retrieve type information from locale LCID about each character in STR.
+The requested TYPE can be one of the following 3 levels:
+
+ CT_CTYPE1 ANSI C and POSIX type information
+ CT_CTYPE2 Text layout type information
+ CT_CTYPE3 Text processing type information
+
+The return value is a list of values, each of wich is a bitwise OR of
+the applicable type bits from the corresponding table below:
+
+ @ct = GetStringType(LOCALE_SYSTEM_DEFAULT, CT_CTYPE1, "String");
+
+ANSI C and POSIX character type information:
+
+ C1_UPPER Uppercase
+ C1_LOWER Lowercase
+ C1_DIGIT Decimal digits
+ C1_SPACE Space characters
+ C1_PUNCT Punctuation
+ C1_CNTRL Control characters
+ C1_BLANK Blank characters
+ C1_XDIGIT Hexadecimal digits
+ C1_ALPHA Any letter
+
+Text layout type information:
+
+ C2_LEFTTORIGHT Left to right
+ C2_RIGHTTOLEFT Right to left
+ C2_EUROPENUMBER European number, European digit
+ C2_EUROPESEPARATOR European numeric separator
+ C2_EUROPETERMINATOR European numeric terminator
+ C2_ARABICNUMBER Arabic number
+ C2_COMMONSEPARATOR Common numeric separator
+ C2_BLOCKSEPARATOR Block separator
+ C2_SEGMENTSEPARATOR Segment separator
+ C2_WHITESPACE White space
+ C2_OTHERNEUTRAL Other neutrals
+ C2_NOTAPPLICABLE No implicit direction (e.g. ctrl codes)
+
+Text precessing type information:
+
+ C3_NONSPACING Nonspacing mark
+ C3_DIACRITIC Diacritic nonspacing mark
+ C3_VOWELMARK Vowel nonspacing mark
+ C3_SYMBOL Symbol
+ C3_KATAKANA Katakana character
+ C3_HIRAGANA Hiragana character
+ C3_HALFWIDTH Narrow character
+ C3_FULLWIDTH Wide character
+ C3_IDEOGRAPH Ideograph
+ C3_ALPHA Any letter
+ C3_NOTAPPLICABLE Not applicable
+
+
+=item GetSystemDefaultLangID()
+
+Returns the system default language identifier.
+
+=item GetSystemDefaultLCID()
+
+Returns the system default locale identifier.
+
+=item GetUserDefaultLangID()
+
+Returns the user default language identifier.
+
+=item GetUserDefaultLCID()
+
+Returns the user default locale identifier.
+
+=item SendSettingChange()
+
+Sends a WM_SETTINGCHANGE message to all top level windows.
+
+=item SetLocaleInfo(LCID, LCTYPE, LCDATA)
+
+Changes an item in the user override part of the locale setting LCID.
+It doesn't change the system default database. The following LCTYPEs are
+changeable:
+
+ LOCALE_ICALENDARTYPE LOCALE_SDATE
+ LOCALE_ICURRDIGITS LOCALE_SDECIMAL
+ LOCALE_ICURRENCY LOCALE_SGROUPING
+ LOCALE_IDIGITS LOCALE_SLIST
+ LOCALE_IFIRSTDAYOFWEEK LOCALE_SLONGDATE
+ LOCALE_IFIRSTWEEKOFYEAR LOCALE_SMONDECIMALSEP
+ LOCALE_ILZERO LOCALE_SMONGROUPING
+ LOCALE_IMEASURE LOCALE_SMONTHOUSANDSEP
+ LOCALE_INEGCURR LOCALE_SNEGATIVESIGN
+ LOCALE_INEGNUMBER LOCALE_SPOSITIVESIGN
+ LOCALE_IPAPERSIZE LOCALE_SSHORTDATE
+ LOCALE_ITIME LOCALE_STHOUSAND
+ LOCALE_S1159 LOCALE_STIME
+ LOCALE_S2359 LOCALE_STIMEFORMAT
+ LOCALE_SCURRENCY LOCALE_SYEARMONTH
+
+You have to call SendSettingChange() to activate these changes for
+subsequent Win32::OLE::Variant object formatting because the OLE
+subsystem seems to cache locale information.
+
+=item MAKELANGID(LANG,SUBLANG)
+
+Creates a language identifier from a primary language and a sublanguage.
+
+=item PRIMARYLANGID(LANGID)
+
+Retrieves the primary language from a language identifier.
+
+=item SUBLANGID(LANGID)
+
+Retrieves the sublanguage from a language identifier.
+
+=item MAKELCID(LANGID)
+
+Creates a locale identifies from a language identifier.
+
+=item LANGIDFROMLCID(LCID)
+
+Retrieves a language identifier from a locale identifier.
+
+=back
+
+=head2 Locale Types
+
+=over 8
+
+=item LOCALE_ILANGUAGE
+
+The language identifier (in hex).
+
+=item LOCALE_SLANGUAGE
+
+The localized name of the language.
+
+=item LOCALE_SENGLANGUAGE
+
+The ISO Standard 639 English name of the language.
+
+=item LOCALE_SABBREVLANGNAME
+
+The three-letter abbreviated name of the language. The first two
+letters are from the ISO Standard 639 language name abbreviation. The
+third letter indicates the sublanguage type.
+
+=item LOCALE_SNATIVELANGNAME
+
+The native name of the language.
+
+=item LOCALE_ICOUNTRY
+
+The country code, which is based on international phone codes.
+
+=item LOCALE_SCOUNTRY
+
+The localized name of the country.
+
+=item LOCALE_SENGCOUNTRY
+
+The English name of the country.
+
+=item LOCALE_SABBREVCTRYNAME
+
+The ISO Standard 3166 abbreviated name of the country.
+
+=item LOCALE_SNATIVECTRYNAME
+
+The native name of the country.
+
+=item LOCALE_IDEFAULTLANGUAGE
+
+Language identifier for the principal language spoken in this
+locale.
+
+=item LOCALE_IDEFAULTCOUNTRY
+
+Country code for the principal country in this locale.
+
+=item LOCALE_IDEFAULTANSICODEPAGE
+
+The ANSI code page associated with this locale. Format: 4 Unicode
+decimal digits plus a Unicode null terminator.
+
+XXX This should be translated by GetLocaleInfo. XXX
+
+=item LOCALE_IDEFAULTCODEPAGE
+
+The OEM code page associated with the country.
+
+=item LOCALE_SLIST
+
+Characters used to separate list items (often a comma).
+
+=item LOCALE_IMEASURE
+
+Default measurement system:
+
+ 0 metric system (S.I.)
+ 1 U.S. system
+
+=item LOCALE_SDECIMAL
+
+Characters used for the decimal separator (often a dot).
+
+=item LOCALE_STHOUSAND
+
+Characters used as the separator between groups of digits left of the decimal.
+
+=item LOCALE_SGROUPING
+
+Sizes for each group of digits to the left of the decimal. An explicit
+size is required for each group. Sizes are separated by semicolons. If
+the last value is 0, the preceding value is repeated. To group
+thousands, specify 3;0.
+
+=item LOCALE_IDIGITS
+
+The number of fractional digits.
+
+=item LOCALE_ILZERO
+
+Whether to use leading zeros in decimal fields. A setting of 0
+means use no leading zeros; 1 means use leading zeros.
+
+=item LOCALE_SNATIVEDIGITS
+
+The ten characters that are the native equivalent of the ASCII 0-9.
+
+=item LOCALE_INEGNUMBER
+
+Negative number mode.
+
+ 0 (1.1)
+ 1 -1.1
+ 2 -1.1
+ 3 1.1
+ 4 1.1
+
+=item LOCALE_SCURRENCY
+
+The string used as the local monetary symbol.
+
+=item LOCALE_SINTLSYMBOL
+
+Three characters of the International monetary symbol specified in ISO
+4217, Codes for the Representation of Currencies and Funds, followed
+by the character separating this string from the amount.
+
+=item LOCALE_SMONDECIMALSEP
+
+Characters used for the monetary decimal separators.
+
+=item LOCALE_SMONTHOUSANDSEP
+
+Characters used as monetary separator between groups of digits left of
+the decimal.
+
+=item LOCALE_SMONGROUPING
+
+Sizes for each group of monetary digits to the left of the decimal. An
+explicit size is needed for each group. Sizes are separated by
+semicolons. If the last value is 0, the preceding value is
+repeated. To group thousands, specify 3;0.
+
+=item LOCALE_ICURRDIGITS
+
+Number of fractional digits for the local monetary format.
+
+=item LOCALE_IINTLCURRDIGITS
+
+Number of fractional digits for the international monetary format.
+
+=item LOCALE_ICURRENCY
+
+Positive currency mode.
+
+ 0 Prefix, no separation.
+ 1 Suffix, no separation.
+ 2 Prefix, 1-character separation.
+ 3 Suffix, 1-character separation.
+
+=item LOCALE_INEGCURR
+
+Negative currency mode.
+
+ 0 ($1.1)
+ 1 -$1.1
+ 2 $-1.1
+ 3 $1.1-
+ 4 $(1.1$)
+ 5 -1.1$
+ 6 1.1-$
+ 7 1.1$-
+ 8 -1.1 $ (space before $)
+ 9 -$ 1.1 (space after $)
+ 10 1.1 $- (space before $)
+
+=item LOCALE_ICALENDARTYPE
+
+The type of calendar currently in use.
+
+ 1 Gregorian (as in U.S.)
+ 2 Gregorian (always English strings)
+ 3 Era: Year of the Emperor (Japan)
+ 4 Era: Year of the Republic of China
+ 5 Tangun Era (Korea)
+
+=item LOCALE_IOPTIONALCALENDAR
+
+The additional calendar types available for this LCID. Can be a
+null-separated list of all valid optional calendars. Value is
+0 for "None available" or any of the LOCALE_ICALENDARTYPE settings.
+
+XXX null separated list should be translated by GetLocaleInfo XXX
+
+=item LOCALE_SDATE
+
+Characters used for the date separator.
+
+=item LOCALE_STIME
+
+Characters used for the time separator.
+
+=item LOCALE_STIMEFORMAT
+
+Time-formatting string.
+
+=item LOCALE_SSHORTDATE
+
+Short Date_Time formatting strings for this locale.
+
+=item LOCALE_SLONGDATE
+
+Long Date_Time formatting strings for this locale.
+
+=item LOCALE_IDATE
+
+Short Date format-ordering specifier.
+
+ 0 Month - Day - Year
+ 1 Day - Month - Year
+ 2 Year - Month - Day
+
+=item LOCALE_ILDATE
+
+Long Date format ordering specifier. Value can be any of the valid
+LOCALE_IDATE settings.
+
+=item LOCALE_ITIME
+
+Time format specifier.
+
+ 0 AM/PM 12-hour format.
+ 1 24-hour format.
+
+=item LOCALE_ITIMEMARKPOSN
+
+Whether the time marker string (AM|PM) precedes or follows the time
+string.
+ 0 Suffix (9:15 AM).
+ 1 Prefix (AM 9:15).
+
+=item LOCALE_ICENTURY
+
+Whether to use full 4-digit century.
+
+ 0 Two digit.
+ 1 Full century.
+
+=item LOCALE_ITLZERO
+
+Whether to use leading zeros in time fields.
+
+ 0 No leading zeros.
+ 1 Leading zeros for hours.
+
+=item LOCALE_IDAYLZERO
+
+Whether to use leading zeros in day fields. Values as for
+LOCALE_ITLZERO.
+
+=item LOCALE_IMONLZERO
+
+Whether to use leading zeros in month fields. Values as for
+LOCALE_ITLZERO.
+
+=item LOCALE_S1159
+
+String for the AM designator.
+
+=item LOCALE_S2359
+
+String for the PM designator.
+
+=item LOCALE_IFIRSTWEEKOFYEAR
+
+Specifies which week of the year is considered first.
+
+ 0 Week containing 1/1 is the first week of the year.
+ 1 First full week following 1/1is the first week of the year.
+ 2 First week with at least 4 days is the first week of the year.
+
+=item LOCALE_IFIRSTDAYOFWEEK
+
+Specifies the day considered first in the week. Value "0" means
+SDAYNAME1 and value "6" means SDAYNAME7.
+
+=item LOCALE_SDAYNAME1 .. LOCALE_SDAYNAME7
+
+Long name for Monday .. Sunday.
+
+=item LOCALE_SABBREVDAYNAME1 .. LOCALE_SABBREVDAYNAME7
+
+Abbreviated name for Monday .. Sunday.
+
+=item LOCALE_SMONTHNAME1 .. LOCALE_SMONTHNAME12
+
+Long name for January .. December.
+
+=item LOCALE_SMONTHNAME13
+
+Native name for 13th month, if it exists.
+
+=item LOCALE_SABBREVMONTHNAME1 .. LOCALE_SABBREVMONTHNAME12
+
+Abbreviated name for January .. December.
+
+=item LOCALE_SABBREVMONTHNAME13
+
+Native abbreviated name for 13th month, if it exists.
+
+=item LOCALE_SPOSITIVESIGN
+
+String value for the positive sign.
+
+=item LOCALE_SNEGATIVESIGN
+
+String value for the negative sign.
+
+=item LOCALE_IPOSSIGNPOSN
+
+Formatting index for positive values.
+
+ 0 Parentheses surround the amount and the monetary symbol.
+ 1 The sign string precedes the amount and the monetary symbol.
+ 2 The sign string precedes the amount and the monetary symbol.
+ 3 The sign string precedes the amount and the monetary symbol.
+ 4 The sign string precedes the amount and the monetary symbol.
+
+=item LOCALE_INEGSIGNPOSN
+
+Formatting index for negative values. Values as for LOCALE_IPOSSIGNPOSN.
+
+=item LOCALE_IPOSSYMPRECEDES
+
+If the monetary symbol precedes, 1. If it succeeds a positive amount, 0.
+
+=item LOCALE_IPOSSEPBYSPACE
+
+If the monetary symbol is separated by a space from a positive amount,
+1. Otherwise, 0.
+
+=item LOCALE_INEGSYMPRECEDES
+
+If the monetary symbol precedes, 1. If it succeeds a negative amount, 0.
+
+=item LOCALE_INEGSEPBYSPACE
+
+If the monetary symbol is separated by a space from a negative amount,
+1. Otherwise, 0.
+
+=back
+
+=head1 AUTHORS/COPYRIGHT
+
+This module is part of the Win32::OLE distribution.
+
+=cut
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/NLS.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TPJ.pod
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TPJ.pod (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TPJ.pod 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,798 @@
+=pod
+
+=head1 NAME
+
+The Perl Journal #10 - Win32::OLE by Jan Dubois
+
+=head1 INTRODUCTION
+
+Suppose you're composing a document with Microsoft Word. You want to
+include an Excel spreadsheet. You could save the spreadsheet in some
+image format that Word can understand, and import it into your
+document. But if the spreadsheet changes, your document will be out of
+date.
+
+Microsoft's OLE (Object Linking and Embedding, pronounced "olay") lets
+one program use objects from another. In the above scenario, the
+spreadsheet is the object. As long as Excel makes that spreadsheet
+available as an OLE object, and Word knows to treat it like one, your
+document will always be current.
+
+You can control OLE objects from Perl with the Win32::OLE module, and
+that's what this article is about. First, I'll show you how to "think
+OLE," which mostly involves a lot of jargon. Next, I'll show you the
+mechanics involved in using Win32::OLE. Then we'll go through a Perl
+program that uses OLE to manipulate Microsoft Excel, Microsoft Access,
+and Lotus Notes. Finally, I'll talk about Variants, an internal OLE
+data type.
+
+
+=head1 THE OLE MINDSET
+
+When an application makes an OLE object available for other
+applications to use, that's called OLE I<automation>. The program
+using the object is called the I<controller>, and the application
+providing the object is called the I<server>. OLE automation is guided
+by the OLE Component Object Model (COM) which specifies how those
+objects must behave if they are to be used by other processes and
+machines.
+
+There are two different types of OLE automation servers. I<In-process>
+servers are implemented as dynamic link libraries (DLLs) and run in
+the same process space as the controller. I<Out-of-process> servers
+are more interesting; they are standalone executables that exist as
+separate processes - possibly on a different computer.
+
+The Win32::OLE module lets your Perl program act as an OLE
+controller. It allows Perl to be used in place of other languages like
+Visual Basic or Java to control OLE objects. This makes all OLE
+automation servers immediately available as Perl modules.
+
+Don't confuse ActiveState OLE with Win32::OLE. ActiveState OLE is
+completely different, although future builds of ActiveState Perl (500
+and up) will work with Win32::OLE.
+
+Objects can expose OLE methods, properties, and events to the outside
+world. Methods are functions that the controller can call to make the
+object do something; properties describe the state of the object; and
+events let the controller know about external events affecting the
+object, such as the user clicking on a button. Since events involve
+asynchronous communication with their objects, they require either
+threads or an event loop. They are not yet supported by the Win32::OLE
+module, and for the same reason ActiveX controls (OCXs) are currently
+unsupported as well.
+
+=head1 WORKING WITH WIN32::OLE
+
+The Win32::OLE module doesn't let your Perl program create OLE
+objects. What it does do is let your Perl program act like a remote
+control for other applications-it lets your program be an OLE
+controller. You can take an OLE object from another application
+(Access, Notes, Excel, or anything else that speaks OLE) and invoke
+its methods or manipulate its properties.
+
+=head2 THE FIRST STEP: CREATING AN OLE SERVER OBJECT
+
+First, we need to create a Perl object to represent the OLE
+server. This is a weird idea; what it amounts to is that if we want to
+control OLE objects produced by, say, Excel, we have to create a Perl
+object that represents Excel. So even though our program is an OLE
+controller, it'll contain objects that represent OLE servers.
+
+You can create a new OLE I<server object> with C<< Win32::OLE->new >>.
+This takes a program ID (a human readable string like
+C<'Speech.VoiceText'>) and returns a server object:
+
+ my $server = Win32::OLE->new('Excel.Application', 'Quit');
+
+Some server objects (particularly those for Microsoft Office
+applications) don't automatically terminate when your program no
+longer needs them. They need some kind of Quit method, and that's just
+what our second argument is. It can be either a code reference or a
+method name to be invoked when the object is destroyed. This lets you
+ensure that objects will be properly cleaned up even when the Perl
+program dies abnormally.
+
+To access a server object on a different computer, replace the first
+argument with a reference to a list of the server name and program ID:
+
+ my $server = Win32::OLE->new(['foo.bar.com',
+ 'Excel.Application']);
+
+(To get the requisite permissions, you'll need to configure your
+security settings with F<DCOMCNFG.EXE>.)
+
+You can also directly attach your program to an already running OLE
+server:
+
+ my $server = Win32::OLE->GetActiveObject('Excel.Application');
+
+This fails (returning C<undef>) if no server exists, or if the server
+refuses the connection for some reason. It is also possible to use a
+persistent object moniker (usually a filename) to start the associated
+server and load the object into memory:
+
+ my $doc = Win32::OLE->GetObject("MyDocument.Doc");
+
+=head2 METHOD CALLS
+
+Once you've created one of these server objects, you need to call its
+methods to make the OLE objects sing and dance. OLE methods are
+invoked just like normal Perl object methods:
+
+ $server->Foo(@Arguments);
+
+This is a Perl method call - but it also triggers an OLE method call
+in the object. After your program executes this statement, the
+C<$server> object will execute its Foo() method. The available methods
+are typically documented in the application's I<object model>.
+
+B<Parameters.> By default, all parameters are positional
+(e.g. C<foo($first, $second, $third)>) rather than named (e.g.
+C<< foo(-name => "Yogi", -title => "Coach") >>). The required parameters
+come first, followed by the optional parameters; if you need to
+provide a dummy value for an optional parameter, use undef.
+
+Positional parameters get cumbersome if a method takes a lot of
+them. You can use named arguments instead if you go to a little extra
+trouble - when the last argument is a reference to a hash, the
+key/value pairs of the hash are treated as named parameters:
+
+ $server->Foo($Pos1, $Pos2, {Name1 => $Value1,
+ Name2 => $Value2});
+
+B<Foreign Languages and Default Methods.> Sometimes OLE servers use
+method and property names that are specific to a non-English
+locale. That means they might have non-ASCII characters, which aren't
+allowed in Perl variable names. In German, you might see C<\xD6ffnen> used
+instead of C<Open>. In these cases, you can use the Invoke() method:
+
+ $server->Invoke('\xD6ffnen', @Arguments);
+
+This is necessary because C<< $Server->\xD6ffnen(@Arguments) >> is a syntax
+error in current versions of Perl.
+
+=head2 PROPERTIES
+
+As I said earlier, objects can expose three things to the outside
+world: methods, properties, and events. We've covered methods, and
+Win32::OLE can't handle events. That leaves properties. But as it
+turns out, properties and events are largely interchangeable. Most
+methods have corresponding properties, and vice versa.
+
+An object's properties can be accessed with a hash reference:
+
+ $server->{Bar} = $value;
+ $value = $server->{Bar};
+
+This example sets and queries the value of the property named
+C<Bar>. You could also have called the object's Bar() method to
+achieve the same effect:
+
+ $value = $server->Bar;
+
+However, you can't write the first line as C<< $server->Bar = $value >>,
+because you can't assign to the return value of a method call. In
+Visual Basic, OLE automation distinguishes between assigning the name
+of an object and assigning its value:
+
+ Set Object = OtherObject
+
+ Let Value = Object
+
+The C<Set> statement shown here makes C<Object> refer to the same object as
+C<OtherObject>. The C<Let> statement copies the value instead. (The value of
+an OLE object is what you get when you call the object's default
+method.
+
+In Perl, saying C<< $server1 = $server2 >> always creates another reference,
+just like the C<Set> in Visual Basic. If you want to assign the value
+instead, use the valof() function:
+
+ my $value = valof $server;
+
+This is equivalent to
+
+ my $value = $server->Invoke('');
+
+=head2 SAMPLE APPLICATION
+
+Let's look at how all of this might be used. In Listing: 1 you'll see
+F<T-Bond.pl>, a program that uses Win32::OLE for an almost-real world
+application.
+
+The developer of this application, Mary Lynch, is a financial futures
+broker. Every afternoon, she connects to the Chicago Board of Trade
+(CBoT) web site at http://www.cbot.com and collects the time and sales
+information for U.S. T-bond futures. She wants her program to create a
+chart that depicts the data in 15-minute intervals, and then she wants
+to record the data in a database for later analysis. Then she wants
+her program to send mail to her clients.
+
+Mary's program will use Microsoft Access as a database, Microsoft
+Excel to produce the chart, and Lotus Notes to send the mail. It will
+all be controlled from a single Perl program using OLE automation. In
+this section, we'll go through T-Bond. pl step by step so you can see
+how Win32::OLE lets you control these applications.
+
+=head2 DOWNLOADING A WEB PAGE WITH LWP
+
+However, Mary first needs to amass the raw T-bond data by having her
+Perl program automatically download and parse a web page. That's the
+perfect job for LWP, the libwww-perl bundle available on the CPAN. LWP
+has nothing to do with OLE. But this is a real-world application, and
+it's just what Mary needs to download her data from the Chicago Board
+of Trade.
+
+ use LWP::Simple;
+ my $URL = 'http://www.cbot.com/mplex/quotes/tsfut';
+ my $text = get("$URL/tsf$Contract.htm");
+
+She could also have used the Win32::Internet module:
+
+ use Win32::Internet;
+ my $URL = 'http://www.cbot.com/mplex/quotes/tsfut';
+ my $text = $Win32::Internet->new->FetchURL("$URL/tsf$Contract.htm");
+
+Mary wants to condense the ticker data into 15 minute bars. She's
+interested only in lines that look like this:
+
+ 03/12/1998 US 98Mar 12116 15:28:34 Open
+
+A regular expression can be used to determine whether a line looks
+like this. If it does, the regex can split it up into individual
+fields. The price quoted above, C<12116>, really means 121 16/32, and
+needs to be converted to 121.5. The data is then condensed into 15
+minute intervals and only the first, last, highest, and lowest price
+during each interval are kept. The time series is stored in the array
+C<@Bars>. Each entry in C<@Bars> is a reference to a list of 5 elements:
+Time, Open, High, Low, and Close.
+
+ foreach (split "\n", $text) {
+ # 03/12/1998 US 98Mar 12116 15:28:34 Open
+ my ($Date,$Price,$Hour,$Min,$Sec,$Ind) =
+ m|^\s*(\d+/\d+/\d+) # " 03/12/1998"
+ \s+US\s+\S+\s+(\d+) # " US 98Mar 12116"
+ \s+(\d+):(\d+):(\d+) # " 12:42:40"
+ \s*(.*)$|x; # " Ask"
+ next unless defined $Date;
+ $Day = $Date;
+
+ # Convert from fractional to decimal format
+ $Price = int($Price/100) + ($Price%100)/32;
+
+ # Round up time to next multiple of 15 minutes
+ my $NewTime = int(($Sec+$Min*60+$Hour*3600)/900+1)*900;
+ unless (defined $Time && $NewTime == $Time) {
+ push @Bars, [$hhmm, $Open, $High, $Low, $Close]
+ if defined $Time;
+ $Open = $High = $Low = $Close = undef;
+ $Time = $NewTime;
+ my $Hour = int($Time/3600);
+ $hhmm = sprintf "%02d:%02d", $Hour, $Time/60-$Hour*60;
+ }
+
+ # Update 15 minute bar values
+ $Close = $Price;
+ $Open = $Price unless defined $Open;
+ $High = $Price unless defined $High && $High > $Price;
+ $Low = $Price unless defined $Low && $Low > $Price;
+ }
+
+ die "No data found" unless defined $Time;
+ push @Bars, [$hhmm, $Open, $High, $Low, $Close];
+
+=head2 MICROSOFT ACCESS
+
+Now that Mary has her T-bond quotes, she's ready to use Win32::OLE to
+store them into a Microsoft Access database. This has the advantage
+that she can copy the database to her lap-top and work with it on her
+long New York commute. She's able to create an Access database as
+follows:
+
+ use Win32::ODBC;
+ use Win32::OLE;
+
+ # Include the constants for the Microsoft Access
+ # "Data Access Object".
+
+ use Win32::OLE::Const 'Microsoft DAO';
+
+ my $DSN = 'T-Bonds';
+ my $Driver = 'Microsoft Access Driver (*.mdb)';
+ my $Desc = 'US T-Bond Quotes';
+ my $Dir = 'i:\tmp\tpj';
+ my $File = 'T-Bonds.mdb';
+ my $Fullname = "$Dir\\$File";
+
+ # Remove old database and dataset name
+ unlink $Fullname if -f $Fullname;
+ Win32::ODBC::ConfigDSN(ODBC_REMOVE_DSN, $Driver, "DSN=$DSN")
+ if Win32::ODBC::DataSources($DSN);
+
+ # Create new database
+ my $Access = Win32::OLE->new('Access.Application', 'Quit');
+ my $Workspace = $Access->DBEngine->CreateWorkspace('', 'Admin', '');
+ my $Database = $Workspace->CreateDatabase($Fullname, dbLangGeneral);
+
+ # Add new database name
+ Win32::ODBC::ConfigDSN(ODBC_ADD_DSN, $Driver,
+ "DSN=$DSN", "Description=$Desc", "DBQ=$Fullname",
+ "DEFAULTDIR=$Dir", "UID=", "PWD=");
+
+This uses Win32::ODBC (described in TPJ #9) to remove and create
+F<T-Bonds.mdb>. This lets Mary use the same script on her workstation
+and on her laptop even when the database is stored in different
+locations on each. The program also uses Win32::OLE to make Microsoft
+Access create an empty database.
+
+Every OLE server has some constants that your Perl program will need
+to use, made accessible by the Win32::OLE::Const module. For instance,
+to grab the Excel constants, say C<use Win32::OLE::Const 'Microsoft
+Excel'>.
+
+In the above example, we imported the Data Access Object con-stants
+just so we could use C<dbLangGeneral>.
+
+=head2 MICROSOFT EXCEL
+
+Now Mary uses Win32::OLE a second time, to have Microsoft Excel create
+the chart shown below.
+
+ Figure 1: T-Bond data generated by MicroSoft Excel via Win32::OLE
+
+ # Start Excel and create new workbook with a single sheet
+ use Win32::OLE qw(in valof with);
+ use Win32::OLE::Const 'Microsoft Excel';
+ use Win32::OLE::NLS qw(:DEFAULT :LANG :SUBLANG);
+
+ my $lgid = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
+ $Win32::OLE::LCID = MAKELCID($lgid);
+
+ $Win32::OLE::Warn = 3;
+
+Here, Mary sets the locale to American English, which lets her do
+things like use American date formats (e.g. C<"12-30-98"> rather than
+C<"30-12-98">) in her program. It will continue to work even when she's
+visiting one of her international customers and has to run this
+program on their computers.
+
+The value of C<$Win32::OLE::Warn> determines what happens when an OLE
+error occurs. If it's 0, the error is ignored. If it's 2, or if it's 1
+and the script is running under C<-w>, the Win32::OLE module invokes
+C<Carp::carp()>. If C<$Win32::OLE::Warn> is set to 3, C<Carp::croak()>
+is invoked and the program dies immediately.
+
+Now the data can be put into an Excel spreadsheet to produce the
+chart. The following section of the program launches Excel and creates
+a new workbook with a single worksheet. It puts the column titles
+('Time', 'Open', 'High', 'Low', and 'Close') in a bold font on the
+first row of the sheet. The first column displays the timestamp in
+I<hh:mm> format; the next four display prices.
+
+ my $Excel = Win32::OLE->new('Excel.Application', 'Quit');
+ $Excel->{SheetsInNewWorkbook} = 1;
+ my $Book = $Excel->Workbooks->Add;
+ my $Sheet = $Book->Worksheets(1);
+ $Sheet->{Name} = 'Candle';
+
+ # Insert column titles
+ my $Range = $Sheet->Range("A1:E1");
+ $Range->{Value} = [qw(Time Open High Low Close)];
+ $Range->Font->{Bold} = 1;
+
+ $Sheet->Columns("A:A")->{NumberFormat} = "h:mm";
+ # Open/High/Low/Close to be displayed in 32nds
+ $Sheet->Columns("B:E")->{NumberFormat} = "# ?/32";
+
+ # Add 15 minute data to spreadsheet
+ print "Add data\n";
+ $Range = $Sheet->Range(sprintf "A2:E%d", 2+$#Bars);
+ $Range->{Value} = \@Bars;
+
+The last statement shows how to pass arrays to OLE objects. The
+Win32::OLE module automatically translates each array reference to a
+C<SAFEARRAY>, the internal OLE array data type. This translation first
+determines the maximum nesting level used by the Perl array, and then
+creates a C<SAFEARRAY> of the same dimension. The C<@Bars> array
+already contains the data in the correct form for the spreadsheet:
+
+ ([Time1, Open1, High1, Low1, Close1],
+ ...
+ [TimeN, OpenN, HighN, LowN, CloseN])
+
+Now the table in the spreadsheet can be used to create a candle stick
+chart from our bars. Excel automatically chooses the time axis labels
+if they are selected before the chart is created:
+
+ # Create candle stick chart as new object on worksheet
+ $Sheet->Range("A:E")->Select;
+
+ my $Chart = $Book->Charts->Add;
+ $Chart->{ChartType} = xlStockOHLC;
+ $Chart->Location(xlLocationAsObject, $Sheet->{Name});
+ # Excel bug: the old $Chart is now invalid!
+ $Chart = $Excel->ActiveChart;
+
+We can change the type of the chart from a separate sheet to a chart
+object on the spreadsheet page with the C<< $Chart->Location >>
+method. (This invalidates the chart object handle, which might be
+considered a bug in Excel.) Fortunately, this new chart is still the
+'active' chart, so an object handle to it can be reclaimed simply by
+asking Excel.
+
+At this point, our chart still needs a title, the legend is
+meaningless, and the axis has decimals instead of fractions. We can
+fix those with the following code:
+
+ # Add title, remove legend
+ with($Chart, HasLegend => 0, HasTitle => 1);
+ $Chart->ChartTitle->Characters->{Text} = "US T-Bond";
+
+ # Set up daily statistics
+ $Open = $Bars[0][1];
+ $High = $Sheet->Evaluate("MAX(C:C)");
+ $Low = $Sheet->Evaluate("MIN(D:D)");
+ $Close = $Bars[$#Bars][4];
+
+The with() function partially mimics the Visual Basic With statement,
+but allows only property assignments. It's a convenient shortcut for
+this:
+
+ { # open new scope
+ my $Axis = $Chart->Axes(xlValue);
+ $Axis->{HasMajorGridlines} = 1;
+ $Axis->{HasMinorGridlines} = 1;
+ # etc ...
+ }
+
+The C<$High> and C<$Low> for the day are needed to determine the
+minimum and maximum scaling levels. MIN and MAX are spreadsheet
+functions, and aren't automatically available as methods. However,
+Excel provides an Evaluate() method to calculate arbitrary spreadsheet
+functions, so we can use that.
+
+We want the chart to show major gridlines at every fourth tick and
+minor gridlines at every second tick. The minimum and maximum are
+chosen to be whatever multiples of 1/16 we need to do that.
+
+ # Change tickmark spacing from decimal to fractional
+ with($Chart->Axes(xlValue),
+ HasMajorGridlines => 1,
+ HasMinorGridlines => 1,
+ MajorUnit => 1/8,
+ MinorUnit => 1/16,
+ MinimumScale => int($Low*16)/16,
+ MaximumScale => int($High*16+1)/16
+ );
+
+ # Fat candles with only 5% gaps
+ $Chart->ChartGroups(1)->{GapWidth} = 5;
+
+ sub RGB { $_[0] | ($_[1] >> 8) | ($_[2] >> 16) }
+
+ # White background with a solid border
+
+ $Chart->PlotArea->Border->{LineStyle} = xlContinuous;
+ $Chart->PlotArea->Border->{Color} = RGB(0,0,0);
+ $Chart->PlotArea->Interior->{Color} = RGB(255,255,255);
+
+ # Add 1 hour moving average of the Close series
+ my $MovAvg = $Chart->SeriesCollection(4)->Trendlines
+ ->Add({Type => xlMovingAvg, Period => 4});
+ $MovAvg->Border->{Color} = RGB(255,0,0);
+
+Now the finished workbook can be saved to disk as
+F<i:\tmp\tpj\data.xls>. That file most likely still exists from when the
+program ran yesterday, so we'll remove it. (Otherwise, Excel would pop
+up a dialog with a warning, because the SaveAs() method doesn't like
+to overwrite files.)
+
+
+ # Save workbook to file my $Filename = 'i:\tmp\tpj\data.xls';
+ unlink $Filename if -f $Filename;
+ $Book->SaveAs($Filename);
+ $Book->Close;
+
+=head2 ACTIVEX DATA OBJECTS
+
+Mary stores the daily prices in her T-bonds database, keeping the data
+for the different contracts in separate tables. After creating an ADO
+(ActiveX Data Object) connection to the database, she tries to connect
+a record set to the table for the current contract. If this fails, she
+assumes that the table doesn't exists yet and tries to create it:
+
+ use Win32::OLE::Const 'Microsoft ActiveX Data Objects';
+
+ my $Connection = Win32::OLE->new('ADODB.Connection');
+ my $Recordset = Win32::OLE->new('ADODB.Recordset');
+ $Connection->Open('T-Bonds');
+
+ # Open a record set for the table of this contract
+ {
+ local $Win32::OLE::Warn = 0;
+ $Recordset->Open($Contract, $Connection, adOpenKeyset,
+ adLockOptimistic, adCmdTable);
+ }
+
+ # Create table and index if it doesn't exist yet
+ if (Win32::OLE->LastError) {
+ $Connection->Execute(<<"SQL");
+ CREATE TABLE $Contract
+ (
+ Day DATETIME,
+ Open DOUBLE, High DOUBLE, Low DOUBLE, Close DOUBLE
+ )
+ SQL
+ $Connection->Execute(<<"SQL");
+ CREATE INDEX $Contract
+ ON $Contract (Day) WITH PRIMARY
+ SQL
+ $Recordset->Open($Contract, $Connection, adOpenKeyset,
+ adLockOptimistic, adCmdTable);
+ }
+
+C<$Win32::OLE::Warn> is temporarily set to zero, so that if
+C<$Recordset->Open> fails, the failure will be recorded silently without
+terminating the program. C<Win32::OLE->LastError> shows whether the Open
+failed or not. C<LastError> returns the OLE error code in a numeric
+context and the OLE error message in a string context, just like
+Perl's C<$!> variable.
+
+Now Mary can add today's data:
+
+ # Add new record to table
+ use Win32::OLE::Variant;
+ $Win32::OLE::Variant::LCID = $Win32::OLE::LCID;
+
+ my $Fields = [qw(Day Open High Low Close)];
+ my $Values = [Variant(VT_DATE, $Day),
+ $Open, $High, $Low, $Close];
+
+Mary uses the Win32::OLE::Variant module to store C<$Day> as a date
+instead of a mere string. She wants to make sure that it's stored as
+an American-style date, so in the third line shown here she sets the
+locale ID of the Win32::OLE::Variant module to match the Win32::OLE
+module. (C<$Win32::OLE::LCID> had been set earlier to English, since
+that's what the Chicago Board of Trade uses.)
+
+ {
+ local $Win32::OLE::Warn = 0;
+ $Recordset->AddNew($Fields, $Values);
+ }
+
+ # Replace existing record
+ if (Win32::OLE->LastError) {
+ $Recordset->CancelUpdate;
+ $Recordset->Close;
+ $Recordset->Open(<<"SQL", $Connection, adOpenDynamic);
+ SELECT * FROM $Contract
+ WHERE Day = #$Day#
+ SQL
+ $Recordset->Update($Fields, $Values);
+ }
+
+ $Recordset->Close;
+ $Connection->Close;
+
+The program expects to be able to add a new record to the table. It
+fails if a record for this date already exists, because the Day field
+is the primary index and therefore must be unique. If an error occurs,
+the update operation started by AddNew() must first be cancelled with
+C<< $Recordset->CancelUpdate >>; otherwise the record set won't close.
+
+=head2 LOTUS NOTES
+
+Now Mary can use Lotus Notes to mail updates to all her customers
+interested in the T-bond data. (Lotus Notes doesn't provide its
+constants in the OLE type library, so Mary had to determine them by
+playing around with LotusScript.) The actual task is quite simple: A
+Notes session must be started, the mail database must be opened and
+the mail message must be created. The body of the message is created
+as a rich text field, which lets her mix formatted text with object
+attachments.
+
+In her program, Mary extracts the email addresses from her customer
+database and sends separate message to each. Here, we've simplified it
+somewhat.
+
+ sub EMBED_ATTACHMENT {1454;} # from LotusScript
+
+ my $Notes = Win32::OLE->new('Notes.NotesSession');
+ my $Database = $Notes->GetDatabase('', '');
+ $Database->OpenMail;
+ my $Document = $Database->CreateDocument;
+
+ $Document->{Form} = 'Memo';
+ $Document->{SendTo} = ['Jon Orwant >orwant at tpj.com>',
+ 'Jan Dubois >jan.dubois at ibm.net>'];
+ $Document->{Subject} = "US T-Bonds Chart for $Day";
+
+ my $Body = $Document->CreateRichtextItem('Body');
+ $Body->AppendText(<<"EOT");
+ I\'ve attached the latest US T-Bond data and chart for $Day.
+ The daily statistics were:
+
+ \tOpen\t$Open
+ \tHigh\t$High
+ \tLow\t$Low
+ \tClose\t$Close
+
+ Kind regards,
+
+ Mary
+ EOT
+
+ $Body->EmbedObject(EMBED_ATTACHMENT, '', $Filename);
+
+ $Document->Send(0);
+
+=head1 VARIANTS
+
+In this final section, I'll talk about Variants, which are the data
+types that you use to talk to OLE objects. We talked about this line
+earlier:
+
+ my $Values = [Variant(VT_DATE, $Day),
+ $Open, $High, $Low, $Close];
+
+Here, the Variant() function creates a Variant object, of type C<VT_DATE>
+and with the value C<$Day>. Variants are similar in many ways to Perl
+scalars. Arguments to OLE methods are transparently converted from
+their internal Perl representation to Variants and back again by the
+Win32::OLE module.
+
+OLE automation uses a generic C<VARIANT> data type to pass
+parameters. This data type contains type information in addition to
+the actual data value. Only the following data types are valid for OLE
+automation:
+
+ B<Data Type Meaning>
+ VT_EMPTY Not specified
+ VT_NULL Null
+ VT_I2 2 byte signed integer
+ VT_I4 4 byte signed integer
+ VT_R4 4 byte real
+ VT_R8 8 byte real
+ VT_CY Currency
+ VT_DATE Date
+ VT_BSTR Unicode string
+ VT_DISPATCH OLE automation interface
+ VT_ERROR Error
+ VT_BOOL Boolean
+ VT_VARIANT (only valid with VT_BYREF)
+ VT_UNKNOWN Generic COM interface
+ VT_UI1 Unsigned character
+
+The following two flags can also be used:
+
+ VT_ARRAY Array of values
+ VT_BYREF Pass by reference (instead of by value)
+
+B<The Perl to Variant transformation.> The following conversions are
+performed automatically whenever a Perl value must be translated into
+a Variant:
+
+ Perl value Variant
+ Integer values VT_I4
+ Real values VT_R8
+ Strings VT_BSTR
+ undef VT_ERROR (DISP_E_PARAMNOTFOUND)
+ Array reference VT_VARIANT | VT_ARRAY
+ Win32::OLE object VT_DISPATCH
+ Win32::OLE::Variant object Type of the Variant object
+
+What if your Perl value is a list of lists? Those can be irregularly
+shaped in Perl; that is, the subsidiary lists needn't have the same
+number of elements. In this case, the structure will be converted to a
+"rectangular" C<SAFEARRAY> of Variants, with unused slots set to
+C<VT_EMPTY>. Consider this Perl 2-D array:
+
+ [ ["Perl" ], # one element
+ [1, 3.1215, undef] # three elements
+ ]
+
+This will be translated to a 2 by 3 C<SAFEARRAY> that looks like this:
+
+ VT_BSTR("Perl") VT_EMPTY VT_EMPTY
+ VT_I4(1) VT_R8(3.1415) VT_ERROR(DISP_E_PARAMNOTFOUND)
+
+B<The Variant To Perl Transformation.> Automatic conversion from Variants
+to Perl values happens as follows:
+
+ Variant Perl value
+ VT_BOOL, VT_ERROR Integer
+ VT_UI1, VT_I2, VT_I4 Integer
+ VT_R4, VT_R8 Float value
+ VT_BSTR String
+ VT_DISPATCH Win32::OLE object
+
+B<The Win32::OLE::Variant module.> This module provides access to the
+Variant data type, which gives you more control over how these
+arguments to OLE methods are encoded. (This is rarely necessary if you
+have a good grasp of the default conversion rules.) A Variant object
+can be created with the C<< Win32::OLE::Variant->new >> method or the
+equivalent Variant() function:
+
+ use Win32::OLE::Variant;
+ my $var1 = Win32::OLE::Variant->new(VT_DATE, 'Jan 1,1970');
+ my $var2 = Variant(VT_BSTR, 'This is an Unicode string');
+
+Several methods let you inspect and manipulate Variant objects: The
+Type() and Value() methods return the variant type and value; the As()
+method returns the value after converting it to a different variant
+type; ChangeType() coerces the Variant into a different type; and
+Unicode() returns the value of a Variant object as an object of the
+Unicode::String class.
+
+These conversions are more interesting if they can be applied directly
+to the return value of an OLE method call without first mutilating the
+value with default conversions. This is possible with the following
+trick:
+
+ my $RetVal = Variant(VT_EMPTY, undef);
+ $Object->Dispatch($Method, $RetVal, @Arguments);
+
+Normally, you wouldn't call Dispatch() directly; it's executed
+implicitly by either AUTOLOAD() or Invoke(). If Dispatch() realizes
+that the return value is already a Win32::OLE::Variant object, the
+return value is not translated into a Perl representation but rather
+copied verbatim into the Variant object.
+
+Whenever a Win32::OLE::Variant object is used in a numeric or string
+context it is automatically converted into the corresponding format.
+
+ printf "Number: %f and String: %s\n",
+ $Var, $Var;
+
+This is equivalent to:
+
+ printf "Number: %f and String: %s\n",
+ $Var->As(VT_R8), $Var->As(VT_BSTR);
+
+For methods that modify their arguments, you need to use the C<VT_BYREF>
+flag. This lets you create number and string Variants that can be
+modified by OLE methods. Here, Corel's GetSize() method takes two
+integers and stores the C<x> and C<y> dimensions in them:
+
+ my $x = Variant( VT_I4 | VT_BYREF, 0);
+ my $y = Variant( VT_I4 | VT_BYREF, 0);
+ $Corel->GetSize($x, $y);
+
+C<VT_BYREF> support for other Variant types might appear in future
+releases of Win32::OLE.
+
+=head1 FURTHER INFORMATION
+
+=head2 DOCUMENTATION AND EXAMPLE CODE
+
+More information about the OLE modules can be found in the
+documentation bundled with Win32::OLE. The distribution also contains
+other code samples.
+
+The object model for Microsoft Office applications can be found in the
+Visual Basic Reference for Microsoft Access, Excel, Word, or
+PowerPoint. These help files are not installed by default, but they
+can be added later by rerunning F<setup.exe> and choosing I<custom
+setup>. The object model for Microsoft Outlook can be found on the
+Microsoft Office Developer Forum at:
+http://www.microsoft.com/OutlookDev/.
+
+Information about the LotusScript object model can be found at:
+http://www.lotus.com/products/lotusscript.nsf.
+
+=head2 OLE AUTOMATION ON OTHER PLATFORMS
+
+Microsoft also makes OLE technology available for the Mac. DCOM is
+already included in Windows NT 4.0 and can be downloaded for Windows
+95. MVS and some Unix systems can use EntireX to get OLE
+functionality; see
+http://www.softwareag.com/corporat/solutions/entirex/entirex.htm.
+
+=head1 COPYRIGHT
+
+Copyright 1998 I<The Perl Journal>. http://www.tpj.com
+
+This article originally appeared in I<The Perl Journal> #10. It
+appears courtesy of Jon Orwant and I<The Perl Journal>. This document
+may be distributed under the same terms as Perl itself.
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TPJ.pod
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TypeInfo.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TypeInfo.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TypeInfo.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,389 @@
+# This module is still experimental and intentionally undocumented.
+# If you don't know why it is here, then you should probably not use it.
+
+package Win32::OLE::TypeInfo;
+
+use strict;
+use vars qw(@ISA @EXPORT @EXPORT_OK);
+use vars qw(@VT %TYPEFLAGS @TYPEKIND %IMPLTYPEFLAGS %PARAMFLAGS
+ %FUNCFLAGS @CALLCONV @FUNCKIND %INVOKEKIND %VARFLAGS
+ %LIBFLAGS @SYSKIND);
+
+use Exporter;
+ at ISA = qw(Exporter);
+
+ at EXPORT = qw(
+ VT_EMPTY VT_NULL VT_I2 VT_I4 VT_R4 VT_R8 VT_CY VT_DATE
+ VT_BSTR VT_DISPATCH VT_ERROR VT_BOOL VT_VARIANT VT_UNKNOWN
+ VT_DECIMAL VT_I1 VT_UI1 VT_UI2 VT_UI4 VT_I8 VT_UI8 VT_INT
+ VT_UINT VT_VOID VT_HRESULT VT_PTR VT_SAFEARRAY VT_CARRAY
+ VT_USERDEFINED VT_LPSTR VT_LPWSTR VT_FILETIME VT_BLOB
+ VT_STREAM VT_STORAGE VT_STREAMED_OBJECT VT_STORED_OBJECT
+ VT_BLOB_OBJECT VT_CF VT_CLSID VT_VECTOR VT_ARRAY VT_BYREF
+ VT_RESERVED VT_ILLEGAL VT_ILLEGALMASKED VT_TYPEMASK
+
+ TYPEFLAG_FAPPOBJECT TYPEFLAG_FCANCREATE TYPEFLAG_FLICENSED
+ TYPEFLAG_FPREDECLID TYPEFLAG_FHIDDEN TYPEFLAG_FCONTROL
+ TYPEFLAG_FDUAL TYPEFLAG_FNONEXTENSIBLE TYPEFLAG_FOLEAUTOMATION
+ TYPEFLAG_FRESTRICTED TYPEFLAG_FAGGREGATABLE TYPEFLAG_FREPLACEABLE
+ TYPEFLAG_FDISPATCHABLE TYPEFLAG_FREVERSEBIND
+
+ TKIND_ENUM TKIND_RECORD TKIND_MODULE TKIND_INTERFACE TKIND_DISPATCH
+ TKIND_COCLASS TKIND_ALIAS TKIND_UNION TKIND_MAX
+
+ IMPLTYPEFLAG_FDEFAULT IMPLTYPEFLAG_FSOURCE IMPLTYPEFLAG_FRESTRICTED
+ IMPLTYPEFLAG_FDEFAULTVTABLE
+
+ PARAMFLAG_NONE PARAMFLAG_FIN PARAMFLAG_FOUT PARAMFLAG_FLCID
+ PARAMFLAG_FRETVAL PARAMFLAG_FOPT PARAMFLAG_FHASDEFAULT
+
+ FUNCFLAG_FRESTRICTED FUNCFLAG_FSOURCE FUNCFLAG_FBINDABLE
+ FUNCFLAG_FREQUESTEDIT FUNCFLAG_FDISPLAYBIND FUNCFLAG_FDEFAULTBIND
+ FUNCFLAG_FHIDDEN FUNCFLAG_FUSESGETLASTERROR FUNCFLAG_FDEFAULTCOLLELEM
+ FUNCFLAG_FUIDEFAULT FUNCFLAG_FNONBROWSABLE FUNCFLAG_FREPLACEABLE
+ FUNCFLAG_FIMMEDIATEBIND
+
+ CC_FASTCALL CC_CDECL CC_MSCPASCAL CC_PASCAL CC_MACPASCAL CC_STDCALL
+ CC_FPFASTCALL CC_SYSCALL CC_MPWCDECL CC_MPWPASCAL CC_MAX
+
+ INVOKE_FUNC INVOKE_PROPERTYGET INVOKE_PROPERTYPUT INVOKE_PROPERTYPUTREF
+
+ VARFLAG_FREADONLY VARFLAG_FSOURCE VARFLAG_FBINDABLE VARFLAG_FREQUESTEDIT
+ VARFLAG_FDISPLAYBIND VARFLAG_FDEFAULTBIND VARFLAG_FHIDDEN VARFLAG_FRESTRICTED
+ VARFLAG_FDEFAULTCOLLELEM VARFLAG_FUIDEFAULT VARFLAG_FNONBROWSABLE
+ VARFLAG_FREPLACEABLE VARFLAG_FIMMEDIATEBIND
+
+ LIBFLAG_FRESTRICTED LIBFLAG_FCONTROL LIBFLAG_FHIDDEN
+ SYS_WIN16 SYS_WIN32 SYS_MAC
+
+ FUNC_VIRTUAL FUNC_PUREVIRTUAL FUNC_NONVIRTUAL FUNC_STATIC FUNC_DISPATCH
+
+ @VT %TYPEFLAGS @TYPEKIND %IMPLTYPEFLAGS %PARAMFLAGS
+ %FUNCFLAGS @CALLCONV @FUNCKIND %INVOKEKIND %VARFLAGS %LIBFLAGS @SYSKIND
+);
+
+# Lib Flags
+# ---------
+
+sub LIBFLAG_FRESTRICTED () { 0x01; }
+sub LIBFLAG_FCONTROL () { 0x02; }
+sub LIBFLAG_FHIDDEN () { 0x04; }
+
+$LIBFLAGS{LIBFLAG_FRESTRICTED()} = LIBFLAG_FRESTRICTED;
+$LIBFLAGS{LIBFLAG_FCONTROL()} = LIBFLAG_FCONTROL;
+$LIBFLAGS{LIBFLAG_FHIDDEN()} = LIBFLAG_FHIDDEN;
+
+# Sys Kind
+# --------
+
+sub SYS_WIN16 () { 0; }
+sub SYS_WIN32 () { SYS_WIN16() + 1; }
+sub SYS_MAC () { SYS_WIN32() + 1; }
+
+$SYSKIND[SYS_WIN16] = 'SYS_WIN16';
+$SYSKIND[SYS_WIN32] = 'SYS_WIN32';
+$SYSKIND[SYS_MAC] = 'SYS_MAC';
+
+# Type Flags
+# ----------
+
+sub TYPEFLAG_FAPPOBJECT () { 0x1; }
+sub TYPEFLAG_FCANCREATE () { 0x2; }
+sub TYPEFLAG_FLICENSED () { 0x4; }
+sub TYPEFLAG_FPREDECLID () { 0x8; }
+sub TYPEFLAG_FHIDDEN () { 0x10; }
+sub TYPEFLAG_FCONTROL () { 0x20; }
+sub TYPEFLAG_FDUAL () { 0x40; }
+sub TYPEFLAG_FNONEXTENSIBLE () { 0x80; }
+sub TYPEFLAG_FOLEAUTOMATION () { 0x100; }
+sub TYPEFLAG_FRESTRICTED () { 0x200; }
+sub TYPEFLAG_FAGGREGATABLE () { 0x400; }
+sub TYPEFLAG_FREPLACEABLE () { 0x800; }
+sub TYPEFLAG_FDISPATCHABLE () { 0x1000; }
+sub TYPEFLAG_FREVERSEBIND () { 0x2000; }
+
+$TYPEFLAGS{TYPEFLAG_FAPPOBJECT()} = TYPEFLAG_FAPPOBJECT;
+$TYPEFLAGS{TYPEFLAG_FCANCREATE()} = TYPEFLAG_FCANCREATE;
+$TYPEFLAGS{TYPEFLAG_FLICENSED()} = TYPEFLAG_FLICENSED;
+$TYPEFLAGS{TYPEFLAG_FPREDECLID()} = TYPEFLAG_FPREDECLID;
+$TYPEFLAGS{TYPEFLAG_FHIDDEN()} = TYPEFLAG_FHIDDEN;
+$TYPEFLAGS{TYPEFLAG_FCONTROL()} = TYPEFLAG_FCONTROL;
+$TYPEFLAGS{TYPEFLAG_FDUAL()} = TYPEFLAG_FDUAL;
+$TYPEFLAGS{TYPEFLAG_FNONEXTENSIBLE()} = TYPEFLAG_FNONEXTENSIBLE;
+$TYPEFLAGS{TYPEFLAG_FOLEAUTOMATION()} = TYPEFLAG_FOLEAUTOMATION;
+$TYPEFLAGS{TYPEFLAG_FRESTRICTED()} = TYPEFLAG_FRESTRICTED;
+$TYPEFLAGS{TYPEFLAG_FAGGREGATABLE()} = TYPEFLAG_FAGGREGATABLE;
+$TYPEFLAGS{TYPEFLAG_FREPLACEABLE()} = TYPEFLAG_FREPLACEABLE;
+$TYPEFLAGS{TYPEFLAG_FDISPATCHABLE()} = TYPEFLAG_FDISPATCHABLE;
+$TYPEFLAGS{TYPEFLAG_FREVERSEBIND()} = TYPEFLAG_FREVERSEBIND;
+
+# Type Kind
+# ---------
+
+sub TKIND_ENUM () { 0; }
+sub TKIND_RECORD () { TKIND_ENUM() + 1; }
+sub TKIND_MODULE () { TKIND_RECORD() + 1; }
+sub TKIND_INTERFACE () { TKIND_MODULE() + 1; }
+sub TKIND_DISPATCH () { TKIND_INTERFACE() + 1; }
+sub TKIND_COCLASS () { TKIND_DISPATCH() + 1; }
+sub TKIND_ALIAS () { TKIND_COCLASS() + 1; }
+sub TKIND_UNION () { TKIND_ALIAS() + 1; }
+sub TKIND_MAX () { TKIND_UNION() + 1; }
+
+$TYPEKIND[TKIND_ENUM] = 'TKIND_ENUM';
+$TYPEKIND[TKIND_RECORD] = 'TKIND_RECORD';
+$TYPEKIND[TKIND_MODULE] = 'TKIND_MODULE';
+$TYPEKIND[TKIND_INTERFACE] = 'TKIND_INTERFACE';
+$TYPEKIND[TKIND_DISPATCH] = 'TKIND_DISPATCH';
+$TYPEKIND[TKIND_COCLASS] = 'TKIND_COCLASS';
+$TYPEKIND[TKIND_ALIAS] = 'TKIND_ALIAS';
+$TYPEKIND[TKIND_UNION] = 'TKIND_UNION';
+
+# Implemented Type Flags
+# ----------------------
+
+sub IMPLTYPEFLAG_FDEFAULT () { 0x1; }
+sub IMPLTYPEFLAG_FSOURCE () { 0x2; }
+sub IMPLTYPEFLAG_FRESTRICTED () { 0x4; }
+sub IMPLTYPEFLAG_FDEFAULTVTABLE () { 0x800; }
+
+$IMPLTYPEFLAGS{IMPLTYPEFLAG_FDEFAULT()} = IMPLTYPEFLAG_FDEFAULT;
+$IMPLTYPEFLAGS{IMPLTYPEFLAG_FSOURCE()} = IMPLTYPEFLAG_FSOURCE;
+$IMPLTYPEFLAGS{IMPLTYPEFLAG_FRESTRICTED()} = IMPLTYPEFLAG_FRESTRICTED;
+$IMPLTYPEFLAGS{IMPLTYPEFLAG_FDEFAULTVTABLE()} = IMPLTYPEFLAG_FDEFAULTVTABLE;
+
+# Parameter Flags
+# ---------------
+
+sub PARAMFLAG_NONE () { 0; }
+sub PARAMFLAG_FIN () { 0x1; }
+sub PARAMFLAG_FOUT () { 0x2; }
+sub PARAMFLAG_FLCID () { 0x4; }
+sub PARAMFLAG_FRETVAL () { 0x8; }
+sub PARAMFLAG_FOPT () { 0x10; }
+sub PARAMFLAG_FHASDEFAULT () { 0x20; }
+
+$PARAMFLAGS{PARAMFLAG_NONE()} = PARAMFLAG_NONE;
+$PARAMFLAGS{PARAMFLAG_FIN()} = PARAMFLAG_FIN;
+$PARAMFLAGS{PARAMFLAG_FOUT()} = PARAMFLAG_FOUT;
+$PARAMFLAGS{PARAMFLAG_FLCID()} = PARAMFLAG_FLCID;
+$PARAMFLAGS{PARAMFLAG_FRETVAL()} = PARAMFLAG_FRETVAL;
+$PARAMFLAGS{PARAMFLAG_FOPT()} = PARAMFLAG_FOPT;
+$PARAMFLAGS{PARAMFLAG_FHASDEFAULT()} = PARAMFLAG_FHASDEFAULT;
+
+# Function Flags
+# --------------
+
+sub FUNCFLAG_FRESTRICTED () { 0x1; }
+sub FUNCFLAG_FSOURCE () { 0x2; }
+sub FUNCFLAG_FBINDABLE () { 0x4; }
+sub FUNCFLAG_FREQUESTEDIT () { 0x8; }
+sub FUNCFLAG_FDISPLAYBIND () { 0x10; }
+sub FUNCFLAG_FDEFAULTBIND () { 0x20; }
+sub FUNCFLAG_FHIDDEN () { 0x40; }
+sub FUNCFLAG_FUSESGETLASTERROR () { 0x80; }
+sub FUNCFLAG_FDEFAULTCOLLELEM () { 0x100; }
+sub FUNCFLAG_FUIDEFAULT () { 0x200; }
+sub FUNCFLAG_FNONBROWSABLE () { 0x400; }
+sub FUNCFLAG_FREPLACEABLE () { 0x800; }
+sub FUNCFLAG_FIMMEDIATEBIND () { 0x1000; }
+
+$FUNCFLAGS{FUNCFLAG_FRESTRICTED()} = FUNCFLAG_FRESTRICTED;
+$FUNCFLAGS{FUNCFLAG_FSOURCE()} = FUNCFLAG_FSOURCE;
+$FUNCFLAGS{FUNCFLAG_FBINDABLE()} = FUNCFLAG_FBINDABLE;
+$FUNCFLAGS{FUNCFLAG_FREQUESTEDIT()} = FUNCFLAG_FREQUESTEDIT;
+$FUNCFLAGS{FUNCFLAG_FDISPLAYBIND()} = FUNCFLAG_FDISPLAYBIND;
+$FUNCFLAGS{FUNCFLAG_FDEFAULTBIND()} = FUNCFLAG_FDEFAULTBIND;
+$FUNCFLAGS{FUNCFLAG_FHIDDEN()} = FUNCFLAG_FHIDDEN;
+$FUNCFLAGS{FUNCFLAG_FUSESGETLASTERROR()} = FUNCFLAG_FUSESGETLASTERROR;
+$FUNCFLAGS{FUNCFLAG_FDEFAULTCOLLELEM()} = FUNCFLAG_FDEFAULTCOLLELEM;
+$FUNCFLAGS{FUNCFLAG_FUIDEFAULT()} = FUNCFLAG_FUIDEFAULT;
+$FUNCFLAGS{FUNCFLAG_FNONBROWSABLE()} = FUNCFLAG_FNONBROWSABLE;
+$FUNCFLAGS{FUNCFLAG_FREPLACEABLE()} = FUNCFLAG_FREPLACEABLE;
+$FUNCFLAGS{FUNCFLAG_FIMMEDIATEBIND()} = FUNCFLAG_FIMMEDIATEBIND;
+
+# Calling conventions
+# -------------------
+
+sub CC_FASTCALL () { 0; }
+sub CC_CDECL () { 1; }
+sub CC_MSCPASCAL () { CC_CDECL() + 1; }
+sub CC_PASCAL () { CC_MSCPASCAL; }
+sub CC_MACPASCAL () { CC_PASCAL() + 1; }
+sub CC_STDCALL () { CC_MACPASCAL() + 1; }
+sub CC_FPFASTCALL () { CC_STDCALL() + 1; }
+sub CC_SYSCALL () { CC_FPFASTCALL() + 1; }
+sub CC_MPWCDECL () { CC_SYSCALL() + 1; }
+sub CC_MPWPASCAL () { CC_MPWCDECL() + 1; }
+sub CC_MAX () { CC_MPWPASCAL() + 1; }
+
+$CALLCONV[CC_FASTCALL] = 'CC_FASTCALL';
+$CALLCONV[CC_CDECL] = 'CC_CDECL';
+$CALLCONV[CC_PASCAL] = 'CC_PASCAL';
+$CALLCONV[CC_MACPASCAL] = 'CC_MACPASCAL';
+$CALLCONV[CC_STDCALL] = 'CC_STDCALL';
+$CALLCONV[CC_FPFASTCALL] = 'CC_FPFASTCALL';
+$CALLCONV[CC_SYSCALL] = 'CC_SYSCALL';
+$CALLCONV[CC_MPWCDECL] = 'CC_MPWCDECL';
+$CALLCONV[CC_MPWPASCAL] = 'CC_MPWPASCAL';
+
+# Function Kind
+# -------------
+
+sub FUNC_VIRTUAL () { 0; }
+sub FUNC_PUREVIRTUAL () { FUNC_VIRTUAL() + 1; }
+sub FUNC_NONVIRTUAL () { FUNC_PUREVIRTUAL() + 1; }
+sub FUNC_STATIC () { FUNC_NONVIRTUAL() + 1; }
+sub FUNC_DISPATCH () { FUNC_STATIC() + 1; }
+
+$FUNCKIND[FUNC_VIRTUAL] = 'FUNC_VIRTUAL';
+$FUNCKIND[FUNC_PUREVIRTUAL] = 'FUNC_PUREVIRTUAL';
+$FUNCKIND[FUNC_NONVIRTUAL] = 'FUNC_NONVIRTUAL';
+$FUNCKIND[FUNC_STATIC] = 'FUNC_STATIC';
+$FUNCKIND[FUNC_DISPATCH] = 'FUNC_DISPATCH';
+
+# Invoke Kind
+# -----------
+
+sub INVOKE_FUNC () { 1; }
+sub INVOKE_PROPERTYGET () { 2; }
+sub INVOKE_PROPERTYPUT () { 4; }
+sub INVOKE_PROPERTYPUTREF () { 8; }
+
+$INVOKEKIND{INVOKE_FUNC()} = INVOKE_FUNC;
+$INVOKEKIND{INVOKE_PROPERTYGET()} = INVOKE_PROPERTYGET;
+$INVOKEKIND{INVOKE_PROPERTYPUT()} = INVOKE_PROPERTYPUT;
+$INVOKEKIND{INVOKE_PROPERTYPUTREF()} = INVOKE_PROPERTYPUTREF;
+
+# Variable Flags
+# --------------
+
+sub VARFLAG_FREADONLY () { 0x1; }
+sub VARFLAG_FSOURCE () { 0x2; }
+sub VARFLAG_FBINDABLE () { 0x4; }
+sub VARFLAG_FREQUESTEDIT () { 0x8; }
+sub VARFLAG_FDISPLAYBIND () { 0x10; }
+sub VARFLAG_FDEFAULTBIND () { 0x20; }
+sub VARFLAG_FHIDDEN () { 0x40; }
+sub VARFLAG_FRESTRICTED () { 0x80; }
+sub VARFLAG_FDEFAULTCOLLELEM () { 0x100; }
+sub VARFLAG_FUIDEFAULT () { 0x200; }
+sub VARFLAG_FNONBROWSABLE () { 0x400; }
+sub VARFLAG_FREPLACEABLE () { 0x800; }
+sub VARFLAG_FIMMEDIATEBIND () { 0x1000; }
+
+$VARFLAGS{VARFLAG_FREADONLY()} = VARFLAG_FREADONLY;
+$VARFLAGS{VARFLAG_FSOURCE()} = VARFLAG_FSOURCE;
+$VARFLAGS{VARFLAG_FBINDABLE()} = VARFLAG_FBINDABLE;
+$VARFLAGS{VARFLAG_FREQUESTEDIT()} = VARFLAG_FREQUESTEDIT;
+$VARFLAGS{VARFLAG_FDISPLAYBIND()} = VARFLAG_FDISPLAYBIND;
+$VARFLAGS{VARFLAG_FDEFAULTBIND()} = VARFLAG_FDEFAULTBIND;
+$VARFLAGS{VARFLAG_FHIDDEN()} = VARFLAG_FHIDDEN;
+$VARFLAGS{VARFLAG_FRESTRICTED()} = VARFLAG_FRESTRICTED;
+$VARFLAGS{VARFLAG_FDEFAULTCOLLELEM()} = VARFLAG_FDEFAULTCOLLELEM;
+$VARFLAGS{VARFLAG_FUIDEFAULT()} = VARFLAG_FUIDEFAULT;
+$VARFLAGS{VARFLAG_FNONBROWSABLE()} = VARFLAG_FNONBROWSABLE;
+$VARFLAGS{VARFLAG_FREPLACEABLE()} = VARFLAG_FREPLACEABLE;
+$VARFLAGS{VARFLAG_FIMMEDIATEBIND()} = VARFLAG_FIMMEDIATEBIND;
+
+
+# Variant Types
+# -------------
+
+sub VT_EMPTY () { 0; }
+sub VT_NULL () { 1; }
+sub VT_I2 () { 2; }
+sub VT_I4 () { 3; }
+sub VT_R4 () { 4; }
+sub VT_R8 () { 5; }
+sub VT_CY () { 6; }
+sub VT_DATE () { 7; }
+sub VT_BSTR () { 8; }
+sub VT_DISPATCH () { 9; }
+sub VT_ERROR () { 10; }
+sub VT_BOOL () { 11; }
+sub VT_VARIANT () { 12; }
+sub VT_UNKNOWN () { 13; }
+sub VT_DECIMAL () { 14; }
+sub VT_I1 () { 16; }
+sub VT_UI1 () { 17; }
+sub VT_UI2 () { 18; }
+sub VT_UI4 () { 19; }
+sub VT_I8 () { 20; }
+sub VT_UI8 () { 21; }
+sub VT_INT () { 22; }
+sub VT_UINT () { 23; }
+sub VT_VOID () { 24; }
+sub VT_HRESULT () { 25; }
+sub VT_PTR () { 26; }
+sub VT_SAFEARRAY () { 27; }
+sub VT_CARRAY () { 28; }
+sub VT_USERDEFINED () { 29; }
+sub VT_LPSTR () { 30; }
+sub VT_LPWSTR () { 31; }
+sub VT_FILETIME () { 64; }
+sub VT_BLOB () { 65; }
+sub VT_STREAM () { 66; }
+sub VT_STORAGE () { 67; }
+sub VT_STREAMED_OBJECT () { 68; }
+sub VT_STORED_OBJECT () { 69; }
+sub VT_BLOB_OBJECT () { 70; }
+sub VT_CF () { 71; }
+sub VT_CLSID () { 72; }
+sub VT_VECTOR () { 0x1000; }
+sub VT_ARRAY () { 0x2000; }
+sub VT_BYREF () { 0x4000; }
+sub VT_RESERVED () { 0x8000; }
+sub VT_ILLEGAL () { 0xffff; }
+sub VT_ILLEGALMASKED () { 0xfff; }
+sub VT_TYPEMASK () { 0xfff; }
+
+$VT[VT_EMPTY] = 'VT_EMPTY';
+$VT[VT_NULL] = 'VT_NULL';
+$VT[VT_I2] = 'VT_I2';
+$VT[VT_I4] = 'VT_I4';
+$VT[VT_R4] = 'VT_R4';
+$VT[VT_R8] = 'VT_R8';
+$VT[VT_CY] = 'VT_CY';
+$VT[VT_DATE] = 'VT_DATE';
+$VT[VT_BSTR] = 'VT_BSTR';
+$VT[VT_DISPATCH] = 'VT_DISPATCH';
+$VT[VT_ERROR] = 'VT_ERROR';
+$VT[VT_BOOL] = 'VT_BOOL';
+$VT[VT_VARIANT] = 'VT_VARIANT';
+$VT[VT_UNKNOWN] = 'VT_UNKNOWN';
+$VT[VT_DECIMAL] = 'VT_DECIMAL';
+$VT[VT_I1] = 'VT_I1';
+$VT[VT_UI1] = 'VT_UI1';
+$VT[VT_UI2] = 'VT_UI2';
+$VT[VT_UI4] = 'VT_UI4';
+$VT[VT_I8] = 'VT_I8';
+$VT[VT_UI8] = 'VT_UI8';
+$VT[VT_INT] = 'VT_INT';
+$VT[VT_UINT] = 'VT_UINT';
+$VT[VT_VOID] = 'VT_VOID';
+$VT[VT_HRESULT] = 'VT_HRESULT';
+$VT[VT_PTR] = 'VT_PTR';
+$VT[VT_SAFEARRAY] = 'VT_SAFEARRAY';
+$VT[VT_CARRAY] = 'VT_CARRAY';
+$VT[VT_USERDEFINED] = 'VT_USERDEFINED';
+$VT[VT_LPSTR] = 'VT_LPSTR';
+$VT[VT_LPWSTR] = 'VT_LPWSTR';
+$VT[VT_FILETIME] = 'VT_FILETIME';
+$VT[VT_BLOB] = 'VT_BLOB';
+$VT[VT_STREAM] = 'VT_STREAM';
+$VT[VT_STORAGE] = 'VT_STORAGE';
+$VT[VT_STREAMED_OBJECT] = 'VT_STREAMED_OBJECT';
+$VT[VT_STORED_OBJECT] = 'VT_STORED_OBJECT';
+$VT[VT_BLOB_OBJECT] = 'VT_BLOB_OBJECT';
+$VT[VT_CF] = 'VT_CF';
+$VT[VT_CLSID] = 'VT_CLSID';
+$VT[VT_VECTOR] = 'VT_VECTOR';
+$VT[VT_ARRAY] = 'VT_ARRAY';
+$VT[VT_BYREF] = 'VT_BYREF';
+$VT[VT_RESERVED] = 'VT_RESERVED';
+$VT[VT_ILLEGAL] = 'VT_ILLEGAL';
+$VT[VT_ILLEGALMASKED] = 'VT_ILLEGALMASKED';
+$VT[VT_TYPEMASK] = 'VT_TYPEMASK';
+
+1;
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/TypeInfo.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Variant.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Variant.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Variant.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,577 @@
+# The documentation is at the __END__
+
+package Win32::OLE::Variant;
+require Win32::OLE; # Make sure the XS bootstrap has been called
+
+use strict;
+use vars qw(@ISA @EXPORT @EXPORT_OK);
+
+use Exporter;
+ at ISA = qw(Exporter);
+
+ at EXPORT = qw(
+ Variant
+ VT_EMPTY VT_NULL VT_I2 VT_I4 VT_R4 VT_R8 VT_CY VT_DATE VT_BSTR
+ VT_DISPATCH VT_ERROR VT_BOOL VT_VARIANT VT_UNKNOWN VT_DECIMAL VT_UI1
+ VT_ARRAY VT_BYREF
+ );
+
+ at EXPORT_OK = qw(CP_ACP CP_OEMCP nothing nullstring);
+
+# Automation data types.
+sub VT_EMPTY {0;}
+sub VT_NULL {1;}
+sub VT_I2 {2;}
+sub VT_I4 {3;}
+sub VT_R4 {4;}
+sub VT_R8 {5;}
+sub VT_CY {6;}
+sub VT_DATE {7;}
+sub VT_BSTR {8;}
+sub VT_DISPATCH {9;}
+sub VT_ERROR {10;}
+sub VT_BOOL {11;}
+sub VT_VARIANT {12;}
+sub VT_UNKNOWN {13;}
+sub VT_DECIMAL {14;} # Officially not allowed in VARIANTARGs
+sub VT_UI1 {17;}
+
+sub VT_ARRAY {0x2000;}
+sub VT_BYREF {0x4000;}
+
+
+# For backward compatibility
+sub CP_ACP {0;} # ANSI codepage
+sub CP_OEMCP {1;} # OEM codepage
+
+use overload
+ # '+' => 'Add', '-' => 'Sub', '*' => 'Mul', '/' => 'Div',
+ '""' => sub {$_[0]->As(VT_BSTR)},
+ '0+' => sub {$_[0]->As(VT_R8)},
+ fallback => 1;
+
+sub Variant {
+ return Win32::OLE::Variant->new(@_);
+}
+
+sub nothing {
+ return Win32::OLE::Variant->new(VT_DISPATCH);
+}
+
+sub nullstring {
+ return Win32::OLE::Variant->new(VT_BSTR);
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+Win32::OLE::Variant - Create and modify OLE VARIANT variables
+
+=head1 SYNOPSIS
+
+ use Win32::OLE::Variant;
+ my $var = Variant(VT_DATE, 'Jan 1,1970');
+ $OleObject->{value} = $var;
+ $OleObject->Method($var);
+
+
+=head1 DESCRIPTION
+
+The IDispatch interface used by the Perl OLE module uses a universal
+argument type called VARIANT. This is basically an object containing
+a data type and the actual data value. The data type is specified by
+the VT_xxx constants.
+
+=head2 Functions
+
+=over 8
+
+=item nothing()
+
+The nothing() function returns an empty VT_DISPATCH variant. It can be
+used to clear an object reference stored in a property
+
+ use Win32::OLE::Variant qw(:DEFAULT nothing);
+ # ...
+ $object->{Property} = nothing;
+
+This has the same effect as the Visual Basic statement
+
+ Set object.Property = Nothing
+
+The nothing() function is B<not> exported by default.
+
+=item nullstring()
+
+The nullstring() function returns a VT_BSTR variant with a NULL string
+pointer. This is B<not> the same as a VT_BSTR variant with an empty
+string "". The nullstring() value is the same as the vbNullString
+constant in Visual Basic.
+
+The nullstring() function is B<not> exported by default.
+
+=item Variant(TYPE, DATA)
+
+This is just a function alias of the C<Win32::OLE::Variant->new()>
+method (see below). This function is exported by default.
+
+=back
+
+=head2 Methods
+
+=over 8
+
+=item new(TYPE, DATA)
+
+This method returns a Win32::OLE::Variant object of the specified
+TYPE that contains the given DATA. The Win32::OLE::Variant object
+can be used to specify data types other than IV, NV or PV (which are
+supported transparently). See L<Variants> below for details.
+
+For VT_EMPTY and VT_NULL variants, the DATA argument may be omitted.
+For all non-VT_ARRAY variants DATA specifies the initial value.
+
+To create a SAFEARRAY variant, you have to specify the VT_ARRAY flag in
+addition to the variant base type of the array elements. In this cases
+DATA must be a list specifying the dimensions of the array. Each element
+can be either an element count (indices 0 to count-1) or an array
+reference pointing to the lower and upper array bounds of this dimension:
+
+ my $Array = Win32::OLE::Variant->new(VT_ARRAY|VT_R8, [1,2], 2);
+
+This creates a 2-dimensional SAFEARRAY of doubles with 4 elements:
+(1,0), (1,1), (2,0) and (2,1).
+
+A special case is the creation of one-dimensional VT_UI1 arrays with
+a string DATA argument:
+
+ my $String = Variant(VT_ARRAY|VT_UI1, "String");
+
+This creates a 6 element character array initialized to "String". For
+backward compatibility VT_UI1 with a string initializer automatically
+implies VT_ARRAY. The next line is equivalent to the previous example:
+
+ my $String = Variant(VT_UI1, "String");
+
+If you really need a single character VT_UI1 variant, you have to create
+it using a numeric intializer:
+
+ my $Char = Variant(VT_UI1, ord('A'));
+
+=item As(TYPE)
+
+C<As> converts the VARIANT to the new type before converting to a
+Perl value. This take the current LCID setting into account. For
+example a string might contain a ',' as the decimal point character.
+Using C<$variant->As(VT_R8)> will correctly return the floating
+point value.
+
+The underlying variant object is NOT changed by this method.
+
+=item ChangeType(TYPE)
+
+This method changes the type of the contained VARIANT in place. It
+returns the object itself, not the converted value.
+
+=item Copy([DIM])
+
+This method creates a copy of the object. If the original variant had
+the VT_BYREF bit set then the new object will contain a copy of the
+referenced data and not a reference to the same old data. The new
+object will not have the VT_BYREF bit set.
+
+ my $Var = Variant(VT_I4|VT_ARRAY|VT_BYREF, [1,5], 3);
+ my $Copy = $Var->Copy;
+
+The type of C<$Copy> is now VT_I4|VT_ARRAY and the value is a copy of
+the other SAFEARRAY. Changes to elements of C<$Var> will not be reflected
+in C<$Copy> and vice versa.
+
+The C<Copy> method can also be used to extract a single element of a
+VT_ARRAY | VT_VARIANT object. In this case the array indices must be
+specified as a list DIM:
+
+ my $Int = $Var->Copy(1, 2);
+
+C<$Int> is now a VT_I4 Variant object containing the value of element (1,2).
+
+=item Currency([FORMAT[, LCID]])
+
+This method converts the VARIANT value into a formatted currency string. The
+FORMAT can be either an integer constant or a hash reference. Valid constants
+are 0 and LOCALE_NOUSEROVERRIDE. You get the value of LOCALE_NOUSEROVERRIDE
+from the Win32::OLE::NLS module:
+
+ use Win32::OLE::NLS qw(:LOCALE);
+
+LOCALE_NOUSEROVERRIDE tells the method to use the system default currency
+format for the specified locale, disregarding any changes that might have
+been made through the control panel application.
+
+The hash reference could contain the following keys:
+
+ NumDigits number of fractional digits
+ LeadingZero whether to use leading zeroes in decimal fields
+ Grouping size of each group of digits to the left of the decimal
+ DecimalSep decimal separator string
+ ThousandSep thousand separator string
+ NegativeOrder see L<Win32::OLE::NLS/LOCALE_ICURRENCY>
+ PositiveOrder see L<Win32::OLE::NLS/LOCALE_INEGCURR>
+ CurrencySymbol currency symbol string
+
+For example:
+
+ use Win32::OLE::Variant;
+ use Win32::OLE::NLS qw(:DEFAULT :LANG :SUBLANG :DATE :TIME);
+ my $lcidGerman = MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_NEUTRAL));
+ my $v = Variant(VT_CY, "-922337203685477.5808");
+ print $v->Currency({CurrencySymbol => "Tuits"}, $lcidGerman), "\n";
+
+will print:
+
+ -922.337.203.685.477,58 Tuits
+
+=item Date([FORMAT[, LCID]])
+
+Converts the VARIANT into a formatted date string. FORMAT can be either
+one of the following integer constants or a format string:
+
+ LOCALE_NOUSEROVERRIDE system default date format for this locale
+ DATE_SHORTDATE use the short date format (default)
+ DATE_LONGDATE use the long date format
+ DATE_YEARMONTH use the year/month format
+ DATE_USE_ALT_CALENDAR use the alternate calendar, if one exists
+ DATE_LTRREADING left-to-right reading order layout
+ DATE_RTLREADING right-to left reading order layout
+
+The constants are available from the Win32::OLE::NLS module:
+
+ use Win32::OLE::NLS qw(:LOCALE :DATE);
+
+The following elements can be used to construct a date format string.
+Characters must be specified exactly as given below (e.g. "dd" B<not> "DD").
+Spaces can be inserted anywhere between formatting codes, other verbatim
+text should be included in single quotes.
+
+ d day of month
+ dd day of month with leading zero for single-digit days
+ ddd day of week: three-letter abbreviation (LOCALE_SABBREVDAYNAME)
+ dddd day of week: full name (LOCALE_SDAYNAME)
+ M month
+ MM month with leading zero for single-digit months
+ MMM month: three-letter abbreviation (LOCALE_SABBREVMONTHNAME)
+ MMMM month: full name (LOCALE_SMONTHNAME)
+ y year as last two digits
+ yy year as last two digits with leading zero for years less than 10
+ yyyy year represented by full four digits
+ gg period/era string
+
+For example:
+
+ my $v = Variant(VT_DATE, "April 1 99");
+ print $v->Date(DATE_LONGDATE), "\n";
+ print $v->Date("ddd',' MMM dd yy"), "\n";
+
+will print:
+
+ Thursday, April 01, 1999
+ Thu, Apr 01 99
+
+=item Dim()
+
+Returns a list of array bounds for a VT_ARRAY variant. The list contains
+an array reference for each dimension of the variant's SAFEARRAY. This
+reference points to an array containing the lower and upper bounds for
+this dimension. For example:
+
+ my @Dim = $Var->Dim;
+
+Now C<@Dim> contains the following list: C<([1,5], [0,2])>.
+
+=item Get(DIM)
+
+For normal variants C<Get> returns the value of the variant, just like the
+C<Value> method. For VT_ARRAY variants C<Get> retrieves the value of a single
+array element. In this case C<DIM> must be a list of array indices. E.g.
+
+ my $Val = $Var->Get(2,0);
+
+As a special case for one dimensional VT_UI1|VT_ARRAY variants the C<Get>
+method without arguments returns the character array as a Perl string.
+
+ print $String->Get, "\n";
+
+=item IsNothing()
+
+Tests if the object is an empty VT_DISPATCH variant. See also nothing().
+
+=item IsNullString()
+
+Tests if the object is an empty VT_BSTR variant. See also nullstring().
+
+=item LastError()
+
+The use of the C<Win32::OLE::Variant->LastError()> method is deprecated.
+Please use the C<Win32::OLE->LastError()> class method instead.
+
+=item Number([FORMAT[, LCID]])
+
+This method converts the VARIANT value into a formatted number string. The
+FORMAT can be either an integer constant or a hash reference. Valid constants
+are 0 and LOCALE_NOUSEROVERRIDE. You get the value of LOCALE_NOUSEROVERRIDE
+from the Win32::OLE::NLS module:
+
+ use Win32::OLE::NLS qw(:LOCALE);
+
+LOCALE_NOUSEROVERRIDE tells the method to use the system default number
+format for the specified locale, disregarding any changes that might have
+been made through the control panel application.
+
+The hash reference could contain the following keys:
+
+ NumDigits number of fractional digits
+ LeadingZero whether to use leading zeroes in decimal fields
+ Grouping size of each group of digits to the left of the decimal
+ DecimalSep decimal separator string
+ ThousandSep thousand separator string
+ NegativeOrder see L<Win32::OLE::NLS/LOCALE_INEGNUMBER>
+
+=item Put(DIM, VALUE)
+
+The C<Put> method is used to assign a new value to a variant. The value will
+be coerced into the current type of the variant. E.g.:
+
+ my $Var = Variant(VT_I4, 42);
+ $Var->Put(3.1415);
+
+This changes the value of the variant to C<3> because the type is VT_I4.
+
+For VT_ARRAY type variants the indices for each dimension of the contained
+SAFEARRAY must be specified in front of the new value:
+
+ $Array->Put(1, 1, 2.7);
+
+It is also possible to assign values to *every* element of the SAFEARRAY at
+once using a single Put() method call:
+
+ $Array->Put([[1,2], [3,4]]);
+
+In this case the argument to Put() must be an array reference and the
+dimensions of the Perl list-of-lists must match the dimensions of the
+SAFEARRAY exactly.
+
+The are a few special cases for one-dimensional VT_UI1 arrays: The VALUE
+can be specified as a string instead of a number. This will set the selected
+character to the first character of the string or to '\0' if the string was
+empty:
+
+ my $String = Variant(VT_UI1|VT_ARRAY, "ABCDE");
+ $String->Put(1, "123");
+ $String->Put(3, ord('Z'));
+ $String->Put(4, '');
+
+This will set the value of C<$String> to C<"A1CZ\0">. If the index is omitted
+then the string is copied to the value completely. The string is truncated
+if it is longer than the size of the VT_UI1 array. The result will be padded
+with '\0's if the string is shorter:
+
+ $String->Put("String");
+
+Now C<$String> contains the value "Strin".
+
+C<Put> returns the Variant object itself so that multiple C<Put> calls can be
+chained together:
+
+ $Array->Put(0,0,$First_value)->Put(0,1,$Another_value);
+
+=item Time([FORMAT[, LCID]])
+
+Converts the VARIANT into a formatted time string. FORMAT can be either
+one of the following integer constants or a format string:
+
+ LOCALE_NOUSEROVERRIDE system default time format for this locale
+ TIME_NOMINUTESORSECONDS don't use minutes or seconds
+ TIME_NOSECONDS don't use seconds
+ TIME_NOTIMEMARKER don't use a time marker
+ TIME_FORCE24HOURFORMAT always use a 24-hour time format
+
+The constants are available from the Win32::OLE::NLS module:
+
+ use Win32::OLE::NLS qw(:LOCALE :TIME);
+
+The following elements can be used to construct a time format string.
+Characters must be specified exactly as given below (e.g. "dd" B<not> "DD").
+Spaces can be inserted anywhere between formatting codes, other verbatim
+text should be included in single quotes.
+
+ h hours; 12-hour clock
+ hh hours with leading zero for single-digit hours; 12-hour clock
+ H hours; 24-hour clock
+ HH hours with leading zero for single-digit hours; 24-hour clock
+ m minutes
+ mm minutes with leading zero for single-digit minutes
+ s seconds
+ ss seconds with leading zero for single-digit seconds
+ t one character time marker string, such as A or P
+ tt multicharacter time marker string, such as AM or PM
+
+For example:
+
+ my $v = Variant(VT_DATE, "April 1 99 2:23 pm");
+ print $v->Time, "\n";
+ print $v->Time(TIME_FORCE24HOURFORMAT|TIME_NOTIMEMARKER), "\n";
+ print $v->Time("hh.mm.ss tt"), "\n";
+
+will print:
+
+ 2:23:00 PM
+ 14:23:00
+ 02.23.00 PM
+
+=item Type()
+
+The C<Type> method returns the variant type of the contained VARIANT.
+
+=item Unicode()
+
+The C<Unicode> method returns a C<Unicode::String> object. This contains
+the BSTR value of the variant in network byte order. If the variant is
+not currently in VT_BSTR format then a VT_BSTR copy will be produced first.
+
+=item Value()
+
+The C<Value> method returns the value of the VARIANT as a Perl value. The
+conversion is performed in the same manner as all return values of
+Win32::OLE method calls are converted.
+
+=back
+
+=head2 Overloading
+
+The Win32::OLE::Variant package has overloaded the conversion to
+string and number formats. Therefore variant objects can be used in
+arithmetic and string operations without applying the C<Value>
+method first.
+
+=head2 Class Variables
+
+The Win32::OLE::Variant class used to have its own set of class variables
+like C<$CP>, C<$LCID> and C<$Warn>. In version 0.1003 and later of the
+Win32::OLE module these variables have been eliminated. Now the settings
+of Win32::OLE are used by the Win32::OLE::Variant module too. Please read
+the documentation of the C<Win32::OLE->Option> class method.
+
+
+=head2 Constants
+
+These constants are exported by default:
+
+ VT_EMPTY
+ VT_NULL
+ VT_I2
+ VT_I4
+ VT_R4
+ VT_R8
+ VT_CY
+ VT_DATE
+ VT_BSTR
+ VT_DISPATCH
+ VT_ERROR
+ VT_BOOL
+ VT_VARIANT
+ VT_UNKNOWN
+ VT_DECIMAL
+ VT_UI1
+
+ VT_ARRAY
+ VT_BYREF
+
+VT_DECIMAL is not on the official list of allowable OLE Automation
+datatypes. But even Microsoft ADO seems to sometimes return values
+of Recordset fields in VT_DECIMAL format.
+
+=head2 Variants
+
+A Variant is a data type that is used to pass data between OLE
+connections.
+
+The default behavior is to convert each perl scalar variable into
+an OLE Variant according to the internal perl representation.
+The following type correspondence holds:
+
+ C type Perl type OLE type
+ ------ --------- --------
+ int IV VT_I4
+ double NV VT_R8
+ char * PV VT_BSTR
+ void * ref to AV VT_ARRAY
+ ? undef VT_ERROR
+ ? Win32::OLE object VT_DISPATCH
+
+Note that VT_BSTR is a wide character or Unicode string. This presents a
+problem if you want to pass in binary data as a parameter as 0x00 is
+inserted between all the bytes in your data. The C<Variant()> method
+provides a solution to this. With Variants the script writer can specify
+the OLE variant type that the parameter should be converted to. Currently
+supported types are:
+
+ VT_UI1 unsigned char
+ VT_I2 signed int (2 bytes)
+ VT_I4 signed int (4 bytes)
+ VT_R4 float (4 bytes)
+ VT_R8 float (8 bytes)
+ VT_DATE OLE Date
+ VT_BSTR OLE String
+ VT_CY OLE Currency
+ VT_BOOL OLE Boolean
+
+When VT_DATE and VT_CY objects are created, the input parameter is treated
+as a Perl string type, which is then converted to VT_BSTR, and finally to
+VT_DATE of VT_CY using the C<VariantChangeType()> OLE API function.
+See L<Win32::OLE/EXAMPLES> for how these types can be used.
+
+=head2 Variant arrays
+
+A variant can not only contain a single value but also a multi-dimensional
+array of values (called a SAFEARRAY). In this case the VT_ARRAY flag must
+be added to the base variant type, e.g. C<VT_I4 | VT_ARRAY> for an array of
+integers. The VT_EMPTY and VT_NULL types are invalid for SAFEARRAYs. It
+is possible to create an array of variants: C<VT_VARIANT | VT_ARRAY>. In this
+case each element of the array can have a different type (including VT_EMPTY
+and VT_NULL). The elements of a VT_VARIANT SAFEARRAY cannot have either of the
+VT_ARRAY or VT_BYREF flags set.
+
+The lower and upper bounds for each dimension can be specified separately.
+They do not have to have all the same lower bound (unlike Perl's arrays).
+
+=head2 Variants by reference
+
+Some OLE servers expect parameters passed by reference so that they
+can be changed in the method call. This allows methods to easily
+return multiple values. There is preliminary support for this in
+the Win32::OLE::Variant module:
+
+ my $x = Variant(VT_I4|VT_BYREF, 0);
+ my $y = Variant(VT_I4|VT_BYREF, 0);
+ $Corel->GetSize($x, $y);
+ print "Size is $x by $y\n";
+
+After the C<GetSize> method call C<$x> and C<$y> will be set to
+the respective sizes. They will still be variants. In the print
+statement the overloading converts them to string representation
+automatically.
+
+VT_BYREF is now supported for all variant types (including SAFEARRAYs).
+It can also be used to pass an OLE object by reference:
+
+ my $Results = $App->CreateResultsObject;
+ $Object->Method(Variant(VT_DISPATCH|VT_BYREF, $Results));
+
+=head1 AUTHORS/COPYRIGHT
+
+This module is part of the Win32::OLE distribution.
+
+=cut
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE/Variant.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE.pm
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE.pm (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE.pm 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,968 @@
+# The documentation is at the __END__
+
+package Win32::OLE;
+
+use strict;
+use vars qw($VERSION @ISA @EXPORT @EXPORT_OK @EXPORT_FAIL $AUTOLOAD
+ $CP $LCID $Warn $LastError $_NewEnum $_Unique);
+
+$VERSION = '0.1712';
+
+use Carp;
+use Exporter;
+use DynaLoader;
+ at ISA = qw(Exporter DynaLoader);
+
+ at EXPORT = qw();
+ at EXPORT_OK = qw(in valof with HRESULT EVENTS OVERLOAD
+ CP_ACP CP_OEMCP CP_MACCP CP_UTF7 CP_UTF8
+ DISPATCH_METHOD DISPATCH_PROPERTYGET
+ DISPATCH_PROPERTYPUT DISPATCH_PROPERTYPUTREF);
+ at EXPORT_FAIL = qw(EVENTS OVERLOAD);
+
+sub export_fail {
+ shift;
+ my @unknown;
+ while (@_) {
+ my $symbol = shift;
+ if ($symbol eq 'OVERLOAD') {
+ eval <<'OVERLOAD';
+ use overload '""' => \&valof,
+ '0+' => \&valof,
+ fallback => 1;
+OVERLOAD
+ }
+ elsif ($symbol eq 'EVENTS') {
+ Win32::OLE->Initialize(Win32::OLE::COINIT_OLEINITIALIZE());
+ }
+ else {
+ push @unknown, $symbol;
+ }
+ }
+ return @unknown;
+}
+
+unless (defined &Dispatch) {
+ # Use regular DynaLoader if XS part is not yet initialized
+ bootstrap Win32::OLE;
+ require Win32::OLE::Lite;
+}
+
+1;
+
+########################################################################
+
+__END__
+
+=head1 NAME
+
+Win32::OLE - OLE Automation extensions
+
+=head1 SYNOPSIS
+
+ $ex = Win32::OLE->new('Excel.Application') or die "oops\n";
+ $ex->Amethod("arg")->Bmethod->{'Property'} = "foo";
+ $ex->Cmethod(undef,undef,$Arg3);
+ $ex->Dmethod($RequiredArg1, {NamedArg1 => $Value1, NamedArg2 => $Value2});
+
+ $wd = Win32::OLE->GetObject("D:\\Data\\Message.doc");
+ $xl = Win32::OLE->GetActiveObject("Excel.Application");
+
+=head1 DESCRIPTION
+
+This module provides an interface to OLE Automation from Perl.
+OLE Automation brings VisualBasic like scripting capabilities and
+offers powerful extensibility and the ability to control many Win32
+applications from Perl scripts.
+
+The Win32::OLE module uses the IDispatch interface exclusively. It is
+not possible to access a custom OLE interface. OLE events and OCX's are
+currently not supported.
+
+Actually, that's no longer strictly true. This module now contains
+B<ALPHA> level support for OLE events. This is largely untested and the
+specific interface might still change in the future.
+
+=head2 Methods
+
+=over 8
+
+=item Win32::OLE->new(PROGID[, DESTRUCTOR])
+
+The new() class method starts a new instance of an OLE Automation object.
+It returns a reference to this object or C<undef> if the creation failed.
+
+The PROGID argument must be either the OLE I<program id> or the I<class id>
+of the required application. The optional DESTRUCTOR specifies a DESTROY-like
+method. This can be either a CODE reference or a string containing an OLE
+method name. It can be used to cleanly terminate OLE applications in case the
+Perl program dies.
+
+To create an object via DCOM on a remote server you can use an array
+reference in place of PROGID. The referenced array must contain the
+machine name and the I<program id> or I<class id>. For example:
+
+ my $obj = Win32::OLE->new(['my.machine.com', 'Program.Id']);
+
+If the PROGID is a I<program id> then Win32::OLE will try to resolve the
+corresponding I<class id> locally. If the I<program id> is not registered
+locally then the remote registry is queried. This will only succeed if
+the local process has read access to the remote registry. The safest
+(and fastest) method is to specify the C<class id> directly.
+
+=item Win32::OLE->EnumAllObjects([CALLBACK])
+
+This class method returns the number Win32::OLE objects currently in
+existence. It will call the optional CALLBACK function for each of
+these objects:
+
+ $Count = Win32::OLE->EnumAllObjects(sub {
+ my $Object = shift;
+ my $Class = Win32::OLE->QueryObjectType($Object);
+ printf "# Object=%s Class=%s\n", $Object, $Class;
+ });
+
+The EnumAllObjects() method is primarily a debugging tool. It can be
+used e.g. in an END block to check if all external connections have
+been properly destroyed.
+
+=item Win32::OLE->FreeUnusedLibraries()
+
+The FreeUnusedLibraries() class method unloads all unused OLE
+resources. These are the libraries of those classes of which all
+existing objects have been destroyed. The unloading of object
+libraries is really only important for long running processes that
+might instantiate a huge number of B<different> objects over time.
+
+Be aware that objects implemented in Visual Basic have a buggy
+implementation of this functionality: They pretend to be unloadable
+while they are actually still running their cleanup code. Unloading
+the DLL at that moment typically produces an access violation. The
+probability for this problem can be reduced by calling the
+SpinMessageLoop() method and sleep()ing for a few seconds.
+
+=item Win32::OLE->GetActiveObject(CLASS[, DESTRUCTOR])
+
+The GetActiveObject() class method returns an OLE reference to a
+running instance of the specified OLE automation server. It returns
+C<undef> if the server is not currently active. It will croak if
+the class is not even registered. The optional DESTRUCTOR method takes
+either a method name or a code reference. It is executed when the last
+reference to this object goes away. It is generally considered rude
+to stop applications that you did not start yourself.
+
+=item Win32::OLE->GetObject(MONIKER[, DESTRUCTOR])
+
+The GetObject() class method returns an OLE reference to the specified
+object. The object is specified by a pathname optionally followed by
+additional item subcomponent separated by exclamation marks '!'. The
+optional DESTRUCTOR argument has the same semantics as the DESTRUCTOR in
+new() or GetActiveObject().
+
+=item Win32::OLE->Initialize([COINIT])
+
+The Initialize() class method can be used to specify an alternative
+apartment model for the Perl thread. It must be called B<before> the
+first OLE object is created. If the C<Win32::OLE::Const> module is
+used then the call to the Initialize() method must be made from a BEGIN
+block before the first C<use> statement for the C<Win32::OLE::Const>
+module.
+
+Valid values for COINIT are:
+
+ Win32::OLE::COINIT_APARTMENTTHREADED - single threaded
+ Win32::OLE::COINIT_MULTITHREADED - the default
+ Win32::OLE::COINIT_OLEINITIALIZE - single threaded, additional OLE stuff
+
+COINIT_OLEINITIALIZE is sometimes needed when an OLE object uses
+additional OLE compound document technologies not available from the
+normal COM subsystem (for example MAPI.Session seems to require it).
+Both COINIT_OLEINITIALIZE and COINIT_APARTMENTTHREADED create a hidden
+top level window and a message queue for the Perl process. This may
+create problems with other application, because Perl normally doesn't
+process its message queue. This means programs using synchronous
+communication between applications (such as DDE initiation), may hang
+until Perl makes another OLE method call/property access or terminates.
+This applies to InstallShield setups and many things started to shell
+associations. Please try to utilize the C<Win32::OLE-E<gt>SpinMessageLoop>
+and C<Win32::OLE-E<gt>Uninitialize> methods if you can not use the default
+COINIT_MULTITHREADED model.
+
+=item OBJECT->Invoke(METHOD[, ARGS])
+
+The Invoke() object method is an alternate way to invoke OLE
+methods. It is normally equivalent to C<$OBJECT-E<gt>METHOD(@ARGS)>. This
+function must be used if the METHOD name contains characters not valid
+in a Perl variable name (like foreign language characters). It can
+also be used to invoke the default method of an object even if the
+default method has not been given a name in the type library. In this
+case use <undef> or C<''> as the method name. To invoke an OLE objects
+native Invoke() method (if such a thing exists), please use:
+
+ $Object->Invoke('Invoke', @Args);
+
+=item Win32::OLE->LastError()
+
+The LastError() class method returns the last recorded OLE
+error. This is a dual value like the C<$!> variable: in a numeric
+context it returns the error number and in a string context it returns
+the error message. The error number is a signed HRESULT value. Please
+use the L<HRESULT(ERROR)> function to convert an unsigned hexadecimal
+constant to a signed HRESULT.
+
+The last OLE error is automatically reset by a successful OLE
+call. The numeric value can also explicitly be set by a call (which will
+discard the string value):
+
+ Win32::OLE->LastError(0);
+
+=item OBJECT->LetProperty(NAME,ARGS,VALUE)
+
+In Win32::OLE property assignment using the hash syntax is equivalent
+to the Visual Basic C<Set> syntax (I<by reference> assignment):
+
+ $Object->{Property} = $OtherObject;
+
+corresponds to this Visual Basic statement:
+
+ Set Object.Property = OtherObject
+
+To get the I<by value> treatment of the Visual Basic C<Let> statement
+
+ Object.Property = OtherObject
+
+you have to use the LetProperty() object method in Perl:
+
+ $Object->LetProperty($Property, $OtherObject);
+
+LetProperty() also supports optional arguments for the property assignment.
+See L<OBJECT->SetProperty(NAME,ARGS,VALUE)> for details.
+
+=item Win32::OLE->MessageLoop()
+
+The MessageLoop() class method will run a standard Windows message
+loop, dispatching messages until the QuitMessageLoop() class method is
+called. It is used to wait for OLE events.
+
+=item Win32::OLE->Option(OPTION)
+
+The Option() class method can be used to inspect and modify
+L<Module Options>. The single argument form retrieves the value of
+an option:
+
+ my $CP = Win32::OLE->Option('CP');
+
+A single call can be used to set multiple options simultaneously:
+
+ Win32::OLE->Option(CP => CP_ACP, Warn => 3);
+
+=item Win32::OLE->QueryObjectType(OBJECT)
+
+The QueryObjectType() class method returns a list of the type library
+name and the objects class name. In a scalar context it returns the
+class name only. It returns C<undef> when the type information is not
+available.
+
+=item Win32::OLE->QuitMessageLoop()
+
+The QuitMessageLoop() class method posts a (user-level) "Quit" message
+to the current threads message loop. QuitMessageLoop() is typically
+called from an event handler. The MessageLoop() class method will
+return when it receives this "Quit" method.
+
+=item OBJECT->SetProperty(NAME,ARGS,VALUE)
+
+The SetProperty() method allows to modify properties with arguments,
+which is not supported by the hash syntax. The hash form
+
+ $Object->{Property} = $Value;
+
+is equivalent to
+
+ $Object->SetProperty('Property', $Value);
+
+Arguments must be specified between the property name and the new value:
+
+ $Object->SetProperty('Property', @Args, $Value);
+
+It is not possible to use "named argument" syntax with this function
+because the new value must be the last argument to SetProperty().
+
+This method hides any native OLE object method called SetProperty().
+The native method will still be available through the Invoke() method:
+
+ $Object->Invoke('SetProperty', @Args);
+
+=item Win32::OLE->SpinMessageLoop
+
+This class method retrieves all pending messages from the message queue
+and dispatches them to their respective window procedures. Calling this
+method is only necessary when not using the COINIT_MULTITHREADED model.
+All OLE method calls and property accesses automatically process the
+message queue.
+
+=item Win32::OLE->Uninitialize
+
+The Uninitialize() class method uninitializes the OLE subsystem. It
+also destroys the hidden top level window created by OLE for single
+threaded apartments. All OLE objects will become invalid after this call!
+It is possible to call the Initialize() class method again with a different
+apartment model after shutting down OLE with Uninitialize().
+
+=item Win32::OLE->WithEvents(OBJECT[, HANDLER[, INTERFACE]])
+
+This class method enables and disables the firing of events by the
+specified OBJECT. If no HANDLER is specified, then events are
+disconnected. For some objects Win32::OLE is not able to
+automatically determine the correct event interface. In this case the
+INTERFACE argument must contain either the COCLASS name of the OBJECT
+or the name of the event DISPATCH interface. Please read the L<Events>
+section below for detailed explanation of the Win32::OLE event
+support.
+
+=back
+
+Whenever Perl does not find a method name in the Win32::OLE package it
+is automatically used as the name of an OLE method and this method call
+is dispatched to the OLE server.
+
+There is one special hack built into the module: If a method or property
+name could not be resolved with the OLE object, then the default method
+of the object is called with the method name as its first parameter. So
+
+ my $Sheet = $Worksheets->Table1;
+or
+ my $Sheet = $Worksheets->{Table1};
+
+is resolved as
+
+ my $Sheet = $Worksheet->Item('Table1');
+
+provided that the $Worksheets object does not have a C<Table1> method
+or property. This hack has been introduced to call the default method
+of collections which did not name the method in their type library. The
+recommended way to call the "unnamed" default method is:
+
+ my $Sheet = $Worksheets->Invoke('', 'Table1');
+
+This special hack is disabled under C<use strict 'subs';>.
+
+=head2 Object methods and properties
+
+The object returned by the new() method can be used to invoke
+methods or retrieve properties in the same fashion as described
+in the documentation for the particular OLE class (eg. Microsoft
+Excel documentation describes the object hierarchy along with the
+properties and methods exposed for OLE access).
+
+Optional parameters on method calls can be omitted by using C<undef>
+as a placeholder. A better way is to use named arguments, as the
+order of optional parameters may change in later versions of the OLE
+server application. Named parameters can be specified in a reference
+to a hash as the last parameter to a method call.
+
+Properties can be retrieved or set using hash syntax, while methods
+can be invoked with the usual perl method call syntax. The C<keys>
+and C<each> functions can be used to enumerate an object's properties.
+Beware that a property is not always writable or even readable (sometimes
+raising exceptions when read while being undefined).
+
+If a method or property returns an embedded OLE object, method
+and property access can be chained as shown in the examples below.
+
+=head2 Functions
+
+The following functions are not exported by default.
+
+=over 8
+
+=item HRESULT(ERROR)
+
+The HRESULT() function converts an unsigned number into a signed HRESULT
+error value as used by OLE internally. This is necessary because Perl
+treats all hexadecimal constants as unsigned. To check if the last OLE
+function returned "Member not found" (0x80020003) you can write:
+
+ if (Win32::OLE->LastError == HRESULT(0x80020003)) {
+ # your error recovery here
+ }
+
+=item in(COLLECTION)
+
+If COLLECTION is an OLE collection object then C<in $COLLECTION>
+returns a list of all members of the collection. This is a shortcut
+for C<Win32::OLE::Enum-E<gt>All($COLLECTION)>. It is most commonly used in
+a C<foreach> loop:
+
+ foreach my $value (in $collection) {
+ # do something with $value here
+ }
+
+=item valof(OBJECT)
+
+Normal assignment of Perl OLE objects creates just another reference
+to the OLE object. The valof() function explictly dereferences the
+object (through the default method) and returns the value of the object.
+
+ my $RefOf = $Object;
+ my $ValOf = valof $Object;
+ $Object->{Value} = $NewValue;
+
+Now $ValOf still contains the old value whereas $RefOf would
+resolve to the $NewValue because it is still a reference to
+$Object.
+
+The valof() function can also be used to convert Win32::OLE::Variant
+objects to Perl values.
+
+=item with(OBJECT, PROPERTYNAME => VALUE, ...)
+
+This function provides a concise way to set the values of multiple
+properties of an object. It iterates over its arguments doing
+C<$OBJECT-E<gt>{PROPERTYNAME} = $VALUE> on each trailing pair.
+
+=back
+
+=head2 Overloading
+
+The Win32::OLE objects can be overloaded to automatically convert to
+their values whenever they are used in a bool, numeric or string
+context. This is not enabled by default. You have to request it
+through the OVERLOAD pseudoexport:
+
+ use Win32::OLE qw(in valof with OVERLOAD);
+
+You can still get the original string representation of an object
+(C<Win32::OLE=0xDEADBEEF>), e.g. for debugging, by using the
+C<overload::StrVal()> method:
+
+ print overload::StrVal($object), "\n";
+
+Please note that C<OVERLOAD> is a global setting. If any module enables
+Win32::OLE overloading then it's active everywhere.
+
+=head2 Events
+
+The Win32::OLE module now contains B<ALPHA> level event support. This
+support is only available when Perl is running in a single threaded
+apartment. This can most easily be assured by using the C<EVENTS>
+pseudo-import:
+
+ use Win32::OLE qw(EVENTS);
+
+which implicitly does something like:
+
+ use Win32::OLE;
+ Win32::OLE->Initialize(Win32::OLE::COINIT_OLEINITIALIZE);
+
+The current interface to OLE events should be considered experimental
+and is subject to change. It works as expected for normal OLE
+applications, but OLE control events often don't seem to work yet.
+
+Events must be enabled explicitly for an OLE object through the
+Win32::OLE->WithEvents() class method. The Win32::OLE module uses the
+IProvideClassInfo2 interface to determine the default event source of
+the object. If this interface is not supported, then the user must
+specify the name of the event source explicitly in the WithEvents()
+method call. It is also possible to specify the class name of the
+object as the third parameter. In this case Win32::OLE will try to
+look up the default source interface for this COCLASS.
+
+The HANDLER argument to Win32::OLE->WithEvents() can either be a CODE
+reference or a package name. In the first case, all events will invoke
+this particular function. The first two arguments to this function will
+be the OBJECT itself and the name of the event. The remaining arguments
+will be event specific.
+
+ sub Event {
+ my ($Obj,$Event, at Args) = @_;
+ print "Event triggered: '$Event'\n";
+ }
+ Win32::OLE->WithEvents($Obj, \&Event);
+
+Alternatively the HANDLER argument can specify a package name. When the
+OBJECT fires an event, Win32::OLE will try to find a function of the same
+name as the event in this package. This function will be called with the
+OBJECT as the first argument followed again by the event specific parameters:
+
+ package MyEvents;
+ sub EventName1 {
+ my ($Obj, at Args) = @_;
+ print "EventName1 event triggered\n";
+ }
+
+ package main;
+ Win32::OLE->WithEvents($Obj, 'MyEvents', 'IEventInterface');
+
+If Win32::OLE doesn't find a function with the name of the event then nothing
+happens.
+
+Event parameters passed I<by reference> are handled specially. They are not
+converted to the corresponding Perl datatype but passed as Win32::OLE::Variant
+objects. You can assign a new value to these objects with the help of the
+Put() method. This value will be passed back to the object when the event
+function returns:
+
+ package MyEvents;
+ sub BeforeClose {
+ my ($self,$Cancel) = @_;
+ $Cancel->Put(1) unless $MayClose;
+ }
+
+Direct assignment to $Cancel would have no effect on the original value and
+would therefore not command the object to abort the closing action.
+
+=head2 Module Options
+
+The following module options can be accessed and modified with the
+C<Win32::OLE-E<gt>Option> class method. In earlier versions of the Win32::OLE
+module these options were manipulated directly as class variables. This
+practice is now deprecated.
+
+=over 8
+
+=item CP
+
+This variable is used to determine the codepage used by all
+translations between Perl strings and Unicode strings used by the OLE
+interface. The default value is CP_ACP, which is the default ANSI
+codepage. Other possible values are CP_OEMCP, CP_MACCP, CP_UTF7 and
+CP_UTF8. These constants are not exported by default.
+
+=item LCID
+
+This variable controls the locale identifier used for all OLE calls.
+It is set to LOCALE_NEUTRAL by default. Please check the
+L<Win32::OLE::NLS> module for other locale related information.
+
+=item Variant
+
+This options controls how method calls and property accessors return
+values of type VT_CY and VT_DECIMAL are being returned. By default
+VT_CY values are turned into strings and VT_DECIMAL values into
+floating point numbers. If the C<Variant> option is enabled, these
+values are returned as Win32::OLE::Variant objects, just like VT_DATE
+and VT_ERROR values. If the Win32::OLE::Variant module is also
+loaded, then all values should still behave as before in string and in
+numeric context.
+
+The only reason that the C<Variant> behavior is not the default is that
+this is an incompatible change that might break existing programs.
+
+=item Warn
+
+This variable determines the behavior of the Win32::OLE module when
+an error happens. Valid values are:
+
+ 0 Ignore error, return undef
+ 1 Carp::carp if $^W is set (-w option)
+ 2 always Carp::carp
+ 3 Carp::croak
+
+The error number and message (without Carp line/module info) are
+available through the C<Win32::OLE-E<gt>LastError> class method.
+
+Alternatively the Warn option can be set to a CODE reference. E.g.
+
+ Win32::OLE->Option(Warn => 3);
+
+is equivalent to
+
+ Win32::OLE->Option(Warn => \&Carp::croak);
+
+This can even be used to emulate the VisualBasic C<On Error Goto
+Label> construct:
+
+ Win32::OLE->Option(Warn => sub {goto CheckError});
+ # ... your normal OLE code here ...
+
+ CheckError:
+ # ... your error handling code here ...
+
+=item _NewEnum
+
+This option enables additional enumeration support for collection
+objects. When the C<_NewEnum> option is set, all collections will
+receive one additional property: C<_NewEnum>. The value of this
+property will be a reference to an array containing all the elements
+of the collection. This option can be useful when used in conjunction
+with an automatic tree traversal program, like C<Data::Dumper> or an
+object tree browser. The value of this option should be either 1
+(enabled) or 0 (disabled, default).
+
+ Win32::OLE->Option(_NewEnum => 1);
+ # ...
+ my @sheets = @{$Excel->Worksheets->{_NewEnum}};
+
+In normal application code, this would be better written as:
+
+ use Win32::OLE qw(in);
+ # ...
+ my @sheets = in $Excel->Worksheets;
+
+=item _Unique
+
+The C<_Unique> options guarantees that Win32::OLE will maintain a
+one-to-one mapping between Win32::OLE objects and the native COM/OLE
+objects. Without this option, you can query the same property twice
+and get two different Win32::OLE objects for the same underlying COM
+object.
+
+Using a unique proxy makes life easier for tree traversal algorithms
+to recognize they already visited a particular node. This option
+comes at a price: Win32::OLE has to maintain a global hash of all
+outstanding objects and their corresponding proxies. Identity checks
+on COM objects can also be expensive if the objects reside
+out-of-process or even on a different computer. Therefore this option
+is off by default unless the program is being run in the debugger.
+
+Unfortunately, this option doesn't always help. Some programs will
+return new COM objects for even the same property when asked for it
+multiple times (especially for collections). In this case, there is
+nothing Win32::OLE can do to detect that these objects are in fact
+identical (because they aren't at the COM level).
+
+The C<_Unique> option can be set to either 1 (enabled) or 0 (disabled,
+default).
+
+=back
+
+=head1 EXAMPLES
+
+Here is a simple Microsoft Excel application.
+
+ use Win32::OLE;
+
+ # use existing instance if Excel is already running
+ eval {$ex = Win32::OLE->GetActiveObject('Excel.Application')};
+ die "Excel not installed" if $@;
+ unless (defined $ex) {
+ $ex = Win32::OLE->new('Excel.Application', sub {$_[0]->Quit;})
+ or die "Oops, cannot start Excel";
+ }
+
+ # get a new workbook
+ $book = $ex->Workbooks->Add;
+
+ # write to a particular cell
+ $sheet = $book->Worksheets(1);
+ $sheet->Cells(1,1)->{Value} = "foo";
+
+ # write a 2 rows by 3 columns range
+ $sheet->Range("A8:C9")->{Value} = [[ undef, 'Xyzzy', 'Plugh' ],
+ [ 42, 'Perl', 3.1415 ]];
+
+ # print "XyzzyPerl"
+ $array = $sheet->Range("A8:C9")->{Value};
+ for (@$array) {
+ for (@$_) {
+ print defined($_) ? "$_|" : "<undef>|";
+ }
+ print "\n";
+ }
+
+ # save and exit
+ $book->SaveAs( 'test.xls' );
+ undef $book;
+ undef $ex;
+
+Please note the destructor specified on the Win32::OLE->new method. It ensures
+that Excel will shutdown properly even if the Perl program dies. Otherwise
+there could be a process leak if your application dies after having opened
+an OLE instance of Excel. It is the responsibility of the module user to
+make sure that all OLE objects are cleaned up properly!
+
+Here is an example of using Variant data types.
+
+ use Win32::OLE;
+ use Win32::OLE::Variant;
+ $ex = Win32::OLE->new('Excel.Application', \&OleQuit) or die "oops\n";
+ $ex->{Visible} = 1;
+ $ex->Workbooks->Add;
+ # should generate a warning under -w
+ $ovR8 = Variant(VT_R8, "3 is a good number");
+ $ex->Range("A1")->{Value} = $ovR8;
+ $ex->Range("A2")->{Value} = Variant(VT_DATE, 'Jan 1,1970');
+
+ sub OleQuit {
+ my $self = shift;
+ $self->Quit;
+ }
+
+The above will put value "3" in cell A1 rather than the string
+"3 is a good number". Cell A2 will contain the date.
+
+Similarly, to invoke a method with some binary data, you can
+do the following:
+
+ $obj->Method( Variant(VT_UI1, "foo\000b\001a\002r") );
+
+Here is a wrapper class that basically delegates everything but
+new() and DESTROY(). The wrapper class shown here is another way to
+properly shut down connections if your application is liable to die
+without proper cleanup. Your own wrappers will probably do something
+more specific to the particular OLE object you may be dealing with,
+like overriding the methods that you may wish to enhance with your
+own.
+
+ package Excel;
+ use Win32::OLE;
+
+ sub new {
+ my $s = {};
+ if ($s->{Ex} = Win32::OLE->new('Excel.Application')) {
+ return bless $s, shift;
+ }
+ return undef;
+ }
+
+ sub DESTROY {
+ my $s = shift;
+ if (exists $s->{Ex}) {
+ print "# closing connection\n";
+ $s->{Ex}->Quit;
+ return undef;
+ }
+ }
+
+ sub AUTOLOAD {
+ my $s = shift;
+ $AUTOLOAD =~ s/^.*:://;
+ $s->{Ex}->$AUTOLOAD(@_);
+ }
+
+ 1;
+
+The above module can be used just like Win32::OLE, except that
+it takes care of closing connections in case of abnormal exits.
+Note that the effect of this specific example can be easier accomplished
+using the optional destructor argument of Win32::OLE::new:
+
+ my $Excel = Win32::OLE->new('Excel.Application', sub {$_[0]->Quit;});
+
+Note that the delegation shown in the earlier example is not the same as
+true subclassing with respect to further inheritance of method calls in your
+specialized object. See L<perlobj>, L<perltoot> and L<perlbot> for details.
+True subclassing (available by setting C<@ISA>) is also feasible,
+as the following example demonstrates:
+
+ #
+ # Add error reporting to Win32::OLE
+ #
+
+ package Win32::OLE::Strict;
+ use Carp;
+ use Win32::OLE;
+
+ use strict qw(vars);
+ use vars qw($AUTOLOAD @ISA);
+ @ISA = qw(Win32::OLE);
+
+ sub AUTOLOAD {
+ my $obj = shift;
+ $AUTOLOAD =~ s/^.*:://;
+ my $meth = $AUTOLOAD;
+ $AUTOLOAD = "SUPER::" . $AUTOLOAD;
+ my $retval = $obj->$AUTOLOAD(@_);
+ unless (defined($retval) || $AUTOLOAD eq 'DESTROY') {
+ my $err = Win32::OLE::LastError();
+ croak(sprintf("$meth returned OLE error 0x%08x",$err))
+ if $err;
+ }
+ return $retval;
+ }
+
+ 1;
+
+This package inherits the constructor new() from the Win32::OLE
+package. It is important to note that you cannot later rebless a
+Win32::OLE object as some information about the package is cached by
+the object. Always invoke the new() constructor through the right
+package!
+
+Here's how the above class will be used:
+
+ use Win32::OLE::Strict;
+ my $Excel = Win32::OLE::Strict->new('Excel.Application', 'Quit');
+ my $Books = $Excel->Workbooks;
+ $Books->UnknownMethod(42);
+
+In the sample above the call to UnknownMethod() will be caught with
+
+ UnknownMethod returned OLE error 0x80020009 at test.pl line 5
+
+because the Workbooks object inherits the class C<Win32::OLE::Strict> from the
+C<$Excel> object.
+
+=head1 NOTES
+
+=head2 Hints for Microsoft Office automation
+
+=over 8
+
+=item Documentation
+
+The object model for the Office applications is defined in the Visual Basic
+reference guides for the various applications. These are typically not
+installed by default during the standard installation. They can be added
+later by rerunning the setup program with the custom install option.
+
+=item Class, Method and Property names
+
+The names have been changed between different versions of Office. For
+example C<Application> was a method in Office 95 and is a property in
+Office97. Therefore it will not show up in the list of property names
+C<keys %$object> when querying an Office 95 object.
+
+The class names are not always identical to the method/property names
+producing the object. E.g. the C<Workbook> method returns an object of
+type C<Workbook> in Office 95 and C<_Workbook> in Office 97.
+
+=item Moniker (GetObject support)
+
+Office applications seem to implement file monikers only. For example
+it seems to be impossible to retrieve a specific worksheet object through
+C<GetObject("File.XLS!Sheet")>. Furthermore, in Excel 95 the moniker starts
+a Worksheet object and in Excel 97 it returns a Workbook object. You can use
+either the Win32::OLE::QueryObjectType class method or the $object->{Version}
+property to write portable code.
+
+=item Enumeration of collection objects
+
+Enumerations seem to be incompletely implemented. Office 95 application don't
+seem to support neither the Reset() nor the Clone() methods. The Clone()
+method is still unimplemented in Office 97. A single walk through the
+collection similar to Visual Basics C<for each> construct does work however.
+
+=item Localization
+
+Starting with Office 97 Microsoft has changed the localized class, method and
+property names back into English. Note that string, date and currency
+arguments are still subject to locale specific interpretation. Perl uses the
+system default locale for all OLE transaction whereas Visual Basic uses a
+type library specific locale. A Visual Basic script would use "R1C1" in string
+arguments to specify relative references. A Perl script running on a German
+language Windows would have to use "Z1S1". Set the LCID module option
+to an English locale to write portable scripts. This variable should
+not be changed after creating the OLE objects; some methods seem to randomly
+fail if the locale is changed on the fly.
+
+=item SaveAs method in Word 97 doesn't work
+
+This is an known bug in Word 97. Search the MS knowledge base for Word /
+Foxpro incompatibility. That problem applies to the Perl OLE interface as
+well. A workaround is to use the WordBasic compatibility object. It doesn't
+support all the options of the native method though.
+
+ $Word->WordBasic->FileSaveAs($file);
+
+The problem seems to be fixed by applying the Office 97 Service Release 1.
+
+=item Randomly failing method calls
+
+It seems like modifying objects that are not selected/activated is sometimes
+fragile. Most of these problems go away if the chart/sheet/document is
+selected or activated before being manipulated (just like an interactive
+user would automatically do it).
+
+=back
+
+=head2 Incompatibilities
+
+There are some incompatibilities with the version distributed by Activeware
+(as of build 306).
+
+=over 8
+
+=item 1
+
+The package name has changed from "OLE" to "Win32::OLE".
+
+=item 2
+
+All functions of the form "Win32::OLEFoo" are now "Win32::OLE::Foo",
+though the old names are temporarily accommodated. Win32::OLECreateObject()
+was changed to Win32::OLE::CreateObject(), and is now called
+Win32::OLE::new() bowing to established convention for naming constructors.
+The old names should be considered deprecated, and will be removed in the
+next version.
+
+=item 3
+
+Package "OLE::Variant" is now "Win32::OLE::Variant".
+
+=item 4
+
+The Variant function is new, and is exported by default. So are
+all the VT_XXX type constants.
+
+=item 5
+
+The support for collection objects has been moved into the package
+Win32::OLE::Enum. The C<keys %$object> method is now used to enumerate
+the properties of the object.
+
+=back
+
+=head2 Bugs and Limitations
+
+=over 8
+
+=item *
+
+To invoke a native OLE method with the same name as one of the
+Win32::OLE methods (C<Dispatch>, C<Invoke>, C<SetProperty>, C<DESTROY>,
+etc.), you have to use the C<Invoke> method:
+
+ $Object->Invoke('Dispatch', @AdditionalArgs);
+
+The same is true for names exported by the Exporter or the Dynaloader
+modules, e.g.: C<export>, C<export_to_level>, C<import>,
+C<_push_tags>, C<export_tags>, C<export_ok_tags>, C<export_fail>,
+C<require_version>, C<dl_load_flags>,
+C<croak>, C<bootstrap>, C<dl_findfile>, C<dl_expandspec>,
+C<dl_find_symbol_anywhere>, C<dl_load_file>, C<dl_find_symbol>,
+C<dl_undef_symbols>, C<dl_install_xsub> and C<dl_error>.
+
+=back
+
+=head1 SEE ALSO
+
+The documentation for L<Win32::OLE::Const>, L<Win32::OLE::Enum>,
+L<Win32::OLE::NLS> and L<Win32::OLE::Variant> contains additional
+information about OLE support for Perl on Win32.
+
+=head1 AUTHORS
+
+Originally put together by the kind people at Hip and Activeware.
+
+Gurusamy Sarathy <gsar at cpan.org> subsequently fixed several
+major bugs, memory leaks, and reliability problems, along with some
+redesign of the code.
+
+Jan Dubois <jand at activestate.com> pitched in with yet more massive redesign,
+added support for named parameters, and other significant enhancements.
+He's been hacking on it ever since.
+
+Please send questions about problems with this module to the
+Perl-Win32-Users mailinglist at ActiveState.com. The mailinglist charter
+requests that you put an [OLE] tag somewhere on the subject line (for OLE
+related questions only, of course).
+
+=head1 COPYRIGHT
+
+ (c) 1995 Microsoft Corporation. All rights reserved.
+ Developed by ActiveWare Internet Corp., now known as
+ ActiveState Tool Corp., http://www.ActiveState.com
+
+ Other modifications Copyright (c) 1997-2006 by Gurusamy Sarathy
+ <gsar at cpan.org> and Jan Dubois <jand at activestate.com>
+
+ You may distribute under the terms of either the GNU General Public
+ License or the Artistic License, as specified in the README file.
+
+=head1 VERSION
+
+Version 0.1712 14 May 2014
+
+=cut
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/Win32/OLE.pm
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/.packlist
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/.packlist (rev 0)
+++ trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/.packlist 2020-03-08 17:43:21 UTC (rev 54174)
@@ -0,0 +1,11 @@
+D:\tlperl\site\lib\OLE.pm
+D:\tlperl\site\lib\Win32\OLE.pm
+D:\tlperl\site\lib\Win32\OLE\Const.pm
+D:\tlperl\site\lib\Win32\OLE\Enum.pm
+D:\tlperl\site\lib\Win32\OLE\Lite.pm
+D:\tlperl\site\lib\Win32\OLE\NEWS.pod
+D:\tlperl\site\lib\Win32\OLE\NLS.pm
+D:\tlperl\site\lib\Win32\OLE\TPJ.pod
+D:\tlperl\site\lib\Win32\OLE\TypeInfo.pm
+D:\tlperl\site\lib\Win32\OLE\Variant.pm
+D:\tlperl\site\lib\auto\Win32\OLE\OLE.dll
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/.packlist
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/OLE.dll
===================================================================
(Binary files differ)
Index: trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/OLE.dll
===================================================================
--- trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/OLE.dll 2020-03-08 13:58:35 UTC (rev 54173)
+++ trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/OLE.dll 2020-03-08 17:43:21 UTC (rev 54174)
Property changes on: trunk/Master/tlpkg/tlperl/site/lib/auto/Win32/OLE/OLE.dll
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+application/octet-stream
\ No newline at end of property
More information about the tex-live-commits
mailing list.