1 /*
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.java.swing.plaf.windows;
27
28 import javax.swing.plaf.basic.*;
29 import javax.swing.plaf.*;
30 import javax.swing.*;
31 import java.awt.*;
32
33 import static com.sun.java.swing.plaf.windows.TMSchema.*;
34 import static com.sun.java.swing.plaf.windows.XPStyle.Skin;
35
36
37 /**
38 * Windows rendition of the component.
39 * <p>
40 * <strong>Warning:</strong>
41 * Serialized objects of this class will not be compatible with
42 * future Swing releases. The current serialization support is appropriate
43 * for short term storage or RMI between applications running the same
44 * version of Swing. A future release of Swing will provide support for
45 * long term persistence.
46 *
47 * @author Michael C. Albers
48 */
49 public class WindowsProgressBarUI extends BasicProgressBarUI
50 {
51
52 private Rectangle previousFullBox;
53 private Insets indeterminateInsets;
54
55 public static ComponentUI createUI(JComponent x) {
56 return new WindowsProgressBarUI();
57 }
58
59
60 protected void installDefaults() {
61 super.installDefaults();
62
63 if (XPStyle.getXP() != null) {
64 LookAndFeel.installProperty(progressBar, "opaque", Boolean.FALSE);
65 progressBar.setBorder(null);
66 indeterminateInsets = UIManager.getInsets("ProgressBar.indeterminateInsets");
67 }
68 }
69
70 /**
71 * Returns the baseline.
72 *
73 * @throws NullPointerException {@inheritDoc}
74 * @throws IllegalArgumentException {@inheritDoc}
75 * @see javax.swing.JComponent#getBaseline(int, int)
76 * @since 1.6
77 */
78 public int getBaseline(JComponent c, int width, int height) {
79 int baseline = super.getBaseline(c, width, height);
80 if (XPStyle.getXP() != null && progressBar.isStringPainted() &&
81 progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
82 FontMetrics metrics = progressBar.
83 getFontMetrics(progressBar.getFont());
84 int y = progressBar.getInsets().top;
85 if (progressBar.isIndeterminate()) {
86 y = -1;
87 height--;
88 }
89 else {
90 y = 0;
91 height -= 3;
92 }
93 baseline = y + (height + metrics.getAscent() -
94 metrics.getLeading() -
95 metrics.getDescent()) / 2;
96 }
97 return baseline;
98 }
99
100 protected Dimension getPreferredInnerHorizontal() {
101 XPStyle xp = XPStyle.getXP();
102 if (xp != null) {
103 Skin skin = xp.getSkin(progressBar, Part.PP_BAR);
104 return new Dimension(
105 (int)super.getPreferredInnerHorizontal().getWidth(),
106 skin.getHeight());
107 }
108 return super.getPreferredInnerHorizontal();
109 }
110
111 protected Dimension getPreferredInnerVertical() {
112 XPStyle xp = XPStyle.getXP();
113 if (xp != null) {
114 Skin skin = xp.getSkin(progressBar, Part.PP_BARVERT);
115 return new Dimension(
116 skin.getWidth(),
117 (int)super.getPreferredInnerVertical().getHeight());
118 }
119 return super.getPreferredInnerVertical();
120 }
121
122 protected void paintDeterminate(Graphics g, JComponent c) {
123 XPStyle xp = XPStyle.getXP();
124 if (xp != null) {
125 boolean vertical = (progressBar.getOrientation() == JProgressBar.VERTICAL);
126 boolean isLeftToRight = WindowsGraphicsUtils.isLeftToRight(c);
127 int barRectWidth = progressBar.getWidth();
128 int barRectHeight = progressBar.getHeight()-1;
129 // amount of progress to draw
130 int amountFull = getAmountFull(null, barRectWidth, barRectHeight);
131
132 paintXPBackground(g, vertical, barRectWidth, barRectHeight);
133 // Paint progress
134 if (progressBar.isStringPainted()) {
135 // Do not paint the standard stripes from the skin, because they obscure
136 // the text
137 g.setColor(progressBar.getForeground());
138 barRectHeight -= 2;
139 barRectWidth -= 2;
140
141 if (barRectWidth <= 0 || barRectHeight <= 0) {
142 return;
143 }
144
145 Graphics2D g2 = (Graphics2D)g;
146 g2.setStroke(new BasicStroke((float)(vertical ? barRectWidth : barRectHeight),
147 BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL));
148 if (!vertical) {
149 if (isLeftToRight) {
150 g2.drawLine(2, barRectHeight / 2 + 1,
151 amountFull - 2, barRectHeight / 2 + 1);
152 } else {
153 g2.drawLine(2 + barRectWidth,
154 barRectHeight / 2 + 1,
155 2 + barRectWidth - (amountFull - 2),
156 barRectHeight / 2 + 1);
157 }
158 paintString(g, 0, 0, barRectWidth, barRectHeight, amountFull, null);
159 } else {
160 g2.drawLine(barRectWidth/2 + 1, barRectHeight + 1,
161 barRectWidth/2 + 1, barRectHeight + 1 - amountFull + 2);
162 paintString(g, 2, 2, barRectWidth, barRectHeight, amountFull, null);
163 }
164
165 } else {
166 Skin skin = xp.getSkin(progressBar, vertical ? Part.PP_CHUNKVERT : Part.PP_CHUNK);
167 int thickness;
168 if (vertical) {
169 thickness = barRectWidth - 5;
170 } else {
171 thickness = barRectHeight - 5;
172 }
173
174 int chunkSize = xp.getInt(progressBar, Part.PP_PROGRESS, null, Prop.PROGRESSCHUNKSIZE, 2);
175 int spaceSize = xp.getInt(progressBar, Part.PP_PROGRESS, null, Prop.PROGRESSSPACESIZE, 0);
176 int nChunks = (amountFull-4) / (chunkSize + spaceSize);
177
178 // See if we can squeeze in an extra chunk without spacing after
179 if (spaceSize > 0 && (nChunks * (chunkSize + spaceSize) + chunkSize) < (amountFull-4)) {
180 nChunks++;
181 }
182
183 for (int i = 0; i < nChunks; i++) {
184 if (vertical) {
185 skin.paintSkin(g,
186 3, barRectHeight - i * (chunkSize + spaceSize) - chunkSize - 2,
187 thickness, chunkSize, null);
188 } else {
189 if (isLeftToRight) {
190 skin.paintSkin(g,
191 4 + i * (chunkSize + spaceSize), 2,
192 chunkSize, thickness, null);
193 } else {
194 skin.paintSkin(g,
195 barRectWidth - (2 + (i+1) * (chunkSize + spaceSize)), 2,
196 chunkSize, thickness, null);
197 }
198 }
199 }
200 }
201 } else {
202 super.paintDeterminate(g, c);
203 }
204 }
205
206
207 /**
208 * {@inheritDoc}
209 * @since 1.6
210 */
211 protected void setAnimationIndex(int newValue) {
212 super.setAnimationIndex(newValue);
213 XPStyle xp = XPStyle.getXP();
214 if (xp != null) {
215 if (boxRect != null) {
216 // get the full repaint area and add it the
217 // previous one so we can erase it
218 Rectangle chunk = getFullChunkBounds(boxRect);
219 if (previousFullBox != null) {
220 chunk.add(previousFullBox);
221 }
222 progressBar.repaint(chunk);
223 } else {
224 progressBar.repaint();
225 }
226 }
227 }
228
229
230 /**
231 * {@inheritDoc}
232 * @since 1.6
233 */
234 protected int getBoxLength(int availableLength, int otherDimension) {
235 XPStyle xp = XPStyle.getXP();
236 if (xp != null) {
237 return 6; // an apparently hard coded value in Windows
238 }
239 return super.getBoxLength(availableLength, otherDimension);
240 }
241
242 /**
243 * {@inheritDoc}
244 * @since 1.6
245 */
246 protected Rectangle getBox(Rectangle r) {
247 Rectangle rect = super.getBox(r);
248
249 XPStyle xp = XPStyle.getXP();
250 if (xp != null) {
251 boolean vertical = (progressBar.getOrientation()
252 == JProgressBar.VERTICAL);
253 Part part = vertical ? Part.PP_BARVERT : Part.PP_BAR;
254 Insets ins = indeterminateInsets;
255
256 int currentFrame = getAnimationIndex();
257 int framecount = getFrameCount()/2;
258
259 int gap = xp.getInt(progressBar, Part.PP_PROGRESS, null,
260 Prop.PROGRESSSPACESIZE, 0);
261 currentFrame = currentFrame % framecount;
262
263 // this code adjusts the chunk size to properly account for the
264 // size and gap specified in the XP style. It also does it's own
265 // box placement for the chunk animation. This is required because
266 // the inherited algorithm from BasicProgressBarUI goes back and
267 // forth whereas XP only goes in one direction. XP also has ghosted
268 // trailing chunks to create the illusion of speed. This code
269 // adjusts the pixel length of the animation to account for the
270 // trails.
271 if (!vertical) {
272 rect.y = rect.y + ins.top;
273 rect.height = progressBar.getHeight() - ins.top - ins.bottom;
274 int len = progressBar.getWidth() - ins.left - ins.right;
275 len += (rect.width+gap)*2; // add 2x for the trails
276 double delta = (double)(len) / (double)framecount;
277 rect.x = (int)(delta * currentFrame) + ins.left;
278 } else {
279 rect.x = rect.x + ins.left;
280 rect.width = progressBar.getWidth() - ins.left - ins.right;
281 int len = progressBar.getHeight() - ins.top - ins.bottom;
282 len += (rect.height+gap)*2; // add 2x for the trails
283 double delta = (double)(len) / (double)framecount;
284 rect.y = (int)(delta * currentFrame) + ins.top;
285 }
286 }
287 return rect;
288 }
289
290
291 protected void paintIndeterminate(Graphics g, JComponent c) {
292 XPStyle xp = XPStyle.getXP();
293 if (xp != null) {
294 boolean vertical = (progressBar.getOrientation()
295 == JProgressBar.VERTICAL);
296 int barRectWidth = progressBar.getWidth();
297 int barRectHeight = progressBar.getHeight();
298 paintXPBackground(g, vertical, barRectWidth, barRectHeight);
299
300 // Paint the bouncing box.
301 boxRect = getBox(boxRect);
302 if (boxRect != null) {
303 g.setColor(progressBar.getForeground());
304 if (!(g instanceof Graphics2D)) {
305 return;
306 }
307 paintIndeterminateFrame(boxRect, (Graphics2D)g, vertical,
308 barRectWidth, barRectHeight);
309 if (progressBar.isStringPainted()) {
310 if (!vertical) {
311 paintString(g, -1, -1, barRectWidth, barRectHeight, 0, null);
312 } else {
313 paintString(g, 1, 1, barRectWidth, barRectHeight, 0, null);
314 }
315 }
316 }
317 } else {
318 super.paintIndeterminate(g, c);
319 }
320 }
321
322 private Rectangle getFullChunkBounds(Rectangle box) {
323 boolean vertical = (progressBar.getOrientation() == JProgressBar.VERTICAL);
324 XPStyle xp = XPStyle.getXP();
325 int gap = (xp != null) ? xp.getInt(progressBar, Part.PP_PROGRESS,
326 null, Prop.PROGRESSSPACESIZE, 0)
327 : 0;
328
329 if (!vertical) {
330 int chunksize = box.width+gap;
331 return new Rectangle(box.x-chunksize*2, box.y, chunksize*3, box.height);
332 } else {
333 int chunksize = box.height+gap;
334 return new Rectangle(box.x, box.y-chunksize*2, box.width, chunksize*3);
335 }
336 }
337
338 private void paintIndeterminateFrame(Rectangle box, Graphics2D g,
339 boolean vertical,
340 int bgwidth, int bgheight) {
341 XPStyle xp = XPStyle.getXP();
342 if (xp == null) {
343 return;
344 }
345
346 // create a new graphics to keep drawing surface state
347 Graphics2D gfx = (Graphics2D)g.create();
348
349 Part part = vertical ? Part.PP_BARVERT : Part.PP_BAR;
350 Part chunk = vertical ? Part.PP_CHUNKVERT : Part.PP_CHUNK;
351
352 // calculate the chunk offsets
353 int gap = xp.getInt(progressBar, Part.PP_PROGRESS, null,
354 Prop.PROGRESSSPACESIZE, 0);
355 int deltax = 0;
356 int deltay = 0;
357 if (!vertical) {
358 deltax = -box.width - gap;
359 deltay = 0;
360 } else {
361 deltax = 0;
362 deltay = -box.height - gap;
363 }
364
365 // Calculate the area of the chunks combined
366 Rectangle fullBox = getFullChunkBounds(box);
367
368 // save this box for the next time
369 previousFullBox = fullBox;
370
371 // this is the entire progress bar minus the track and borders
372 Insets ins = indeterminateInsets;
373 Rectangle progbarExtents = new Rectangle(ins.left, ins.top,
374 bgwidth - ins.left - ins.right,
375 bgheight - ins.top - ins.bottom);
376
377 // only paint where the chunks overlap with the progress bar drawing area
378 Rectangle repaintArea = progbarExtents.intersection(fullBox);
379
380 // adjust the cliprect to chop the chunks when they go off the end
381 gfx.clip(repaintArea);
382
383 // get the skin
384 XPStyle.Skin skin = xp.getSkin(progressBar, chunk);
385
386 // do the drawing
387 gfx.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.8f));
388 skin.paintSkin(gfx, box.x, box.y, box.width, box.height, null);
389 box.translate(deltax, deltay);
390 gfx.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f));
391 skin.paintSkin(gfx, box.x, box.y, box.width, box.height, null);
392 box.translate(deltax, deltay);
393 gfx.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.2f));
394 skin.paintSkin(gfx, box.x, box.y, box.width, box.height, null);
395
396 // get rid of our clip and composite changes
397 gfx.dispose();
398 }
399
400 private void paintXPBackground(Graphics g, boolean vertical,
401 int barRectWidth, int barRectHeight) {
402 XPStyle xp = XPStyle.getXP();
403 if (xp == null) {
404 return;
405 }
406 Part part = vertical ? Part.PP_BARVERT : Part.PP_BAR;
407 Skin skin = xp.getSkin(progressBar, part);
408
409 // Paint background
410 skin.paintSkin(g, 0, 0, barRectWidth, barRectHeight, null);
411 }
412 }