Example #1
0
	def _extract_content(self):
		pdxf_file = ZipFile(self.path, 'r')
		try:
			fl = pdxf_file.namelist()
		except:
			errtype, value, traceback = sys.exc_info()
			msg = _('It seems the PDXF file is corrupted') + '\n' + value
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(errtype, msg , traceback)
		if not 'mimetype' in fl or not pdxf_file.read('mimetype') == const.DOC_MIME:
			msg = _('The file is corrupted or not PDXF file')
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(2, msg)

		filelist = []
		for item in fl:
			if item == 'mimetype' or item[-1] == '/':
				continue
			filelist.append(item)

		for item in filelist:
			source = pdxf_file.read(item)
			dest = open(os.path.join(self.presenter.doc_dir, item), 'wb')
			dest.write(source)
			dest.close()
		msg = _('The file content is extracted successfully')
		events.emit(events.MESSAGES, msgconst.OK, msg)
Example #2
0
def get_saver(path, experimental=False, return_id=False):
    ret_id = None
    ext = get_file_extension(path)
    saver = None
    sv_formats = [] + uc2const.SAVER_FORMATS

    msg = _('Start to search saver by file extension %s') % (ext.__str__())
    events.emit(events.MESSAGES, msgconst.INFO, msg)

    if experimental:
        sv_formats += uc2const.EXPERIMENTAL_SAVERS
    for item in sv_formats:
        if ext in uc2const.FORMAT_EXTENSION[item]:
            saver = _get_saver(item)
            ret_id = item
            break
    if saver is None:
        msg = _('Saver is not found for %s file format') % (ext.__str__())
        events.emit(events.MESSAGES, msgconst.ERROR, msg)
    else:
        msg = _('Saver is found for extension %s') % (ext.__str__())
        events.emit(events.MESSAGES, msgconst.OK, msg)

    if return_id:
        return saver, ret_id
    return saver
Example #3
0
    def _build_model(self):
        content_handler = XMLDocReader(self.presenter)
        error_handler = ErrorHandler()
        entity_resolver = EntityResolver()
        dtd_handler = DTDHandler()
        try:
            filename = os.path.join(self.presenter.doc_dir, 'content.xml')
            handler = open(filename, 'r')
            lines = float(sum(1 for l in handler))
            handler.close()
            self.file_handler = open(filename, "r")
            input_source = InputSource()
            input_source.setByteStream(self.file_handler)
            content_handler.lines = lines
            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)
            self.file_handler.close()
            content_handler.file = None
        except:
            errtype, value, traceback = sys.exc_info()
            msg = _('It seems content.xml is corrupted') + '\n' + value
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(errtype, msg, traceback)
        self.model = content_handler.model

        msg = _('Content.xml is parsed successfully')
        events.emit(events.MESSAGES, msgconst.OK, msg)
Example #4
0
    def _extract_content(self):
        pdxf_file = ZipFile(self.path, 'r')
        try:
            fl = pdxf_file.namelist()
        except:
            errtype, value, traceback = sys.exc_info()
            msg = _('It seems the PDXF file is corrupted') + '\n' + value
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(errtype, msg, traceback)
        if not 'mimetype' in fl or not pdxf_file.read(
                'mimetype') == const.DOC_MIME:
            msg = _('The file is corrupted or not PDXF file')
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(2, msg)

        filelist = []
        for item in fl:
            if item == 'mimetype' or item[-1] == '/':
                continue
            filelist.append(item)

        for item in filelist:
            source = pdxf_file.read(item)
            dest = open(os.path.join(self.presenter.doc_dir, item), 'wb')
            dest.write(source)
            dest.close()
        msg = _('The file content is extracted successfully')
        events.emit(events.MESSAGES, msgconst.OK, msg)
