org.eclipse.scout.rt.ui.swt/src/org/eclipse/scout/rt/ui/swt/LogicalGridLayout.java - gerrit/scout/org.eclipse.scout.rt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010 BSI Business Systems Integration AG.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     BSI Business Systems Integration AG - initial API and implementation
  ******************************************************************************/
 package org.eclipse.scout.rt.ui.swt;

 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.scout.commons.CompositeObject;
 import org.eclipse.scout.commons.logger.IScoutLogger;
 import org.eclipse.scout.commons.logger.ScoutLogManager;
 import org.eclipse.scout.rt.client.ui.form.fields.IFormField;
 import org.eclipse.scout.rt.ui.swt.basic.SwtScoutComposite;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.graphics.Point;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Layout;
 import org.eclipse.ui.forms.widgets.ILayoutExtension;

 /**
  * Dynamic layout using logical grid data {@link LogicalGridData} to arrange
  * fields. The grid data per field can be passed when adding the component to
  * the container or set as client property with name {@link LogicalGridData#CLIENT_PROPERTY_NAME}.
  */
 public class LogicalGridLayout extends Layout implements ILayoutExtension {

   private static final IScoutLogger LOG = ScoutLogManager.getLogger(LogicalGridLayout.class);

   public static final int MIN = 0;
   public static final int PREF = 1;
   public static final int MAX = 2;

   public static final float EPS = 1E-6f;

   private boolean m_debug;
   private final int m_hgap;
   private final int m_vgap;
   private final int m_minWidth;
   private LogicalGridLayoutInfo m_info;
   private CompositeObject m_infoCacheKey;

   public LogicalGridLayout(int hgap, int vgap) {
     this(hgap, vgap, -1);
   }

   public LogicalGridLayout(int hgap, int vgap, int minWidth) {
     m_hgap = hgap;
     m_vgap = vgap;
     m_minWidth = minWidth;
   }

   public LogicalGridLayoutInfo getInfo() {
     return m_info;
   }

   @Override
   public int computeMinimumWidth(Composite parent, boolean changed) {
     return computeMinimumSize(parent, changed).x;
   }

   public Point computeMinimumSize(Composite parent, boolean changed) {
     return computeSize(parent, changed, SWT.DEFAULT, SWT.DEFAULT, MIN);
   }

   @Override
   protected Point computeSize(Composite composite, int wHint, int hHint, boolean flushCache) {
     return computeSize(composite, flushCache, wHint, hHint, PREF);
   }

   @Override
   public int computeMaximumWidth(Composite parent, boolean changed) {
     return computeSize(parent, changed, SWT.DEFAULT, SWT.DEFAULT, MAX).x;
   }

   public Point computeSize(Composite composite, boolean changed, int wHint, int hHint, int sizeFlag) {
     if (changed) {
       m_info = null;
     }
     if (wHint <= 0) {
       wHint = SWT.DEFAULT;
     }
     validateLayout(composite, wHint, changed);

     Point min = new Point(0, 0);
     Point pref = new Point(0, 0);
     Point max = new Point(0, 0);
     // w
     int useCount = 0;
     for (int i = 0; i < m_info.cols; i++) {
       if (useCount > 0) {
         min.x = min.x + m_hgap;
         pref.x = pref.x + m_hgap;
         max.x = max.x + m_hgap;
       }
       min.x = min.x + m_info.width[i][MIN];
       pref.x = pref.x + m_info.width[i][PREF];
       max.x = max.x + m_info.width[i][MAX];
       useCount++;
     }
     // h
     useCount = 0;
     for (int i = 0; i < m_info.rows; i++) {
       if (useCount > 0) {
         min.y = min.y + m_vgap;
         pref.y = pref.y + m_vgap;
         max.y = max.y + m_vgap;
       }
       min.y = min.y + m_info.height[i][MIN];
       pref.y = pref.y + m_info.height[i][PREF];
       max.y = max.y + m_info.height[i][MAX];
       useCount++;
     }
     Point size = new Point(0, 0);
     switch (sizeFlag) {
       case MIN:
         if (m_minWidth < 0) {
           size.x = min.x;
         }
         else {
           size.x = m_minWidth;
         }
         size.y = min.y;
         break;
       case MAX:
         size.x = min.x;
         size.y = min.y;
         break;
       default:
         // adjust width
         if (wHint == SWT.DEFAULT) {
           size.x = pref.x;
         }
         else {
           size.x = wHint;
           size.x = Math.min(max.x, size.x);
           size.x = Math.max(min.x, size.x);
         }
         // adjust height
         if (hHint == SWT.DEFAULT) {
           size.y = pref.y;
         }
         else {
           size.y = hHint;
           size.y = Math.min(max.y, size.y);
           size.y = Math.max(min.y, size.y);
         }
         break;
     }
     return size;
   }

   @Override
   protected void layout(Composite parent, boolean flushCache) {
     if (flushCache) {
       m_info = null;
     }
     Rectangle clientArea = parent.getClientArea();
     validateLayout(parent, clientArea.width, flushCache);
     Point size = new Point(clientArea.width, clientArea.height);
     Rectangle[][] cellBounds = m_info.layoutCellBounds(size);
     if (m_debug || LOG.isDebugEnabled()) {
       dumpLayoutInfo(parent);
     }
     // bounds
     int n = m_info.components.length;
     for (int i = 0; i < n; i++) {
       Control comp = m_info.components[i];
       LogicalGridData data = m_info.gridDatas[i];
       Rectangle r1 = cellBounds[data.gridy][data.gridx];
       Rectangle r2 = cellBounds[data.gridy + data.gridh - 1][data.gridx + data.gridw - 1];
       Rectangle r = r1.union(r2);
       if (data.topInset > 0) {
         r.y += data.topInset;
         r.height -= data.topInset;
       }
       if (data.fillHorizontal && data.fillVertical) {
         // ok
       }
       else {
         Point d = new Point(m_info.componentWidths[i], m_info.componentHeights[i]);
         if (!data.fillHorizontal) {
           if (d.x < r.width) {
             int delta = r.width - d.x;
             r.width = d.x;
             if (data.horizontalAlignment == 0) {
               r.x += delta / 2;
             }
             else if (data.horizontalAlignment > 0) {
               r.x += delta;
             }
           }
         }
         if (!data.fillVertical) {
           if (d.y < r.height) {
             int delta = r.height - d.y;
             if (data.heightHint == 0) {
               r.height = d.y;
             }
             else {
               r.height = data.heightHint;
             }
             if (data.verticalAlignment == 0) {
               r.y += delta / 2;
             }
             else if (data.verticalAlignment > 0) {
               r.y += delta;
             }
           }
         }
       }
       comp.setBounds(r);
     }
   }

   public void setDebug(boolean b) {
     m_debug = b;
   }

   public void dumpLayoutInfo(Composite parent) {
     dumpLayoutInfo(parent, new PrintWriter(System.out));
   }

   public void dumpLayoutInfo(Composite parent, PrintWriter out) {
     Point parentSize = parent.getSize();
     Rectangle[][] cellBounds = m_info.layoutCellBounds(parentSize);
     Object field = SwtScoutComposite.getScoutModelOnWidget(parent);
     String className = "undefined (PROP_SCOUT_OBJECT not set!)";
     if (field != null) {
       className = field.getClass().getSimpleName();
     }
     out.println("DUMP layout of: " + className + " compSize= " + parentSize);
     out.println("  containerBounds = " + parent.getClientArea());
     out.println("  Fields ---");
     for (int i = 0; i < m_info.components.length; i++) {
       Control c = m_info.components[i];
       LogicalGridData data = m_info.gridDatas[i];
       try {
         Rectangle r1 = cellBounds[data.gridy][data.gridx];
         Rectangle r2 = cellBounds[data.gridy + data.gridh - 1][data.gridx + data.gridw - 1];
         Rectangle r = r1.union(r2);
         String scoutObjectName = "NOT DEFINED";
         Object scoutObject = SwtScoutComposite.getScoutModelOnWidget(c);
         if (scoutObject != null) {
           scoutObjectName = scoutObject.getClass().getSimpleName();
         }
         out.println("   b=" + r + " " + scoutObjectName);
         if (scoutObject instanceof IFormField) {
           out.println("   model grid: " + ((IFormField) scoutObject).getGridData().toString());
         }
         out.println("   uiGridData: " + data.toString());
       }
       catch (ArrayIndexOutOfBoundsException e) {
         out.print("unable to print layout info of: " + data);
         e.printStackTrace();
       }
     }
     out.flush();
   }

   protected void validateLayout(Composite parent, int wHint, boolean flushCache) {
     CompositeObject newKey = new CompositeObject(parent.getSize(), wHint == SWT.DEFAULT ? (m_infoCacheKey != null ? m_infoCacheKey.getComponent(1) : wHint) : wHint);
     //check cache key
     if (m_info != null) {
       if (m_infoCacheKey == null || !m_infoCacheKey.equals(newKey)) {
         m_info = null;
         m_infoCacheKey = null;
       }
     }
     if (m_info != null && m_infoCacheKey != null) {
       return;
     }
     List<Control> visibleComps = new ArrayList<>();
     List<LogicalGridData> visibleCons = new ArrayList<>();
     for (Control comp : parent.getChildren()) {
       if (comp.getVisible() && comp.getLayoutData() instanceof LogicalGridData) {
         visibleComps.add(comp);
         LogicalGridData cons = (LogicalGridData) comp.getLayoutData();
         cons.validate();
         visibleCons.add(cons);
       }
     }
     m_info = new LogicalGridLayoutInfo(visibleComps.toArray(new Control[visibleComps.size()]), visibleCons.toArray(new LogicalGridData[visibleCons.size()]), m_hgap, m_vgap, wHint, flushCache);
     m_infoCacheKey = newKey;
   }

 }
	/*******************************************************************************
	* Copyright (c) 2010 BSI Business Systems Integration AG.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* BSI Business Systems Integration AG - initial API and implementation
	******************************************************************************/
	package org.eclipse.scout.rt.ui.swt;

	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.scout.commons.CompositeObject;
	import org.eclipse.scout.commons.logger.IScoutLogger;
	import org.eclipse.scout.commons.logger.ScoutLogManager;
	import org.eclipse.scout.rt.client.ui.form.fields.IFormField;
	import org.eclipse.scout.rt.ui.swt.basic.SwtScoutComposite;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.graphics.Point;
	import org.eclipse.swt.graphics.Rectangle;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Layout;
	import org.eclipse.ui.forms.widgets.ILayoutExtension;

	/**
	* Dynamic layout using logical grid data {@link LogicalGridData} to arrange
	* fields. The grid data per field can be passed when adding the component to
	* the container or set as client property with name {@link LogicalGridData#CLIENT_PROPERTY_NAME}.
	*/
	public class LogicalGridLayout extends Layout implements ILayoutExtension {

	private static final IScoutLogger LOG = ScoutLogManager.getLogger(LogicalGridLayout.class);

	public static final int MIN = 0;
	public static final int PREF = 1;
	public static final int MAX = 2;

	public static final float EPS = 1E-6f;

	private boolean m_debug;
	private final int m_hgap;
	private final int m_vgap;
	private final int m_minWidth;
	private LogicalGridLayoutInfo m_info;
	private CompositeObject m_infoCacheKey;

	public LogicalGridLayout(int hgap, int vgap) {
	this(hgap, vgap, -1);
	}

	public LogicalGridLayout(int hgap, int vgap, int minWidth) {
	m_hgap = hgap;
	m_vgap = vgap;
	m_minWidth = minWidth;
	}

	public LogicalGridLayoutInfo getInfo() {
	return m_info;
	}

	@Override
	public int computeMinimumWidth(Composite parent, boolean changed) {
	return computeMinimumSize(parent, changed).x;
	}

	public Point computeMinimumSize(Composite parent, boolean changed) {
	return computeSize(parent, changed, SWT.DEFAULT, SWT.DEFAULT, MIN);
	}

	@Override
	protected Point computeSize(Composite composite, int wHint, int hHint, boolean flushCache) {
	return computeSize(composite, flushCache, wHint, hHint, PREF);
	}

	@Override
	public int computeMaximumWidth(Composite parent, boolean changed) {
	return computeSize(parent, changed, SWT.DEFAULT, SWT.DEFAULT, MAX).x;
	}

	public Point computeSize(Composite composite, boolean changed, int wHint, int hHint, int sizeFlag) {
	if (changed) {
	m_info = null;
	}
	if (wHint <= 0) {
	wHint = SWT.DEFAULT;
	}
	validateLayout(composite, wHint, changed);

	Point min = new Point(0, 0);
	Point pref = new Point(0, 0);
	Point max = new Point(0, 0);
	// w
	int useCount = 0;
	for (int i = 0; i < m_info.cols; i++) {
	if (useCount > 0) {
	min.x = min.x + m_hgap;
	pref.x = pref.x + m_hgap;
	max.x = max.x + m_hgap;
	}
	min.x = min.x + m_info.width[i][MIN];
	pref.x = pref.x + m_info.width[i][PREF];
	max.x = max.x + m_info.width[i][MAX];
	useCount++;
	}
	// h
	useCount = 0;
	for (int i = 0; i < m_info.rows; i++) {
	if (useCount > 0) {
	min.y = min.y + m_vgap;
	pref.y = pref.y + m_vgap;
	max.y = max.y + m_vgap;
	}
	min.y = min.y + m_info.height[i][MIN];
	pref.y = pref.y + m_info.height[i][PREF];
	max.y = max.y + m_info.height[i][MAX];
	useCount++;
	}
	Point size = new Point(0, 0);
	switch (sizeFlag) {
	case MIN:
	if (m_minWidth < 0) {
	size.x = min.x;
	}
	else {
	size.x = m_minWidth;
	}
	size.y = min.y;
	break;
	case MAX:
	size.x = min.x;
	size.y = min.y;
	break;
	default:
	// adjust width
	if (wHint == SWT.DEFAULT) {
	size.x = pref.x;
	}
	else {
	size.x = wHint;
	size.x = Math.min(max.x, size.x);
	size.x = Math.max(min.x, size.x);
	}
	// adjust height
	if (hHint == SWT.DEFAULT) {
	size.y = pref.y;
	}
	else {
	size.y = hHint;
	size.y = Math.min(max.y, size.y);
	size.y = Math.max(min.y, size.y);
	}
	break;
	}
	return size;
	}

	@Override
	protected void layout(Composite parent, boolean flushCache) {
	if (flushCache) {
	m_info = null;
	}
	Rectangle clientArea = parent.getClientArea();
	validateLayout(parent, clientArea.width, flushCache);
	Point size = new Point(clientArea.width, clientArea.height);
	Rectangle[][] cellBounds = m_info.layoutCellBounds(size);
	if (m_debug \|\| LOG.isDebugEnabled()) {
	dumpLayoutInfo(parent);
	}
	// bounds
	int n = m_info.components.length;
	for (int i = 0; i < n; i++) {
	Control comp = m_info.components[i];
	LogicalGridData data = m_info.gridDatas[i];
	Rectangle r1 = cellBounds[data.gridy][data.gridx];
	Rectangle r2 = cellBounds[data.gridy + data.gridh - 1][data.gridx + data.gridw - 1];
	Rectangle r = r1.union(r2);
	if (data.topInset > 0) {
	r.y += data.topInset;
	r.height -= data.topInset;
	}
	if (data.fillHorizontal && data.fillVertical) {
	// ok
	}
	else {
	Point d = new Point(m_info.componentWidths[i], m_info.componentHeights[i]);
	if (!data.fillHorizontal) {
	if (d.x < r.width) {
	int delta = r.width - d.x;
	r.width = d.x;
	if (data.horizontalAlignment == 0) {
	r.x += delta / 2;
	}
	else if (data.horizontalAlignment > 0) {
	r.x += delta;
	}
	}
	}
	if (!data.fillVertical) {
	if (d.y < r.height) {
	int delta = r.height - d.y;
	if (data.heightHint == 0) {
	r.height = d.y;
	}
	else {
	r.height = data.heightHint;
	}
	if (data.verticalAlignment == 0) {
	r.y += delta / 2;
	}
	else if (data.verticalAlignment > 0) {
	r.y += delta;
	}
	}
	}
	}
	comp.setBounds(r);
	}
	}

	public void setDebug(boolean b) {
	m_debug = b;
	}

	public void dumpLayoutInfo(Composite parent) {
	dumpLayoutInfo(parent, new PrintWriter(System.out));
	}

	public void dumpLayoutInfo(Composite parent, PrintWriter out) {
	Point parentSize = parent.getSize();
	Rectangle[][] cellBounds = m_info.layoutCellBounds(parentSize);
	Object field = SwtScoutComposite.getScoutModelOnWidget(parent);
	String className = "undefined (PROP_SCOUT_OBJECT not set!)";
	if (field != null) {
	className = field.getClass().getSimpleName();
	}
	out.println("DUMP layout of: " + className + " compSize= " + parentSize);
	out.println(" containerBounds = " + parent.getClientArea());
	out.println(" Fields ---");
	for (int i = 0; i < m_info.components.length; i++) {
	Control c = m_info.components[i];
	LogicalGridData data = m_info.gridDatas[i];
	try {
	Rectangle r1 = cellBounds[data.gridy][data.gridx];
	Rectangle r2 = cellBounds[data.gridy + data.gridh - 1][data.gridx + data.gridw - 1];
	Rectangle r = r1.union(r2);
	String scoutObjectName = "NOT DEFINED";
	Object scoutObject = SwtScoutComposite.getScoutModelOnWidget(c);
	if (scoutObject != null) {
	scoutObjectName = scoutObject.getClass().getSimpleName();
	}
	out.println(" b=" + r + " " + scoutObjectName);
	if (scoutObject instanceof IFormField) {
	out.println(" model grid: " + ((IFormField) scoutObject).getGridData().toString());
	}
	out.println(" uiGridData: " + data.toString());
	}
	catch (ArrayIndexOutOfBoundsException e) {
	out.print("unable to print layout info of: " + data);
	e.printStackTrace();
	}
	}
	out.flush();
	}

	protected void validateLayout(Composite parent, int wHint, boolean flushCache) {
	CompositeObject newKey = new CompositeObject(parent.getSize(), wHint == SWT.DEFAULT ? (m_infoCacheKey != null ? m_infoCacheKey.getComponent(1) : wHint) : wHint);
	//check cache key
	if (m_info != null) {
	if (m_infoCacheKey == null \|\| !m_infoCacheKey.equals(newKey)) {
	m_info = null;
	m_infoCacheKey = null;
	}
	}
	if (m_info != null && m_infoCacheKey != null) {
	return;
	}
	List<Control> visibleComps = new ArrayList<>();
	List<LogicalGridData> visibleCons = new ArrayList<>();
	for (Control comp : parent.getChildren()) {
	if (comp.getVisible() && comp.getLayoutData() instanceof LogicalGridData) {
	visibleComps.add(comp);
	LogicalGridData cons = (LogicalGridData) comp.getLayoutData();
	cons.validate();
	visibleCons.add(cons);
	}
	}
	m_info = new LogicalGridLayoutInfo(visibleComps.toArray(new Control[visibleComps.size()]), visibleCons.toArray(new LogicalGridData[visibleCons.size()]), m_hgap, m_vgap, wHint, flushCache);
	m_infoCacheKey = newKey;
	}

	}