def CreateDetailedView(self, details):
# Controls have not been constructed yet
if TextIsEmpty(self.details):
self.btn_details = wx.ToggleButton(self, label=GT(u'Details'))
#btn_copy = wx.Button(self, label=GT(u'Copy details'))
self.dsp_details = TextAreaPanel(self,
value=details,
style=wx.TE_READONLY)
# *** Event handlers *** #
self.btn_details.Bind(wx.EVT_TOGGLEBUTTON, self.ToggleDetails)
#btn_copy.Bind(wx.EVT_BUTTON, self.OnCopyDetails)
layout = self.GetSizer()
layout.Add(self.btn_details, (2, 1))
#layout.Add(btn_copy, (2, 2), flag=wx.ALIGN_LEFT|wx.RIGHT, border=5)
layout.Add(self.dsp_details, (3, 1), (1, 2), wx.EXPAND | wx.RIGHT,
5)
self.ToggleDetails()
if not TextIsEmpty(details):
for C in self.GetChildren():
if isinstance(C, TextAreaPanel):
self.details = details
C.SetValue(self.details)
return True
return False
def GetLauncherInfo(self):
desktop_list = [u'[Desktop Entry]']
name = GetField(self, inputid.NAME).GetValue()
if not TextIsEmpty(name):
desktop_list.append(u'Name={}'.format(name))
desktop_list.append(u'Version=1.0')
executable = GetField(self, inputid.EXEC).GetValue()
if not TextIsEmpty(executable):
desktop_list.append(u'Exec={}'.format(executable))
comment = GetField(self, inputid.DESCR).GetValue()
if not TextIsEmpty(comment):
desktop_list.append(u'Comment={}'.format(comment))
icon = GetField(self, inputid.ICON).GetValue()
if not TextIsEmpty(icon):
desktop_list.append(u'Icon={}'.format(icon))
launcher_type = GetField(self, inputid.TYPE).GetValue()
if not TextIsEmpty(launcher_type):
desktop_list.append(u'Type={}'.format(launcher_type))
desktop_list.append(u'Terminal={}'.format(
GS(GetField(self, chkid.TERM).GetValue()).lower()))
desktop_list.append(u'StartupNotify={}'.format(
GS(GetField(self, chkid.NOTIFY).GetValue()).lower()))
encoding = GetField(self, inputid.ENC).GetValue()
if not TextIsEmpty(encoding):
desktop_list.append(u'Encoding={}'.format(encoding))
lst_categories = GetField(self, listid.CAT)
categories = []
cat_total = lst_categories.GetItemCount()
count = 0
while count < cat_total:
C = lst_categories.GetItemText(count)
if not TextIsEmpty(C):
categories.append(lst_categories.GetItemText(count))
count += 1
# Add a final semi-colon if categories is not empty
if categories:
categories = u';'.join(categories)
if categories[-1] != u';':
categories = u'{};'.format(categories)
desktop_list.append(u'Categories={}'.format(categories))
other = GetField(self, inputid.OTHER).GetValue()
if not TextIsEmpty(other):
desktop_list.append(other)
return u'\n'.join(desktop_list)
def ExportDeprecated(self, outDir, outName=wx.EmptyString):
if not os.path.isdir(outDir):
Logger.Debug(__name__, u'Directory does not exist: {}'.format(outDir))
return ERR_DIR_NOT_AVAILABLE
if outName == wx.EmptyString:
outName = page_ids[self.GetId()].upper()
page_info = self.Get()
if not page_info:
return 0
if not outName:
outName = self.Name
if TextIsEmpty(page_info):
return 0
absolute_filename = u'{}/{}'.format(outDir, outName)
Logger.Debug(outName, u'Exporting: {}'.format(absolute_filename))
WriteFile(absolute_filename, page_info)
return 0
def GetDestValue(self, event=None): if not TextIsEmpty(self.ti_target.GetValue()): if self.ti_target.GetValue()[0] == u'/': self.prev_dest_value = self.ti_target.GetValue() if event: event.Skip()
def OnAddCustom(self, event=None):
custom_label = GS(
self.input_add_custom.GetValue()).strip(u' ').replace(u' ', u'_')
if not TextIsEmpty(custom_label) and not self.check_list.LabelExists(
custom_label):
self.check_list.AddItem(custom_label, True)
self.check_list.ScrollToEnd()
def FormatChangelog(text,
name=APP_name,
version=VERSION_string,
dist=OS_codename,
urgency=u'low',
packager=AUTHOR_name,
email=AUTHOR_email,
preserve_indent=False):
if TextIsEmpty(text):
return None
# Remove leading & trailing whitespace & empty lines & split into
# list of lines.
lines = text.strip(u' \t\n\r').split(u'\n')
if not lines:
return None
lines = RemoveEmptyLines(lines)
lines = _format_lines(lines, preserve_indent)
text = u'\n'.join(lines)
header = u'{} ({}) {}; urgency={}\n'.format(name, version, dist, urgency)
footer = u'\n -- {} <{}> {}'.format(packager, email, _get_cl_timestamp())
return u'\n'.join((header, text, footer))
def set_value(option):
key = option.GetName()
value = None
if key in menu_definitions:
value = menu_definitions[key]
if not TextIsEmpty(value):
if option in self.opts_input:
option.SetValue(value)
return True
elif option in self.opts_choice:
if option.SetStringSelection(value):
return True
elif option in self.opts_list:
lst_categories = GetField(self, listid.CAT)
if key == lst_categories.GetName():
value = value.split(u';')
if value:
for X, val in enumerate(value):
lst_categories.InsertStringItem(X, val)
return True
return False
def _title_is_ok(self, title):
if TextIsEmpty(title):
return False
return not Contains(title, (
u' ',
u'\t',
))
def Get(self):
scripts = {}
for DS, RB in self.script_objects:
if not TextIsEmpty(DS.GetValue()):
scripts[DS.GetFilename()] = DS.GetValue()
return scripts
def __init__(self,
parent,
title=GT(u'Message'),
icon=ICON_INFORMATION,
text=wx.EmptyString,
details=wx.EmptyString,
style=wx.DEFAULT_DIALOG_STYLE,
buttons=(wx.ID_OK, ),
linewrap=0):
BaseDialog.__init__(self, parent, wx.ID_ANY, title, style=style)
# Allow using strings for 'icon' argument
if isinstance(icon, (unicode, str)):
icon = wx.Bitmap(icon)
icon = wx.StaticBitmap(self, wx.ID_ANY, icon)
txt_message = wx.StaticText(self, label=text)
if linewrap:
txt_message.Wrap(linewrap)
# self.details needs to be empty for constructor
self.details = wx.EmptyString
details = details
# *** Layout *** #
self.lyt_urls = BoxSizer(wx.VERTICAL)
# Only set if buttons are added to dialog
self.lyt_buttons = None
lyt_main = wx.GridBagSizer(5, 5)
lyt_main.SetCols(3)
lyt_main.AddGrowableRow(3)
lyt_main.AddGrowableCol(2)
lyt_main.Add(icon, (0, 0), (5, 1),
wx.ALIGN_TOP | lyt.PAD_LR | wx.BOTTOM, 20)
lyt_main.Add(txt_message, (0, 1), (1, 2), lyt.PAD_RT, 20)
lyt_main.Add(self.lyt_urls, (1, 1), (1, 2), wx.RIGHT, 5)
self.SetAutoLayout(True)
self.SetSizer(lyt_main)
self.AddButtons(buttons)
if not TextIsEmpty(details):
# self.details will be set here
self.CreateDetailedView(details)
else:
self.Layout()
self.Fit()
self.SetMinSize(self.GetSize())
self.CenterOnParent()
def DestroyLicenseText(self):
if not TextIsEmpty(self.dsp_copyright.GetValue()):
warn_msg = GT(u'This will destroy all license text.')
warn_msg = u'{}\n\n{}'.format(warn_msg, GT(u'Continue?'))
if ConfirmationDialog(GetMainWindow(), text=warn_msg).ShowModal() not in (wx.ID_OK, wx.OK):
return False
return True
def GetOutputFilename(self):
if not GetField(self, chkid.FNAME).GetValue():
filename = GetField(self,
inputid.FNAME).GetValue().strip(u' ').replace(
u' ', u'_')
if not TextIsEmpty(filename):
return filename
return GetField(self, inputid.NAME).GetValue().strip(u' ').replace(
u' ', u'_')
def Get(self, getModule=False):
page = self.dsp_copyright.GetValue()
if TextIsEmpty(page):
page = None
if getModule:
page = (__name__, page,)
return page
def CheckDest(self, event=None): if TextIsEmpty(self.ti_target.GetValue()): self.ti_target.SetValue(self.prev_dest_value) self.ti_target.SetInsertionPoint(-1) elif self.ti_target.GetValue()[0] != u'/': self.ti_target.SetValue(self.prev_dest_value) self.ti_target.SetInsertionPoint(-1) if event: event.Skip()
def ImportFromFile(self, filename):
Logger.Debug(__name__, GT(u'Importing page info from {}').format(filename))
if not os.path.isfile(filename):
return dbrerrno.ENOENT
files_data = ReadFile(filename, split=True)
# Lines beginning with these characters will be ignored
ignore_characters = (
u'',
u' ',
u'#',
)
target = None
targets_list = []
for L in files_data:
if not TextIsEmpty(L) and L[0] not in ignore_characters:
if u'[' in L and u']' in L:
target = L.split(u'[')[-1].split(u']')[0]
continue
if target:
executable = (len(L) > 1 and L[-2:] == u' *')
if executable:
L = L[:-2]
targets_list.append((target, L, executable))
missing_files = []
for T in targets_list:
# FIXME: Create method in FileList class to retrieve all missing files
if not os.path.exists(T[1]):
missing_files.append(T[1])
source_file = os.path.basename(T[1])
source_dir = os.path.dirname(T[1])
self.lst_files.AddFile(source_file, source_dir, T[0], executable=T[2])
if len(missing_files):
main_window = GetMainWindow()
err_line1 = GT(u'The following files/folders are missing from the filesystem.')
err_line2 = GT(u'They will be highlighted on the Files page.')
DetailedMessageDialog(main_window, title=GT(u'Warning'), icon=ICON_ERROR,
text=u'\n'.join((err_line1, err_line2)),
details=u'\n'.join(missing_files)).ShowModal()
return 0
def AddInfo(self, event=None):
new_changes = self.ti_changes.GetValue()
if TextIsEmpty(new_changes):
DetailedMessageDialog(
GetMainWindow(), GT(u'Warning'), ICON_WARNING,
GT(u'"Changes" section is empty')).ShowModal()
self.ti_changes.SetInsertionPointEnd()
self.ti_changes.SetFocus()
return
package = self.ti_package.GetValue()
version = self.ti_version.GetValue()
dist = self.ti_dist.GetValue()
urgency = self.sel_urgency.GetStringSelection()
maintainer = self.ti_maintainer.GetValue()
email = self.ti_email.GetValue()
new_changes = FormatChangelog(new_changes, package, version, dist,
urgency, maintainer, email,
self.chk_indentation.GetValue())
# Clean up leading & trailing whitespace in old changes
old_changes = self.dsp_changes.GetValue().strip(u' \t\n\r')
# Only append newlines if log isn't already empty
if not TextIsEmpty(old_changes):
new_changes = u'{}\n\n\n{}'.format(new_changes, old_changes)
# Add empty line to end of log
if not new_changes.endswith(u'\n'):
new_changes = u'{}\n'.format(new_changes)
self.dsp_changes.SetValue(new_changes)
# Clear "Changes" text
self.ti_changes.Clear()
self.ti_changes.SetFocus()
def SetTabName(self, index=-1, rename=False, checkBox=None, checked=False):
getname = TextEntryDialog(GetMainWindow(), GT(u'Name for new page'))
new_name = None
if not rename and checkBox:
check_box = CheckBox(getname, label=checkBox)
check_box.SetValue(checked)
sizer = getname.GetSizer()
insert_point = len(sizer.GetChildren()) - 1
sizer.InsertSpacer(insert_point, 5)
sizer.Insert(insert_point + 1, check_box, 0, wx.LEFT, 16)
getname.SetSize(sizer.GetMinSize())
getname.Fit()
getname.CenterOnParent()
valid_name = False
while not valid_name:
if new_name and TextIsEmpty(new_name):
getname.Clear()
# User cancelled
if not ShowDialog(getname):
return False
else:
new_name = getname.GetValue()
valid_name = self._title_is_ok(new_name)
if valid_name:
break
ShowErrorDialog(GT(u'Page name cannot contain whitespace'),
warn=True)
if rename:
if index < 0:
return False
return self.Tabs.SetPageText(index, new_name)
if checkBox:
return self.AddPage(new_name, checkBox=check_box)
return self.AddPage(new_name)
def Set(self, items):
# Text control is cleared when options are changed
cached_value = self.GetValue()
if not isinstance(items, (tuple, list, dict)):
items = (items, )
if wx.MAJOR_VERSION > 2:
OwnerDrawnComboBox.Set(self, items)
else:
self.Clear()
for I in items:
self.Append(I)
if not TextIsEmpty(cached_value):
self.SetValue(cached_value)
def OnKeyUp(self, event=None):
insertion_point = self.GetInsertionPoint()
text = self.GetValue()
original_text = text
# Remove whitespace
for C in (u' ', u'\t'):
if C in text:
text = text.replace(C, u'-')
if not TextIsEmpty(text):
for C in invalid_chars:
if C in text:
text = text.replace(C, u'-')
if text != original_text:
self.SetValue(text)
self.SetInsertionPoint(insertion_point)
def Get(self, getModule=False):
target = self.pnl_target.GetPath()
if target == self.pnl_target.GetDefaultPath():
target = u'DEFAULT'
body = self.dsp_changes.GetValue()
if TextIsEmpty(body):
page = None
else:
page = u'[TARGET={}]\n\n[BODY]\n{}'.format(target, body)
if getModule:
page = (
__name__,
page,
)
return page
def ImportFromFile(self, filename):
Logger.Debug(__name__, GT(u'Importing script: {}').format(filename))
script_name = filename.split(u'-')[-1]
script_object = None
for DS, RB in self.script_objects:
if script_name == DS.GetFilename():
script_object = DS
break
# Loading the actual text
# FIXME: Should be done in class method
if script_object != None:
script_data = ReadFile(filename, split=True, convert=list)
# FIXME: this should be global variable
shebang = u'/bin/bash'
remove_indexes = 0
if u'#!' == script_data[0][:2]:
shebang = script_data[0][2:]
script_data.remove(script_data[0])
# Remove empty lines from beginning of script
for L in script_data:
if not TextIsEmpty(L):
break
remove_indexes += 1
for I in reversed(range(remove_indexes)):
script_data.remove(script_data[I])
script_data = u'\n'.join(script_data)
script_object.SetShell(shebang, True)
script_object.SetValue(script_data)
def ImportFromFile(self, filename):
if not os.path.isfile(filename):
return dbrerrno.ENOENT
copyright_data = ReadFile(filename, split=True)
# Remove preceding empty lines
remove_index = 0
for I in copyright_data:
if not TextIsEmpty(I):
break
remove_index += 1
for I in reversed(range(remove_index)):
copyright_data.remove(copyright_data[I])
copyright_data = u'\n'.join(copyright_data)
self.dsp_copyright.SetValue(copyright_data)
return 0
def OnImportFromControl(self, event=None):
fields = (
(self.ti_package, inputid.PACKAGE),
(self.ti_version, inputid.VERSION),
(self.ti_maintainer, inputid.MAINTAINER),
(self.ti_email, inputid.EMAIL),
)
for F, FID in fields:
field_value = GetFieldValue(pgid.CONTROL, FID)
if isinstance(field_value, ErrorTuple):
err_msg1 = GT(
u'Got error when attempting to retrieve field value')
err_msg2 = u'\tError code: {}\n\tError message: {}'.format(
field_value.GetCode(), field_value.GetString())
Logger.Error(__name__, u'{}:\n{}'.format(err_msg1, err_msg2))
continue
if not TextIsEmpty(field_value):
F.SetValue(field_value)
def WriteConfig(k_name, k_value, conf=default_config, sectLabel=None):
conf_dir = os.path.dirname(conf)
if not os.path.isdir(conf_dir):
if os.path.exists(conf_dir):
print(u'{}: {}: {}'.format(
GT(u'Error'),
GT(u'Cannot create config directory, file exists'), conf_dir))
return ConfCode.ERR_WRITE
os.makedirs(conf_dir)
# Only write pre-defined keys
if k_name not in default_config_values:
print(u'{}: {}: {}'.format(GT(u'Error'),
GT(u'Configuration key not found'), k_name))
return ConfCode.KEY_NOT_DEFINED
# Make sure we are writing the correct type
k_value = default_config_values[k_name][0](k_value)
if k_value == None:
print(u'{}: {}: {}'.format(
GT(u'Error'), GT(u'Wrong value type for configuration key'),
k_name))
return ConfCode.WRONG_TYPE
# tuple is the only type we need to format
if isinstance(k_value, tuple):
k_value = u'{},{}'.format(GS(k_value[0]), GS(k_value[1]))
else:
k_value = GS(k_value)
conf_text = wx.EmptyString
# Save current config to buffer
if os.path.exists(conf):
if not os.path.isfile(conf):
print(u'{}: {}: {}'.format(
GT(u'Error'),
GT(u'Cannot open config for writing, directory exists'), conf))
return ConfCode.ERR_WRITE
conf_text = ReadFile(conf)
# FIXME: ReadFile returns None type if config file exists but is empty
if conf_text == None:
conf_text = u''
else:
conf_text = u'[CONFIG-{}.{}]'.format(GS(config_version[0]),
GS(config_version[1]))
conf_lines = conf_text.split(u'\n')
key_exists = False
for L in conf_lines:
l_index = conf_lines.index(L)
if u'=' in L:
key = L.split(u'=')[0]
if k_name == key:
key_exists = True
conf_lines[l_index] = u'{}={}'.format(k_name, k_value)
if not key_exists:
conf_lines.append(u'{}={}'.format(k_name, k_value))
conf_text = u'\n'.join(conf_lines)
if TextIsEmpty(conf_text):
print(u'{}: {}'.format(GT(u'Warning'),
GT(u'Not writing empty text to configuration')))
return ConfCode.ERR_WRITE
# Actual writing to configuration
WriteFile(conf, conf_text)
if os.path.isfile(conf):
return ConfCode.SUCCESS
return ConfCode.ERR_WRITE
def IsOkay(self):
return not TextIsEmpty(self.dsp_changes.GetValue())
def ImportFromFile(self, filename):
if not os.path.isfile(filename):
return dbrerrno.ENOENT
clog_data = ReadFile(filename, split=True)
sections = {}
def parse_section(key, lines):
value = u'\n'.join(lines).split(u'\n[')[0]
if u'=' in key:
key = key.split(u'=')
value = (key[-1], value)
key = key[0]
sections[key] = value
# NOTE: This would need to be changed were more sections added to project file
for L in clog_data:
line_index = clog_data.index(L)
if not TextIsEmpty(L) and u'[' in L and u']' in L:
L = L.split(u'[')[-1].split(u']')[0]
parse_section(L, clog_data[line_index + 1:])
for S in sections:
Logger.Debug(
__name__,
GT(u'Changelog section: "{}", Value:\n{}').format(
S, sections[S]))
if isinstance(sections[S], (tuple, list)):
value_index = 0
for I in sections[S]:
Logger.Debug(__name__,
GT(u'Value {}: {}').format(value_index, I))
value_index += 1
if S == u'TARGET':
Logger.Debug(__name__, u'SECTION TARGET FOUND')
if sections[S][0] == u'DEFAULT':
Logger.Debug(__name__, u'Using default target')
if not self.pnl_target.UsingDefault():
self.pnl_target.Reset()
else:
Logger.Debug(
__name__,
GT(u'Using custom target: {}').format(sections[S][0]))
self.pnl_target.SetPath(sections[S][0])
continue
if S == u'BODY':
Logger.Debug(__name__, u'SECTION BODY FOUND')
self.dsp_changes.SetValue(sections[S])
continue
return 0
def IsOkay(self):
return not TextIsEmpty(self.dsp_copyright.GetValue())
def IsOkay(self): return not TextIsEmpty(self.ScriptBody.GetValue())
def OnGenerate(self, event=None):
main_window = GetMainWindow()
# Get the amount of links to be created
total = self.Executables.GetCount()
if total > 0:
non_empty_scripts = []
for DS in self.script_objects[1][0], self.script_objects[2][0]:
if not TextIsEmpty(DS.GetValue()):
non_empty_scripts.append(DS.GetName())
# Warn about overwriting previous post-install & pre-remove scripts
if non_empty_scripts:
warn_msg = GT(u'The following scripts will be overwritten if you continue: {}')
warn_msg = u'{}\n\n{}'.format(warn_msg.format(u', '.join(non_empty_scripts)), GT(u'Continue?'))
overwrite = ConfirmationDialog(main_window, text=warn_msg)
if not overwrite.Confirmed():
return
overwrite.Destroy()
del warn_msg, overwrite
# Get destination for link from Auto-Link input textctrl
link_path = self.ti_autolink.GetValue()
# Warn about linking in a directory that does not exist on the current filesystem
if not os.path.isdir(link_path):
warn_msg = GT(u'Path "{}" does not exist.')
warn_msg = u'{}\n\n{}'.format(warn_msg, GT(u'Continue?'))
overwrite = ConfirmationDialog(main_window, text=warn_msg.format(link_path))
if not overwrite.Confirmed():
return
overwrite.Destroy()
del warn_msg, overwrite
# Create a list of commands to put into the script
postinst_list = []
prerm_list = []
for INDEX in range(total):
source_path = self.Executables.GetPath(INDEX)
filename = self.Executables.GetBasename(INDEX)
if u'.' in filename:
linkname = u'.'.join(filename.split(u'.')[:-1])
link = u'{}/{}'.format(link_path, linkname)
else:
link = u'{}/{}'.format(link_path, filename)
postinst_list.append(u'ln -fs "{}" "{}"'.format(source_path, link))
prerm_list.append(u'rm -f "{}"'.format(link))
postinst = u'\n\n'.join(postinst_list)
prerm = u'\n\n'.join(prerm_list)
self.script_objects[1][0].SetValue(postinst)
self.script_objects[2][0].SetValue(prerm)
DetailedMessageDialog(main_window, GT(u'Success'),
text=GT(u'Post-Install and Pre-Remove scripts generated')).ShowModal()
def OnBuild(self, event=None):
if event:
event.Skip()
# Show control file preview for editing
if UsingTest(u'alpha') and self.chk_editctrl.GetValue():
self.EditControl()
wizard = GetWizard()
pg_control = wizard.GetPage(pgid.CONTROL)
pg_files = wizard.GetPage(pgid.FILES)
pg_launcher = wizard.GetPage(pgid.LAUNCHERS)
required_fields = {
GT(u'Control'): pg_control.GetRequiredFields(),
}
# Check if launchers are enabled for build
if pg_launcher.GetLaunchersCount():
required_fields[GT(
u'Menu Launcher')] = pg_launcher.GetRequiredFields()
# FIXME: Old code won't work with multiple launchers
for RF in required_fields[GT(u'Menu Launcher')]:
Logger.Debug(
__name__,
GT(u'Required field (Menu Launcher): {}').format(
RF.GetName()))
for p_name in required_fields:
Logger.Debug(__name__, GT(u'Page name: {}').format(p_name))
for F in required_fields[p_name]:
if not isinstance(F, wx.StaticText) and TextIsEmpty(
F.GetValue()):
f_name = F.GetName()
msg_l1 = GT(u'One of the required fields is empty:')
msg_full = u'{}: {} ➜ {}'.format(msg_l1, p_name, f_name)
Logger.Warn(__name__, msg_full)
DetailedMessageDialog(GetMainWindow(),
GT(u'Cannot Continue'),
ICON_EXCLAMATION,
text=msg_full).ShowModal()
for P in wizard.GetAllPages():
if P.GetTitle() == p_name:
Logger.Debug(
__name__,
GT(u'Showing page with required field: {}').
format(p_name))
wizard.ShowPage(P.GetId())
return
if GetField(pg_files, inputid.LIST).MissingFiles():
ShowErrorDialog(GT(u'Files are missing in file list'),
warn=True,
title=GT(u'Warning'))
wizard.ShowPage(pgid.FILES)
return
ttype = GT(u'Debian Packages')
save_dialog = GetFileSaveDialog(GetMainWindow(), GT(u'Build Package'),
u'{} (*.deb)|*.deb'.format(ttype),
u'deb')
package = GetFieldValue(pg_control, inputid.PACKAGE)
version = GetFieldValue(pg_control, inputid.VERSION)
arch = GetFieldValue(pg_control, inputid.ARCH)
save_dialog.SetFilename(u'{}_{}_{}.deb'.format(package, version, arch))
if ShowDialog(save_dialog):
self.Build(save_dialog.GetPath())