Hi there,

at the moment it is not possible to fetch the IDL-help texts at runtime via
reflection. For that reason I would like to request such a feature, but before
doing so, a discussion about the usefulness of such a feature may be in order.

So please let me talk for a few seconds about MS Windows OLE, where it is
possible (if the software provides the information) to query the documentation
for the OLE classes, its methods, its attributes and its events *at* *runtime*.
Because of this, I was able a few years ago to create a little utility which
dumps the OLE interfaces (methods, attributes, events) and formats them in HTML
(using a CSS). In addition, using MSIE and having ooRexx installed one could
even switch sections on/off (important e.g. for looking at the interfaces e.g.
Excel or Word supplies, looking at the defined constants which may go into the
hundreds (e.g. Excel 2003 defines 1,542 constants, Word 2003 defines 2,757
constants).

Anyway, it has become possible with this little utility to either supply the
PROGID or CLSID value of an OLE class and get its defined interfaces back.

Here is a full and a compact list of the interfaces MS InternetExplorer defines:

   * <http://wi.wu-wien.ac.at/rgf/rexx/orx13/tmp/InternetExplorer.Application_0.html
      >
     full listing (includes a constant section)
   * <http://wi.wu-wien.ac.at/rgf/rexx/orx13/tmp/InternetExplorer.Application_1.html
      >
     compact listing (folds attributes, does not document constants).

These listings can be printed out and may serve as some sort of reference cards,
which helps gain an overview about the features a particular OLE class supplies.
[The utility set is briefly described at and could be downloaded from:
<http://wi.wu-wien.ac.at/rgf/rexx/orx15/readme.html>.]

---

Now turning to OOo: as anyone who wants to script/program an OOo component
knows, the research of the available interfaces may be quite cumbersome, if
clicking from one defined class to the next, then needing to get back to the
original area and follow another path (by e.g. exploring the interfaces of
another interface or service). Although practically everything is documented (at
least briefly), it is very hard to gain an overview or being able to explore an
area of interest just using the IDL definitions on their own.

If there was an ability to use reflection to get at the information/help text
that goes with the IDL definition, then one would get the ability to devise
utilities which may help mastering different areas of OOo in an innovative and
(hopefully!) easier way. E.g. when turning to a text-component service object,
one is interested about its immediate abilities, but also about those one can
get access to by requesting interfaces form it. It would be possible, to explore
everything at runtime (e.g. defining a depth of 3 links) and render the found
definitions together with their definition in a much more concentrated,
domain-related form.

Personally, I am convinced that such a utility would help jump-start developers
and scripters who are newbies, but also those who are turning to a new area of
OOo, with which they have never worked before.

Such a functionality becomes only possible, if it was possible to query the text
going with the IDL definition at runtime via reflection (e.g. get the first
sentence, get all text, get it as plain text or formatted text, e.g. in HTML,
etc.). This would imply that the IDL compiler would include the text-information
and the creation of a method allowing to get at such text at runtime via
reflection. (Also, of course, the information would become readily
available/updated, each time the IDL compiler is run.)

So, what would you think (especially looking at what is possible in the Windows
world w.r.t. OLE supplying published information on its definitions)?

Regards,

---rony

P.S.: I posted this to <dev@OOo> and <api@OOo> lists, because both may be
affected/interested in this.