示例#1
0
 def __init__(self, editor):
     # There are 3 rectangles for marking selection, 1st line, middle lines
     # and last line.
     self.editor = editor
     view = self.editor.canvas
     self.selRect1 = BGRect(view, "selbg")
     self.selRect2 = BGRect(view, "selbg")
     self.selRect3 = BGRect(view, "selbg")
     self.mainWidth = self.editor.rsubject.db.layoutInfo.mainWidth
示例#2
0
    def init(self, rsubject):
        """Set up the editor for a new report.
        rsubject: A RSubject object for the current report.
        """
        self.rsubject = rsubject

        if self.edCursor:
            self.edCursor.stop()

        # Set the viewing area (x-margin, y-margin, width)
        self.mainWidth = self.rsubject.db.layoutInfo.mainWidth
        self.canvas.initArea(20, 10, self.mainWidth)

        # Special background for overflow text
        self.ovflRect = BGRect(self.canvas, "ovflbg", under=True)

        # Render the frames
        frames = self.rsubject.frames
        y = 0.0
        for f in frames[:-1]:
            # Separator line
            HLine(self.canvas, y, self.mainWidth)
            f.render(self.canvas, self.rsubject, y)
            y += f.maxHeight

        # The overflow frame:
        HLine(self.canvas, y, self.mainWidth)
        f = frames[-1]
        yo = 0.0
        ol = self.rsubject.getFrameLines(f)
        if ol:
            lastline = ol[-1]
            # vertical space needed by the frame text:
            yo = lastline.y + lastline.height
        f.getHeight(yo)
        f.render(self.canvas, self.rsubject, y)

        self.setSize(y, f.height)

        self.edCursor = EdCursor(self)

        self.selection = Selection(self)
        self.initCurSel()
示例#3
0
 def __init__(self, editor):
     # There are 3 rectangles for marking selection, 1st line, middle lines
     # and last line.
     self.editor = editor
     view = self.editor.canvas
     self.selRect1 = BGRect(view, "selbg")
     self.selRect2 = BGRect(view, "selbg")
     self.selRect3 = BGRect(view, "selbg")
     self.mainWidth = self.editor.rsubject.db.layoutInfo.mainWidth
示例#4
0
    def init(self, rsubject):
        """Set up the editor for a new report.
        rsubject: A RSubject object for the current report.
        """
        self.rsubject = rsubject

        if self.edCursor:
            self.edCursor.stop()

        # Set the viewing area (x-margin, y-margin, width)
        self.mainWidth = self.rsubject.db.layoutInfo.mainWidth
        self.canvas.initArea(20, 10, self.mainWidth)

        # Special background for overflow text
        self.ovflRect = BGRect(self.canvas, "ovflbg", under=True)

        # Render the frames
        frames = self.rsubject.frames
        y = 0.0
        for f in frames[:-1]:
            # Separator line
            HLine(self.canvas, y, self.mainWidth)
            f.render(self.canvas, self.rsubject, y)
            y += f.maxHeight

        # The overflow frame:
        HLine(self.canvas, y, self.mainWidth)
        f = frames[-1]
        yo = 0.0
        ol = self.rsubject.getFrameLines(f)
        if ol:
            lastline = ol[-1]
            # vertical space needed by the frame text:
            yo = lastline.y + lastline.height
        f.getHeight(yo)
        f.render(self.canvas, self.rsubject, y)

        self.setSize(y, f.height)

        self.edCursor = EdCursor(self)

        self.selection = Selection(self)
        self.initCurSel()
示例#5
0
class Selection:
    """This class represents a text selection within an 'editor'.

    There are two markers, selectionMark and selectionMark2, the first being
    set by left-cursor-press, the second by left-cursor-move. Their values are
    index triples (line, word, character), and become invalid when the text is
    edited - so any editing action must clear them.
    """
    def __init__(self, editor):
        # There are 3 rectangles for marking selection, 1st line, middle lines
        # and last line.
        self.editor = editor
        view = self.editor.canvas
        self.selRect1 = BGRect(view, "selbg")
        self.selRect2 = BGRect(view, "selbg")
        self.selRect3 = BGRect(view, "selbg")
        self.mainWidth = self.editor.rsubject.db.layoutInfo.mainWidth

    def clearSelection(self):
        # The defining property of a clear selection is that selectiomMark2
        # is 'None'. selectionMark need not be 'None'
        self.selectionMark2 = None
        self.selRect1.hide()
        self.selRect2.hide()
        self.selRect3.hide()

    def isSelection(self):
        return (self.selectionMark2 != None)

    def setMark1(self, newMark):
        """Called when the left mouse button is pressed.
        """
        self.selectionMark = newMark
        self.clearSelection()
        self.editor.edCursor.setPos(*newMark)

    def setMark2(self, newMark):
        """Called when the mouse is moved with the left button pressed.
        """
        if (self.selectionMark2 == newMark): return
        self.selectionMark2 = newMark
        self.markSelection()

    def markSelection(self):
        """Sets the coloured background for the selection.
        It also resets the (display) cursor position.
        """
        self.editor.edCursor.setPos(*self.selectionMark2)
        if (self.selectionMark2 == self.selectionMark):
            self.selRect1.hide()
            self.selRect2.hide()
            self.selRect3.hide()
            return

        sm1, sm2 = self.order()
        w, cx = sm1
        x1, y1, dy1 = w.getXYH(cx)
        w, cx = sm2
        x2, y2, dy2 = w.getXYH(cx)

        if (y1 == y2):
            # single line, 1 rectangle, sm1 to sm2
            self.selRect1.setRect(x1, y1, x2-x1, dy1)
            self.selRect1.show()
            self.selRect2.hide()
            self.selRect3.hide()
            return

        # selRect1: from sm1 to end of line
        # selRect2: from start of line to sm2
        self.selRect1.setRect(x1, y1, self.mainWidth-x1, dy1)
        self.selRect1.show()
        self.selRect2.setRect(0, y2, x2, dy2)
        self.selRect2.show()

        y0 = y1+dy1
        if (y0 == y2):
            # adjacent lines, 2 rectangles
            self.selRect3.hide()
            return

        # several lines, all 3 rectangles
        # selRect3: all lines in between
        self.selRect3.setRect(0, y0, self.mainWidth, y2-y0)
        self.selRect3.show()

    def order(self, mark1=None, mark2=None):
        """Return the two marks as a tuple so that the first entry
        is guaranteed not to be after the second. The default marks
        are the current selection markers.
        """
        if not mark1: mark1 = self.selectionMark
        if not mark2: mark2 = self.selectionMark2
        w1 = mark1[0]
        w2 = mark2[0]
        if (w1 == w2):
            # compare character positions
            if (mark1[1] > mark2[1]):
                return (mark2, mark1)
            return (mark1, mark2)
        tl1 = w1.tline
        tl2 = w2.tline
        if (tl1 != tl2):
            tls = self.editor.rsubject.tlines
            if (tls.index(tl1) > tls.index(tl2)):
                return (mark2, mark1)
            return (mark1, mark2)
        if (tl1.twords.index(w1) > tl1.twords.index(w2)):
            return (mark2, mark1)
        return (mark1, mark2)
