Tizen 2.1 base

1 files changed, 483 insertions, 0 deletions

diff --git a/base/tui.py b/base/tui.py
new file mode 100644
index 0000000..e012636
--- /dev/null
+++ b/base/tui.py
@@ -0,0 +1,483 @@
+# -*- coding: utf-8 -*-
+#
+# (c) Copyright 2003-2009 Hewlett-Packard Development Company, L.P.
+#
+# 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; either version 2 of the License, or
+# (at your option) any later version.
+#
+# 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# Author: Don Welch
+#
+
+# Std Lib
+import sys
+import re
+
+# Local
+from g import *
+import pexpect
+import utils
+
+
+def enter_yes_no(question, default_value='y', choice_prompt=None):
+    if type(default_value) == type(""):
+        if default_value == 'y':
+            default_value = True
+        else:
+            default_value = False
+
+    #assert default_value in [True, False]
+
+    if choice_prompt is None:
+        if default_value:
+            question += " (y=yes*, n=no, q=quit) ? "
+        else:
+            question += " (y=yes, n=no*, q=quit) ? "
+    else:
+        question += choice_prompt
+
+    while True:
+        try:
+            user_input = raw_input(log.bold(question)).lower().strip()
+        except EOFError:
+            continue
+
+        if not user_input:
+            return True, default_value
+
+        if user_input == 'n':
+            return True, False
+
+        if user_input == 'y':
+            return True, True
+
+        if user_input in ('q', 'c'): # q -> quit, c -> cancel
+            return False, default_value
+
+        log.error("Please press <enter> or enter 'y', 'n', or 'q'.")
+
+
+def enter_range(question, min_value, max_value, default_value=None):
+    while True:
+        try:
+            user_input = raw_input(log.bold(question)).lower().strip()
+        except EOFError:
+            continue
+
+        if not user_input:
+            if default_value is not None:
+                return True, default_value
+
+        if user_input == 'q':
+            return False, default_value
+
+        try:
+            value_int = int(user_input)
+        except ValueError:
+            log.error('Please enter a number between %d and %d, or "q" to quit.' %
+                (min_value, max_value))
+            continue
+
+        if value_int < min_value or value_int > max_value:
+            log.error('Please enter a number between %d and %d, or "q" to quit.' %
+                (min_value, max_value))
+            continue
+
+        return True, value_int
+
+
+def enter_choice(question, choices, default_value=None):
+    if 'q' not in choices:
+        choices.append('q')
+
+    while True:
+        try:
+            user_input = raw_input(log.bold(question)).lower().strip()
+        except EOFError:
+            continue
+
+
+        if (not user_input and default_value) or user_input == default_value:
+            if default_value == 'q':
+                return False, default_value
+            else:
+                return True, default_value
+
+        #print user_input
+        if user_input == 'q':
+            return False, user_input
+
+        if user_input in choices:
+            return True, user_input
+
+        log.error("Please enter %s or press <enter> for the default of '%s'." %
+            (', '.join(["'%s'" % x for x in choices]), default_value))
+
+
+def title(text):
+    log.info("")
+    log.info("")
+    log.info(log.bold(text))
+    log.info(log.bold("-"*len(text)))
+
+
+def header(text):
+    c = len(text)
+    log.info("")
+    log.info("-"*(c+4))
+    log.info("| "+text+" |")
+    log.info("-"*(c+4))
+    log.info("")
+
+
+def load_paper_prompt():
+    return continue_prompt("A page will be printed.\nPlease load plain paper into the printer.")
+
+
+def load_scanner_for_align_prompt():
+    return continue_prompt("Load the alignment page on the scanner bed and push the 'Scan' or 'Enter' button on the printer to complete the alignment.")
+
+def load_photo_paper_prompt():
+    return continue_prompt("A page will be printed.\nPlease load HP Advanced Photo Paper - Glossy into the printer.")
+
+
+def continue_prompt(prompt=''):
+    while True:
+        try:
+            x = raw_input(log.bold(prompt + " Press <enter> to continue or 'q' to quit: ")).lower().strip()
+        except EOFError:
+            continue
+
+        if not x:
+            return True
+
+        elif x == 'q':
+            return  False
+
+        log.error("Please press <enter> or enter 'q' to quit.")
+
+
+def enter_regex(regex, prompt, pattern, default_value=None):
+    re_obj = re.compile(regex)
+    while True:
+        try:
+            x = raw_input(log.bold(prompt))
+        except EOFError:
+            continue
+
+        if not x and default_value is not None:
+            return default_value, x
+
+        elif x == 'q':
+            return False, default_value
+
+        match = re_obj.search(x)
+
+        if not match:
+            log.error("Incorrect input. Please enter correct input.")
+            continue
+
+        return True, x
+
+
+def ttysize():
+    try:
+        import commands # TODO: Replace with subprocess (commands is deprecated in Python 3.0)
+        ln1 = commands.getoutput('stty -a').splitlines()[0]
+        vals = {'rows':None, 'columns':None}
+        for ph in ln1.split(';'):
+            x = ph.split()
+            if len(x) == 2:
+                vals[x[0]] = x[1]
+                vals[x[1]] = x[0]
+        return int(vals['rows']), int(vals['columns'])
+    except TypeError:
+        return 40, 64
+
+
+class ProgressMeter(object):
+    def __init__(self, prompt="Progress:"):
+        self.progress = 0
+        self.prompt = prompt
+        self.prev_length = 0
+        self.spinner = "\|/-\|/-*"
+        self.spinner_pos = 0
+        self.max_size = ttysize()[1] - len(prompt) - 25
+        self.update(0)
+
+    def update(self, progress, msg=''): # progress in %
+        self.progress = progress
+
+        x = self.progress * self.max_size / 100
+        if x > self.max_size: x = self.max_size
+
+        if self.progress >= 100:
+            self.spinner_pos = 8
+            self.progress = 100
+
+        sys.stdout.write("\b" * self.prev_length)
+
+        y = "%s [%s%s%s] %d%%  %s   " % \
+            (self.prompt, '*'*(x-1), self.spinner[self.spinner_pos],
+             ' '*(self.max_size-x), self.progress, msg)
+
+        sys.stdout.write(y)
+
+        sys.stdout.flush()
+        self.prev_length = len(y)
+        self.spinner_pos = (self.spinner_pos + 1) % 8
+
+
+
+class Formatter(object):
+    def __init__(self, margin=2, header=None, min_widths=None, max_widths=None):
+        self.margin = margin # int
+        self.header = header # tuple of strings
+        self.rows = [] # list of tuples
+        self.max_widths = max_widths # tuple of ints
+        self.min_widths = min_widths # tuple of ints
+
+
+    def add(self, row_data): # tuple of strings
+        self.rows.append(row_data)
+
+
+    def output(self):
+        if self.rows:
+            num_cols = len(self.rows[0])
+            for r in self.rows:
+                if len(r) != num_cols:
+                    log.error("Invalid number of items in row: %s" % r)
+                    return
+
+            if len(self.header) != num_cols:
+                log.error("Invalid number of items in header.")
+
+            min_calc_widths = []
+            for c in self.header:
+                header_parts = c.split(' ')
+                max_width = 0
+                for x in header_parts:
+                    max_width = max(max_width, len(x))
+
+                min_calc_widths.append(max_width)
+
+            max_calc_widths = []
+            for x, c in enumerate(self.header):
+                max_width = 0
+                for r in self.rows:
+                    max_width = max(max_width, len(r[x]))
+
+                max_calc_widths.append(max_width)
+
+            max_screen_width = None
+
+            if self.max_widths is None:
+                max_screen_width = ttysize()[1]
+                def_max = 8*(max_screen_width/num_cols)/10
+                self.max_widths = []
+                for c in self.header:
+                    self.max_widths.append(def_max)
+            else:
+                if len(self.max_widths) != num_cols:
+                    log.error("Invalid number of items in max col widths.")
+
+            if self.min_widths is None:
+                if max_screen_width is None:
+                    max_screen_width = ttysize()[1]
+                def_min = 4*(max_screen_width/num_cols)/10
+                self.min_widths = []
+                for c in self.header:
+                    self.min_widths.append(def_min)
+            else:
+                if len(self.min_widths) != num_cols:
+                    log.error("Invalid number of items in min col widths.")
+
+            col_widths = []
+            formats = []
+            for m1, m2, m3, m4 in zip(self.min_widths, min_calc_widths,
+                                      self.max_widths, max_calc_widths):
+                col_width = max(max(m1, m2), min(m3, m4))
+                col_widths.append(col_width)
+                formats.append({'width': col_width, 'margin': self.margin})
+
+            formatter = utils.TextFormatter(tuple(formats))
+
+            log.info(formatter.compose(self.header))
+
+            sep = []
+            for c in col_widths:
+                sep.append('-'*c)
+
+            log.info(formatter.compose(tuple(sep)))
+
+            for r in self.rows:
+                log.info(formatter.compose(r))
+
+        else:
+            log.error("No data rows")
+
+
+
+ALIGN_LEFT = 0
+ALIGN_CENTER = 1
+ALIGN_RIGHT = 2
+
+
+def align(line, width=70, alignment=ALIGN_LEFT):
+    space = width - len(line)
+
+    if alignment == ALIGN_CENTER:
+        return ' '*(space/2) + line + \
+               ' '*(space/2 + space%2)
+
+    elif alignment == ALIGN_RIGHT:
+        return ' '*space + line
+
+    else:
+        return line + ' '*space
+
+
+def format_paragraph(paragraph, width=None, alignment=ALIGN_LEFT):
+    if width is None:
+        width = ttysize()[1]
+
+    result = []
+    words = paragraph.split()
+    try:
+        current, words = words[0], words[1:]
+    except IndexError:
+        return [paragraph]
+
+    for word in words:
+        increment = 1 + len(word)
+
+        if len(current) + increment > width:
+            result.append(align(current, width, alignment))
+            current = word
+
+        else:
+            current = current+" "+word
+
+    result.append(align(current, width, alignment))
+    return result
+
+
+def printer_table(printers):
+    header("SELECT PRINTER")
+    last_used_printer_name = user_conf.get('last_used', 'printer_name')
+    ret = None
+
+    table = Formatter(header=('Num', 'CUPS Printer'),
+                              max_widths=(8, 100), min_widths=(8, 20))
+
+    default_index = None
+    for x, _ in enumerate(printers):
+        if last_used_printer_name == printers[x]:
+            table.add((str(x) + '*', printers[x]))
+            default_index = x
+        else:
+            table.add((str(x), printers[x]))
+
+    table.output()
+
+    if default_index is not None:
+        ok, i = enter_range("\nEnter number 0...%d for printer (q=quit, <enter>=default: *%d) ?" % (x, default_index),
+                                0, x, default_index)
+    else:
+        ok, i = enter_range("\nEnter number 0...%d for printer (q=quit) ?" % x, 0, x)
+
+    if ok:
+        ret = printers[i]
+
+    return ret
+
+
+def device_table(devices, scan_flag=False):
+    header("SELECT DEVICE")
+    last_used_device_uri = user_conf.get('last_used', 'device_uri')
+    ret = None
+
+    if scan_flag:
+        table = Formatter(header=('Num', 'Scan device URI'),
+                                 max_widths=(8, 100), min_widths=(8, 12))
+    else:
+        table = Formatter(header=('Num', 'Device URI', 'CUPS Printer(s)'),
+                                 max_widths=(8, 100, 100), min_widths=(8, 12, 12))
+
+    default_index = None
+    device_index = {}
+    for x, d in enumerate(devices):
+        device_index[x] = d
+        if last_used_device_uri == d:
+            if scan_flag:
+                table.add((str(x) + "*", d))
+            else:
+                table.add((str(x) + "*", d, ','.join(devices[d])))
+            default_index = x
+        else:
+            if scan_flag:
+                table.add((str(x), d))
+            else:
+                table.add((str(x), d, ','.join(devices[d])))
+
+    table.output()
+
+    if default_index is not None:
+        ok, i = enter_range("\nEnter number 0...%d for device (q=quit, <enter>=default: %d*) ?" % (x, default_index),
+                                0, x, default_index)
+    else:
+        ok, i = enter_range("\nEnter number 0...%d for device (q=quit) ?" % x, 0, x)
+
+    if ok:
+        ret = device_index[i]
+
+    return ret
+
+
+def connection_table():
+    ret, ios, x = None, {0: ('usb', "Universal Serial Bus (USB)") }, 1
+
+    if prop.net_build:
+        ios[x] = ('net', "Network/Ethernet/Wireless (direct connection or JetDirect)")
+        x += 1
+
+    if prop.par_build:
+        ios[x] = ('par', "Parallel Port (LPT:)")
+        x += 1
+
+    if len(ios) > 1:
+        header("SELECT CONNECTION (I/O) TYPE")
+
+        table = Formatter(header=('Num', 'Connection Type', 'Description'),
+                          max_widths=(8, 20, 80), min_widths=(8, 10, 40))
+
+        for x, data in ios.items():
+            if x == 0:
+                table.add((str(x) + "*", data[0], data[1]))
+            else:
+                table.add((str(x), data[0], data[1]))
+
+        table.output()
+
+        ok, val = enter_range("\nEnter number 0...%d for connection type (q=quit, enter=usb*) ? " % x,
+            0, x, 0)
+
+        if ok:
+            ret = [ios[val][0]]
+
+    else:
+        ret = ['usb']
+
+    return ret
+