XSConsoleFields.py

# Copyright (c) 2007-2009 Citrix Systems Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; version 2 only.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

from XSConsoleBases import *
from XSConsoleLang import *

class Field:
    FLOW_INVALID=0
    FLOW_NONE=1
    FLOW_RIGHT=2
    FLOW_RETURN=3
    FLOW_DOUBLERETURN=4

    LAYOUT_MINWIDTH = 48 # Minimum width for dialogue

    def Flow(self):
        return self.flow

    def UpdateWidth(self, inWidth):
        pass

class SeparatorField(Field):
    def __init__(self, flow):
        ParamsToAttr()

    def Render(self, inPane, inX, inY):
        pass

    def Width(self):
        return 0

    def Height(self):
        return 1

INPUT_FIELD_DEFAULT_WIDTH = 40  # Declared for use in constructor
class InputField(Field):
    MIN_WIDTH = 5  # Minimum width for input fields

    def __init__(self, text, colour, selectedColour, flow, lengthLimit, width=INPUT_FIELD_DEFAULT_WIDTH):
        ParamsToAttr()
        self.activated = False
        self.cursorPos = len(self.text)
        self.hideText = False
        self.selected = True
        self.scrollPos = 0
        self.UpdateWidth(width)
        if self.lengthLimit is None:
            self.lengthLimit = 4096

    def HideText(self):
        self.hideText = True

    def Activate(self):
        self.activated = True
        self.cursorPos = len(self.text)
        self.selected = (len(self.text) > 0)

    def Deactivate(self):
        self.activated = False

    def Content(self):
        return self.text

    def UpdateWidth(self, inWidth):
        self.width = max(self.MIN_WIDTH, inWidth)

    def Render(self, inPane, inX, inY):
        colour = self.colour
        suffix = ' '
        if self.selected and self.activated:
            colour = self.selectedColour
            suffix = ''

        # Adjust scroll point so that the cursor is within the field area
        self.scrollPos = min(self.scrollPos, self.cursorPos) # Move if cursor is outside of field to left
        self.scrollPos = max(self.scrollPos, self.cursorPos - self.width + 1) # Move if cursor is outside of field to right

        clippedStr = self.text
        # Move according to scrollPos
        clippedStr = clippedStr[self.scrollPos:]
        # Clip on right edge
        clippedStr = clippedStr[:self.width]


        if self.hideText:
            inPane.AddText("*" * len(clippedStr)+suffix, inX, inY, colour)
        else:
            inPane.AddText(clippedStr+suffix, inX, inY, colour)
        if self.selected:
            # Make cursor the right colour
            inPane.AddText(' ', inX+len(clippedStr), inY, self.colour)

        if self.activated:
            inPane.CursorOn(inX+self.cursorPos-self.scrollPos, inY)

    def Width(self):
        return max(self.MIN_WIDTH, len(self.text))

    def Height(self):
        return 1

    def HandleKey(self, inKey):
        handled = True

        if self.selected: # Handle keypress when the input text is selected
            if inKey == 'KEY_LEFT' or inKey == 'KEY_HOME':
               self.cursorPos = 0 # Move cursor to start
            elif inKey == 'KEY_RIGHT' or inKey == 'KEY_END':
                pass # Leave cursor at end
            elif inKey == 'KEY_UP' or inKey == 'KEY_DOWN':
                pass # Don't delete
            else:
                self.text = '' # First keypress deletes text
            self.selected = False

        # Constain cursor within string (in case we deleted the string contents above)
        self.cursorPos = min(self.cursorPos, len(self.text))

        if inKey == 'KEY_LEFT':
            self.cursorPos = max(0, self.cursorPos - 1) # Move cursor left
        elif inKey == 'KEY_RIGHT':
            self.cursorPos = min(len(self.text), self.cursorPos + 1) #Move cursor right
        elif inKey == 'KEY_HOME':
            self.cursorPos = 0 #Move cursor to home
        elif inKey == 'KEY_END':
            self.cursorPos = len(self.text) #Move cursor to end
        elif inKey == 'KEY_DC':
            self.text = self.text[:self.cursorPos] + self.text[self.cursorPos+1:] # Delete on right
        elif inKey == 'KEY_BACKSPACE':
            if (self.cursorPos > 0):
                self.cursorPos -= 1
                self.text = self.text[:self.cursorPos] + self.text[self.cursorPos+1:] # Delete on left
        elif len(inKey) == 1 and inKey[0] >= ' ':
            if len(self.text) < self.lengthLimit:
                self.text = self.text[:self.cursorPos] + inKey[0] + self.text[self.cursorPos:] # Insert char
                self.cursorPos += 1
        else:
            handled = False
        return handled