示例#6
0
class Editor:
    """There may be only one instance of this class, because of the
    slot declarations.

    Given a canvas widget to draw on, implement a report text editor.
    It can also be restricted to use in a view-only mode by passing
    'False' to the 'editable' argument.

    Much of the low level stuff is done in the 'graphics view' widget,
    which is a GUI class. I decided not to make this class inherit from
    that widget, in order to leave maximum flexibility in how it is
    created and implemented itself (I hope that makes sense).

    According to the settings in the layout description the area
    available for the report can comprise more than one 'frame'.
    The text can be split over a number of separate boxes - specifically
    here for the case of longer, principally class teacher, reports,
    which need more than one page). The editor needs the vertical sizes
    (in mm) of these boxes, so that the display area can be divided
    into several blocks which will appear sequentially, and also margin
    information.

    To deal with text that is too long for a report box, an additional
    large 'dummy' box is added after the 'official' box(es). This gets
    a coloured background, to indicate the overflow.

    The text being edited is primarily managed by the RSubject object,
    which stores it as a list of TextLine objects, each containing a
    list of TWord objects.
    """
    def __init__(self, canvas, editable=True):
        self.canvas = canvas  # the canvas widget
        self.editable = editable

        slot = canvas.slot
        slot("edPress", self.edPress)
        slot("edMove", self.edMove)
        slot("edRelease", self.edRelease)
        slot("keyPress", self.edKey)
        slot("renderedToEnd", self.renewOvfl)
        self.edCursor = None
        self.selection = None
        self.cursorX = None

    def init(self, rsubject):
        """Set up the editor for a new report.
        rsubject: A RSubject object for the current report.
        """
        self.rsubject = rsubject

        if self.edCursor:
            self.edCursor.stop()

        # Set the viewing area (x-margin, y-margin, width)
        self.mainWidth = self.rsubject.db.layoutInfo.mainWidth
        self.canvas.initArea(20, 10, self.mainWidth)

        # Special background for overflow text
        self.ovflRect = BGRect(self.canvas, "ovflbg", under=True)

        # Render the frames
        frames = self.rsubject.frames
        y = 0.0
        for f in frames[:-1]:
            # Separator line
            HLine(self.canvas, y, self.mainWidth)
            f.render(self.canvas, self.rsubject, y)
            y += f.maxHeight

        # The overflow frame:
        HLine(self.canvas, y, self.mainWidth)
        f = frames[-1]
        yo = 0.0
        ol = self.rsubject.getFrameLines(f)
        if ol:
            lastline = ol[-1]
            # vertical space needed by the frame text:
            yo = lastline.y + lastline.height
        f.getHeight(yo)
        f.render(self.canvas, self.rsubject, y)

        self.setSize(y, f.height)

        self.edCursor = EdCursor(self)

        self.selection = Selection(self)
        self.initCurSel()

    def initCurSel(self):
        # Convert cursor from index to word format
        cp, cw, cx = self.rsubject.cursor
        para = None
        ipara = -1
        for tl in self.rsubject.tlines:
            if (tl.para != para):
                ipara += 1
                para = tl.para
            if (ipara == cp):
                nw = len(tl.twords)
                if (cw < nw):
                    w = tl.twords[cw]
                    break
                cw -= nw
        self.edCursor.setPos(w, cx)

        #        else:
        #            self.edCursor.setPos(self.rsubject.tlines[0].twords[0], 0)

        self.selection.clearSelection()

    def setSize(self, y, h):
        """Set the size of the background rectangle behind the
        text overflow area and also the displayed canvas area.
        y: y-coordinate of overflow start
        h: height of overflow area
        """
        if (h <= 0.0):
            self.ovflRect.hide()
            self.canvas.setHeight(y)
        else:
            self.ovflRect.setRect(0, y, self.mainWidth, h)
            self.ovflRect.show()
            self.canvas.setHeight(y + h)

    def renewOvfl(self, arg):
        # This is a 'slot', called when a report has been rendered to
        # the end.
        f = self.rsubject.frames[-1]
        # How much space is used in the overflow area?
        lastLine = self.rsubject.tlines[-1]
        if (lastLine.frame != f):
            y = 0.0
        else:
            y = lastLine.y + lastLine.height
        self.setSize(f.yF, f.getHeight(y))

    def edKey(self, key):
        """This handles key presses.
        """
        # Any key press except cursor keys (?) causes the selection to be deleted!
        if isinstance(key, types.IntType):
            rawkey = (key & (SHIFT - 1))
            if (rawkey in (1, 2, 3, 4)):
                # First check for shift+cursor-key, because these alter the selection
                if (key & SHIFT):  # SHIFT + cursor key
                    # if there is not already a selection, set the first marker before
                    # moving the cursor
                    if not self.selection.selectionMark2:
                        w, cx = self.edCursor.getPos()
                        # Hack to handle empty words which are about to be deleted
                        if (w.string == u"") and (len(w.tline.twords) > 1):
                            # Don't start selection, just move cursor
                            self.cursorKey(rawkey)
                            return
                        self.selection.selectionMark = (w, cx)
                    self.cursorKey(rawkey)
                    self.selection.setMark2(self.edCursor.getPos())

                else:  # cursor key without SHIFT
                    # clear selection and move cursor.
                    self.selection.clearSelection()
                    self.cursorKey(rawkey)
                return

            # All other keys are ignored if this widget is read-only
            if not self.editable: return

            self.cursorX = None
            # If there is a selection this must be deleted
            if self.delete() and (rawkey in (8, 9)): return

            # Get cursor position
            word, cx = self.edCursor.getPos()
            tline = word.tline

            if (rawkey == 10):  # space
                if (key & SHIFT):
                    self.insertChar(FixedSpace)
                    return
                s1 = word.string[:cx]
                s2 = word.string[cx:]
                word.setString(s1)
                # Create a new TWord with the second half of the split:
                nw = TWord(s2)
                wx = tline.twords.index(word)
                tline.insert(nw, wx + 1)
                nw.setCanvas(self.canvas)

                # Re-render from this word, noting that it became shorter:
                self.rsubject.renderShortened(word)
                self.edCursor.setPos(nw, 0)
                return

            if (rawkey == 7):  # line break
                s1 = word.string[:cx]
                s2 = word.string[cx:]
                word.setString(s1)
                # Create a new TWord with the second half of the split:
                nw = TWord(s2)
                # And a new Paragraph, copying the properties of the old one:
                para = Paragraph(tline.para)
                # And a new TextLine:
                ntl = TextLine(para, [nw])
                lx = self.rsubject.tlines.index(tline) + 1
                self.rsubject.tlines.insert(lx, ntl)
                nw.setCanvas(self.canvas)
                # Move words following the split:
                wx = tline.twords.index(word)
                for w in tline.twords[wx + 1:]:
                    ntl.insert(w)
                del (tline.twords[wx + 1:])
                # Now move subsequent lines to new paragraph
                while True:
                    lx += 1
                    if (len(self.rsubject.tlines) <= lx) or \
                            (self.rsubject.tlines[lx].para != tline.para):
                        break
                    self.rsubject.tlines[lx].para = para

                # Re-render from this word, noting that it became shorter:
                self.rsubject.renderShortened(word)
                # Set cursor to start of new word.
                self.edCursor.setPos(nw, 0)
                return

            if (rawkey == 8) or (rawkey == 9):  # delete / backspace
                if (rawkey == 9):
                    # backspace: take one step back and then do as delete.
                    if (cx == 0):  # at start of word
                        para0 = tline.para
                        # if stepping back works ...
                        if not self.edCursor.step(False): return
                        # Get new cursor position
                        word, cx = self.edCursor.getPos()
                        tline = word.tline
                        para = tline.para  # needed for deletion test below
                    else:
                        cx -= 1
                s = word.string
                if (len(s) == cx):  # at end of word
                    # Join words
                    wx = tline.twords.index(word) + 1
                    if (wx >= len(tline.twords)):  # at end of line
                        # If we arrived at the end of a paragraph with
                        # backspace, and the step backwards didn't skip
                        # to the previous paragraph, do nothing!
                        # That is necessary because of the
                        # automatic deletion of words which become empty
                        # when the cursor leaves them.
                        if (rawkey == 9) and (para == para0): return
                        # If at end of paragraph, join paragraphs
                        nl = self.rsubject.nextLine(tline)
                        if nl:
                            para0 = tline.para
                            para = nl.para
                            if (para != para0):
                                nl2 = nl
                                while True:
                                    nl2.setPara(para0)
                                    nl2 = self.rsubject.nextLine(nl2)
                                    if (not nl2) or (nl2.para != para): break
                            # Next line is (now) in same paragraph.
                            # Move first word of next line to current line:
                            tline.insert(nl.twords[0])
                            del (nl.twords[0])
                            if not nl.twords:
                                # Line now empty, delete it
                                self.rsubject.deleteTLine(nl)
                            else:
                                nl.y = None  # to ensure re-rendering
                        else:
                            # Nothing to delete
                            return

                    nw = tline.twords[wx]
                    del (tline.twords[wx])
                    word.setString(s + nw.string)
                    # The removed word must be 'freed'
                    nw.delete()
                    # Re-render from tline:
                    self.rsubject.linify(tline)
                else:
                    # Not at end of word, the word will be shortened.
                    s = s[:cx] + s[cx + 1:]
                    word.setString(s)
                    # Re-render from this word, noting that it became shorter:
                    self.rsubject.renderShortened(word)
                # Reset cursor to start of new word/paragraph.
                self.edCursor.setPos(word, cx)

                self.deleteCount += 1
                if (self.deleteCount >= DELETECOUNT):
                    self.saveText()
                return

            # Anything else is ignored
            return

        # All other keys are ignored if this widget is read-only
        if not self.editable: return

        # character key
        self.cursorX = None
        # If there is a selection this must be deleted
        # This must also reset the cursor appropriately
        self.delete()
        self.insertChar(key)

    def insertChar(self, ch):
        """Insert the given character into the current word.
        """
        word, cx = self.edCursor.getPos()
        string = word.string[:cx] + ch + word.string[cx:]
        word.setString(string)
        # Re-render from tline:
        self.rsubject.linify(word.tline)
        self.edCursor.setPos(word, cx + 1)

    def insertBlock(self, utext):
        """Insert the given (unicode) text at the current cursor position.
        Special style formatting will also be recognized but only after
        a newline.
        """
        self.saveText()

        self.selection.clearSelection()
        word, cx = self.edCursor.getPos()
        # Get cursor offset from end of word (for new cursor placement)
        cxn = len(word.string) - cx
        # Insert the new text at the cursor position ...
        string = word.string[:cx] + utext + word.string[cx:]
        textLines = self.rsubject.textToLines(string)
        tline = word.tline
        nline0 = textLines[0]
        word1 = nline0.twords[0]  # position to start rendering
        wx = tline.twords.index(word)  # insertion index
        # delete the word which was under the cursor
        word.delete()
        # and set its string to non-empty so that the cursor
        # repositioning works (!)
        word.string = u"DUMMY"
        # and add the rest of the original line to the end of the insertion
        oline2 = tline.twords[wx + 1:]
        del (tline.twords[wx:])
        nlineL = textLines[-1]
        word = nlineL.twords[-1]  # get new word under cursor
        for w in oline2:
            nlineL.insert(w)
        # Append the first inserted line to tline
        for w in nline0.twords:
            tline.insert(w)

        # Insert the remaining lines into the subjects line list
        tlx = self.rsubject.tlines.index(tline) + 1
        self.rsubject.tlines[tlx:tlx] = textLines[1:]

        self.rsubject.renderShortened(word1)

        cx = len(word.string) - cxn
        self.edCursor.setPos(word, cx)

    def delete(self):
        """Delete the text between the two selection marks, if they are set,
        and place the cursor appropriately afterwards.
        Return True if something was deleted.
        """
        if not self.selection.isSelection(): return False

        # Save the current text
        self.saveText()

        sm1, sm2 = self.selection.order(self.selection.selectionMark,
                                        self.selection.selectionMark2)
        w1 = sm1[0]
        w2 = sm2[0]
        cx = sm1[1]
        self.edCursor.setPos(w1, cx)
        # Join words before and after selection
        w1.setString(w1.string[:cx] + w2.string[sm2[1]:])
        # Delete all intervening words, and w2
        tl1 = w1.tline
        wx1 = tl1.twords.index(w1)
        tl2 = w2.tline
        wx2 = tl2.twords.index(w2)
        if (tl1 == tl2):  # only delete from 1 line
            # delete words from wx1+1 to wx2 (incl.)
            for w in tl1.twords[wx1 + 1:wx2 + 1]:
                w.delete()
            del (tl1.twords[wx1 + 1:wx2 + 1])

        else:  # deletion block covers >1 line
            # delete words from wx1+1 to end of paragraph
            for w in tl1.twords[wx1 + 1:]:
                w.delete()
            del (tl1.twords[wx1 + 1:])
            # delete all the intervening lines
            while True:
                tl = self.rsubject.nextLine(tl1)
                if (tl == tl2): break
                self.rsubject.deleteTLine(tl)

            # Move remaining words after w2 in tl2 to end of tl1
            for w in tl2.twords[wx2 + 1:]:
                tl1.insert(w)
            del (tl2.twords[wx2 + 1:])
            # Delete tl2
            self.rsubject.deleteTLine(tl2)

        self.selection.clearSelection()

        self.rsubject.renderShortened(w1)

        self.edCursor.setPos(w1, cx)
        return True

    def getMarked(self):
        """Get the text between the two selection marks.
        This shares much of the same logic as the block delete function,
        but for the sake of clarity I decided to keep them separate.
        """
        if not self.selection.isSelection():
            return u""
        sm1, sm2 = self.selection.order(self.selection.selectionMark,
                                        self.selection.selectionMark2)
        w1 = sm1[0]
        w2 = sm2[0]
        cx1 = sm1[1]
        cx2 = sm2[1]
        if (w1 == w2):
            return w1.string[cx1:cx2]
        # Get the word fragments at the beginning and end of the selection
        snip1 = w1.string[cx1:]
        snip2 = w2.string[:cx2]
        tl1 = w1.tline
        wx1 = tl1.twords.index(w1)
        tl2 = w2.tline
        wx2 = tl2.twords.index(w2)
        # Start the text string with the format of the first line
        text = tl1.para.getFormat() + snip1
        # then get all intervening words
        if (tl1 == tl2):  # only 1 line is involved
            # get words from wx1+1 to wx2-1 (incl.)
            for w in tl1.twords[wx1 + 1:wx2]:
                text += u" " + w.string
            ch = u" "

        else:  # deletion block covers >1 line
            # get words from wx1+1 to end of paragraph
            for w in tl1.twords[wx1 + 1:]:
                text += u" " + w.string
            # get all the intervening lines
            while True:
                para = tl1.para
                tl1 = self.rsubject.nextLine(tl1)
                if (tl1.para == para):
                    text += u" "
                else:
                    text += u"\n" + tl1.para.getFormat()
                if (tl1 == tl2): break
                text += tl1.getText()

            ch = u""
            # Add the remaining words in tl2 up to w2-1
            for w in tl2.twords[:wx2]:
                text += ch + w.string
                ch = u" "

        # Add the fragment of the last marked word
        return text + ch + snip2

    def cursorKey(self, key):
        if (key in (1, 2)):
            self.cursorX = None
            if (key == 1):  # left
                self.edCursor.step(False)
            else:  # right
                self.edCursor.step(True)
        else:
            if (self.cursorX == None):
                w, x = self.edCursor.getPos()
                self.cursorX = w.getXYH(x)[0]
            if (key == 3):  # up
                self.edCursor.lineStep(self.cursorX, True)
            else:  # down
                self.edCursor.lineStep(self.cursorX, False)

    # These event handlers are passed mm coordinates!
    def edPress(self, xy):
        # This also sets the cursor
        self.selection.setMark1(self.getPos(*xy))

    def edMove(self, xy):
        # This also sets the cursor
        self.selection.setMark2(self.getPos(*xy))

    def edRelease(self, xy):
        # Not so significant at the moment.
        # For cursor key up/down only:
        self.cursorX = None

    def getPos(self, x, y):
        """Get the nearest text position to the given (mm) coordinates.
        Return a (word, charIx) tuple.
        """
        # First find the TextLine
        tline = self.rsubject.tlines[0]
        for tl in self.rsubject.tlines:
            if (y < (tl.y + tl.frame.yF)): break
            tline = tl
        return self.getXPos(tline, x)

    def getXPos(self, tline, x):
        """Get the nearest text position to the given (mm) x-coordinate
        within the line 'tline'.
        Return a (word, charIx) tuple.
        """
        # Find the TWord object
        words = tline.twords
        j = 0  # word index
        imax = len(words) - 1
        for w in words:
            # Find out if the point is in this word -
            # need to include half the space width after the word, if there
            # is a following word.
            x0 = w.getX()
            x1 = x0 + w.getWidth()
            if (j == imax): break
            x2 = words[j + 1].getX()
            spw = (x2 - x1) / 2
            if (x < x1 + spw): break
            j += 1

        word = words[j]

        # Then the character
        xvec = word.getOffsets()

        k = 0
        if xvec:
            xo = x - x0  # xo is x relative to word start
            p0 = 0.0
            for p in xvec:
                p1 = xvec[k]
                if (xo < (p0 + p1) / 2): break
                k += 1
                p0 = p1

        return (word, k)

    def saveText(self):
        """Called by various operations to keep backup versions of the
        text which can be reverted to using 'undo'.
        It is a rather primitive mechanism, but it should suffice for
        the foreseen purpose.
        """
        self.rsubject.saveOnChanged(self.edCursor.getPos())

        # Allows saving after a certain number of delete operations:
        self.deleteCount = 0
