def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.width = stream.read_double('width')
self.type = stream.read_int('type', expected=(0, 1, 2))
self.quality = stream.read_double('quality')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
def read(self, stream: Stream, version):
self.symbol_level = SymbolLayer.read_symbol_level(stream)
# consume unused properties - MultiLayerMarkerSymbol implements IMarkerSymbol
# so that the size/offsets/angle are required properties. But they aren't used
# or exposed anywhere for MultiLayerMarkerSymbol
_ = stream.read_double('unused marker size')
_ = stream.read_double('unused marker x/y/offset or angle')
_ = stream.read_double('unused marker x/y/offset or angle')
_ = stream.read_double('unused marker x/y/offset or angle')
_ = stream.read_object('unused color')
self.halo = stream.read_int() == 1
self.halo_size = stream.read_double('halo size')
self.halo_symbol = stream.read_object('halo')
# useful stuff
number_layers = stream.read_int('layers')
for i in range(number_layers):
layer = stream.read_object('symbol layer {}/{}'.format(i + 1, number_layers))
self.layers.extend([layer])
for l in self.layers:
l.read_enabled(stream)
for l in self.layers:
l.read_locked(stream)
if version > 1:
_ = stream.read_double('unknown size')
_ = stream.read_double('unknown size')
if version >= 3:
for l in self.layers:
l.read_tags(stream)
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.width = stream.read_double('width')
self.line_type = self.read_line_type(stream)
stream.log('read line type of {}'.format(self.line_type))
self.symbol_level = SymbolLayer.read_symbol_level(stream)
def run_symbol_checks(self, path):
"""
Checks all bin symbols against expectations
"""
blobs = []
for fn in os.listdir(path):
file = os.path.join(path, fn)
if os.path.isfile(file):
blobs.append(file)
for file in blobs:
print(file)
group, symbol_name = os.path.split(file)
path, group = os.path.split(group)
with open(file, 'rb') as f:
expected_symbol = expected[group][symbol_name]
if 'skip' in expected_symbol:
continue
stream = Stream(f, debug=False)
color = stream.read_object()
self.assertEqual(expected_symbol['color'], color.to_dict())
def read_symbol_level(stream: Stream):
"""
Reads the symbol level from the stream
"""
# actually raster op
assert stream.read_int('terminator') == 13
# symbol level of 0xffffffff = merge and join
return stream.read_int('symbol level')
def read_symbol(_io_stream):
"""
Reads a symbol from the specified file
"""
stream = Stream(_io_stream, False, tolerant=False)
res = stream.read_object('symbol')
assert stream.tell() == stream.end, (stream.tell, stream.end)
return res
def read(self, stream: Stream, version):
"""
Reads the decoration information
"""
# next bit is probably number of decorations?
count = stream.read_uint('count of decorations')
for i in range(count):
decoration = stream.read_object('decoration element {}/{}'.format(i, count))
self.decorations.append(decoration)
def check_handle(self, file_handle):
try:
stream = Stream(file_handle)
o = stream.read_object()
if o is not None:
return PersistentMatch(file_handle.tell() - 1, 1, o)
else:
return None
except: # nopep8, pylint: disable=bare-except
pass
return None
def check_handle(self, file_handle):
try:
start = file_handle.tell()
stream = Stream(file_handle)
color = stream.read_object()
if issubclass(color.__class__, Color):
return ColorMatch(start, file_handle.tell() - start, color.color_model, color)
else:
return None
except: # nopep8, pylint: disable=bare-except
pass
return None
def read(self, stream: Stream, version):
self.texture = stream.read_object('texture')
self.color = stream.read_object('color')
self.transparency_color = stream.read_object('transparency color')
self.outline = stream.read_object('outline')
self.angle = stream.read_double('angle')
self.size = stream.read_double('size')
stream.read_int('raster op', expected=13)
self.symbol_level = stream.read_int('level')
def open_lyr(input_file):
"""
Opens a LYR file in the current project
"""
with open(input_file, 'rb') as f:
stream = Stream(f, False, force_layer=True)
return LyrDropHandler.open_lyr_stream(stream, input_file)
def read(self, stream: Stream, version):
self.symbol_level = SymbolLayer.read_symbol_level(stream)
number_layers = stream.read_uint('layer count')
for i in range(number_layers):
layer = stream.read_object('symbol layer {}/{}'.format(i + 1, number_layers))
self.layers.extend([layer])
for l in self.layers:
l.read_enabled(stream)
for l in self.layers:
l.read_locked(stream)
if version >= 2:
for l in self.layers:
l.read_tags(stream)
def read_line_type(stream: Stream):
"""
Interprets the line type bytes
"""
line_type = stream.read_uint()
types = {
0: 'solid',
1: 'dashed',
2: 'dotted',
3: 'dash dot',
4: 'dash dot dot',
5: 'null'
}
if line_type not in types:
raise UnreadableSymbolException(
'unknown line type {} at {}'.format(line_type,
hex(stream.tell() - 4)))
return types[line_type]
def check_handle(self, file_handle):
try:
start = file_handle.tell()
string_value = Stream(file_handle).read_string()
if string_value and StringScan.strip_non_ascii(string_value) == string_value:
return StringMatch(start, file_handle.tell() - start, string_value)
except: # nopep8, pylint: disable=bare-except
pass
return None
def read(self, stream: Stream, version):
self.cap = self.read_cap(stream)
self.join = self.read_join(stream)
self.width = stream.read_double('width')
self.flip = stream.read_uchar('flip') != 0
self.offset = stream.read_double('offset')
self.color = stream.read_object('color')
self.template = stream.read_object('template')
self.decoration = stream.read_object('decoration')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.decoration_on_top = stream.read_uchar('decoration on top') != 0
self.line_start_offset = stream.read_double('line start offset')
self.miter_limit = stream.read_double('miter limit')
def read_join(stream: Stream):
"""
Reads a line join style from the stream
"""
join_bin = stream.read_int('join')
if join_bin == 0:
return 'miter'
elif join_bin == 1:
return 'round'
elif join_bin == 2:
return 'bevel'
else:
raise UnreadableSymbolException('unknown join style {}'.format(join_bin))
def read_cap(stream: Stream):
"""
Reads a line cap style from the stream
"""
cap_bin = stream.read_int('cap')
if cap_bin == 0:
return 'butt'
elif cap_bin == 1:
return 'round'
elif cap_bin == 2:
return 'square'
else:
raise UnreadableSymbolException('unknown cap style {}'.format(cap_bin))
def read(self, stream: Stream, version):
self.ramp = stream.read_object('Color ramp')
self.fill_color = stream.read_object('fill color')
# either an entire LineSymbol or just a LineSymbolLayer
self.outline = stream.read_object('outline')
self.percent = stream.read_double('percent')
self.intervals = stream.read_uint('intervals')
self.angle = stream.read_double('angle')
self.type = stream.read_uint('Gradient type')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.size = stream.read_double('size')
self.width = stream.read_double('width')
self.angle = stream.read_double('angle')
self.style = stream.read_uint('style')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.rotate_with_transform = stream.read_ushort('rotate with transform') != 0
def read(self, stream: Stream, version):
self.random = bool(stream.read_int('random'))
self.offset_x = stream.read_double('offset x')
self.offset_y = stream.read_double('offset y')
self.separation_x = stream.read_double('separation x')
self.separation_y = stream.read_double('separation y')
_ = stream.read_double('unused double')
_ = stream.read_double('unused double')
self.marker = stream.read_object('fill marker')
# either an entire LineSymbol or just a LineSymbolLayer
self.outline = stream.read_object('outline')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.grid_angle = stream.read_double('grid angle')
def read(self, stream: Stream, version):
_ = stream.read_double('unused double')
_ = stream.read_double('unused double')
self.line = stream.read_object('pattern line')
# either an entire LineSymbol or just a LineSymbolLayer
self.outline = stream.read_object('outline')
self.angle = stream.read_double('angle')
self.offset = stream.read_double('offset')
self.separation = stream.read_double('separation')
self.symbol_level = SymbolLayer.read_symbol_level(stream)
def read(self, stream: Stream, version):
self.pattern_interval = stream.read_double('pattern interval')
pattern_part_count = stream.read_int('pattern parts')
self.pattern_parts = []
for p in range(pattern_part_count):
filled_squares = stream.read_double()
empty_squares = stream.read_double()
self.pattern_parts.append([filled_squares, empty_squares])
pattern = ''
for p in self.pattern_parts:
pattern += '-' * int(p[0]) + '.' * int(p[1])
stream.log('deciphered line pattern {} ending'.format(pattern))
def read(self, stream: Stream, version):
version = binascii.hexlify(stream.read(1))
if version != b'01':
raise UnsupportedVersionException(
'Unsupported Font version {}'.format(version))
self.charset = stream.read_ushort('charset')
# Not exposed in ArcMap front end:
attributes = stream.read_uchar('attributes')
self.italic = bool(attributes & self.Italic)
self.underline = bool(attributes & self.Underline)
self.strikethrough = bool(attributes & self.Strikethrough)
self.weight = stream.read_ushort('weight')
# From https://docs.microsoft.com/en-us/windows/desktop/api/olectl/ns-olectl-tagfontdesc
# Use the int64 member of the CY structure and scale your font size (in points) by 10000.
self.size = stream.read_int('font size') / 10000
name_length = stream.read_uchar('font name size')
self.font_name = stream.read(name_length).decode(
Font.CHARSET_MAP[self.charset])
def read(self, stream: Stream, version):
"""
Reads the decoration information
"""
self.fixed_angle = not bool(stream.read_uchar())
stream.log('detected {}'.format(
'fixed angle' if self.fixed_angle else 'not fixed angle'))
self.flip_first = bool(stream.read_uchar())
stream.log('detected {}'.format(
'flip first' if self.flip_first else 'no flip first'))
self.flip_all = bool(stream.read_uchar())
stream.log('detected {}'.format(
'flip all' if self.flip_all else 'no flip all'))
self.position_as_ratio = stream.read_ushort('position as ratio') != 0
self.marker = stream.read_object('marker')
# next bit is the number of doubles coming next
marker_number_positions = stream.read_uint('marker positions')
# next bit is the positions themselves -- maybe we can infer this from the number of positions
# alone. E.g. 2 positions = 0, 1. 3 positions = 0, 0.5, 1
for _ in range(marker_number_positions):
self.marker_positions.append(stream.read_double())
stream.log('marker positions are {}'.format(self.marker_positions))
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.unicode = stream.read_int('unicode')
self.units = stream.read_int('units')
self.angle = stream.read_double('angle')
self.size = stream.read_double('size')
self.depth = stream.read_double('depth')
self.normalized_origin_x = stream.read_double('normalized origin x')
self.normalized_origin_y = stream.read_double('normalized origin y')
self.normalized_origin_z = stream.read_double('normalized origin z')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.z_offset = stream.read_double('z offset')
self.font = stream.read_object('font')
self.read_symbol_level(stream)
stream.read_ushort('unknown', expected=65535)
self.character_marker_symbol = stream.read_object('character marker')
self.vertical_orientation = stream.read_uchar(
'vertical orientation') != 0
self.x_rotation = stream.read_double('x rotation')
self.y_rotation = stream.read_double('y rotation')
self.width = stream.read_double('width')
self.maintain_aspect_ratio = stream.read_ushort(
'maintain aspect ratio') != 0
self.billboard_display = stream.read_ushort('billboard display') != 0
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.size_z = stream.read_double('size z')
self.type = stream.read_int('type', expected=(0, 1, 2, 3, 4, 5, 6))
self.quality = stream.read_double('quality') # 0->1
self.symbol_level = SymbolLayer.read_symbol_level(stream)
self.z_rotation = stream.read_double('z rotation')
self.x_offset = stream.read_double('x offset')
self.y_offset = stream.read_double('y offset')
self.z_offset = stream.read_double('z offset')
stream.read_ushort('unknown', expected=65535)
self.dx = stream.read_double('dx')
self.dy = stream.read_double('dy')
self.dz = stream.read_double('dz')
self.x_rotation = stream.read_double('x rotation')
self.y_rotation = stream.read_double('y rotation')
self.width = stream.read_double('width')
self.depth_y = stream.read_double('depth y')
self.keep_aspect_ratio = stream.read_ushort('keep aspect ratio') != 0
self.billboard_display = stream.read_ushort('display front face') != 0
def read(self, stream: Stream, version):
stream.read_uchar('unknown', expected=0)
self.offset = stream.read_double('offset')
self.width = stream.read_double('width')
self.fill_symbol = stream.read_object('fill symbol')
def open_style(input_file): # pylint: disable=too-many-locals,too-many-branches,too-many-statements
"""
Opens a .style file
"""
if not Extractor.is_mdb_tools_binary_available():
bar = iface.messageBar()
widget = bar.createMessage('SLYR', "MDB Tools utility not found")
settings_button = QPushButton("Configure…", pressed=partial(open_settings, widget))
widget.layout().addWidget(settings_button)
bar.pushWidget(widget, Qgis.Critical)
return True
style = QgsStyle()
style.createMemoryDatabase()
symbol_names = set()
def make_name_unique(name):
"""
Ensures that the symbol name is unique (in a case insensitive way)
"""
counter = 0
candidate = name
while candidate.lower() in symbol_names:
# make name unique
if counter == 0:
candidate += '_1'
else:
candidate = candidate[:candidate.rfind('_') + 1] + str(counter)
counter += 1
symbol_names.add(candidate.lower())
return candidate
feedback = QgsFeedback()
progress_dialog = QProgressDialog("Loading style database…", "Abort", 0, 100, None)
progress_dialog.setWindowTitle("Loading Style")
def progress_changed(progress):
"""
Handles feedback to progress dialog bridge
"""
progress_dialog.setValue(progress)
iters = 0
while QCoreApplication.hasPendingEvents() and iters < 100:
QCoreApplication.processEvents()
iters += 1
feedback.progressChanged.connect(progress_changed)
def cancel():
"""
Slot to cancel the import
"""
feedback.cancel()
progress_dialog.canceled.connect(cancel)
unreadable = []
warnings = set()
errors = set()
types_to_extract = [Extractor.FILL_SYMBOLS, Extractor.LINE_SYMBOLS, Extractor.MARKER_SYMBOLS,
Extractor.COLOR_RAMPS,
Extractor.TEXT_SYMBOLS, Extractor.LABELS, Extractor.MAPLEX_LABELS, Extractor.AREA_PATCHES,
Extractor.LINE_PATCHES]
type_percent = 100 / len(types_to_extract)
for type_index, symbol_type in enumerate(types_to_extract):
try:
raw_symbols = Extractor.extract_styles(input_file, symbol_type)
except MissingBinaryException:
show_warning('MDB Tools utility not found', 'Convert style',
'The MDB tools "mdb-export" utility is required to convert .style databases. Please setup a path to the MDB tools utility in the SLYR options panel.',
level=Qgis.Critical)
progress_dialog.deleteLater()
return True
if feedback.isCanceled():
break
for index, raw_symbol in enumerate(raw_symbols):
feedback.setProgress(index / len(raw_symbols) * type_percent + type_percent * type_index)
if feedback.isCanceled():
break
name = raw_symbol[Extractor.NAME]
tags = raw_symbol[Extractor.TAGS].split(';')
if symbol_type in (
Extractor.AREA_PATCHES, Extractor.LINE_PATCHES, Extractor.TEXT_SYMBOLS, Extractor.MAPLEX_LABELS,
Extractor.LABELS):
if symbol_type == Extractor.AREA_PATCHES:
type_string = 'area patches'
elif symbol_type == Extractor.LINE_PATCHES:
type_string = 'line patches'
elif symbol_type == Extractor.TEXT_SYMBOLS:
type_string = 'text symbols'
elif symbol_type == Extractor.MAPLEX_LABELS:
type_string = 'maplex labels'
elif symbol_type == Extractor.LABELS:
type_string = 'labels'
else:
type_string = ''
unreadable.append('<b>{}</b>: {} conversion requires a licensed version of the SLYR plugin'.format(
html.escape(name), type_string))
continue
unique_name = make_name_unique(name)
handle = BytesIO(raw_symbol[Extractor.BLOB])
stream = Stream(handle)
stream.allow_shortcuts = False
try:
symbol = stream.read_object()
except UnreadableSymbolException as e:
e = 'Unreadable object: {}'.format(e)
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
except NotImplementedException as e:
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
except UnsupportedVersionException as e:
e = 'Unsupported version: {}'.format(e)
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
except UnknownClsidException as e:
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
except UnreadablePictureException as e:
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
context = Context()
context.symbol_name = unique_name
def unsupported_object_callback(msg, level=Context.WARNING):
if level == Context.WARNING:
warnings.add('<b>{}</b>: {}'.format(html.escape(unique_name), html.escape(msg)))
elif level == Context.CRITICAL:
errors.add('<b>{}</b>: {}'.format(html.escape(unique_name), html.escape(msg)))
context.unsupported_object_callback = unsupported_object_callback
# context.style_folder, _ = os.path.split(output_file)
try:
qgis_symbol = SymbolConverter.Symbol_to_QgsSymbol(symbol, context)
except NotImplementedException as e:
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
except UnreadablePictureException as e:
unreadable.append('<b>{}</b>: {}'.format(html.escape(name), html.escape(str(e))))
continue
if isinstance(qgis_symbol, QgsSymbol):
# self.check_for_missing_fonts(qgis_symbol, feedback)
style.addSymbol(unique_name, qgis_symbol, True)
elif isinstance(qgis_symbol, QgsColorRamp):
style.addColorRamp(unique_name, qgis_symbol, True)
if tags:
if isinstance(qgis_symbol, QgsSymbol):
assert style.tagSymbol(QgsStyle.SymbolEntity, unique_name, tags)
elif isinstance(qgis_symbol, QgsColorRamp):
assert style.tagSymbol(QgsStyle.ColorrampEntity, unique_name, tags)
progress_dialog.deleteLater()
if feedback.isCanceled():
return True
if errors or unreadable or warnings:
message = ''
if unreadable:
message = '<p>The following symbols could not be converted:</p>'
message += '<ul>'
for w in unreadable:
message += '<li>{}</li>'.format(w.replace('\n', '<br>'))
message += '</ul>'
if errors:
message += '<p>The following errors were generated while converting symbols:</p>'
message += '<ul>'
for w in errors:
message += '<li>{}</li>'.format(w.replace('\n', '<br>'))
message += '</ul>'
if warnings:
message += '<p>The following warnings were generated while converting symbols:</p>'
message += '<ul>'
for w in warnings:
message += '<li>{}</li>'.format(w.replace('\n', '<br>'))
message += '</ul>'
show_warning('style could not be completely converted', 'Convert style', message,
level=Qgis.Critical if (unreadable or errors) else Qgis.Warning)
if Qgis.QGIS_VERSION_INT >= 30800:
dlg = QgsStyleManagerDialog(style, readOnly=True)
dlg.setFavoritesGroupVisible(False)
dlg.setSmartGroupsVisible(False)
fi = QFileInfo(input_file)
dlg.setBaseStyleName(fi.baseName())
else:
dlg = QgsStyleManagerDialog(style)
dlg.exec_()
return True
def read(self, stream: Stream, version):
has_picture = stream.read_int('has picture') != 0
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
stream.read_int('unknown')
self.transparency = stream.read_double('transparency')
self.color = stream.read_object('color')
self.transparent_texture_color = stream.read_object('transparent texture color')
if has_picture:
self.picture = BmpPicture()
self.picture.read(stream, 1)
def read(self, stream: Stream, version):
self.color = stream.read_object('color')
self.size_z = stream.read_double('size z')
self.geometry = stream.read_object('multipatch')
stream.read_int('unknown', expected=9)
self.origin_x = stream.read_double('origin x')
self.origin_y = stream.read_double('origin y')
self.origin_z = stream.read_double('origin z')
self.material_draping = stream.read_ushort('no material draping') == 0
stream.read_int('unknown', expected=13)
stream.read_int('unknown', expected=0)
self.rotation_z = stream.read_double('rotation z')
self.offset_x = stream.read_double('offset x')
self.offset_y = stream.read_double('offset y')
self.offset_z = stream.read_double('offset z')
stream.read_ushort('unknown', expected=65535)
self.picture = stream.read_object('picture')
self.rotation_x = stream.read_double('rotation x')
self.rotation_y = stream.read_double('rotation y')
self.size_x = stream.read_double('size x')
self.size_y = stream.read_double('size y')
self.keep_aspect = stream.read_ushort('keep aspect') != 0
stream.read_ushort('unknown', expected=0)
if version == 7:
return
self.display_face_front = stream.read_ushort('display face front') != 0
if version < 7:
stream.read_int('unknown', expected=0)
stream.read_double('unknown')
stream.read_ushort('unknown', expected=0)
stream.read_ushort('unknown', expected=65535)
if version > 8:
stream.read_ushort('unknown', expected=0)
stream.read_int('unknown', expected=0)
