~ubuntu-branches/ubuntu/jaunty/electric/jaunty

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

 

import javax.swing.SwingUtilities;

 

 *   When compositing at the top level, however, the POLs are converted back to patterns, so that they line-up.</LI>

 *   </UL>

 * </UL>

 */

public class PixelDrawing

{

    private static class ExpandedCellKey {

        private Cell cell;

        private Orientation orient;

        private ExpandedCellKey(Cell cell, Orientation orient) {

            this.cell = cell;

            this.orient = orient;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj instanceof ExpandedCellKey) {

            }

            return false;

        }

        @Override

        public int hashCode() { return cell.hashCode()^orient.hashCode(); }

    }

        /**

         * This class holds information about expanded cell instances.

         * For efficiency, Electric remembers the bits in an expanded cell instance

                        offscreen = null;

                }

        }

        /** the size of the EditWindow */                                               private final Dimension sz;

    /** the scale of the EditWindow */                      private double scale;

    /** the VarContext of the EditWindow */                 private VarContext varContext = VarContext.globalContext;

    /** the X origin of the cell in display coordinates. */ private double originX;

    /** the Y origin of the cell in display coordinates. */ private double originY;

        /** 0: color display, 1: color printing, 2: B&W printing */     private int nowPrinting;

    /** the area of the cell to draw, in DB units */        private Rectangle2D drawBounds;

        /** whether any layers are highlighted/dimmed */                boolean highlightingLayers;

        /** true if the last display was a full-instantiate */  private boolean lastFullInstantiate = false;

        private byte[][] layerBitMap;

        PatternedOpaqueLayer(int height, int numBytesPerRow) { layerBitMap = new byte[height][numBytesPerRow]; }

    }

        /** the top-level window being rendered */                              private boolean renderedWindow;

 

        /** whether to occasionally update the display. */              private boolean periodicRefresh;

 

        /** the size of the top-level EditWindow */                             private static Dimension topSz;

        /** the last Technology that had transparent layers */  private static Technology techWithLayers = null;

        /** scale of cell expansions. */                                                private static double expandedScale = 0;

        /** number of extra cells to render this time */                private static int numberToReconcile;

        /** zero rectangle */                                                                   private static final Rectangle2D CENTERRECT = new Rectangle2D.Double(0, 0, 0, 0);

                new int[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0});

 

    private int clipLX, clipHX, clipLY, clipHY;

    private final EditWindow0 dummyWnd = new EditWindow0() {

        public VarContext getVarContext() { return varContext; }

        public double getScale() { return scale; }

    };

 

    static class Drawing extends AbstractDrawing {

        private final VectorDrawing vd = new VectorDrawing();

        private volatile PixelDrawing offscreen;

        Drawing(EditWindow wnd) {

            super(wnd);

        }

        @Override

        public boolean paintComponent(Graphics2D g, Dimension sz) {

            assert SwingUtilities.isEventDispatchThread();

            PixelDrawing offscreen = this.offscreen;

            if (offscreen == null || !offscreen.getSize().equals(sz))

                return false;

            // show the image

            g.drawImage(offscreen.getBufferedImage(), 0, 0, wnd);

            return true;

        }

        @Override

        public void render(Dimension sz, WindowFrame.DisplayAttributes da, boolean fullInstantiate, Rectangle2D bounds) {

            PixelDrawing offscreen_ = this.offscreen;

            this.da = da;

            offscreen_.drawImage(this, fullInstantiate, bounds);

        }

        @Override

        public void abortRendering() {

            if (User.getDisplayAlgorithm() > 0)

                vd.abortRendering();

        }

    }

    // ************************************* TOP LEVEL *************************************

 

        /**

        clipHX = sz.width - 1;

        clipLY = 0;

        clipHY = sz.height - 1;

                // allocate pointer to the opaque image

                img = new BufferedImage(sz.width, sz.height, BufferedImage.TYPE_INT_RGB);

                WritableRaster raster = img.getRaster();

                numBytesPerRow = (sz.width + 7) / 8;

                renderedWindow = true;

        }

    public PixelDrawing(double scale, Rectangle screenBounds) {

        this.scale = scale;

        this.originX = -screenBounds.x;

        this.originY = screenBounds.y + screenBounds.height;

        this.sz = new Dimension(screenBounds.width, screenBounds.height);

        clipHX = sz.width - 1;

        clipLY = 0;

        clipHY = sz.height - 1;

                // allocate pointer to the opaque image

        img = null;

                total = sz.height * sz.width;

        opaqueData = new int[total];

                numBytesPerRow = (sz.width + 7) / 8;

                // initialize the data

                clearImage(null);

    }

    void initOrigin(double scale, double offx, double offy) {

        this.scale = scale;

        this.originX = sz.width/2 - offx*scale;

                clearImage(null);

        initOrigin(scale, 0, 0);

    }

    /**

     * Method to set the printing mode used for all drawing.

     * @param mode the printing mode:  0=color display (default), 1=color printing, 2=B&W printing.

         * @return an RGB array for this edit window.

         */

    int[] getOpaqueData() { return opaqueData; }

        /**

         * Method for obtaining the size of the offscreen bitmap.

         * @return the size of the offscreen bitmap.

        double width = sz.width/scale;

        double height = sz.height/scale;

        drawBounds = new Rectangle2D.Double(drawing.da.offX - width/2, drawing.da.offY - height/2, width, height);

 

                // set colors to use

        textColor = new Color(User.getColor(User.ColorPrefType.TEXT));

                textGraphics.setColor(textColor);

                gridGraphics.setColor(new Color(User.getColor(User.ColorPrefType.GRID)));

                instanceGraphics.setColor(new Color(User.getColor(User.ColorPrefType.INSTANCE)));

                // initialize the cache of expanded cell displays

                if (expandedScale != drawing.da.scale)

                {

                objectCount = 0;

                lastRefreshTime = System.currentTimeMillis();

 

        synchronized (changedCells) {

            changedCellsCopy = new HashSet<CellId>(changedCells);

            changedCells.clear();

        {

        clearSubCellCache();

        lastFullInstantiate = false;

 

                // set colors to use

        textColor = new Color(User.getColor(User.ColorPrefType.TEXT));

                textGraphics.setColor(textColor);

                gridGraphics.setColor(new Color(User.getColor(User.ColorPrefType.GRID)));

                instanceGraphics.setColor(new Color(User.getColor(User.ColorPrefType.INSTANCE)));

        if (wnd != null) varContext = wnd.getVarContext();

        initOrigin(scale, offset.getX(), offset.getY());

                canDrawText = expandedScale > 1;

        clipHY = sz.height - 1;

                clearImage(null);

 

        synchronized (changedCells) {

            changedCellsCopy = new HashSet<CellId>(changedCells);

            changedCells.clear();

                                {

                                        int index = baseIndex + x;

                                        int pixelValue = opaqueData[index];

                                        // the value of Alpha starts at 0xFF, which means "background"

                                        // opaque drawing typically sets it to 0, which means "filled"

                                        // Text drawing can antialias by setting the edge values in the range 0-254

                                databaseToScreen(tmpPt.getX(), tmpPt.getY(), tempPt1);

                                int x = tempPt1.x;

                                int y = tempPt1.y;

 

                                double boldValueX = j;

                                if (j < 0) boldValueX -= boldSpacingThreshX/2; else

                Point2D high = new Point2D.Double();

        screenToDatabase(sz.width-1, sz.height-1, high);

        intoCellTransform.transform(high, high);

                double lowX = Math.min(low.getX(), high.getX());

                double lowY = Math.min(low.getY(), high.getY());

                double sizeX = Math.abs(high.getX()-low.getX());

            }

        }

    }

        // ************************************* HIERARCHY TRAVERSAL *************************************

 

        /**

                                double ctrY = ctr.getY();

                if (renderedWindow && drawBounds != null) {

                    Rectangle2D databaseBounds = drawBounds;

                    if (ctrX + halfWidth < databaseBounds.getMinX()) return;

                    if (ctrX - halfWidth > databaseBounds.getMaxX()) return;

                    if (ctrY + halfWidth < databaseBounds.getMinY()) return;

                    if (ctrY - halfWidth > databaseBounds.getMaxY()) return;

                }

                                PrimitiveNode prim = (PrimitiveNode)np;

                                totalPrims++;

                                if (!prim.isCanBeZeroSize() && halfWidth < halfMaxObjectSize && !forceVisible)

                                if (arcSize < maxObjectSize)

                                {

                                        linedArcs++;

                                        // draw a tiny arc by setting a single dot from each layer

                                        Point2D headEnd = new Point2D.Double(ai.getHeadLocation().getX(), ai.getHeadLocation().getY());

                                        trans.transform(headEnd, headEnd);

                        expandedCellCount.offscreen.drawCell(subCell, null, fullInstantiate, orient, rotTrans, topCell);

                        offscreensCreated++;

            offscreenPixelsCreated += expandedCellCount.offscreen.total;

                }

 

                // copy out of the offscreen buffer into the main buffer

        }

        }

 

        {

                // if there is no global for remembering cached cells, do not cache

                if (expandedCells == null) return;

            if (destY < 0 || destY >= sz.height) continue;

            int srcBase = srcY * dim.width;

            int destBase = destY * sz.width;

            for (int srcX = minSrcX; srcX <= maxSrcX; srcX++) {

                int destX = srcX + cornerX;

                assert destX >= clipLX && destX <= clipHX;

            byte [][] srcLayerBitMap = srcOffscreen.layerBitMaps[i];

            if (srcLayerBitMap == null) continue;

            byte [][] destLayerBitMap = getLayerBitMap(i);

            for (int srcY = minSrcY; srcY <= maxSrcY; srcY++) {

                int destY = srcY + cornerY;

                assert destY >= clipLY && destY <= clipHY;

                if (destY < 0 || destY >= sz.height) continue;

                byte [] srcRow = srcLayerBitMap[srcY];

                byte [] destRow = destLayerBitMap[destY];

                for (int srcX = minSrcX; srcX <= maxSrcX; srcX++) {

                    int destX = srcX + cornerX;

                    assert destX >= clipLX && destX <= clipHX;

                    if (destX < 0 || destX >= sz.width) continue;

                    if ((srcRow[srcX>>3] & (1<<(srcX&7))) != 0)

                        destRow[destX>>3] |= (1 << (destX&7));

                }

        }

 

        // ************************************* RENDERING POLY SHAPES *************************************

    /**

     * A class representing a rectangular array of pixels. References

     * to pixels outside of the bounding rectangle may result in an

         * @param lX left X coordinate

         * @param hX right X coordiante

         * @param lY top Y coordinate

         */

        public void fillBox(int lX, int hX, int lY, int hY);

        /**

         * Method to fill a horizontal scanline [lX,hX] x [y].

         * Both low and high coordiantes are inclusive.

         * @param hX right X coordiante

         */

        public void fillHorLine(int y, int lX, int hX);

        /**

         * Method to fill a verticaltal scanline [x] x [lY,hY].

         * Both low and bigh coordiantes are inclusive.

         * @param hY bottom Y coordiante

         */

        public void fillVerLine(int x, int lY, int hY);

        /**

         * Method to fill a point.

         * Filling might be patterned.

         * @param y Y coordinate

         */

        public void fillPoint(int x, int y);

        /**

         * Method to draw a horizontal line [lX,hX] x [y].

         * Both low and high coordiantes are inclusive.

         * @param hX right X coordiante

         */

        public void drawHorLine(int y, int lX, int hX);

        /**

         * Method to draw a vertical line [x] x [lY,hY].

         * Both low and high coordiantes are inclusive.

         * @param hY bottom Y coordiante

         */

        public void drawVerLine(int x, int lY, int hY);

        /**

         * Method to draw a point.

         * @param x X coordinate

         * @param y Y coordinate

         */

        public void drawPoint(int x, int y);

        /**

         * Method to return Electric Outline style for this ERaster.

         * @return Electric Outline style for this ERaster or null for no outline.

         */

        public EGraphics.Outline getOutline();

    }

        // ************************************* RENDERING POLY SHAPES *************************************

 

        /**

        layerBitMaps[layerNum] = layerBitMap;

        numLayerBitMapsCreated++;

        return layerBitMap;

    }

        /**

         * Render a Poly to the offscreen buffer.

         */

        tempPt3.y = y1;

        tempPt4.x = x2;

        tempPt4.y = y2;

                // first clip the line

                if (GenMath.clipLine(tempPt3, tempPt4, 0, sz.width-1, 0, sz.height-1)) return;

 

                                Color full = EGraphics.getColorFromIndex(colorIndex);

                                if (full != null) col = full.getRGB() & 0xFFFFFF;

                        }

                        size = (int)dSize;

                        if (size < MINIMUMTEXTSIZE)

                        {

                                pattern = desc.getPattern();

                                if (desc.getOutlined() != EGraphics.Outline.NOPAT)

                                {

                                }

                        }

                }

                result.x = (int)(scrX >= 0 ? scrX + 0.5 : scrX - 0.5);

                result.y = (int)(scrY >= 0 ? scrY + 0.5 : scrY - 0.5);

    }

    private void screenToDatabase(int x, int y, Point2D result) {

        result.setLocation((x - originX)/scale, (originY - y)/scale);

    }

        /**

         * Method to convert a database rectangle to screen coordinates.

         * @param db the rectangle (in database units).