| # Copyright 2015 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import fileinput |
| import glob |
| import optparse |
| import os |
| import re |
| import shlex |
| import sys |
| import textwrap |
| |
| CANVAS_DIMENSIONS = "CANVAS_DIMENSIONS" |
| CPP_COMMENT_DELIMITER = "//" |
| REFERENCE_SIZE_DIP = 48 |
| TEMPLATE_PLACEHOLDER = "TEMPLATE_PLACEHOLDER" |
| |
| |
| def Error(msg): |
| print(msg, file=sys.stderr) |
| sys.exit(1) |
| |
| |
| def CamelCase(name, suffix): |
| words = name.split("_") |
| words = [w.capitalize() for w in words] |
| return "k" + "".join(words) + suffix |
| |
| |
| def GetPathName(name, size=None): |
| return CamelCase(name, "{}Path".format(size) if size != None else "Path") |
| |
| |
| def GetRepListName(name): |
| return CamelCase(name, "RepList") |
| |
| |
| def GetIconName(name): |
| return CamelCase(name, "Icon") |
| |
| |
| def AddIconToDictionary(icon_file, new_icon, icon_size, icon_index): |
| if icon_size in icon_index: |
| Error("Duplicate icon of size {} found in {}.".format(icon_size, icon_file)) |
| icon_index[icon_size] = "\n".join(new_icon) |
| return icon_index |
| |
| |
| def ExtractIconReps(icon_file_name): |
| """Reads the contents of the given icon file and returns a dictionary of icon |
| sizes to vector commands for different icon representations stored in that |
| file. |
| |
| Args: |
| icon_file_name: The file path of the icon file to read. |
| """ |
| with open(icon_file_name, "r") as icon_file: |
| icon_file_contents = icon_file.readlines() |
| |
| current_icon_size = REFERENCE_SIZE_DIP |
| icon_sizes = [] |
| current_icon_representation = [] |
| icon_representations = {} |
| for line in icon_file_contents: |
| # Strip comments and empty lines. |
| line = line.partition(CPP_COMMENT_DELIMITER)[0].strip() |
| if not line: |
| continue |
| # Retrieve sizes specified by CANVAS_DIMENSIONS to ensure icons are added in |
| # sorted order by size descending. |
| if line.startswith(CANVAS_DIMENSIONS): |
| sizes = re.findall(r"\d+", line) |
| if len(sizes) != 1: |
| Error("Malformed {} line in {} - it should specify exactly one size." |
| .format(CANVAS_DIMENSIONS, icon_file_name)) |
| icon_sizes.append(int(sizes[0])) |
| |
| # All icons except the first / default icon must start with |
| # "CANVAS_DIMENSIONS", so rely on it here as a icon delimiter. |
| if current_icon_representation: |
| icon_representations = AddIconToDictionary( |
| icon_file_name, current_icon_representation, current_icon_size, |
| icon_representations) |
| current_icon_representation = [] |
| current_icon_size = icon_sizes[-1] |
| |
| current_icon_representation.append(line) |
| if current_icon_representation: |
| icon_representations = AddIconToDictionary( |
| icon_file_name, current_icon_representation, current_icon_size, |
| icon_representations) |
| |
| if not icon_representations: |
| Error("Didn't find any icons in {}.".format(icon_file_name)) |
| |
| if len(icon_representations) != len(icon_sizes): |
| icon_sizes.insert(0, REFERENCE_SIZE_DIP) |
| if sorted(icon_sizes, reverse=True) != icon_sizes: |
| Error("The icons in {} should be sorted in descending order of size." |
| .format(icon_file_name)) |
| return icon_representations |
| |
| |
| def AggregateVectorIcons(working_directory, file_list, output_cc, output_h): |
| """Compiles all .icon files in a directory into two C++ files. |
| |
| Args: |
| working_directory: The path to the directory that holds the .icon files |
| and C++ templates. |
| file_list: A file containing the list of vector icon files to process. |
| output_cc: The path that should be used to write the .cc file. |
| output_h: The path that should be used to write the .h file. |
| """ |
| |
| # For each file in |file_list|, place it in |path_map| if its extension is |
| # .icon. This will map the icon's name to its path, e.g., |
| # path_map['cat'] = 'foo/bar/cat.icon'. |
| icon_list = [] |
| with open(file_list, "r") as f: |
| file_list_contents = f.read() |
| icon_list = shlex.split(file_list_contents) |
| |
| path_map = {} |
| |
| for icon_path in icon_list: |
| (icon_name, extension) = os.path.splitext(os.path.basename(icon_path)) |
| |
| if extension != ".icon": |
| Error("Only filenames " + icon_name + ".icon are allowed.") |
| |
| if icon_name not in path_map: |
| path_map[icon_name] = icon_path |
| else: |
| Error("A vector icon with name '" + icon_name + "' already exists.") |
| |
| # Generate the file vector_icons.h which declares a variable for each |
| # icon in |path_map|. The variable name is derived from the icon name by |
| # converting to camel case, prepending 'k', and appending 'Icon'. For |
| # example, the icon 'foo_bar' will have the variable name kFooBarIcon. |
| with open(os.path.join(working_directory, "vector_icons.h.template"), |
| "r") as input_header_template: |
| header_template_contents = input_header_template.readlines() |
| |
| output_header = open(output_h, "w") |
| for line in header_template_contents: |
| if not TEMPLATE_PLACEHOLDER in line: |
| output_header.write(line) |
| continue |
| |
| for icon in path_map: |
| (icon_name, extension) = os.path.splitext( |
| os.path.basename(path_map[icon])) |
| output_header.write("VECTOR_ICON_TEMPLATE_H({})\n".format( |
| GetIconName(icon_name))) |
| output_header.close() |
| |
| # Copy the vector icon drawing commands from the .icon files, splitting them |
| # into their individual icon representations, and use them to generate |
| # vector_icons.cc, which defines the variables declared in vector_icons.h. |
| input_cc_template = open( |
| os.path.join(working_directory, "vector_icons.cc.template")) |
| cc_template_contents = input_cc_template.readlines() |
| input_cc_template.close() |
| |
| output_cc = open(output_cc, "w") |
| for line in cc_template_contents: |
| if not TEMPLATE_PLACEHOLDER in line: |
| output_cc.write(line) |
| continue |
| for icon in path_map: |
| (icon_name, extension) = os.path.splitext( |
| os.path.basename(path_map[icon])) |
| |
| icon_representations = ExtractIconReps(path_map[icon]) |
| icon_representation_strings = [] |
| for i, size in enumerate(sorted(icon_representations, reverse=True)): |
| vector_commands = icon_representations[size] |
| icon_path_name = GetPathName(icon_name, size if i != 0 else None) |
| # Store the vector-drawing commands for foo_bar.icon in the temporary |
| # variable kFooBarPath. |
| output_cc.write("VECTOR_ICON_REP_TEMPLATE({}, {})\n".format( |
| icon_path_name, vector_commands)) |
| icon_representation_strings.append( |
| "{{{0}, std::size({0})}}".format(icon_path_name)) |
| |
| # Another temporary variable kFooBarRepList is used to create all the |
| # VectorIconReps inline, with a pointer to it in the final VectorIcon. |
| output_cc.write("VECTOR_ICON_TEMPLATE_CC({}, {}, {})\n".format( |
| GetRepListName(icon_name), GetIconName(icon_name), |
| ", ".join(icon_representation_strings))) |
| |
| output_cc.close() |
| |
| |
| def main(): |
| parser = optparse.OptionParser() |
| parser.add_option("--working_directory", |
| help="The directory to look for template C++ as well as " |
| "icon files.") |
| parser.add_option("--file_list", |
| help="A response file containing the list of icon files " |
| "to be processed.") |
| parser.add_option("--output_cc", |
| help="The path to output the CC file to.") |
| parser.add_option("--output_h", |
| help="The path to output the header file to.") |
| |
| (options, args) = parser.parse_args() |
| |
| AggregateVectorIcons(options.working_directory, |
| options.file_list, |
| options.output_cc, |
| options.output_h) |
| |
| |
| if __name__ == "__main__": |
| main() |