This is an automated email from the ASF dual-hosted git repository.

carlosrovira pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/royale-asjs.git

commit 7c49aa595cc81b9943364d53fb6802af0a113676
Author: Carlos Rovira <[email protected]>
AuthorDate: Thu Jun 4 11:55:21 2020 +0200

    jewel-tilehorizontallayout: tilelayout with orientation columns or 
horizontal
---
 .../Jewel/src/main/resources/jewel-manifest.xml    |   1 +
 .../jewel/beads/layouts/TileHorizontalLayout.as    | 514 +++++++++++++++++++++
 2 files changed, 515 insertions(+)

diff --git a/frameworks/projects/Jewel/src/main/resources/jewel-manifest.xml 
b/frameworks/projects/Jewel/src/main/resources/jewel-manifest.xml
index 842ac20..a39b5cf 100644
--- a/frameworks/projects/Jewel/src/main/resources/jewel-manifest.xml
+++ b/frameworks/projects/Jewel/src/main/resources/jewel-manifest.xml
@@ -207,6 +207,7 @@
     <component id="HorizontalFlowLayout" 
class="org.apache.royale.jewel.beads.layouts.HorizontalFlowLayout"/>
     <component id="VerticalFlowLayout" 
class="org.apache.royale.jewel.beads.layouts.VerticalFlowLayout"/>
     <component id="TileLayout" 
class="org.apache.royale.jewel.beads.layouts.TileLayout"/>
+    <component id="TileHorizontalLayout" 
class="org.apache.royale.jewel.beads.layouts.TileHorizontalLayout"/>
     <component id="GridLayout" 
class="org.apache.royale.jewel.beads.layouts.GridLayout"/>
     <component id="GridCellLayout" 
class="org.apache.royale.jewel.beads.layouts.GridCellLayout"/>
     <component id="TableLayout" 
class="org.apache.royale.jewel.beads.layouts.TableLayout"/>
diff --git 
a/frameworks/projects/Jewel/src/main/royale/org/apache/royale/jewel/beads/layouts/TileHorizontalLayout.as
 