示例#7
0
class Selection:
    """This class represents a text selection within an 'editor'.

    There are two markers, selectionMark and selectionMark2, the first being
    set by left-cursor-press, the second by left-cursor-move. Their values are
    index triples (line, word, character), and become invalid when the text is
    edited - so any editing action must clear them.
    """
    def __init__(self, editor):
        # There are 3 rectangles for marking selection, 1st line, middle lines
        # and last line.
        self.editor = editor
        view = self.editor.canvas
        self.selRect1 = BGRect(view, "selbg")
        self.selRect2 = BGRect(view, "selbg")
        self.selRect3 = BGRect(view, "selbg")
        self.mainWidth = self.editor.rsubject.db.layoutInfo.mainWidth

    def clearSelection(self):
        # The defining property of a clear selection is that selectiomMark2
        # is 'None'. selectionMark need not be 'None'
        self.selectionMark2 = None
        self.selRect1.hide()
        self.selRect2.hide()
        self.selRect3.hide()

    def isSelection(self):
        return (self.selectionMark2 != None)

    def setMark1(self, newMark):
        """Called when the left mouse button is pressed.
        """
        self.selectionMark = newMark
        self.clearSelection()
        self.editor.edCursor.setPos(*newMark)

    def setMark2(self, newMark):
        """Called when the mouse is moved with the left button pressed.
        """
        if (self.selectionMark2 == newMark): return
        self.selectionMark2 = newMark
        self.markSelection()

    def markSelection(self):
        """Sets the coloured background for the selection.
        It also resets the (display) cursor position.
        """
        self.editor.edCursor.setPos(*self.selectionMark2)
        if (self.selectionMark2 == self.selectionMark):
            self.selRect1.hide()
            self.selRect2.hide()
            self.selRect3.hide()
            return

        sm1, sm2 = self.order()
        w, cx = sm1
        x1, y1, dy1 = w.getXYH(cx)
        w, cx = sm2
        x2, y2, dy2 = w.getXYH(cx)

        if (y1 == y2):
            # single line, 1 rectangle, sm1 to sm2
            self.selRect1.setRect(x1, y1, x2 - x1, dy1)
            self.selRect1.show()
            self.selRect2.hide()
            self.selRect3.hide()
            return

        # selRect1: from sm1 to end of line
        # selRect2: from start of line to sm2
        self.selRect1.setRect(x1, y1, self.mainWidth - x1, dy1)
        self.selRect1.show()
        self.selRect2.setRect(0, y2, x2, dy2)
        self.selRect2.show()

        y0 = y1 + dy1
        if (y0 == y2):
            # adjacent lines, 2 rectangles
            self.selRect3.hide()
            return

        # several lines, all 3 rectangles
        # selRect3: all lines in between
        self.selRect3.setRect(0, y0, self.mainWidth, y2 - y0)
        self.selRect3.show()

    def order(self, mark1=None, mark2=None):
        """Return the two marks as a tuple so that the first entry
        is guaranteed not to be after the second. The default marks
        are the current selection markers.
        """
        if not mark1: mark1 = self.selectionMark
        if not mark2: mark2 = self.selectionMark2
        w1 = mark1[0]
        w2 = mark2[0]
        if (w1 == w2):
            # compare character positions
            if (mark1[1] > mark2[1]):
                return (mark2, mark1)
            return (mark1, mark2)
        tl1 = w1.tline
        tl2 = w2.tline
        if (tl1 != tl2):
            tls = self.editor.rsubject.tlines
            if (tls.index(tl1) > tls.index(tl2)):
                return (mark2, mark1)
            return (mark1, mark2)
        if (tl1.twords.index(w1) > tl1.twords.index(w2)):
            return (mark2, mark1)
        return (mark1, mark2)
