old mode 100644

new mode 100755

old mode 100644

new mode 100755

old mode 100644

new mode 100755

@@ -20,7 +20,7 @@ class ConfirmWindow(Window):

                         ('No',  self.exit_function, False)

                     ]

         self.menu = Menu(menu_starty,  maxx, items, can_navigate_outside = False, horizontal=True)

-        super(ConfirmWindow, self).__init__(height, width, maxy, maxx, 'Confirm', False, self.menu)

+        super(ConfirmWindow, self).__init__(height, width, maxy, maxx, 'Confirm', False, self.menu, items=[])

         self.addstr(0,0, message)

     def exit_function(self, yes):

old mode 100644

new mode 100755

@@ -19,6 +19,11 @@ class Device(object):

         return Device.wrap_devices_from_list(devices_list)

     @staticmethod

+    def refresh_devices_bytes():

+        devices_list = subprocess.check_output(['lsblk', '-S', '--bytes', '-I', '8', '-n', '--output', 'NAME,SIZE,MODEL'], stderr=open(os.devnull, 'w'))

+        return Device.wrap_devices_from_list(devices_list)

+

+    @staticmethod

     def wrap_devices_from_list(list):

         devices = []

         deviceslines = list.splitlines()

old mode 100644

new mode 100755

old mode 100644

new mode 100755

@@ -64,7 +64,7 @@ class Installer(object):

             self.progress_width = self.width - self.progress_padding

             self.starty = (self.maxy - self.height) / 2

             self.startx = (self.maxx - self.width) / 2

-            self.window = Window(self.height, self.width, self.maxy, self.maxx, 'Installing Photon', False)

+            self.window = Window(self.height, self.width, self.maxy, self.maxx, 'Installing Photon', False, items =[])

             self.progress_bar = ProgressBar(self.starty + 3, self.startx + self.progress_padding / 2, self.progress_width)

         signal.signal(signal.SIGINT, self.exit_gracefully)

@@ -231,6 +231,7 @@ class Installer(object):

             fsck = 2

             if 'mountpoint' in partition and partition['mountpoint'] == '/':

+                options = options + ',barrier,noatime,noacl,data=ordered'

                 fsck = 1

             if partition['filesystem'] == 'swap':

old mode 100644

new mode 100755

@@ -21,6 +21,7 @@ import random

 import urllib

 import urllib2

 import modules.commons

+from partitionISO import PartitionISO

 from diskpartitioner import DiskPartitioner

 from packageselector import PackageSelector

 from custompackageselector import CustomPackageSelector

@@ -227,10 +228,12 @@ class IsoInstaller(object):

             install_config = {'iso_system': False}

             license_agreement = License(self.maxy, self.maxx)

             select_disk = SelectDisk(self.maxy, self.maxx, install_config)

+            select_partition = PartitionISO(self.maxy, self.maxx, install_config)

             package_selector = PackageSelector(self.maxy, self.maxx, install_config, options_file)

             self.alpha_chars = range(65, 91)

             self.alpha_chars.extend(range(97,123))

+            partition_accepted_chars = list(range(48, 58))

             hostname_accepted_chars = list(self.alpha_chars)

             # Adding the numeric chars

             hostname_accepted_chars.extend(range(48, 58))

@@ -246,7 +249,8 @@ class IsoInstaller(object):

                     self.validate_hostname, # validation function of the input

                     None, # post processing of the input field

                     'Choose the hostname for your system', 'Hostname:', 2, install_config,

-                    random_hostname)

+                    random_hostname,

