mirror

diylc/diylc-core/src/main/java/org/diylc/core/BoardUndersideDisplay.java

@@ -0,0 +1,10 @@
+package org.diylc.core;
+
+public enum BoardUndersideDisplay {
+  NONE, ABOVE, BELOW, LEFT, RIGHT;
+  
+  @Override
+  public String toString() {
+    return super.toString().charAt(0) + super.toString().substring(1).toLowerCase();
+  }
+}

diylc/diylc-core/src/main/java/org/diylc/core/IBoard.java

@@ -0,0 +1,16 @@
+package org.diylc.core;
+
+import org.diylc.core.measures.Size;
+
+import java.awt.geom.Rectangle2D;
+
+public interface IBoard {
+  
+  Rectangle2D getBoardRectangle();
+
+  BoardUndersideDisplay getBoardUndersideDisplay();
+
+  Size getUndersideOffset();
+  
+  boolean shouldExportToGerber();
+}

diylc/diylc-core/src/main/java/org/diylc/core/gerber/GerberExporter.java

@@ -13,16 +13,15 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.log4j.Logger;
-
-import com.bancika.gerberwriter.DataLayer;
-
 import org.diylc.core.ComponentState;
+import org.diylc.core.IBoard;
 import org.diylc.core.IDIYComponent;
 import org.diylc.core.IView;
 import org.diylc.core.Project;
 import org.diylc.core.measures.Size;
 import org.diylc.core.measures.SizeUnit;
 import org.diylc.lang.LangUtil;
