reportelement.java

来自「优秀的打印控件全源代码,类似水晶表的设计器!」· Java 代码 · 共 947 行 · 第 1/2 页

/*
 * ReportElement.java
 *
 *  iReport  --  Visual designer for generating JasperReports Documents
 *  Copyright (C) 2002  Giulio Toffoli [e-mail]
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  Giulio Toffoli
 *  Via T.Aspetti, 233
 *  35100 Padova ITALY
 *  [e-mail]
 *
 *
 *  Created on 22 febbraio 2003, 15.03
 *
 *  Updated 3 July 2003, 2004 by Robert Lamping
 *  - Added: adjustBand()
      Moving a element will trigger iReports to see whether
 *    an element is entirely within another band
 *    If so, the element's band is modified to the band it is placed in.
 *  - Modified: trasform()
 *    Included adjustBand() at the end.
 */
package it.businesslogic.ireport;

import it.businesslogic.ireport.gui.*;
import it.businesslogic.ireport.util.*;
import java.awt.*;
import java.awt.image.*;
import java.awt.geom.*;
import java.util.Iterator;
import java.util.Vector;

public class ReportElement {
    
    static int id_gen=1;
    public String name;
    public Point position;
    public int width;
    public int height;
    Rectangle bounds;
    public static BufferedImage hached=null;
    public Band band;
    public String transparent;
    
    public String printWhenExpression="";
    public String positionType="FixRelativeToTop";
    public boolean isPrintRepeatedValues=true;
    public boolean isRemoveLineWhenBlank=false;
    public boolean isPrintInFirstWholeBand=false;
    public boolean isPrintWhenDetailOverflows=false;
    public static Color lightcolor;
    
    public String printWhenGroupChanges="";
    double zoom_factor=1.0;
    
    public Color bgcolor = null;
    public Color fgcolor = null;
    
    protected String stretchType;
    
    public Vector intersections = new Vector();
    
    public ReportElement(int x, int y, int width, int height) {
        if (hached == null)
            hached = Misc.loadBufferedImageFromResources(new java.awt.Panel() ,"it/businesslogic/ireport/icons/layout/hached.gif");
        this.position = new Point(x,y);
        this.width=width;
        this.height=height;
        
        bounds = new Rectangle(position.x,position.y,width,height);
        name = "element-"+id_gen;
        
        id_gen++;
        this.hached = hached;
        
        bgcolor = Color.WHITE;
        fgcolor = Color.BLACK;
        
        if (lightcolor == null) lightcolor = Color.LIGHT_GRAY;
        transparent = "Opaque";
        stretchType = "NoStretch";
    }
    
    
    public void drawObject(Graphics2D g, double zoom_factor, int x_shift_origin, int y_shift_origin) {
        position.x -= 10;
        position.y -= 10;
        x_shift_origin -= 10;
        y_shift_origin -= 10;
        
        this.zoom_factor = zoom_factor;
        //g.setPaint( new TexturePaint( red, new Rectangle2D.Double( zoomed_width+10-horizontal_scroll,9-vertical_scroll,9,9)));
        
        g.fillRect( getZoomedDim(position.x)-x_shift_origin,
        getZoomedDim(position.y)-y_shift_origin,
        getZoomedDim(width),
        getZoomedDim(height));
        
        //g.drawRect(getZoomedDim(position.x)-x_shift_origin, getZoomedDim(position.y)-y_shift_origin, getZoomedDim(width), getZoomedDim(height));
        
        position.x += 10;
        position.y += 10;
        x_shift_origin += 10;
        y_shift_origin += 10;
        
        drawGraphicsElement(g,"2Point", zoom_factor,  x_shift_origin,y_shift_origin);
        drawBorder(g, zoom_factor,  x_shift_origin,y_shift_origin);
    }
    
    public void  drawGraphicsElement(Graphics2D g, String pen, double zoom_factor, int x_shift_origin, int y_shift_origin) {
        drawGraphicsElement( g, pen, zoom_factor, x_shift_origin, y_shift_origin,0);
    }
    
    public void  drawGraphicsElement(Graphics2D g, String pen, double zoom_factor, int x_shift_origin, int y_shift_origin,int radius) {
        
        int correction = (zoom_factor <= 1 && (pen.equals("Thin") || pen.equals("1Point") || pen.equals("Dotted") )  ) ? -1 : 0;
        int xy_correction = (zoom_factor <= 1 && pen.equals("Dotted")) ? 1 : 0;
        
        Stroke stroke = getPenStroke( pen,zoom_factor );
        g.setColor( this.fgcolor );
        
        this.zoom_factor = zoom_factor;
        if (stroke==null || pen.equalsIgnoreCase("None")) return;
        
        position.x -= 10;
        position.y -= 10;
        x_shift_origin -= 10;
        y_shift_origin -= 10;
        
        Stroke oldStroke = g.getStroke();
        g.setStroke(stroke);
        
        
        if (radius != 0) {
            g.drawRoundRect(
            getZoomedDim(position.x)-x_shift_origin+xy_correction,
            getZoomedDim(position.y)-y_shift_origin+xy_correction,
            getZoomedDim(width)+correction,getZoomedDim(height)+correction,radius,radius);
        }
        else {
            g.drawRect(
            getZoomedDim(position.x)-x_shift_origin+xy_correction,
            getZoomedDim(position.y)-y_shift_origin+xy_correction,
            getZoomedDim(width) + correction,getZoomedDim(height)+correction);
        }
        
        position.x += 10;
        position.y += 10;
        
        g.setStroke(oldStroke);
    }
    