+                    True)

             root_password_reader = WindowStringReader(

                     self.maxy, self.maxx, 10, 70, 

                     'password', 

@@ -290,6 +294,8 @@ class IsoInstaller(object):

             items = items + [

                     (license_agreement.display, False),

                     (select_disk.display, True),

+                    (select_partition.display, False),

+                    (select_disk.guided_partitions, False),

                     (package_selector.display, True),

                     (hostname_reader.get_user_string, True),

                     (root_password_reader.get_user_string, True),

old mode 100644

new mode 100755

old mode 100644

new mode 100755

@@ -22,7 +22,7 @@ class License(object):

         self.text_height = self.win_height - 6

         self.text_width = self.win_width - 6

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False)

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False, items=[])

     def display(self, params):

         accept_decline_items =  [

old mode 100644

new mode 100755

@@ -10,7 +10,7 @@ from action import Action

 from sets import Set

 class Menu(Action):

-    def __init__(self, starty, maxx, items, height = 0, selector_menu = False, can_navigate_outside = True, horizontal = False, default_selected = 0):

+    def __init__(self, starty, maxx, items, height = 0, selector_menu = False, can_navigate_outside = True, horizontal = False, default_selected = 0, save_sel = False, tab_enable = True):

         self.can_navigate_outside = can_navigate_outside

         self.horizontal = horizontal

         self.horizontal_padding = 10

@@ -20,6 +20,8 @@ class Menu(Action):

         self.items_strings = []

         self.width = self.lengthen_items()

         self.num_items = len(self.items)

+        self.save_sel = save_sel

+        self.tab_enable=tab_enable

         if height == 0 or height > self.num_items:

             self.height = self.num_items

         else:

@@ -61,6 +63,9 @@ class Menu(Action):

         self.panel.hide()

         curses.panel.update_panels()

+    def can_save_sel(self, can_save_sel):

+        self.save_sel = can_save_sel

+

     def lengthen_items(self):

         width = 0

         for item in self.items:

@@ -179,13 +184,31 @@ class Menu(Action):

                 else:

                     self.selected_items.add(self.position)

             elif key in [ord('\t')] and self.can_navigate_outside:

+                if not self.tab_enable:

+                    continue

                 self.refresh(False)

-                return ActionResult(False, None)

+                if self.save_sel:

+                    return ActionResult(False, {'diskIndex': self.position})

+                else:

+                    return ActionResult(False, None)

             elif key == curses.KEY_UP or key == curses.KEY_LEFT:

+                if not self.tab_enable and key==curses.KEY_LEFT:

+                    if self.save_sel:

+                        return ActionResult(False, {'diskIndex': self.position, 'direction':-1})

+                    elif self.selector_menu:

+                        result = self.items[self.position][1](self.selected_items)

+                    else:

+                        result = self.items[self.position][1](self.items[self.position][2])

+                    return ActionResult(False, {'direction': -1})

                 self.navigate(-1)

             elif key == curses.KEY_DOWN or key == curses.KEY_RIGHT:

+                if not self.tab_enable and key==curses.KEY_RIGHT:

+                    if self.save_sel:

+                        return ActionResult(False, {'diskIndex': self.position, 'direction':1})

+                    else:

+                        return ActionResult(False, {'direction': 1})

                 self.navigate(1)

             elif key == curses.KEY_NPAGE:

old mode 100644

new mode 100755

old mode 100644

new mode 100755

@@ -155,7 +155,7 @@ class OstreeInstaller(Installer):

         deployment_fstab = os.path.join(deployment, "etc/fstab")

-        self.run("echo \"/dev/sda3    /        ext4   defaults   1 1  \" >> {} ".format(deployment_fstab), "Adding / mount point in fstab")

+        self.run("echo \"/dev/sda3    /        ext4   defaults,barrier,noatime,noacl,data=ordered 1 1  \" >> {} ".format(deployment_fstab), "Adding / mount point in fstab")

         self.run("echo \"/dev/sda2    /boot    ext4   defaults   1 2  \" >> {} ".format(deployment_fstab), "Adding /boot mount point in fstab")

         self.run("mount --bind {} {}".format(deployment, self.photon_root))

         self.progress_bar.update_loading_message("Starting post install modules")

old mode 100644

new mode 100755

old mode 100644

new mode 100755

old mode 100644

new mode 100755

old mode 100644

new mode 100755

@@ -28,7 +28,7 @@ class PackageSelector(object):

         self.load_package_list(options_file)

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Select Installation', True, self.package_menu)

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Select Installation', True, self.package_menu, can_go_next=True, position=1)

     @staticmethod

     def get_packages_to_install(options, config_type, output_data_path):

@@ -74,7 +74,7 @@ class PackageSelector(object):

                 visible_options_cnt = visible_options_cnt + 1

-        self.package_menu = Menu(self.menu_starty,  self.maxx, self.package_menu_items, default_selected = default_selected)

+        self.package_menu = Menu(self.menu_starty,  self.maxx, self.package_menu_items, default_selected = default_selected, tab_enable=False)

     def exit_function(self,  selected_item_params):

         self.install_config['type'] = selected_item_params[0];

new file mode 100755

@@ -0,0 +1,196 @@

+from window import Window 

+from windowstringreader import WindowStringReader

+from textpane import TextPane

+from readmultext import ReadMulText

+from confirmwindow import ConfirmWindow

+from actionresult import ActionResult

+from device import Device

+

+class PartitionISO(object):

+    def __init__(self, maxy, maxx, install_config):

+        self.maxx = maxx

+        self.maxy = maxy

+        self.win_width = maxx - 4

+        self.win_height = maxy - 4

+        self.install_config = install_config

+        self.path_checker = []

+

+        self.win_starty = (self.maxy - self.win_height) / 2

+        self.win_startx = (self.maxx - self.win_width) / 2

+

+        self.text_starty = self.win_starty + 4

+        self.text_height = self.win_height - 6

+        self.text_width = self.win_width - 6

+        self.install_config['partitionsnumber'] = 0

+        self.devices = Device.refresh_devices_bytes()

+        self.has_slash = False

+        self.has_remain = False

+        self.has_empty = False

+

+        self.disk_size = []

+        for index, device in enumerate(self.devices):

+            self.disk_size.append((device.path, int(device.size) / 1048576))     

+

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Welcome to the Photon installer', False, items=[], can_go_next=False)

+        Device.refresh_devices()

+

+    def display(self, params):

+        if 'skipPrevs' in self.install_config and self.install_config['skipPrevs'] == True:

+            self.delete()

+            return ActionResult(False, {'goBack':True})

+        if 'autopartition' in self.install_config and self.install_config['autopartition'] == True:

+            return ActionResult(True, None)

+        if 'delete_partition' in self.install_config and self.install_config['delete_partition'] == True:

+            self.delete()

+            self.install_config['delete_partition']=False

+

+        self.device_index = self.install_config['diskindex']

+

+        self.disk_buttom_items = []

+        self.disk_buttom_items.append(('<Next>', self.next))

+        self.disk_buttom_items.append(('<Create New>', self.create_function))

+        self.disk_buttom_items.append(('<Delete All>', self.delete_function))

+        self.disk_buttom_items.append(('<Go Back>', self.go_back))

+

+        self.text_items = []

+        self.text_items.append(('Disk', 20))

+        self.text_items.append(('Size', 5))

+        self.text_items.append(('Type', 5))

+        self.text_items.append(('Mountpoint', 20))

+        self.table_space = 5

+

+        title = 'Current partitions:\n'

+        self.window.addstr(0, (self.win_width - len(title)) / 2, title)

+

+        info = "Unpartitioned space: "+str(self.disk_size[self.device_index][1])+ " MB, Total size: "+ str(int(self.devices[self.device_index].size)/ 1048576)+" MB"

+

+        self.text_pane = TextPane(self.text_starty, self.maxx, self.text_width, 

+            "EULA.txt", self.text_height, self.disk_buttom_items, 

+            partition = True, popupWindow = True, install_config = self.install_config, 

+            text_items = self.text_items, table_space=self.table_space, default_start=1, info=info, size_left=str(self.disk_size[self.device_index][1]))

+

+        self.window.set_action_panel(self.text_pane)

+

+        return self.window.do_action()

+

+    def validate_partition(self, pstr):

+        if not pstr:

+            return ActionResult(False, None)

+        sizedata = pstr[0]

+        mtdata = pstr[2]

+        typedata = pstr[1]

+        devicedata = self.devices[self.device_index].path

+

+        #no empty fields unless swap

+        if typedata == 'swap' and (len(mtdata)!=0 or len(typedata) == 0 or len(devicedata) == 0):

+            return False, "invalid swap data "

+

+        if typedata != 'swap' and (len(sizedata) == 0 or len(mtdata) == 0 or len(typedata) == 0 or len(devicedata) == 0):

+            if not self.has_empty and len(mtdata) != 0 and len(typedata) != 0 and len(devicedata) != 0:

+                self.has_empty = True

+            else:

+                return False, "Input cannot be empty"

+

+        if typedata !='swap' and typedata!='ext3' and typedata!='ext4':

+            return False, "Invalid type"

+

+        if len(mtdata)!=0 and mtdata[0] !='/':

+            return False, "Invalid path"

+

+        if mtdata in self.path_checker:

+            return False, "Path already existed"

+        #validate disk: must be one of the existing disks

+        i = self.device_index

+

+        #valid size: must not exceed memory limit

+        curr_size = self.disk_size[i][1]

+        if len(sizedata)!=0:

+            try:

+                int(sizedata)

+            except ValueError:

+                return False, "invalid device size"

+

+            if int(curr_size) - int(sizedata) < 0:

+                return False, "invalid device size"

+            #if valid, update the size and return true

+            new_size = (self.disk_size[i][0], int(curr_size)- int(sizedata))

+            self.disk_size[i] =new_size

+

+        if mtdata=="/":

+            self.has_slash=True

+

+        self.path_checker.append(mtdata)

+        return True, None

+

+    def create_function(self):

+        self.window.hide_window()

+

+        self.install_config['partition_disk'] = self.devices[self.device_index].path

+        self.partition_items = []

+        self.partition_items.append(('Size in MB: '+str(self.disk_size[self.device_index][1])+' available'))

+        self.partition_items.append(('Type: (ext3, ext4, swap)'))

+        self.partition_items.append(('Mountpoint:'))

+        self.create_window = ReadMulText(

+                self.maxy, self.maxx, 0,

+                self.install_config,

+                str(self.install_config['partitionsnumber']) + 'partition_info',

+                self.partition_items,

+                None,

+                None,

+                None,

+                self.validate_partition,   #validation function of the input

+                None,

+                True,

+                )

+        result = self.create_window.do_action()

+        if result.success:

+            self.install_config['partitionsnumber'] = self.install_config['partitionsnumber'] + 1

+

+        #parse the input in install config

+        return self.display(False)

+

+    def delete_function(self):

+        self.delete()

+        return self.display(False)

+

+    def go_back(self):

+        self.delete()

+        self.window.hide_window()

+        self.text_pane.hide()

+        return ActionResult(False, {'goBack':True})

+

+    def next(self):

+        if self.install_config['partitionsnumber'] == 0:

+            window_height=9

+            window_width=40

+            window_starty=(self.maxy-window_height)/2+5

+            confirm_window=ConfirmWindow(window_height,window_width,self.maxy, self.maxx, window_starty, 'Partition information cannot be empty', info=True)

+            confirm_window.do_action()

+            return self.display(False)

+        #must have /

+        if not self.has_slash:

+            window_height=9

+            window_width=40

+            window_starty=(self.maxy-window_height)/2+5

+            confirm_window=ConfirmWindow(window_height,window_width,self.maxy, self.maxx, window_starty, 'Missing /', info=True)

+            confirm_window.do_action()

+            return self.display(False)

+

+        self.window.hide_window()

+        self.text_pane.hide()

+        return ActionResult(True, {'goNext':True})

+

+    def delete(self):

+        for i in range(int(self.install_config['partitionsnumber'])):

+            self.install_config[str(i)+'partition_info'+str(0)] = ''

+            self.install_config[str(i)+'partition_info'+str(1)] = ''

+            self.install_config[str(i)+'partition_info'+str(2)] = ''

+            self.install_config[str(i)+'partition_info'+str(3)] = ''

+        del self.disk_size[:]

+        for index, device in enumerate(self.devices):

+            self.disk_size.append((device.path, int(device.size) / 1048576))

+        del self.path_checker[:]

+        self.has_slash = False

+        self.has_remain = False

+        self.has_empty = False

+        self.install_config['partitionsnumber'] = 0

old mode 100644

new mode 100755

@@ -10,7 +10,7 @@ import math

 from curses import panel

 class ProgressBar(object):

-    def __init__(self, starty, startx, width):

+    def __init__(self, starty, startx, width, new_win=False):

         self.timer = None

         self.loadding_timer = None

         self.timer_lock = threading.Lock()

@@ -26,6 +26,20 @@ class ProgressBar(object):

         self.window.bkgd(' ', curses.color_pair(2)) #defaultbackground color

         self.progress = 0

+        self.new_win = new_win

+        self.x=startx

+        self.y=starty

+

+        if new_win:

+            self.contentwin = curses.newwin(7, width+2)

+            self.contentwin.bkgd(' ', curses.color_pair(2)) #Default Window color

+            self.contentwin.erase()

+            self.contentwin.box()

+            self.contentpanel = curses.panel.new_panel(self.contentwin)

+            self.contentpanel.move(starty-1, startx-1)

+            self.contentpanel.hide()

+

+

         self.panel = panel.new_panel(self.window)

         self.panel.move(starty, startx)

         self.panel.hide()

@@ -93,6 +107,11 @@ class ProgressBar(object):

         self.render_progress()

     def show(self):

+        if self.new_win:

+            self.contentpanel.top()

+            self.contentpanel.move(self.y-1, self.x-1)

+            self.contentpanel.show()

+

         self.refresh()

         self.panel.top()

         self.panel.show()

@@ -135,6 +154,8 @@ class ProgressBar(object):

                 self.loadding_timer.cancel()

                 self.loadding_timer = None

+        if self.new_win:

+            self.contentpanel.hide()

         self.panel.hide()

         panel.update_panels()

new file mode 100755

@@ -0,0 +1,211 @@

+#! /usr/bin/python2

+#

+#    Copyright (C) 2015 vmware inc.

+#

+#    Author: Yang Yao <yaoyang@vmware.com>

+

+import curses

+import sys

+from actionresult import ActionResult

+from action import Action

+from window import Window

+from confirmwindow import ConfirmWindow

+

+class ReadMulText(Action):

+    def __init__(self, maxy, maxx, y, install_config, field, display_string, confirmation_error_msg, 

+        echo_char, accepted_chars, validation_fn, conversion_fn, can_cancel, default_string = None):

+        self.maxy = maxy

+        self.maxx = maxx

+        self.y = y

+        self.install_config = install_config

+        self.field = field

+        self.horizontal_padding = 10

+        self.confirmation_error_msg = confirmation_error_msg

+        self.echo_char = echo_char

+        self.accepted_chars = accepted_chars

+        self.validation_fn = validation_fn

+        self.conversion_fn = conversion_fn

+        self.default_string = default_string

+        self.display_string = display_string

+        self.textwin_width = maxx - self.horizontal_padding -2

+        self.textwin_width = self.textwin_width*2/3

+        self.visible_text_width = self.textwin_width - 1

+        self.position = 0

+        self.height = len(self.display_string) * 4 + 2

+        self.menu_pos = 0

+

+        self.textwin = curses.newwin(self.height, self.textwin_width + 2)#self.textwin_width)

+        self.textwin.bkgd(' ', curses.color_pair(2))

+        self.textwin.keypad(1)

+

+        self.shadowwin = curses.newwin(self.height, self.textwin_width + 2)

+        self.shadowwin.bkgd(' ', curses.color_pair(0)) #Default shadow color

+

+        self.panel = curses.panel.new_panel(self.textwin)

+        self.panel.move((maxy-self.height)/2, (maxx - self.textwin_width) / 2 -1)

+        self.panel.hide()

+        self.shadowpanel = curses.panel.new_panel(self.shadowwin)

+        self.shadowpanel.move((maxy-self.height)/2+1, (maxx - self.textwin_width) / 2)

+        self.shadowpanel.hide()

+        curses.panel.update_panels()

+

+        self.init_text()

+        self.textwin.box()

+        self.maxlength = 255

+

+        #initialize the accepted characters

+        if accepted_chars:

+            self.accepted_chars = accepted_chars

+        else:

+            self.accepted_chars = range(32, 127)

+

+    def hide(self):

+        return

+    

+    def init_text(self):

+        self.shadowpanel.show()

+        curses.panel.update_panels()

+

+        self.x = 0;

+        #initialize the ----

+        dashes = '_' * self.textwin_width 

+        cury = self.y+1

+        self.str = []

+

+        for string in self.display_string:

+            self.textwin.addstr(cury, 1, string)

+            self.textwin.addstr(cury+1, 1, dashes)

+            cury = cury + 4

+            self.str.append('')

+

+        #remove the error messages

+        spaces = ' ' * self.textwin_width

+        #self.textwin.addstr(self.y + 2, 0, spaces)

+        self.update_menu()

+

+    def do_action(self):

+        self.init_text()

+        curses.curs_set(1)

+

+        if self.default_string != None:

+            self.textwin.addstr(self.y, 0, self.default_string)

+            self.str = self.default_string

+

+        while True:

+            if len(self.str[self.position]) > self.visible_text_width:

+                curs_loc = self.visible_text_width + 1

+            else:

+                curs_loc = len(self.str[self.position]) +1

+            ch = self.textwin.getch(self.y+2+self.position*4, curs_loc)

+

+            update_text = False

+            if ch in [curses.KEY_ENTER, ord('\n')]:

+                if self.menu_pos==1:

+                    curses.curs_set(0)

+                    self.shadowpanel.hide()

+                    return ActionResult(False, None)

+                if self.confirmation_error_msg:

+                    if self.str != self.install_config[self.field]:

+                        curses.curs_set(0)

+                        conf_message_height = 8

+                        conf_message_width = 48

+                        conf_message_button_y = (self.maxy - conf_message_height) / 2 + 5

+                        confrim_window = ConfirmWindow(conf_message_height, conf_message_width, self.maxy, self.maxx, conf_message_button_y, self.confirmation_error_msg, True)

+                        confrim_window.do_action()

+                        return ActionResult(False, {'goBack': True})

+                    self.set_field()

+                else:

+                    if not self.validate_input():

+                        continue

+                    self.set_field()

+                curses.curs_set(0)

+                self.shadowpanel.hide()

+                return ActionResult(True, None)

+            elif ch == curses.KEY_UP:

+                self.refresh(-1)

+

+            elif ch == curses.KEY_DOWN:

+                self.refresh(1)

+

+            elif ch in [ord('\t')]:

+                self.refresh(1, reset=True)

+

+            elif ch ==curses.KEY_LEFT:

+                self.menu_refresh(1)

+

+            elif ch == curses.KEY_RIGHT:

+                self.menu_refresh(-1)

+

+            elif ch == curses.KEY_BACKSPACE:

+                # Handle the backspace case

+                self.str[self.position] = self.str[self.position][:len(self.str[self.position]) - 1]

+                update_text = True

+

+            elif len(self.str[self.position]) < self.maxlength and ch in self.accepted_chars:

+                self.str[self.position] += chr(ch)

+                update_text = True

+

+            if update_text:

+                self.update_text()

+

+    def menu_refresh(self, n):

+        self.menu_pos+=n

+        if self.menu_pos<0:

+            self.menu_pos=0

+        elif self.menu_pos>=1:

+            self.menu_pos=1

+        self.update_menu()

+

+    def update_menu(self):

+        if self.menu_pos==1:

+            self.textwin.addstr(self.height-2, 5, '<Cancel>', curses.color_pair(3))

+        else:

+            self.textwin.addstr(self.height-2, 5, '<Cancel>')

+        if self.menu_pos==0:

+            self.textwin.addstr(self.height-2, self.textwin_width-len('<OK>')-5, '<OK>',curses.color_pair(3))

+        else:

+            self.textwin.addstr(self.height-2, self.textwin_width-len('<OK>')-5, '<OK>')

+

+

+

+    def update_text(self):

+        if len(self.str[self.position]) > self.visible_text_width:

+            text = self.str[self.position][-self.visible_text_width:]

+        else:

+            text = self.str[self.position]

+        if self.echo_char:

+            text = self.echo_char * len(text)

+

+        text = text + '_' * (self.visible_text_width - len(self.str[self.position]))

+        self.textwin.addstr(self.y+2+self.position*4, 1, text)

+

+    def refresh(self, n, reset=False):

+        self.position += n 

+        if self.position < 0:

+            self.position = 0

+        elif self.position >= len(self.display_string):

+            if reset:

+                self.position=0

+            else:

+                self.position = len(self.display_string)-1

+

+    def set_field(self):

+        i = 0

+        for string in self.display_string:

+            if self.conversion_fn:

+                self.install_config[self.field+str(i)] = self.conversion_fn(self.str[i])

+            else:

+                self.install_config[self.field+str(i)] = self.str[i]

+            i = i + 1

+

+    def validate_input(self):

+        if self.validation_fn:

+            success, err = self.validation_fn(self.str)

+            if not success:

+                spaces = ' ' * (int(self.textwin_width) - len(self.display_string[0]))

+                self.textwin.addstr(self.y + 1, len(self.display_string[0]), spaces)

+                self.textwin.addstr(self.y + 1, len(self.display_string[0]), err, curses.color_pair(4))

+            return success

+        else:

+            return True

+

old mode 100644

new mode 100755

@@ -11,7 +11,7 @@ from action import Action

 from confirmwindow import ConfirmWindow

 class ReadText(Action):

-    def __init__(self, maxy, maxx, textwin, y, install_config, field, confirmation_error_msg, echo_char, accepted_chars, validation_fn, conversion_fn, default_string = None):

+    def __init__(self, maxy, maxx, textwin, y, install_config, field, confirmation_error_msg, echo_char, accepted_chars, validation_fn, conversion_fn, default_string = None, tab_enabled=True):

         self.textwin = textwin

         self.maxy = maxy

         self.maxx = maxx

@@ -26,10 +26,14 @@ class ReadText(Action):

         self.default_string = default_string

         self.textwin_width = self.textwin.getmaxyx()[1] - 1

         self.visible_text_width = self.textwin_width - 1

+        self.tab_enabled=tab_enabled

         self.init_text()

         self.maxlength = 255

+        if not tab_enabled:

+            self.textwin.keypad(1)

+

         #initialize the accepted characters

         if accepted_chars:

             self.accepted_chars = accepted_chars

@@ -50,13 +54,23 @@ class ReadText(Action):

         spaces = ' ' * self.textwin_width

         self.textwin.addstr(self.y + 2, 0, spaces)

-    def do_action(self):

-        self.init_text()

-        curses.curs_set(1)

-

-        if self.default_string != None:

-            self.textwin.addstr(self.y, 0, self.default_string)

-            self.str = self.default_string

+    def do_action(self, returned=False, go_back=False):

+        if returned:

+            if len(self.str) > self.visible_text_width:

+                text = self.str[-self.visible_text_width:]

+            else:

+                text = self.str

+            if self.echo_char:

+                text = self.echo_char * len(text)

+            # Add the dashes

+            text = text + '_' * (self.visible_text_width - len(self.str))

+            self.textwin.addstr(self.y, 0, text)

+        if not returned:

+            curses.curs_set(1)

+            self.init_text()

+            if self.default_string != None:

+                self.textwin.addstr(self.y, 0, self.default_string)

+                self.str = self.default_string

         while True:

             if len(self.str) > self.visible_text_width:

@@ -67,9 +81,11 @@ class ReadText(Action):

             update_text = False

             if ch in [curses.KEY_ENTER, ord('\n')]:

+                curses.curs_set(0)

+                if go_back:

+                    return ActionResult(False, {'goBack': True})

                 if self.confirmation_error_msg:

                     if self.str != self.install_config[self.field]:

-                        curses.curs_set(0)

                         conf_message_height = 8

                         conf_message_width = 48

                         conf_message_button_y = (self.maxy - conf_message_height) / 2 + 5

@@ -83,10 +99,14 @@ class ReadText(Action):

                     self.set_field()

                 curses.curs_set(0)

                 return ActionResult(True, None)

+            elif ch ==curses.KEY_LEFT and not self.tab_enabled:

+                return ActionResult(False, {'direction': -1})

+            elif ch ==curses.KEY_RIGHT and not self.tab_enabled:

+                return ActionResult(False, {'direction': 1})

             elif ch in [ord('\t')]:

                 curses.curs_set(0)

                 return ActionResult(False, None)

-            elif ch == 127:

+            elif ch == curses.KEY_BACKSPACE: #originally ==127

                 # Handle the backspace case

                 self.str = self.str[:len(self.str) - 1]

old mode 100644

new mode 100755

@@ -29,30 +29,61 @@ class SelectDisk(object):

         self.menu_height = 5

         self.progress_padding = 5

         self.progress_width = self.win_width - self.progress_padding

-        self.progress_bar = ProgressBar(self.win_starty + 6, self.win_startx + self.progress_padding / 2, self.progress_width)

+        self.progress_bar = ProgressBar(self.win_starty + 6, self.win_startx + self.progress_padding / 2, self.progress_width, new_win=True)

-        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Setup your disk', True)

+        self.disk_buttom_items = []

+        self.disk_buttom_items.append(('<Custom>', self.custom_function, False))

+        self.disk_buttom_items.append(('<Auto>', self.auto_function, False))

+

+        self.window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Select a disk', True, items = self.disk_buttom_items, menu_helper = self.save_index, position = 2, tab_enabled=False)

+        self.partition_window = Window(self.win_height, self.win_width, self.maxy, self.maxx, 'Partition', True)

         self.devices = Device.refresh_devices()

-    def guided_partitions(self, device_index):

+    def guided_partitions(self, params):

+        if not 'diskindex' in self.install_config:

+            return ActionResult(False, None);

+

+        device_index = self.install_config['diskindex']

+

         menu_height = 9

         menu_width = 40

         menu_starty = (self.maxy - menu_height) / 2 + 5

+        self.install_config['delete_partition'] = True

         confrim_window = ConfirmWindow(menu_height, menu_width, self.maxy, self.maxx, menu_starty, 'This will erase the disk.\nAre you sure?')

         confirmed = confrim_window.do_action().result['yes']

-        if not confirmed:

-            return ActionResult(confirmed, None)

+        if confirmed == False:

+            self.install_config['skipPrevs'] = True

+            return ActionResult(False, {'goBack':True})

+        self.install_config['skipPrevs'] = False

         self.progress_bar.initialize('Partitioning...')

         self.progress_bar.show()

         self.progress_bar.show_loading('Partitioning')

         # Do the partitioning

-        self.window.clearerror()

-        partitions_data = modules.commons.partition_disk(self.devices[device_index].path, modules.commons.default_partitions)

+        if 'partitionsnumber' in self.install_config:

+                if (int(self.install_config['partitionsnumber']) == 0):

+                    partitions_data = modules.commons.partition_disk(self.devices[device_index].path, modules.commons.default_partitions)

+                else:

+                    partitions = []

+                    for i in range (int (self.install_config['partitionsnumber'])):

+                        if len(self.install_config[str(i)+'partition_info'+str(0)])==0:

+                            sizedata=0

+                        else:

+                            sizedata = int(self.install_config[str(i)+'partition_info'+str(0)])

+                        mtdata = self.install_config[str(i)+'partition_info'+str(2)]

+                        typedata = self.install_config[str(i)+'partition_info'+str(1)]

+

+                        partitions = partitions + [

+                                    {"mountpoint": mtdata, "size": sizedata, "filesystem": typedata},

+                                    ]

+                    partitions_data = modules.commons.partition_disk(self.devices[device_index].path, partitions)

+        else: 

+            partitions_data = modules.commons.partition_disk(self.devices[device_index].path, modules.commons.default_partitions)

+

         if partitions_data == None:

-            self.window.adderror('Partitioning failed, you may try again')

+            self.partition_window.adderror('Partitioning failed, you may try again')

         else:

             self.install_config['disk'] = partitions_data

@@ -60,7 +91,9 @@ class SelectDisk(object):

         return ActionResult(partitions_data != None, None)

     def display(self, params):

-        self.window.addstr(0, 0, 'First, we will setup your disks.\n\nWe have detected {0} disks, choose disk to be auto-partitioned:'.format(len(self.devices)))

+        if 'skipPrevs' in self.install_config:

+            self.install_config['skipPrevs'] = False

+        self.window.addstr(0, 0, 'Please select a disk and a method how to partition it:\nAuto - single partition for /, no swap partition.\nCustom - for customized partitioning')

         self.disk_menu_items = []

@@ -70,15 +103,27 @@ class SelectDisk(object):

                 self.disk_menu_items.append(

                         (

                             '{2} - {1} @ {0}'.format(device.path, device.size, device.model), 

-                            self.guided_partitions, 

+                            self.save_index, 

                             index

                         )

                     )

-        self.disk_menu = Menu(self.menu_starty,  self.maxx, self.disk_menu_items, self.menu_height)

+        self.disk_menu = Menu(self.menu_starty,  self.maxx, self.disk_menu_items, self.menu_height, tab_enable=False)

+        self.disk_menu.can_save_sel(True)