Merge pull request #9 from DWilliames/v1.0.1

V1.0.1

Paddy.sketchplugin/Contents/Sketch/autoLayoutLookup.js

@@ -0,0 +1,39 @@
+
+
+var alCommand = autoLayoutCommand()
+
+function autoLayoutCommand() {
+
+  var pluginManager = AppController.sharedInstance().pluginManager()
+  var plugin = pluginManager.plugins().objectForKey('com.animaapp.stc-sketch-plugin')
+
+  if (!plugin) return
+  var commands = plugin.commands()
+
+  if (!commands) return
+
+  return commands['autolayout']
+}
+
+
+function alTypeForLayer(layer) {
+  var kViewTypeKey = "kViewTypeKey"
+
+  if (!alCommand) return
+
+  return alCommand.valueForKey_onLayer(kViewTypeKey, layer)
+}
+
+
+function alPropertiesForLayer(layer) {
+  var kModelPropertiesKey = "kModelPropertiesKey"
+
+  if (!alCommand) return
+
+  return alCommand.valueForKey_onLayer(kModelPropertiesKey, layer)
+}
+
+
+function layerIsStackView(layer) {
+  return alTypeForLayer(layer) == 'ADModelStackView'
+}

Paddy.sketchplugin/Contents/Sketch/layers.js

@@ -1,4 +1,5 @@
 @import 'padding.js'
+@import 'autoLayoutLookup.js'
 
 /**
  * Get the container frame for a BG layer
@@ -21,14 +22,88 @@ function getContainerFrameForBGLayer(bg) {
     return true
   })
 
+  // takeIntoAccountStackViews = true
+
   var frames = validLayers.map(function(layer) {
-    return MSRect.rectWithRect(layer.frameForTransforms())
+    return rectForLayer(layer)
   })
 
+  // takeIntoAccountStackViews = false
+
   return MSRect.rectWithUnionOfRects(frames)
 }
 
 
+// Whether to check for Stack Groups
+var takeIntoAccountStackViews = true
+
+
+// Return the rect for a layer as an MSRect
+function rectForLayer(layer) {
+  if (!takeIntoAccountStackViews || !layerIsStackView(layer)) {
+    return MSRect.rectWithRect(layer.frameForTransforms())
+  }
+
+  // Calculate based on stack view
+  var props = alPropertiesForLayer(layer)
+  //     ADModelStackView
+  // {
+  //     align = 5;
+  //     isCollapsing = 1;
+  //     spacing = 2;
+  //     type = 0;
+  // }
+
+
+  var vertical = (props.type == 0) // Else horizontal
+
+  // Filter out hidden layers if StackGroup 'isCollapsing'
+  var layers = (props.isCollapsing == 1) ? filter(layer.layers(), function(layer) {
+    return layer.isVisible()
+  }) : sortedLayers
+
+  // Map each layer to its rect
+  var rects = layers.map(function(layer) {
+    return rectForLayer(layer)
+  })
+
+  // Sort the layers
+  // Vertical – Top to bottom
+  // Horizontal – Left to right
+  var sortedRects = rects.sort(function(a, b) {
+    if (vertical) {
+      return a.y() <= b.y() ? -1 : 1
+    } else {
+      return a.x() <= b.x() ? -1 : 1
+    }
+  })
+
+  var frames = []
+  sortedRects.forEach(function(rect, index) {
+
+    if (frames.length > 0) {
+      var previous = frames[frames.length - 1]
+
+      if (vertical) {
+        rect.y = previous.y() + previous.height() + props.spacing
+      } else {
+        rect.x = previous.x() + previous.width() + props.spacing
+      }
+
+    }
+
+    frames.push(rect)
+  })
+
+  var unionRect = MSRect.rectWithUnionOfRects(frames)
+  var originalRect = MSRect.rectWithRect(layer.frameForTransforms())
+  unionRect.y = originalRect.y()
+  unionRect.x = originalRect.x()
+
+  return unionRect
+}
+
+
 /**
  * Get the background layer for a given layer (if any)
  */

Paddy.sketchplugin/Contents/Sketch/spacing.js

