source: trunk/Monitoring/Watch/repo-state @ 871

#!/usr/bin/env python

# --- ncurses sample 1

#import curses
#from curses import panel
#
#class Menu(object):
#
#       def __init__(self, items, stdscreen):
#               self.window = stdscreen.subwin(0,0)
#               self.window.keypad(1)
#               self.panel = panel.new_panel(self.window)
#               self.panel.hide()
#               panel.update_panels()
#
#               self.position = 0
#               self.items = items
#               self.items.append(('exit','exit'))
#
#       def navigate(self, n):
#               self.position += n
#               if self.position < 0:
#                       self.position = 0
#               elif self.position >= len(self.items):
#                       self.position = len(self.items)-1
#
#       def display(self):
#               self.panel.top()
#               self.panel.show()
#               self.window.clear()
#
#
#               while True:
#                       self.window.refresh()
#                       curses.doupdate()
#                       for index, item in enumerate(self.items):
#                               if index == self.position:
#                                       mode = curses.A_REVERSE
#                               else:
#                                       mode = curses.A_NORMAL
#
#                               msg = '%d. %s' % (index, item[0])
#                               self.window.addstr(1+index, 1, msg, mode)
#
#                       key = self.window.getch()
#
#                       if key in [curses.KEY_ENTER, ord('\n')]:
#                               if self.position == len(self.items)-1:
#                                       break
#                               else:
#                                       self.items[self.position][1]()
#
#                       elif key == curses.KEY_UP:
#                               self.navigate(-1)
#
#                       elif key == curses.KEY_DOWN:
#                               self.navigate(1)
#
#               self.window.clear()
#               self.panel.hide()
#               panel.update_panels()
#               curses.doupdate()
#
#
#class MyApp(object):
#
#       def __init__(self, stdscreen):
#               self.screen = stdscreen
#               curses.curs_set(0)
#
#               submenu_items = [
#                               ('beep', curses.beep),
#                               ('flash', curses.flash)
#                               ]
#               submenu = Menu(submenu_items, self.screen)
#
#               main_menu_items = [
#                               ('beep', curses.beep),
#                               ('flash', curses.flash),
#                               ('submenu', submenu.display)
#                               ]
#               main_menu = Menu(main_menu_items, self.screen)
#               main_menu.display()

#if __name__ == '__main__':
#       curses.wrapper(MyApp)





# --- ncurses sample 2

# Author: Nikolai Tschacher
# Date: 02.06.2013
#
#class BoxSelector:
#    """ Originally designed for accman.py.
#        Display options build from a list of strings in a (unix) terminal.
#        The user can browser though the textboxes and select one with enter.
#    """
#    
#    def __init__(self, L):
#        """ Create a BoxSelector object. 
#            L is a list of strings. Each string is used to build 
#            a textbox.
#        """
#        self.L = L
#        # Element parameters. Change them here.
#        self.TEXTBOX_WIDTH = 50
#        self.TEXTBOX_HEIGHT = 6
#
#        self.PAD_WIDTH = 400
#        self.PAD_HEIGHT = 10000
#        
#    def pick(self):
#        """ Just run this when you want to spawn the selction process. """
#        self._init_curses()
#        self._create_pad()
#        
#        windows = self._make_textboxes()
#        picked = self._select_textbox(windows)
#        
#        self._end_curses()
#        
#        return picked
#        
#    def _init_curses(self):
#        """ Inits the curses appliation """
#        # initscr() returns a window object representing the entire screen.
#        self.stdscr = curses.initscr()
#        # turn off automatic echoing of keys to the screen
#        curses.noecho()
#        # Enable non-blocking mode. Keys are read directly, without hitting enter.
#        curses.cbreak()
#        # Disable the mouse cursor.
#        curses.curs_set(0)
#        self.stdscr.keypad(1)
#        # Enable colorous output.
#        curses.start_color()
#        curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN)
#        curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLACK)
#        self.stdscr.bkgd(curses.color_pair(2))
#        self.stdscr.refresh()
#
#    def _end_curses(self):
#        """ Terminates the curses application. """
#        curses.nocbreak()
#        self.stdscr.keypad(0)
#        curses.echo()
#        curses.endwin()
#        
#    def _create_pad(self):
#        """ Creates a big self.pad to place the textboxes in. """
#        self.pad = curses.newpad(self.PAD_HEIGHT, self.PAD_WIDTH)
#        self.pad.box()
#        
#    def _make_textboxes(self):
#        """ Build the textboxes in the pad center and put them in the 
#            horizontal middle of the pad. """
#        # Get the actual screensize.
#        maxy, maxx = self.stdscr.getmaxyx()
#        
#        windows = []
#        i = 1
#        for s in self.L:
#            windows.append(self.pad.derwin(self.TEXTBOX_HEIGHT,
#                    self.TEXTBOX_WIDTH, i, self.PAD_WIDTH//2-self.TEXTBOX_WIDTH//2))
#            i += self.TEXTBOX_HEIGHT
#            
#        for k in range(len(windows)):
#            windows[k].box()
#            windows[k].addstr(4, 4, '0x{0:X} - {1}'.format(k, self.L[k]))
#            
#        return windows
#
#    def _center_view(self, window):
#        """ Centers and aligns the view according to the window argument given. 
#            Returns the (y, x) coordinates of the centered window. """
#        # The refresh() and noutrefresh() methods of a self.pad require 6 arguments
#        # to specify the part of the self.pad to be displayed and the location on
#        # the screen to be used for the display. The arguments are pminrow,
#        # pmincol, sminrow, smincol, smaxrow, smaxcol; the p arguments refer
#        # to the upper left corner of the self.pad region to be displayed and the
#        # s arguments define a clipping box on the screen within which the
#        # self.pad region is to be displayed.
#        cy, cx = window.getbegyx()
#        maxy, maxx = self.stdscr.getmaxyx()
#        self.pad.refresh(cy, cx, 1, maxx//2 - self.TEXTBOX_WIDTH//2, maxy-1, maxx-1)
#        return (cy, cx)
#        
#    def _select_textbox(self, windows):
#        # See at the root textbox.
#        topy, topx = self._center_view(windows[0])
#        
#        current_selected = 0
#        last = 1
#        top_textbox = windows[0]
#        
#        while True:
#            # Highligth the selected one, the last selected textbox should
#            # become normal again.
#            windows[current_selected].bkgd(curses.color_pair(1))
#            windows[last].bkgd(curses.color_pair(2))
#            
#            # While the textbox can be displayed on the page with the current 
#            # top_textbox, don't alter the view. When this becomes impossible, 
#            # center the view to last displayable textbox on the previous view.
#            maxy, maxx = self.stdscr.getmaxyx()
#            cy, cx = windows[current_selected].getbegyx()
#            
#            # The current window is to far down. Switch the top textbox.
#            if ((topy + maxy - self.TEXTBOX_HEIGHT) <= cy):
#                top_textbox = windows[current_selected]
#            
#            # The current window is to far up. There is a better way though...
#            if topy >= cy + self.TEXTBOX_HEIGHT:
#                top_textbox = windows[current_selected]
#            
#            if last != current_selected:
#                last = current_selected
#                
#            topy, topx = self._center_view(top_textbox)
#            
#            c = self.stdscr.getch()
#            
#            # Vim like KEY_UP/KEY_DOWN with j(DOWN) and k(UP).
#            if c == ord('j'):
#                if current_selected >= len(windows)-1:
#                    current_selected = 0 # wrap around.
#                else:
#                    current_selected += 1
#            elif c == ord('k'):
#                if current_selected <= 0:
#                    current_selected = len(windows)-1 # wrap around.
#                else:
#                    current_selected -= 1
#            elif c == ord('q'): # Quit without selecting.
#                break
#            # At hitting enter, return the index of the selected list element.
#            elif c == curses.KEY_ENTER or c == 10:
#                return int(current_selected)
#
#
#if __name__ == '__main__':
#    # As simple as that.
#    L = [
#         'I wish I was a wizard',
#         'Sometimes it all just makes sense',
#         'This string is here because I need it',
#         'Being or not being!',
#         'Python is worse then PHP ;)',
#         'a -> b <=> if a then b'
#        ]
#        
#    choice = BoxSelector(L).pick()
#    print('[+] Your choice was "{0}"'.format(L[choice]))







