1. /*

  2.  * @(#)PixmapEngine.java	1.13 04/01/13

  3.  *

  4.  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. package com.sun.java.swing.plaf.gtk;

  8. 

  9. import java.awt.*;

  10. import java.security.AccessController;

  11. import java.util.*;

  12. import javax.swing.*;

  13. import sun.security.action.GetPropertyAction;

  14. 

  15. /**

  16.  * GTKEngine implementation that renders using images. The images to render

  17.  * are dictated by the <code>PixmapStyle.Info</code>.

  18.  *

  19.  * @version 1.13, 01/13/04

  20.  * @author Scott Violet

  21.  */

  22. class PixmapEngine extends GTKEngine implements GTKConstants {

  23.     /**

  24.      * By default we don't use smooth scaling as it is currently not optimized.

  25.      */

  26.     private static final Object RENDERING_HINT;

  27. 

  28.     private int _clipX1;

  29.     private int _clipX2;

  30.     private int _clipY1;

  31.     private int _clipY2;

  32. 

  33.     static {

  34.         if ("true".equals((String)AccessController.doPrivileged(

  35.                    new GetPropertyAction("swing.pixmap.smoothScaling")))) {

  36.             RENDERING_HINT = RenderingHints.VALUE_INTERPOLATION_BILINEAR;

  37.         }

  38.         else {

  39.             RENDERING_HINT = null;

  40.         }

  41.     }

  42. 

  43.     public void paintSlider(SynthContext context, Graphics g, int state,

  44.                            int shadowType, String info,

  45.                            int x, int y, int w, int h, int orientation) {

  46.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  47.                          getInfo("SLIDER", info,state, shadowType, orientation,

  48.                                  UNDEFINED, UNDEFINED), true)) {

  49.             super.paintSlider(context, g, state, shadowType, info,

  50.                               x, y, w, h, orientation);

  51.         }

  52.     }

  53. 

  54.     public void paintHline(SynthContext context, Graphics g, int state,

  55.                            String info, int x, int y, int w, int h) {

  56.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  57.                          getInfo("HLINE", info, state, UNDEFINED, UNDEFINED,

  58.                          UNDEFINED, UNDEFINED), true)) {

  59.             super.paintHline(context, g, state, info, x, y, w, h);

  60.         }

  61.     }

  62. 

  63.     public void paintVline(SynthContext context, Graphics g, int state,

  64.                            String info, int x, int y, int w, int h) {

  65.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  66.                          getInfo("VLINE", info, state, UNDEFINED, UNDEFINED,

  67.                                  UNDEFINED, UNDEFINED), true)) {

  68.             super.paintVline(context, g, state, info, x, y, w, h);

  69.         }

  70.     }

  71. 

  72.     public void paintArrow(SynthContext context, Graphics g, int state,

  73.                            int shadowType, int direction, String info,

  74.                            int x, int y, int w, int h) {

  75.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  76.                          getInfo("ARROW", info, state, shadowType, UNDEFINED,

  77.                          UNDEFINED, direction), true)) {

  78.             super.paintArrow(context, g, state, shadowType, direction, info,

  79.                              x, y, w, h);

  80.         }

  81.     }

  82. 

  83.     public void paintBox(SynthContext context, Graphics g, int state,

  84.                          int shadowType, String info, int x, int y,

  85.                          int w, int h) {

  86.         int orientation;

  87.         Region id = context.getRegion();

  88.         if (id == Region.SCROLL_BAR) {

  89.             if (((JScrollBar)context.getComponent()).getOrientation() ==

  90.                                      SwingConstants.HORIZONTAL) {

  91.                 orientation = GTKConstants.HORIZONTAL;

  92.             }

  93.             else {

  94.                 orientation = GTKConstants.VERTICAL;

  95.             }

  96.         }

  97.         else if (id == Region.SLIDER_TRACK) {

  98.             if (((JSlider)context.getComponent()).getOrientation() ==

  99.                                      SwingConstants.HORIZONTAL) {

  100.                 orientation = GTKConstants.HORIZONTAL;

  101.             }

  102.             else {

  103.                 orientation = GTKConstants.VERTICAL;

  104.             }

  105.         }

  106.         else {

  107.             orientation = UNDEFINED;

  108.         }

  109.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  110.                          getInfo("BOX", info, state, shadowType, orientation,

  111.                                  UNDEFINED, UNDEFINED), true)) {

  112.             super.paintBox(context, g, state, shadowType, info, x, y, w, h);

  113.         }

  114.     }

  115. 

  116.     public void paintBoxGap(SynthContext context, Graphics g, int state,

  117.                             int shadow, String key, int x, int y,

  118.                             int w, int h, int gapSide, int gapStart,

  119.                             int gapSize) {

  120.         PixmapStyle.Info info = ((PixmapStyle)context.getStyle()).getInfo(

  121.               "BOX_GAP", key, state, shadow, UNDEFINED, gapSide, UNDEFINED);

  122. 

  123.         if (info != null) {

  124.             // Yes, this appears to paint before the gap does.

  125.             paintPixmap(g, x, y, w, h, info, true);

  126.             

  127.             // Determine the size of the opposite axis of the gap.

  128.             int size = 0;

  129.             Image startImage = info.getGapStartImage();

  130.             Image image = info.getGapImage();

  131.             Image endImage = info.getGapEndImage();

  132.             if (gapSide == LEFT || gapSide == RIGHT) {

  133.                 if (startImage != null) {

  134.                     size = startImage.getWidth(null);

  135.                 }

  136.                 else if (image != null) {

  137.                     size = image.getWidth(null);

  138.                 }

  139.                 else if (endImage != null) {

  140.                     size = endImage.getWidth(null);

  141.                 }

  142.             }

  143.             else {

  144.                 if (startImage != null) {

  145.                     size = startImage.getHeight(null);

  146.                 }

  147.                 else if (image != null) {

  148.                     size = image.getHeight(null);

  149.                 }

  150.                 else if (endImage != null) {

  151.                     size = endImage.getHeight(null);

  152.                 }

  153.             }

  154.             if (size <= 0) {

  155.                 // No matching images.

  156.                 return;

  157.             }

  158.             paintGapImage(g, x, y, w, h, startImage, info.getGapStartInsets(),

  159.                           gapSide, size, 0, gapStart);

  160.             paintGapImage(g, x, y, w, h, image, info.getGapInsets(), gapSide,

  161.                           size, gapStart, gapSize);

  162.             paintGapImage(g, x, y, w, h, endImage, info.getGapEndInsets(),

  163.                           gapSide, size, gapStart + gapSize,

  164.                           Integer.MAX_VALUE);

  165.         }

  166.         else {

  167.             super.paintBoxGap(context, g, state, shadow, key, x, y, w, h,

  168.                               gapSide, gapStart,gapSize);

  169.         }

  170.     }

  171. 

  172.     public void paintHandle(SynthContext context, Graphics g, int paintState,

  173.                             int shadowType, String info, int x, int y,

  174.                             int w, int h, int orientation) {

  175.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  176.                          getInfo("HANDLE", info, paintState, shadowType,

  177.                                  orientation, UNDEFINED, UNDEFINED), true)) {

  178.             super.paintHandle(context, g, paintState, shadowType, info, x, y,

  179.                               w, h, orientation);

  180.         }

  181.     }

  182. 

  183.     public void paintOption(SynthContext context, Graphics g, int paintState,

  184.                             int shadowType, String info, int x, int y,

  185.                             int w, int h) {

  186.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  187.                          getInfo("OPTION", info, paintState, shadowType,

  188.                                  UNDEFINED, UNDEFINED, UNDEFINED), true)) {

  189.             super.paintOption(context, g, paintState, shadowType, info, x, y,

  190.                               w, h);

  191.         }

  192.     }

  193. 

  194.     public void paintFocus(SynthContext context, Graphics g, int state,

  195.                            String key, int x, int y, int w, int h) {

  196.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  197.                          getInfo( "FOCUS", key, state, UNDEFINED, UNDEFINED,

  198.                          UNDEFINED, UNDEFINED), true)) {

  199.             super.paintFocus(context, g, state, key, x, y, w, h);

  200.         }

  201.     }

  202. 

  203.     public void paintShadow(SynthContext context, Graphics g, int state,

  204.                             int shadowType, String info, int x, int y,

  205.                             int w, int h) {

  206.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  207.                          getInfo("SHADOW", info, state, shadowType, UNDEFINED,

  208.                                  UNDEFINED, UNDEFINED), false)) {

  209.             super.paintShadow(context, g, state, shadowType, info, x, y, w, h);

  210.         }

  211.     }

  212. 

  213.     public void paintExpander(SynthContext context, Graphics g, int state,

  214.                               int expanderStyle, String info, int x,

  215.                               int y, int w, int h) {

  216.         // It does not appear that there is a way to override this.

  217.         super.paintExpander(context, g, state, expanderStyle, info, x, y, w,h);

  218.     }

  219. 

  220.     public void paintCheck(SynthContext context, Graphics g, int state,

  221.                            int shadowType, String info, int x, int y,

  222.                            int w, int h) {

  223.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  224.                         getInfo("CHECK", info, state, shadowType, UNDEFINED,

  225.                                 UNDEFINED, UNDEFINED), true)) {

  226.             super.paintCheck(context, g, state, shadowType, info, x, y, w, h);

  227.         }

  228.     }

  229. 

  230.     public void paintExtension(SynthContext context, Graphics g, int state,

  231.                                int shadowType, String info, int x, int y,

  232.                                int w, int h, int placement) {

  233.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  234.                          getInfo("EXTENSION", info, state, shadowType,

  235.                                  UNDEFINED, placement, UNDEFINED), true)) {

  236.             super.paintExtension(context, g, state, shadowType, info, x, y,

  237.                                  w, h, placement);

  238.         }

  239.     }

  240. 

  241.     public void paintFlatBox(SynthContext context, Graphics g, int state,

  242.                              String key, int x, int y, int w, int h) {

  243.         if (!paintPixmap(g, x, y, w, h, ((PixmapStyle)context.getStyle()).

  244.                          getInfo("FLAT_BOX", key, state, UNDEFINED, UNDEFINED,

  245.                                  UNDEFINED, UNDEFINED), true)) {

  246.             super.paintFlatBox(context, g, state, key, x, y, w, h);

  247.         }

  248.     }

  249. 

  250. 

  251.     /**

  252.      * Paints a gap image. This renders the image into a portion of

  253.      * the passed in region that is dictated

  254.      * by the <code>gapSide</code> and <code>size</code> arguments. For

  255.      * example, if <code>gapSide</code> is <code>GTKConstants.TOP</code>,

  256.      * this will render the image into the space:

  257.      * <table>

  258.      * <tr><td>x origin<td> <code>x</code> + <code>gapStart</code>

  259.      * <tr><td>y origin<td>  <code>y</code>

  260.      * <tr><td>width<td> <code>gapSize</code>

  261.      * <tr><td>height<td> <code>size</code>

  262.      * </table>

  263.      *

  264.      * @param g Graphics object to paint to

  265.      * @param x X origin

  266.      * @param y Y origin

  267.      * @param w Width to draw to

  268.      * @param h Height to draw to

  269.      * @param image Image to paint

  270.      * @param insets Insets dicatating fixed portion and scaled portion of

  271.      *               the image.

  272.      * @param gapSide Side the gap is on, one of GTKConstants.LEFT,

  273.      *        GTKConstants.RIGHT, GTKConstants.TOP or GTKConstants.BOTTOM

  274.      * @param size Size of the gap, either width or height, dependant upon

  275.      *        gapSide

  276.      * @param gapStart Starting location of the gap. The axis the gap is

  277.      *        on is dictated by the gapSide

  278.      * @param gapSize size of the gap

  279.      */

  280.     private void paintGapImage(Graphics g, int x, int y, int w, int h,

  281.                                Image image, Insets insets, int gapSide,

  282.                                int size, int gapStart, int gapSize) {

  283.         if (image != null && gapSize > 0) {

  284.             switch(gapSide) {

  285.             case LEFT:

  286.                 paintImage(g, x, y + gapStart, Math.min(w, size),

  287.                       Math.min(h - y - gapStart, gapSize), image,insets, true,

  288.                            false, true);

  289.                 break;

  290.             case RIGHT:

  291.                 paintImage(g, x + w - Math.min(w, size),

  292.                            y + gapStart, Math.min(w, size),

  293.                            Math.min(h - y - gapStart, gapSize), image,

  294.                            insets, true, false, true);

  295.                 break;

  296.             case TOP:

  297.                 paintImage(g, x + gapStart, y, Math.min(w - x - gapStart,

  298.                            gapSize), Math.min(h, size), image, insets, true,

  299.                            false, true);

  300.                 break;

  301.             case BOTTOM:

  302.                 paintImage(g, x + gapStart, y + h - Math.min(h, size),

  303.                            Math.min(w - x - gapStart, gapSize),

  304.                            Math.min(h, size), image, insets, true, false,true);

  305.                 break;

  306.             }

  307.          }

  308.     }

  309. 

  310.     /**

  311.      * Paints the image and overlay image from the passed in style.

  312.      *

  313.      * @param g Graphics object to paint to

  314.      * @param x X origin

  315.      * @param y Y origin

  316.      * @param w Width to draw to

  317.      * @param h Height to draw to

  318.      * @param info Used to fetch image, insets and overlay image from

  319.      */

  320.     private boolean paintPixmap(Graphics g, int x, int y, int w, int h,

  321.                                 PixmapStyle.Info info, boolean drawCenter) {

  322.         if (info != null) {

  323.             Rectangle clip = g.getClipBounds();

  324.             _clipX1 = clip.x;

  325.             _clipY1 = clip.y;

  326.             _clipX2 = _clipX1 + clip.width;

  327.             _clipY2 = _clipY1 + clip.height;

  328.             paintImage(g, x, y, w, h, info.getImage(), info.getImageInsets(),

  329.                        info.getStretch(), false, drawCenter);

  330.             paintImage(g, x, y, w, h, info.getOverlayImage(),

  331.                        info.getOverlayInsets(), info.getOverlayStretch(),

  332.                        true, drawCenter);

  333.             return true;

  334.          }

  335.         return false;

  336.     }

  337. 

  338.     /**

  339.      * Paints the image in the specified region.

  340.      *

  341.      * @param g Graphics object to paint to

  342.      * @param x X origin

  343.      * @param y Y origin

  344.      * @param w Width to draw to

  345.      * @param h Height to draw to

  346.      * @param image Image to render

  347.      * @param insets Insets used to determine portion of image that is fixed.

  348.      */

  349.     private void paintImage(Graphics g, int x, int y, int w, int h,

  350.                             Image image, Insets insets, boolean stretch,

  351.                             boolean overlay, boolean drawCenter) {

  352.         if (image == null) {

  353.             return;

  354.         }

  355.         if (insets == null) {

  356.             insets = GTKPainter.EMPTY_INSETS;

  357.         }

  358.         int iw = image.getWidth(null);

  359.         int ih = image.getHeight(null);

  360. 

  361.         if (iw <= 0 || ih <= 0) {

  362.             return;

  363.         }

  364.         Object lastHint;

  365.         Object renderingHint = RENDERING_HINT;

  366. 

  367.         if (renderingHint != null && stretch) {

  368.             Graphics2D g2 = (Graphics2D)g;

  369. 

  370.             lastHint = g2.getRenderingHint(RenderingHints.KEY_INTERPOLATION);

  371.             if (lastHint == null) {

  372.                 lastHint = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;

  373.             }

  374.             g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,

  375.                                 renderingHint);

  376.         }

  377.         else {

  378.             lastHint = null;

  379.         }

  380. 

  381.         if (!stretch) {

  382.             if (overlay) {

  383.                 g.drawImage(image, x + w / 2 - iw / 2, y + h / 2 - ih / 2,

  384.                             null);

  385.             }

  386.             else {

  387.                 int lastIY = 0;

  388.                 for (int yCounter = y, maxY = y + h; yCounter < maxY;

  389.                          yCounter += (ih - lastIY), lastIY = 0) {

  390.                     int lastIX = 0;

  391.                     for (int xCounter = x, maxX = x + w; xCounter < maxX;

  392.                              xCounter += (iw - lastIX), lastIX = 0) {

  393.                         int dx2 = Math.min(maxX, xCounter + iw - lastIX);

  394.                         int dy2 = Math.min(maxY, yCounter + ih - lastIY);

  395.                         if (intersectsClip(xCounter, yCounter, dx2, dy2)) {

  396.                             g.drawImage(image, xCounter, yCounter, dx2, dy2,

  397.                                         lastIX, lastIY, lastIX + dx2 -xCounter,

  398.                                         lastIY + dy2 - yCounter, null);

  399.                         }

  400.                     }

  401.                 }

  402.             }

  403.         }

  404.         else {

  405.             int it = insets.top;

  406.             int il = insets.left;

  407.             int ib = insets.bottom;

  408.             int ir = insets.right;

  409. 

  410.             // Constrain the insets to the size of the image

  411.             if (it + ib >= ih) {

  412.                 ib = it = Math.max(0, ih / 2 - 1);

  413.             }

  414.             if (il + ir >= iw) {

  415.                 il = ir = Math.max(0, iw / 2 - 1);

  416.             }

  417.             // Constrain the insets to the size of the region we're painting

  418.             // in.

  419.             if (it + ib > h) {

  420.                 it = ib = Math.max(2, h / 2 - 1);

  421.             }

  422.             if (il + ir > w) {

  423.                 il = ir = Math.max(2, w / 2 - 1);

  424.             }

  425.             // left

  426.             if (il > 0 && it + ib < ih) {

  427.                 drawChunk(image, g, stretch, x, y + it, x + il, y + h - ib, 0,

  428.                           it, il, ih - ib, false);

  429.             }

  430.             // top left

  431.             if (il > 0 && it > 0) {

  432.                 g.drawImage(image, x, y, x + il, y + it, 0, 0, il, it, null);

  433.             }

  434.             // top

  435.             if (it > 0 && il + ir < iw) {

  436.                 drawChunk(image, g, stretch, x + il, y, x + w - ir, y + it,

  437.                           il, 0, iw - ir, it, true);

  438.             }

  439.             // top right

  440.             if (ir < iw && it > 0) {

  441.                 g.drawImage(image, x + w - ir, y, x + w, y + it, iw - ir, 0,

  442.                             iw, it, null);

  443.             }

  444.             // right

  445.             if (ir < iw && it + ib < ih) {

  446.                 drawChunk(image, g, stretch, x + w - ir, y + it, x + w,

  447.                           y + h - ib, iw - ir, it, iw, ih - ib, false);

  448.             }

  449.             // bottom right

  450.             if (ir < iw && ib < ih) {

  451.                 g.drawImage(image, x + w - ir, y + h - ib, x + w, y + h,

  452.                             iw - ir, ih - ib, iw, ih, null);

  453.             }

  454.             // bottom

  455.             if (il + ir < iw && ib > 0) {

  456.                 drawChunk(image, g, stretch, x + il, y + h - ib, x + w - ir,

  457.                           y + h, il, ih - ib, iw - ir, ih, true);

  458.             }

  459.             // bottom left

  460.             if (il > 0 && ib > 0) {

  461.                 g.drawImage(image, x, y + h - ib, x + il,

  462.                             y + h, 0, ih - ib, il, ih, null);

  463.             }

  464.             // center

  465.             if (drawCenter && il + ir < iw && it + ib < ih) {

  466.                 g.drawImage(image, x + il, y + it, x + w - ir, y + h - ib,

  467.                             il, it, iw - ir, ih - ib, null);

  468.             }

  469.         }

  470. 

  471.         if (lastHint != null) {

  472.             ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_INTERPOLATION,

  473.                                              lastHint);

  474.         }

  475.     }

  476. 

  477.     /**

  478.      * Draws a portion of an image, stretched or tiled.

  479.      *

  480.      * @param image Image to render.

  481.      * @param g Graphics to render to

  482.      * @param stretch Whether the image should be stretched or timed in the

  483.      *                provided space.

  484.      * @param dx1 X origin to draw to

  485.      * @param dy1 Y origin to draw to

  486.      * @param dx2 End x location to draw to

  487.      * @param dy2 End y location to draw to

  488.      * @param sx1 X origin to draw from

  489.      * @param sy1 Y origin to draw from

  490.      * @param sx2 Max x location to draw from

  491.      * @param sy2 Max y location to draw from

  492.      * @param xDirection Used if the image is not stretched. If true it

  493.      *        indicates the image should be tiled along the x axis.

  494.      */

  495.     private void drawChunk(Image image, Graphics g, boolean stretch,

  496.                            int dx1, int dy1, int dx2, int dy2, int sx1,

  497.                            int sy1, int sx2, int sy2,

  498.                            boolean xDirection) {

  499.         if (dx2 - dx1 <= 0 || dy2 - dy1 <= 0 ||

  500.                               !intersectsClip(dx1, dy1, dx2, dy2)) {

  501.             // Bogus location, nothing to paint

  502.             return;

  503.         }

  504.         if (stretch) {

  505.             g.drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null);

  506.         }

  507.         else {

  508.             int xSize = sx2 - sx1;

  509.             int ySize = sy2 - sy1;

  510.             int deltaX;

  511.             int deltaY;

  512. 

  513.             if (xDirection) {

  514.                 deltaX = xSize;

  515.                 deltaY = 0;

  516.             }

  517.             else {

  518.                 deltaX = 0;

  519.                 deltaY = ySize;

  520.             }

  521.             while (dx1 < dx2 && dy1 < dy2) {

  522.                 int newDX2 = Math.min(dx2, dx1 + xSize);

  523.                 int newDY2 = Math.min(dy2, dy1 + ySize);

  524. 

  525.                 if (intersectsClip(dx1, dy1, newDX2, newDY2)) {

  526.                     g.drawImage(image, dx1, dy1, newDX2, newDY2,

  527.                                 sx1, sy1, sx1 + newDX2 - dx1,

  528.                                 sy1 + newDY2 - dy1, null);

  529.                 }

  530.                 dx1 += deltaX;

  531.                 dy1 += deltaY;

  532.             }

  533.         }

  534.     }

  535. 

  536.     /**

  537.      * Returns true if the passed in region intersects the clip.

  538.      */

  539.     private boolean intersectsClip(int x1, int y1, int x2, int y2) {

  540.         return ((x2 < x1 || x2 > _clipX1) &&

  541.                 (y2 < y1 || y2 > _clipY1) &&

  542.                 (_clipX2 < _clipX1 || _clipX2 > x1) &&

  543.                 (_clipY2 < _clipY1 || _clipY2 > y1));

  544.     }

  545. }