def __init__(self, paths, parent_module_name, interrupt_if_fail,
is_logging, log_file_path, stage_name,
only_fail_notification):
"""
Parameters
----------
paths : list
paths to directories with CSV systems
parent_module_name: str
a parent module name
interrupt_if_fail : bool
interrupt the execution of the all stages if an error has occurred
is_logging : bool
write messages to the log file or not
log_file_path : str
a path to directory for the log file
stage_name : str
stage name
only_fail_notification : bool
notification condition
"""
Stage.__init__(self, parent_module_name, interrupt_if_fail,
log_file_path, stage_name, is_logging, "", "", "",
only_fail_notification)
self._vcs_paths = paths.copy()
for path in self._vcs_paths:
if not os.path.exists(path):
raise FileNotFoundError("VCS: Directory " + path +
" doesn't exists!")
self._commit_msg = 'new '
def __init__(self):
"""
"""
Stage.__init__(self, moduleDescription)
# Info: NTFS partitions, current partition, total drive size
self.info = self.addWidget(PartitionWidget())
# NTFS resizing
self.ntfs = self.addWidget(NtfsWidget(self.size_changed_cb))
# Info: space after last NTFS partition
self.rest = self.addWidget(ShowInfoWidget(
_("(Potential) free space at end of drive: ")))
# Get a list of NTFS partitions (all disks) and then the
# corresponding info about the disks and partitions
self.partlist = self.getNTFSparts()
# Each disk (with NTFS partitions) gets an entry in self.diskinfo.
# Each entry is a list-pair: [disk info, list of partitions' info]
# The second item, the partition-info list can be changed if a
# partition is shrunk or removed.
self.diskinfo = {}
for p in self.partlist:
d = p.rstrip("0123456789")
if not self.diskinfo.has_key(d):
self.diskinfo[d] = [install.getDeviceInfo(d), None]
self.diskChanged(d)
# List of already 'handled' partitions
self.donelist = []
self.reinit()
def __init__(self, parent, score_to_add = None):
Stage.__init__(self, parent)
self.score_to_add = score_to_add
self.high_scores = load_high_scores()
self.new_idx = None
if self.score_to_add != None:
s = Score("???", self.score_to_add)
self.new_idx = self.high_scores.potential_position(s)
if self.new_idx != None:
self.high_scores.add(s)
score_frame = Frame(self)
score_frame.pack()
for i in range(self.high_scores.max_size):
score = self.high_scores.get(i)
if score != None:
score = self.high_scores.scores[i]
name = score.name
points = str(score.points)
else:
name = "---"
points = "---"
if i == self.new_idx:
self.new_entry = Entry(score_frame)
self.new_entry.grid(row=i, column=0)
else:
Label(score_frame, text=name).grid(row=i,column=0)
Label(score_frame, text=points).grid(row=i,column=1)
b = Button(self, text="return to main", command=self.button_clicked)
b.pack()
def __init__(self):
Stage.__init__(self, moduleDescription)
# Set up grub's device map and a list of existing menu.lst files.
assert install.set_devicemap(), "Couldn't get device map for GRUB"
self.addOption('mbr', _("Install GRUB to MBR - make it the main"
" bootloader"), True, callback=self.mbrtoggled)
self.mbrinstall = Mbrinstall(self)
self.addWidget(self.mbrinstall, False)
# What if there is >1 drive?
if install.menulst:
self.addOption('old', _("Add new installation to existing GRUB"
" menu."), callback=self.oldtoggled)
self.oldgrub = Oldgrub(self)
self.addWidget(self.oldgrub, False)
self.addOption('part', _("Install GRUB to installation partition."))
self.ntfsboot = None
# Seek likely candidate for Windows boot partition
dinfo = install.fdiskall()
nlist = install.listNTFSpartitions()
for np in nlist:
# First look for (first) partition marked with boot flag
if re.search(r"^%s +\*" % np, dinfo, re.M):
self.ntfsboot = np
break
if (not self.ntfsboot) and nlist:
# Else just guess first NTFS partition
self.ntfsboot = nlist[0]
self.request_soon(self.init)
def __init__(self):
Stage.__init__(self, moduleDescription)
self.addLabel(_("Please check that the formatting of the"
" following partitions and their use within the new"
" installation (mount-points) corresponds with what you"
" had in mind. Accidents could well result in serious"
" data loss."))
# List of partitions configured for use.
# Each entry has the form [mount-point, device, format,
# format-flags, mount-flags]
parts = install.get_config("partitions", False)
plist = []
if parts:
for p in parts.splitlines():
pl = p.split(':')
plist.append(pl + [self.getsize(pl[1])])
# In case of mounts within mounts
plist.sort()
# Swaps ([device, format, include])
swaps = install.get_config("swaps", False)
if swaps:
for s in swaps.splitlines():
p, f, i = s.split(':')
if i:
plist.append(["swap", p, f, "", "", self.getsize(p)])
self.addWidget(PartTable(plist))
def __init__(self):
Stage.__init__(self, moduleDescription)
self.output = self.addWidget(Report())
self.progress = self.addWidget(Progress(), False)
self.request_soon(self.run)
def __init__(self):
Stage.__init__(self, moduleDescription)
self.addLabel(_('Disk(-like) devices will be detected and offered'
' for automatic partitioning.\n\n'
'If a device has mounted partitions it will not be offered'
' for automatic partitioning. If you want to partition'
' such a device, you must select the "Manual Partitioning"'
' stage.'))
self.getDevices()
def __init__(self, loggers):
"""
Parameters
----------
loggers: list
list of loggers to send
"""
Stage.__init__(self, "", False, "", "Notification", False, "", "", "",
False)
self._loggers = loggers
def __init__(self, parent, *args, **kargs):
Stage.__init__(self, parent, *args, **kargs)
Label(self, text="FALLING BLOCK GAME", font=("Helvetica", 30)).pack()
self.selections = SelectionGroup(self, "Start", "High Scores", "Exit")
self.selections.pack()
self.bind_parent("<Up>" , lambda event: self.selections.previous_selection())
self.bind_parent("<Down>", lambda event: self.selections.next_selection())
self.bind_parent("<Return>", self.selection_chosen)
def __init__(self):
Stage.__init__(self, moduleDescription)
self.addLabel(_('This will install Arch Linux'
' from this "live" system on your computer.'
' This program was written'
' for the <i>larch</i> project:\n'
' http://larch.berlios.de\n'
'\nIt is free software,'
' released under the GNU General Public License.\n\n') +
'Copyright (c) 2008 Michael Towers')
def __init__(self):
Stage.__init__(self, moduleDescription)
# Info on drive
self.device = install.get_config('autodevice', trap=False)
if not self.device:
self.device = install.listDevices()[0][0]
self.dinfo = install.getDeviceInfo(self.device)
# Info: total drive size
totalsize = self.addWidget(ShowInfoWidget(
_("Total capacity of drive %s: ") % self.device))
totalsize.set(self.dinfo[0])
# Get partition info (consider only space after NTFS partitions)
parts = install.getParts(self.device)
self.startpart = 1
self.startsector = 0
for p in parts:
if (p[1] == 'ntfs'):
self.startpart = p[0] + 1
self.startsector = p[4] + 1
avsec = (self.dinfo[1] * self.dinfo[2] - self.startsector)
self.avG = avsec * self.dinfo[3] / 1.0e9
if (self.startpart > 1):
popupMessage(_("One or more NTFS (Windows) partitions were"
" found. These will be retained. The available space"
" is thus reduced to %3.1f GB.\n"
"Allocation will begin at partition %d.") %
(self.avG, self.startpart))
self.homesizeG = 0.0
self.swapsizeG = 0.0
self.root = None # To suppress writing before widget is created
self.swapfc = None # To suppress errors due to widget not yet ready
# swap size
self.swapWidget()
self.swapfc = self.addCheckButton(_("Check for bad blocks "
"when formatting swap partition.\nClear this when running "
"in VirtualBox (it takes forever)."))
self.setCheck(self.swapfc, True)
# home size
self.homeWidget()
# root size
self.root = self.addWidget(ShowInfoWidget(
_("Space for Linux system: ")))
self.adjustroot()
def __init__(self):
Stage.__init__(self, moduleDescription)
ld = install.listDevices()
# Offer gparted - if available
if (install.gparted_available() == ""):
gparted = self.addOption('gparted',
_("Use gparted (recommended)"), True)
else:
gparted = None
# Offer cfdisk on each available disk device
mounts = install.getmounts().splitlines()
mounteds = 0
i = 0
if ld:
for d, s, n in ld:
i += 1
# Determine devices which have mounted partitions
dstring = "%16s (%10s : %s)" % (d, s, n)
style = None
for m in mounts:
if m.startswith(d):
style = 'red'
mounteds += 1
break
self.addOption('cfdisk-%s' % d,
_("Use cfdisk on %s (%s)") % (d, s),
(i == 1) and not gparted,
style=style)
else:
popupError(_("No disk(-like) devices were found,"
" so Arch Linux can not be installed on this machine"))
mainWindow.exit()
if mounteds:
self.addLabel(_('WARNING: Editing partitions on a device with'
' mounted partitions (those marked in red) is likely'
' to cause a lot of trouble!\n'
'If possible, unmount them and then restart this'
' program.'), style='red')
# Offer 'use existing partitions/finished'
self.done = self.addOption('done',
_("Use existing partitions / finished editing partitions"))
def __init__(self, auto_commit_and_push, parent_module_name, is_logging,
log_file_path, vcs_obj):
"""
Parameters
----------
parent_module_name: str
a parent module name
auto_commit_and_push : bool
auto commit and push after Test stage
is_logging : bool
write messages to the log file or not
log_file_path : str
a path to directory for the log file
vcs_obj : VCS
VCS object
"""
Stage.__init__(self, parent_module_name, False, log_file_path,
'Commit', is_logging, "", "", "", False)
self._vcs_obj = vcs_obj
self._auto_commit_and_push = auto_commit_and_push
def __init__(self, path, parent_module_name, interrupt_if_fail, is_logging,
log_file_path, stage_name, targets, pre_script_path,
main_script_path, post_script_path, only_fail_notification):
"""
Parameters
----------
path : str
a path to directory with build file(Makefile and etc)
parent_module_name: str
a parent module name
interrupt_if_fail : bool
interrupt the execution of the all stages if an error has occurred
is_logging : bool
write messages to the log file or not
log_file_path : str
a path to directory for the log file
stage_name : str
stage name
targets : list
list of targets to build
pre_script_path : str
script for pre_exec()
main_script_path : str
script for exec()
post_script_path : str
script for post_exec()
only_fail_notification : bool
notification condition
"""
Stage.__init__(self, parent_module_name, interrupt_if_fail,
log_file_path, stage_name, is_logging, pre_script_path,
main_script_path, post_script_path,
only_fail_notification)
self._build_path = path
if self._build_path[-1] != os.sep:
self._build_path += os.sep
self._build_targets = targets.copy()
if not os.path.exists(self._build_path):
raise FileNotFoundError("Build: Directory " + self._build_path +
" doesn't exists!")
def __init__(self):
"""
"""
Stage.__init__(self, moduleDescription)
self.swaps = {}
inuse = install.getActiveSwaps()
self.done = []
if inuse:
self.addLabel(_("The following swap partitions are currently"
" in use and will not be formatted (they shouldn't"
" need it!)."))
for p, s in inuse:
b = self.addCheckButton("%12s - %s %4.1f GB" % (p, _("size"), s))
self.setCheck(b, True)
self.done.append(p)
self.swaps[p] = b
all = install.getAllSwaps()
fmt = []
for p, s in all:
if not (p in self.done):
fmt.append((p, s))
if fmt:
self.addLabel(_("The following swap partitions will be formatted"
" if you select them for inclusion."))
for p, s in fmt:
b = self.addCheckButton("%12s - %s %4.1f GB" % (p, _("size"), s))
self.setCheck(b, True)
self.swaps[p] = b
if all:
self.cformat = self.addCheckButton(_("Check for bad blocks "
"when formatting.\nClear this when running in VirtualBox "
"(it takes forever)."))
self.setCheck(self.cformat, True)
else:
self.addLabel(_("There are no swap partitions available. If the"
" installation computer does not have a large amount of"
" memory, you are strongly advised to create one before"
" continuing."))
def __init__(self):
Stage.__init__(self, moduleDescription)
self.device = None
self.mounts = install.getmounts()
# List of partitions already configured for use.
# Each entry has the form [mount-point, device, format,
# format-flags, mount-flags]
global used_partitions
used_partitions = []
parts = install.get_config("partitions", False)
if parts:
for p in parts.splitlines():
used_partitions.append(p.split(':'))
self.table = SelTable()
self.devselect = SelDevice([d[0] for d in install.listDevices()],
self.setDevice)
self.addWidget(self.devselect, False)
self.addWidget(self.table)
def __init__(self, script_path, parent_module_name, interrupt_if_fail,
is_logging, log_file_path, only_fail_notification):
"""
Parameters
----------
script_path : str
an absolute path to tests
parent_module_name: str
a parent module name
interrupt_if_fail : bool
interrupt the execution of the all stages if an error has occurred
is_logging : bool
write messages to the log file or not
log_file_path : str
an absolute path to directory for the log file
only_fail_notification : bool
notification condition
"""
Stage.__init__(self, parent_module_name, interrupt_if_fail,
log_file_path, 'Test', is_logging, "", script_path, "",
only_fail_notification)
def __init__(self, parent, state):
Stage.__init__(self, parent)
self.state = state
self.state = state
self.fps_counter = FpsCounter()
self.init_widgets()
self.init_bindings()
self.ghost_piece = None
#True when the user pauses the game
self.paused = False
#True when a coroutine is playing that should halt game logic, ex. when lines flash before disappearing
self.blocking = False
self.state.register_listener(self.model_alert)
self.state.start()
self.update_labels()
def __init__(self):
Stage.__init__(self, moduleDescription)
self.addLabel(
_("If all went well, your installation should now" " be bootable. Click on OK to quit the installer.")
)
def __init__(self):
Stage.__init__(self, moduleDescription)
self.pwe = self.addWidget(PWEnter())
self.reinit()
