Heap leaks detected:

--memory-breakpoint__ 13578 : Memory at 0x0x7fe4901bf600, size 0x30 = 48
    +0 0x00007FE4901BF600 01 00 00 00 46 72 65 65 68 F3 1B 90 E4 7F 00 00     ....Freeh......
   +16 0x00007FE4901BF610 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00     ................
   +32 0x00007FE4901BF620 00 72 65 65 46 72 65 65 60 89 9E 03 D3 55 00 00     .reeFree`....U..

--memory-breakpoint__ 13577 : Memory at 0x0x7fe4901bf360, size 0x30 = 48
    +0 0x00007FE4901BF360 46 72 65 65 46 72 65 65 00 00 00 00 46 72 65 65     FreeFree....Free
   +16 0x00007FE4901BF370 00 F6 1B 90 E4 7F 00 00 00 F6 1B 90 E4 7F 00 00     ..............
   +32 0x00007FE4901BF380 00 F6 1B 90 E4 7F 00 00 01 00 00 00 00 00 00 00     ...............

--memory-breakpoint__ 13576 : Memory at 0x0x7fe4901ab6e0, size 0x10 = 16
    +0 0x00007FE4901AB6E0 80 97 95 03 D3 55 00 00 00 00 00 00 01 72 65 65     .....U.......ree

--memory-breakpoint__ 6757 : Memory at 0x0x7fe498a9fba0, size 0x10 = 16
    +0 0x00007FE498A9FBA0 08 0E EE 8B E4 7F 00 00 00 72 65 65 00 00 00 00     ........ree....
****************** PANIC: Heap leaks detected!

void GLCtrl::Paint(Draw& w)
{
	Size sz = GetSize();
	if(!s_GLXContext || sz.cx == 0 || sz.cy == 0)
		return;

        MemoryIgnoreLeaksBlock __;      // This supresses all. Note: Putting this below glXMakeCurrent() leads to heap leaks message only when the ctrl is resized.

	glXMakeCurrent(s_Display, win, s_GLXContext);

	ONCELOCK {
		glewInit();
	}

	
	
	DoGLPaint();
	
	if(doubleBuffering)
		glXSwapBuffers(s_Display, win);
	else
		glFlush();

	glXMakeCurrent(s_Display, None, NULL);
}

void Ctrl::UpdateArea0(SystemDraw& draw, const Rect& clip, int backpaint)
{
	GuiLock __;
	LTIMING("UpdateArea");
	LLOG("========== UPDATE AREA " << UPP::Name(this) << " " << clip << " ==========");
//      ExcludeDHCtrls(draw, GetRect().GetSize(), clip);
	if(globalbackbuffer) {
		CtrlPaint(draw, clip);
		LLOG("========== END (TARGET IS BACKBUFFER)");
		return;
	}
/*
	if(backpaint == FULLBACKPAINT || globalbackpaint) {
		ShowRepaintRect(draw, clip, LtRed());
		BackDraw bw;
		bw.Create(draw, clip.GetSize());
		bw.Offset(-clip.TopLeft());
		bw.SetPaintingDraw(draw, clip.TopLeft());
		CtrlPaint(bw, clip);
		bw.Put(draw, clip.TopLeft());
		LLOG("========== END (FULLBACKPAINT)");
		return;
	}
*/
	if(backpaint == TRANSPARENTBACKPAINT) {
		LLOG("TransparentBackpaint");
		Vector<Rect> area;
		GatherTransparentAreas(area, draw, GetRect().GetSize(), clip);

-	if(backpaint == FULLBACKPAINT || globalbackpaint/* && !hasdhctrl && !dynamic_cast<DHCtrl *>(this)*/) {
+	if(backpaint == FULLBACKPAINT || globalbackpaint && !hasdhctrl && !dynamic_cast<DHCtrl *>(this)) {

#include <Core/Core.h>

#include <GL/glx.h>
#include <GL/gl.h>
#include <unistd.h>
#include <iostream>
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
#define GLX_CONTEXT_MAJOR_VERSION_ARB       0x2091
#define GLX_CONTEXT_MINOR_VERSION_ARB       0x2092

typedef GLXContext (*glXCreateContextAttribsARBProc)(Display*, GLXFBConfig, GLXContext, Bool, const int*);
 
CONSOLE_APP_MAIN
{
    Display *display = XOpenDisplay(0);
 
    glXCreateContextAttribsARBProc glXCreateContextAttribsARB = NULL;
 
    const char *extensions = glXQueryExtensionsString(display, DefaultScreen(display));
    std::cout << extensions << std::endl;
 
    static int visual_attribs[] =
    {
        GLX_RENDER_TYPE, GLX_RGBA_BIT,
        GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
        GLX_DOUBLEBUFFER, true,
        GLX_RED_SIZE, 1,
        GLX_GREEN_SIZE, 1,
        GLX_BLUE_SIZE, 1,
        None
     };
 
    std::cout << "Getting framebuffer config" << std::endl;
    int fbcount;
    GLXFBConfig *fbc = glXChooseFBConfig(display, DefaultScreen(display), visual_attribs, &fbcount);
    if (!fbc)
    {
        std::cout << "Failed to retrieve a framebuffer config" << std::endl;
        return;
    }
 
    std::cout << "Getting XVisualInfo" << std::endl;
    XVisualInfo *vi = glXGetVisualFromFBConfig(display, fbc[0]);
 
    XSetWindowAttributes swa;
    memset(&swa, 0, sizeof(swa));
    std::cout << "Creating colormap" << std::endl;
    swa.colormap = XCreateColormap(display, RootWindow(display, vi->screen), vi->visual, AllocNone);
    swa.border_pixel = 0;
    swa.event_mask = 0;//StructureNotifyMask;
 
    std::cout << "Creating window" << std::endl;
    Window win = XCreateWindow(display, RootWindow(display, vi->screen), 0, 0, 100, 100, 0, vi->depth, InputOutput, vi->visual, CWBorderPixel|CWColormap|CWEventMask, &swa);
    if (!win)
    {
        std::cout << "Failed to create window." << std::endl;
        return;
    }
 
    std::cout << "Mapping window" << std::endl;
    XMapWindow(display, win);
 
    // Create an oldstyle context first, to get the correct function pointer for glXCreateContextAttribsARB
    GLXContext ctx_old = glXCreateContext(display, vi, 0, GL_TRUE);
    glXCreateContextAttribsARB =  (glXCreateContextAttribsARBProc)glXGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB");
    glXMakeCurrent(display, 0, 0);
    glXDestroyContext(display, ctx_old);
 
    if (glXCreateContextAttribsARB == NULL)
    {
        std::cout << "glXCreateContextAttribsARB entry point not found. Aborting." << std::endl;
        return;
    }
 
    static int context_attribs[] =
    {
        GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
        GLX_CONTEXT_MINOR_VERSION_ARB, 0,
        None
    };

/* 
    std::cout << "Creating context" << std::endl;
    GLXContext ctx = glXCreateContextAttribsARB(display, fbc[0], NULL, true, context_attribs);
    if (!ctx)
    {
        std::cout << "Failed to create GL3 context." << std::endl;
        return;
    }
*/
//    GLXContext ctx = glXCreateContextAttribsARB(display, fbc[0], NULL, true, context_attribs);
	GLXContext ctx = glXCreateContext(display, vi, NULL, GL_TRUE);

    std::cout << "Making context current" << std::endl;
    glXMakeCurrent(display, win, ctx);
 
 	for(int i = 0; i < 4; i++) {
        glClearColor (0, 0.5, 1, 1);
        glClear (GL_COLOR_BUFFER_BIT);
        glXSwapBuffers (display, win);
 
        sleep(1);
 
        glClearColor (1, 0.5, 0, 1);
        glClear (GL_COLOR_BUFFER_BIT);
        glXSwapBuffers (display, win);
 
        sleep(1);
 	}
    ctx = glXGetCurrentContext();
    glXMakeCurrent(display, 0, 0);
    glXDestroyContext(display, ctx);
}

#include "GLCtrl.h"

#ifdef GUI_GTK

#include <GL/glx.h>
#include <GL/gl.h>
#include <gdk/gdkx.h>

namespace Upp {
	
static XVisualInfo *s_XVisualInfo;
static Colormap     s_Colormap;
static GLXContext   s_GLXContext;
static ::Display   *s_Display;

EXITBLOCK {
	if(s_GLXContext)
		glXDestroyContext(s_Display, s_GLXContext);
}

void GLCtrl::Create()
{
	DLOG("Create");
	Ctrl *top = GetTopCtrl();
	if(!top)
		return;
	
	GdkWindow *gdk = top->gdk();
	if(!gdk)
		return;
	
	DDUMP(gdk);

	Window w = gdk_x11_drawable_get_xid((GdkDrawable *)gdk);
	
	DDUMP(w);
	
	ONCELOCK {
		s_Display = gdk_x11_drawable_get_xdisplay((GdkDrawable *)gdk);
		int samples = numberOfSamples;
		GLXFBConfig *fbc;
		do {
			Vector<int> attr;
			attr << GLX_RGBA << GLX_DEPTH_SIZE << depthSize
			     << GLX_STENCIL_SIZE << stencilSize;
			if(doubleBuffering)
				attr << GLX_DOUBLEBUFFER;
			if(samples > 1)
				attr << GLX_SAMPLE_BUFFERS_ARB << 1 << GLX_SAMPLES_ARB << samples;
			attr << 0;
	
			samples >>= 1;
			int fbcount;
			fbc = glXChooseFBConfig(s_Display, DefaultScreen(s_Display), attr, &fbcount);
		}
		while(!fbc && samples > 0);
		DDUMP(fbc);
		if(!fbc)
			return;
		s_XVisualInfo = glXGetVisualFromFBConfig(s_Display, fbc[0]);
		s_Colormap = XCreateColormap(s_Display, RootWindow(s_Display, s_XVisualInfo->screen), s_XVisualInfo->visual, AllocNone);
		s_GLXContext = glXCreateContext(s_Display, s_XVisualInfo, NULL, GL_TRUE);
		
		DDUMP(s_XVisualInfo);
		DDUMP(s_Colormap);
		DDUMP(s_GLXContext);
	}
	
	if(!s_GLXContext)
		return;

	XSetWindowAttributes swa;
	swa.colormap = s_Colormap;
	swa.border_pixel = 0;
	swa.event_mask = 0;
 
	win = XCreateWindow(s_Display, w, 0, 0, 1, 1, 0,
                        s_XVisualInfo->depth, InputOutput, s_XVisualInfo->visual,
                        CWBorderPixel|CWColormap|CWEventMask, &swa);
	visible = false;
	position = Null;
	
	DDUMP(win);
}

void GLCtrl::Sync()
{
	if(win) {
		Rect r = GetScreenView() - GetTopCtrl()->GetScreenRect().TopLeft();
		bool b = IsVisible() && r.GetWidth() > 0 && r.GetHeight() > 0;
		if(b != visible) {
			visible = b;
			position = Null;
			if(b)
			    XMapWindow(s_Display, win);
			else
			    XUnmapWindow(s_Display, win);
		}
		if(r != position && visible) {
			position = r;
			XMoveResizeWindow(s_Display, win, r.left, r.top, r.Width(), r.Height());
		}
		DDUMP(visible);
		DDUMP(r);
	}
}

void GLCtrl::State(int reason)
{
	DLOG("State");
	switch(reason) {
	case CLOSE:
		DLOG("Destroy");
		XDestroyWindow(s_Display, win);
		break;
	case OPEN:
		DLOG("Create");
		Create();
	default:
		DLOG("Sync");
		Sync();
		break;
	}
}

void GLCtrl::Paint(Draw& w)
{
	Size sz = GetSize();
	DLOG("Paint");
	DDUMP(s_GLXContext);
	DDUMP(sz);
	DDUMP(s_Display);

	if(!s_GLXContext || sz.cx == 0 || sz.cy == 0)
		return;

	glXMakeCurrent(s_Display, win, s_GLXContext);

	ONCELOCK {
		glewInit();
	}

	DLOG("DoGLPaint");
	DoGLPaint();

	if(doubleBuffering)
		glXSwapBuffers(s_Display, win);
	else
		glFlush();

	glXMakeCurrent(s_Display, None, NULL);
}

}

#endif

void GLCtrl::Create()
{
	Ctrl *top = GetTopCtrl();
	if(!top)
		return;
	
	GdkWindow *gdk = top->gdk();
	if(!gdk)
		return;

	Window w = gdk_x11_drawable_get_xid((GdkDrawable *)gdk);
	
	ONCELOCK {
		s_Display = gdk_x11_drawable_get_xdisplay((GdkDrawable *)gdk);
		int samples = numberOfSamples;

		do {
			Vector<int> attr;
			attr << GLX_RGBA << GLX_DEPTH_SIZE << depthSize
			     << GLX_STENCIL_SIZE << stencilSize;
			if(doubleBuffering)
				attr << GLX_DOUBLEBUFFER;
			if(samples > 1)
				attr << GLX_SAMPLE_BUFFERS_ARB << 1 << GLX_SAMPLES_ARB << samples;
			attr << 0;
			samples >>= 1;
			s_XVisualInfo = glXChooseVisual(s_Display, DefaultScreen(s_Display), attr);
		}
		while(!s_XVisualInfo && samples > 0);
		if(!s_XVisualInfo)
			return;
		s_Colormap = XCreateColormap(s_Display, RootWindow(s_Display, s_XVisualInfo->screen), s_XVisualInfo->visual, AllocNone);
		s_GLXContext = glXCreateContext(s_Display, s_XVisualInfo, NULL, GL_TRUE);
	}
	
	if(!s_GLXContext)
		return;

	XSetWindowAttributes swa;
	swa.colormap = s_Colormap;
	swa.border_pixel = 0;
	swa.event_mask = 0;
 
	win = XCreateWindow(s_Display, w, 0, 0, 1, 1, 0,
                        s_XVisualInfo->depth, InputOutput, s_XVisualInfo->visual,
                        CWBorderPixel|CWColormap|CWEventMask, &swa);
	visible = false;
	position = Null;
}

void GLCtrl::DoGLPaint()
{
	glClearDepth(1);
	glClearColor(1, 0, 0, 1);
	glClear(GL_COLOR_B
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	
	UFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
	glEnable(GL_MULTISAMPLE);
	Size sz = GetSize();
	current_viewport = sz;
	SetCurrentViewport();
	GLPaint();
}