示例#8
0
class Editor:
    """There may be only one instance of this class, because of the
    slot declarations.

    Given a canvas widget to draw on, implement a report text editor.
    It can also be restricted to use in a view-only mode by passing
    'False' to the 'editable' argument.

    Much of the low level stuff is done in the 'graphics view' widget,
    which is a GUI class. I decided not to make this class inherit from
    that widget, in order to leave maximum flexibility in how it is
    created and implemented itself (I hope that makes sense).

    According to the settings in the layout description the area
    available for the report can comprise more than one 'frame'.
    The text can be split over a number of separate boxes - specifically
    here for the case of longer, principally class teacher, reports,
    which need more than one page). The editor needs the vertical sizes
    (in mm) of these boxes, so that the display area can be divided
    into several blocks which will appear sequentially, and also margin
    information.

    To deal with text that is too long for a report box, an additional
    large 'dummy' box is added after the 'official' box(es). This gets
    a coloured background, to indicate the overflow.

    The text being edited is primarily managed by the RSubject object,
    which stores it as a list of TextLine objects, each containing a
    list of TWord objects.
    """
    def __init__(self, canvas, editable=True):
        self.canvas = canvas        # the canvas widget
        self.editable = editable

        slot = canvas.slot
        slot("edPress", self.edPress)
        slot("edMove", self.edMove)
        slot("edRelease", self.edRelease)
        slot("keyPress", self.edKey)
        slot("renderedToEnd", self.renewOvfl)
        self.edCursor = None
        self.selection = None
        self.cursorX = None

    def init(self, rsubject):
        """Set up the editor for a new report.
        rsubject: A RSubject object for the current report.
        """
        self.rsubject = rsubject

        if self.edCursor:
            self.edCursor.stop()

        # Set the viewing area (x-margin, y-margin, width)
        self.mainWidth = self.rsubject.db.layoutInfo.mainWidth
        self.canvas.initArea(20, 10, self.mainWidth)

        # Special background for overflow text
        self.ovflRect = BGRect(self.canvas, "ovflbg", under=True)

        # Render the frames
        frames = self.rsubject.frames
        y = 0.0
        for f in frames[:-1]:
            # Separator line
            HLine(self.canvas, y, self.mainWidth)
            f.render(self.canvas, self.rsubject, y)
            y += f.maxHeight

        # The overflow frame:
        HLine(self.canvas, y, self.mainWidth)
        f = frames[-1]
        yo = 0.0
        ol = self.rsubject.getFrameLines(f)
        if ol:
            lastline = ol[-1]
            # vertical space needed by the frame text:
            yo = lastline.y + lastline.height
        f.getHeight(yo)
        f.render(self.canvas, self.rsubject, y)

        self.setSize(y, f.height)

        self.edCursor = EdCursor(self)

        self.selection = Selection(self)
        self.initCurSel()

    def initCurSel(self):
        # Convert cursor from index to word format
        cp, cw, cx = self.rsubject.cursor
        para = None
        ipara = -1
        for tl in self.rsubject.tlines:
            if (tl.para != para):
                ipara += 1
                para = tl.para
            if (ipara == cp):
                nw = len(tl.twords)
                if (cw < nw):
                    w = tl.twords[cw]
                    break
                cw -= nw
        self.edCursor.setPos(w, cx)

