/*

 * Copyright (c) 1997, 2019, 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.

 */

#include "jni_util.h"

#include "awt_p.h"

#include "awt.h"

#include "color.h"

#include <java_awt_DisplayMode.h>

#include <sun_awt_X11GraphicsEnvironment.h>

#include <sun_awt_X11GraphicsDevice.h>

#include <sun_awt_X11GraphicsConfig.h>

#ifndef HEADLESS

#include <X11/extensions/Xdbe.h>

#include <X11/XKBlib.h>

#ifndef NO_XRANDR

#include <X11/extensions/Xrandr.h>

#endif

#include "GLXGraphicsConfig.h"

#endif /* !HEADLESS */

#include <jni.h>

#include <jni_util.h>

#include <jvm.h>

#include <jvm_md.h>

#include <jlong.h>

#include "systemScale.h"

#include <stdlib.h>

#include "awt_GraphicsEnv.h"

#include "awt_util.h"

#include "gdefs.h"

#include <dlfcn.h>

#include "Trace.h"

#ifndef HEADLESS

int awt_numScreens;     /* Xinerama-aware number of screens */

AwtScreenDataPtr x11Screens;

/*

 * Set in initDisplay() to indicate whether we should attempt to initialize

 * GLX for the default configuration.

 */

static jboolean glxRequested = JNI_FALSE;

#endif /* !HEADLESS */

#ifdef HEADLESS

#define Display void

#endif /* HEADLESS */

Display *awt_display;

jclass tkClass = NULL;

jmethodID awtLockMID = NULL;

jmethodID awtUnlockMID = NULL;

jmethodID awtWaitMID = NULL;

jmethodID awtNotifyMID = NULL;

jmethodID awtNotifyAllMID = NULL;

jboolean awtLockInited = JNI_FALSE;

/** Convenience macro for loading the lock-related method IDs. */

#define GET_STATIC_METHOD(klass, method_id, method_name, method_sig) \

    do { \

        method_id = (*env)->GetStaticMethodID(env, klass, \

                                              method_name, method_sig); \

        if (method_id == NULL) return NULL; \

    } while (0)

struct X11GraphicsConfigIDs x11GraphicsConfigIDs;

#ifndef HEADLESS

int awtCreateX11Colormap(AwtGraphicsConfigDataPtr adata);

#endif /* HEADLESS */

static char *x11GraphicsConfigClassName = "sun/awt/X11GraphicsConfig";

/* AWT and Xinerama

 *

 * As of fix 4356756, AWT is Xinerama-aware.  X11GraphicsDevices are created for

 * each screen of a Xinerama setup, though X11 itself still only sees a single

 * display.

 * In many places where we talk to X11, a xinawareScreen variable is used to

 * pass the correct Display value, depending on the circumstances (a single

 * X display, multiple X displays, or a single X display with multiple

 * Xinerama screens).

 *

 * Solaris and Linux differ in the functions used to access Xinerama-related

 * data.  This is in part because at this time, the X consortium has not

 * finalized the "official" Xinerama API.  Once this spec is available, and

 * both OSes are conformant, one code base should be sufficient for Xinerama

 * operation on both OSes.  Until then, some of the Xinerama-related code

 * is ifdef'd appropriately.  -bchristi, 7/12/01

 */

#define MAXFRAMEBUFFERS 16

#if defined(__solaris__)

typedef Status XineramaGetInfoFunc(Display* display, int screen_number,

         XRectangle* framebuffer_rects, unsigned char* framebuffer_hints,

         int* num_framebuffers);

#else /* Linux, Mac, AIX */

typedef struct {

   int   screen_number;

   short x_org;

   short y_org;

   short width;

   short height;

} XineramaScreenInfo;

typedef XineramaScreenInfo* XineramaQueryScreensFunc(Display*, int*);

#endif

Bool usingXinerama = False;

XRectangle fbrects[MAXFRAMEBUFFERS];

JNIEXPORT void JNICALL

Java_sun_awt_X11GraphicsConfig_initIDs (JNIEnv *env, jclass cls)

{

    x11GraphicsConfigIDs.aData = NULL;

    x11GraphicsConfigIDs.bitsPerPixel = NULL;

    x11GraphicsConfigIDs.aData = (*env)->GetFieldID (env, cls, "aData", "J");

    CHECK_NULL(x11GraphicsConfigIDs.aData);

    x11GraphicsConfigIDs.bitsPerPixel = (*env)->GetFieldID (env, cls, "bitsPerPixel", "I");

    CHECK_NULL(x11GraphicsConfigIDs.bitsPerPixel);

}

#ifndef HEADLESS

/*

 * XIOErrorHandler

 */

