def write(self, fp, padding=4):
written = 0
for item in self:
written += write_fmt(fp, 'H', item.selector.value)
written += item.write(fp)
written += write_padding(fp, written, padding)
return written
def write(self, fp, **kwargs):
written = write_fmt(
fp, '4s2BH', self.kind, self.is_open, self.flags,
self.optional_blocks
)
written += write_fmt(fp, '4i', *self.icon_location)
written += write_fmt(fp, '4i', *self.popup_location)
written += self.color.write(fp)
written += write_pascal_string(fp, self.author, 'macroman', padding=2)
written += write_pascal_string(fp, self.name, 'macroman', padding=2)
written += write_pascal_string(
fp, self.mod_date, 'macroman', padding=2
)
written += write_fmt(fp, 'I4s', len(self.data) + 12, self.marker)
written += write_length_block(fp, lambda f: write_bytes(f, self.data))
return written
def write(self, fp, version=1):
"""Write the element to a file-like object.
:param fp: file-like object
:param version: psd file version
"""
return write_fmt(fp, ('hI', 'hQ')[version - 1], *attr.astuple(self))
def write_length_and_key(fp, value):
"""
Helper to write descriptor key.
"""
written = write_fmt(fp, 'I', 0 if value in _TERMS else len(value))
written += write_bytes(fp, value)
return written
def write(self, fp, **kwargs):
written = write_fmt(
fp, 'BHI', self.is_map, self.version, self.count_map
)
if self.is_map:
written += sum(write_fmt(fp, '256B', *item) for item in self.data)
else:
for points in self.data:
written += write_fmt(fp, 'H', len(points))
written += sum(write_fmt(fp, '2H', *item) for item in points)
if self.extra is not None:
written += self.extra.write(fp)
written += write_padding(fp, written, 4)
return written
def write(self, fp):
written = 0
written += write_fmt(
fp, 'B', ((1 if self.user_mask_density is not None else 0) |
(2 if self.user_mask_feather is not None else 0) |
(4 if self.vector_mask_density is not None else 0) |
(8 if self.vector_mask_feather is not None else 0)))
if self.user_mask_density is not None:
written += write_fmt(fp, 'B', self.user_mask_density)
if self.user_mask_feather is not None:
written += write_fmt(fp, 'd', self.user_mask_feather)
if self.vector_mask_density is not None:
written += write_fmt(fp, 'B', self.vector_mask_density)
if self.vector_mask_feather is not None:
written += write_fmt(fp, 'd', self.vector_mask_feather)
return written
def write(self, fp, **kwargs):
written = write_fmt(fp, 'I', self.version)
for item in self:
written += write_length_block(fp,
lambda f: item.write(f),
fmt='Q',
padding=4)
return written
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
"""
written = write_fmt(fp, 'I', self.items_count)
written += self._write_body(fp)
return written
def write(self, fp, padding=1, **kwargs):
written = write_fmt(fp, '4sI', self.kind.value, self.version)
written += write_pascal_string(fp, self.uuid, 'macroman', padding=1)
written += write_unicode_string(fp, self.filename)
written += write_fmt(fp, '4s4sQB', self.filetype, self.creator,
len(self.data) if self.data is not None else 0,
self.open_file is not None)
if self.open_file is not None:
written += self.open_file.write(fp, padding=1)
if self.kind == LinkedLayerType.EXTERNAL:
written += self.linked_file.write(fp, padding=1)
if self.version > 3:
written += write_fmt(fp, 'I4Bd', *self.timestamp)
written += write_fmt(fp, 'Q', self.filesize)
if self.version > 2:
written += write_bytes(fp, self.data)
elif self.kind == LinkedLayerType.ALIAS:
written += write_fmt(fp, '8x')
if self.kind == LinkedLayerType.DATA:
written += write_bytes(fp, self.data)
if self.child_id is not None:
written += write_unicode_string(fp, self.child_id)
if self.mod_time is not None:
written += write_fmt(fp, 'd', self.mod_time)
if self.lock_state is not None:
written += write_fmt(fp, 'B', self.lock_state)
if self.kind == LinkedLayerType.EXTERNAL and self.version == 2:
written += write_bytes(fp, self.data)
written += write_padding(fp, written, padding)
return written
def write(self, fp):
written = write_fmt(
fp, '3I', self.slice_id, self.group_id, self.origin
)
if self.origin == 1 and self.associated_id is not None:
written += write_fmt(fp, 'I', self.associated_id)
written += write_unicode_string(fp, self.name, padding=1)
written += write_fmt(fp, 'I', self.slice_type)
written += write_fmt(fp, '4I', *self.bbox)
written += write_unicode_string(fp, self.url, padding=1)
written += write_unicode_string(fp, self.target, padding=1)
written += write_unicode_string(fp, self.message, padding=1)
written += write_unicode_string(fp, self.alt_tag, padding=1)
written += write_fmt(fp, '?', self.cell_is_html)
written += write_unicode_string(fp, self.cell_text, padding=1)
written += write_fmt(
fp, '2I', self.horizontal_align, self.vertical_align
)
written += write_fmt(
fp, '4B', self.alpha, self.red, self.green, self.blue
)
if self.data is not None:
if hasattr(self.data, 'write'):
written += self.data.write(fp, padding=1)
elif self.data:
written += write_bytes(fp, self.data)
return written
def _write_body(self, fp):
written = write_fmt(fp, '4iB', self.top, self.left, self.bottom, self.right, self.background_color)
written += self.flags.write(fp)
# if self.real_flags is None and self.parameters is None:
# written += write_fmt(fp, '2x')
# assert written == 20
if self.real_flags:
written += self.real_flags.write(fp)
written += write_fmt(fp, 'B4i', self.real_background_color, self.real_top, self.real_left, self.real_bottom,
self.real_right)
if self.flags.parameters_applied and self.parameters:
written += self.parameters.write(fp)
written += write_padding(fp, written, 4)
return written
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
"""
flags = ((self.pos_relative_to_layer * 1) | (self.mask_disabled * 2) | (self.invert_mask * 4) |
(self.user_mask_from_render * 8) | (self.parameters_applied * 16) | (self.undocumented_1 * 32) |
(self.undocumented_2 * 64) | (self.undocumented_3 * 128))
return write_fmt(fp, 'B', flags)
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
"""
flags = ((self.transparency_protected * 1) | ((not self.visible) * 2) | (self.obsolete * 4) |
(self.photoshop_v5_later * 8) | (self.pixel_data_irrelevant * 16) | (self.undocumented_1 * 32) |
(self.undocumented_2 * 64) | (self.undocumented_3 * 128))
return write_fmt(fp, 'B', flags)
def write(self, fp, **kwargs):
"""Write the element to a file-like object.
:param fp: file-like object
"""
written = write_fmt(fp, 'H', self.compression.value)
written += write_bytes(fp, self.data)
# written += write_padding(fp, written, 2) # Seems no padding here.
return written
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
"""
written = write_unicode_string(fp, self.name)
written += write_length_and_key(fp, self.classID)
written += write_fmt(fp, 'I', self.value)
return written
def _write_body(self, fp):
written = write_unicode_string(fp, self.name, padding=1)
written += write_length_and_key(fp, self.classID)
written += write_fmt(fp, 'I', len(self))
for key in self:
written += write_length_and_key(fp, key)
written += write_bytes(fp, self[key].ostype.value)
written += self[key].write(fp)
return written
def write(self, fp, encoding='macroman', version=1):
start_pos = fp.tell()
written = write_fmt(fp, '4iH', self.top, self.left, self.bottom,
self.right, len(self.channel_info))
written += sum(c.write(fp, version) for c in self.channel_info)
written += write_fmt(fp, '4s4sBB', self.signature,
self.blend_mode.value, self.opacity,
self.clipping.value)
written += self.flags.write(fp)
def writer(f):
written = self._write_extra(f, encoding, version)
logger.debug(' wrote layer record, len=%d' %
(fp.tell() - start_pos))
return written
written += write_length_block(fp, writer, fmt='xI')
return written
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
"""
written = write_fmt(fp, 'I', len(self))
for item in self:
written += write_bytes(fp, item.ostype.value)
written += item.write(fp)
return written
def write(self, fp, encoding='macroman', version=1, padding=4):
def writer(f):
written = self._write_body(f, encoding, version, padding)
logger.debug('writing layer info, len=%d' % (written))
return written
fmt = ('I', 'Q')[version - 1]
if self.layer_count == 0:
return write_fmt(fp, fmt, 0)
return write_length_block(fp, writer, fmt=fmt)
def write(self, fp):
written = write_fmt(
fp, 'Ii2I', self.version, self.angle, self.depth, self.blur
)
written += write_fmt(
fp, '4s4s4s4s', b'8BIM', self.highlight_blend_mode.value, b'8BIM',
self.shadow_blend_mode.value
)
written += self.highlight_color.write(fp)
written += self.shadow_color.write(fp)
written += write_fmt(
fp, '6B', self.bevel_style, self.highlight_opacity,
self.shadow_opacity, self.enabled, self.use_global_angle,
self.direction
)
if self.version >= 2:
written += self.highlight_color.write(fp)
written += self.shadow_color.write(fp)
return written
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
"""
written = 0
written += write_fmt(
fp, 'B',
((1 if self.user_mask_density is not None else 0) | (2 if self.user_mask_feather is not None else 0) |
(4 if self.vector_mask_density is not None else 0) | (8 if self.vector_mask_feather is not None else 0)))
if self.user_mask_density is not None:
written += write_fmt(fp, 'B', self.user_mask_density)
if self.user_mask_feather is not None:
written += write_fmt(fp, 'd', self.user_mask_feather)
if self.vector_mask_density is not None:
written += write_fmt(fp, 'B', self.vector_mask_density)
if self.vector_mask_feather is not None:
written += write_fmt(fp, 'd', self.vector_mask_feather)
return written
def write(self, fp):
"""Write the element to a file-like object.
:param fp: file-like object
:rtype: int
"""
start_pos = fp.tell()
written = write_fmt(fp, 'H', self.compression.value)
written += write_bytes(fp, self.data)
logger.debug(' wrote image data, len=%d' % (fp.tell() - start_pos))
return written
def _write_extra(self, fp, encoding, version):
written = 0
if self.mask_data:
written += self.mask_data.write(fp)
else:
written += write_fmt(fp, 'I', 0)
written += self.blending_ranges.write(fp)
written += write_pascal_string(fp, self.name, encoding, padding=4)
written += self.tagged_blocks.write(fp, version, padding=1)
written += write_padding(fp, written, 2)
return written
def _write_body(self, fp, encoding, version, padding):
start_pos = fp.tell()
written = write_fmt(fp, 'h', self.layer_count)
if self.layer_records:
self._update_channel_length()
written += self.layer_records.write(fp, encoding, version)
logger.debug(' wrote layer records, len=%d' % (fp.tell() - start_pos))
if self.channel_image_data:
written += self.channel_image_data.write(fp)
# Seems the padding size here is different between Photoshop and GIMP.
written += write_padding(fp, written, padding)
return written
def write(self, fp, **kwargs):
written = write_pascal_string(fp, self.uuid, encoding='ascii', padding=1)
written += write_fmt(fp, 'I', self.version)
def writer(f):
return self._write_body(f)
written += write_length_block(fp, writer, fmt='Q')
if self.extra is not None:
written += self.extra.write(fp)
return written
def write(self, fp, encoding='macroman'):
written = write_fmt(fp, '4sH', self.signature,
getattr(self.key, 'value', self.key))
written += write_pascal_string(fp, self.name, encoding, 2)
def writer(f):
if hasattr(self.data, 'write'):
return self.data.write(f, padding=1)
return write_bytes(f, self.data)
written += write_length_block(fp, writer, padding=2)
return written
def write(self, fp, **kwargs):
written = write_fmt(fp, '4s4s?3x', self.signature, self.key,
self.copy_on_sheet)
def writer(f):
if hasattr(self.data, 'write'):
return self.data.write(f, padding=4)
elif isinstance(self.data, int):
return write_fmt(fp, 'I', self.data)
return write_bytes(f, self.data)
written += write_length_block(fp, writer)
return written
def write(self, fp, **kwargs):
written = write_fmt(fp, 'I', self.is_written)
if self.is_written == 0:
return written
def writer(f):
if self.compression is None:
return 0
length = write_fmt(f, 'H', self.compression)
length += write_bytes(f, self.data)
return length
written += write_length_block(fp, writer, fmt='Q')
return written
def write(self, fp, encoding='macroman', version=1, padding=4):
"""Write the element to a file-like object.
:param fp: file-like object
:rtype: int
"""
def writer(f):
written = self._write_body(f, encoding, version, padding)
logger.debug('writing layer info, len=%d' % (written))
return written
fmt = ('I', 'Q')[version - 1]
if self.layer_count == 0:
return write_fmt(fp, fmt, 0)
return write_length_block(fp, writer, fmt=fmt)
def write(self, fp, version=1, padding=1):
key = self.key if isinstance(self.key, bytes) else self.key.value
written = write_fmt(fp, '4s4s', self.signature, key)
def writer(f):
if hasattr(self.data, 'write'):
# It seems padding size applies at the block level here.
inner_padding = 1 if padding == 4 else 4
return self.data.write(f, padding=inner_padding,
version=version)
return write_bytes(f, self.data)
fmt = self._length_format(self.key, version)
written += write_length_block(fp, writer, fmt=fmt, padding=padding)
return written
