def indexprec(self, size):
bits = self.Int()
if bits in (8, 16, 24, 32):
reff.inxsize = (bits / 8)
reff.inxprec = reff.inxsize - 1
else:
raise SketchLoadError("This implementation can't work with %d bit indices" % (bits,))
def interpret(self, sz):
tell = self.file.tell
Id = -1
pos = tell()
start = pos
while Id != 0x40 and pos < start + sz:
head = self.u16()
Id = head & 0xffe0
size = head & 0x001f
hdsz = 2
if size == 31:
size = self.u16()
hdsz = 4
pdsz = ((size + 1) / 2) * 2
self._print(20 , '%4x at %5d) %5d(%5d): %4x: %s' , head, pos, size, pdsz, Id, CGM_ID.get(Id, ''))
if hasattr(self, CGM_ID.get(Id, '')):
self._print(30 , 'Calling %s' % (CGM_ID.get(Id, '')))
getattr(self, CGM_ID[Id])(size)
else:
if Id:
self.file.read(pdsz)
name = CGM_ID.get(Id, '')
Class = Id >> 12
Elem = (Id & 0x0fff) >> 5
self._print(2, '*** unimplemented: %4x; class = %d, element = %2d %s'
, Id , Class , Elem, name)
pos = pos + hdsz + pdsz
if tell() < pos:
self.file.read(pos - tell())
elif tell() > pos:
self._print(2, 'read too many bytes')
self.file.seek(pos - tell(), 1)
if pos != tell():
raise SketchLoadError("Lost position in File")
def realprec(self, size):
type = self.Enum()
prec = (self.Int(), self.Int())
if type == 1:
if prec == (16, 16):
reff.realprec = 0# 32 bit fixed precision
elif prec == (32, 32):
reff.realprec = 1# 64 bit fixed precision
else:
raise SketchLoadError("This implementation can't work with %d,%d bit fixed points" % prec)
else:
if prec == (9, 23):
reff.realprec = 2# 32 bit floating point
elif prec == (12, 52):
reff.realprec = 3# 64 bit floating point
else:
raise SketchLoadError("This implementation can't work with %d,%d bit floatingpoints" % prec)
def vdcintegerprec(self, size):
bits = self.Int()
if bits in (8, 16, 24, 32):
reff.vdc.intsize = (bits / 8)
reff.vdc.intprec = reff.vdc.intsize - 1
if reff.vdc.type == 0:
reff.vdc.size = reff.vdc.intsize
reff.vdc.prec = reff.vdc.intprec
else:
raise SketchLoadError("This implementation can't work with %d bit integers" % (bits,))
def colrindexprec(self, size):
bits = self.Int()
if bits == 8:
reff.color.inxstruct = "!B"
elif bits == 16:
reff.color.inxstruct = "!H"
elif bits == 32:
reff.color.inxstruct = "!I"
else:
raise SketchLoadError("This implementation can't work with %d bit color indices" % (bits,))
def colrprec(self, size):
bits = self.Int()
if bits == 8:
reff.color.absstruct = "!BBB"
elif bits == 16:
reff.color.absstruct = "!HHH"
elif bits == 32:
reff.color.absstruct = "!III"
else:
raise SketchLoadError("This implementation can't work with %d bit color components" % (bits,))
def Load(self):
try:
self.file.seek(0)
cdr = RiffChunk()
cdr.load(self.file.read())
app.updateInfo(inf2=_("Parsing is finished"),inf3=10)
self.document()
if self.verbosity:
text=''
if cdr.infocollector.cdr_version>0:
text+='CorelDRAW ver.%u'%cdr.infocollector.cdr_version+' \n'
text+=' Pages: %u'%(cdr.infocollector.pages-1)+'\n'
text+=' Layers: %u'%(cdr.infocollector.layers/cdr.infocollector.pages)+'\n'
text+=' Groups: %u'%cdr.infocollector.groups+'\n'
text+=' Objects: %u'%cdr.infocollector.objects+'\n'
text+=' Bitmaps: %u'%cdr.infocollector.bitmaps+'\n'
if cdr.infocollector.compression:
text+=' COMPRESSED'
sys.stderr.write(text)
if cdr.infocollector.cdr_version>6:
self.info=cdr.infocollector
self.info.loader=self
self.info.process_properties()
self.import_curves()
else:
warn(USER, 'File <'+self.filename+
'> contains usupported CorelDRAW ver.%u'%cdr.infocollector.cdr_version+'.0 drawing')
self.end_all()
self.object.load_Completed()
self.object.pages.remove(self.object.pages[-1])
self.object.pages.reverse()
self.object.active_page=len(self.object.pages)-1
self.object.setActivePage(0)
return self.object
except RiffEOF:
raise SketchLoadError(_("Unexpected problems in file parsing"))
except:
import traceback
traceback.print_exc()
raise
def Load(self):
doc = None
if self.ext.upper() == '.DST':
loader = DSTLoader(self.file, self.filename, self.match)
doc = loader.Load()
elif self.ext.upper() == '.PES':
loader = PESLoader(self.file, self.filename, self.match)
doc = loader.Load()
elif self.ext.upper() == '.EXP':
loader = EXPLoader(self.file, self.filename, self.match)
doc = loader.Load()
elif self.ext.upper() == '.PCS':
loader = PCSLoader(self.file, self.filename, self.match)
doc = loader.Load()
else:
raise SketchLoadError(_("unrecognised file type"))
return doc
def read_headers(self):
self.file.seek(0)
placeable = self.file.read(calcsize(struct_placeable_header))
key, handle, left, top, right, bottom, inch, reserved, checksum\
= unpack(struct_placeable_header, placeable)
if key != rx_magic:
raise SketchLoadError(
_("The file is not a placeable "
"windows metafile"))
self._print("The file is not a placeable windows metafile")
sum = 0
for word in unpack('<10h', placeable[:20]):
sum = sum ^ word
if sum != checksum:
#raise SketchLoadError(_("The file has an incorrect checksum"))
self._print("The file has an incorrect checksum")
self.inch = inch
self.bbox = (left, top, right, bottom)
factor = 72.0 / self.inch
self.wx = self.wy = 0
self.wwidth = right - left
self.wheight = bottom - top
self.vx = self.vy = 0
self.vwidth = self.wwidth
self.vheight = self.wheight
self.base_trafo = Trafo(factor, 0, 0, -factor, 0,
factor * self.vheight)
self.update_trafo()
header = self.file.read(calcsize(struct_wmf_header))
filetype, headersize, version, filesize, numobj, maxrecord, numparams\
= unpack(struct_wmf_header, header)
self._print('\nHeader\n------\n')
fmt = '% 10s: %s\n'
self._print(fmt, 'inch', self.inch)
self._print(fmt, 'bbox', self.bbox)
self._print(fmt, 'headersize', headersize)
self._print(fmt, 'version', version)
self._print(fmt, 'numobj', numobj)
self._print(fmt, 'numparams', numparams)
self._print(fmt, 'maxrecord', maxrecord)
self._print('\n')
def mfversion(self, size):
if self.u16() != 1:
raise SketchLoadError("Can only load CGM version 1")
class CDRLoader(GenericLoader):
def __init__(self, file, filename, match):
GenericLoader.__init__(self, file, filename, match)
self.fix_tile = None
self.fix_clip = 0
self.fix_lens = ()
self.object = None
self.filename = filename
self.verbosity = False
self.info = None
self.file = file
def Load(self):
try:
self.file.seek(0)
cdr = RiffChunk()
cdr.load(self.file.read())
app.updateInfo(inf2=_("Parsing is finished"), inf3=10)
summary = [
('CDR version', cdr.infocollector.cdr_version),
('pages', cdr.infocollector.pages - 1),
('layers', cdr.infocollector.layers / cdr.infocollector.pages),
('groups', cdr.infocollector.groups),
('objects', cdr.infocollector.objects),
('bitmaps', cdr.infocollector.bitmaps),
]
if cdr.infocollector.compression:
summary.append(('compression', 'yes'))
else:
summary.append(('compression', 'no'))
if self.filename == None:
return
from xml.sax.saxutils import XMLGenerator
try:
file = open(self.filename, 'w')
except (IOError, os.error), value:
import sys
sys.stderr('cannot write parsing result into %s: %s' %
( ` filename `, value[1]))
return
writer = XMLGenerator(out=file, encoding='utf-8')
writer.startDocument()
writer.startElement('riffDocument', {})
writer.characters('\n')
writer.startElement('docSummary', {})
writer.characters('\n')
for key, value in summary:
writer.characters('\t')
writer.startElement('%s' % key, {})
writer.characters('%s' % ` value `)
writer.endElement('%s' % key)
writer.characters('\n')
writer.endElement('docSummary')
writer.characters('\n')
writer.startElement('docStructure', {})
writer.characters('\n')
if cdr.infocollector.cdr_version > 6:
self.info = cdr.infocollector
self.info.loader = self
self.info.process_properties()
self.import_curves(writer)
else:
writer.characters('\t')
writer.startElement('info', {})
value = 'Parsed file contains usupported CorelDRAW ver.%u' % cdr.infocollector.cdr_version + '.0 drawing'
writer.characters('%s' % ` value `)
writer.endElement('info')
writer.characters('\n')
except RiffEOF:
writer.characters('\t')
writer.startElement('info', {})
writer.characters('Unexpected problems in file parsing')
writer.endElement('info')
writer.characters('\n')
raise SketchLoadError(_("Unexpected problems in file parsing"))