PainterChain.java
上传用户:haobig99
上传日期:2022-06-15
资源大小:369k
文件大小:5k
源码类别:

J2ME

开发平台:

Java

  1. /*
  2.  * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4.  *
  5.  * This code is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License version 2 only, as
  7.  * published by the Free Software Foundation.  Sun designates this
  8.  * particular file as subject to the "Classpath" exception as provided
  9.  * by Sun in the LICENSE file that accompanied this code.
  10.  *
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * version 2 for more details (a copy is included in the LICENSE file that
  15.  * accompanied this code).
  16.  *
  17.  * You should have received a copy of the GNU General Public License version
  18.  * 2 along with this work; if not, write to the Free Software Foundation,
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20.  *
  21.  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22.  * CA 95054 USA or visit www.sun.com if you need additional information or
  23.  * have any questions.
  24.  */
  25. package com.sun.lwuit.painter;
  26. import com.sun.lwuit.Form;
  27. import com.sun.lwuit.Graphics;
  28. import com.sun.lwuit.Painter;
  29. import com.sun.lwuit.geom.Rectangle;
  30. import java.util.Vector;
  31. /**
  32.  * A painter chain allows us to chain together several painters to provide a
  33.  * "layer" effect where each painter only draws one element.
  34.  *
  35.  * @author Shai Almog
  36.  */
  37. public class PainterChain implements Painter {
  38.     private Painter[] chain;
  39.     
  40.     /**
  41.      * Create a new painter chain which will paint all of the elements in the chain
  42.      * in sequence from 0 to the last element
  43.      * 
  44.      * @param the chain of components in the painter
  45.      */
  46.     public PainterChain(Painter[] chain) {
  47.         this.chain = chain;
  48.     }
  49.     
  50.     /**
  51.      * Creates a new chain based on the existing chain with the new element added
  52.      * at the end
  53.      * 
  54.      * @param p new painter
  55.      * @return new chain element
  56.      */
  57.     public PainterChain addPainter(Painter p) {
  58.         if(chain.length != 0) {
  59.             Painter[] newChain = new Painter[chain.length + 1];
  60.             System.arraycopy(chain, 0, newChain, 0, chain.length);
  61.             newChain[chain.length] = p;
  62.             return new PainterChain(newChain);
  63.         } 
  64.         return new PainterChain(new Painter[] {p});
  65.     }
  66.     
  67.     /**
  68.      * Creates a new chain based on the existing chain with the new element added
  69.      * at the beginning
  70.      * 
  71.      * @param p new painter
  72.      * @return new chain element
  73.      */
  74.     public PainterChain prependPainter(Painter p) {
  75.         Painter[] newChain = new Painter[chain.length + 1];
  76.         System.arraycopy(chain, 1, newChain, 0, chain.length);
  77.         newChain[0] = p;
  78.         return new PainterChain(newChain);
  79.     }
  80.     
  81.     /**
  82.      * @inheritDoc
  83.      */
  84.     public void paint(Graphics g, Rectangle rect) {
  85.         for(int iter = 0 ; iter < chain.length ;  iter++) {
  86.             chain[iter].paint(g, rect);
  87.         }
  88.     }
  89.     /**
  90.      * Installs a glass pane on the given form making sure to make it a painter
  91.      * chain only if required by existing painter
  92.      * 
  93.      * @param f form on which to install the chain
  94.      * @param p painter to install
  95.      */
  96.     public static void installGlassPane(Form f, Painter p) {
  97.         Painter existing = f.getGlassPane();
  98.         if(existing == null) {
  99.             f.setGlassPane(p);
  100.             return;
  101.         }
  102.         if(existing instanceof PainterChain) {
  103.             ((PainterChain)existing).addPainter(p);
  104.         } else {
  105.             PainterChain pc = new PainterChain(new Painter[] {existing, p});
  106.             f.setGlassPane(pc);
  107.         }
  108.     }
  109.     /**
  110.      * Allows us to traverse the painter chain
  111.      * 
  112.      * @return the internal painter chain
  113.      */
  114.     public Painter[] getChain() {
  115.         return chain;
  116.     }
  117.     
  118.     /**
  119.      * Removes a glass pane from the given form, this is the opposite operation for the
  120.      * install glass pane
  121.      * 
  122.      * @param f form from which to remove the chain
  123.      * @param p painter to remove
  124.      */
  125.     public static void removeGlassPane(Form f, Painter p) {
  126.         Painter existing = f.getGlassPane();
  127.         if(existing == null) {
  128.             return;
  129.         }
  130.         if(existing == p) {
  131.             f.setGlassPane(null);
  132.             return;
  133.         }
  134.         if(existing instanceof PainterChain) {
  135.             PainterChain pc = (PainterChain)existing;
  136.             if(pc.chain.length == 1) {
  137.                 f.setGlassPane(null);
  138.             } else {
  139.                 Vector v = new Vector();
  140.                 for(int iter = 0 ; iter < pc.chain.length ; iter++) {
  141.                     if(pc.chain[iter] != p) {
  142.                         v.addElement(pc.chain[iter]);
  143.                     }
  144.                 }
  145.                 if(v.size() == 0) {
  146.                     f.setGlassPane(null);
  147.                     return;
  148.                 }
  149.                 Painter[] newChain = new Painter[v.size()];
  150.                 for(int iter = 0 ; iter < newChain.length ; iter++) {
  151.                     newChain[iter] = (Painter)v.elementAt(iter);
  152.                 }
  153.                 pc.chain = newChain;
  154.             }
  155.         } 
  156.     }
  157. }