plugins/images/src/org/intellij/images/ui/ImageComponent.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /** $Id$ */
  18
  19 package org.intellij.images.ui;
  20
  21 import org.intellij.images.editor.ImageDocument;
  22 import org.intellij.images.options.GridOptions;
  23 import org.intellij.images.options.TransparencyChessboardOptions;
  24 import org.jetbrains.annotations.NonNls;
  25
  26 import javax.swing.*;
  27 import javax.swing.event.ChangeEvent;
  28 import javax.swing.event.ChangeListener;
  29 import java.awt.*;
  30 import java.awt.image.BufferedImage;
  31 import java.util.HashSet;
  32 import java.util.Set;
  33
  34 /**
  35  * Image component is draw image box with effects.
  36  *
  37  * @author <a href="mailto:aefimov.box@gmail.com">Alexey Efimov</a>
  38  */
  39 public class ImageComponent extends JComponent {
  40     @NonNls
  41     private static final String TRANSPARENCY_CHESSBOARD_CELL_SIZE_PROP = "TransparencyChessboard.cellSize";
  42     @NonNls
  43     private static final String TRANSPARENCY_CHESSBOARD_WHITE_COLOR_PROP = "TransparencyChessboard.whiteColor";
  44     @NonNls
  45     private static final String TRANSPARENCY_CHESSBOARD_BLACK_COLOR_PROP = "TransparencyChessboard.blackColor";
  46     @NonNls
  47     private static final String TRANSPARENCY_CHESSBOARD_VISIBLE_PROP = "TransparencyChessboard.visible";
  48     @NonNls
  49     private static final String GRID_LINE_ZOOM_FACTOR_PROP = "Grid.lineZoomFactor";
  50     @NonNls
  51     private static final String GRID_LINE_SPAN_PROP = "Grid.lineSpan";
  52     @NonNls
  53     private static final String GRID_LINE_COLOR_PROP = "Grid.lineColor";
  54     @NonNls
  55     private static final String GRID_VISIBLE_PROP = "Grid.visible";
  56
  57     /**
  58      * @see #getUIClassID
  59      * @see #readObject
  60      */
  61     @NonNls
  62     private static final String uiClassID = "ImageComponentUI";
  63
  64     static {
  65         UIManager.getDefaults().put(uiClassID, ImageComponentUI.class.getName());
  66     }
  67
  68     private final ImageDocument document = new ImageDocumentImpl();
  69     private final Grid grid = new Grid();
  70     private final Chessboard chessboard = new Chessboard();
  71
  72     public ImageComponent() {
  73         updateUI();
  74     }
  75
  76     public ImageDocument getDocument() {
  77         return document;
  78     }
  79
  80     public void setTransparencyChessboardCellSize(int cellSize) {
  81         int oldValue = chessboard.getCellSize();
  82         if (oldValue != cellSize) {
  83             chessboard.setCellSize(cellSize);
  84             firePropertyChange(TRANSPARENCY_CHESSBOARD_CELL_SIZE_PROP, oldValue, cellSize);
  85         }
  86     }
  87
  88     public void setTransparencyChessboardWhiteColor(Color color) {
  89         Color oldValue = chessboard.getWhiteColor();
  90         if (oldValue != null && !oldValue.equals(color) || oldValue == null && color != null) {
  91             chessboard.setWhiteColor(color);
  92             firePropertyChange(TRANSPARENCY_CHESSBOARD_WHITE_COLOR_PROP, oldValue, color);
  93         }
  94     }
  95
  96     public void setTransparencyChessboardBlankColor(Color color) {
  97         Color oldValue = chessboard.getBlackColor();
  98         if (oldValue != null && !oldValue.equals(color) || oldValue == null && color != null) {
  99             chessboard.setBlackColor(color);
 100             firePropertyChange(TRANSPARENCY_CHESSBOARD_BLACK_COLOR_PROP, oldValue, color);
 101         }
 102     }
 103
 104     public void setTransparencyChessboardVisible(boolean visible) {
 105         boolean oldValue = chessboard.isVisible();
 106         if (oldValue != visible) {
 107             chessboard.setVisible(visible);
 108             firePropertyChange(TRANSPARENCY_CHESSBOARD_VISIBLE_PROP, oldValue, visible);
 109         }
 110     }
 111
 112     public int getTransparencyChessboardCellSize() {
 113         return chessboard.getCellSize();
 114     }
 115
 116     public Color getTransparencyChessboardWhiteColor() {
 117         return chessboard.getWhiteColor();
 118     }
 119
 120     public Color getTransparencyChessboardBlackColor() {
 121         return chessboard.getBlackColor();
 122     }
 123
 124     public boolean isTransparencyChessboardVisible() {
 125         return chessboard.isVisible();
 126     }
 127
 128     public void setGridLineZoomFactor(int lineZoomFactor) {
 129         int oldValue = grid.getLineZoomFactor();
 130         if (oldValue != lineZoomFactor) {
 131             grid.setLineZoomFactor(lineZoomFactor);
 132             firePropertyChange(GRID_LINE_ZOOM_FACTOR_PROP, oldValue, lineZoomFactor);
 133         }
 134     }
 135
 136     public void setGridLineSpan(int lineSpan) {
 137         int oldValue = grid.getLineSpan();
 138         if (oldValue != lineSpan) {
 139             grid.setLineSpan(lineSpan);
 140             firePropertyChange(GRID_LINE_SPAN_PROP, oldValue, lineSpan);
 141         }
 142     }
 143
 144     public void setGridLineColor(Color color) {
 145         Color oldValue = grid.getLineColor();
 146         if (oldValue != null && !oldValue.equals(color) || oldValue == null && color != null) {
 147             grid.setLineColor(color);
 148             firePropertyChange(GRID_LINE_COLOR_PROP, oldValue, color);
 149         }
 150     }
 151
 152     public void setGridVisible(boolean visible) {
 153         boolean oldValue = grid.isVisible();
 154         if (oldValue != visible) {
 155             grid.setVisible(visible);
 156             firePropertyChange(GRID_VISIBLE_PROP, oldValue, visible);
 157         }
 158     }
 159
 160     public int getGridLineZoomFactor() {
 161         return grid.getLineZoomFactor();
 162     }
 163
 164     public int getGridLineSpan() {
 165         return grid.getLineSpan();
 166     }
 167
 168     public Color getGridLineColor() {
 169         return grid.getLineColor();
 170     }
 171
 172     public boolean isGridVisible() {
 173         return grid.isVisible();
 174     }
 175
 176     public void setCanvasSize(int width, int height) {
 177         setSize(width + 4, height + 4);
 178     }
 179
 180     public void setCanvasSize(Dimension dimension) {
 181         setCanvasSize(dimension.width, dimension.height);
 182     }
 183
 184     public Dimension getCanvasSize() {
 185         Dimension size = getSize();
 186         return new Dimension(size.width - 4, size.height - 4);
 187     }
 188
 189     public String getUIClassID() {
 190         return uiClassID;
 191     }
 192
 193     public void updateUI() {
 194         setUI(UIManager.getUI(this));
 195     }
 196
 197     private static final class ImageDocumentImpl implements ImageDocument {
 198         private final Set<ChangeListener> listeners = new HashSet<ChangeListener>(0);
 199         private BufferedImage image;
 200         private String format;
 201         private Image renderer;
 202
 203         public Image getRenderer() {
 204             return renderer;
 205         }
 206
 207         public BufferedImage getValue() {
 208             return image;
 209         }
 210
 211         public void setValue(BufferedImage image) {
 212             this.image = image;
 213             this.renderer = image != null ? Toolkit.getDefaultToolkit().createImage(image.getSource()) : null;
 214             fireChangeEvent(new ChangeEvent(this));
 215         }
 216
 217         public String getFormat() {
 218             return format;
 219         }
 220
 221
 222         public void setFormat(String format) {
 223             this.format = format;
 224             fireChangeEvent(new ChangeEvent(this));
 225         }
 226
 227         private void fireChangeEvent(ChangeEvent e) {
 228             for (ChangeListener listener : listeners) {
 229                 listener.stateChanged(e);
 230             }
 231         }
 232
 233         public void addChangeListener(ChangeListener listener) {
 234             listeners.add(listener);
 235         }
 236
 237         public void removeChangeListener(ChangeListener listener) {
 238             listeners.remove(listener);
 239         }
 240     }
 241
 242     private static final class Chessboard {
 243         private int cellSize = TransparencyChessboardOptions.DEFAULT_CELL_SIZE;
 244         private Color whiteColor = TransparencyChessboardOptions.DEFAULT_WHITE_COLOR;
 245         private Color blackColor = TransparencyChessboardOptions.DEFAULT_BLACK_COLOR;
 246         private boolean visible = false;
 247
 248         public int getCellSize() {
 249             return cellSize;
 250         }
 251
 252         public void setCellSize(int cellSize) {
 253             this.cellSize = cellSize;
 254         }
 255
 256         public Color getWhiteColor() {
 257             return whiteColor;
 258         }
 259
 260         public void setWhiteColor(Color whiteColor) {
 261             this.whiteColor = whiteColor;
 262         }
 263
 264         public Color getBlackColor() {
 265             return blackColor;
 266         }
 267
 268         public void setBlackColor(Color blackColor) {
 269             this.blackColor = blackColor;
 270         }
 271
 272         public boolean isVisible() {
 273             return visible;
 274         }
 275
 276         public void setVisible(boolean visible) {
 277             this.visible = visible;
 278         }
 279     }
 280
 281     private static final class Grid {
 282         private int lineZoomFactor = GridOptions.DEFAULT_LINE_ZOOM_FACTOR;
 283         private int lineSpan = GridOptions.DEFAULT_LINE_SPAN;
 284         private Color lineColor = GridOptions.DEFAULT_LINE_COLOR;
 285         private boolean visible = false;
 286
 287         public int getLineZoomFactor() {
 288             return lineZoomFactor;
 289         }
 290
 291         public void setLineZoomFactor(int lineZoomFactor) {
 292             this.lineZoomFactor = lineZoomFactor;
 293         }
 294
 295         public int getLineSpan() {
 296             return lineSpan;
 297         }
 298
 299         public void setLineSpan(int lineSpan) {
 300             this.lineSpan = lineSpan;
 301         }
 302
 303         public Color getLineColor() {
 304             return lineColor;
 305         }
 306
 307         public void setLineColor(Color lineColor) {
 308             this.lineColor = lineColor;
 309         }
 310
 311         public boolean isVisible() {
 312             return visible;
 313         }
 314
 315         public void setVisible(boolean visible) {
 316             this.visible = visible;
 317         }
 318     }
 319 }