static int xioerror_handler(Display *disp)

{

    if (awtLockInited) {

        if (errno == EPIPE) {

            jio_fprintf(stderr, "X connection to %s host broken (explicit kill or server shutdown)\n", XDisplayName(NULL));

        }

        /*SignalError(lockedee->lastpc, lockedee, "fp/ade/gui/GUIException", "I/O error"); */

    }

    return 0;

}

static AwtGraphicsConfigDataPtr

findWithTemplate(XVisualInfo *vinfo,

                 long mask)

{

    XVisualInfo *visualList;

    XColor color;

    AwtGraphicsConfigDataPtr defaultConfig;

    int visualsMatched, i;

    visualList = XGetVisualInfo(awt_display,

                                mask, vinfo, &visualsMatched);

    if (visualList) {

        int id = -1;

        VisualID defaultVisual = XVisualIDFromVisual(DefaultVisual(awt_display, vinfo->screen));

        defaultConfig = ZALLOC(_AwtGraphicsConfigData);

        for (i = 0; i < visualsMatched; i++) {

            memcpy(&defaultConfig->awt_visInfo, &visualList[i], sizeof(XVisualInfo));

            defaultConfig->awt_depth = visualList[i].depth;

            /* we can't use awtJNI_CreateColorData here, because it'll pull,

               SystemColor, which in turn will cause toolkit to be reinitialized */

            if (awtCreateX11Colormap(defaultConfig)) {

                if (visualList[i].visualid == defaultVisual) {

                    id = i;

                    break;

                } else if (-1 == id) {

                    // Keep 1st match for fallback

                    id = i;

                }

            }

        }

        if (-1 != id) {

            memcpy(&defaultConfig->awt_visInfo, &visualList[id], sizeof(XVisualInfo));

            defaultConfig->awt_depth = visualList[id].depth;

            /* Allocate white and black pixels for this visual */

            color.flags = DoRed | DoGreen | DoBlue;

            color.red = color.green = color.blue = 0x0000;

            XAllocColor(awt_display, defaultConfig->awt_cmap, &color);

            x11Screens[visualList[id].screen].blackpixel = color.pixel;

            color.flags = DoRed | DoGreen | DoBlue;

            color.red = color.green = color.blue = 0xffff;

            XAllocColor(awt_display, defaultConfig->awt_cmap, &color);

            x11Screens[visualList[id].screen].whitepixel = color.pixel;

            XFree(visualList);

            return defaultConfig;

        }

        XFree(visualList);

        free((void *)defaultConfig);

    }

    return NULL;

}

/* default config is based on X11 screen.  All Xinerama screens of that X11

   screen will have the same default config */

/* Need more notes about which fields of the structure are based on the X

   screen, and which are based on the Xinerama screen */

static AwtGraphicsConfigDataPtr

makeDefaultConfig(JNIEnv *env, int screen) {

    AwtGraphicsConfigDataPtr defaultConfig;

    int xinawareScreen = 0;

    VisualID forcedVisualID = 0, defaultVisualID;

    char *forcedVisualStr;

    XVisualInfo vinfo;

    long mask;

    xinawareScreen = usingXinerama ? 0 : screen;

    defaultVisualID =

        XVisualIDFromVisual(DefaultVisual(awt_display, xinawareScreen));

    memset(&vinfo, 0, sizeof(XVisualInfo));

    vinfo.screen = xinawareScreen;

    if ((forcedVisualStr = getenv("FORCEDEFVIS"))) {

        mask = VisualIDMask | VisualScreenMask;

        if (sscanf(forcedVisualStr, "%lx", &forcedVisualID) > 0 &&

            forcedVisualID > 0)

        {

            vinfo.visualid = forcedVisualID;

        } else {

            vinfo.visualid = defaultVisualID;

        }

    } else {

        VisualID bestGLXVisualID;

        if (glxRequested &&

            (bestGLXVisualID = GLXGC_FindBestVisual(env, xinawareScreen)) > 0)

        {

            /* we've found the best visual for use with GLX, so use it */

            vinfo.visualid = bestGLXVisualID;

            mask = VisualIDMask | VisualScreenMask;

        } else {

            /* otherwise, continue looking for the best X11 visual */

            vinfo.depth = 24;

            vinfo.class = TrueColor;

            mask = VisualDepthMask | VisualScreenMask | VisualClassMask;

        }

    }

    /* try the best, or forced visual */

    defaultConfig = findWithTemplate(&vinfo, mask);

    if (defaultConfig) {

        return defaultConfig;

    }

    /* try the default visual */

    vinfo.visualid = defaultVisualID;

    mask = VisualIDMask | VisualScreenMask;

    defaultConfig = findWithTemplate(&vinfo, mask);

    if (defaultConfig) {

        return defaultConfig;

    }

    /* try any TrueColor */

    vinfo.class = TrueColor;

    mask = VisualScreenMask | VisualClassMask;

    defaultConfig = findWithTemplate(&vinfo, mask);

    if (defaultConfig) {

        return defaultConfig;

    }

    /* try 8-bit PseudoColor */

    vinfo.depth = 8;

    vinfo.class = PseudoColor;

    mask = VisualDepthMask | VisualScreenMask | VisualClassMask;

    defaultConfig = findWithTemplate(&vinfo, mask);

    if (defaultConfig) {

        return defaultConfig;

    }

    /* try any 8-bit */

    vinfo.depth = 8;

    mask = VisualDepthMask | VisualScreenMask;

    defaultConfig = findWithTemplate(&vinfo, mask);

    if (defaultConfig) {

        return defaultConfig;

    }

    /* we tried everything, give up */

    JNU_ThrowInternalError(env, "Can't find supported visual");

    XCloseDisplay(awt_display);

    awt_display = NULL;

    return NULL;

}