class TextField(Field):
    def __init__(self, text, colour, flow):
        ParamsToAttr()

    def Render(self, inPane, inX, inY):
        inPane.AddWrappedText(self.text, inX, inY, self.colour)

    def Width(self):
        return len(self.text)

    def Height(self):
        return 1

class WrappedTextField(Field):
    def __init__(self, text, colour, flow):
        ParamsToAttr()
        self.wrappedWidth = None
        self.wrappedText = []
        self.centred = False

    def SetCentred(self):
        self.centred = True

    def UpdateWidth(self, inWidth):
        if self.wrappedWidth is None or self.wrappedWidth != inWidth:
            self.wrappedWidth = inWidth
            self.wrappedText = Language.ReflowText(self.text, self.wrappedWidth)

    def Render(self, inPane, inXPos, inYPos):
        yPos = inYPos
        for line in self.wrappedText:
            if self.centred:
                offset = (self.wrappedWidth - len(line)) // 2
                inPane.AddText(line, inXPos+offset, yPos, self.colour)
            else:
                inPane.AddText(line, inXPos, yPos, self.colour)

            yPos += 1

    def Width(self):
        retVal = 1
        for line in self.wrappedText:
            retVal = max(retVal, len(line))
        return retVal

    def Height(self):
        return max(1, len(self.wrappedText))

class MenuField(Field):
    def __init__(self, menu, colour, highlight, height, flow):
        ParamsToAttr()
        self.scrollPoint = 0
        self.height = min(self.height, len(self.menu.ChoiceDefs()))

    def Width(self):
        if len(self.menu.ChoiceDefs()) == 0:
            return 0
        return max(len(choice.name) for choice in self.menu.ChoiceDefs() )

    def Height(self):
        return self.height

    def Render(self, inPane, inXPos, inYPos):
        # This rendering doesn't necessarily deal with scrolling menus where the choice names
        # are of different lengths.  More erase/overwrite operations may be required to do that.

        # Move the scroll point if the selected option would otherwise be off the screen
        choiceIndex = self.menu.ChoiceIndex()
        if self.scrollPoint > choiceIndex:
            # Move so the choiceIndex is at the top
            self.scrollPoint = choiceIndex
        elif self.scrollPoint + self.height <= choiceIndex:
            # Move so the choiceIndex is at the bottom
            self.scrollPoint = choiceIndex - self.height + 1

        choiceDefs = self.menu.ChoiceDefs()
        for i in range(min(self.height, len(choiceDefs) - self.scrollPoint)):
            choiceNum = self.scrollPoint + i
            if choiceNum == choiceIndex:
                colour = self.highlight
            else:
                colour = self.colour

            inPane.AddText(choiceDefs[choiceNum].name, inXPos, inYPos + i, colour)

class FieldGroup:
    def __init__(self):
        self.Reset()

    def Reset(self):
        self.bodyFields = []
        self.bodyFieldNames = []
        self.staticFields = []
        self.staticFieldNames = []
        # Fields are ordered, so the order of field names is recorded here and the fields themselves are in bodyFields
        self.inputOrder = []
        self.inputTags = {}

    def NumStaticFields(self):
        return len(self.staticFields)

    def NumInputFields(self):
        return len(self.inputOrder)

    def BodyFields(self):
        return self.bodyFields

    def StaticFields(self):
        return self.staticFields

    def InputField(self, inIndex):
        return self.inputOrder[inIndex]

    def BodyFieldAdd(self, inTag, inField):
        self.bodyFields.append(inField)

    def StaticFieldAdd(self, inTag, inField):
        self.staticFields.append(inField)

    def InputFieldAdd(self, inTag, inField):
        # Three reference to the same field
        self.inputTags[inTag] = inField
        self.inputOrder.append(inField)
        self.bodyFields.append(inField)

    def GetFieldValues(self):
        retVal = {}
        for key, field in self.inputTags.items():
            retVal[key] = field.Content()

        return retVal

