1 /*******************************************************************************

     2  * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved. This program and the accompanying materials

     4  * are made available under the terms of the Eclipse Public License v1.0

     5  * which accompanies this distribution, and is available at

     6  * http://www.eclipse.org/legal/epl-v10.html

     7  *

     8  * Contributors:

     9  *     Nokia Corporation - initial implementation

    10  *******************************************************************************/

    11 package org.eclipse.swt.internal.qt.graphics;

    12 

    13 import java.util.Vector;

    14 import java.util.Enumeration;

    15 

    16 /**

    17  * This class implements a command buffer that can be bound by GraphicsContext

    18  * to collect the drawing operations. Contents of the command buffer can be replayed to

    19  * GraphicsContext target with GraphicsContext.render() method.

    20  *

    21  * When JavaCommandBuffer is set as the target of GraphicsContext some of the methods

    22  * provided by GraphicsContext are not supported, e.g. getters, since the JavaCommandBuffer

    23  * does not have a real rendering target from which to query related data. To find out what is

    24  * supported see the methods of this class. In principal GraphicsContext supports all draw and set operations,

    25  * when JavaCommandBuffer is set as rendering target.

    26  */

    27 public final class JavaCommandBuffer {

    28 

    29 	// All collected drawing operations and their parameters

    30 	private int[] intParams;

    31 	private int intCount;

    32 	private StringBuffer strParams;

    33 

    34 	// Holder for images

    35 	private Vector images;

    36 

    37 	// holder for rgbData

    38 	private Vector rgbData;

    39 

    40 	// This flag is indicates if this buffer is bound by some GraphicsContext

    41 	private boolean bound;

    42 

    43     // This flag indicates if this buffer is empty or not

    44 	private boolean containsData;

    45 

    46     // Memory management configuration constants

    47 	private static final int INT_BUF_GRANULARITY     	 = 10;

    48 	private static final int INT_BUF_INITIAL_SIZE    	 = 250;

    49 	private static final int IMAGE_BUF_INITIAL_SIZE 	 = 3;

    50 	private static final int IMAGE_BUF_GRANULARITY  	 = 2;

    51 	private static final int STRING_BUFFER_INITIAL_SIZE = 10;

    52 

    53 	// Prefixes for different categories of op codes, stored in MSB

    54 	final static int DRAW_PREFIX = 0;

    55 	final static int FILL_PREFIX = 1;

    56 	final static int SET_PREFIX = 2;

    57 	final static int MISC_PREFIX = 3;

    58 

    59 	// Unique operation codes for all the gc operations that can be buffered.

    60 	static final int OP_DRAWARC            = ((DRAW_PREFIX << 24) | 1);

    61 	static final int OP_DRAWFOCUS          = ((DRAW_PREFIX << 24) | 2);

    62 	static final int OP_DRAWIMAGE1         = ((DRAW_PREFIX << 24) | 3);

    63 	static final int OP_DRAWIMAGE2         = ((DRAW_PREFIX << 24) | 4);

    64 	static final int OP_DRAWLINE           = ((DRAW_PREFIX << 24) | 5);

    65 	static final int OP_DRAWELLIPSE        = ((DRAW_PREFIX << 24) | 6);

    66 	static final int OP_DRAWPOINT          = ((DRAW_PREFIX << 24) | 7);

    67 	static final int OP_DRAWPOLYGON        = ((DRAW_PREFIX << 24) | 8);

    68 	static final int OP_DRAWPOLYLINE       = ((DRAW_PREFIX << 24) | 9);

    69 	static final int OP_DRAWRECT           = ((DRAW_PREFIX << 24) | 10);

    70 	static final int OP_DRAWRGB_INT        = ((DRAW_PREFIX << 24) | 11);

    71 	static final int OP_DRAWRGB_BYTE       = ((DRAW_PREFIX << 24) | 12);

    72 	static final int OP_DRAWRGB_SHORT      = ((DRAW_PREFIX << 24) | 13);

    73 	static final int OP_DRAWROUNDRECT      = ((DRAW_PREFIX << 24) | 14);

    74 	static final int OP_DRAWSTRING         = ((DRAW_PREFIX << 24) | 15);

    75 	static final int OP_FILLARC            = ((FILL_PREFIX << 24) | 16);

    76 	static final int OP_FILLGRADIENTRECT   = ((FILL_PREFIX << 24) | 17);

    77 	static final int OP_FILLELLIPSE        = ((FILL_PREFIX << 24) | 18);

    78 	static final int OP_FILLPOLYGON        = ((FILL_PREFIX << 24) | 19);

    79 	static final int OP_FILLRECT           = ((FILL_PREFIX << 24) | 20);

    80 	static final int OP_FILLROUNDRECT      = ((FILL_PREFIX << 24) | 21);

    81 	static final int OP_SETBACKGROUNDALPHA = ((SET_PREFIX << 24) | 22);

    82 	static final int OP_SETBACKGROUNDCOLOR = ((SET_PREFIX << 24) | 23);

    83 	static final int OP_SETBLENDINGMODE    = ((SET_PREFIX << 24) | 24);

    84 	static final int OP_SETCLIP            = ((SET_PREFIX << 24) | 25);

    85 	static final int OP_CANCELCLIPPING     = ((SET_PREFIX << 24) | 26);

    86 	static final int OP_SETFONT            = ((SET_PREFIX << 24) | 27);

    87 	static final int OP_SETFOREGROUNDALPHA = ((SET_PREFIX << 24) | 28);

    88 	static final int OP_SETFOREGROUNDCOLOR = ((SET_PREFIX << 24) | 29);

    89 	static final int OP_SETSTROKESTYLE     = ((SET_PREFIX << 24) | 30);

    90 	static final int OP_SETSTROKEWIDTH     = ((SET_PREFIX << 24) | 31);

    91 	static final int OP_TRANSLATE          = ((MISC_PREFIX << 24) | 32);

    92 	static final int OP_SCALE              = ((MISC_PREFIX << 24) | 33);

    93 	static final int OP_RESETTRANSFORM     = ((MISC_PREFIX << 24) | 34);

    94 	static final int OP_COPYAREA1          = ((MISC_PREFIX << 24) | 35);

    95 	static final int OP_COPYAREA2          = ((MISC_PREFIX << 24) | 36);

    96 

    97 	/**

    98 	 * Constructs empty command buffer with defined buffer sizes.

    99 	 */

   100 	public JavaCommandBuffer() {

   101 		intParams = new int[INT_BUF_INITIAL_SIZE];

   102 		strParams = new StringBuffer(STRING_BUFFER_INITIAL_SIZE);

   103 		images = new Vector(IMAGE_BUF_INITIAL_SIZE, IMAGE_BUF_GRANULARITY);

   104 		rgbData = new Vector(IMAGE_BUF_INITIAL_SIZE, IMAGE_BUF_GRANULARITY);

   105 	}

   106 

   107 	/**

   108 	 * Resets the buffer, i.e. removes all recorded commands and related data. The integer array containing

   109 	 * the actual operation codes is not deleted, only the index pointer is rested, thus the memory consumption of that is not freed.

   110 	 * CommandBuffer can be reseted only if it is not bound by any GraphicsContext

   111 	 * @throws IllegalStateException if this CommandBuffer is bound while calling reset

   112 	 */

   113 	public void reset() {

   114 		if(bound) {

   115 			throw new IllegalStateException("CommandBuffer is still bound by gc");

   116 		}

   117 		intCount = 0;

   118 		strParams.setLength(0);

   119 

   120 		Enumeration allImages = images.elements();

   121 		while(allImages.hasMoreElements()) {

   122 			Image image = (Image)allImages.nextElement();

   123 			if(!image.isDisposed()) {

   124 				image.dispose();

   125 			}

   126 		}

   127 		images.removeAllElements();

   128 		rgbData.removeAllElements();

   129 		containsData = false;

   130 	}

   131 

   132 	/**

   133 	 * Binds this buffer

   134 	 */

   135 	void bind() {

   136 		bound = true;

   137 	}

   138 

   139 	/**

   140 	 * Checks that does this buffer contain any commands

   141 	 * @return

   142 	 */

   143 	boolean containsData() {

   144 		return containsData;

   145 	}

   146 

   147 	/**

   148 	 * Provides the binding status of this buffer

   149 	 * @return true if this buffer has been already bound otherwise false

   150 	 */

   151 	boolean isBound() {

   152 		return bound;

   153 	}

   154 

   155 	/**

   156 	 * Releases this buffer, i.e. it can be bound by some other GraphicsContext

   157 	 */

   158 	void release() {

   159 		bound = false;

   160 	}

   161 

   162 	/**

   163 	 * Writes an integer to given array.

   164 	 * @param item The item to be added to the array

   165 	 * @param array The array where to append given item

   166 	 * @param elementsUsed The size of slots used in given array

   167 	 * @param granularity The granularity used if the array needs to be enlarged

   168 	 * @return Array containing the added item

   169 	 */

   170 	private int[] writeToArray(int item, int[] array, int elementsUsed, int granularity) {

   171 		if( array.length < elementsUsed + 1) {

   172 			int[] src = array;

   173 			int[] dst = new int[array.length + granularity];

   174 			System.arraycopy(src, 0, dst, 0, src.length);

   175 			array = dst;

   176 		}

   177 		array[elementsUsed] = item;

   178 		return array;

   179 	}

   180 

   181 	private void writeInt(int param) {

   182 		intParams = writeToArray(param, intParams, intCount++, INT_BUF_GRANULARITY);

   183 		containsData = true;

   184 	}

   185 

   186 	private void writeImage(Image image) {

   187 		images.addElement(image);

   188 	}

   189 

   190 	private void writeStr(String string) {

   191     	strParams.append(string);

   192 	}

   193 

   194 	private void writeRgb(int[] rgb) {

   195 		rgbData.addElement(rgb);

   196 	}

   197 	private void writeRgb(byte[] rgb) {

   198 		rgbData.addElement(rgb);

   199 	}

   200 

   201 	private void writeRgb(short[] rgb) {

   202 		rgbData.addElement(rgb);

   203 	}

   204 

   205 	private void reportNotSupported() {

   206 		throw new RuntimeException("Intenal: Operation not supported with JavaCommandBuffer");

   207 	}

   208 

   209 	private void printBufferInfo() {

   210 		System.out.println("CommandBuffer Info: " +this);

   211 		System.out.println("intParamCount: " + intCount);

   212 		System.out.println("intBuffer Size: " + intParams.length);

   213 		System.out.println("StringBuffer Size: " + strParams.length());

   214 	}

   215 

   216 	int[] intParams() {

   217 		return intParams;

   218 	}

   219 

   220 	int intParamCount() {

   221         return intCount;

   222 	}

   223 

   224 	Vector rgbParams() {

   225 		return rgbData;

   226 	}

   227 

   228 	Vector images() {

   229 		return images;

   230 	}

   231 

   232 	String strParams() {

   233 		return strParams.toString();

   234 	}

   235 

   236 	void drawArc (int x, int y, int width, int height, int startAngle, int arcAngle) {

   237 		writeInt(OP_DRAWARC);

   238 		writeInt(x);

   239 		writeInt(y);

   240 		writeInt(width);

   241 		writeInt(height);

   242 		writeInt(startAngle);

   243 		writeInt(arcAngle);

   244 	}

   245 

   246 	void drawFocus (int x, int y, int width, int height) {

   247 		writeInt(OP_DRAWFOCUS);

   248 		writeInt(x);

   249 		writeInt(y);

   250 		writeInt(width);

   251 		writeInt(height);

   252 	}

   253 

   254 	// must be called from UI thread as images cannot be creates outside that

   255 	void drawImage(Image image, int x, int y) {

   256 		writeInt(OP_DRAWIMAGE1);

   257 		writeInt(x);

   258 		writeInt(y);

   259 		// creating copy of image here uses implicit data sharing,

   260 		// thus only a shallow copy is made

   261 		writeImage(new Image(image));

   262 	}

   263 

   264 	// must be called from UI thread as images cannot be creates outside that

   265 	void drawImage(Image image, int tx, int ty, int tw, int th,int sx, int sy, int sw, int sh, int manipulation) {

   266 		writeInt(OP_DRAWIMAGE2);

   267 		writeInt(tx);

   268 		writeInt(ty);

   269 		writeInt(tw);

   270 		writeInt(th);

   271 		writeInt(sx);

   272 		writeInt(sy);

   273 		writeInt(sw);

   274 		writeInt(sh);

   275 		writeInt(manipulation);

   276 		// creating copy of image here uses implicit data sharing,

   277 		// thus only a shallow copy is made

   278 		writeImage(new Image(image));

   279 	}

   280 

   281 	void drawLine (int x1, int y1, int x2, int y2) {

   282 		writeInt(OP_DRAWLINE);

   283 		writeInt(x1);

   284 		writeInt(y1);

   285 		writeInt(x2);

   286 		writeInt(y2);

   287 	}

   288 

   289 	void drawEllipse (int x, int y, int width, int height) {

   290 		writeInt(OP_DRAWELLIPSE);

   291 		writeInt(x);

   292 		writeInt(y);

   293 		writeInt(width);

   294 		writeInt(height);

   295 	}

   296 

   297 	void drawPoint (int x, int y) {

   298 		writeInt(OP_DRAWPOINT);

   299 		writeInt(x);

   300 		writeInt(y);

   301 	}

   302 

   303 	void drawPolygon(int[] pointArray) {

   304 		writeInt(OP_DRAWPOLYGON);

   305 		writeInt(pointArray.length);

   306 		for(int i = 0; i < pointArray.length; ++i) {

   307 			writeInt(pointArray[i]);

   308 		}

   309 	}

   310 

   311 	void drawPolyline(int[] pointArray) {

   312 		writeInt(OP_DRAWPOLYLINE);

   313 		writeInt(pointArray.length);

   314 		for(int i = 0; i < pointArray.length; ++i) {

   315 			writeInt(pointArray[i]);

   316 		}

   317 	}

   318 

   319 	void drawRect (int x, int y, int width, int height) {

   320 		writeInt(OP_DRAWRECT);

   321 		writeInt(x);

   322 		writeInt(y);

   323 		writeInt(width);

   324 		writeInt(height);

   325 	}

   326 

   327 	void drawRGB(int[] rgbData, int offset, int scanlength, int x, int y, int width, int height, boolean processAlpha, int manipulation) {

   328 		writeInt(OP_DRAWRGB_INT);

   329 		writeInt(offset);

   330 		writeInt(scanlength);

   331 		writeInt(x);

   332 		writeInt(y);

   333 		writeInt(width);

   334 		writeInt(height);

   335 		writeInt(processAlpha? 1 : 0);

   336 		writeInt(manipulation);

   337 		writeRgb(rgbData);

   338 	}

   339 

   340 	void drawRGB(byte[] rgbData, byte[] transparencyMask,int offset, int scanlength, int x, int y, int width, int height, int manipulation, int format) {

   341 		writeInt(OP_DRAWRGB_BYTE);

   342 		writeInt(offset);

   343 		writeInt(scanlength);

   344 		writeInt(x);

   345 		writeInt(y);

   346 		writeInt(width);

   347 		writeInt(height);

   348 		writeInt(manipulation);

   349 		writeInt(format);

   350 		writeRgb(rgbData);

   351 		writeRgb(transparencyMask);

   352 	}

   353 

   354 	void drawRGB(short[] rgbData, int offset, int scanlength, int x, int y, int width, int height, boolean processAlpha, int manipulation, int format) {

   355 		writeInt(OP_DRAWRGB_SHORT);

   356 		writeInt(offset);

   357 		writeInt(scanlength);

   358 		writeInt(x);

   359 		writeInt(y);

   360 		writeInt(width);

   361 		writeInt(height);

   362 		writeInt(processAlpha? 1 : 0);

   363 		writeInt(manipulation);

   364 		writeInt(format);

   365 		writeRgb(rgbData);

   366 	}

   367 

   368 	void drawRoundRect (int x, int y, int width, int height, int arcWidth, int arcHeight) {

   369 		writeInt(OP_DRAWROUNDRECT);

   370 		writeInt(x);

   371 		writeInt(y);

   372 		writeInt(width);

   373 		writeInt(height);

   374 		writeInt(arcWidth);

   375 		writeInt(arcHeight);

   376 	}

   377 

   378 	void drawString(String string, int x, int y, int width, int height, int alignments, int flags, boolean isTransparent) {

   379 		writeInt(OP_DRAWSTRING);

   380 		writeStr(string);

   381 		writeInt(string.length());

   382 		writeInt(x);

   383 		writeInt(y);

   384 		writeInt(width);

   385 		writeInt(height);

   386 		writeInt(alignments);

   387 		writeInt(flags);

   388 		writeInt(isTransparent? 1 : 0);

   389 	}

   390 

   391 	void fillArc (int x, int y, int width, int height, int startAngle, int arcAngle) {

   392 		writeInt(OP_FILLARC);

   393 		writeInt(x);

   394 		writeInt(y);

   395 		writeInt(width);

   396 		writeInt(height);

   397 		writeInt(startAngle);

   398 		writeInt(arcAngle);

   399 	}

   400 

   401 	void fillGradientRect(int x, int y, int width, int height, boolean vertical, boolean swapColors) {

   402 		writeInt(OP_FILLGRADIENTRECT);

   403 		writeInt(x);

   404 		writeInt(y);

   405 		writeInt(width);

   406 		writeInt(height);

   407 		writeInt(vertical ? 1 : 0);

   408 		writeInt(swapColors ? 1 : 0);

   409 	}

   410 

   411 	void fillEllipse (int x, int y, int width, int height) {

   412 		writeInt(OP_FILLELLIPSE);

   413 		writeInt(x);

   414 		writeInt(y);

   415 		writeInt(width);

   416 		writeInt(height);

   417 	}

   418 

   419 	void fillPolygon (int[] pointArray) {

   420 		writeInt(OP_FILLPOLYGON);

   421 		writeInt(pointArray.length);

   422 		for(int i = 0; i < pointArray.length; ++i) {

   423 			writeInt(pointArray[i]);

   424 		}

   425 	}

   426 

   427 	void fillRect (int x, int y, int width, int height) {

   428 		writeInt(OP_FILLRECT);

   429 		writeInt(x);

   430 		writeInt(y);

   431 		writeInt(width);

   432 		writeInt(height);

   433 	}

   434 

   435 	void fillRoundRectangle (int x, int y, int width, int height, int arcWidth, int arcHeight) {

   436 		writeInt(OP_FILLROUNDRECT);

   437 		writeInt(x);

   438 		writeInt(y);

   439 		writeInt(width);

   440 		writeInt(height);

   441 		writeInt(arcWidth);

   442 		writeInt(arcHeight);

   443 	}

   444 

   445 	public void setBackgroundAlpha(int alpha) {

   446 		writeInt(OP_SETBACKGROUNDALPHA);

   447 		writeInt(alpha);

   448 	}

   449 

   450 	void setBackgroundColor(int argb, boolean updateAlpha) {

   451 		writeInt(OP_SETBACKGROUNDCOLOR);

   452 		writeInt(argb);

   453 		writeInt(updateAlpha? 1 : 0);

   454 	}

   455 

   456 	void setBlendingMode(int mode) {

   457 		writeInt(OP_SETBLENDINGMODE);

   458 		writeInt(mode);

   459 	}

   460 

   461 	void setClip(int x, int y, int width, int height, boolean intersects) {

   462 		writeInt(OP_SETCLIP);

   463 		writeInt(x);

   464 		writeInt(y);

   465 		writeInt(width);

   466 		writeInt(height);

   467 		writeInt(intersects? 1 : 0 );

   468 	}

   469 

   470 	void cancelClipping () {

   471 		writeInt(OP_CANCELCLIPPING);

   472 	}

   473 

   474 	void setFont(int fontHandle) {

   475 		writeInt(OP_SETFONT);

   476 		writeInt(fontHandle);

   477 	}

   478 

   479 	void setForegroundAlpha(int alpha) {

   480 		writeInt(OP_SETFOREGROUNDALPHA);

   481 		writeInt(alpha);

   482 	}

   483 

   484 	void setForegroundColor(int argb, boolean updateAlpha) {

   485 		writeInt(OP_SETFOREGROUNDCOLOR);

   486 		writeInt(argb);

   487 		writeInt(updateAlpha? 1 : 0);

   488 	}

   489 

   490 	void setStrokeStyle(int style) {

   491 		writeInt(OP_SETSTROKESTYLE);

   492 		writeInt(style);

   493 	}

   494 

   495 	void setStrokeWidth(int width) {

   496 		writeInt(OP_SETSTROKEWIDTH);

   497 		writeInt(width);

   498 	}

   499 

   500 	void translate(int x, int y) {

   501 		writeInt(OP_TRANSLATE);

   502 		writeInt(x);

   503 		writeInt(y);

   504 	}

   505 

   506 	void scale(int x, int y) {

   507 		writeInt(OP_SCALE);

   508 		writeInt(x);

   509 		writeInt(y);

   510 	}

   511 

   512 	void resetTransform() {

   513 		writeInt(OP_RESETTRANSFORM);

   514 	}

   515 

   516 	void copyArea(Image image, int x, int y) {

   517 		writeInt(OP_COPYAREA1);

   518         writeInt(x);

   519         writeInt(y);

   520         // TODO does this need flushing on the image

   521         images.addElement(new Image(image));

   522     }

   523 

   524 	void copyArea(int srcX, int srcY, int width, int height, int destX, int destY, boolean paint) {

   525         writeInt(OP_COPYAREA2);

   526         writeInt(srcX);

   527         writeInt(srcY);

   528         writeInt(width);

   529         writeInt(height);

   530         writeInt(destX);

   531         writeInt(destY);

   532         writeInt(paint? 1 : 0);

   533     }

   534 

   535 	// Unsupported operations

   536 	int getAdvancedCharacterWidth(char ch, boolean isAdvanced) {

   537 		reportNotSupported();

   538 		return 0;

   539 	}

   540 

   541 	void getFontMetricsData(int[] data, int fontHandle) {

   542 		reportNotSupported();

   543 	}

   544 

   545 	int getBackgroundAlpha() {

   546 		reportNotSupported();

   547 		return 0;

   548 	}

   549 

   550 	int getBackgroundColor() {

   551 		reportNotSupported();

   552 		return 0;

   553 	}

   554 

   555 	int getBlendingMode() {

   556 		reportNotSupported();

   557 		return 0;

   558 	}

   559 

   560 	void getClip(int[] clip) {

   561 		reportNotSupported();

   562 	}

   563 

   564 	int getForegroundAlpha() {

   565 		reportNotSupported();

   566 		return 0;

   567 	}

   568 

   569 	int getForegroundColor() {

   570 		reportNotSupported();

   571 		return 0;

   572 	}

   573 

   574 	void getTextBoundingBox(int[] boundingBox, String string, int alignments, int flags, int rectX, int rectY, int rectWidth, int rectHeight) {

   575 		reportNotSupported();

   576 	}

   577 

   578 	int getStrokeWidth() {

   579 		reportNotSupported();

   580 		return 0;

   581 	}

   582 

   583 	int getStrokeStyle() {

   584 		reportNotSupported();

   585 		return 0;

   586 	}

   587 

   588 	int getTranslateX() {

   589 		reportNotSupported();

   590 		return 0;

   591 	}

   592 

   593 	int getTranslateY() {

   594 		reportNotSupported();

   595 		return 0;

   596 	}

   597 

   598 	boolean hasClipping() {

   599 		reportNotSupported();

   600 		return false;

   601 	}

   602 

   603 	void saveSettings() {

   604 		reportNotSupported();

   605 	}

   606 

   607 	void restoreSettings() {

   608 		reportNotSupported();

   609 	}

   610 

   611 

   612 

   613 }