[ff-cvs] fenfire/docs/pegboard/textnodeview_locate_curso...

[Asko Soukka]

CVSROOT:        /cvsroot/fenfire
Module name:    fenfire
Branch:         
Changes by:     Asko Soukka <address@hidden>    03/08/15 03:26:32

Modified files:
        docs/pegboard/textnodeview_locate_cursor--humppake: peg.rst 

Log message:
        grammar fix

CVSWeb URLs:
http://savannah.gnu.org/cgi-bin/viewcvs/fenfire/fenfire/docs/pegboard/textnodeview_locate_cursor--humppake/peg.rst.diff?tr1=1.1&tr2=1.2&r1=text&r2=text

Patches:
Index: fenfire/docs/pegboard/textnodeview_locate_cursor--humppake/peg.rst
diff -u fenfire/docs/pegboard/textnodeview_locate_cursor--humppake/peg.rst:1.1 
fenfire/docs/pegboard/textnodeview_locate_cursor--humppake/peg.rst:1.2
--- fenfire/docs/pegboard/textnodeview_locate_cursor--humppake/peg.rst:1.1      
Thu Aug 14 03:36:37 2003
+++ fenfire/docs/pegboard/textnodeview_locate_cursor--humppake/peg.rst  Fri Aug 
15 03:26:32 2003
@@ -4,62 +4,73 @@
 
 :Authors:  Asko Soukka
 :Date-Created: 2003-08-14
-:Last-Modified: $Date: 2003/08/14 07:36:37 $
-:Revision: $Revision: 1.1 $
+:Last-Modified: $Date: 2003/08/15 07:26:32 $
+:Revision: $Revision: 1.2 $
 :Status:   Current
 :Scope:    Trivial
 :Type:     Interface, Feature
 
-Mudyc asked me to think how text cursor could be located within
+Mudyc asked me to think how the text cursor could be located within a
 TextNodeView (currently ``org.fenfire.view.TextNodeView``). This PEG
-describes my solution proposal: two new methods for TextNodeView. One
-returning the cursor position according to coordinates within
-TextNodeView and another returning the coordinates of the cursor
-according to it's position (often referred as offset) within the text.
+describes my solution proposal for solving the problem: two new
+methods for TextNodeView. One would returning the cursor position
+according to coordinates within the TextNodeView and another would
+return the coordinates of the cursor according to it's position (often
+referred as offset) within the text.
 
 Issues
 ======
 
-Who knows position of cursors?
+Who is responsible for managing text cursor position? (The term
+`position` means here the cursor's offset within the text string.)
 
-       RESOLVED: The position is usually stored within demo
-        application. A spesific Cursor class may be used
+       RESOLVED: The text cursor position is usually stored within
+        a demo application. Also a spesific Cursor class may be used
         (``org.fengire.view.lava.Cursor``).
-        
-       NOTE: The term `position` means here only cursor's offset
-        within the text string.
+
+       RE-RESOLVED: Currently the text cursor position is usually stored
+        within a demo application, but Mudyc seems to be developing more
+        general cursor handling in Lava.
 
 But there is also a method ``getCursorOffset`` in
-``org.fenfire.view.lava.TextHandler`` (`the `TextNodeView``
+``org.fenfire.view.lava.TextHandler`` (which the `TextNodeView``
 inherits). Does it have any role?
 
-       RESOLVED: AFAIK, currently it's not used anywhere. ``Cursor``
-        is used instead of it.
+       RESOLVED: AFAIK, currently it's not used anywhere.
+
+       RE-RESOLVED: We need to ask Mudyc about the role of
+        ``TextHandler`` methods in ``TextNodeView`` and also his
+        cursor development in Lava.
+
+       Anyway, this peg is not dependent on the way of storing the
+        text cursor position.
 
-Who knows how text's lines are broken?
+Who is responsible for breaking a text string into lines?
 
-       RESOLVED: Only the used ``TextNodeView`` knows. It uses
-        LibVob's linebreaking code (``org.nongnu.libvob.linebreaking``).
-       The linebreaking information is formed only when needed (when
-        creating a placeable object) and is not stored.
+       RESOLVED: Only the used ``TextNodeView`` knows. Currently, it
+        uses LibVob's linebreaking code
+        (``org.nongnu.libvob.linebreaking``). The linebreaking
+       information is generated only when needed (when creating a
+        ``Placeable`` object) and is not stored.
 
-How the information of linebreaking can be reached?
+How can the linebreaking information be reached?
 
-        RESOLVED: The information is not stored within
-        ``TextNodeView``, but it could be reconstructed. 
+        RESOLVED: The ``TextNodeView`` objects do not store the
+        linebreaking information but can reconstruct it.
 
-Where the information of linebreaking could be reconstructed?
+Where could the information of linebreaking be reconstructed?
 
-       RESOLVED: The reconstruction is complex and is most practical
-        to do also within ``TextNodeView``, since it has already the
-        supportive  methods needed for easy use of linebreaking lib.
+       RESOLVED: The reconstruction is complex and is is also most
+        practical to do within ``TextNodeView``, since it has already
+        the supportive methods to help using the linebreaking
+        library.
 
        In ``TextNodeView`` only the text content is needed for
         linebreaking. When creating a placeable TextNodeView object,
-        the text is fetched from the current node (needed parameters
+        the text is fetched from the current node (required parameters
         are current ``ConstGraph`` and current node)
 
-When the linebreaking information is needed?
+When is the linebreaking information needed?
 
        RESOLVED: With mudyc we ended up to two main use cases.
 
@@ -71,22 +82,22 @@
            coordinates? (this should cover also the selection of text
            using mouse)
            
-How the needs could be filled?
+How could the needs be addressed?
 
-       RESOLVED: According to the previous use cases, I suggest two
+       RESOLVED: Based on to the previous use cases, I suggest two
         new methods into ``TextNodeView``. They will reconstruct the
-        linebreaking information using supportive methods already in
-        ``TextNodeView`` and use available public methods of
+        linebreaking information using the supportive methods already
+        in ``TextNodeView`` and use the public methods of
         ``linebreaking.HBroken`` and ``linebreaking.HChain`` to
         collect the information needed.
            
-        The first method returns the cursor position according to
-        given coordinates within TextNodeView and another returns the
-        coordinates of the cursor according to it's given position
+        The first method returns the cursor position for given
+        coordinates within a TextNodeView and the other returns the
+        coordinates of the cursor given its position
         (often referred as offset) within the text.
 
-       The following should be always true, when a has a proper
-        (existing) text cursor offset value::
+       The following (pseudocode) expression should be always true
+        when a proper (existing) text cursor offset value is used::
 
                a == TextNodeView.getPos(TextNodeView.getXY(a))
 
@@ -109,5 +120,5 @@
 Implementation notes
 ====================
 
-``TextNodeView.getXY()`` returns y coordinate located below the line,
-because the ``linebreaking.Hbroken.getLineOffset()`` also does that.
+``TextNodeView.getXY()`` returns the y coordinate located below the
+line, because ``linebreaking.Hbroken.getLineOffset()`` also does that.