    public void  drawBorder(Graphics2D g,double zoom_factor, int x_shift_origin, int y_shift_origin) {
        this.zoom_factor = zoom_factor;
        
        int correction = (zoom_factor <= 1 ) ? -1 : 0;
        
        
        position.x -= 10;
        position.y -= 10;
        x_shift_origin -= 10;
        y_shift_origin -= 10;
        
        if ( insideBand() ) {
            g.setColor( lightcolor);
        } else {
            g.setColor( Color.RED);
        }
        
        g.drawRect(
        getZoomedDim(position.x)-x_shift_origin,
        getZoomedDim(position.y)-y_shift_origin,
        getZoomedDim(width) + correction,getZoomedDim(height)+correction);
        
        
        position.x += 10;
        position.y += 10;
        x_shift_origin += 10;
        y_shift_origin += 10;
    }
    
    public void drawCorona(Graphics2D g, double zoom_factor, int x_shift_origin, int y_shift_origin, boolean selected) {
        
        this.zoom_factor = zoom_factor;
        // draw a  corona...
        position.x -= 10;
        position.y -= 10;
        x_shift_origin -= 10;
        y_shift_origin -= 10;
        
        Rectangle2D r =  new Rectangle2D.Double(getZoomedDim(position.x)-5-x_shift_origin,
        getZoomedDim(position.y)-5-y_shift_origin,
        getZoomedDim(width)+10,
        getZoomedDim(height)+10);
        
        Rectangle2D r2 = new Rectangle2D.Double( getZoomedDim(position.x)-x_shift_origin,
        getZoomedDim(position.y)-y_shift_origin,
        getZoomedDim(width),
        getZoomedDim(height));
        java.awt.geom.Area area = new Area(r);
        area.exclusiveOr( new Area(r2));
        if (hached == null) {
            g.fill(area);
        }
        else {
            g.setPaint( new java.awt.TexturePaint( hached, new Rectangle2D.Double(0,0,2,2 ) ));
            g.fill(area);
        }
        // draw grips...
        g.setPaint(Color.BLUE);
        
        if (!selected) {
            g.setPaint(Color.GRAY);
        }
        
        // checking overlaps slows down the repainting
        if (intersectsElements() ) {
            if ( enclosesOtherElement() ) {
                g.setPaint(Color.PINK);
            } else {
                g.setPaint(Color.GREEN);
            }
            
        }
        
        if ( !insideBand()) {
            g.setPaint(Color.RED);
        }
        
        
        
        g.fillRect(getZoomedDim(position.x)-5-x_shift_origin, getZoomedDim(position.y)-5-y_shift_origin,5,5);
        g.fillRect(getZoomedDim(position.x+width+1)-x_shift_origin, getZoomedDim(position.y)-5-y_shift_origin,5,5);
        g.fillRect(getZoomedDim(position.x+width)-x_shift_origin, getZoomedDim(position.y+height)-y_shift_origin,5,5);
        g.fillRect(getZoomedDim(position.x)-5-x_shift_origin, getZoomedDim(position.y+height)-y_shift_origin,5,5);
        
        g.fillRect(getZoomedDim(position.x+(width/2))-2-x_shift_origin, getZoomedDim(position.y)-5-y_shift_origin,5,5);
        g.fillRect(getZoomedDim(position.x+(width/2))-2-x_shift_origin, getZoomedDim(position.y+height)-y_shift_origin,5,5);
        g.fillRect(getZoomedDim(position.x)-5-x_shift_origin, getZoomedDim(position.y+(height/2))-2-y_shift_origin,5,5);
        g.fillRect(getZoomedDim(position.x+width)-x_shift_origin, getZoomedDim(position.y+(height/2))-2-y_shift_origin,5,5);
        
        position.x += 10;
        position.y += 10;
    }
    
    
    public boolean enclosesOtherElement() {
        for (Iterator i = intersections.iterator(); i.hasNext(); ) {
            ReportElement e = (ReportElement) i.next();
            if (bounds.contains(e.bounds) ) {
                return true;
            }
        }
        return false;
    }
    