Example #5
0
	def _build_model(self):
		content_handler = XMLDocReader(self.presenter)
		error_handler = ErrorHandler()
		entity_resolver = EntityResolver()
		dtd_handler = DTDHandler()
		try:
			filename = os.path.join(self.presenter.doc_dir, 'content.xml')
			handler = open(filename, 'r')
			lines = float(sum(1 for l in handler))
			handler.close()
			self.file_handler = open(filename, "r")
			input_source = InputSource()
			input_source.setByteStream(self.file_handler)
			content_handler.lines = lines
			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)
			self.file_handler.close()
			content_handler.file = None
		except:
			errtype, value, traceback = sys.exc_info()
			msg = _('It seems content.xml is corrupted') + '\n' + value
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(errtype, msg , traceback)
		self.model = content_handler.model

		msg = _('Content.xml is parsed successfully')
		events.emit(events.MESSAGES, msgconst.OK, msg)
Example #6
0
def get_fileptr(path, writable=False):
    if not path:
        msg = _('There is no file path')
        raise IOError(errno.ENODATA, msg, '')
    try:
        return uopen(path, 'wb' if writable else 'rb')
    except Exception:
        msg = _('Cannot open %s file for writing') % path \
            if writable else _('Cannot open %s file for reading') % path
        events.emit(events.MESSAGES, msgconst.ERROR, msg)
        LOG.exception(msg)
        raise
Example #7
0
    def load(self, presenter, path):
        self.presenter = presenter
        self.path = path
        self.model = presenter.model
        self.jobs = []

        try:
            file = open(path, 'rb')
        except:
            errtype, value, traceback = sys.exc_info()
            msg = _('Cannot open %s file for writing') % (path)
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(errtype, msg + '\n' + value, traceback)

        res = file.read().split('IN;')
        file.close()

        if not len(res) == 2:
            msg = _(
                'Wrong content in %s file: "IN;" instruction should be unique'
            ) % (path)
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(msg)

        if res[0]:
            self.model.string = res[0]
        cmds = res[1].split(';')
        jobs = []
        job = []
        stack = ''
        for cmd in cmds:
            if cmd[:2] == 'PU':
                stack = cmd
                if job:
                    jobs.append(job)
                    job = []
            elif cmd[:2] == 'PD':
                if not job:
                    if not stack:
                        stack = 'PU0,0'
                    job.append(stack)
                job.append(cmd)

        for job in jobs:
            string = ''
            for cmd in job:
                string += cmd + ';'
            self.jobs.append(model.PltJob(string))

        self.model.childs[1].childs = self.jobs
        return self.model
Example #8
0
	def load(self, presenter, path):
		self.presenter = presenter
		self.path = path
		self.model = presenter.model
		self.jobs = []

		try:
			file = open(path, 'rb')
		except:
			errtype, value, traceback = sys.exc_info()
			msg = _('Cannot open %s file for writing') % (path)
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(errtype, msg + '\n' + value, traceback)

		res = file.read().split('IN;')
		file.close()

		if not len(res) == 2:
			msg = _('Wrong content in %s file: "IN;" instruction should be unique') % (path)
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(msg)

		if res[0]:
			self.model.string = res[0]
		cmds = res[1].split(';')
		jobs = []
		job = []
		stack = ''
		for cmd in cmds:
			if cmd[:2] == 'PU':
				stack = cmd
				if job:
					jobs.append(job)
					job = []
			elif cmd[:2] == 'PD':
				if not job:
					if not stack:
						stack = 'PU0,0'
					job.append(stack)
				job.append(cmd)

		for job in jobs:
			string = ''
			for cmd in job:
				string += cmd + ';'
			self.jobs.append(model.PltJob(string))

		self.model.childs[1].childs = self.jobs
		return self.model
Example #9
0
    def update(self, action=False):
        if self.model is not None:
            self.obj_num = self.model.count() + 1
            self.update_msg(0.0)
            try:
                self.model.config = self.config
                self.model.do_update(self, action)
            except Exception:
                LOG.error(_('Error updating document model'))
                raise

            model_name = uc2const.FORMAT_NAMES[self.cid]
            msg = _('<%s> document model is updated successfully') % model_name
            self.send_progress_message(msg, 0.99)
            self.send_ok(msg)
