/*

 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* $XConsortium: multiVis.c /main/4 1996/10/14 15:04:08 swick $ */

/** ------------------------------------------------------------------------

        This file contains functions to create a list of regions which

        tile a specified window.  Each region contains all visible

        portions of the window which are drawn with the same visual.

        If the window consists of subwindows of two different visual types,

        there will be two regions in the list.  The list can be traversed

        to correctly pull an image of the window using XGetImage or the

        Image Library.

 This file is available under and governed by the GNU General Public

 License version 2 only, as published by the Free Software Foundation.

 However, the following notice accompanied the original version of this

 file:

Copyright (c) 1994 Hewlett-Packard Co.

Copyright (c) 1996  X Consortium

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the

"Software"), to deal in the Software without restriction, including

without limitation the rights to use, copy, modify, merge, publish,

distribute, sublicense, and sell copies of the Software, and to

permit persons to whom the Software is furnished to do so, subject to

the following conditions:

The above copyright notice and this permission notice shall be included

in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR

OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of the X Consortium shall

not be used in advertising or otherwise to promote the sale, use or

other dealings in this Software without prior written authorization

from the X Consortium.

    ------------------------------------------------------------------------ **/

#include <stdlib.h>

#include <X11/Xlib.h>

#include <X11/Xutil.h>

#include <X11/X.h>

#include <stdio.h>

#include "list.h"

#include "wsutils.h"

#include "multiVis.h"

#include "robot_common.h"

static char *vis_class_str[] = { "StaticGray" , "GrayScale" , "StaticColor",

                                 "PseudoColor","TrueColor","DirectColor" } ;

/* These structures are copied from X11/region.h.  For some reason

 * they're invisible from the outside.*/

typedef struct {

    short x1, x2, y1, y2;

} myBox, myBOX, myBoxRec, *myBoxPtr;

typedef struct my_XRegion {    /* 64-bit: Region is supposed to be opaque    */

    long size;                 /* but it is defined here anyway.  I'm going  */

    long numRects;             /* to leave those longs alone.                */

    myBOX *rects;

    myBOX extents;

} myREGION;

/* Items in long list of windows that have some part in the grabbed area */

typedef struct {

    Window win;

    Visual *vis;

    Colormap cmap;

    int32_t x_rootrel, y_rootrel;       /* root relative location of window */

    int32_t x_vis, y_vis;               /* rt rel x,y of vis part, not parent clipped */

    int32_t width, height;              /* width and height of visible part */

    int32_t border_width;               /* border width of the window */

    Window parent;              /* id of parent (for debugging) */

} image_win_type;

/*  Items in short list of regions that tile the grabbed area.  May have

    multiple windows in the region.

*/

typedef struct {

    Window win;                 /* lowest window of this visual */

    Visual *vis;

    Colormap cmap;

    int32_t x_rootrel, y_rootrel;       /* root relative location of bottom window */

    int32_t x_vis, y_vis;               /* rt rel x,y of vis part, not parent clipped */

    int32_t width, height;              /* w & h of visible rect of bottom window */

    int32_t border;                     /* border width of the window */

    Region visible_region;

} image_region_type;

/** ------------------------------------------------------------------------

        Returns TRUE if the two structs pointed to have the same "vis" &

        "cmap" fields and s2 lies completely within s1.  s1 and s2 can

        point to structs of image_win_type or image_region_type.

    ------------------------------------------------------------------------ **/

#define SAME_REGIONS( s1, s2)   \

        ((s1)->vis == (s2)->vis && (s1)->cmap == (s2)->cmap &&          \

         (s1)->x_vis <= (s2)->x_vis &&                              \

         (s1)->y_vis <= (s2)->y_vis &&                              \

         (s1)->x_vis + (s1)->width  >= (s2)->x_vis + (s2)->width && \

         (s1)->y_vis + (s1)->height >= (s2)->y_vis + (s2)->height)

#ifndef MIN

#define MIN( a, b)      ((a) < (b) ? a : b)

