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)

	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)

	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

	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'))

	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

 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

	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

	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)

	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)

	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))

	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]

 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]

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

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

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 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)

	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()

	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)

	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)

	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()