    public boolean intersectsElements() {
        int oldHeight = 0;
        boolean result = false;
        
        // do not stop after you found an intersection
        // list them all so that
        // later on you can see whether one is hidden or enclosed by the
        // current element.
        for (Iterator i = band.getParent().getElements().iterator(); i.hasNext(); ) {
            ReportElement e = (ReportElement) i.next();
            
            // do not compare with 'this' reportElement
            if ( ! this.equals( e ) ) {
                oldHeight = e.height;
                
                // make lines a little heigher,so that they can intersect
                // with a rectangle
                if (e.height == 0 ) {
                    e.height = 10;
                }
                
                if (e.bounds.intersects(bounds) ) {
                    // store the intersecting rectangle
                    this.intersections.add( e );
                    result = true;
                }
                e.height = oldHeight;
            }
        }
        
        return result;
    }
    
    public boolean intersects(Point p) {
        Rectangle r = new Rectangle(bounds);
        if (height == 0) {
            r.height = 10;
            r.y -= 5;
        }
        if (width  == 0) {
            r.width = 10;
            r.x -= 5;
        }
        return r.intersects(p.x,p.y,1,1);
    }
    
    public boolean insideBandReal() {
        position.x -= 10;
        position.y -= 10;
        
        boolean result = insideBand();
        
        position.x += 10;
        position.y += 10;
        
        return result;
    }
    public boolean insideBand() {
        if ( band == null )
            return false; // no parent ?????
        
        int yband = band.getBandYLocation();
        
        // lower left corner of element is below the band.
        if ( position.y - yband < 0 )
            return false;
        
        // lower left corner of element is left from the left margin
        if ( position.x - band.getParent().getLeftMargin() < 0 )
            return false;
        
        // with element on the bottom the element is too high for the band
        if ( position.y - yband + height > band.getHeight() )
            return false;
        
        // with element on the left margin, the width is larger than usable width of page.
        if ( position.x -  band.getParent().getLeftMargin() + width > band.getUsableWidth() )
            return false  ;
        return true;
    }
    
    
    public boolean intersects(Rectangle r2) {
        Rectangle r = new Rectangle(bounds);
        if (height == 0) {
            r.height = 10;
            r.y -= 5;
        }
        if (width  == 0) {
            r.width = 10;
            r.x -= 5;
        }
        
        return r.intersects(r2);
    }
    
    public void setPosition(Point p) {
        if (p == null) return;
        if (p.x == position.x && p.y == position.y) return;
        position.x = p.x;
        position.y = p.y;
        bounds = new Rectangle(position.x,position.y,width,height);
    }
    
    public Point trasform(Point delta, int type) {
        if (delta == null) return null;
        Point result = new Point(delta);
        int old_x = 0;
        int old_y = 0;
        
        if (type == TransformationType.TRANSFORMATION_MOVE) {
            position.x += delta.x;
            position.y += delta.y;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_E) {
            old_x = width;
            width += delta.x;
            if (width <0) width=0;
            result.x = width - old_x;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_W) {
            old_x = width;
            int d = Math.min(delta.x,width);
            width -= d;
            position.x += d;
            result.x = d;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_N) {
            int d = Math.min(delta.y,height);
            height -= d;
            position.y += d;
            result.y = d;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_S) {
            old_y = height;
            height += delta.y;
            if (height <0) height=0;
            result.y = height - old_y;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_SE) {
            old_y = height;
            old_x = width;
            height += delta.y;
            if (height <0) height=0;
            width += delta.x;
            if (width <0) width=0;
            result.x = width - old_x;
            result.y = height - old_y;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_SW) {
            old_y = height;
            height += delta.y;
            if (height <0) height=0;
            int d = Math.min(delta.x,width);
            width -= d;
            position.x += d;
            result.x = d;
            result.y = height - old_y;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_NE) {
            old_x = width;
            int d = Math.min(delta.y,height);
            height -= d;
            position.y += d;
            width += delta.x;
            if (width <0) width=0;
            result.x = width - old_x;
            result.y = d;
        }
        else if (type == TransformationType.TRANSFORMATION_RESIZE_NW) {
            
            int d = Math.min(delta.y,height);
            height -= d;
            position.y += d;
            result.y = d;
            d = Math.min(delta.x,width);
            width -= d;
            position.x += d;
            result.x = d;
        }
        
        bounds = new Rectangle(position.x,position.y,width,height);
        
        return result;
    }
    
    /**
     * Try to move the element to another band if the element is placed entirely
     * within the band.
     *
     * @author RFL
     */
    
    public void adjustBand() {
        position.x -= 10;
        position.y -= 10;
        
        for (Iterator i = band.getParent().getBands().iterator(); i.hasNext(); ) {
            Band b = (Band) i.next();
            
            if ( position.y - band.getParent().getBandYLocation(b) >= 0) {
                if ( position.y - band.getParent().getBandYLocation(b) + height <= b.getHeight() ) {
                    // element is within this band.
                    band = b;