#define MAX( a, b)      ((a) > (b) ? a : b)

#endif

#define RED_SHIFT        16

#define GREEN_SHIFT       8

#define BLUE_SHIFT        0

/*

extern list_ptr new_list();

extern list_ptr dup_list_head();

extern void *   first_in_list();

extern void *   next_in_list();

extern int32_t  add_to_list();

extern void     zero_list();

extern void     delete_list();

extern void     delete_list_destroying();

extern uint32_t list_length();

*/

/* Prototype Declarations for Static Functions */

static void TransferImage(

           Display *, XImage *,int32_t, int32_t , image_region_type*,

           XImage *,int32_t ,int32_t

           );

static XImage * ReadRegionsInList(

           Display *, Visual *, int32_t ,int32_t ,int32_t ,

           int32_t , XRectangle, list_ptr

           );

static list_ptr make_region_list(

                  Display*, Window, XRectangle*,

                  int32_t*, int32_t, XVisualInfo**, int32_t     *

         );

static void destroy_region_list(

            list_ptr

            ) ;

static void subtr_rect_from_image_region(

           image_region_type *, int32_t , int32_t , int32_t , int32_t

     );

static void add_rect_to_image_region(

           image_region_type *,

           int32_t , int32_t , int32_t , int32_t

     );

static int32_t src_in_region_list(

    image_win_type *, list_ptr

    );

static void add_window_to_list(

    list_ptr, Window, int32_t, int32_t ,

    int32_t     , int32_t , int32_t , int32_t, int32_t,

    Visual*, Colormap, Window

    );

static int32_t src_in_image(

    image_win_type      *, int32_t      , XVisualInfo**

    );

static int32_t src_in_overlay(

    image_region_type *, int32_t, OverlayInfo *, int32_t*, int32_t*

    );

/* End of Prototype Declarations */

{

    Vis->ext_data=NULL;

    Vis->class = DirectColor ;

    Vis->red_mask =   0x00FF0000;

    Vis->green_mask = 0x0000FF00 ;

    Vis->blue_mask  = 0x000000FF ;

    Vis->map_entries = 256 ;

    Vis->bits_per_rgb = 8 ;

}

/* QueryColorMap has been moved into robot_common.c so it can be used by

 * awt_DataTransferer.c as well.

 */

int32_t

{

    int32_t             hasNonDefault;

    XRectangle          bbox;           /* bounding box of grabbed area */

    /* Java uses 32-bit ints for coordinates, but XRectangles use 16-bit shorts.

     * Hope nobody passes in too big a coordinate */

    bbox.x = (short) x;                 /* init X rect for bounding box */

    bbox.y = (short) y;

    bbox.width = (unsigned short) width;

    bbox.height = (unsigned short) height;

    GetXVisualInfo(disp,DefaultScreen(disp),

                    transparentOverlays,

                    numVisuals, pVisuals,

                    numOverlayVisuals, pOverlayVisuals,

                    numImageVisuals, pImageVisuals);

    *vis_regions = *vis_image_regions = NULL ;

    if ((*vis_regions = make_region_list( disp, srcRootWinid, &bbox,

                                         &hasNonDefault, *numImageVisuals,

                                         *pImageVisuals, allImage)) == NULL)

        return 0 ;

    if (*transparentOverlays)

    {

        *allImage = 1; /* until proven otherwise,

                         this flags that it to be an image only list */

        *vis_image_regions =

                make_region_list( disp, srcRootWinid, &bbox, &hasNonDefault,

                                        *numImageVisuals, *pImageVisuals, allImage);

    }

    /* if there is a second region in any of the two lists return 1 **/

    if ( ( *vis_regions && (*vis_regions)->next && (*vis_regions)->next->next ) ||

         ( *vis_image_regions && (*vis_image_regions)->next &&

           (*vis_image_regions)->next->next ) ) return 1 ;

    else return 0 ;

}

