staticanimation.java.svn-base

来自「j2me设计的界面包」· SVN-BASE 代码 · 共 552 行 · 第 1/2 页

        
        // for performance we can calculate the visible drawing area so we don't have to
        // calculate the whole array
        int clipY = g.getClipY();
        int clipBottomY = g.getClipHeight() + clipY;
        int firstLine = 0;
        int lastLine = getHeight();
        if(clipY > y) {
            firstLine = clipY - y;
        } 
        if(clipBottomY < y + getHeight()) {
            lastLine = clipBottomY - y;
        }
        
        Frame f = frames[currentFrame - 1];
        byte[] imageDataByte = f.getKeyFrame();
        int[] palette = getPalette();
        
        // we draw based on the last keyframe and if a row was modified then we
        // will draw that row rather than the keyframe
        for(int line = firstLine ; line < lastLine ; line += 1) {
            byte[] lineArray = f.getModifiedRow(line);
            if(lineArray != null) {
                for(int position = 0 ; position < width ; position++) {
                    int i = lineArray[position] & 0xff;                
                    lineCache[position] = palette[i];
                }
            } else {
                //if(!f.isDrawPrevious()) {
                    int currentPos = line * width;
                    for(int position = 0 ; position < width ; position++) {
                        int i = imageDataByte[position + currentPos] & 0xff;                
                        lineCache[position] = palette[i];
                    }
                //}
            }
            g.drawRGB(lineCache, 0, width, x, y + line, width, 1, true);
        }
    }    
    
    /**
     * @inheritDoc
     */
    public void scale(int width, int height) {
        StaticAnimation s = (StaticAnimation)scaled(width, height);
        super.scale(width, height);
        frames = s.frames;
    }
    
    /**
     * @inheritDoc
     */
    public Image scaled(int width, int height) {
        int srcWidth = getWidth();
        int srcHeight = getHeight();

        // no need to scale
        if(srcWidth == width && srcHeight == height){
            return this;
        }

        // save the previous keyframe all the time this allows us to swap a keyframe
        // based on its pointer rather than scale it twice
        byte[] lastKeyFrame = getImageDataByte();

        // scale the first frame
        StaticAnimation result = new StaticAnimation(width, height, getPalette(), scaleArray(lastKeyFrame, width, height));
        result.loop = loop;
        result.totalAnimationTime = totalAnimationTime;
        result.animationStartTime = animationStartTime;
        result.currentFrame = currentFrame;
        result.frames = new Frame[frames.length];
        
        byte[] lastKeyFrameAfterScale = result.getImageDataByte();
        
        int yRatio = (srcHeight << 16) / height;
        int xRatio = (srcWidth << 16) / width;

        // now we need to traverse all the frames and scale them one by one
        for(int iter = 0 ; iter < frames.length ; iter++) {
            byte[] currentKeyFrame = frames[iter].getKeyFrame();
            if(currentKeyFrame != lastKeyFrame) {
                lastKeyFrame = currentKeyFrame;
                currentKeyFrame = scaleArray(currentKeyFrame, width, height);
                lastKeyFrameAfterScale = currentKeyFrame;
            }
            result.frames[iter] = new Frame(frames[iter].getTime(), lastKeyFrameAfterScale, frames[iter], xRatio, yRatio, width, height);
        }
        return result;
    }
    
    /**
     * @inheritDoc
     */
    public boolean isAnimation() {
        return true;
    }
    
    /**
     * Used by the resource editor
     */
    boolean isKeyframe(int offset) {
        if(offset == 0) {
            return true;
        }
        if(offset == 1) {
            return frames[offset - 1].getKeyFrame() != imageDataByte;
        }
        return frames[offset - 1].getKeyFrame() != frames[offset - 2].getKeyFrame();
    }
    
    /**
     * Used by the resource editor
     */
    byte[] getKeyframe(int offset) {
        return frames[offset - 1].getKeyFrame();
    }

    /**
     * Used by the resource editor
     */
    boolean isDrawPrevious(int offset) {
        return frames[offset - 1].isDrawPrevious();
    }
    
    /**
     * Used by the resource editor
     */
    byte[][] getModifiedRows(int offset) {
        return frames[offset - 1].modifiedRows;
    }
    
    /**
     * Used by the resource editor
     */
    int[] getModifiedRowOffsets(int offset) {
        return frames[offset - 1].modifiedRowOffsets;
    }
    
    Rectangle getDirtyRegion(){
        int frame = currentFrame;
        if(frame == 0){
            return null;
        }
        if(frame == frames.length){
            frame = 0;
        }
        int [] modified = frames[frame].modifiedRowOffsets;
        Rectangle rect = new Rectangle(0, frames[frame].smallestChangedRow, new Dimension(getWidth(), frames[frame].highestChangedRow -frames[frame].smallestChangedRow));
        return rect;
    }
    
    /**
     * Represents a frame within the animation that is not the first frame
     */
    static class Frame {
        /**
         * Offset since the beginning of the animation
         */
        private int time;
        
        private byte[] keyFrame;
        
        /**
         * Relevant only for standard frames, this represents the rows that
         * were modified for this specific frame
         */
        byte[][] modifiedRows;
        int[] modifiedRowOffsets;
        private boolean drawPrevious;
        int smallestChangedRow;
        int highestChangedRow;
        
        
        public Frame(int time, byte[] keyFrame, Vector rowNumbers, Vector rowValues, boolean drawPrevious) {
            this.time = time;
            this.keyFrame = keyFrame;
            this.drawPrevious = drawPrevious;
            initArrays(rowNumbers, rowValues);
        }

        private void initArrays(Vector rowNumbers, Vector rowValues) {
            modifiedRowOffsets = new int[rowNumbers.size()];
            modifiedRows = new byte[modifiedRowOffsets.length][];
            for(int iter = 0 ; iter < modifiedRowOffsets.length ; iter++) {
                modifiedRowOffsets[iter] = ((Integer)rowNumbers.elementAt(iter)).intValue();
                modifiedRows[iter] = (byte[])rowValues.elementAt(iter);
            }
            smallestChangedRow = modifiedRowOffsets[0];
            highestChangedRow = modifiedRowOffsets[0];
            for(int i=1;i<modifiedRowOffsets.length;i++){
                smallestChangedRow = Math.min(smallestChangedRow, modifiedRowOffsets[i]) ;
                highestChangedRow = Math.max(highestChangedRow, modifiedRowOffsets[i]) ;
            }
        }
        
        public Frame(int time, byte[] keyFrame) {
            this.time = time;
            this.keyFrame = keyFrame;
            modifiedRowOffsets = new int[0];
        }
        

        /**
         * This constructor is used for scaling the original frame according to the given ratios
         */
        public Frame(int time, byte[] keyFrame, Frame original, int xRatio, int yRatio, int width, int height) {
            this.time = time;
            this.keyFrame = keyFrame;
            
            // if the original was a keyframe then no work...
            if(original.modifiedRowOffsets.length == 0) {
                modifiedRowOffsets = original.modifiedRowOffsets;
                return;
            }
            Vector newRows = new Vector();
            Vector newValues = new Vector();
            
            int xPos = xRatio / 2;
            int yPos = yRatio / 2;

            for(int y = 0 ; y < height ; y++) {
                int srcY = yPos >> 16;
                
                // do we have the row at srcY???
                int rowAtY = -1;
                for(int iter = 0 ; iter < original.modifiedRowOffsets.length ; iter++) {
                    if(original.modifiedRowOffsets[iter] == srcY) {
                        rowAtY = iter;
                        break;
                    }
                }
                if(rowAtY != -1) {
                    byte[] newRow = new byte[width];
                    for (int x = 0; x < width; x++) {
                        int srcX = xPos >> 16;
                        newRow[x] = original.modifiedRows[rowAtY][srcX];
                        xPos += xRatio;
                    }
                    newRows.addElement(new Integer(y));
                    newValues.addElement(newRow);
                }
                yPos += yRatio;
                xPos = xRatio / 2;
            }
            
            initArrays(newRows, newValues);
        }
        
        public boolean isDrawPrevious() {
            return drawPrevious;
        }
        
        public int getTime() {
            return time;
        }
        
        private byte[] getModifiedRow(int row) {
            for(int iter = 0 ; iter < modifiedRowOffsets.length ; iter++) {
                if(modifiedRowOffsets[iter] == row) {
                    return modifiedRows[iter];
                }
            }
            return null;
        }
        
        private byte[] getKeyFrame() {
            return keyFrame;
        }
        
        private void setKeyFrame(byte[] keyFrame) {
            this.keyFrame = keyFrame;
        }
    }
}