static void

getAllConfigs (JNIEnv *env, int screen, AwtScreenDataPtr screenDataPtr) {

    int i;

    int n8p=0, n12p=0, n8s=0, n8gs=0, n8sg=0, n1sg=0, nTrue=0;

    int nConfig;

    XVisualInfo *pVI8p, *pVI12p, *pVI8s, *pVITrue, *pVI8gs,

                *pVI8sg, *pVI1sg = NULL, viTmp;

    AwtGraphicsConfigDataPtr *graphicsConfigs;

    AwtGraphicsConfigDataPtr defaultConfig;

    int ind;

    char errmsg[128];

    int xinawareScreen;

    void* xrenderLibHandle = NULL;

    XRenderFindVisualFormatFunc* xrenderFindVisualFormat = NULL;

    int major_opcode, first_event, first_error;

    if (usingXinerama) {

        xinawareScreen = 0;

    }

    else {

        xinawareScreen = screen;

    }

    AWT_LOCK ();

    viTmp.screen = xinawareScreen;

    viTmp.depth = 8;

    viTmp.class = PseudoColor;

    viTmp.colormap_size = 256;

    pVI8p = XGetVisualInfo (awt_display,

                            VisualDepthMask | VisualClassMask |

                            VisualColormapSizeMask | VisualScreenMask,

                            &viTmp, &n8p);

    viTmp.depth = 12;

    viTmp.class = PseudoColor;

    viTmp.colormap_size = 4096;

    pVI12p = XGetVisualInfo (awt_display,

                             VisualDepthMask | VisualClassMask |

                             VisualColormapSizeMask | VisualScreenMask,

                             &viTmp, &n12p);

    viTmp.class = TrueColor;

    pVITrue = XGetVisualInfo (awt_display,

                              VisualClassMask |

                              VisualScreenMask,

                              &viTmp, &nTrue);

    viTmp.depth = 8;

    viTmp.class = StaticColor;

    pVI8s = XGetVisualInfo (awt_display, VisualDepthMask | VisualClassMask |

                            VisualScreenMask, &viTmp, &n8s);

    viTmp.depth = 8;

    viTmp.class = GrayScale;

    viTmp.colormap_size = 256;

    pVI8gs = XGetVisualInfo (awt_display,

                             VisualDepthMask | VisualClassMask |

                             VisualColormapSizeMask | VisualScreenMask,

                             &viTmp, &n8gs);

    viTmp.depth = 8;

    viTmp.class = StaticGray;

    viTmp.colormap_size = 256;

    pVI8sg = XGetVisualInfo (awt_display,

                             VisualDepthMask | VisualClassMask |

                             VisualColormapSizeMask | VisualScreenMask,

                             &viTmp, &n8sg);

/* REMIND.. remove when we have support for the color classes below */

/*     viTmp.depth = 1; */

/*     viTmp.class = StaticGray; */

/*     pVI1sg = XGetVisualInfo (awt_display, VisualDepthMask | VisualClassMask, */

/*                              viTmp, &n1sg); */

    nConfig = n8p + n12p + n8s + n8gs + n8sg  + n1sg + nTrue + 1;

    graphicsConfigs = (AwtGraphicsConfigDataPtr *)

        calloc(nConfig, sizeof(AwtGraphicsConfigDataPtr));

    if (graphicsConfigs == NULL) {

        JNU_ThrowOutOfMemoryError((JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2),

                                  NULL);

        AWT_UNLOCK();

        return;

    }

    if (screenDataPtr->defaultConfig == NULL) {

        /*

         * After a display change event, the default config field will have

         * been reset, so we need to recreate the default config here.

         */

        screenDataPtr->defaultConfig = makeDefaultConfig(env, screen);

    }

    defaultConfig = screenDataPtr->defaultConfig;

    graphicsConfigs[0] = defaultConfig;

    nConfig = 1; /* reserve index 0 for default config */

    // Only use the RENDER extension if it is available on the X server

    if (XQueryExtension(awt_display, "RENDER",

                        &major_opcode, &first_event, &first_error))

    {

        DTRACE_PRINTLN("RENDER extension available");

        xrenderLibHandle = dlopen("libXrender.so.1", RTLD_LAZY | RTLD_GLOBAL);

#ifdef MACOSX

#define XRENDER_LIB "/usr/X11/lib/libXrender.dylib"

#else

#define XRENDER_LIB "libXrender.so"

#endif

        if (xrenderLibHandle == NULL) {

            xrenderLibHandle = dlopen(XRENDER_LIB,

                                      RTLD_LAZY | RTLD_GLOBAL);

        }

#if defined(__solaris__)

        if (xrenderLibHandle == NULL) {

            xrenderLibHandle = dlopen("/usr/lib/libXrender.so.1",

                                      RTLD_LAZY | RTLD_GLOBAL);

        }

#elif defined(_AIX)

        if (xrenderLibHandle == NULL) {

            xrenderLibHandle = dlopen("libXrender.a(libXrender.so.0)",

                                      RTLD_MEMBER | RTLD_LAZY | RTLD_GLOBAL);

        }

#endif

        if (xrenderLibHandle != NULL) {

            DTRACE_PRINTLN("Loaded libXrender");

            xrenderFindVisualFormat =

                (XRenderFindVisualFormatFunc*)dlsym(xrenderLibHandle,

                                                    "XRenderFindVisualFormat");

            if (xrenderFindVisualFormat == NULL) {

                DTRACE_PRINTLN1("Can't find 'XRenderFindVisualFormat' in libXrender (%s)", dlerror());

            }

        } else {

            DTRACE_PRINTLN1("Can't load libXrender (%s)", dlerror());

        }

    } else {

        DTRACE_PRINTLN("RENDER extension NOT available");

    }

    for (i = 0; i < nTrue; i++) {

        if (XVisualIDFromVisual(pVITrue[i].visual) ==

            XVisualIDFromVisual(defaultConfig->awt_visInfo.visual) ||

            pVITrue[i].depth == 12) {

            /* Skip the non-supported 12-bit TrueColor visual */

            continue;

        } else {

            ind = nConfig++;

        }

        graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);

        graphicsConfigs [ind]->awt_depth = pVITrue [i].depth;

        memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVITrue [i],

                sizeof (XVisualInfo));

        if (xrenderFindVisualFormat != NULL) {

            XRenderPictFormat *format = xrenderFindVisualFormat (awt_display,

                                                                 pVITrue [i].visual);

            if (format &&

                format->type == PictTypeDirect &&

                format->direct.alphaMask)

            {

                DTRACE_PRINTLN1("GraphicsConfig[%d] supports Translucency", ind);

                graphicsConfigs [ind]->isTranslucencySupported = 1;

                memcpy(&graphicsConfigs [ind]->renderPictFormat, format,

                        sizeof(*format));

            } else {

                DTRACE_PRINTLN1(format ?

                                "GraphicsConfig[%d] has no Translucency support" :

                                "Error calling 'XRenderFindVisualFormat'", ind);

            }

       }

    }

    if (xrenderLibHandle != NULL) {

        dlclose(xrenderLibHandle);

        xrenderLibHandle = NULL;

    }

    for (i = 0; i < n8p; i++) {

        if (XVisualIDFromVisual(pVI8p[i].visual) ==

            XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {

            continue;

        } else {

            ind = nConfig++;

        }

        graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);

        graphicsConfigs [ind]->awt_depth = pVI8p [i].depth;

        memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI8p [i],

                sizeof (XVisualInfo));

    }

    for (i = 0; i < n12p; i++) {

        if (XVisualIDFromVisual(pVI12p[i].visual) ==

            XVisualIDFromVisual(defaultConfig->awt_visInfo.visual)) {

            continue;

        } else {

            ind = nConfig++;

        }

        graphicsConfigs [ind] = ZALLOC (_AwtGraphicsConfigData);

        graphicsConfigs [ind]->awt_depth = pVI12p [i].depth;

        memcpy (&graphicsConfigs [ind]->awt_visInfo, &pVI12p [i],

                sizeof (XVisualInfo));