On 23/03/2006, at 9:44 AM, Robin Laing wrote:
Jallan wrote:
Robin Laing wrote:
Styles such as T1, T2 and so forth are defined in any OOo
Content.xml I've looked at, if they exist. They are invented
styles based on any direct formatting in the document. For
example, if the user applies italics to some text through direct
formatting, OOo Writer, on saving, will create a T-something style
with the attribute "italic" and the code will use it in the places
where the user has directly applied the italic attribute to text.
You should find their definitions somewhere in content.xlm before
they are actually used.
Yes the definitions are at the beginning of content.xml. If you
make a change, the T(numbers) will change to remain linear.
In the content.xml, things look pretty linear to me.
Yes, the source code is linear and the actual text in memory is
linear, in that it proceeds from beginning to end, at least if you
look at it in that fashion. How it is stored is another matter but
is irrelevant to higher level examination, just as you don't care
exactly which blocks of a disk are used by a file and in what
order they are used.
But in memory the sections of text are resolved into objects with
various formatting attributes based on the tags and the tags
themselves utterly vanish.
This is where things could be fun. There are tags that indicate
all the formatting for that section in memory. Why can't that
formatting information be displayed on an editable pop-up. Or at
least be able to be marked when View > Non Printing Characters is
selected?
SNIP!
The tags that are in the final xml documents are not really something
that can be used directly in the use of OpenOffice.org. You must
remember that with the xml files, generally these are translated/
transformed into something more usable in the application - in OOo's
case, into objects that match the styles/formatting/language settings
etc. The xml file can be read in a linear fashion which would work
for reveal code style display, but it is not how the program uses
objects when running. To do what you suggest, you would have to work
with a temporary xml file in memory to do the linear-style reads/
changes as well as the object-based design.
A structure map, to me is very similar to Reveal Codes in that if
your cursor is at a set location, you would know what is
happening. It would be a decent tool for debugging. As the
properties such as {com.sun.star.style.CharacterProperties} are in
memory, then they could be displayed. And if I had a way of
showing where there were formatting changes as with non-printing
characters, then it would provide a tool to find those troublesome
properties. This is what I see as Reveal Codes.
If only everyone could see reveal codes as a structure diagram :-)
Regards
Jonathon
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