+import com.bancika.gerberwriter.DataLayer;
 
 public class GerberExporter {
 
@@ -31,12 +30,15 @@ public class GerberExporter {
 
   public static void exportGerber(String fileNameBase, Project currentProject, IView view,
                                   Graphics2D graphics2d, String diylcVersion) {
-    List<IGerberBoard> gerberBoards =
-        currentProject.getComponents().stream().filter(c -> c instanceof IGerberBoard)
-            .map(x -> (IGerberBoard) x).collect(Collectors.toList());
 
-    Map<IGerberBoard, List<IDIYComponent<?>>> boardComponentMap =
-        new HashMap<IGerberBoard, List<IDIYComponent<?>>>();
+    List<IBoard> gerberBoards =
+            currentProject.getComponents().stream()
+                    .filter(IBoard.class::isInstance)
+                    .map(IBoard.class::cast)
+                    .filter(IBoard::shouldExportToGerber).collect(Collectors.toList());
+
+    Map<IBoard, List<IDIYComponent<?>>> boardComponentMap =
+            new HashMap<IBoard, List<IDIYComponent<?>>>();
 
     // DefaultGerberBoard defaultGerberBoard = new DefaultGerberBoard();
 
@@ -45,7 +47,7 @@ public class GerberExporter {
     currentProject.getComponents().stream().filter(c -> c instanceof IGerberComponent)
             .forEach(c -> {
               Point2D firstPoint = c.getControlPoint(0);
-          IGerberBoard board = gerberBoards.stream()
+              IBoard board = gerberBoards.stream()
                       .filter(b -> b.getBoardRectangle().contains(firstPoint)).findFirst().orElse(null);
               if (board == null) {
                 componentsWithoutBoard.add(c);

diylc/diylc-core/src/main/java/org/diylc/core/gerber/IGerberBoard.java

@@ -1,8 +0,0 @@
-package org.diylc.core.gerber;
-
-import java.awt.geom.Rectangle2D;
-
-public interface IGerberBoard {
-  
-  Rectangle2D getBoardRectangle();
-}

diylc/diylc-core/src/main/java/org/diylc/presenter/DrawingCache.java

@@ -74,7 +74,7 @@ public class DrawingCache {
           .extractComponentTypeFrom((Class<? extends IDIYComponent<?>>) x.getComponent().getClass());
 
       if (type != null && type.getEnableCache()) {
-        renderAndCache(x.getComponent(), g2d, x.getState(), outlineMode, project, zoom, scaleFactor, x.getZOrder());
+        renderAndCache(x.getComponent(), g2d, x.getState(), outlineMode, project, zoom, scaleFactor, x.getZOrder(), false);
       }
     });
   }
@@ -89,10 +89,14 @@ public class DrawingCache {
    * @param outlineMode
    * @param project
    * @param zoom
+   * @param scaleFactor
+   * @param zOrder
+   * @param mirrored
    */
   @SuppressWarnings("unchecked")
   public void draw(IDIYComponent<?> component, G2DWrapper g2d, ComponentState componentState,
-      boolean outlineMode, Project project, double zoom, double scaleFactor, int zOrder, Rectangle2D visibleRect) {
+      boolean outlineMode, Project project, double zoom, double scaleFactor, int zOrder, Rectangle2D visibleRect,
+                   boolean mirrored) {
     ComponentType type = ComponentProcessor.getInstance()
         .extractComponentTypeFrom((Class<? extends IDIYComponent<?>>) component.getClass());
 
@@ -100,7 +104,7 @@ public class DrawingCache {
       // if we need to apply caching
       Point2D firstPoint = component.getControlPoint(0);
       
-      CacheValue value = renderAndCache(component, g2d, componentState, outlineMode, project, zoom, scaleFactor, zOrder); 
+      CacheValue value = renderAndCache(component, g2d, componentState, outlineMode, project, zoom, scaleFactor, zOrder, mirrored);
       
       if (value == null) {
         return;
@@ -180,7 +184,7 @@ public class DrawingCache {
   }
   
   private CacheValue renderAndCache(IDIYComponent<?> component, G2DWrapper g2d, ComponentState componentState,
-      boolean outlineMode, Project project, double zoom, double scaleFactor, int zOrder) {
+      boolean outlineMode, Project project, double zoom, double scaleFactor, int zOrder, boolean mirrored) {
     // if we need to apply caching
     Point2D firstPoint = component.getControlPoint(0);
 
@@ -196,7 +200,7 @@ public class DrawingCache {
     // only honor the cache if the component hasn't changed in the meantime
     if (value == null || !value.getComponent().equalsTo(component)
         || value.getState() != componentState || value.getZoom() != zoom || value.getOutlineMode() != outlineMode
-        || value.getScaleFactor() != scaleFactor) {
+        || value.getScaleFactor() != scaleFactor || value.isMirrored() != mirrored) {
       // figure out size and placement of buffer image
       Rectangle2D rect = component.getCachingBounds();
       int width = (int)Math.round(rect.getWidth() * zoom);
@@ -270,7 +274,7 @@ public class DrawingCache {
       
       // add to the cache        
       value = new CacheValue(component, image, wrapper.getCurrentArea(), wrapper.getContinuityPositiveAreas(),
-          wrapper.getContinuityNegativeAreas(), componentState, outlineMode, zoom, scaleFactor, dx, dy, rect);        
+          wrapper.getContinuityNegativeAreas(), componentState, outlineMode, zoom, scaleFactor, dx, dy, rect, mirrored);
       imageCache.put(component, new SoftReference<DrawingCache.CacheValue>(value));
     }
     
@@ -287,6 +291,7 @@ public class DrawingCache {
     boolean outlineMode;
     double zoom;
     double scaleFactor;
+    boolean mirrored;
     int dx;
     int dy;
     Rectangle2D cacheBounds;
@@ -294,7 +299,7 @@ public class DrawingCache {
     public CacheValue(IDIYComponent<?> component, BufferedImage image, Area currentArea,
         Map<String, Area> continuityPositiveAreas,  Map<String, Area> continuityNegativeAreas,
         ComponentState state, boolean outlineMode, double zoom, double scaleFactor, int dx, int dy,
-        Rectangle2D cacheBounds) {
+        Rectangle2D cacheBounds, boolean mirrored) {
       super();
       this.cacheBounds = cacheBounds;
       // take a copy of the component, so we can check if it changed in the meantime
@@ -309,6 +314,7 @@ public class DrawingCache {
       this.state = state;
       this.outlineMode = outlineMode;
       this.zoom = zoom;
+      this.scaleFactor = scaleFactor;
       this.dx = dx;
       this.dy = dy;
     }
@@ -349,6 +355,10 @@ public class DrawingCache {
       return scaleFactor;
     }
 
+    public boolean isMirrored() {
+      return mirrored;
+    }
+
     public int getDx() {
       return dx;
     }

diylc/diylc-core/src/main/java/org/diylc/presenter/DrawingManager.java

@@ -46,17 +46,20 @@ import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.log4j.Logger;
+import org.checkerframework.checker.units.qual.A;
 import org.diylc.appframework.miscutils.IConfigurationManager;
 import org.diylc.appframework.simplemq.MessageDispatcher;
-
 import org.diylc.common.DrawOption;
 import org.diylc.common.EventType;
 import org.diylc.common.GridType;
 import org.diylc.common.IComponentFilter;
 import org.diylc.common.IPlugInPort;
 import org.diylc.common.ObjectCache;
+import org.diylc.components.AbstractTransparentComponent;
+import org.diylc.core.BoardUndersideDisplay;
 import org.diylc.core.ComponentForRender;
 import org.diylc.core.ComponentState;
+import org.diylc.core.IBoard;
 import org.diylc.core.IContinuity;
 import org.diylc.core.IDIYComponent;
 import org.diylc.core.ILayeredComponent;
@@ -92,6 +95,8 @@ public class DrawingManager {
   public static Color CONTROL_POINT_COLOR = Color.blue;
   public static Color SELECTED_CONTROL_POINT_COLOR = Color.green;
 
+  private static final Byte MIRRORED_ALPHA = 64;
+
   private Theme theme;
 
   // Maps keyed by object reference.
@@ -171,12 +176,14 @@ public class DrawingManager {
    * @param visibleRect
    * @return
    */
+  @SuppressWarnings("unlikely-arg-type")
   public List<IDIYComponent<?>> drawProject(Graphics2D g2d, Project project,
                                             Set<DrawOption> drawOptions, IComponentFilter filter, Rectangle selectionRect,
                                             Collection<IDIYComponent<?>> selectedComponents, Set<IDIYComponent<?>> lockedComponents,
                                             Set<IDIYComponent<?>> groupedComponents, List<Point2D> controlPointSlot,
                                             List<IDIYComponent<?>> componentSlot, boolean dragInProgress, Double externalZoom,
                                             Double scaleFactor, Rectangle2D visibleRect) {
+
     long totalStartTime = System.nanoTime();
     failedComponents.clear();
     if (project == null) {
@@ -195,38 +202,35 @@ public class DrawingManager {
 
     G2DWrapper g2dWrapper = new G2DWrapper(g2d, zoom);
 
-    if (drawOptions.contains(DrawOption.ANTIALIASING)) {
-      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
-      g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-          RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
-    } else {
-      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
-      g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-          RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+    configureG2D(g2d, drawOptions);
+
+    // group components with boards that contain them
+    Map<IBoard, List<IDIYComponent<?>>> boardMap = project.getComponents().stream()
+            .filter(IBoard.class::isInstance)
+            .map(IBoard.class::cast)
+            .filter(b -> b.getBoardUndersideDisplay() != BoardUndersideDisplay.NONE)
+            .collect(Collectors.toMap(x -> x, x -> new ArrayList<IDIYComponent<?>>()));
+    Map<IDIYComponent<?>, List<IBoard>> componentBoardMap = new HashMap<IDIYComponent<?>, List<IBoard>>();
+
+    for (IBoard board : boardMap.keySet()) {
+      Rectangle2D boardRect = board.getBoardRectangle();
+      for (IDIYComponent<?> c : project.getComponents()) {
+        if (c == board) {
+          continue;
+        }
+        boolean include = true;
+        for (int i = 0; i < c.getControlPointCount(); i++) {
+          if (!boardRect.contains(c.getControlPoint(i))) {
+            include = false;
+            break;
+          }
+        }
+        if (include) {
+          boardMap.get(board).add(c);
+          componentBoardMap.computeIfAbsent(c, key -> new ArrayList<IBoard>()).add(board);
+        }
       }
-    if (configManager.readBoolean(IPlugInPort.HI_QUALITY_RENDER_KEY, false)) {
-      g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
-          RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
-      g2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
-          RenderingHints.VALUE_COLOR_RENDER_QUALITY);
-      g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
-      g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
-      g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
-      // g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
-      // RenderingHints.VALUE_STROKE_PURE);
-    } else {
-      g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
-          RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
-      g2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
-          RenderingHints.VALUE_COLOR_RENDER_SPEED);
-      g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
-      g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
-      g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
-          RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
     }
-    g2d.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
-        RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
 
     // AffineTransform initialTx = g2d.getTransform();
     Dimension canvasDimension =
@@ -292,12 +296,13 @@ public class DrawingManager {
       if (filter != null && !filter.testComponent(component)) {
         continue;
       }
+
       ComponentState state = componentStateMap.get(component);
       // Do not track the area if component is not invalidated and was
       // drawn in the same state.
       boolean trackArea = lastDrawnStateMap.get(component) != state;
 
-      synchronized (g2d) {
+      synchronized (this) {
         g2dWrapper.startedDrawingComponent(i);
         if (!trackArea) {
           g2dWrapper.stopTracking();
@@ -312,15 +317,26 @@ public class DrawingManager {
         long componentStart = System.nanoTime();
         try {
 
-          if (drawOptions.contains(DrawOption.ENABLE_CACHING)) // go through the DrawingCache
-            DrawingCache.Instance.draw(component, g2dWrapper, state,
-                drawOptions.contains(DrawOption.OUTLINE_MODE), project, zoom, scaleFactor, i, visibleRect);
-          else // go straight to the wrapper
-            component.draw(g2dWrapper, state, outlineMode, project, g2dWrapper);
+          AffineTransform txBefore = new AffineTransform(g2d.getTransform());
+          drawComponent(project, drawOptions, scaleFactor, visibleRect, zoom, g2dWrapper,
+                  outlineMode, i, component, state, false);
+          g2dWrapper.setTransform(txBefore);
 
-          if (g2dWrapper.isTrackingContinuityArea()) {
-            LOG.info("Component " + component.getName() + " of type "
-                + component.getClass().getName() + " did not stop tracking continuity area.");
+          // find one or more boards that contain the component and mirror the component to all
+          List<IBoard> boards = componentBoardMap.get(component);
+          if (boards != null) {
+            for (IBoard board : boards) {
+              double boardMirrorSpacing  = board.getUndersideOffset().convertToPixels();
+              drawMirroredComponent(project, drawOptions, scaleFactor, visibleRect, zoom,
+                      g2dWrapper, outlineMode, i, state, boardMirrorSpacing, component, board);
+            }
+          }
+          // if the component is the board itself, mirror it
+          if (boardMap.keySet().contains(component)) {
+            IBoard board = (IBoard) component;
+            double boardMirrorSpacing  = board.getUndersideOffset().convertToPixels();
+            drawMirroredComponent(project, drawOptions, scaleFactor, visibleRect, zoom,
+                    g2dWrapper, outlineMode, i, state, boardMirrorSpacing, component, (IBoard)component);
           }
         } catch (Exception e) {
           LOG.error("Error drawing " + component.getName(), e);
@@ -510,6 +526,123 @@ public class DrawingManager {
     return failedComponents;
   }
 
+  private void drawMirroredComponent(Project project, Set<DrawOption> drawOptions,
+                                     Double scaleFactor, Rectangle2D visibleRect, double zoom, G2DWrapper g2dWrapper,
+                                     boolean outlineMode, int i, ComponentState state, double boardMirrorSpacing,
+                                     IDIYComponent<?> componentToDraw, IBoard board) {
+    Rectangle2D boardRectangle = board.getBoardRectangle();
+    AffineTransform mirrorTx = null;
+    switch (board.getBoardUndersideDisplay()) {
+      case ABOVE:
+        mirrorTx = new AffineTransform();
+        mirrorTx.translate(boardRectangle.getMinX(), boardRectangle.getMinY());
+        mirrorTx.scale(1, -1);
+        mirrorTx.translate(-boardRectangle.getMinX(), -boardRectangle.getMinY());
+        mirrorTx.translate(0, boardMirrorSpacing);
+        break;
+      case BELOW:
+        mirrorTx = new AffineTransform();
+        mirrorTx.translate(boardRectangle.getMinX(), boardRectangle.getMaxY());
+        mirrorTx.scale(1, -1);
+        mirrorTx.translate(-boardRectangle.getMinX(), -boardRectangle.getMaxY());
+        mirrorTx.translate(0, -boardMirrorSpacing);
+        break;
+      case LEFT:
+        mirrorTx = new AffineTransform();
+        mirrorTx.translate(boardRectangle.getMinX(), boardRectangle.getMinY());
+        mirrorTx.scale(-1, 1);
+        mirrorTx.translate(-boardRectangle.getMinX(), -boardRectangle.getMinY());
+        mirrorTx.translate(boardMirrorSpacing, 0);
+        break;
+      case RIGHT:
+        mirrorTx = new AffineTransform();
+        mirrorTx.translate(boardRectangle.getMaxX(), boardRectangle.getMinY());
+        mirrorTx.scale(-1, 1);
+        mirrorTx.translate(-boardRectangle.getMaxX(), -boardRectangle.getMinY());
+        mirrorTx.translate(-boardMirrorSpacing, 0);
+        break;
+      default:
+        LOG.warn("Unexpected board underside display: " + board.getBoardUndersideDisplay());
+        break;
+    }
+    AffineTransform txBefore = new AffineTransform(g2dWrapper.getTransform());
+    byte alphaBefore = 0;
+    if (AbstractTransparentComponent.class.isInstance(componentToDraw)) {
+      alphaBefore = ((AbstractTransparentComponent<?>)componentToDraw).getAlpha();
+      ((AbstractTransparentComponent<?>)componentToDraw).setAlpha(MIRRORED_ALPHA);
+    }
+    try {
+      g2dWrapper.setMirrorTransform(mirrorTx);
+      g2dWrapper.transform(mirrorTx);
+
+      drawComponent(project, drawOptions, scaleFactor, visibleRect, zoom, g2dWrapper, outlineMode, i, componentToDraw, state, true);
+
+//      componentToDraw.draw(g2dWrapper, state, outlineMode, project, g2dWrapper);
+    } finally {
+      g2dWrapper.setTransform(txBefore);
+      g2dWrapper.setMirrorTransform(null);
+      if (AbstractTransparentComponent.class.isInstance(componentToDraw)) {
+        ((AbstractTransparentComponent<?>)componentToDraw).setAlpha(alphaBefore);
+      }
+    }
+  }
+
+  private void drawComponent(Project project, Set<DrawOption> drawOptions, Double scaleFactor,
+                             Rectangle2D visibleRect, double zoom, G2DWrapper g2dWrapper, boolean outlineMode, int i,
+                             IDIYComponent<?> component, ComponentState state, boolean mirrored) {
+
+    AffineTransform txBefore = new AffineTransform(g2dWrapper.getTransform());
+    try {
+      if (drawOptions.contains(DrawOption.ENABLE_CACHING)) // go through the DrawingCache
+        DrawingCache.Instance.draw(component, g2dWrapper, state,
+                drawOptions.contains(DrawOption.OUTLINE_MODE), project, zoom, scaleFactor, i, visibleRect, mirrored);
+      else // go straight to the wrapper
+        component.draw(g2dWrapper, state, outlineMode, project, g2dWrapper);
+
+      if (g2dWrapper.isTrackingContinuityArea()) {
+        LOG.debug("Component " + component.getName() + " of type "
+                + component.getClass().getName() + " did not stop tracking continuity area.");
+      }
+    } finally {
+      g2dWrapper.setTransform(txBefore);
+    }
+  }
+
+  private void configureG2D(Graphics2D g2d, Set<DrawOption> drawOptions) {
+    if (drawOptions.contains(DrawOption.ANTIALIASING)) {
+      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+      g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+              RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+    } else {
+      g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
+      g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+              RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+    }
+    if (configManager.readBoolean(IPlugInPort.HI_QUALITY_RENDER_KEY, false)) {
+      g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
+              RenderingHints.VALUE_ALPHA_INTERPOLATION_QUALITY);
+      g2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
+              RenderingHints.VALUE_COLOR_RENDER_QUALITY);
+      g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
+      g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_ENABLE);
+      g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+              RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+      // g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
+      // RenderingHints.VALUE_STROKE_PURE);
+    } else {
+      g2d.setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,
+              RenderingHints.VALUE_ALPHA_INTERPOLATION_SPEED);
+      g2d.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING,
+              RenderingHints.VALUE_COLOR_RENDER_SPEED);
+      g2d.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
+      g2d.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
+      g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+              RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+    }
+    g2d.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
+            RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
+  }
+
   private double zoomCached = 0;
   private Dimension canvasDimensionCached;
   private double extraSpaceCached;

diylc/diylc-core/src/main/java/org/diylc/presenter/G2DWrapper.java

@@ -62,7 +62,6 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
-
 import org.diylc.common.ObjectCache;
 import org.diylc.common.ZoomableStroke;
 import org.diylc.core.IDrawingObserver;
@@ -70,7 +69,7 @@ import org.diylc.core.IDrawingObserver;
 /**
  * {@link Graphics2D} wrapper that keeps track of all drawing actions and creates an {@link Area}
  * that corresponds to drawn objects. Before each component is drawn,
- * {@link #startedDrawingComponent()} should be called. After the component is drawn, area may be
+ * {@link #startedDrawingComponent(int)} ()} should be called. After the component is drawn, area may be
  * retrieved using {@link #finishedDrawingComponent()}. Graphics configuration (color, font, etc) is
  * reset between each two components.
  *
@@ -107,6 +106,8 @@ class G2DWrapper extends Graphics2D implements IDrawingObserver {
   private double zoom;
   private int zOrder;
 
+  private AffineTransform mirrorTransform;
+
   /**
    * Creates a wrapper around specified {@link Graphics2D} object.
    *
@@ -221,6 +222,10 @@ class G2DWrapper extends Graphics2D implements IDrawingObserver {
     continuityMarker = marker;
   }
 
+  public void setMirrorTransform(AffineTransform mirrorTransform) {
+    this.mirrorTransform = mirrorTransform;
+  }
+
   /**
    * Appends shape interior to the current component area.
    *
@@ -345,22 +350,73 @@ class G2DWrapper extends Graphics2D implements IDrawingObserver {
 
   @Override
   public void drawString(String str, int x, int y) {
-    canvasGraphics.drawString(str, x, y);
-    if (drawingComponent && trackingAllowed) {
-      FontMetrics fontMetrics = canvasGraphics.getFontMetrics();
-      Rectangle2D rect = fontMetrics.getStringBounds(str, canvasGraphics);
-      Point2D point = new Point2D.Double(x, y);
-      // currentTx.transform(point, point);
-      Rectangle2D finalRec =
-          new Rectangle2D.Double(rect.getX() + point.getX(), rect.getY() + point.getY(), rect.getWidth(),
-              rect.getHeight());
-      appendShape(finalRec);
-    }
+    this.drawString(str, (float)x, (float)y);
   }
 
   @Override
   public void drawString(String str, float x, float y) {
+    if (this.mirrorTransform == null) {
       canvasGraphics.drawString(str, x, y);
+    } else {
+      drawStringUnmirrored(str, x, y);
+    }
+    handleDrawString(str, x, y);
+  }
+
+  private void drawStringUnmirrored(String str, float x, float y) {
+    // Save the current transform (T), which includes the mirror.
+    AffineTransform originalTransform = new AffineTransform(getTransform());
+
+    // Compute the non-mirrored transform A by "canceling" the mirror:
+    // Since T = A ? M and M is self-inverse, we have A = T ? M.
+    AffineTransform nonMirroredTransform = new AffineTransform(originalTransform);
+    nonMirroredTransform.concatenate(mirrorTransform);
+
+    GlyphVector gv = getFont().createGlyphVector(this.getFontRenderContext(), str);
+    Rectangle2D visualBounds = gv.getVisualBounds();
+    // Use a temporary Graphics2D (with transform A) to obtain correct FontMetrics.
+    Graphics2D gTemp = (Graphics2D) canvasGraphics.create();
+    gTemp.setTransform(nonMirroredTransform);
+    FontMetrics fm = gTemp.getFontMetrics();
+    double textWidth  = fm.stringWidth(str);
+    // Use ascent + descent as the bounding box height.
+    double textHeight = visualBounds.getHeight();//fm.getAscent() + fm.getDescent();
+    double ascent     = fm.getAscent();
+    gTemp.dispose();
+
+    // 1. Compute the center of the text?s bounding box in the mirrored (T) space.
+    Point2D centerMirrored = new Point2D.Double(x + textWidth / 2.0,
+            y + textHeight / 2.0);
+
+    // 2. Convert that center to screen coordinates using the original transform T.
+    Point2D centerScreen = originalTransform.transform(centerMirrored, null);
+
+    // 3. Map the screen coordinate into the non-mirrored coordinate system (A).
+    Point2D centerNonMirrored;
+    try {
+      centerNonMirrored = nonMirroredTransform.createInverse().transform(centerScreen, null);
+    } catch (NoninvertibleTransformException e) {
+      e.printStackTrace();
+      centerNonMirrored = centerMirrored; // Fallback if inversion fails.
+    }
+
+    // 4. Compute the new top-left in A so that the bounding box (width x height)
+    //     remains centered at centerNonMirrored.
+    double newTopLeftX = centerNonMirrored.getX() - textWidth / 2.0;
+    double newTopLeftY = centerNonMirrored.getY() - textHeight / 2.0;
+    // Adjust for the baseline (drawString uses the baseline for y)
+    float drawX = (float) newTopLeftX;
+    float drawY = (float) (newTopLeftY + ascent);
+
+    // 5. Set the transform to the non-mirrored transform (A) so that mirror is canceled.
+    canvasGraphics.setTransform(nonMirroredTransform);
+    canvasGraphics.drawString(str, drawX, drawY);
+
+    // 6. Restore the original transform.
+    setTransform(originalTransform);
+  }
+
+  private void handleDrawString(String str, float x, float y) {
     if (drawingComponent && trackingAllowed) {
       FontMetrics fontMetrics = canvasGraphics.getFontMetrics();
       Rectangle2D rect = fontMetrics.getStringBounds(str, canvasGraphics);

diylc/diylc-library/src/main/java/org/diylc/components/boards/AbstractBoard.java

@@ -28,14 +28,15 @@ import java.awt.Graphics2D;
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
 import org.diylc.appframework.miscutils.ConfigurationManager;
-
 import org.diylc.awt.StringUtils;
 import org.diylc.common.HorizontalAlignment;
 import org.diylc.common.IPlugInPort;
 import org.diylc.common.ObjectCache;
 import org.diylc.common.VerticalAlignment;
 import org.diylc.components.AbstractTransparentComponent;
+import org.diylc.core.BoardUndersideDisplay;
 import org.diylc.core.ComponentState;
+import org.diylc.core.IBoard;
 import org.diylc.core.IDrawingObserver;
 import org.diylc.core.Project;
 import org.diylc.core.VisibilityPolicy;
@@ -43,9 +44,10 @@ import org.diylc.core.annotations.EditableProperty;
 import org.diylc.core.measures.Size;
 import org.diylc.core.measures.SizeUnit;
 
-public abstract class AbstractBoard extends AbstractTransparentComponent<String> {
+public abstract class AbstractBoard extends AbstractTransparentComponent<String> implements IBoard {
 
   private static final long serialVersionUID = 1L;
+  public static final Size DEFAULT_UNDERSIDE_OFFSET = new Size(0.1, SizeUnit.in);
 
   public static Color BORDER_COLOR = PHENOLIC_COLOR.darker();
   public static Color COORDINATE_COLOR = Color.gray.brighter();
@@ -74,6 +76,9 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
   protected Size width;
   protected BoardSizingMode mode = BoardSizingMode.TwoPoints;
 
+  protected BoardUndersideDisplay boardUndersideDisplay = BoardUndersideDisplay.NONE;
+  protected Size undersideOffset = DEFAULT_UNDERSIDE_OFFSET;
+
   @Override
   public void draw(Graphics2D g2d, ComponentState componentState, boolean outlineMode, Project project,
                    IDrawingObserver drawingObserver) {
@@ -364,6 +369,45 @@ public abstract class AbstractBoard extends AbstractTransparentComponent<String>
     this.mode = mode;
   }
 
+  @EditableProperty(name = "Underside Display")
+  @Override
+  public BoardUndersideDisplay getBoardUndersideDisplay() {
+    if (this.boardUndersideDisplay == null) {
+      this.boardUndersideDisplay = BoardUndersideDisplay.NONE;
+    }
+    return this.boardUndersideDisplay;
+  }
+
+  public void setBoardUndersideDisplay(BoardUndersideDisplay boardUndersideDisplay) {
+    this.boardUndersideDisplay = boardUndersideDisplay;
+  }
+
+  @EditableProperty(name = "Underside Offset")
+  @Override
+  public Size getUndersideOffset() {
+    if (undersideOffset == null) {
+      undersideOffset = DEFAULT_UNDERSIDE_OFFSET;
+    }
+    return undersideOffset;
+  }
+
+  public void setUndersideOffset(Size undersideOffset) {
+    this.undersideOffset = undersideOffset;
+  }
+
+  @Override
+  public Rectangle2D getBoardRectangle() {
+    Point2D finalSecondPoint = getFinalSecondPoint();
+
+    return new Rectangle2D.Double(firstPoint.getX(), firstPoint.getY(),
+            finalSecondPoint.getX() - firstPoint.getX(), finalSecondPoint.getY() - firstPoint.getY());
+  }
+
+  @Override
+  public boolean shouldExportToGerber() {
+    return false;
+  }
+
   @Override
   public Rectangle2D getCachingBounds() {
     Point2D finalSecondPoint = getFinalSecondPoint();

diylc/diylc-library/src/main/java/org/diylc/components/boards/BlankBoard.java

@@ -28,7 +28,6 @@ import java.awt.Graphics2D;
 import java.awt.Shape;
 import java.awt.geom.Point2D;
 import java.awt.geom.Rectangle2D;
-
 import org.diylc.common.ObjectCache;
 import org.diylc.components.transform.SimpleComponentTransformer;
 import org.diylc.core.ComponentState;
@@ -38,12 +37,11 @@ import org.diylc.core.Project;
 import org.diylc.core.annotations.BomPolicy;
 import org.diylc.core.annotations.ComponentDescriptor;
 import org.diylc.core.annotations.EditableProperty;
-import org.diylc.core.gerber.IGerberBoard;
 
 @ComponentDescriptor(name = "Blank Board", category = "Boards", author = "Branislav Stojkovic",
         zOrder = IDIYComponent.BOARD, instanceNamePrefix = "Board", description = "Blank circuit board",
         bomPolicy = BomPolicy.SHOW_ONLY_TYPE_NAME, autoEdit = false, transformer = SimpleComponentTransformer.class)
-public class BlankBoard extends AbstractBoard implements IGerberBoard {
+public class BlankBoard extends AbstractBoard {
 
   private static final long serialVersionUID = 1L;
 
@@ -134,6 +132,11 @@ public class BlankBoard extends AbstractBoard implements IGerberBoard {
     return null;
   }
 
+  @Override
+  public boolean shouldExportToGerber() {
+    return true;
+  }
+
   static enum Type {
     ROUND, SQUARE;
 
@@ -142,12 +145,4 @@ public class BlankBoard extends AbstractBoard implements IGerberBoard {
       return name().substring(0, 1) + name().substring(1).toLowerCase();
     }
   }
-
-  @Override
-  public Rectangle2D getBoardRectangle() {
-    Point2D finalSecondPoint = getFinalSecondPoint();
-    
-    return new Rectangle2D.Double(firstPoint.getX(), firstPoint.getY(), 
-        finalSecondPoint.getX() - firstPoint.getX(), finalSecondPoint.getY() - firstPoint.getY());    
-  }
 }

diylc/diylc-swing/dict.txt

@@ -583,6 +583,8 @@ Tubular Beveled
 Two
 Type
 Ultra-miniature
+Underside Display
+Underside Offset
 Underside Pad Color
 Underside Trace Color
 Undo