Reformat public header with Qt's clang-format

.clang-format

@@ -0,0 +1,85 @@
+# Copyright (C) 2016 Olivier Goffart <ogoffart@woboq.com>
+#
+# You may use this file under the terms of the 3-clause BSD license.
+# See the file LICENSE from this package for details.
+
+# This is the clang-format configuration style to be used by Qt,
+# based on the rules from https://wiki.qt.io/Qt_Coding_Style and
+# https://wiki.qt.io/Coding_Conventions
+
+---
+# Webkit style was loosely based on the Qt style
+BasedOnStyle: WebKit
+
+Standard: Cpp11
+
+# Column width is limited to 100 in accordance with Qt Coding Style.
+# https://wiki.qt.io/Qt_Coding_Style
+# Note that this may be changed at some point in the future.
+ColumnLimit: 100
+# How much weight do extra characters after the line length limit have.
+# PenaltyExcessCharacter: 4
+
+# Disable reflow of qdoc comments: indentation rules are different.
+# Translation comments are also excluded.
+CommentPragmas: "^!|^:"
+
+# We want a space between the type and the star for pointer types.
+PointerBindsToType: false
+
+# We use template< without space.
+SpaceAfterTemplateKeyword: false
+
+# We want to break before the operators, but not before a '='.
+BreakBeforeBinaryOperators: NonAssignment
+
+# Braces are usually attached, but not after functions or class declarations.
+BreakBeforeBraces: Custom
+BraceWrapping:
+    AfterClass: true
+    AfterControlStatement: false
+    AfterEnum: false
+    AfterFunction: true
+    AfterNamespace: false
+    AfterObjCDeclaration: false
+    AfterStruct: true
+    AfterUnion: false
+    BeforeCatch: false
+    BeforeElse: false
+    IndentBraces: false
+
+# When constructor initializers do not fit on one line, put them each on a new line.
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+# Indent initializers by 4 spaces
+ConstructorInitializerIndentWidth: 4
+
+# Indent width for line continuations.
+ContinuationIndentWidth: 8
+
+# No indentation for namespaces.
+NamespaceIndentation: None
+
+# Allow indentation for preprocessing directives (if/ifdef/endif). https://reviews.llvm.org/rL312125
+IndentPPDirectives: AfterHash
+
+# Horizontally align arguments after an open bracket.
+# The coding style does not specify the following, but this is what gives
+# results closest to the existing code.
+AlignAfterOpenBracket: true
+AlwaysBreakTemplateDeclarations: true
+
+# Ideally we should also allow less short function in a single line, but
+# clang-format does not handle that.
+AllowShortFunctionsOnASingleLine: Inline
+
+# The coding style specifies some include order categories, but also tells to
+# separate categories with an empty line. It does not specify the order within
+# the categories. Since the SortInclude feature of clang-format does not
+# re-order includes separated by empty lines, the feature is not used.
+SortIncludes: false
+
+# macros for which the opening brace stays attached.
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH, forever, Q_FOREVER, QBENCHMARK, QBENCHMARK_ONCE ]
+
+# Break constructor initializers before the colon and after the commas.
+BreakConstructorInitializers: BeforeColon

api/sixtyfps-cpp/include/sixtyfps.h

@@ -13,13 +13,14 @@ namespace sixtyfps {
 using internal::ComponentType;
 using internal::ItemTreeNode;
 
-template <typename Component> void run(Component *c) {
+template<typename Component>
-  // FIXME! some static assert that the component is indeed a generated
+void run(Component *c)
-  // component matching the vtable.  In fact, i think the VTable should be a
+{
-  // static member of the Component
+    // FIXME! some static assert that the component is indeed a generated
-  internal::sixtyfps_runtime_run_component_with_gl_renderer(
+    // component matching the vtable.  In fact, i think the VTable should be a
-      &Component::component_type,
+    // static member of the Component
-      reinterpret_cast<internal::ComponentImpl *>(c));
+    internal::sixtyfps_runtime_run_component_with_gl_renderer(
+            &Component::component_type, reinterpret_cast<internal::ComponentImpl *>(c));
 }
 
 using internal::Image;
@@ -30,14 +31,14 @@ using internal::RectangleVTable;
 // the component has static lifetime so it does not need to be destroyed
 // FIXME: we probably need some kind of way to dinstinguish static component and
 // these on the heap
-inline void dummy_destory(const ComponentType *, internal::ComponentImpl *) {}
+inline void dummy_destory(const ComponentType *, internal::ComponentImpl *) { }
 
 constexpr inline ItemTreeNode make_item_node(std::intptr_t offset,
                                              const internal::ItemVTable *vtable,
-                                             uint32_t child_count,
+                                             uint32_t child_count, uint32_t child_index)
-                                             uint32_t child_index) {
+{
-  return ItemTreeNode{
+    return ItemTreeNode { ItemTreeNode::Tag::Item,
-      ItemTreeNode::Tag::Item,
+                          { ItemTreeNode::Item_Body { offset, vtable, child_count,
-      {ItemTreeNode::Item_Body{offset, vtable, child_count, child_index}}};
+                                                      child_index } } };
 }
 } // namespace sixtyfps