{

    int32_t ncolors;

    int32_t i,j,old_pixel,new_pixel,red_ind,green_ind,blue_ind ;

    XColor *colors;

    int32_t rShift,gShift,bShift;

    int32_t targetBytesPerLine ;

    ncolors = QueryColorMap(disp,reg->cmap,reg->vis,&colors,

         &rShift,&gShift,&bShift) ;

    targetBytesPerLine = target_image->bytes_per_line;

    switch (reg->vis->class) {

    case TrueColor :

       for(i=0 ; i < srch ; i++)

       {

         for(j=0 ; j < srcw ;  j++)

         {

           old_pixel = (int32_t) XGetPixel(reg_image,j,i) ;

/* commented out since not using server RGB masks in all true color modes

 * causes the R and B values to be swapped around on some X servers

 *    - robi.khan@eng 9/7/1999

 *           if( reg->vis->map_entries == 16) {

 */

             red_ind   = (old_pixel & reg->vis->red_mask) >> rShift ;

                 green_ind = (old_pixel & reg->vis->green_mask) >> gShift ;

                 blue_ind  = (old_pixel & reg->vis->blue_mask) >> bShift ;

                 new_pixel = (

                              ((colors[red_ind].red >> 8) << RED_SHIFT)

                              |((colors[green_ind].green >> 8) << GREEN_SHIFT)

                              |((colors[blue_ind].blue >> 8) << BLUE_SHIFT)

                             );

/*         }

 *  else

 *    new_pixel = old_pixel;

 */

           XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);

         }

       }

       break;

    case DirectColor :

       for(i=0 ; i < srch ; i++)

       {

         for(j=0 ; j < srcw ;  j++)

         {

           old_pixel = (int32_t) XGetPixel(reg_image,j,i) ;

           red_ind   = (old_pixel & reg->vis->red_mask) >> rShift ;

               green_ind = (old_pixel & reg->vis->green_mask) >> gShift ;

               blue_ind  = (old_pixel & reg->vis->blue_mask) >> bShift ;

               new_pixel = (

                         ((colors[red_ind].red >> 8) << RED_SHIFT)

                        |((colors[green_ind].green >> 8) << GREEN_SHIFT)

                        |((colors[blue_ind].blue >> 8) << BLUE_SHIFT)

                       );

           XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);

         }

       }

       break;

    default :

       for(i=0 ; i < srch ; i++)

       {

         for(j=0 ; j < srcw ;  j++)

         {

               old_pixel = (int32_t) XGetPixel(reg_image,j,i) ;

               new_pixel = (

                         ((colors[old_pixel].red >> 8) << RED_SHIFT)

                        |((colors[old_pixel].green >> 8) << GREEN_SHIFT)

                        |((colors[old_pixel].blue >> 8) << BLUE_SHIFT)

                       );

           XPutPixel(target_image,dst_x+j, dst_y+i,new_pixel);

         }

       }

       break;

    }

    /* Fix memory leak by freeing colors

     *  - robi.khan@eng 9/22/1999

     */

    free(colors);

}

static XImage *