# --- ncurses sample 3



import sys
import curses
#import pprint

# line below is to include "smon" package in the search path
sys.path.append("/home/jripsl/snapshot/Monitoring")

from smon import repo_io
import smon.types


repo_io.init() # open DB connection

repo_io.populate_tables_with_sample()

simulations=repo_io.retrieve_simulations()

mylines = ["Line {0} ".format(id)*3 for id in range(1,11)]


def main(stdscr):
  hlines = begin_y = begin_x = 5 ; wcols = 10
  # calculate total content size
  padhlines = len(mylines)
  padwcols = 0
  for line in mylines:
    if len(line) > padwcols: padwcols = len(line)
  padhlines += 2 ; padwcols += 2 # allow border
  #stdscr.addstr("padhlines "+str(padhlines)+" padwcols "+str(padwcols)+"; ")
  # both newpad and subpad are <class '_curses.curses window'>:
  mypadn = curses.newpad(padhlines, padwcols)
  mypads = stdscr.subpad(padhlines, padwcols, begin_y, begin_x+padwcols+4)
  #stdscr.addstr(str(type(mypadn))+" "+str(type(mypads)) + "\n")
  mypadn.scrollok(1)
  mypadn.idlok(1)
  mypads.scrollok(1)
  mypads.idlok(1)

  mypadn.border(0) # first ...
  mypads.border(0) # ... border

  for line in mylines:
    mypadn.addstr(padhlines-1,1, line)
    mypadn.scroll(1)
    mypads.addstr(padhlines-1,1, line)
    mypads.scroll(1)

  mypadn.border(0) # second ...
  mypads.border(0) # ... border

  # refresh parent first, to render the texts on top
  #~ stdscr.refresh()

  # refresh the pads next
  mypadn.refresh(0,0, begin_y,begin_x, begin_y+hlines, begin_x+padwcols)
  mypads.refresh()
  mypads.touchwin()
  mypadn.touchwin()
  stdscr.touchwin() # no real effect here
  #stdscr.refresh() # not here! overwrites newpad!
  mypadn.getch()
  # even THIS command erases newpad!
  # (unless stdscr.refresh() previously):
  stdscr.getch()

curses.wrapper(main)




repo_io.free() # close DB connection









# --- urwid sample 1

#import urwid
#
#txt = urwid.Text(u"Hello World")
#fill = urwid.Filler(txt, 'top')
#loop = urwid.MainLoop(fill)
#loop.run()


# --- urwid sample 2

#import urwid
#
#def show_or_exit(key):
#    if key in ('q', 'Q'):
#        raise urwid.ExitMainLoop()
#    txt.set_text(repr(key))
#
#txt = urwid.Text(u"Hello World")
#fill = urwid.Filler(txt, 'top')
#loop = urwid.MainLoop(fill, unhandled_input=show_or_exit)
#loop.run()