Lines Matching +defs:pixel +defs:height
5 * full color (32 bits per pixel including alpha channel) and displayed
53 * An unsigned 32-bit integral type, used for pixel values. We use int rather
57 typedef unsigned int pixel;
74 * in which they were allocated. Sets of pixel values allocated for displaying
77 * these sets of pixel values, using the following data structure as key:
90 * structure of the following type is used to store the allocated pixel values
106 pixel redValues[256]; /* Maps 8-bit values of red intensity to a
107 * pixel value or index in pixelMap. */
108 pixel greenValues[256]; /* Ditto for green intensity. */
109 pixel blueValues[256]; /* Ditto for blue intensity. */
110 unsigned long *pixelMap; /* Actual pixel values allocated. */
127 * MAP_COLORS: 1 means pixel values should be mapped through
153 int width, height; /* Dimensions of image. */
164 * pixel in image. */
216 int width, height; /* Dimensions of the pixmap. */
311 int imageX, int imageY, int width, int height,
318 int height, int prepass);
365 {TK_CONFIG_INT, "-height", NULL, NULL,
411 int width, int height);
413 int height);
423 static int CountBits(pixel mask);
440 int y, int width, int height);
657 int result, index, x, y, width, height, dataWidth, dataHeight, listObjc;
819 if ((options.fromX2 > block.width) || (options.fromY2 > block.height)
821 || (options.fromY2 > block.height)) {
842 options.fromY2 = block.height;
855 height = options.fromY2 - options.fromY;
857 height = (height + options.subsampleY - 1)
860 height = 0;
862 height = (height - options.subsampleY - 1)
865 options.toY2 = options.toY + height * options.zoomY;
888 block.height = options.fromY2 - options.fromY;
920 || (options.fromY > masterPtr->height)
922 || (options.fromY2 > masterPtr->height)) {
934 options.fromY2 = masterPtr->height;
1030 || (y < 0) || (y >= masterPtr->height)) {
1037 * Extract the value of the desired pixel and format it as a string.
1203 block.height = dataHeight;
1289 height = imageHeight - options.fromY;
1292 height = options.fromY2 - options.fromY;
1301 options.toY + height) != TCL_OK) {
1320 options.toY, width, height, options.fromX, options.fromY);
1344 if (masterPtr->ditherY < masterPtr->height) {
1348 masterPtr->height - masterPtr->ditherY);
1351 if (y < masterPtr->height) {
1357 (masterPtr->width - x), (masterPtr->height - y),
1358 masterPtr->width, masterPtr->height);
1393 || (y < 0) || (y >= masterPtr->height)) {
1402 testBox.height = 1;
1411 (testBox.width==0 && testBox.height==0));
1430 || (y < 0) || (y >= masterPtr->height)) {
1439 setBox.height = 1;
1444 * Make pixel transparent.
1461 * Make pixel opaque.
1475 masterPtr->width, masterPtr->height);
1516 || (options.fromY > masterPtr->height)
1518 || (options.fromY2 > masterPtr->height)) {
1530 options.fromY2 = masterPtr->height;
2026 masterPtr->height) != TCL_OK) {
2153 masterPtr->height, masterPtr->width, masterPtr->height);
2284 * If the user has specified a width and/or height for the master which is
2285 * different from our current width/height, set the size to the values
2292 || (instancePtr->height != masterPtr->height)) {
2303 if ((validBox.width > 0) && (validBox.height > 0)) {
2305 validBox.width, validBox.height);
2347 * between 3 and 15 bits/pixel.
2412 instancePtr->height = 0;
2473 gcValues.foreground = (white != NULL)? white->pixel:
2475 gcValues.background = (black != NULL)? black->pixel:
2496 masterPtr->width, masterPtr->height);
2526 MAX(mPtr->userHeight, mPtr->height) * 4;
2597 int width, int height) /* Width & height of image to draw. */
2600 unsigned long pixel;
2658 for (y = 0; y < height; y++) {
2684 pixel = XGetPixel(bgImg, x, y);
2685 ra = GetRValue(pixel) << red_mlen;
2686 ga = GetGValue(pixel) << green_mlen;
2687 ba = GetBValue(pixel) << blue_mlen;
2701 for (y = 0; y < height; y++) {
2727 pixel = XGetPixel(bgImg, x, y);
2728 ra = GetRValue(pixel);
2729 ga = GetGValue(pixel);
2730 ba = GetBValue(pixel);
2768 int width, int height, /* Dimensions of region within image to
2804 (unsigned int)width, (unsigned int)height, AllPlanes, ZPixmap);
2811 height);
2820 (unsigned int) width, (unsigned int) height);
2835 imageX, imageY, (unsigned) width, (unsigned) height,
2984 * `height' pixels.
2999 int width, int height)
3012 height = masterPtr->userHeight;
3022 if ((width != masterPtr->width) || (height != masterPtr->height)
3028 unsigned /*long*/ newPixSize = (unsigned /*long*/) (height * pitch);
3051 || (validBox.y + validBox.height > height)) {
3055 clipBox.height = height;
3082 h = validBox.y + validBox.height;
3083 if (h < height) {
3084 memset(newPix32 + h*pitch, 0, (size_t) ((height - h) * pitch));
3087 memset(newPix32, 0, (size_t) (height * pitch));
3104 (size_t) (validBox.height * pitch));
3106 } else if ((validBox.width > 0) && (validBox.height > 0)) {
3114 for (h = validBox.height; h > 0; h--) {
3126 masterPtr->height = height;
3137 if ((int) validBox.height < masterPtr->ditherY) {
3139 masterPtr->ditherY = validBox.height;
3170 * to `width' x `height' pixels.
3195 || (instancePtr->height != masterPtr->height)
3201 (masterPtr->height > 0) ? masterPtr->height: 1,
3225 validBox.width, validBox.height, validBox.x, validBox.y);
3232 || (instancePtr->height != masterPtr->height)
3235 if (masterPtr->height > 0 && masterPtr->width > 0) {
3237 masterPtr->height * masterPtr->width * 3 * sizeof(schar));
3251 h = validBox.y + validBox.height;
3252 if (h < masterPtr->height) {
3254 (size_t) (masterPtr->height - h)
3259 masterPtr->height * masterPtr->width *3*sizeof(schar));
3274 (size_t) (validBox.height
3277 } else if (validBox.width > 0 && validBox.height > 0) {
3283 for (h = validBox.height; h > 0; --h) {
3297 instancePtr->height = masterPtr->height;
3405 pixel mask) /* Value to count the 1 bits in. */
3612 * If we are using 1 bit/pixel, we don't need to allocate any colors
3722 pixels[i] = colors[i].pixel;
3804 colorPtr->redValues[i] = colors[r].pixel;
3811 colors[r].pixel & colorPtr->visualInfo.red_mask;
3813 colors[g].pixel & colorPtr->visualInfo.green_mask;
3815 colors[b].pixel & colorPtr->visualInfo.blue_mask;
4046 * width and height of the image are returned in *widthPtr and
4177 * width and height of the image are returned in *widthPtr and
4341 /* Pointer to a structure describing the pixel
4343 int x, int y, /* Coordinates of the top-left pixel to be
4345 int width, int height, /* Dimensions of the area of the image to be
4364 && ((y + height) > masterPtr->userHeight)) {
4365 height = masterPtr->userHeight - y;
4367 if ((width <= 0) || (height <= 0)) {
4372 yEnd = y + height;
4373 if ((xEnd > masterPtr->width) || (yEnd > masterPtr->height)) {
4377 MAX(yEnd, masterPtr->height)) == TCL_ERROR) {
4419 * Copy the data into our local 32-bit/pixel array. If we can do it with a
4434 && (width <= blockPtr->width) && (height <= blockPtr->height)
4435 && ((height == 1) || ((x == 0) && (width == masterPtr->width)
4439 (size_t) (height * width * 4));
4453 for (hLeft = height; hLeft > 0;) {
4458 hCopy = MIN(hLeft, blockPtr->height);
4524 * Bother; need to consider the alpha value of each pixel to
4594 * drawing time, for each transparent pixel, set its color to the
4595 * color of the background behind that pixel. This is what I suspect
4598 * Determining the correct bg color for a given pixel might be
4615 rect.height = height;
4628 (unsigned) y, (unsigned) width, (unsigned) height,
4635 rect.height = height;
4644 if (!sourceIsSimplePhoto && (width == 1) && (height == 1)) {
4646 * Optimize the single pixel case if we can. This speeds up code that
4676 Tk_DitherPhoto((Tk_PhotoHandle)masterPtr, x, y, width, height);
4682 Tk_ImageChanged(masterPtr->tkMaster, x, y, width, height,
4683 masterPtr->width, masterPtr->height);
4713 /* Pointer to a structure describing the pixel
4715 int x, int y, /* Coordinates of the top-left pixel to be
4717 int width, int height, /* Dimensions of the area of the image to be
4734 return Tk_PhotoPutBlock(interp, handle, blockPtr, x, y, width, height,
4748 && ((y + height) > masterPtr->userHeight)) {
4749 height = masterPtr->userHeight - y;
4751 if (width <= 0 || height <= 0) {
4756 yEnd = y + height;
4757 if ((xEnd > masterPtr->width) || (yEnd > masterPtr->height)) {
4760 MAX(yEnd, masterPtr->height)) == TCL_ERROR) {
4802 * Work out what area the pixel data in the block expands to after
4816 blockHt = ((blockPtr->height + subsampleY - 1) / subsampleY) * zoomY;
4818 blockHt = height;
4820 blockHt = ((blockPtr->height - subsampleY - 1) / -subsampleY) * zoomY;
4824 * Copy the data into our local 32-bit/pixel array.
4833 srcOrigPtr += (blockPtr->height - 1) * blockPtr->pitch;
4837 for (hLeft = height; hLeft > 0; ) {
4921 rect.height = 1;
4929 (unsigned)x, (unsigned)y, (unsigned)width, (unsigned)height,
4936 rect.height = height;
4945 if (!sourceIsSimplePhoto && (width == 1) && (height == 1)) {
4947 * Optimize the single pixel case if we can. This speeds up code that
4975 Tk_DitherPhoto((Tk_PhotoHandle) masterPtr, x, y, width, height);
4981 Tk_ImageChanged(masterPtr->tkMaster, x, y, width, height, masterPtr->width,
4982 masterPtr->height);
5010 int x, int y, /* Coordinates of the top-left pixel in the
5012 int width, int height) /* Dimensions of the area to be dithered. */
5017 if ((width <= 0) || (height <= 0)) {
5023 DitherInstance(instancePtr, x, y, width, height);
5033 && ((y + height) > (masterPtr->ditherY))) {
5047 masterPtr->ditherY = y + height;
5087 int xStart, int yStart, /* Coordinates of the top-left pixel in the
5089 int width, int height) /* Dimensions of the block to be dithered. */
5098 pixel firstBit, word, mask;
5119 * we'll need for pixel storage, and allocate it.
5126 if (nLines > height ) {
5127 nLines = height;
5137 imagePtr->height = nLines;
5154 for (; height > 0; height -= nLines) {
5158 if (nLines > height) {
5159 nLines = height;
5166 pixel *destLongPtr = (pixel *) dstLinePtr;
5182 * Compute the error propagated into this pixel
5234 * pixel value, and store it in the image.
5250 * image format is different from the pixel format in
5257 case NBBY * sizeof(pixel):
5312 * image format is different from the pixel format in
5319 case NBBY * sizeof(pixel):
5444 * Clear out the 32-bit pixel storage array. Clear out the dithering error
5449 (size_t) (masterPtr->width * masterPtr->height * 4));
5454 (size_t) (masterPtr->width * masterPtr->height
5464 masterPtr->height, masterPtr->width, masterPtr->height);
5474 * necessary to be at least `width' pixels wide and `height' pixels high.
5476 * -height configuration options) then this call has no effect.
5493 int width, int height) /* Desired minimum dimensions of the image. */
5500 if (height <= masterPtr->height) {
5501 height = masterPtr->height;
5503 if ((width != masterPtr->width) || (height != masterPtr->height)) {
5505 MAX(height, masterPtr->height)) == TCL_ERROR) {
5513 masterPtr->height);
5527 * The image's width and height are returned in *widthp and *heightp.
5546 *heightPtr = masterPtr->height;
5556 * equivalent to using the -width and -height configuration options.
5574 int width, int height) /* New dimensions for the image. */
5579 masterPtr->userHeight = height;
5581 ((height > 0) ? height: masterPtr->height)) == TCL_ERROR) {
5589 masterPtr->width, masterPtr->height);
5662 blockPtr->height = optPtr->fromY2 - optPtr->fromY;
5671 for (y = 0; y < blockPtr->height; y++) {
5705 blockPtr->width * blockPtr->height));
5709 for (y = blockPtr->height; y > 0; y--) {
5719 for (y = blockPtr->height; y > 0; y--) {
5730 for (y = blockPtr->height; y > 0; y--) {
5754 for (y = blockPtr->height; y > 0; y--) {
5773 for (y = blockPtr->height; y > 0; y--) {
5786 for (y = blockPtr->height; y > 0; y--) {
5846 if ((blockPtr->width > 0) && (blockPtr->height > 0)) {
5848 for (row=0; row<blockPtr->height; row++) {
5899 blockPtr->height = masterPtr->height;
6080 int x, int y, /* First pixel to output. */
6081 int width, int height, /* Width and height of area. */
6089 return Tk_PostscriptPhoto(interp, &block, psInfo, width, height);
6111 int x, int y, int width, int height)
6113 if (Tk_PhotoPutBlock(NULL, handle, blockPtr, x, y, width, height,
6123 int x, int y, int width, int height,
6126 if (Tk_PhotoPutZoomedBlock(NULL, handle, blockPtr, x, y, width, height,
6152 int width, int height)
6154 if (Tk_PhotoExpand(NULL, handle, width, height) != TCL_OK) {
6163 int x, int y, int width, int height, int compRule)
6165 if (Tk_PhotoPutBlock(NULL, handle, blockPtr, x, y, width, height,
6174 int x, int y, int width, int height,
6178 if (Tk_PhotoPutZoomedBlock(NULL, handle, blockPtr, x, y, width, height,
6187 int width, int height)
6189 if (Tk_PhotoSetSize(NULL, handle, width, height) != TCL_OK) {