{

    XImage              *ximage ;

    image_region_type* reg;

    int32_t rect;

    ximage = XCreateImage(disp,fakeVis,(uint32_t) depth,format,0,NULL,

                          (uint32_t)width,(uint32_t)height,8,0);

    ximage->data = calloc(ximage->bytes_per_line*height*((format==ZPixmap)? 1 : depth), sizeof(char));

    ximage->bits_per_pixel = depth; /** Valid only if format is ZPixmap ***/

    for (reg = (image_region_type *) first_in_list( regions); reg;

         reg = (image_region_type *) next_in_list( regions))

    {

                struct my_XRegion *vis_reg = (struct my_XRegion *)(reg->visible_region);

                for (rect = 0; rect < vis_reg->numRects; rect++)

                {

                    /** ------------------------------------------------------------------------

                            Intersect bbox with visible part of region giving src rect & output

                            location.  Width is the min right side minus the max left side.

                            Similar for height.  Offset src rect so x,y are relative to

                            origin of win, not the root-relative visible rect of win.

                        ------------------------------------------------------------------------ **/

                        int32_t srcRect_width  = MIN( vis_reg->rects[rect].x2, bbox.width + bbox.x)

                                         - MAX( vis_reg->rects[rect].x1, bbox.x);

                        int32_t srcRect_height = MIN( vis_reg->rects[rect].y2, bbox.height + bbox.y)

                                         - MAX( vis_reg->rects[rect].y1, bbox.y);

                        int32_t diff = bbox.x - vis_reg->rects[rect].x1;

                        int32_t srcRect_x = MAX( 0, diff)  + (vis_reg->rects[rect].x1 - reg->x_rootrel - reg->border);

                        int32_t dst_x     = MAX( 0, -diff) ;

                        diff = bbox.y - vis_reg->rects[rect].y1;

                        int32_t srcRect_y = MAX( 0, diff)  + (vis_reg->rects[rect].y1 - reg->y_rootrel - reg->border);

                        int32_t dst_y     = MAX( 0, -diff) ;

                        XImage* reg_image = XGetImage(disp,reg->win,srcRect_x,srcRect_y,

                                            (uint32_t) srcRect_width, (uint32_t) srcRect_height,AllPlanes,format) ;

                        if (reg_image) {

                            TransferImage(disp,reg_image,srcRect_width,

                                            srcRect_height,reg,ximage,dst_x,dst_y) ;

                            XDestroyImage(reg_image);

                        }

                }

    }

    return ximage ;

}

/** ------------------------------------------------------------------------

    ------------------------------------------------------------------------ **/

{

    image_region_type   *reg;

    XRectangle          bbox;           /* bounding box of grabbed area */

    int32_t             depth ;

    XImage              *ximage, *ximage_ipm ;

    Visual              fakeVis ;

    int32_t     x1, y1;

    XImage      *image;

    unsigned char       *pmData ,  *ipmData ;

    int32_t                 transparentColor, transparentType;

    int32_t                     srcRect_x,srcRect_y,srcRect_width,srcRect_height ;

    int32_t                     diff ;

    int32_t                     dst_x, dst_y;   /* where in pixmap to write (UL) */

    int32_t                     pixel;

    bbox.x = (short) x;                 /* init X rect for bounding box */

    bbox.y = (short) y;

    bbox.width = (unsigned short) width;

    bbox.height = (unsigned short) height;

    ximage_ipm = NULL;

    initFakeVisual(&fakeVis) ;

    depth = 24 ;

    ximage = ReadRegionsInList(disp,&fakeVis,depth,format,

             (int32_t) width, (int32_t) height, bbox,vis_regions) ;

    pmData = (unsigned char *)ximage -> data ;

/* if transparency possible do it again, but this time for image planes only */

    if (vis_image_regions && (vis_image_regions->next) && !allImage)

    {

            ximage_ipm = ReadRegionsInList(disp,&fakeVis,depth,format,

                         (int32_t) width, (int32_t) height,bbox,vis_image_regions) ;

        ipmData = (unsigned char *)ximage_ipm -> data ;

    }

/* Now tranverse the overlay visual windows and test for transparency index.  */

/* If you find one, subsitute the value from the matching image plane pixmap. */

    for (reg = (image_region_type *) first_in_list( vis_regions); reg;

         reg = (image_region_type *) next_in_list( vis_regions))

    {

        if (src_in_overlay( reg, numOverlayVisuals, pOverlayVisuals,

                                 &transparentColor, &transparentType))

        {

         int32_t test = 0 ;

             srcRect_width  = MIN( reg->width + reg->x_vis, bbox.width + bbox.x)

                                 - MAX( reg->x_vis, bbox.x);

             srcRect_height = MIN( reg->height + reg->y_vis, bbox.height

                                 + bbox.y) - MAX( reg->y_vis, bbox.y);

         diff = bbox.x - reg->x_vis;

         srcRect_x = MAX( 0, diff) + (reg->x_vis - reg->x_rootrel - reg->border);

         dst_x     = MAX( 0, -diff) ;

             diff = bbox.y - reg->y_vis;