b/frameworks/projects/Jewel/src/main/royale/org/apache/royale/jewel/beads/layouts/TileHorizontalLayout.as
new file mode 100644
index 0000000..b48b1f0
--- /dev/null
+++ 
b/frameworks/projects/Jewel/src/main/royale/org/apache/royale/jewel/beads/layouts/TileHorizontalLayout.as
@@ -0,0 +1,514 @@
+////////////////////////////////////////////////////////////////////////////////
+//
+//  Licensed to the Apache Software Foundation (ASF) under one or more
+//  contributor license agreements.  See the NOTICE file distributed with
+//  this work for additional information regarding copyright ownership.
+//  The ASF licenses this file to You under the Apache License, Version 2.0
+//  (the "License"); you may not use this file except in compliance with
+//  the License.  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+package org.apache.royale.jewel.beads.layouts
+{
+       COMPILE::SWF
+       {
+       import org.apache.royale.core.IUIBase;
+       }
+       import org.apache.royale.core.IBorderPaddingMarginValuesImpl;
+       import org.apache.royale.core.ILayoutView;
+       import org.apache.royale.core.UIBase;
+       import org.apache.royale.core.ValuesManager;
+       import org.apache.royale.core.layout.EdgeData;
+       import org.apache.royale.core.layout.ILayoutStyleProperties;
+       import org.apache.royale.events.Event;
+
+       /**
+        *  The TileLayout class bead sizes and positions the elements it 
manages into rows and columns.
+        *  The size of each element is determined either by setting 
TileLayout's columnWidth and rowHeight
+        *  properties, or having the tile size determined by factoring the 
columnCount into the area assigned
+        *  for the layout.
+        *
+        *  @langversion 3.0
+        *  @playerversion Flash 10.2
+        *  @playerversion AIR 2.6
+        *  @productversion Royale 0.9.8
+        */
+       public class TileHorizontalLayout extends StyledLayoutBase implements 
ILayoutStyleProperties
+       {
+               /**
+                *  constructor.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               public function TileHorizontalLayout()
+               {
+                       super();
+               }
+
+               public static const LAYOUT_TYPE_NAMES:String = "layout tile";
+
+               /**
+                *  Add class selectors when the component is addedToParent
+                *  Otherwise component will not get the class selectors when 
+                *  perform "removeElement" and then "addElement"
+                * 
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               override public function beadsAddedHandler(event:Event = 
null):void
+               {
+                       super.beadsAddedHandler();
+
+                       COMPILE::JS
+                       {
+                       if (hostComponent.containsClass("layout"))
+                               hostComponent.removeClass("layout");
+                       hostComponent.addClass("layout");
+                       if(hostComponent.containsClass("tile"))
+                               hostComponent.removeClass("tile");
+                       hostComponent.addClass("tile");
+                       }
+               }
+
+               private var _columnCount:int = -1;
+               /**
+                *  The number of tiles to fit horizontally into the layout.
+                *  Contain the actual column count.
+                *  The default value is -1.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               public function get columnCount():int
+               {
+                       return _columnCount;
+               }
+
+               private var _requestedColumnCount:int = -1;
+               /**
+                *  Number of columns to be displayed.
+                *  Set to -1 to allow the TileLayout to determine the column 
count automatically.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("requestedColumnCountChanged")]
+               public function get requestedColumnCount():int
+               {
+                       return _requestedColumnCount;
+               }
+               public function set requestedColumnCount(value:int):void
+               {
+                       _requestedColumnCount = value;
+                       layout();
+               }
+
+               private var _columnWidth:Number = Number.NaN;
+               /**
+                *  Contain the actual column width, in pixels.
+                *  If not explicitly set, the column width is determined from 
the width of the widest element.
+                *  If the columnAlign property is set to "justifyUsingWidth", 
the column width grows to the container width to justify the fully-visible 
columns.
+                *  The default value is NaN.
+                *  This property can be used as the source for data binding.
+                *  
+                *  The width of each column, in pixels. If left unspecified, 
the
+                *  columnWidth is determined by dividing the columnCount into 
the
+                *  strand's bounding box width.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("columnWidthChanged")]
+               public function get columnWidth():Number
+               {
+                       return _columnWidth;
+               }
+               public function set columnWidth(value:Number):void
+               {
+                       _columnWidth = value;
+                       layout();
+               }
+
+               private var _rowCount:int = -1;
+               /**
+                *  The number of tiles to fit horizontally into the layout.
+                *  The row count.
+                *  The default value is -1.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("rowCountChanged")]
+               public function get rowCount():int
+               {
+                       return _rowCount;
+               }
+               
+               private var _requestedRowCount:int = -1;
+               /**
+                *  Number of rows to be displayed.
+                *  Set to -1 to remove explicit override and allow the 
TileLayout to determine the row count automatically.
+                *  If the orientation property is set to 
TileOrientation.COLUMNS, setting this property has no effect. in this case, 
columnCount is explicitly set, and the container height is explicitly set.
+                *  The default value is -1.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("requestedRowCountChanged")]
+               public function get requestedRowCount():int
+               {
+                       return _requestedRowCount;
+               }
+               public function set requestedRowCount(value:int):void
+               {
+                       _requestedRowCount = value;
+                       layout();
+               }
+
+               private var _rowHeight:Number = Number.NaN;
+               /**
+                *  The row height, in pixels.
+                *  If not explicitly set, the row height is determined from 
the maximum of elements' height.
+                *  If rowAlign is set to "justifyUsingHeight", the actual row 
height increases to justify the fully-visible rows to the container height.
+                *  The default value is NaN.
+                *  This property can be used as the source for data binding.
+                *  
+                *  The height of each row, in pixels. If left unspecified, the
+                *  rowHeight is determine by dividing the possible number of 
rows
+                *  into the strand's bounding box height.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("rowHeightChanged")]
+               public function get rowHeight():Number
+               {
+                       return _rowHeight;
+               }
+               public function set rowHeight(value:Number):void
+               {
+                       _rowHeight = value;
+                       layout();
+               }
+
+               /**
+                *  @private
+                */
+               private var horizontalGapInitialized:Boolean;
+               public static const HORIZONTAL_GAP_STYLE:String = 
"horizontalGap"
+               private var _horizontalGap:Number = 0;
+               /**
+                *  The horizontalGap between items.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("horizontalGapChanged")]
+               public function get horizontalGap():Number
+               {
+                       return _horizontalGap;
+               }
+               /**
+                *  @private
+                */
+               public function set horizontalGap(value:Number):void
+               {
+                       _horizontalGap = value;
+                       horizontalGapInitialized = true;
+                       // layout();
+               }
+
+               /**
+                *  @private
+                */
+               private var verticalGapInitialized:Boolean;
+               public static const VERTICAL_GAP_STYLE:String = "verticalGap"
+               private var _verticalGap:Number = 0;
+               /**
+                *  The verticalGap between items.
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               [Bindable("verticalGapChanged")]
+               public function get verticalGap():Number
+               {
+                       return _verticalGap;
+               }
+               /**
+                *  @private
+                */
+               public function set verticalGap(value:Number):void
+               {
+                       _verticalGap = value;
+                       verticalGapInitialized = true;
+                       // layout();
+               }
+
+               /**
+                *  Get the component layout style and apply to if exists
+                * 
+                *  @param component the IUIBase component that host this layout
+                *  @param cssProperty the style property in css set for the 
component to retrieve
+                * 
+                *  @see 
org.apache.royale.core.layout.ILayoutStyleProperties#applyStyleToLayout(component:IUIBase,
 cssProperty:String):void
+                * 
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                */
+               // override public function 
applyStyleToLayout(component:IUIBase, cssProperty:String):void
+               // {    
+               //      var cssValue:* = 
ValuesManager.valuesImpl.getValue(component, cssProperty);
+               //      if (cssValue !== undefined)
+               //      {
+               //              switch(cssProperty)
+               //              {
+               //                      case VERTICAL_GAP_STYLE:
+               //                              if(!verticalGapInitialized)
+               //                              {
+               //                                      verticalGap = 
Number(cssValue);
+               //                              }
+               //                              break;
+               //                      default:
+               //                              break;
+               //              }       
+               //      }
+               // }
+               
+               /**
+                *  Layout children
+                *
+                *  @langversion 3.0
+                *  @playerversion Flash 10.2
+                *  @playerversion AIR 2.6
+                *  @productversion Royale 0.9.8
+                *  @royaleignorecoercion org.apache.royale.core.ILayoutHost
+                *  @royaleignorecoercion 
org.apache.royale.core.WrappedHTMLElement
+                */
+               override public function layout():Boolean
+               {
+                       COMPILE::SWF
+                       {
+                               var borderMetrics:EdgeData = 
(ValuesManager.valuesImpl as 
IBorderPaddingMarginValuesImpl).getBorderMetrics(host);
+                               var area:UIBase = layoutView as UIBase;
+
+                               var xpos:Number = 0;
+                               var ypos:Number = 0;
+                               var useWidth:Number = columnWidth;
+                               var useHeight:Number = rowHeight;
+                               var n:Number = area.numElements;
+                               if (n == 0) return false;
+                               
+                               var adjustedWidth:Number = 
Math.floor(host.width - borderMetrics.left - borderMetrics.right);
+                               var adjustedHeight:Number = 
Math.floor(host.height - borderMetrics.top - borderMetrics.bottom);
+
+                               var realN:Number = n;
+                               for(var j:int=0; j < n; j++)
+                               {
+                                       var testChild:IUIBase = 
area.getElementAt(i) as IUIBase;
+                                       if (testChild == null || 
!testChild.visible) realN--;
+                               }
+
+                               if (isNaN(useWidth)) useWidth = 
Math.floor(adjustedWidth / columnCount); // + gap
+                               if (isNaN(useHeight)) {
+                                       // given the width and total number of 
items, how many rows?
+                                       var numRows:Number = 
Math.ceil(realN/columnCount);
+                                       if (host.isHeightSizedToContent()) 
useHeight = 30; // default height
+                                       else useHeight = 
Math.floor(adjustedHeight / numRows);
+                               }
+
+                               var maxWidth:Number = useWidth;
+                               var maxHeight:Number = useHeight;
+
+                               for(var i:int=0; i < n; i++)
+                               {
+                                       var child:IUIBase = 
area.getElementAt(i) as IUIBase;
+                                       if (child == null || !child.visible) 
continue;
+                                       child.width = useWidth;
+                                       child.height = useHeight;
+                                       child.x = xpos;
+                                       child.y = ypos;
+
+                                       xpos += useWidth;
+                                       maxWidth = Math.max(maxWidth,xpos);
+
+                                       var test:Number = (i+1)%columnCount;
+
+                                       if (test == 0) {
+                                               xpos = 0;
+                                               ypos += useHeight;
+                                               maxHeight = 
Math.max(maxHeight,ypos);
+                                       }
+                               }
+
+                               maxWidth = Math.max(maxWidth, 
columnCount*useWidth);
+                               maxHeight = Math.max(maxHeight, 
numRows*useHeight);
+
+                               // Only return true if the contentView needs to 
be larger; that new
+                               // size is stored in the model.
+                               var sizeChanged:Boolean = true;
+
+                               return sizeChanged;
+                       }
+                       COMPILE::JS
+                       {
+                               trace(" **** TILE LAYOUT ****");
+                               
+                               trace(" - requestedColumnCount", 
requestedColumnCount);
+                               trace(" - columnCount", columnCount);
+                               trace(" - columnWidth", columnWidth);
+                               trace(" - horizontalGap", horizontalGap);
+
+                               trace(" - requestedRowCount", 
requestedRowCount);
+                               trace(" - rowCount", rowCount);
+                               trace(" - rowHeight", rowHeight);
+                               trace(" - verticalGap", verticalGap);
+                               
+                               var i:int;
+                               var n:int;
+                               var child:UIBase;
+                               var useWidth:Number;
+                               var useHeight:Number;
+
+                               var contentView:ILayoutView = layoutView as 
ILayoutView;
+                               n = contentView.numElements;
+
+                               if (n === 0) return false;
+
+
+                               useWidth = columnWidth;
+                               trace(" - useWidth", useWidth);
+                               useHeight = rowHeight;
+                               trace(" - useHeight", useHeight);
+                               var needWidth:Boolean = isNaN(useWidth);
+                               trace(" - needWidth", needWidth);
+                               var needHeight:Boolean = isNaN(useHeight);
+                               trace(" - needHeight", needHeight);
+                               
+                               var realN:int = n;
+                               var widestTile:Number = 0; // hold the widest 
tile
+                               var tallestTile:Number = 0; // hold the widest 
tile
+                               for (i = 0; i < n; i++)
+                               {
+                                       child = contentView.getElementAt(i) as 
UIBase;
+                                       if (!child.visible) realN--;
+                                       if (needWidth && child.width > 
widestTile) widestTile = child.width;
+                                       if (needWidth && child.height > 
tallestTile) tallestTile = child.height;
+                               }
+                               trace(" - widestTile", widestTile);
+                               trace(" - tallestTile", tallestTile);
+                               
+                               if(needHeight || needWidth)
+                               {
+                                       trace("  -- calculate useWidth & 
useHeight");
+                                       var borderMetrics:EdgeData = 
(ValuesManager.valuesImpl as 
IBorderPaddingMarginValuesImpl).getBorderMetrics(host);
+                                       var adjustedHostWidth:Number = 
Math.floor(host.width - borderMetrics.left - borderMetrics.right);
+                                       trace(" - adjustedWidth", 
adjustedHostWidth);
+                                       var adjustedHostHeight:Number = 
Math.floor(host.height - borderMetrics.top - borderMetrics.bottom);
+                                       trace(" - adjustedHeight", 
adjustedHostHeight);
+                                       if (needWidth)
+                                       {
+                                               // calculate columnCount in 
base of the widesTile
+                                               _columnCount = 
_requestedColumnCount != -1 ? _requestedColumnCount : 
Math.floor(adjustedHostWidth / (widestTile + horizontalGap));
+                                               useWidth = 
_requestedColumnCount == -1 ? widestTile : Math.floor((adjustedHostWidth - 
horizontalGap) / columnCount);
+                                       } else {
+                                               _columnCount = 
_requestedColumnCount != -1 ? _requestedColumnCount : 
Math.floor(adjustedHostWidth/ (_columnWidth + horizontalGap));
+                                               useWidth = 
_requestedColumnCount == -1 ? _columnWidth : Math.floor((adjustedHostWidth - 
horizontalGap) / columnCount);
+                                       }
+                                       trace("  -- _columnCount", 
_columnCount);
+                                       trace("  -- useWidth", useWidth);
+
+                                       // given the width and total number of 
items, how many rows?
+                                       // _rowCount = _requestedRowCount != -1 
? _requestedRowCount : Math.floor(adjustedHostHeight / (tallestTile + 
verticalGap));
+                                       _rowCount = Math.ceil(realN / 
columnCount);
+                                       trace("  -- _rowCount", _rowCount);
+                                       
+                                       if (needHeight)
+                                       {       
+                                               useHeight = tallestTile;
+                                               
+                                               // if 
(host.isHeightSizedToContent()) useHeight = 30; // default height
+                                               // else useHeight = 
Math.floor((adjustedHostHeight + verticalGap) / numRows);
+                                               // trace("  -- useHeight", 
useHeight);
+                                       } else {
+                                               // _rowCount = 
_requestedRowCount != -1 ? _requestedRowCount : Math.floor(adjustedHostHeight / 
(_rowHeight + verticalGap));
+                                               useHeight = _rowHeight;
+                                       }
+                                       // else {
+                                       //      // we have tile height so 
calculate rowCount
+                                       //      _rowCount = 
Math.floor((adjustedHostHeight + verticalGap)/ useHeight);
+                                       // }
+                               }
+                               
+                               trace("  -- useHeight", useHeight);
+                               for (i = 0; i < n; i++)
+                               {
+                                       child = contentView.getElementAt(i) as 
UIBase;
+
+                                       if (!child.visible) continue;
+                                       
+                                       trace(i, i % columnCount, i % rowCount);
+                                       
+                                       // add horizontalGap
+                                       if(i % columnCount != 0)
+                                               
child.positioner.style.marginLeft = horizontalGap + "px";
+                                       else
+                                               
child.positioner.style.marginLeft = null;
+                                       
+                                       // add verticalGap
+                                       if(i >= columnCount)
+                                               
child.positioner.style.marginTop = verticalGap + "px";
+                                       else
+                                               
child.positioner.style.marginTop = null;
+
+                                       
//child.setDisplayStyleForLayout('inline-flex');
+                                       //if the parent width/height not 
explicitly set, we can't calculate the child width/height
+                                       if(useWidth > 0)
+                                               child.width = 
_requestedColumnCount == -1 ? useWidth : useWidth - horizontalGap;
+                                       if(useHeight > 0)
+                                               child.height = 
_requestedRowCount == -1 ? useHeight : useHeight - verticalGap;
+                                       
+                                       // avoid a tile from the next row stay 
in the previous row due to flexbox algorithm
+                                       if(i % columnCount == columnCount - 1)
+                                               
child.positioner.style.marginRight = Math.floor(adjustedHostWidth - (1 + 
child.width + (child.width + horizontalGap) * (_columnCount - 1))) + "px";
+                                       else
+                                               
child.positioner.style.marginRight = null;
+                                       
+                                       child.dispatchEvent('sizeChanged');
+                               }
+                               return true;
+                       }
+               }
+       }
+}

Reply via email to