History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/awt/iGraphics.java (1 of 18352 files). Show all

Unified · Split

java/pkg/awt/iGraphics.java+606−0
@@ -0,0 +1,606 @@
1package inferno.awt;
2
3import java.awt.*;
4import java.awt.peer.*;
5import java.io.*;
6import java.util.*;
7import java.awt.image.ImageObserver;
8import inferno.awt.iFontPeer;
9
10//import sun.awt.image.OffScreenImageSource;
11//import sun.awt.image.ImageRepresentation;
12
13/**
14 * iGraphics is an object that encapsulates a graphics context for a
15 * particular canvas.
16 *
17 * @version 1.18 18 Mar 1996
18 */
19
20public class iGraphics extends Graphics {
21 // Object pcanvas;
22 Object refImage;
23 Object refOffScreenImage;
24 Component target;
25 Color foreground;
26 Font font;
27 private iFontPeer ifontpeer;
28 int originX;
29 int originY;
30 Rectangle clipRect;
31 Rectangle initialClipRect;
32 boolean dirty;
33
34 //private native void imageCreate(ImageRepresentation ir);
35 private native void pSetForeground(int r, int g, int b);
36
37 private Image image;
38
39 private Object awt; // Pointer to awt object
40
41 private native void createGraphics();
42
43 public iGraphics(Object refImage, Object refOffScreenImage, Rectangle initialClipRect, Component target)
44 {
45 this.refImage = refImage;
46 this.refOffScreenImage = refOffScreenImage;
47 this.initialClipRect = new Rectangle(initialClipRect);
48 this.clipRect = new Rectangle(initialClipRect);
49 this.target = target;
50 this.font = target.getFont();
51 if (font != null) {
52 this.ifontpeer = (iFontPeer)font.getPeer();
53 }
54 dirty = false;
55 createGraphics();
56 }
57
58// a dummy constructor for testing
59 public iGraphics(Object im) {
60 }
61
62
63 public iGraphics(Image image) {
64 }
65
66 /**
67 * Create a new iGraphics Object based on this one.
68 */
69 public Graphics create() {
70 iGraphics g = new iGraphics(refImage, refOffScreenImage, initialClipRect, target);
71 g.foreground = foreground;
72 g.font = font;
73 g.ifontpeer = ifontpeer;
74 g.originX = originX;
75 g.originY = originY;
76 g.image = image;
77 //g.clipRect = clipRect;
78 //g.initialClipRect = initialClipRect;
79 return g;
80 }
81
82 private void checkDirty()
83 {
84 if (dirty)
85 {
86 dirty = false;
87 copyOffscreenImage(clipRect.x,clipRect.y,clipRect.width,clipRect.height);
88 }
89
90 }
91
92
93 /**
94 * Translate
95 */
96 public void translate(int x, int y) {
97 originX += x;
98 originY += y;
99 clipRect.translate(-x,-y);
100 initialClipRect.translate(-x,-y);
101 }
102
103 /**
104 * Disposes of this iGraphics context. It cannot be used after being
105 * disposed.
106 */
107 private native void pDispose();
108
109 public void dispose()
110 {
111 checkDirty();
112 pDispose();
113 }
114
115 public void setFont(Font font) {
116 if ((font != null) && (this.font != font)) {
117 synchronized (this.font) {
118 this.font = font;
119 ifontpeer = (iFontPeer)font.getPeer();
120 }
121 }
122 }
123 public Font getFont() {
124 return this.font;
125 }
126
127 /**
128 * Gets font metrics for the given font.
129 */
130 public FontMetrics getFontMetrics(Font font) {
131 return iFontMetrics.getFontMetrics(font);
132 }
133
134
135 private void ourSetForeground()
136 {
137 pSetForeground(foreground.getRed(), foreground.getGreen(), foreground.getBlue());
138 }
139
140 /**
141 * Sets the foreground color.
142 */
143 public void setColor(Color c) {
144 if ((c != null) && (c != foreground)) {
145 foreground = c;
146 pSetForeground(c.getRed(), c.getGreen(), c.getBlue());
147 }
148 }
149 public Color getColor() {
150 return foreground;
151 }
152
153
154 /**
155 * Sets the paint mode to overwrite the destination with the
156 * current color. This is the default paint mode.
157 */
158 public native void setPaintMode();
159
160 /**
161 * Sets the paint mode to alternate between the current color
162 * and the given color.
163 */
164 public native void setXORMode(Color c1);
165
166 /**
167 * Gets the current clipping area
168 */
169 public Rectangle getClipBounds()
170 {
171 return new Rectangle(clipRect);
172 }
173
174 private native void changeClip(int X, int Y, int W, int H, boolean set);
175
176 private void removeClip()
177 {
178 checkDirty();
179 clipRect = new Rectangle(initialClipRect);
180 }
181
182 private void ourSetClip()
183 {
184 dirty = true;
185 changeClip(clipRect.x,clipRect.y,clipRect.width,clipRect.height,true);
186 }
187
188 /** Crops the clipping rectangle for this iGraphics context. */
189 public void clipRect(int X, int Y, int W, int H) {
190 checkDirty();
191 clipRect = clipRect.intersection(new Rectangle(X,Y,W,H)); // test lg
192 // System.out.println("java == intersection: "+ clipRect);
193 //changeClip(X, Y, W, H, false);
194 }
195
196 /** Sets the clipping rectangle for this iGraphics context. */
197 public void setClip(int X, int Y, int W, int H) {
198 checkDirty();
199 clipRect = new Rectangle(X,Y,W,H);
200 //changeClip(X, Y, W, H, true);
201 }
202
203 /** Returns a Shape object representing the clip. */
204 public Shape getClip() {
205 return getClipBounds();
206 }
207
208 /** Sets the clip to a Shape (only Rectangle allowed). */
209 public void setClip(Shape clip) {
210 if (clip == null) {
211 removeClip();
212 } else if (clip instanceof Rectangle) {
213 Rectangle r = (Rectangle) clip;
214 checkDirty();
215 clipRect = new Rectangle(r);
216 //changeClip(r.x, r.y, r.width, r.height, true);
217 } else {
218 throw new IllegalArgumentException("setClip(Shape) only supports Rectangle objects");
219 }
220 }
221
222 /** Clears the rectangle indicated by x,y,w,h. */
223 private native void pClearRect(int x, int y, int w, int h);
224
225 public void clearRect(int x, int y, int w, int h)
226 {
227 ourSetClip();
228 pClearRect(x,y,w,h);
229 }
230
231 /** Fills the given rectangle with the foreground color. */
232 private native void pFillRect(int X, int Y, int W, int H);
233
234 public void fillRect(int X, int Y, int W, int H)
235 {
236 ourSetClip();
237 pFillRect(X,Y,W,H);
238 }
239
240 /** Draws the given rectangle. */
241 private native void pDrawRect(int X, int Y, int W, int H);
242
243 public void drawRect(int X, int Y, int W, int H)
244 {
245 ourSetClip();
246 pDrawRect(X,Y,W,H);
247 }
248
249
250 /** Draws the given string. */
251 public void drawString(String str, int x, int y) {
252 drawStringWidth(str, x, y);
253 }
254
255 /** Draws the given character array. */
256 public void drawChars(char data[], int offset, int length, int x, int y) {
257 String str = new String(data, offset, length);
258 drawStringWidth(str, x, y);
259 // drawCharsWidth(data, offset, length, x, y);
260 }
261
262 /** Draws the given byte array. */
263 public void drawBytes(byte data[], int offset, int length, int x, int y) {
264 String str = new String(data, offset, length);
265 drawStringWidth(str, x, y);
266 // drawBytesWidth(data, offset, length, x, y);
267 }
268
269 /** Draws the given string and returns the length of the drawn
270 string in pixels. If font is not set then returns -1. */
271 private native int pDrawStringWidth(String str, int x, int y);
272
273 private int drawStringWidth(String str, int x, int y)
274 {
275 int r;
276 ourSetClip();
277 if (ifontpeer == null) {
278 return 0;
279 }
280 r = pDrawStringWidth(str, x, y - ifontpeer.iAscent - ifontpeer.fLeading);
281 // System.out.println("Length of string "+r);
282 return r;
283 }
284
285 /** Draws the given character array and return the width in
286 pixels. If font is not set then returns -1. */
287// public native int drawCharsWidth(char data[], int offset, int length,
288// int x, int y);
289
290 /** Draws the given character array and return the width in
291 pixels. If font is not set then returns -1. */
292// public native int drawBytesWidth(byte data[], int offset, int length,
293// int x, int y);
294
295 /** Draws the given line. */
296 private native void pDrawLine(int x1, int y1, int x2, int y2);
297
298 public void drawLine(int x1, int y1, int x2, int y2) {
299 ourSetClip();
300 pDrawLine(x1, y1, x2, y2);
301 }
302
303 /**
304 * Draws an image at x,y in nonblocking mode with a callback object.
305 */
306 public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
307 // We need to get the bits.
308 if ( img == null )
309 return false;
310 java.awt.image.ImageProducer ip = img.getSource();
311 java.awt.image.ImageConsumer ic = new iImageConsumer(this, img, x, y);
312 ip.startProduction(ic);
313 ip.removeConsumer(ic);
314 /*WImage wImg = (WImage) img;
315 if (wImg.hasError()) {
316 if (observer != null) {
317 observer.imageUpdate(img,
318 ImageObserver.ERROR|ImageObserver.ABORT,
319 -1, -1, -1, -1);
320 }
321 return false;
322 }
323 ImageRepresentation ir = wImg.getImageRep();
324 return ir.drawImage(this, x, y, null, observer);
325 */
326 return false;
327 }
328
329 /**
330 * Draws an image scaled to x,y,w,h in nonblocking mode with a
331 * callback object.
332 */
333 public boolean drawImage(Image img, int x, int y, int width, int height,
334 ImageObserver observer) {
335 /*if (width == 0 || height == 0) {
336 return true;
337 }
338 WImage wImg = (WImage) img;
339 if (wImg.hasError()) {
340 if (observer != null) {
341 observer.imageUpdate(img,
342 ImageObserver.ERROR|ImageObserver.ABORT,
343 -1, -1, -1, -1);
344 }
345 return false;
346 }
347 ImageRepresentation ir = wImg.getImageRep();
348 return ir.drawScaledImage(this, x, y, width, height, null, observer);
349 */
350 return false;
351 }
352
353 /**
354 * Draws an image at x,y in nonblocking mode with a solid background
355 * color and a callback object.
356 */
357 public boolean drawImage(Image img, int x, int y, Color bg,
358 ImageObserver observer) {
359 /*WImage wImg = (WImage) img;
360 if (wImg.hasError()) {
361 if (observer != null) {
362 observer.imageUpdate(img,
363 ImageObserver.ERROR|ImageObserver.ABORT,
364 -1, -1, -1, -1);
365 }
366 return false;
367 }
368 ImageRepresentation ir = wImg.getImageRep();
369 return ir.drawImage(this, x, y, bg, observer);
370 */
371 return false;
372 }
373
374 /**
375 * Draws an image scaled to x,y,w,h in nonblocking mode with a
376 * solid background color and a callback object.
377 */
378 public boolean drawImage(Image img, int x, int y, int width, int height,
379 Color bg, ImageObserver observer) {
380 /*if (width == 0 || height == 0) {
381 return true;
382 }
383 WImage wImg = (WImage) img;
384 if (wImg.hasError()) {
385 if (observer != null) {
386 observer.imageUpdate(img,
387 ImageObserver.ERROR|ImageObserver.ABORT,
388 -1, -1, -1, -1);
389 }
390 return false;
391 }
392 ImageRepresentation ir = wImg.getImageRep();
393 return ir.drawScaledImage(this, x, y, width, height, bg, observer);
394 */
395 return false;
396 }
397
398 /**
399 * Draws a subrectangle of an image scaled to a destination rectangle
400 * in nonblocking mode with a callback object.
401 */
402 public boolean drawImage(Image img,
403 int dx1, int dy1, int dx2, int dy2,
404 int sx1, int sy1, int sx2, int sy2,
405 ImageObserver observer) {
406 /*if (dx1 == dx2 || dy1 == dy2) {
407 return true;
408 }
409 WImage wImg = (WImage) img;
410 if (wImg.hasError()) {
411 if (observer != null) {
412 observer.imageUpdate(img,
413 ImageObserver.ERROR|ImageObserver.ABORT,
414 -1, -1, -1, -1);
415 }
416 return false;
417 }
418 ImageRepresentation ir = wImg.getImageRep();
419 return ir.drawStretchImage(this,
420 dx1, dy1, dx2, dy2,
421 sx1, sy1, sx2, sy2,
422 null, observer);
423 */
424 return false;
425 }
426
427 /**
428 * Draws a subrectangle of an image scaled to a destination rectangle in
429 * nonblocking mode with a solid background color and a callback object.
430 */
431 public boolean drawImage(Image img,
432 int dx1, int dy1, int dx2, int dy2,
433 int sx1, int sy1, int sx2, int sy2,
434 Color bgcolor, ImageObserver observer) {
435 /*if (dx1 == dx2 || dy1 == dy2) {
436 return true;
437 }
438 WImage wImg = (WImage) img;
439 if (wImg.hasError()) {
440 if (observer != null) {
441 observer.imageUpdate(img,
442 ImageObserver.ERROR|ImageObserver.ABORT,
443 -1, -1, -1, -1);
444 }
445 return false;
446 }
447 ImageRepresentation ir = wImg.getImageRep();
448 return ir.drawStretchImage(this,
449 dx1, dy1, dx2, dy2,
450 sx1, sy1, sx2, sy2,
451 bgcolor, observer);
452 */
453 return false;
454 }
455
456 /**
457 * Actually draws the image on the Inferno display in a blocking mode.
458 */
459 private native void pGenDraw(int x, int y, int w, int h, byte pixels[]);
460
461 protected void drawImage(int x, int y, int w, int h, byte pixels[]) {
462 ourSetClip();
463 //ourSetForeground();
464 pGenDraw(x, y, w, h, pixels);
465 return;
466 }
467
468 /**
469 * Copies an area of the canvas that this graphics context paints to.
470 * @param X the x-coordinate of the source.
471 * @param Y the y-coordinate of the source.
472 * @param W the width.
473 * @param H the height.
474 * @param dx the x-coordinate of the destination.
475 * @param dy the y-coordinate of the destination.
476 */
477 public native void copyArea(int X, int Y, int W, int H, int dx, int dy);
478
479
480 /** Draws a rounded rectangle. */
481 private native void pDrawRoundRect(int x, int y, int w, int h,
482 int arcWidth, int arcHeight);
483
484 public void drawRoundRect(int x, int y, int w, int h,
485 int arcWidth, int arcHeight)
486 {
487 ourSetClip();
488 pDrawRoundRect(x,y,w,h,arcWidth,arcHeight);
489 }
490
491 /** Draws a filled rounded rectangle. */
492 private native void pFillRoundRect(int x, int y, int w, int h,
493 int arcWidth, int arcHeight);
494
495 public void fillRoundRect(int x, int y, int w, int h,
496 int arcWidth, int arcHeight)
497 {
498 ourSetClip();
499 pFillRoundRect(x,y,w,h,arcWidth,arcHeight);
500 }
501
502 /** Draws a polygon defined by an array of x points and y points */
503 private native void pDrawPolygon(int xPoints[], int yPoints[], int nPoints);
504
505 public void drawPolygon(int xPoints[], int yPoints[], int nPoints)
506 {
507 ourSetClip();
508 pDrawPolygon(xPoints,yPoints,nPoints);
509 }
510
511 /** Draws a polygon defined by an array of x points and y points */
512 private native void pDrawPolyline(int xPoints[], int yPoints[], int nPoints);
513
514 public void drawPolyline(int xPoints[], int yPoints[], int nPoints)
515 {
516 ourSetClip();
517 pDrawPolyline(xPoints,yPoints,nPoints);
518 }
519
520 /** Fills a polygon with the current fill mask */
521 private native void pFillPolygon(int xPoints[], int yPoints[], int nPoints);
522
523 public void fillPolygon(int xPoints[], int yPoints[], int nPoints)
524 {
525 ourSetClip();
526 pFillPolygon(xPoints,yPoints,nPoints);
527 }
528
529 /** Draws an oval to fit in the given rectangle */
530 private native void pDrawOval(int x, int y, int w, int h);
531
532 public void drawOval(int x, int y, int w, int h)
533 {
534 ourSetClip();
535 pDrawOval(x,y,w,h);
536 }
537
538 /** Fills an oval to fit in the given rectangle */
539 private native void pFillOval(int x, int y, int w, int h);
540
541 public void fillOval(int x, int y, int w, int h)
542 {
543 ourSetClip();
544 pFillOval(x,y,w,h);
545 }
546
547 /**
548 * Draws an arc bounded by the given rectangle from startAngle to
549 * endAngle. 0 degrees is a vertical line straight up from the
550 * center of the rectangle. Positive angles indicate clockwise
551 * rotations, negative angle are counter-clockwise.
552 */
553 private native void pDrawArc(int x, int y, int w, int h,
554 int startAngle,
555 int endAngle);
556
557 public void drawArc(int x, int y, int w, int h,
558 int startAngle,
559 int endAngle)
560 {
561 ourSetClip();
562 pDrawArc(x,y,w,h,startAngle,endAngle);
563 }
564
565 /** fills an arc. arguments are the same as drawArc. */
566 private native void pFillArc(int x, int y, int w, int h,
567 int startAngle,
568 int endAngle);
569
570 public void fillArc(int x, int y, int w, int h,
571 int startAngle,
572 int endAngle)
573 {
574 ourSetClip();
575 pFillArc(x,y,w,h,startAngle,endAngle);
576 }
577
578
579 public String toString() {
580 return (getClass().getName() + "[" + originX + "," + originY +
581 "[font=" + getFont() + "], color=" + getColor() + "]");
582 }
583
584 // Print a peer using this graphics object.
585 void print(ComponentPeer peer)
586 {
587 }
588
589 /* Outline the given region. */
590 //public native void drawRegion(Region r);
591
592 /* Fill the given region. */
593 //public native void fillRegion(Region r);
594
595 /** Terminates a PrintJob and releases resources */
596 public void close(PrintJob pj)
597 {
598 }
599
600 private native void copyOffscreenImage(int X, int Y, int W, int H);
601
602}
603
604
605
606