Commit | Line | Data |
---|---|---|
b6b7ed68 JL |
1 | /* |
2 | GNU Lesser General Public License | |
3 | ||
4 | RelativeImageView | |
5 | Copyright (C) 2001 Frits Jalvingh & Howard Kistler | |
6 | ||
7 | This library is free software; you can redistribute it and/or | |
8 | modify it under the terms of the GNU Lesser General Public | |
9 | License as published by the Free Software Foundation; either | |
10 | version 2.1 of the License, or (at your option) any later version. | |
11 | ||
12 | This library is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | Lesser General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU Lesser General Public | |
18 | License along with this library; if not, write to the Free Software | |
19 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 | */ | |
21 | ||
22 | package com.hexidec.ekit.component; | |
23 | ||
24 | import java.awt.Color; | |
25 | import java.awt.Component; | |
26 | import java.awt.Container; | |
27 | import java.awt.Dimension; | |
28 | import java.awt.Graphics; | |
29 | import java.awt.Image; | |
30 | import java.awt.Point; | |
31 | import java.awt.Rectangle; | |
32 | import java.awt.Shape; | |
33 | import java.awt.Toolkit; | |
34 | import java.awt.event.MouseEvent; | |
35 | import java.awt.event.MouseListener; | |
36 | import java.awt.event.MouseMotionListener; | |
37 | import java.awt.image.ImageObserver; | |
38 | import java.io.BufferedInputStream; | |
39 | import java.io.ByteArrayOutputStream; | |
40 | import java.io.File; | |
41 | import java.io.InputStream; | |
42 | import java.io.IOException; | |
43 | import java.net.MalformedURLException; | |
44 | import java.net.URL; | |
45 | import java.util.Dictionary; | |
46 | import javax.swing.Icon; | |
47 | import javax.swing.ImageIcon; | |
48 | import javax.swing.JEditorPane; | |
49 | import javax.swing.text.AbstractDocument; | |
50 | import javax.swing.text.AttributeSet; | |
51 | import javax.swing.text.BadLocationException; | |
52 | import javax.swing.text.Document; | |
53 | import javax.swing.text.Element; | |
54 | import javax.swing.text.JTextComponent; | |
55 | import javax.swing.text.MutableAttributeSet; | |
56 | import javax.swing.text.Position; | |
57 | import javax.swing.text.SimpleAttributeSet; | |
58 | import javax.swing.text.StyledDocument; | |
59 | import javax.swing.text.View; | |
60 | import javax.swing.text.ViewFactory; | |
61 | import javax.swing.text.html.HTML; | |
62 | import javax.swing.text.html.HTMLDocument; | |
63 | import javax.swing.text.html.StyleSheet; | |
64 | import javax.swing.event.DocumentEvent; | |
65 | ||
66 | /** | |
67 | * @author <a href="mailto:jal@grimor.com">Frits Jalvingh</a> | |
68 | * @version 1.0 | |
69 | * | |
70 | * This code was modeled after an artice on | |
71 | * <a href="http://www.javaworld.com/javaworld/javatips/jw-javatip109.html"> | |
72 | * JavaWorld</a> by Bob Kenworthy. | |
73 | */ | |
74 | ||
75 | public class RelativeImageView extends View implements ImageObserver, MouseListener, MouseMotionListener | |
76 | { | |
77 | public static final String TOP = "top"; | |
78 | public static final String TEXTTOP = "texttop"; | |
79 | public static final String MIDDLE = "middle"; | |
80 | public static final String ABSMIDDLE = "absmiddle"; | |
81 | public static final String CENTER = "center"; | |
82 | public static final String BOTTOM = "bottom"; | |
83 | public static final String IMAGE_CACHE_PROPERTY = "imageCache"; | |
84 | ||
85 | private static Icon sPendingImageIcon; | |
86 | private static Icon sMissingImageIcon; | |
87 | private static final String PENDING_IMAGE_SRC = "icons/ImagePendingHK.gif"; | |
88 | private static final String MISSING_IMAGE_SRC = "icons/ImageMissingHK.gif"; | |
89 | private static final int DEFAULT_WIDTH = 32; | |
90 | private static final int DEFAULT_HEIGHT = 32; | |
91 | private static final int DEFAULT_BORDER = 1; | |
92 | ||
93 | private AttributeSet attr; | |
94 | private Element fElement; | |
95 | private Image fImage; | |
96 | private int fHeight; | |
97 | private int fWidth; | |
98 | private Container fContainer; | |
99 | private Rectangle fBounds; | |
100 | private Component fComponent; | |
101 | private Point fGrowBase; // base of drag while growing image | |
102 | private boolean fGrowProportionally; // should grow be proportional? | |
103 | private String BaseUrl; | |
104 | private boolean bLoading; // set to true while the receiver is locked, to indicate the reciever is loading the image. This is used in imageUpdate. | |
105 | ||
106 | /** Constructor | |
107 | * Creates a new view that represents an IMG element. | |
108 | * @param elem the element to create a view for | |
109 | */ | |
110 | public RelativeImageView(Element elem,String baseurl) | |
111 | { | |
112 | super(elem); | |
113 | BaseUrl = baseurl; | |
114 | initialize(elem); | |
115 | StyleSheet sheet = getStyleSheet(); | |
116 | attr = sheet.getViewAttributes(this); | |
117 | } | |
118 | ||
119 | private void initialize(Element elem) | |
120 | { | |
121 | synchronized(this) | |
122 | { | |
123 | bLoading = true; | |
124 | fWidth = 0; | |
125 | fHeight = 0; | |
126 | } | |
127 | int width = 0; | |
128 | int height = 0; | |
129 | boolean customWidth = false; | |
130 | boolean customHeight = false; | |
131 | try | |
132 | { | |
133 | fElement = elem; | |
134 | // request image from document's cache | |
135 | AttributeSet attr = elem.getAttributes(); | |
136 | if(true || isURL()) | |
137 | { | |
138 | URL src = getSourceURL(); | |
139 | if(src != null) | |
140 | { | |
141 | Dictionary cache = (Dictionary)getDocument().getProperty(IMAGE_CACHE_PROPERTY); | |
142 | if(cache != null) | |
143 | { | |
144 | fImage = (Image)cache.get(src); | |
145 | } | |
146 | else | |
147 | { | |
148 | fImage = Toolkit.getDefaultToolkit().getImage(src); | |
149 | } | |
150 | } | |
151 | } | |
152 | else | |
153 | { | |
154 | // load image from relative path | |
155 | String src = (String)fElement.getAttributes().getAttribute(HTML.Attribute.SRC); | |
156 | src = processSrcPath(src); | |
157 | fImage = Toolkit.getDefaultToolkit().createImage(src); | |
158 | try | |
159 | { | |
160 | waitForImage(); | |
161 | } | |
162 | catch(InterruptedException ie) | |
163 | { | |
164 | fImage = null; | |
165 | // possibly replace with the ImageBroken icon, if that's what is happening | |
166 | } | |
167 | } | |
168 | ||
169 | // get height & width from params or image or defaults | |
170 | height = getIntAttr(HTML.Attribute.HEIGHT, -1); | |
171 | customHeight = (height > 0); | |
172 | if(!customHeight && fImage != null) | |
173 | { | |
174 | height = fImage.getHeight(this); | |
175 | } | |
176 | if(height <= 0) | |
177 | { | |
178 | height = DEFAULT_HEIGHT; | |
179 | } | |
180 | ||
181 | width = getIntAttr(HTML.Attribute.WIDTH, -1); | |
182 | customWidth = (width > 0); | |
183 | if(!customWidth && fImage != null) | |
184 | { | |
185 | width = fImage.getWidth(this); | |
186 | } | |
187 | if(width <= 0) | |
188 | { | |
189 | width = DEFAULT_WIDTH; | |
190 | } | |
191 | ||
192 | if(fImage != null) | |
193 | { | |
194 | if(customHeight && customWidth) | |
195 | { | |
196 | Toolkit.getDefaultToolkit().prepareImage(fImage, height, width, this); | |
197 | } | |
198 | else | |
199 | { | |
200 | Toolkit.getDefaultToolkit().prepareImage(fImage, -1, -1, this); | |
201 | } | |
202 | } | |
203 | } | |
204 | finally | |
205 | { | |
206 | synchronized(this) | |
207 | { | |
208 | bLoading = false; | |
209 | if(customHeight || fHeight == 0) | |
210 | { | |
211 | fHeight = height; | |
212 | } | |
213 | if(customWidth || fWidth == 0) | |
214 | { | |
215 | fWidth = width; | |
216 | } | |
217 | } | |
218 | } | |
219 | } | |
220 | ||
221 | /** Determines if path is in the form of a URL | |
222 | */ | |
223 | private boolean isURL() | |
224 | { | |
225 | String src = (String)fElement.getAttributes().getAttribute(HTML.Attribute.SRC); | |
226 | return src.toLowerCase().startsWith("file") || src.toLowerCase().startsWith("http"); | |
227 | } | |
228 | ||
229 | /** Checks to see if the absolute path is availabe thru an application | |
230 | * global static variable or thru a system variable. If so, appends | |
231 | * the relative path to the absolute path and returns the String. | |
232 | */ | |
233 | private String processSrcPath(String src) | |
234 | { | |
235 | String val = src; | |
236 | File imageFile = new File(src); | |
237 | if(imageFile.isAbsolute()) | |
238 | { | |
239 | return src; | |
240 | } | |
241 | boolean found = false; | |
242 | Document doc = getDocument(); | |
243 | if(doc != null) | |
244 | { | |
245 | String pv = (String)doc.getProperty("com.hexidec.ekit.docsource"); | |
246 | if(pv != null) | |
247 | { | |
248 | File f = new File(pv); | |
249 | val = (new File(f.getParent(), imageFile.getPath().toString())).toString(); | |
250 | found = true; | |
251 | } | |
252 | } | |
253 | if(!found) | |
254 | { | |
255 | String imagePath = System.getProperty("system.image.path.key"); | |
256 | if(imagePath != null) | |
257 | { | |
258 | val = (new File(imagePath, imageFile.getPath())).toString(); | |
259 | } | |
260 | } | |
261 | return val; | |
262 | } | |
263 | ||
264 | /** Method insures that the image is loaded and not a broken reference | |
265 | */ | |
266 | private void waitForImage() | |
267 | throws InterruptedException | |
268 | { | |
269 | int w = fImage.getWidth(this); | |
270 | int h = fImage.getHeight(this); | |
271 | while (true) | |
272 | { | |
273 | int flags = Toolkit.getDefaultToolkit().checkImage(fImage, w, h, this); | |
274 | if(((flags & ERROR) != 0) || ((flags & ABORT) != 0 )) | |
275 | { | |
276 | throw new InterruptedException(); | |
277 | } | |
278 | else if((flags & (ALLBITS | FRAMEBITS)) != 0) | |
279 | { | |
280 | return; | |
281 | } | |
282 | Thread.sleep(10); | |
283 | } | |
284 | } | |
285 | ||
286 | /** Fetches the attributes to use when rendering. This is | |
287 | * implemented to multiplex the attributes specified in the | |
288 | * model with a StyleSheet. | |
289 | */ | |
290 | public AttributeSet getAttributes() | |
291 | { | |
292 | return attr; | |
293 | } | |
294 | ||
295 | /** Method tests whether the image within a link | |
296 | */ | |
297 | boolean isLink() | |
298 | { | |
299 | AttributeSet anchorAttr = (AttributeSet)fElement.getAttributes().getAttribute(HTML.Tag.A); | |
300 | if(anchorAttr != null) | |
301 | { | |
302 | return anchorAttr.isDefined(HTML.Attribute.HREF); | |
303 | } | |
304 | return false; | |
305 | } | |
306 | ||
307 | /** Method returns the size of the border to use | |
308 | */ | |
309 | int getBorder() | |
310 | { | |
311 | return getIntAttr(HTML.Attribute.BORDER, isLink() ? DEFAULT_BORDER : 0); | |
312 | } | |
313 | ||
314 | /** Method returns the amount of extra space to add along an axis | |
315 | */ | |
316 | int getSpace(int axis) | |
317 | { | |
318 | return getIntAttr((axis == X_AXIS) ? HTML.Attribute.HSPACE : HTML.Attribute.VSPACE, 0); | |
319 | } | |
320 | ||
321 | /** Method returns the border's color, or null if this is not a link | |
322 | */ | |
323 | Color getBorderColor() | |
324 | { | |
325 | StyledDocument doc = (StyledDocument)getDocument(); | |
326 | return doc.getForeground(getAttributes()); | |
327 | } | |
328 | ||
329 | /** Method returns the image's vertical alignment | |
330 | */ | |
331 | float getVerticalAlignment() | |
332 | { | |
333 | String align = (String)fElement.getAttributes().getAttribute(HTML.Attribute.ALIGN); | |
334 | if(align != null) | |
335 | { | |
336 | align = align.toLowerCase(); | |
337 | if(align.equals(TOP) || align.equals(TEXTTOP)) | |
338 | { | |
339 | return 0.0f; | |
340 | } | |
341 | else if(align.equals(this.CENTER) || align.equals(MIDDLE) || align.equals(ABSMIDDLE)) | |
342 | { | |
343 | return 0.5f; | |
344 | } | |
345 | } | |
346 | return 1.0f; // default alignment is bottom | |
347 | } | |
348 | ||
349 | boolean hasPixels(ImageObserver obs) | |
350 | { | |
351 | return ((fImage != null) && (fImage.getHeight(obs) > 0) && (fImage.getWidth(obs) > 0)); | |
352 | } | |
353 | ||
354 | /** Method returns a URL for the image source, or null if it could not be determined | |
355 | */ | |
356 | private URL getSourceURL() | |
357 | { | |
358 | String src = (String)fElement.getAttributes().getAttribute(HTML.Attribute.SRC); | |
359 | if(src == null) | |
360 | { | |
361 | return null; | |
362 | } | |
363 | try | |
364 | { | |
365 | URL reference = new URL(BaseUrl); | |
366 | URL u = new URL(reference,src); | |
367 | return u; | |
368 | } | |
369 | catch(MalformedURLException mue) | |
370 | { | |
371 | return null; | |
372 | } | |
373 | } | |
374 | ||
375 | /** Method looks up an integer-valued attribute (not recursive!) | |
376 | */ | |
377 | private int getIntAttr(HTML.Attribute name, int iDefault) | |
378 | { | |
379 | AttributeSet attr = fElement.getAttributes(); | |
380 | if(attr.isDefined(name)) | |
381 | { | |
382 | int i; | |
383 | String val = (String)attr.getAttribute(name); | |
384 | if(val == null) | |
385 | { | |
386 | i = iDefault; | |
387 | } | |
388 | else | |
389 | { | |
390 | try | |
391 | { | |
392 | i = Math.max(0, Integer.parseInt(val)); | |
393 | } | |
394 | catch(NumberFormatException nfe) | |
395 | { | |
396 | i = iDefault; | |
397 | } | |
398 | } | |
399 | return i; | |
400 | } | |
401 | else | |
402 | { | |
403 | return iDefault; | |
404 | } | |
405 | } | |
406 | ||
407 | /** | |
408 | * Establishes the parent view for this view. | |
409 | * Seize this moment to cache the AWT Container I'm in. | |
410 | */ | |
411 | public void setParent(View parent) | |
412 | { | |
413 | super.setParent(parent); | |
414 | fContainer = ((parent != null) ? getContainer() : null); | |
415 | if((parent == null) && (fComponent != null)) | |
416 | { | |
417 | fComponent.getParent().remove(fComponent); | |
418 | fComponent = null; | |
419 | } | |
420 | } | |
421 | ||
422 | /** My attributes may have changed. */ | |
423 | public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) | |
424 | { | |
425 | super.changedUpdate(e, a, f); | |
426 | float align = getVerticalAlignment(); | |
427 | ||
428 | int height = fHeight; | |
429 | int width = fWidth; | |
430 | ||
431 | initialize(getElement()); | |
432 | ||
433 | boolean hChanged = fHeight != height; | |
434 | boolean wChanged = fWidth != width; | |
435 | if(hChanged || wChanged || getVerticalAlignment() != align) | |
436 | { | |
437 | getParent().preferenceChanged(this, hChanged, wChanged); | |
438 | } | |
439 | } | |
440 | ||
441 | ||
442 | /** | |
443 | * Paints the image. | |
444 | * | |
445 | * @param g the rendering surface to use | |
446 | * @param a the allocated region to render into | |
447 | * @see View#paint | |
448 | */ | |
449 | public void paint(Graphics g, Shape a) | |
450 | { | |
451 | Color oldColor = g.getColor(); | |
452 | fBounds = a.getBounds(); | |
453 | int border = getBorder(); | |
454 | int x = fBounds.x + border + getSpace(X_AXIS); | |
455 | int y = fBounds.y + border + getSpace(Y_AXIS); | |
456 | int width = fWidth; | |
457 | int height = fHeight; | |
458 | int sel = getSelectionState(); | |
459 | ||
460 | // If no pixels yet, draw gray outline and icon | |
461 | if(!hasPixels(this)) | |
462 | { | |
463 | g.setColor(Color.lightGray); | |
464 | g.drawRect(x, y, width - 1, height - 1); | |
465 | g.setColor(oldColor); | |
466 | loadImageStatusIcons(); | |
467 | Icon icon = ((fImage == null) ? sMissingImageIcon : sPendingImageIcon); | |
468 | if(icon != null) | |
469 | { | |
470 | icon.paintIcon(getContainer(), g, x, y); | |
471 | } | |
472 | } | |
473 | ||
474 | // Draw image | |
475 | if(fImage != null) | |
476 | { | |
477 | g.drawImage(fImage, x, y, width, height, this); | |
478 | } | |
479 | ||
480 | // If selected exactly, we need a black border & grow-box | |
481 | Color bc = getBorderColor(); | |
482 | if(sel == 2) | |
483 | { | |
484 | // Make sure there's room for a border | |
485 | int delta = 2 - border; | |
486 | if(delta > 0) | |
487 | { | |
488 | x += delta; | |
489 | y += delta; | |
490 | width -= delta << 1; | |
491 | height -= delta << 1; | |
492 | border = 2; | |
493 | } | |
494 | bc = null; | |
495 | g.setColor(Color.black); | |
496 | // Draw grow box | |
497 | g.fillRect(x + width - 5, y + height - 5, 5, 5); | |
498 | } | |
499 | ||
500 | // Draw border | |
501 | if(border > 0) | |
502 | { | |
503 | if(bc != null) | |
504 | { | |
505 | g.setColor(bc); | |
506 | } | |
507 | // Draw a thick rectangle: | |
508 | for(int i = 1; i <= border; i++) | |
509 | { | |
510 | g.drawRect(x - i, y - i, width - 1 + i + i, height - 1 + i + i); | |
511 | } | |
512 | g.setColor(oldColor); | |
513 | } | |
514 | } | |
515 | ||
516 | /** Request that this view be repainted. Assumes the view is still at its last-drawn location. | |
517 | */ | |
518 | protected void repaint(long delay) | |
519 | { | |
520 | if((fContainer != null) && (fBounds != null)) | |
521 | { | |
522 | fContainer.repaint(delay, fBounds.x, fBounds.y, fBounds.width, fBounds.height); | |
523 | } | |
524 | } | |
525 | ||
526 | /** | |
527 | * Determines whether the image is selected, and if it's the only thing selected. | |
528 | * @return 0 if not selected, 1 if selected, 2 if exclusively selected. | |
529 | * "Exclusive" selection is only returned when editable. | |
530 | */ | |
531 | protected int getSelectionState() | |
532 | { | |
533 | int p0 = fElement.getStartOffset(); | |
534 | int p1 = fElement.getEndOffset(); | |
535 | if(fContainer instanceof JTextComponent) | |
536 | { | |
537 | JTextComponent textComp = (JTextComponent)fContainer; | |
538 | int start = textComp.getSelectionStart(); | |
539 | int end = textComp.getSelectionEnd(); | |
540 | if((start <= p0) && (end >= p1)) | |
541 | { | |
542 | if((start == p0) && (end == p1) && isEditable()) | |
543 | { | |
544 | return 2; | |
545 | } | |
546 | else | |
547 | { | |
548 | return 1; | |
549 | } | |
550 | } | |
551 | } | |
552 | return 0; | |
553 | } | |
554 | ||
555 | protected boolean isEditable() | |
556 | { | |
557 | return ((fContainer instanceof JEditorPane) && ((JEditorPane)fContainer).isEditable()); | |
558 | } | |
559 | ||
560 | /** Returns the text editor's highlight color. | |
561 | */ | |
562 | protected Color getHighlightColor() | |
563 | { | |
564 | JTextComponent textComp = (JTextComponent)fContainer; | |
565 | return textComp.getSelectionColor(); | |
566 | } | |
567 | ||
568 | // Progressive display ------------------------------------------------- | |
569 | ||
570 | // This can come on any thread. If we are in the process of reloading | |
571 | // the image and determining our state (loading == true) we don't fire | |
572 | // preference changed, or repaint, we just reset the fWidth/fHeight as | |
573 | // necessary and return. This is ok as we know when loading finishes | |
574 | // it will pick up the new height/width, if necessary. | |
575 | ||
576 | private static boolean sIsInc = true; | |
577 | private static int sIncRate = 100; | |
578 | ||
579 | public boolean imageUpdate(Image img, int flags, int x, int y, int width, int height) | |
580 | { | |
581 | if((fImage == null) || (fImage != img)) | |
582 | { | |
583 | return false; | |
584 | } | |
585 | ||
586 | // Bail out if there was an error | |
587 | if((flags & (ABORT|ERROR)) != 0) | |
588 | { | |
589 | fImage = null; | |
590 | repaint(0); | |
591 | return false; | |
592 | } | |
593 | ||
594 | // Resize image if necessary | |
595 | short changed = 0; | |
596 | if((flags & ImageObserver.HEIGHT) != 0) | |
597 | { | |
598 | if(!getElement().getAttributes().isDefined(HTML.Attribute.HEIGHT)) | |
599 | { | |
600 | changed |= 1; | |
601 | } | |
602 | } | |
603 | if((flags & ImageObserver.WIDTH) != 0) | |
604 | { | |
605 | if(!getElement().getAttributes().isDefined(HTML.Attribute.WIDTH)) | |
606 | { | |
607 | changed |= 2; | |
608 | } | |
609 | } | |
610 | ||
611 | synchronized(this) | |
612 | { | |
613 | if((changed & 1) == 1) | |
614 | { | |
615 | fWidth = width; | |
616 | } | |
617 | if((changed & 2) == 2) | |
618 | { | |
619 | fHeight = height; | |
620 | } | |
621 | if(bLoading) | |
622 | { | |
623 | // No need to resize or repaint, still in the process of loading | |
624 | return true; | |
625 | } | |
626 | } | |
627 | ||
628 | if(changed != 0) | |
629 | { | |
630 | // May need to resize myself, asynchronously | |
631 | Document doc = getDocument(); | |
632 | try | |
633 | { | |
634 | if(doc instanceof AbstractDocument) | |
635 | { | |
636 | ((AbstractDocument)doc).readLock(); | |
637 | } | |
638 | preferenceChanged(this, true, true); | |
639 | } | |
640 | finally | |
641 | { | |
642 | if(doc instanceof AbstractDocument) | |
643 | { | |
644 | ((AbstractDocument)doc).readUnlock(); | |
645 | } | |
646 | } | |
647 | return true; | |
648 | } | |
649 | ||
650 | // Repaint when done or when new pixels arrive | |
651 | if((flags & (FRAMEBITS|ALLBITS)) != 0) | |
652 | { | |
653 | repaint(0); | |
654 | } | |
655 | else if((flags & SOMEBITS) != 0) | |
656 | { | |
657 | if(sIsInc) | |
658 | { | |
659 | repaint(sIncRate); | |
660 | } | |
661 | } | |
662 | return ((flags & ALLBITS) == 0); | |
663 | } | |
664 | ||
665 | // Layout -------------------------------------------------------------- | |
666 | ||
667 | /** Determines the preferred span for this view along an axis. | |
668 | * | |
669 | * @param axis may be either X_AXIS or Y_AXIS | |
670 | * @returns the span the view would like to be rendered into. | |
671 | * Typically the view is told to render into the span | |
672 | * that is returned, although there is no guarantee. | |
673 | * The parent may choose to resize or break the view. | |
674 | */ | |
675 | public float getPreferredSpan(int axis) | |
676 | { | |
677 | int extra = 2 * (getBorder() + getSpace(axis)); | |
678 | switch(axis) | |
679 | { | |
680 | case View.X_AXIS: | |
681 | return fWidth+extra; | |
682 | case View.Y_AXIS: | |
683 | return fHeight+extra; | |
684 | default: | |
685 | throw new IllegalArgumentException("Invalid axis in getPreferredSpan() : " + axis); | |
686 | } | |
687 | } | |
688 | ||
689 | /** Determines the desired alignment for this view along an | |
690 | * axis. This is implemented to give the alignment to the | |
691 | * bottom of the icon along the y axis, and the default | |
692 | * along the x axis. | |
693 | * | |
694 | * @param axis may be either X_AXIS or Y_AXIS | |
695 | * @returns the desired alignment. This should be a value | |
696 | * between 0.0 and 1.0 where 0 indicates alignment at the | |
697 | * origin and 1.0 indicates alignment to the full span | |
698 | * away from the origin. An alignment of 0.5 would be the | |
699 | * center of the view. | |
700 | */ | |
701 | public float getAlignment(int axis) | |
702 | { | |
703 | switch(axis) | |
704 | { | |
705 | case View.Y_AXIS: | |
706 | return getVerticalAlignment(); | |
707 | default: | |
708 | return super.getAlignment(axis); | |
709 | } | |
710 | } | |
711 | ||
712 | /** Provides a mapping from the document model coordinate space | |
713 | * to the coordinate space of the view mapped to it. | |
714 | * | |
715 | * @param pos the position to convert | |
716 | * @param a the allocated region to render into | |
717 | * @return the bounding box of the given position | |
718 | * @exception BadLocationException if the given position does not represent a | |
719 | * valid location in the associated document | |
720 | * @see View#modelToView | |
721 | */ | |
722 | public Shape modelToView(int pos, Shape a, Position.Bias b) | |
723 | throws BadLocationException | |
724 | { | |
725 | int p0 = getStartOffset(); | |
726 | int p1 = getEndOffset(); | |
727 | if((pos >= p0) && (pos <= p1)) | |
728 | { | |
729 | Rectangle r = a.getBounds(); | |
730 | if(pos == p1) | |
731 | { | |
732 | r.x += r.width; | |
733 | } | |
734 | r.width = 0; | |
735 | return r; | |
736 | } | |
737 | return null; | |
738 | } | |
739 | ||
740 | /** Provides a mapping from the view coordinate space to the logical | |
741 | * coordinate space of the model. | |
742 | * | |
743 | * @param x the X coordinate | |
744 | * @param y the Y coordinate | |
745 | * @param a the allocated region to render into | |
746 | * @return the location within the model that best represents the | |
747 | * given point of view | |
748 | * @see View#viewToModel | |
749 | */ | |
750 | public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) | |
751 | { | |
752 | Rectangle alloc = (Rectangle) a; | |
753 | if(x < (alloc.x + alloc.width)) | |
754 | { | |
755 | bias[0] = Position.Bias.Forward; | |
756 | return getStartOffset(); | |
757 | } | |
758 | bias[0] = Position.Bias.Backward; | |
759 | return getEndOffset(); | |
760 | } | |
761 | ||
762 | /** Change the size of this image. This alters the HEIGHT and WIDTH | |
763 | * attributes of the Element and causes a re-layout. | |
764 | */ | |
765 | protected void resize(int width, int height) | |
766 | { | |
767 | if((width == fWidth) && (height == fHeight)) | |
768 | { | |
769 | return; | |
770 | } | |
771 | fWidth = width; | |
772 | fHeight= height; | |
773 | // Replace attributes in document | |
774 | MutableAttributeSet attr = new SimpleAttributeSet(); | |
775 | attr.addAttribute(HTML.Attribute.WIDTH ,Integer.toString(width)); | |
776 | attr.addAttribute(HTML.Attribute.HEIGHT,Integer.toString(height)); | |
777 | ((StyledDocument)getDocument()).setCharacterAttributes(fElement.getStartOffset(), fElement.getEndOffset(), attr, false); | |
778 | } | |
779 | ||
780 | // Mouse event handling ------------------------------------------------ | |
781 | ||
782 | /** Select or grow image when clicked. | |
783 | */ | |
784 | public void mousePressed(MouseEvent e) | |
785 | { | |
786 | Dimension size = fComponent.getSize(); | |
787 | if((e.getX() >= (size.width - 7)) && (e.getY() >= (size.height - 7)) && (getSelectionState() == 2)) | |
788 | { | |
789 | // Click in selected grow-box: | |
790 | Point loc = fComponent.getLocationOnScreen(); | |
791 | fGrowBase = new Point(loc.x + e.getX() - fWidth, loc.y + e.getY() - fHeight); | |
792 | fGrowProportionally = e.isShiftDown(); | |
793 | } | |
794 | else | |
795 | { | |
796 | // Else select image: | |
797 | fGrowBase = null; | |
798 | JTextComponent comp = (JTextComponent)fContainer; | |
799 | int start = fElement.getStartOffset(); | |
800 | int end = fElement.getEndOffset(); | |
801 | int mark = comp.getCaret().getMark(); | |
802 | int dot = comp.getCaret().getDot(); | |
803 | if(e.isShiftDown()) | |
804 | { | |
805 | // extend selection if shift key down: | |
806 | if(mark <= start) | |
807 | { | |
808 | comp.moveCaretPosition(end); | |
809 | } | |
810 | else | |
811 | { | |
812 | comp.moveCaretPosition(start); | |
813 | } | |
814 | } | |
815 | else | |
816 | { | |
817 | // just select image, without shift: | |
818 | if(mark != start) | |
819 | { | |
820 | comp.setCaretPosition(start); | |
821 | } | |
822 | if(dot != end) | |
823 | { | |
824 | comp.moveCaretPosition(end); | |
825 | } | |
826 | } | |
827 | } | |
828 | } | |
829 | ||
830 | /** Resize image if initial click was in grow-box: */ | |
831 | public void mouseDragged(MouseEvent e) | |
832 | { | |
833 | if(fGrowBase != null) | |
834 | { | |
835 | Point loc = fComponent.getLocationOnScreen(); | |
836 | int width = Math.max(2, loc.x + e.getX() - fGrowBase.x); | |
837 | int height= Math.max(2, loc.y + e.getY() - fGrowBase.y); | |
838 | if(e.isShiftDown() && fImage != null) | |
839 | { | |
840 | // Make sure size is proportional to actual image size | |
841 | float imgWidth = fImage.getWidth(this); | |
842 | float imgHeight = fImage.getHeight(this); | |
843 | if((imgWidth > 0) && (imgHeight > 0)) | |
844 | { | |
845 | float prop = imgHeight / imgWidth; | |
846 | float pwidth = height / prop; | |
847 | float pheight = width * prop; | |
848 | if(pwidth > width) | |
849 | { | |
850 | width = (int)pwidth; | |
851 | } | |
852 | else | |
853 | { | |
854 | height = (int)pheight; | |
855 | } | |
856 | } | |
857 | } | |
858 | resize(width,height); | |
859 | } | |
860 | } | |
861 | ||
862 | public void mouseReleased(MouseEvent me) | |
863 | { | |
864 | fGrowBase = null; | |
865 | //! Should post some command to make the action undo-able | |
866 | } | |
867 | ||
868 | /** On double-click, open image properties dialog. | |
869 | */ | |
870 | public void mouseClicked(MouseEvent me) | |
871 | { | |
872 | if(me.getClickCount() == 2) | |
873 | { | |
874 | //$ IMPLEMENT | |
875 | } | |
876 | } | |
877 | ||
878 | public void mouseEntered(MouseEvent me) { ; } | |
879 | public void mouseMoved(MouseEvent me) { ; } | |
880 | public void mouseExited(MouseEvent me) { ; } | |
881 | ||
882 | // Static icon accessors ----------------------------------------------- | |
883 | ||
884 | private Icon makeIcon(final String gifFile) | |
885 | throws IOException | |
886 | { | |
887 | /* Copy resource into a byte array. This is | |
888 | * necessary because several browsers consider | |
889 | * Class.getResource a security risk because it | |
890 | * can be used to load additional classes. | |
891 | * Class.getResourceAsStream just returns raw | |
892 | * bytes, which we can convert to an image. | |
893 | */ | |
894 | InputStream resource = RelativeImageView.class.getResourceAsStream(gifFile); | |
895 | ||
896 | if(resource == null) | |
897 | { | |
898 | return null; | |
899 | } | |
900 | BufferedInputStream in = new BufferedInputStream(resource); | |
901 | ByteArrayOutputStream out = new ByteArrayOutputStream(1024); | |
902 | byte[] buffer = new byte[1024]; | |
903 | int n; | |
904 | while((n = in.read(buffer)) > 0) | |
905 | { | |
906 | out.write(buffer, 0, n); | |
907 | } | |
908 | in.close(); | |
909 | out.flush(); | |
910 | ||
911 | buffer = out.toByteArray(); | |
912 | if(buffer.length == 0) | |
913 | { | |
914 | System.err.println("WARNING : " + gifFile + " is zero-length"); | |
915 | return null; | |
916 | } | |
917 | return new ImageIcon(buffer); | |
918 | } | |
919 | ||
920 | private void loadImageStatusIcons() | |
921 | { | |
922 | try | |
923 | { | |
924 | if(sPendingImageIcon == null) | |
925 | { | |
926 | sPendingImageIcon = makeIcon(PENDING_IMAGE_SRC); | |
927 | } | |
928 | if(sMissingImageIcon == null) | |
929 | { | |
930 | sMissingImageIcon = makeIcon(MISSING_IMAGE_SRC); | |
931 | } | |
932 | } | |
933 | catch(Exception e) | |
934 | { | |
935 | System.err.println("ImageView : Couldn't load image icons"); | |
936 | } | |
937 | } | |
938 | ||
939 | protected StyleSheet getStyleSheet() | |
940 | { | |
941 | HTMLDocument doc = (HTMLDocument)getDocument(); | |
942 | return doc.getStyleSheet(); | |
943 | } | |
944 | ||
945 | } |