XSConsoleLayout.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 XSConsoleCurses import *
from XSConsoleHotData import *

class Layout:
    WIN_MAIN = 0
    WIN_TOPLINE = 1

    APP_XSIZE = 80
    APP_YSIZE = 24

    instance = None

    def __init__(self, inParent = None):
        self.parent = inParent
        self.windows = []
        self.exitCommand = None # Not layout, but keep with layout for convenience
        self.exitBanner = None # Not layout, but keep with layout for convenience
        self.exitCommandIsExec = True # Not layout, but keep with layout for convenience

    def AssertScreenSize(self):
        consoleXSize = self.parent.XSize()
        consoleYSize = self.parent.YSize()
        if consoleXSize < self.APP_XSIZE or consoleYSize < self.APP_YSIZE:
            raise Exception('Console size ('+str(consoleXSize)+', '+str(consoleYSize) +
                ') too small for application size ('+str(self.APP_XSIZE)+', '+str(self.APP_YSIZE) +')')

    @classmethod
    def Inst(cls):
        if cls.instance is None:
            cls.instance = Layout()
        return cls.instance

    @classmethod
    def NewInst(cls):
        cls.instance = Layout()
        return cls.instance

    def ParentSet(self, inParent):
        self.parent = inParent

    def Parent(self):
        return self.parent

    def ExitBanner(self):
        return self.exitBanner

    def ExitBannerSet(self,  inBanner):
        self.exitBanner = inBanner

    def ExitCommand(self):
        return self.exitCommand

    def ExitCommandSet(self,  inCommand):
        self.exitCommand = inCommand
        self.exitCommandIsExec = True

    def SubshellCommandSet(self, inCommand):
        self.exitCommand = inCommand
        self.exitCommandIsExec = False

    def ExitCommandIsExec(self):
        return self.exitCommandIsExec

    def Window(self, inNum):
        return self.windows[inNum]

    def TopDialogue(self):
        return self.dialogues[-1]

    def PushDialogue(self, inDialogue):
        self.dialogues.append(inDialogue)

    def PopDialogue(self):
        if len(self.dialogues) < 1:
            raise Exception("Stack underflow in PopDialogue")
        self.TopDialogue().Destroy()
        self.dialogues.pop()
        if len(self.dialogues) == 1:
            # When the display returns to the root screen, it's possible that data has changed, so
            # delete the HotData cache to force a refetch
            HotData.Inst().DeleteCache()
        self.TopDialogue().UpdateFields()
        self.Refresh()

    def UpdateRootFields(self):
        if len(self.dialogues) > 0:
            self.dialogues[0].UpdateFields()

    def LiveUpdateFields(self):
        needsRefresh = False
        if len(self.dialogues) > 0:
            topDialogue = self.dialogues[-1]
            if hasattr(topDialogue, 'LiveUpdateFields'):
                topDialogue.LiveUpdateFields()
                needsRefresh = True
        return needsRefresh

    def TransientBannerHandlerSet(self, inHandler):
        self.transientBannerHandler = inHandler

    def TransientBanner(self, inMessage):
        self.transientBannerHandler(inMessage)

    def WriteParentOffset(self, inParent):
        self.AssertScreenSize()

        # Centralise subsequent windows
        inParent.OffsetSet(
            (inParent.XSize() - self.APP_XSIZE) // 2,
            (inParent.YSize() - self.APP_YSIZE) // 2)

    def Create(self):
        self.windows.append(CursesWindow(0,1,self.APP_XSIZE, self.APP_YSIZE-1, self.parent)) # MainWindow
        self.windows.append(CursesWindow(0,0,self.APP_XSIZE,1, self.parent)) # Top line window
        self.windows[self.WIN_MAIN].DefaultColourSet('MAIN_BASE')
        self.windows[self.WIN_TOPLINE].DefaultColourSet('TOPLINE_BASE')

        self.Window(self.WIN_MAIN).AddBox()
        self.Window(self.WIN_MAIN).TitleSet("Configuration")

    def CreateRootDialogue(self, inRootDialogue):
        self.dialogues = [ inRootDialogue ]

    def Reset(self):
        while len(self.dialogues) > 1:
            self.PopDialogue()
        self.TopDialogue().Reset()

    def Refresh(self):
        self.Window(self.WIN_MAIN).Erase() # Unknown why main won't redraw without this
        for window in self.windows:
            window.Refresh()

        for dialogue in self.dialogues:
            dialogue.Render()

        if not self.TopDialogue().NeedsCursor():
            self.TopDialogue().CursorOff()

    def Redraw(self):
        for window in self.windows:
            window.Win().redrawwin()
            window.Win().refresh()

    def Clear(self):
        for window in self.windows:
            window.Clear()
        self.Refresh()

    def DoUpdate(self):
        curses.doupdate()