class FieldArranger:
    BOXWIDTH = 1
    BORDER = 1

    def __init__(self, inFieldGroup, inXSize, inYSize):
        self.fieldGroup = inFieldGroup
        self.baseXSize = inXSize
        self.baseYSize = inYSize
        self.hasBox = False
        self.Reset()

    def Reset(self):
        self.layoutXSize = None
        self.layoutYSize = None

    def XSizeSet(self, inXSize):
        self.baseXSize = inXSize
        self.layoutXSize = None
        self.layoutYSize = None

    def YSizeSet(self, inYSize):
        self.baseYSize = inYSize
        self.layoutXSize = None
        self.layoutYSize = None

    def XSize(self):
        if self.layoutXSize is None:
            self.layoutXSize = max(self.BodyLayout().pop().xpos, self.StaticLayout().pop().xpos)
        return max(self.layoutXSize, Field.LAYOUT_MINWIDTH)

    def YSize(self):
        if self.layoutYSize is None:
            self.layoutYSize = self.BodyLayout().pop().ypos # Static layout not included
        return self.layoutYSize

    def XBounds(self):
        if self.hasBox:
            retVal = self.XSize()+4
        else:
            retVal = self.XSize()+2
        return retVal

    def YBounds(self):
        if self.hasBox:
            retVal = self.YSize()+3
        else:
            retVal = self.YSize()+1
        return retVal

    def AddBox(self):
        self.hasBox = True

    def LayoutFields(self, inFields, inYStep):
        if self.hasBox:
            xOffset = self.BOXWIDTH
            yOffset = self.BOXWIDTH
            xSize = self.baseXSize - self.BOXWIDTH
            ySize = self.baseYSize - self.BOXWIDTH
        else:
            xOffset = 0
            yOffset = 0
            xSize = self.baseXSize
            ySize = self.baseYSize

        xStart = xOffset+self.BORDER
        if inYStep >= 0:
            yStart = yOffset+self.BORDER
        else:
            # If inYStep is negative, start from the bottom
            yStart = ySize - self.BORDER

        xPos = xStart
        yPos = yStart

        xMax = xPos
        yMax = yPos

        retVal = []
        for field in inFields:
            flow = field.Flow()

            retVal.append(Struct(xpos = xPos, ypos = yPos))

            # UpdateWidth can rewrap text and change the field width and height
            field.UpdateWidth((xSize - self.BORDER) - xPos)
            xMax = max(xMax, xPos + field.Width())
            if field.Width() > 0:
                yMax = yPos + inYStep * field.Height() # Only advance yMax for non-blank lines

            if flow == Field.FLOW_RIGHT:
                xPos += field.Width() + 1
            elif flow == Field.FLOW_RETURN:
                xPos = xStart
                yPos += inYStep * field.Height()
            elif flow == Field.FLOW_DOUBLERETURN:
                xPos = xStart
                yPos += inYStep * (field.Height()+1)
            elif flow == Field.FLOW_NONE:
                pass # Leave xPos and yPos as they are
            else:
                raise Exception("Unknown flow type: "+str(flow))

        retVal.append(Struct(xpos = xMax, ypos = yMax)) # End marker

        return retVal

    def BodyLayout(self):
        return self.LayoutFields(self.fieldGroup.BodyFields(), 1)

    def StaticLayout(self):
        return self.LayoutFields(self.fieldGroup.StaticFields(), -1)

class FieldInputTracker:
    def __init__(self, inFieldGroup):
        self.fieldGroup = inFieldGroup
        self.inputIndex = None

    def ActivateNextInput(self):
        self.InputIndexSet((self.inputIndex + 1) % self.fieldGroup.NumInputFields())

    def ActivatePreviousInput(self):
        numFields = self.fieldGroup.NumInputFields()
        self.InputIndexSet((self.inputIndex + numFields - 1) % numFields)

    def IsLastInput(self):
        return self.inputIndex + 1 == self.fieldGroup.NumInputFields()

    def CurrentInput(self):
        if self.inputIndex is not None:
            retVal = self.fieldGroup.InputField(self.inputIndex)
        else:
            retVal = None
        return retVal

    def InputIndex(self):
        return self.inputIndex

    def InputIndexSet(self, inIndex):
        if self.inputIndex is not None:
            self.CurrentInput().Deactivate()

        self.inputIndex = inIndex

        if self.inputIndex is not None:
            self.CurrentInput().Activate()

    def NeedsCursor(self):
        if self.inputIndex is not None:
            retVal = True
        else:
            retVal = False
        return retVal