Example #10
0
    def close(self):
        file = self.doc_file
        self.doc_file = ''
        if not self.model is None:
            self.model.destroy()
        self.model = None

        self.send_ok(_('Document model is destroyed for') + ' %s' % (file))

        if self.doc_dir and os.path.lexists(self.doc_dir):
            try:
                fs.xremove_dir(self.doc_dir)
                self.send_ok(_('Cache is cleared for') + ' %s' % (file))
            except IOError:
                self.send_srror(_('Cache clearing is unsuccessful'))
Example #11
0
	def close(self):
		filename = self.doc_file
		self.doc_file = ''
		if not self.model is None:
			self.model.destroy()
		self.model = None

		self.send_ok(_('Document model is destroyed for') + ' %s' % (filename))

		if self.doc_dir and os.path.lexists(self.doc_dir):
			try:
				fs.xremove_dir(self.doc_dir)
				self.send_ok(_('Cache is cleared for') + ' %s' % (filename))
			except IOError:
				self.send_srror(_('Cache clearing is unsuccessful'))
Example #12
0
	def update(self, action=False):
		if not self.model is None:
			self.obj_num = self.model.count() + 1
			self.update_msg(0.0)
			try:
				self.model.config = self.config
				self.model.do_update(self, action)
			except:
				print sys.exc_info()[1], sys.exc_info()[2]
				msg = _('Exception while document model update')
				self.send_error(msg)
				raise IOError(msg)

			msg = _('Document model is updated successfully')
			self.send_progress_message(msg, 0.99)
			self.send_ok(msg)
Example #13
0
	def __init__(self, config, parent=None, name=_('GridLayer')):
		Layer.__init__(self, config, parent, name)
		self.cid = GRID_LAYER
		self.childs = []
		self.color = [] + self.config.grid_layer_color
		self.grid = [] + self.config.grid_layer_geometry
		self.properties = [] + self.config.grid_layer_propeties
Example #14
0
 def add_layer(self, page, layer_name=''):
     if not layer_name:
         layer_name = _('Layer') + ' %i' % (page.layer_counter + 1)
     layer = model.Layer(self.config, page, layer_name)
     page.childs.append(layer)
     page.layer_counter += 1
     return layer
Example #15
0
    def startElement(self, name, attrs):
        if name == 'Content':
            pass
        else:
            position = float(self.locator.getLineNumber()) / self.lines
            if position - self.position > 0.05:
                msg = _('Parsing in process...')
                events.emit(events.FILTER_INFO, msg, position)
                self.position = position
            obj = None
            cid = model.TAGNAME_TO_CID[name]
            obj = model.CID_TO_CLASS[cid](self.presenter.config)
            obj.tag = name
            for item in attrs._attrs.keys():
                line = 'self.value=' + attrs._attrs[item]
                code = compile(line, '<string>', 'exec')
                exec code
                obj.__dict__[item] = self.value

            if self.parent_stack:
                parent = self.parent_stack[-1]
                methods.add_child(parent, obj)
            else:
                self.model = obj

            self.parent_stack.append(obj)
Example #16
0
    def create_jobs(self):
        if self.obj_stack:
            m11, m21, m12, m22, dx, dy = SK2_to_PLT_TRAFO

            if self.plt_doc.config.force_zero:
                bbox = []
                bbox += self.obj_stack[0].cache_bbox
                for obj in self.obj_stack:
                    bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)

                dx = -bbox[0] * m11
                dy = -bbox[1] * m22

            trafo = [m11, m21, m12, m22, dx, dy]

            obj_num = len(self.obj_stack)
            for obj in self.obj_stack:

                self.counter += 1
                position = float(self.counter) / obj_num
                if position - self.position > 0.05:
                    msg = _('Saving in process...')
                    events.emit(events.FILTER_INFO, msg, position)
                    self.position = position

                paths = libgeom.get_flattened_path(
                    obj, trafo, self.plt_doc.config.tolerance)
                if paths is None: continue

                for path in paths:
                    if path and path[1]:
                        self.jobs.append(plt_model.PltJob('', path))
