I'm trying to use the Win32::OLE module to control a Windows application. I know that the developers of the application provide an OLE Object to control it, but I don't know the name of the object.
On an old version of the program, I managed to reference the object in Perl by the following line:
$ref = new Win32::OLE 'object.name'
but the new version of the program has a different object name.
Is there any way of checking which OLE objects exist for applications that are currently running on Windows?
Win32::OLE comes with an OLE browser. Keep in mind, it only works with Internet Explorer and only when you load the HTML document from your local system.
Of course, you could also install Microsoft's development tools and get the native OLE/COM Object Viewer:
You can also find the names and components of Win32::OLE objects for other products (Excel, Word) by starting the product, then typing Alt-F11. This should open the VBA editor. Once in the VBA editor, type F2 (or use the pull-down menu from View) to start the Object Browser. This will list the objects relevant to that product. Here is an example from Excel.
I am a 3rd party, and I would like to start an 1st party application and virtualize somehow a document folder that I would decide the location.
The first application would not touch the real 'my document' folder but instead save the file in a location I would set.
I don't want to change the registry entries for the personal folders, I want it just for this application.
I did some research but didn't find anything like that. Is that possible without a virtual machine? I would try to work in VB6, I want to test something on xp and win7. It's about a game redesign, and I would like the person to be able to have my program, and the original game installed on the PC without the configuration folders in 'my document' colliding.
I should mention that I cannot pass parameters to it because I am launching the 1st party application through a 2nd party executable already.
Thank you!
Yanick
Of course you can, with a text file (or a program). MS made it easy.
Here is someone quoting my post, who is quoting Raymond Chen directly,
http://www.pcreview.co.uk/threads/re-create-system-folder.522854/
Creating Shell Extensions with Shell Instance Objects
Raymond Chen
Microsoft Corporation
February 2000
Summary: A traditional shell namespace extension requires the implementation
of a COM in-process server. Shell instance objects allow you to create
simple shell extensions without having to write a single line of code. This
article describes how shell instance objects and shell command objects can
be used to easily deploy simple shell extensions. (5 printed pages)
Contents
What Is a Shell Namespace Extension?
What Is a Shell Instance Object?
Shell Objects That Can Be Created as Shell Instance Objects
How About an Example?
Shell Command Objects
Conclusion
What Is a Shell Namespace Extension?
Shell namespace extensions allow you to create "virtual folders" in the
shell. For example, the Recycle Bin icon on the desktop is not an actual
file system directory, but rather represents a collection of items that is
maintained by the Recycle Bin shell extension.
Details on creating shell namespace extensions can be found in the Platform
SDK section of the MSDN Online Library
(http://msdn.microsoft.com/library/psdk/shellcc/shell/shell_adv/namespace.ht
m).
Writing a shell namespace extension can be quite an ordeal. Fortunately, the
shell provides an easy way to create certain types of simple shell namespace
extensions, as this article will show.
What Is a Shell Instance Object?
A shell instance object is a special kind of shell extension provided by the
shdocvw.dll component. Whereas a traditional shell extension requires a DLL
to implement the object, a shell instance object retrieves everything it
needs to know from the registry.
How the shell creates a shell instance object
1.. The shdocvw.dll component is loaded by virtue of being registered as
the InProcServer32 for the shell instance object.
2.. When shdocvw.dll is asked to create an object it does not otherwise
recognize, it checks the registry key for a subkey named Instance. If found,
it reads the CLSID value of that subkey and passes that CLSID to the
CoCreateInstance function. (For lack of a better term, let's call this the
"host" object.)
3.. Next, shdocvw.dll looks for a subkey of Instance named InitPropertyBag
or InitStream. If found, it then creates an IPropertyBag or IStream
(accordingly) based on the contents of the registry key and passes it to the
IPersistPropertyBag::Load or IPersistStream::Load method (accordingly).
4.. Finally, shdocvw.dll returns the now-initialized host object as the
shell instance object.
Shell Objects That Can Be Created as Shell Instance Objects
There are two shell objects that support being the host object of a shell
instance object, namely the Shell link object and the Shell folder shortcut
object.
Both of these objects support the IPersistPropertyBag interface, so you can
use the InitPropertyBag method of initializing them. (It so happens that
both objects also support IPersistStream, but initializing a shortcut from a
registry stream is much more cumbersome.)
The property bag you provide in the registry describes the target of the
shell link or shell folder shortcut object. There are three supported forms
for this property bag.
Targeting a shell special folder
InitPropertyBag
TargetSpecialFolder=REG_SZ:"<special folder number>"
Notice that this is a REG_SZ registry value even though it represents an
integer. Both decimal and hex notation are supported.
Targeting a directory inside a shell special folder
InitPropertyBag
TargetSpecialFolder=REG_SZ:"<special folder number>"
Target=REG_SZ:"<subdirectory name>"
The subdirectory name can contain embedded backslashes.
Targeting a directory by explicit path
InitPropertyBag
Target=REG_SZ:"<full path to target directory>"
How About an Example?
Here's a copy of the registration that creates the Fonts folder icon in
Control Panel:
HKEY_CLASSES_ROOT
CLSID
{D20EA4E1-3957-11D2-A40B-0C5020524152}=REG_SZ:"Fonts"
InfoTip=REG_SZ:"Displays and manages fonts on your computer"
DefaultIcon=REG_EXPAND_SZ:"%SystemRoot%\system32\main.cpl,9"
InProcServer32=REG_EXPAND_SZ:"%SystemRoot%\system32\shdocvw.dll"
ThreadingModel=REG_SZ:"Apartment"
ShellFolder
Attributes=REG_DWORD:0x60000000
WantsFORPARSING=REG_SZ:""
Instance
CLSID=REG_SZ:"{0AFACED1-E828-11D1-9187-B532F1E9575D}"
InitPropertyBag
TargetSpecialFolder=REG_SZ:"0x0024"
Target=REG_SZ:"Fonts"
Because {D20EA4E1-3957-11D2-A40B-0C5020524152} is registered in the Control
Panel namespace, a Fonts folder shortcut is installed in Control Panel.
Let's go through this registry key step by step.
a.. The GUID {D20EA4E1-3957-11D2-A40B-0C5020524152} was generated by
running the uuidgen program found in the Platform SDK. Of course, when you
create your own instance objects, you should run uuidgen and use your own
GUID. The name of the icon as it appears in the namespace is also provided
here.
b.. The optional InfoTip string is displayed when the user hovers over the
icon.
c.. The DefaultIcon string provides the name and icon index for the icon
to display for this item.
d.. The InProcServer32 key must be set to the shdocvw.dll file, and the
threading model must be set to Apartment.
e.. The ShellFolder key sets the Attributes to a collection of SFGAO_
values, which we wish to apply to the folder shortcut. The SFGAO_FOLDER flag
must always be set. Because the target is a file system folder, the
SFGAO_FILESYSTEM flag is also set in the Attributes, and the WantsFORPARSING
value is set to an empty string. (If the target is not a file system folder,
the WantsFORPARSING value should not be created.)
f.. The Instance key sets the CLSID value to the string representation of
CLSID_FolderShortcut. This indicates that the object instance should create
a folder shortcut.
g.. The InitPropertyBag key indicates that the folder shortcut will be
initialized with the IPersistPropertyBag interface. The two values inside
the property bag specify that the target is the subdirectory "Fonts" in the
special folder 0x0024, which is CSIDL_WINDOWS.
Shell Command Objects
Another type of shell extension object is an icon that when double-clicked
runs a command. This, too, can be created without having to write a COM
server. For example, here is a command object that is used by the My Network
Places folder:
HKEY_CLASSES_ROOT
CLSID
{D4480A50-BA28-11d1-8E75-00C04FA31A86}=REG_SZ:"Add Network Place"
InfoTip=REG_SZ:"Connects to shared folders, Web folders, and FTP
sites."
DefaultIcon=REG_EXPAND_SZ:"%SystemRoot%\System32\netplwiz.dll,-107"
ShellFolder
Attributes=REG_DWORD:0x00000000
Shell
Open
Command=REG_EXPAND_SZ:"rundll32 ..."
Most of this registry key should look familiar, so I will only highlight the
differences from shell instance objects:
a.. There is no InProcServer32 key.
b.. The Attributes of the ShellFolder key should omit the SFGAO_FOLDER
flag because this item is not a folder.
c.. Instead of an Instance key, we have a Shell key, which has the same
structure as a progid key. The "Open" verb is the default action for
double-clicking. You can also create other verbs, which will appear on the
context menu. For example, the Internet Explorer icon creates a custom verb
called "Open Home Page."
Details on the structure of the Shell key can be found in the Platform SDK
section of the MSDN Online Library under the topic heading "Extending
Context Menus"
(http://msdn.microsoft.com/library/psdk/shellcc/shell/shell_basics/context.h
tm).
Conclusion
Shell instance objects and shell command objects allow you to deploy simple
shell extensions with a minimum amount of work. For example, you might
create a command object in the Control Panel folder called "Troubleshoot,"
which runs a troubleshoot program. Or you might create a shell instance
object that hosts a folder shortcut to a collection of system administrative
tools on a shared network server. Shell instance objects and shell command
objects allow you to easily deploy these types of shell extensions.
My solution was to search the executable with a hex editor and manually edit it to another folder. Of course I had to choose a folder with less or equal number or character in the path.
Thank you all.
Is it possible to hide the Driver script for each execution in HP-UFT?
Instead of using a driver script, you can create the COM object of Quicktest.Application inside your UI application itself. If you are using Excel as UI, you can use the same driver script code in a function and it will work in excel. All languages will have similar methods to create COM objects. A C# example would be this
Does anyone ever used an OLE or an ActiveX to modify the windows registry keys?
I have found some documentation to do it in command line, but I would like a way to program it otherwise.
Our context is an HTA application.
For COM objects to access the Registry from scripts or classic ASP you can choose from :
The "Set" methods of the WMI StdRegProv class : http://msdn.microsoft.com/en-us/library/aa394600%28v=vs.85%29.aspx
or
The WshShell RegWrite method http://msdn.microsoft.com/en-us/library/yfdfhz1b%28v=vs.85%29.aspx
How do I read a particular vb program settings or registry entry from the registry of the key "HKEY_USERS\S-1-5-21-1390067357-1965331169-725345543-1003\Software\VB and VBA Program Settings".A standardized way to read as the part after hikey_users and before software changes with the pc used,but the vb programs do write perfectly at the right place.Is there some variable that defines the registry key location ?
VB6 has built-in functions for manipulating the registry, like GetSetting. These functions use registry keys underneath HKEY_CURRENT_USER\Software\VB and VBA Program Settings
HKEY_USERS\S-1-5-21-1390067357-1965331169-725345543-1003\Software\VB and VBA Program Settings is just another path to the same set of keys: the long string in the middle identifies the current user by their ID, rather than just saying "the current user".
So the answer is:
If you are using VB6, just use GetSetting.
If you are using VBScript, use WshShell.RegRead and work on HKEY_CURRENT_USER\Software\VB and VBA Program Settings. Example code in this article.