@@ -227,6 +227,10 @@ function defaultSpacing() {
 function applySpacingToGroup(spacing, groupLayer) {
   if (!spacing) return
 
+  // Get the current group position
+  var beginningX = groupLayer.frame().x()
+  var beginningY = groupLayer.frame().y()
+
   // Valid layers for spacing
   var layers = filter(groupLayer.layers(), function(layer) {
     if (layerHasPadding(layer))
@@ -291,39 +295,44 @@ function applySpacingToGroup(spacing, groupLayer) {
 
   if (spacing.align) {
 
+
+
     log(2, 'Will align layers', layers.map(function(layer) {
       return layer.name() + "\n"
     }))
     // if (spacing.layout == "v") {
-      layers.forEach(function(layer) {
-        if (spacing.align == "l") {
-          layer.frame().setX(minX)
-        } else if (spacing.align == "r") {
-          layer.frame().setMaxX(maxX)
-        } else if (spacing.align == "c") {
-          var mid = minX + (maxX - minX) / 2
-          layer.frame().setMidX(mid)
-        }
-      })
-
-    // } else if (spacing.layout == "h") {
-      layers.forEach(function(layer) {
-        if (spacing.align == "t") {
-          layer.frame().setY(minY)
-        } else if (spacing.align == "b") {
-          layer.frame().setMaxY(maxY)
-        } else if (spacing.align == "m") {
-          var mid = minY + (maxY - minY) / 2
-          layer.frame().setMidY(mid)
-        }
-      })
-    // }
+    layers.forEach(function(layer) {
+      if (spacing.align == "l") {
+        layer.frame().setX(minX)
+      } else if (spacing.align == "r") {
+        layer.frame().setMaxX(maxX)
+      } else if (spacing.align == "c") {
+        var mid = minX + (maxX - minX) / 2
+        layer.frame().setMidX(mid)
+      }
+    })
+
+  // } else if (spacing.layout == "h") {
+    layers.forEach(function(layer) {
+      if (spacing.align == "t") {
+        layer.frame().setY(minY)
+      } else if (spacing.align == "b") {
+        layer.frame().setMaxY(maxY)
+      } else if (spacing.align == "m") {
+        var mid = minY + (maxY - minY) / 2
+        layer.frame().setMidY(mid)
+      }
+    })
   }
 
 
 
   log(2, 'Sorted layers', sortedLayers)
   groupLayer.layerDidEndResize()
+
+  // Reset the position to be the same
+  groupLayer.frame().setX(beginningX)
+  groupLayer.frame().setY(beginningY)
 }
 
 

Paddy.sketchplugin/Contents/Sketch/symbols.js

@@ -36,6 +36,7 @@ function updateForSymbolInstance(symbol) {
     maxTextWidth = padding.conditions.maxWidth - padding.left - padding.right
   }
 
+  var ignoreWidth = (padding.left == 'x' && padding.right == 'x')
 
   // Get all the layers to override, sorted from left to right on the screen
   var layersToOverride = filter(master.children(), function(layer) {
@@ -125,14 +126,28 @@ function updateForSymbolInstance(symbol) {
     layer.textBehaviour = 0
     layer.adjustFrameToFit()
 
-    if (maxTextWidth && layer.frame().width() > maxTextWidth) {
+    if ((maxTextWidth && layer.frame().width() > maxTextWidth) || ignoreWidth) {
+
+      // Make sure the text is a single line – we're trying to get the size of the height
+      var newStringValue = layer.stringValue()
+      layer.stringValue = 'Ay' // We want a rough height, including ascenders and descenders
 
       // There's a tiny offset we need to calculate, to make it look 'just right'
       var originalGlyphBounds = layer.glyphBounds()
       var yOffset = layer.frame().height() - (originalGlyphBounds.size.height + originalGlyphBounds.origin.y)
 
+      layer.stringValue = newStringValue
+
       layer.textBehaviour = 1
-      layer.frame().width = maxTextWidth
+
+      if (ignoreWidth) {
+        var originalLayerWidth = originalProperties[id].width
+        var widthDiff = masterFrame.width() - originalLayerWidth
+
+        layer.frame().width = symbol.frame().width() - widthDiff
+      } else {
+        layer.frame().width = maxTextWidth
+      }
 
       layer.adjustFrameToFit()
 
@@ -202,6 +217,8 @@ function updateForSymbolInstance(symbol) {
 
   fixEdges(bg)
 
+  takeIntoAccountStackViews = true
+
   updatePaddingForLayerBG(bg)
 
   var newSize = bg.frame()
@@ -214,8 +231,15 @@ function updateForSymbolInstance(symbol) {
   if (newHeight < 0) {
     newHeight = -newHeight
   }
-  symbol.frame().setWidth(newWidth)
-  symbol.frame().setHeight(newHeight)
+
+  if (!ignoreWidth) {
+    symbol.frame().setWidth(newWidth)
+  }
+
+  if (!(padding.top == 'x' && padding.bottom == 'x')) {
+    symbol.frame().setHeight(newHeight)
+  }
+
   log(2, 'Got new size from master', newSize)
   log(3, 'Resetting overrides on master')
 
@@ -240,6 +264,8 @@ function updateForSymbolInstance(symbol) {
     }
   })
 
+  takeIntoAccountStackViews = false
+
   updatePaddingForLayerBG(bg)
 
   symbol.layerDidEndResize()
@@ -269,10 +295,16 @@ function getStringOverridesForSymbolInstance(symbol) {
     var overrideValue = availableOverride.overrideValue()
     log(2, 'getting override for', overrideValue)
 
-    if (overrideValue && availableOverride.overridePoint().property() == 'stringValue') {
-      var value = (overrideValue.isMemberOfClass(MSOverrideValue)) ? overrideValue.value() : overrideValue
-      var key = availableOverride.overridePoint().layerID()
-      overrides[key] = value
+    if (availableOverride.overridePoint().property() == 'stringValue') {
+      if (!overrideValue) {
+        overrideValue = availableOverride.defaultValue()
+      }
+
+      if (overrideValue) {
+        var value = (overrideValue.isMemberOfClass(MSOverrideValue)) ? overrideValue.value() : overrideValue
+        var key = availableOverride.overridePoint().layerID()
+        overrides[key] = value
+      }
     }
   })