Example #17
0
	def startElement(self, name, attrs):
		if name == 'Content':
			pass
		else:
			position = float(self.locator.getLineNumber()) / self.lines
			if position - self.position > 0.05:
				msg = _('Parsing in process...')
				events.emit(events.FILTER_INFO, msg, position)
				self.position = position
			obj = None
			cid = model.TAGNAME_TO_CID[name]
			obj = model.CID_TO_CLASS[cid](self.presenter.config)
			obj.tag = name
			for item in attrs._attrs.keys():
				line = 'self.value=' + attrs._attrs[item]
				code = compile(line, '<string>', 'exec')
				exec code
				obj.__dict__[item] = self.value

			if self.parent_stack:
				parent = self.parent_stack[-1]
				methods.add_child(parent, obj)
			else:
				self.model = obj

			self.parent_stack.append(obj)
Example #18
0
    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(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 as inst:
            print type(inst)
            print inst.args
            print inst
            raise IOError(type(inst), str(inst.args) + '\n' + str(inst), '')

        self.fileptr.close()
        self.position = 0
        return self.model
Example #19
0
def get_loader_by_id(pid):
    loader = _get_loader(pid)
    if not loader:
        msg = _('Loader is not found for id %s') % (
            uc2const.FORMAT_NAMES[pid], )
        events.emit(events.MESSAGES, msgconst.ERROR, msg)
    return loader
Example #20
0
	def set_default_page_size(self, width, height):
		parent = self.model.childs[0]
		fmt = _('Custom size')
		size = (width, height)
		orient = uc2const.PORTRAIT
		if width > height:orient = uc2const.LANDSCAPE
		parent.page_format = [fmt, size, orient]
Example #21
0
    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
Example #22
0
	def create_jobs(self):
		if self.obj_stack:
			m11, m21, m12, m22, dx, dy = SK2_to_PLT_TRAFO

			if self.plt_doc.config.force_zero:
				bbox = []
				bbox += self.obj_stack[0].cache_bbox
				for obj in self.obj_stack:
					bbox = libgeom.sum_bbox(bbox, obj.cache_bbox)

				dx = -bbox[0] * m11
				dy = -bbox[1] * m22

			trafo = [m11, m21, m12, m22, dx, dy]

			obj_num = len(self.obj_stack)
			for obj in self.obj_stack:

				self.counter += 1
				position = float(self.counter) / obj_num
				if position - self.position > 0.05:
					msg = _('Saving in process...')
					events.emit(events.FILTER_INFO, msg, position)
					self.position = position

				paths = libgeom.get_flattened_path(obj, trafo,
									self.plt_doc.config.tolerance)
				if paths is None: continue

				for path in paths:
					if path and path[1]:
						self.jobs.append(plt_model.PltJob('', path))
Example #23
0
    def update(self):
        if not self.model is None:
            self.obj_num = self.model.count() + 1
            self.update_msg(0.0)
            try:
                self.model.config = self.config
                self.model.do_update(self)
            except:
                print sys.exc_info()[1], sys.exc_info()[2]
                msg = _('Exception while document model update')
                self.send_error(msg)
                raise IOError(msg)

            msg = _('Document model is updated successfully')
            self.send_progress_message(msg, 0.99)
            self.send_ok(msg)
Example #24
0
	def add_layer(self, page, layer_name=''):
		if not layer_name:
			layer_name = _('Layer') + ' %i' % (page.layer_counter + 1)
		layer = model.Layer(self.config, page, layer_name)
		page.childs.append(layer)
		page.layer_counter += 1
		return layer
Example #25
0
 def add_layer(self, page, layer_name=""):
     if not layer_name:
         layer_name = _("Layer") + " %i" % (page.layer_counter + 1)
     layer = sk2_model.Layer(self.config, page, layer_name)
     page.childs.append(layer)
     page.layer_counter += 1
     return layer
Example #26
0
 def set_default_page_size(self, width, height):
     parent = self.model.childs[0]
     fmt = _('Custom size')
     size = (width, height)
     orient = uc2const.PORTRAIT
     if width > height: orient = uc2const.LANDSCAPE
     parent.page_format = [fmt, size, orient]
Example #27
0
def get_loader_by_id(pid):
    loader = None
    if pid in data.LOADERS.keys():
        loader = data.LOADERS[pid]
    else:
        msg = _('Loader is not found for id %u') % (pid)
        events.emit(events.MESSAGES, msgconst.ERROR, msg)
    return loader
Example #28
0
def get_saver_by_id(pid):
    saver = None
    if pid in data.SAVERS.keys():
        saver = data.SAVERS[pid]
    else:
        msg = _('Saver is not found for id %u') % (pid)
        events.emit(events.MESSAGES, msgconst.ERROR, msg)
    return saver
Example #29
0
 def set_default_page_size(self, width, height):
     parent = self.get_pages_obj()
     fmt = _("Custom size")
     size = (width, height)
     orient = uc2const.PORTRAIT
     if width > height:
         orient = uc2const.LANDSCAPE
     parent.page_format = [fmt, size, orient]
Example #30
0
def get_saver_by_id(pid):
	saver = None
	if pid in data.SAVERS.keys():
		saver = data.SAVERS[pid]
	else:
		msg = _('Saver is not found for id %u') % (pid)
		events.emit(events.MESSAGES, msgconst.ERROR, msg)
	return saver
Example #31
0
def get_loader_by_id(pid):
	loader = None
	if pid in data.LOADERS.keys():
		loader = data.LOADERS[pid]
	else:
		msg = _('Loader is not found for id %u') % (pid)
		events.emit(events.MESSAGES, msgconst.ERROR, msg)
	return loader
Example #32
0
	def save(self, path):
		if path:
			self.doc_file = path
			try:
				self.saving_msg(0.03)
				self.send_info(_('Saving is started...'))
				self.saver.save(self, path)
			except:
				msg = _('Error while saving') + ' ' + path
				self.send_error(msg)
				raise IOError(msg, sys.exc_info()[1], sys.exc_info()[2])
		else:
			self.send_error(_('Error while saving:') + ' ' + _('Empty file name'))
			raise IOError(msg)

		msg = _('Document model is saved successfully')
		self.send_progress_message(msg, 0.95)
		self.send_ok(msg)
Example #33
0
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
Example #34
0
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
Example #35
0
 def verbose(self, *args):
     status = msgconst.MESSAGES[args[0]]
     LOG_MAP[args[0]](args[1])
     if self.do_verbose or args[0] in (msgconst.ERROR, msgconst.STOP):
         indent = ' ' * (msgconst.MAX_LEN - len(status))
         echo('%s%s| %s' % (status, indent, args[1]))
     if args[0] == msgconst.STOP:
         echo(_('For details see logs: %s\n') % self.log_filepath)
         sys.exit(1)
Example #36
0
	def load(self, path):
		if path and os.path.lexists(path):
			try:
				self.parsing_msg(0.03)
				self.send_info(_('Parsing is started...'))
				self.model = self.loader.load(self, path)
			except:
				self.close()
				raise IOError(_('Error while loading') + ' ' + path,
							sys.exc_info()[1], sys.exc_info()[2])

			self.send_ok(_('Document model is created'))
			self.doc_file = path
		else:
			msg = _('Error while loading:') + ' ' + _('file doesn\'t exist')
			self.send_error(msg)
			raise IOError(msg)
		self.update()
Example #37
0
	def _save_content(self):
		content_xml = os.path.join(self.presenter.doc_dir, 'content.xml')
		try:
			self.file = open(content_xml, 'wb')
		except:
			errtype, value, traceback = sys.exc_info()
			msg = _('Cannot open %s file for writing') % (content_xml)
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(errtype, msg + '\n' + value, traceback)

		doc = self.presenter.model
		self.obj_num = doc.count()
		self._start()
		self._write_tree(doc)
		self._finish()

		msg = _('PDXF file content.xml is created')
		events.emit(events.MESSAGES, msgconst.OK, msg)
Example #38
0
    def _save_content(self):
        content_xml = os.path.join(self.presenter.doc_dir, 'content.xml')
        try:
            self.file = open(content_xml, 'wb')
        except:
            errtype, value, traceback = sys.exc_info()
            msg = _('Cannot open %s file for writing') % (content_xml)
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(errtype, msg + '\n' + value, traceback)

        doc = self.presenter.model
        self.obj_num = doc.count()
        self._start()
        self._write_tree(doc)
        self._finish()

        msg = _('PDXF file content.xml is created')
        events.emit(events.MESSAGES, msgconst.OK, msg)
Example #39
0
	def _pack_content(self):
		pdxf_file = ZipFile(self.presenter.doc_file, 'w')
		for item in self.content:
			path, filename = item
			filename = filename.encode('ascii')
			pdxf_file.write(path, filename, zipfile.ZIP_DEFLATED)
		pdxf_file.close()

		msg = _('PDXF file is created successfully')
		events.emit(events.MESSAGES, msgconst.OK, msg)
Example #40
0
def get_loader(path, experimental=False, return_id=False):
    if not os.path.lexists(path):
        return None
    if not os.path.isfile(path):
        return None

    ret_id = None

    ext = get_file_extension(path)
    loader = None
    ld_formats = [] + uc2const.LOADER_FORMATS

    msg = _('Start to search for loader by file extension %s') % (ext.__str__())
    events.emit(events.MESSAGES, msgconst.INFO, msg)

    if experimental:
        ld_formats += uc2const.EXPERIMENTAL_LOADERS
    for item in ld_formats:
        if ext in uc2const.FORMAT_EXTENSION[item]:
            checker = _get_checker(item)
            if checker and checker(path):
                loader = _get_loader(item)
                ret_id = item
                break

    if loader is None:
        msg = _('Loader is not found or not suitable for %s') % path
        events.emit(events.MESSAGES, msgconst.WARNING, msg)
        msg = _('Start to search loader by file content')
        events.emit(events.MESSAGES, msgconst.INFO, msg)

        for item in ld_formats:
            checker = _get_checker(item)
            if checker is not None:
                if checker(path):
                    loader = _get_loader(item)
                    ret_id = item
                    break

    if loader is None:
        msg = _('By file content loader is not found for %s') % path
        events.emit(events.MESSAGES, msgconst.WARNING, msg)
        msg = _('Try using fallback loader')
        events.emit(events.MESSAGES, msgconst.INFO, msg)
        if fallback_check(path):
            loader = im_loader

    if loader is None:
        msg = _('Loader is not found for %s') % path
        events.emit(events.MESSAGES, msgconst.ERROR, msg)
    else:
        loader_name = loader.__str__().split(' ')[1]
        msg = _('Loader <%s> is found for %s') % (loader_name, path)
        events.emit(events.MESSAGES, msgconst.OK, msg)

    if return_id:
        return loader, ret_id
    return loader
Example #41
0
	def load(self, filename=None, fileptr=None):
		if filename and os.path.lexists(filename):
			self.doc_file = filename
		elif not fileptr:
			msg = _('Error while loading:') + ' ' + _('No file')
			self.send_error(msg)
			raise IOError(msg)

		try:
			self.parsing_msg(0.03)
			self.send_info(_('Parsing is started...'))
			self.model = self.loader.load(self, filename, fileptr)
		except:
			self.close()
			raise IOError(_('Error while loading') + ' ' + filename,
						sys.exc_info()[1], sys.exc_info()[2])

		self.send_ok(_('Document model is created'))
		self.update()
Example #42
0
	def __init__(self, name=_("GuideLayer"),
					visible=1, printable=0, locked=0,
					outlined=0, outline_color=sk_const.default_layer_color):
		self.name = name
		self.visible = visible
		self.printable = printable
		self.locked = locked
		self.outlined = outlined
		self.layer_color = outline_color
		SKModelObject.__init__(self)
Example #43
0
    def close(self):
        filename = self.doc_file
        self.doc_file = ''
        if self.model is not None:
            self.model.destroy()
        self.model = None
        model_name = uc2const.FORMAT_NAMES[self.cid]
        self.send_ok(_('<%s> document model is destroyed for %s') %
                     (model_name, filename))

        if self.doc_dir and fsutils.exists(self.doc_dir):
            try:
                fs.xremove_dir(self.doc_dir)
                self.send_ok(_('Cache is cleared for') + ' %s' % filename)
            except Exception as e:
                msg = _('Cache clearing is unsuccessful')
                self.send_error(msg)
                LOG.warning(msg + ' %s', e)
                LOG.exception(e)
Example #44
0
File: load.py Project: Scrik/sk1-wx
	def Messages(self):
		messages = self.messages.items()
		list = []
		for message, count in messages:
			if count > 1:
				list.append(_("%(message)s (%(count)d times)") % locals())
			else:
				list.append(message)
		list.sort()
		return string.join(list, '\n')
Example #45
0
 def __init__(self, name=_("GuideLayer"),
              visible=1, printable=0, locked=0,
              outlined=0, outline_color=sk_const.default_layer_color):
     self.name = name
     self.visible = visible
     self.printable = printable
     self.locked = locked
     self.outlined = outlined
     self.layer_color = outline_color
     SKModelObject.__init__(self)
Example #46
0
 def Messages(self):
     messages = self.messages.items()
     list = []
     for message, count in messages:
         if count > 1:
             list.append(_("%(message)s (%(count)d times)") % locals())
         else:
             list.append(message)
     list.sort()
     return string.join(list, '\n')
Example #47
0
    def save(self, path):
        if path:
            self.doc_file = path
            try:
                self.saving_msg(0.03)
                self.send_info(_('Saving is started...'))
                self.saver.save(self, path)
            except:
                msg = _('Error while saving') + ' ' + path
                self.send_error(msg)
                raise IOError(msg, sys.exc_info()[1], sys.exc_info()[2])
        else:
            self.send_error(
                _('Error while saving:') + ' ' + _('Empty file name'))
            raise IOError(msg)

        msg = _('Document model is saved successfully')
        self.send_progress_message(msg, 0.95)
        self.send_ok(msg)
Example #48
0
	def _write_manifest(self):
		xml = os.path.join(self.presenter.doc_dir, 'META-INF', 'manifest.xml')
		try:
			self.file = open(xml, 'wb')
		except:
			errtype, value, traceback = sys.exc_info()
			msg = _('Cannot open %s file for writing') % (xml)
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(errtype, msg + '\n' + value, traceback)
		self._start()
		self.file.write('<manifest>\n')
		self._write_manifest_entries()
		self.file.write('</manifest>\n')
		self._finish()
		filename = os.path.join('META-INF', 'manifest.xml')
		self.content.append((xml, filename))

		msg = _('PDXF file manifest.xml is created')
		events.emit(events.MESSAGES, msgconst.OK, msg)
Example #49
0
    def _pack_content(self):
        pdxf_file = ZipFile(self.presenter.doc_file, 'w')
        for item in self.content:
            path, filename = item
            filename = filename.encode('ascii')
            pdxf_file.write(path, filename, zipfile.ZIP_DEFLATED)
        pdxf_file.close()

        msg = _('PDXF file is created successfully')
        events.emit(events.MESSAGES, msgconst.OK, msg)
Example #50
0
    def _write_manifest(self):
        xml = os.path.join(self.presenter.doc_dir, 'META-INF', 'manifest.xml')
        try:
            self.file = open(xml, 'wb')
        except:
            errtype, value, traceback = sys.exc_info()
            msg = _('Cannot open %s file for writing') % (xml)
            events.emit(events.MESSAGES, msgconst.ERROR, msg)
            raise IOError(errtype, msg + '\n' + value, traceback)
        self._start()
        self.file.write('<manifest>\n')
        self._write_manifest_entries()
        self.file.write('</manifest>\n')
        self._finish()
        filename = os.path.join('META-INF', 'manifest.xml')
        self.content.append((xml, filename))

        msg = _('PDXF file manifest.xml is created')
        events.emit(events.MESSAGES, msgconst.OK, msg)
Example #51
0
	def add_page(self, page_format=[]):
		parent = self.model.childs[0]
		if page_format:
			page = model.Page(self.config)
			page.page_format = deepcopy(page_format)
		else:
			page = model.Page(self.config, parent)
		parent.childs.append(page)
		parent.page_counter += 1
		page.name = _('Page') + ' %i' % (parent.page_counter)
		return page
Example #52
0
	def save(self, filename=None, fileptr=None):
		if filename:
			self.doc_file = filename
		elif not fileptr:
			msg = _('Error while saving:') + ' ' + _('No file data')
			self.send_error(msg)
			raise IOError(msg)

		try:
			self.saving_msg(0.03)
			self.send_info(_('Saving is started...'))
			self.saver.save(self, filename, fileptr)
		except:
			msg = _('Error while saving') + ' ' + filename
			self.send_error(msg)
			raise IOError(msg, sys.exc_info()[1], sys.exc_info()[2])

		msg = _('Document model is saved successfully')
		self.send_progress_message(msg, 0.95)
		self.send_ok(msg)
Example #53
0
 def add_page(self, page_format=[]):
     parent = self.model.childs[0]
     if page_format:
         page = model.Page(self.config)
         page.page_format = deepcopy(page_format)
     else:
         page = model.Page(self.config, parent)
     parent.childs.append(page)
     parent.page_counter += 1
     page.name = _('Page') + ' %i' % (parent.page_counter)
     return page
Example #54
0
 def add_page(self, page_format=[]):
     parent = self.get_pages_obj()
     if page_format:
         page = sk2_model.Page(self.config)
         page.page_format = deepcopy(page_format)
     else:
         page = sk2_model.Page(self.config, parent)
     parent.childs.append(page)
     parent.page_counter += 1
     page.name = _("Page") + " %i" % (parent.page_counter)
     return page
Example #55
0
    def load(self, path):
        if path and os.path.lexists(path):
            try:
                self.parsing_msg(0.03)
                self.send_info(_('Parsing is started...'))
                self.model = self.loader.load(self, path)
            except:
                self.close()
                raise IOError(
                    _('Error while loading') + ' ' + path,
                    sys.exc_info()[1],
                    sys.exc_info()[2])

            self.send_ok(_('Document model is created'))
            self.doc_file = path
        else:
            msg = _('Error while loading:') + ' ' + _('file doesn\'t exist')
            self.send_error(msg)
            raise IOError(msg)
        self.update()
Example #56
0
	def __init__(self, geometry=sk_const.default_grid, visible=0,
				grid_color=sk_const.default_grid_color, name=_("Grid")):
		if len(geometry) == 2:
			self.geometry = (0, 0) + geometry
		elif len(geometry) == 4:
			self.geometry = geometry
		else:
			self.geometry = sk_const.default_grid
		self.visible = visible
		self.grid_color = grid_color
		self.name = name
		SKModelObject.__init__(self)
Example #57
0
    def insert_layer(self, page, layer_name="", index=0):
        if not layer_name:
            layer_name = _("Layer") + " %i" % (page.layer_counter + 1)
        layer = sk2_model.Layer(self.config, page)
        layer.name = "" + layer_name
        if index < len(page.childs):
            page.childs.insert(index, layer)
        else:
            page.childs.append(layer)

        page.layer_counter += 1
        return layer
Example #58
0
	def save(self, presenter, path):

		try:
			file = open(path, 'wb')
		except:
			errtype, value, traceback = sys.exc_info()
			msg = _('Cannot open %s file for writing') % (path)
			events.emit(events.MESSAGES, msgconst.ERROR, msg)
			raise IOError(errtype, msg + '\n' + value, traceback)

		file.write(presenter.model.get_content())
		file.close()
Example #59
0
	def insert_layer(self, page, layer_name='', index=0):
		if not layer_name:
			layer_name = _('Layer') + ' %i' % (page.layer_counter + 1)
		layer = model.Layer(self.config, page)
		layer.name = "" + layer_name
		if index < len(page.childs):
			page.childs.insert(index, layer)
		else:
			page.childs.append(layer)

		page.layer_counter += 1
		return layer