def extract_bitmap(self, filepath):
ext = '.tiff' if self.bitmap.mode == uc2const.IMAGE_CMYK else '.png'
path, file_ext = os.path.splitext(filepath)
filepath = path + ext if not file_ext == ext else filepath
fileptr = fsutils.get_fileptr(filepath, True)
self.bitmap.save(fileptr, format=self._get_saver_fmt(self.bitmap))
fileptr.close()
if self.alpha:
fileptr = fsutils.get_fileptr(path + '_alphachannel.png', True)
self.bitmap.save(fileptr, format=PNG_FMT)
fileptr.close()
def apply_action(self):
if not self.picture:
return
doc_file = 'image'
doc_file = os.path.join(self.config.save_dir, doc_file)
doc_file = dialogs.get_save_file_name(self.app.mw,
doc_file,
_('Save image as...'),
file_types=[uc2const.PNG],
path_only=True)
if doc_file:
try:
fileptr = fsutils.get_fileptr(doc_file, True)
fileptr.write(self.picture.getvalue())
fileptr.close()
except Exception:
first = _('Cannot save image:')
msg = "%s\n'%s'." % (first, doc_file) + '\n'
msg += _('Please check file name and write permissions')
dialogs.error_dialog(self.app.mw, self.app.appdata.app_name,
msg)
return
self.config.save_dir = str(os.path.dirname(doc_file))
self.save_config()
events.emit(events.APP_STATUS, _('Image is successfully saved'))
def check_png(path):
fileptr = get_fileptr(path)
mstr = fileptr.read(len(PNG_ID))
fileptr.close()
if mstr == PNG_ID:
return True
return False
def save_resource(self, res, filename):
try:
with fsutils.get_fileptr(filename, writable=True) as fileptr:
fileptr.write(res)
fileptr.close()
except Exception:
pass
def png_saver(sk2_doc,
filename=None,
fileptr=None,
translate=True,
cnf=None,
**kw):
cnf = merge_cnf(cnf, kw)
if filename and not fileptr:
fileptr = get_fileptr(filename, True)
page = sk2_doc.methods.get_page()
w, h = page.page_format[1]
trafo = (1.0, 0, 0, -1.0, w / 2.0, h / 2.0)
canvas_matrix = cairo.Matrix(*trafo)
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(w), int(h))
ctx = cairo.Context(surface)
ctx.set_matrix(canvas_matrix)
rend = CairoRenderer(sk2_doc.cms)
antialias_flag = True
if 'antialiasing' in cnf.keys():
if not cnf['antialiasing'] in ('True', '1'):
antialias_flag = False
rend.antialias_flag = antialias_flag
layers = sk2_doc.methods.get_visible_layers(page)
for item in layers:
if not item.properties[3] and antialias_flag:
rend.antialias_flag = False
rend.render(ctx, item.childs)
if not item.properties[3] and antialias_flag:
rend.antialias_flag = True
surface.write_to_png(fileptr)
fileptr.close()
def load(self, presenter, path=None, fileptr=None):
self.presenter = presenter
self.model = presenter.model
self.config = self.presenter.config
if path:
self.filepath = path
self.file_size = os.path.getsize(get_sys_path(path))
self.fileptr = get_fileptr(path)
elif fileptr:
self.fileptr = fileptr
self.fileptr.seek(0, 2)
self.file_size = self.fileptr.tell()
self.fileptr.seek(0)
else:
msg = _('There is no file for reading')
raise IOError(errno.ENODATA, msg, '')
try:
self.init_load()
except Exception:
LOG.error('Error loading file content')
raise
self.fileptr.close()
self.position = 0
return self.model
def save(self, filename=None):
if self.filename and filename is None:
filename = self.filename
if len(self.__dict__) == 0 or filename is None:
return
try:
fileobj = fsutils.get_fileptr(filename, True)
except Exception:
return
defaults = SerializedConfig.__dict__
items = self.__dict__.items()
items.sort()
for key, value in items:
if key in defaults and defaults[key] == value:
continue
if key in ['filename', 'app']:
continue
try:
line = fsutils.get_sys_path('%s = %s\n' %
(key, value.__repr__()))
except Exception as e:
LOG.error('ERROR>>> %s', e)
continue
fileobj.write(line)
fileobj.close()
def save_history(self):
fp = fsutils.get_fileptr(self.history_file, True)
for item in self.history:
state, path, timestamp = str(item[0]), item[1], str(item[2])
fp.write('%s\t%s\t%s\n' % (state, path, timestamp))
fp.close()
events.emit(events.HISTORY_CHANGED)
def png_saver(sk2_doc,
filename=None,
fileptr=None,
translate=True,
cnf=None,
**kw):
cnf = merge_cnf(cnf, kw)
if filename and not fileptr:
fileptr = get_fileptr(filename, True)
page = sk2_doc.methods.get_page()
scale = abs(float(cnf.get('scale', 1.0))) or 1.0
w, h = [scale * item for item in page.page_format[1]]
trafo = (scale, 0, 0, -scale, w / 2.0, h / 2.0)
canvas_matrix = cairo.Matrix(*trafo)
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, int(w), int(h))
ctx = cairo.Context(surface)
ctx.set_matrix(canvas_matrix)
antialias_flag = not cnf.get('antialiasing') in (False, 0)
layers = sk2_doc.methods.get_visible_layers(page)
rend = CairoRenderer(sk2_doc.cms)
for item in layers:
rend.antialias_flag = not any(
[not item.properties[3], not antialias_flag])
rend.render(ctx, item.childs)
surface.write_to_png(fileptr)
fileptr.close()
def check_cdr(path):
fileptr = get_fileptr(path)
header = fileptr.read(12)
fileptr.close()
if not header[:4] == cdr_const.RIFF_ID:
return False
if header[8:] in cdr_const.CDR_VERSIONS:
return True
else:
return False
def __init__(self, app, cfgdir='~'):
# --- Init paths
path = fsutils.expanduser(os.path.join(cfgdir, '.config', 'sk1-wx'))
self.app_config_dir = path
UCData.__init__(self, app, check=False)
self.check_config_dirs()
self.app_palette_dir = os.path.join(path, 'palettes')
self.plugin_dir = os.path.join(path, 'sk1_custom_plugins')
self.app_temp_dir = os.path.join(path, 'temp')
# --- Check config directories
paths = (self.app_palette_dir, self.plugin_dir, self.app_temp_dir)
[fsutils.makedirs(item) for item in paths if not fsutils.exists(item)]
plugin_dir_init = os.path.join(self.plugin_dir, '__init__.py')
if not fsutils.exists(plugin_dir_init):
fsutils.get_fileptr(plugin_dir_init, True).close()
def check_dst(path):
file_size = os.path.getsize(path)
fileptr = get_fileptr(path)
if file_size > 3:
string = fileptr.read(3)
else:
string = fileptr.read()
fileptr.close()
return string.startswith('LA:')
def check_pes(path):
file_size = os.path.getsize(path)
fileptr = get_fileptr(path)
if file_size > 4:
string = fileptr.read(4)
else:
string = fileptr.read()
fileptr.close()
return string in (PES_SIGNATURE, PEC_SIGNATURE)
def check_plt(path):
file_size = os.path.getsize(path)
fileptr = get_fileptr(path)
if file_size > 20:
string = fileptr.read(20)
else:
string = fileptr.read()
fileptr.close()
return string.startswith('IN;')
def load_logs(self, log_path):
if not os.path.lexists(log_path):
return
fileptr = get_fileptr(log_path)
self.logs = []
while True:
line = fileptr.readline()
if not line:
break
self.logs.append(line)
self.parse_logs()
self.change_title(log_path)
def check_fig(path):
file_size = os.path.getsize(path)
fileptr = get_fileptr(path)
magic = '#FIG 3'
if file_size > len(magic):
string = fileptr.read(len(magic))
else:
string = fileptr.read()
fileptr.close()
return string.startswith(magic)
def check_xml_(path):
fileptr = get_fileptr(path)
ret = False
i = 0
while i < 20:
line = fileptr.readline()
if not line.find('<?xml ') == -1:
ret = True
break
i += 1
fileptr.close()
return ret
def check_scribus_pal(path):
fileptr = get_fileptr(path)
ret = False
i = 0
while i < 20:
line = fileptr.readline()
if not line.find(SP_TAG) == -1:
ret = True
break
i += 1
fileptr.close()
return ret
def check_corel_pal(path):
fileptr = get_fileptr(path, binary=False)
ret = False
i = 0
while i < 20:
line = fileptr.readline()
if not line.find('<palette') == -1:
ret = True
break
i += 1
fileptr.close()
return ret
def check_svg(path):
tag = None
fileptr = get_fileptr(path)
try:
for event, el in cElementTree.iterparse(fileptr, ('start', )):
tag = el.tag
break
except cElementTree.ParseError:
pass
finally:
fileptr.close()
return tag == '{http://www.w3.org/2000/svg}svg' or tag == 'svg'
def check_wmf(path):
fileptr = get_fileptr(path)
sign = fileptr.read(len(WMF_SIGNATURE))
fileptr.seek(0)
metatype = fileptr.read(2)
fileptr.read(2)
metaver = fileptr.read(2)
fileptr.close()
if sign == WMF_SIGNATURE:
return True
if metatype in METAFILETYPES and metaver in METAVERSIONS:
return True
return False
def check_plt(path):
file_size = os.path.getsize(path)
fileptr = get_fileptr(path)
if file_size > 200:
string = fileptr.read(200)
else:
string = fileptr.read()
fileptr.close()
if len(string.split("IN;")) > 1 and len(string.split(";")) > 2:
if len(string.split(";PD")) > 1:
return True
return False
def load_pattern(self):
img_file = self.app.import_pattern(self.dlg)
if img_file:
fobj = fsutils.get_fileptr(img_file)
pattern, flag = libimg.read_pattern(fobj.read())
pattern_type = sk2const.PATTERN_TRUECOLOR
if flag:
pattern_type = sk2const.PATTERN_IMG
if flag == 'EPS':
pattern_type = sk2const.PATTERN_EPS
self.pattern_def[0] = pattern_type
self.pattern_def[1] = pattern
if self.callback:
self.callback(self.get_pattern_def())
def check_soc(path):
fileptr = get_fileptr(path, binary=False)
ret = False
i = 0
while i < 20:
line = fileptr.readline()
if not line.find(SOC_PAL_TAG) == -1:
ret = True
break
if not line.find(SOC_PAL_OO_TAG) == -1:
ret = True
break
i += 1
fileptr.close()
return ret
def read_history(self):
if fsutils.isfile(self.history_file):
fp = fsutils.get_fileptr(self.history_file)
lines = [line.strip(' \n\r') for line in fp.readlines()]
for line in lines:
items = line.split('\t')
if len(items) == 3:
status = int(items[0])
path = items[1]
try:
path = path.decode('utf-8')
except Exception:
path = path.decode(sys.getfilesystemencoding())
finally:
path = path.encode('utf-8')
timestamp = int(items[2])
self.history.append([status, path, timestamp])
fp.close()
def save(self, presenter, path=None, fileptr=None):
self.presenter = presenter
self.config = self.presenter.config
self.model = presenter.model
if path:
self.fileptr = get_fileptr(path, True)
elif fileptr:
self.fileptr = fileptr
else:
msg = _('There is no file for writting')
raise IOError(errno.ENODATA, msg, '')
self.presenter.update()
try:
self.do_save()
except Exception as e:
LOG.error('Error saving file content %s', e)
raise
self.fileptr.close()
self.fileptr = None
def check_sk2(path):
ret = False
fileptr = get_fileptr(path)
ln = fileptr.readline()
if ln[:len(SK2DOC_ID)] == SK2DOC_ID:
if int(ln[len(SK2DOC_ID):]) <= int(SK2VER):
ret = True
else:
fileptr.close()
raise RuntimeError(_('Newer version of SK2 format is found!'))
else:
ln2 = fileptr.readline()
if ln2[:len(SK2XML_ID)] == SK2XML_ID:
if int(ln2[len(SK2XML_ID):]) <= int(SK2VER):
ret = True
else:
fileptr.close()
raise RuntimeError(_('Newer version of SK2 format is found!'))
fileptr.close()
return ret
def load(self, filename=None):
self.filename = filename
if fsutils.lexists(filename):
content_handler = XMLPrefReader(pref=self)
error_handler = ErrorHandler()
entity_resolver = EntityResolver()
dtd_handler = DTDHandler()
try:
input_file = get_fileptr(filename)
input_source = InputSource()
input_source.setByteStream(input_file)
xml_reader = xml.sax.make_parser()
xml_reader.setContentHandler(content_handler)
xml_reader.setErrorHandler(error_handler)
xml_reader.setEntityResolver(entity_resolver)
xml_reader.setDTDHandler(dtd_handler)
xml_reader.parse(input_source)
input_file.close()
except Exception as e:
LOG.error('Cannot read preferences from %s %s', filename, e)
def load_logs(self, log_path):
if not os.path.lexists(log_path):
return
fileptr = get_fileptr(log_path)
self.entry.clear()
self.entry.set_monospace(self.zoom)
while True:
line = fileptr.readline()
if not line:
break
color = COLOR_MAP.get(line[:9].strip(), None)
if not color:
for item in COLOR_MAP:
if item in line:
color = COLOR_MAP[item]
break
color = color or DARK
self.entry.set_text_colors(color)
self.entry.append(line)
self.change_title(log_path)
def load(self, filename=None):
self.filename = filename
if os.path.lexists(filename):
try:
fileobj = get_fileptr(filename)
except Exception:
return
while True:
line = fileobj.readline()
if line.startswith('<?xml') or not line:
break
if line.startswith('#'):
continue
line = path_system('self.%s' % line)
try:
code = compile(line, '<string>', 'exec')
exec code
except Exception as e:
LOG.error('ERROR>>> %s\n%s', line, e)
fileobj.close()