#        else:
#            self.edCursor.setPos(self.rsubject.tlines[0].twords[0], 0)

        self.selection.clearSelection()

    def setSize(self, y, h):
        """Set the size of the background rectangle behind the
        text overflow area and also the displayed canvas area.
        y: y-coordinate of overflow start
        h: height of overflow area
        """
        if (h <= 0.0):
            self.ovflRect.hide()
            self.canvas.setHeight(y)
        else:
            self.ovflRect.setRect(0, y, self.mainWidth, h)
            self.ovflRect.show()
            self.canvas.setHeight(y + h)

    def renewOvfl(self, arg):
        # This is a 'slot', called when a report has been rendered to
        # the end.
        f = self.rsubject.frames[-1]
        # How much space is used in the overflow area?
        lastLine = self.rsubject.tlines[-1]
        if (lastLine.frame != f):
            y = 0.0
        else:
            y = lastLine.y + lastLine.height
        self.setSize(f.yF, f.getHeight(y))

    def edKey(self, key):
        """This handles key presses.
        """
        # Any key press except cursor keys (?) causes the selection to be deleted!
        if isinstance(key, types.IntType):
            rawkey = (key & (SHIFT-1))
            if (rawkey in (1,2,3,4)):
                # First check for shift+cursor-key, because these alter the selection
                if (key & SHIFT):  # SHIFT + cursor key
                    # if there is not already a selection, set the first marker before
                    # moving the cursor
                    if not self.selection.selectionMark2:
                        w, cx = self.edCursor.getPos()
                        # Hack to handle empty words which are about to be deleted
                        if (w.string == u"") and (len(w.tline.twords) > 1):
                            # Don't start selection, just move cursor
                            self.cursorKey(rawkey)
                            return
                        self.selection.selectionMark = (w, cx)
                    self.cursorKey(rawkey)
                    self.selection.setMark2(self.edCursor.getPos())

                else:           # cursor key without SHIFT
                    # clear selection and move cursor.
                    self.selection.clearSelection()
                    self.cursorKey(rawkey)
                return

            # All other keys are ignored if this widget is read-only
            if not self.editable: return

            self.cursorX = None
            # If there is a selection this must be deleted
            if self.delete() and (rawkey in (8,9)): return

            # Get cursor position
            word, cx = self.edCursor.getPos()
            tline = word.tline

            if (rawkey == 10):      # space
                if (key & SHIFT):
                    self.insertChar(FixedSpace)
                    return
                s1 = word.string[:cx]
                s2 = word.string[cx:]
                word.setString(s1)
                # Create a new TWord with the second half of the split:
                nw = TWord(s2)
                wx = tline.twords.index(word)
                tline.insert(nw, wx+1)
                nw.setCanvas(self.canvas)

                # Re-render from this word, noting that it became shorter:
                self.rsubject.renderShortened(word)
                self.edCursor.setPos(nw, 0)
                return

            if (rawkey == 7):       # line break
                s1 = word.string[:cx]
                s2 = word.string[cx:]
                word.setString(s1)
                # Create a new TWord with the second half of the split:
                nw = TWord(s2)
                # And a new Paragraph, copying the properties of the old one:
                para = Paragraph(tline.para)
                # And a new TextLine:
                ntl = TextLine(para, [nw])
                lx = self.rsubject.tlines.index(tline) + 1
                self.rsubject.tlines.insert(lx, ntl)
                nw.setCanvas(self.canvas)
                # Move words following the split:
                wx = tline.twords.index(word)
                for w in tline.twords[wx+1:]:
                    ntl.insert(w)
                del(tline.twords[wx+1:])
                # Now move subsequent lines to new paragraph
                while True:
                    lx += 1
                    if (len(self.rsubject.tlines) <= lx) or \
                            (self.rsubject.tlines[lx].para != tline.para):
                        break
                    self.rsubject.tlines[lx].para = para

                # Re-render from this word, noting that it became shorter:
                self.rsubject.renderShortened(word)
                # Set cursor to start of new word.
                self.edCursor.setPos(nw, 0)
                return

            if (rawkey == 8) or (rawkey == 9):       # delete / backspace
                if (rawkey == 9):
                    # backspace: take one step back and then do as delete.
                    if (cx == 0): # at start of word
                        para0 = tline.para
                        # if stepping back works ...
                        if not self.edCursor.step(False): return
                        # Get new cursor position
                        word, cx = self.edCursor.getPos()
                        tline = word.tline
                        para = tline.para   # needed for deletion test below
                    else:
                        cx -= 1
                s = word.string
                if (len(s) == cx): # at end of word
                    # Join words
                    wx = tline.twords.index(word) + 1
                    if (wx >= len(tline.twords)): # at end of line
                        # If we arrived at the end of a paragraph with
                        # backspace, and the step backwards didn't skip
                        # to the previous paragraph, do nothing!
                        # That is necessary because of the
                        # automatic deletion of words which become empty
                        # when the cursor leaves them.
                        if (rawkey == 9) and (para == para0): return
                        # If at end of paragraph, join paragraphs
                        nl = self.rsubject.nextLine(tline)
                        if nl:
                            para0 = tline.para
                            para = nl.para
                            if (para != para0):
                                nl2 = nl
                                while True:
                                    nl2.setPara(para0)
                                    nl2 = self.rsubject.nextLine(nl2)
                                    if (not nl2) or (nl2.para != para): break
                            # Next line is (now) in same paragraph.
                            # Move first word of next line to current line:
                            tline.insert(nl.twords[0])
                            del(nl.twords[0])
                            if not nl.twords:
                                # Line now empty, delete it
                                self.rsubject.deleteTLine(nl)
                            else:
                                nl.y = None     # to ensure re-rendering
                        else:
                            # Nothing to delete
                            return

                    nw = tline.twords[wx]
                    del(tline.twords[wx])
                    word.setString(s + nw.string)
                    # The removed word must be 'freed'
                    nw.delete()
                    # Re-render from tline:
                    self.rsubject.linify(tline)
                else:
                    # Not at end of word, the word will be shortened.
                    s = s[:cx] + s[cx+1:]
                    word.setString(s)
                    # Re-render from this word, noting that it became shorter:
                    self.rsubject.renderShortened(word)
                # Reset cursor to start of new word/paragraph.
                self.edCursor.setPos(word, cx)

                self.deleteCount +=1
                if (self.deleteCount >= DELETECOUNT):
                    self.saveText()
                return

            # Anything else is ignored
            return

        # All other keys are ignored if this widget is read-only
        if not self.editable: return

        # character key
        self.cursorX = None
        # If there is a selection this must be deleted
        # This must also reset the cursor appropriately
        self.delete()
        self.insertChar(key)

    def insertChar(self, ch):
        """Insert the given character into the current word.
        """
        word, cx = self.edCursor.getPos()
        string = word.string[:cx] + ch + word.string[cx:]
        word.setString(string)
        # Re-render from tline:
        self.rsubject.linify(word.tline)
        self.edCursor.setPos(word, cx+1)

    def insertBlock(self, utext):
        """Insert the given (unicode) text at the current cursor position.
        Special style formatting will also be recognized but only after
        a newline.
        """
        self.saveText()

        self.selection.clearSelection()
        word, cx = self.edCursor.getPos()
        # Get cursor offset from end of word (for new cursor placement)
        cxn = len(word.string) - cx
        # Insert the new text at the cursor position ...
        string = word.string[:cx] + utext + word.string[cx:]
        textLines = self.rsubject.textToLines(string)
        tline = word.tline
        nline0 = textLines[0]
        word1 = nline0.twords[0]    # position to start rendering
        wx = tline.twords.index(word)   # insertion index
        # delete the word which was under the cursor
        word.delete()
        # and set its string to non-empty so that the cursor
        # repositioning works (!)
        word.string = u"DUMMY"
        # and add the rest of the original line to the end of the insertion
        oline2 = tline.twords[wx+1:]
        del(tline.twords[wx:])
        nlineL = textLines[-1]
        word = nlineL.twords[-1]        # get new word under cursor
        for w in oline2:
            nlineL.insert(w)
        # Append the first inserted line to tline
        for w in nline0.twords:
            tline.insert(w)

        # Insert the remaining lines into the subjects line list
        tlx = self.rsubject.tlines.index(tline) + 1
        self.rsubject.tlines[tlx:tlx] = textLines[1:]

        self.rsubject.renderShortened(word1)

        cx = len(word.string) - cxn
        self.edCursor.setPos(word, cx)

    def delete(self):
        """Delete the text between the two selection marks, if they are set,
        and place the cursor appropriately afterwards.
        Return True if something was deleted.
        """
        if not self.selection.isSelection(): return False

        # Save the current text
        self.saveText()

        sm1, sm2 = self.selection.order(self.selection.selectionMark,
                self.selection.selectionMark2)
        w1 = sm1[0]
        w2 = sm2[0]
        cx = sm1[1]
        self.edCursor.setPos(w1, cx)
        # Join words before and after selection
        w1.setString(w1.string[:cx] + w2.string[sm2[1]:])
        # Delete all intervening words, and w2
        tl1 = w1.tline
        wx1 = tl1.twords.index(w1)
        tl2 = w2.tline
        wx2 = tl2.twords.index(w2)
        if (tl1 == tl2):    # only delete from 1 line
            # delete words from wx1+1 to wx2 (incl.)
            for w in tl1.twords[wx1+1:wx2+1]:
                w.delete()
            del(tl1.twords[wx1+1:wx2+1])

        else:               # deletion block covers >1 line
            # delete words from wx1+1 to end of paragraph
            for w in tl1.twords[wx1+1:]:
                w.delete()
            del(tl1.twords[wx1+1:])
            # delete all the intervening lines
            while True:
                tl = self.rsubject.nextLine(tl1)
                if (tl == tl2): break
                self.rsubject.deleteTLine(tl)

            # Move remaining words after w2 in tl2 to end of tl1
            for w in tl2.twords[wx2+1:]:
                tl1.insert(w)
            del(tl2.twords[wx2+1:])
            # Delete tl2
            self.rsubject.deleteTLine(tl2)

        self.selection.clearSelection()

        self.rsubject.renderShortened(w1)

        self.edCursor.setPos(w1, cx)
        return True

    def getMarked(self):
        """Get the text between the two selection marks.
        This shares much of the same logic as the block delete function,
        but for the sake of clarity I decided to keep them separate.
        """
        if not self.selection.isSelection():
            return u""
        sm1, sm2 = self.selection.order(self.selection.selectionMark,
                self.selection.selectionMark2)
        w1 = sm1[0]
        w2 = sm2[0]
        cx1 = sm1[1]
        cx2 = sm2[1]
        if (w1 == w2):
            return w1.string[cx1:cx2]
        # Get the word fragments at the beginning and end of the selection
        snip1 = w1.string[cx1:]
        snip2 = w2.string[:cx2]
        tl1 = w1.tline
        wx1 = tl1.twords.index(w1)
        tl2 = w2.tline
        wx2 = tl2.twords.index(w2)
        # Start the text string with the format of the first line
        text = tl1.para.getFormat() + snip1
        # then get all intervening words
        if (tl1 == tl2):    # only 1 line is involved
            # get words from wx1+1 to wx2-1 (incl.)
            for w in tl1.twords[wx1+1:wx2]:
                text += u" " + w.string
            ch = u" "

        else:               # deletion block covers >1 line
            # get words from wx1+1 to end of paragraph
            for w in tl1.twords[wx1+1:]:
                text += u" " + w.string
            # get all the intervening lines
            while True:
                para = tl1.para
                tl1 = self.rsubject.nextLine(tl1)
                if (tl1.para == para):
                    text += u" "
                else:
                    text += u"\n" + tl1.para.getFormat()
                if (tl1 == tl2): break
                text += tl1.getText()

            ch = u""
            # Add the remaining words in tl2 up to w2-1
            for w in tl2.twords[:wx2]:
                text += ch + w.string
                ch = u" "

        # Add the fragment of the last marked word
        return text + ch + snip2

    def cursorKey(self, key):
        if (key in (1,2)):
            self.cursorX = None
            if (key == 1):  # left
                self.edCursor.step(False)
            else:           # right
                self.edCursor.step(True)
        else:
            if (self.cursorX == None):
                w, x = self.edCursor.getPos()
                self.cursorX = w.getXYH(x)[0]
            if (key == 3):  # up
                self.edCursor.lineStep(self.cursorX, True)
            else:           # down
                self.edCursor.lineStep(self.cursorX, False)


    # These event handlers are passed mm coordinates!
    def edPress(self, xy):
        # This also sets the cursor
        self.selection.setMark1(self.getPos(*xy))

    def edMove(self, xy):
        # This also sets the cursor
        self.selection.setMark2(self.getPos(*xy))

    def edRelease(self, xy):
        # Not so significant at the moment.
        # For cursor key up/down only:
        self.cursorX = None

    def getPos(self, x, y):
        """Get the nearest text position to the given (mm) coordinates.
        Return a (word, charIx) tuple.
        """
        # First find the TextLine
        tline = self.rsubject.tlines[0]
        for tl in self.rsubject.tlines:
            if (y < (tl.y + tl.frame.yF)): break
            tline = tl
        return self.getXPos(tline, x)

    def getXPos(self, tline, x):
        """Get the nearest text position to the given (mm) x-coordinate
        within the line 'tline'.
        Return a (word, charIx) tuple.
        """
        # Find the TWord object
        words = tline.twords
        j = 0   # word index
        imax = len(words) - 1
        for w in words:
            # Find out if the point is in this word -
            # need to include half the space width after the word, if there
            # is a following word.
            x0 = w.getX()
            x1 = x0 + w.getWidth()
            if (j == imax): break
            x2 = words[j+1].getX()
            spw = (x2 - x1)/2
            if (x < x1 + spw): break
            j += 1

        word = words[j]

        # Then the character
        xvec = word.getOffsets()

        k = 0
        if xvec:
            xo = x - x0     # xo is x relative to word start
            p0 = 0.0
            for p in xvec:
                p1 = xvec[k]
                if (xo < (p0 + p1)/2): break
                k += 1
                p0 = p1

        return (word, k)

    def saveText(self):
        """Called by various operations to keep backup versions of the
        text which can be reverted to using 'undo'.
        It is a rather primitive mechanism, but it should suffice for
        the foreseen purpose.
        """
        self.rsubject.saveOnChanged(self.edCursor.getPos())

        # Allows saving after a certain number of delete operations:
        self.deleteCount = 0