diff -u xorg-server-1.6.0/debian/changelog xorg-server-1.6.0/debian/changelog --- xorg-server-1.6.0/debian/changelog +++ xorg-server-1.6.0/debian/changelog @@ -1,3 +1,11 @@ +xorg-server (2:1.6.0-0ubuntu5) jaunty; urgency=low + + * Add 171_fix_qt3_missing_fonts.patch: + - Reverts 3 upstream commits that caused regressions in QT3 + applications when calling show() on widgets. (LP: #341898) + + -- test Tue, 24 Mar 2009 01:36:31 -0400 + xorg-server (2:1.6.0-0ubuntu4) jaunty; urgency=low * Add 168_glibc_trace_to_stderr.patch: diff -u xorg-server-1.6.0/debian/patches/series xorg-server-1.6.0/debian/patches/series --- xorg-server-1.6.0/debian/patches/series +++ xorg-server-1.6.0/debian/patches/series @@ -27,0 +28 @@ +171_fix_qt3_missing_fonts.patch only in patch2: unchanged: --- xorg-server-1.6.0.orig/debian/patches/171_fix_qt3_missing_fonts.patch +++ xorg-server-1.6.0/debian/patches/171_fix_qt3_missing_fonts.patch @@ -0,0 +1,329 @@ +This patch reverts commits: +3575cb86a18d9e80e239acefdab18694e4ca2098 +516f8e2cad1311a09764e2633644188d1e3c31bb +8b967b24690cb072fc37c463eceb2b886cef80c4 +which has caused failures in QT3 show() calls, as seen in mythtv. + +diff --git a/glx/glxscreens.c b/glx/glxscreens.c +index 95d35eb..0c76cfd 100644 +--- a/glx/glxscreens.c ++++ b/glx/glxscreens.c +@@ -242,6 +242,44 @@ GLint glxConvertToXVisualType(int visualType) + ? x_visual_types[ visualType - GLX_TRUE_COLOR ] : -1; + } + ++ ++static void ++filterOutNativeConfigs(__GLXscreen *pGlxScreen) ++{ ++ __GLXconfig *m, *next, **last; ++ ScreenPtr pScreen = pGlxScreen->pScreen; ++ int i, depth; ++ ++ last = &pGlxScreen->fbconfigs; ++ for (m = pGlxScreen->fbconfigs; m != NULL; m = next) { ++ next = m->next; ++ depth = m->redBits + m->blueBits + m->greenBits; ++ ++ for (i = 0; i < pScreen->numVisuals; i++) { ++ if (pScreen->visuals[i].nplanes == depth) { ++ *last = m; ++ last = &m->next; ++ break; ++ } ++ } ++ } ++ ++ *last = NULL; ++} ++ ++static XID ++findVisualForConfig(ScreenPtr pScreen, __GLXconfig *m) ++{ ++ int i; ++ ++ for (i = 0; i < pScreen->numVisuals; i++) { ++ if (glxConvertToXVisualType(m->visualType) == pScreen->visuals[i].class) ++ return pScreen->visuals[i].vid; ++ } ++ ++ return 0; ++} ++ + /* This code inspired by composite/compinit.c. We could move this to + * mi/ and share it with composite.*/ + +@@ -349,52 +387,119 @@ initGlxVisual(VisualPtr visual, __GLXconfig *config) + visual->offsetBlue = findFirstSet(config->blueMask); + } + ++typedef struct { ++ GLboolean doubleBuffer; ++ GLboolean depthBuffer; ++ GLboolean stencilBuffer; ++} FBConfigTemplateRec, *FBConfigTemplatePtr; ++ + static __GLXconfig * +-pickFBConfig(__GLXscreen *pGlxScreen, VisualPtr visual) ++pickFBConfig(__GLXscreen *pGlxScreen, FBConfigTemplatePtr template, int class) + { +- __GLXconfig *best = NULL, *config; +- int best_score = 0; ++ __GLXconfig *config; + + for (config = pGlxScreen->fbconfigs; config != NULL; config = config->next) { +- int score = 0; +- +- if (config->redMask != visual->redMask || +- config->greenMask != visual->greenMask || +- config->blueMask != visual->blueMask) +- continue; + if (config->visualRating != GLX_NONE) + continue; +- if (glxConvertToXVisualType(config->visualType) != visual->class) ++ if (glxConvertToXVisualType(config->visualType) != class) + continue; +- /* If it's the 32-bit RGBA visual, demand a 32-bit fbconfig. */ +- if (visual->nplanes == 32 && config->rgbBits != 32) ++ if ((config->doubleBufferMode > 0) != template->doubleBuffer) + continue; +- /* Can't use the same FBconfig for multiple X visuals. I think. */ +- if (config->visualID != 0) ++ if ((config->depthBits > 0) != template->depthBuffer) ++ continue; ++ if ((config->stencilBits > 0) != template->stencilBuffer) + continue; + +- if (config->doubleBufferMode > 0) +- score += 8; +- if (config->depthBits > 0) +- score += 4; +- if (config->stencilBits > 0) +- score += 2; +- if (config->alphaBits > 0) +- score++; +- +- if (score > best_score) { +- best = config; +- best_score = score; +- } ++ return config; + } + +- return best; ++ return NULL; ++} ++ ++static void ++addMinimalSet(__GLXscreen *pGlxScreen) ++{ ++ __GLXconfig *config; ++ VisualPtr visuals; ++ int i, j; ++ FBConfigTemplateRec best = { GL_TRUE, GL_TRUE, GL_TRUE }; ++ FBConfigTemplateRec good = { GL_TRUE, GL_TRUE, GL_FALSE }; ++ FBConfigTemplateRec minimal = { GL_FALSE, GL_FALSE, GL_FALSE }; ++ ++ pGlxScreen->visuals = xcalloc(pGlxScreen->pScreen->numVisuals, ++ sizeof (__GLXconfig *)); ++ if (pGlxScreen->visuals == NULL) { ++ ErrorF("Failed to allocate for minimal set of GLX visuals\n"); ++ return; ++ } ++ ++ visuals = pGlxScreen->pScreen->visuals; ++ for (i = 0, j = 0; i < pGlxScreen->pScreen->numVisuals; i++) { ++ if (visuals[i].nplanes == 32) ++ config = pickFBConfig(pGlxScreen, &minimal, visuals[i].class); ++ else { ++ config = pickFBConfig(pGlxScreen, &best, visuals[i].class); ++ if (config == NULL) ++ config = pickFBConfig(pGlxScreen, &good, visuals[i].class); ++ } ++ if (config == NULL) ++ config = pGlxScreen->fbconfigs; ++ if (config == NULL) ++ continue; ++ ++ pGlxScreen->visuals[j] = config; ++ config->visualID = visuals[i].vid; ++ j++; ++ } ++ ++ pGlxScreen->numVisuals = j; ++} ++ ++static void ++addTypicalSet(__GLXscreen *pGlxScreen) ++{ ++ addMinimalSet(pGlxScreen); ++} ++ ++static void ++addFullSet(__GLXscreen *pGlxScreen) ++{ ++ __GLXconfig *config; ++ VisualPtr visuals; ++ int i, depth; ++ ++ pGlxScreen->visuals = ++ xcalloc(pGlxScreen->numFBConfigs, sizeof (__GLXconfig *)); ++ if (pGlxScreen->visuals == NULL) { ++ ErrorF("Failed to allocate for full set of GLX visuals\n"); ++ return; ++ } ++ ++ config = pGlxScreen->fbconfigs; ++ depth = config->redBits + config->greenBits + config->blueBits; ++ visuals = AddScreenVisuals(pGlxScreen->pScreen, pGlxScreen->numFBConfigs, depth); ++ if (visuals == NULL) { ++ xfree(pGlxScreen->visuals); ++ return; ++ } ++ ++ pGlxScreen->numVisuals = pGlxScreen->numFBConfigs; ++ for (i = 0, config = pGlxScreen->fbconfigs; config; config = config->next, i++) { ++ pGlxScreen->visuals[i] = config; ++ initGlxVisual(&visuals[i], config); ++ } ++} ++ ++static int glxVisualConfig = GLX_ALL_VISUALS; ++ ++void GlxSetVisualConfig(int config) ++{ ++ glxVisualConfig = config; + } + + void __glXScreenInit(__GLXscreen *pGlxScreen, ScreenPtr pScreen) + { + __GLXconfig *m; +- __GLXconfig *config; + int i; + + pGlxScreen->pScreen = pScreen; +@@ -406,66 +511,32 @@ void __glXScreenInit(__GLXscreen *pGlxScreen, ScreenPtr pScreen) + pGlxScreen->CloseScreen = pScreen->CloseScreen; + pScreen->CloseScreen = glxCloseScreen; + ++ filterOutNativeConfigs(pGlxScreen); ++ + i = 0; + for (m = pGlxScreen->fbconfigs; m != NULL; m = m->next) { + m->fbconfigID = FakeClientID(0); +- m->visualID = 0; ++ m->visualID = findVisualForConfig(pScreen, m); + i++; + } + pGlxScreen->numFBConfigs = i; + +- pGlxScreen->visuals = +- xcalloc(pGlxScreen->numFBConfigs, sizeof (__GLXconfig *)); +- +- /* First, try to choose featureful FBconfigs for the existing X visuals. +- * Note that if multiple X visuals end up with the same FBconfig being +- * chosen, the later X visuals don't get GLX visuals (because we want to +- * prioritize the root visual being GLX). +- */ +- for (i = 0; i < pScreen->numVisuals; i++) { +- VisualPtr visual = &pScreen->visuals[i]; +- +- config = pickFBConfig(pGlxScreen, visual); +- if (config) { +- pGlxScreen->visuals[pGlxScreen->numVisuals++] = config; +- config->visualID = visual->vid; +- } +- } +- +- /* Then, add new visuals corresponding to all FBconfigs that didn't have +- * an existing, appropriate visual. +- */ +- for (config = pGlxScreen->fbconfigs; config != NULL; config = config->next) { +- int depth; +- +- VisualPtr visual; +- +- if (config->visualID != 0) +- continue; +- +- /* Only count RGB bits and not alpha, as we're not trying to create +- * visuals for compositing (that's what the 32-bit composite visual +- * set up above is for. +- */ +- depth = config->redBits + config->greenBits + config->blueBits; +- +- /* Make sure that our FBconfig's depth can actually be displayed +- * (corresponds to an existing visual). +- */ +- for (i = 0; i < pScreen->numVisuals; i++) { +- if (depth == pScreen->visuals[i].nplanes) +- break; +- } +- if (i == pScreen->numVisuals) +- continue; +- +- /* Create a new X visual for our FBconfig. */ +- visual = AddScreenVisuals(pScreen, 1, depth); +- if (visual == NULL) +- continue; +- +- pGlxScreen->visuals[pGlxScreen->numVisuals++] = config; +- initGlxVisual(visual, config); ++ /* Select a subset of fbconfigs that we send to the client when it ++ * asks for the glx visuals. All the fbconfigs here have a valid ++ * value for visual ID and each visual ID is only present once. ++ * This runs before composite adds its extra visual so we have to ++ * remember the number of visuals here.*/ ++ ++ switch (glxVisualConfig) { ++ case GLX_MINIMAL_VISUALS: ++ addMinimalSet(pGlxScreen); ++ break; ++ case GLX_TYPICAL_VISUALS: ++ addTypicalSet(pGlxScreen); ++ break; ++ case GLX_ALL_VISUALS: ++ addFullSet(pGlxScreen); ++ break; + } + + dixSetPrivate(&pScreen->devPrivates, glxScreenPrivateKey, pGlxScreen); +diff --git a/glx/glxserver.h b/glx/glxserver.h +index a5ca0a2..1d20929 100644 +--- a/glx/glxserver.h ++++ b/glx/glxserver.h +@@ -135,6 +135,8 @@ enum { + GLX_ALL_VISUALS + }; + ++void GlxSetVisualConfig(int config); ++ + void __glXsetEnterLeaveServerFuncs(void (*enter)(GLboolean), + void (*leave)(GLboolean)); + void __glXenterServer(GLboolean rendering); +diff --git a/hw/xfree86/dixmods/glxmodule.c b/hw/xfree86/dixmods/glxmodule.c +index 62a047e..f6fda4b 100644 +--- a/hw/xfree86/dixmods/glxmodule.c ++++ b/hw/xfree86/dixmods/glxmodule.c +@@ -101,6 +101,21 @@ glxSetup(pointer module, pointer opts, int *errmaj, int *errmin) + GlxPushProvider(provider); + } + ++ switch (xf86Info.glxVisuals) { ++ case XF86_GlxVisualsMinimal: ++ GlxSetVisualConfig(GLX_MINIMAL_VISUALS); ++ xf86Msg(xf86Info.aiglxFrom, "Exporting only minimal set of GLX visuals\n"); ++ break; ++ case XF86_GlxVisualsTypical: ++ GlxSetVisualConfig(GLX_TYPICAL_VISUALS); ++ xf86Msg(xf86Info.aiglxFrom, "Exporting typical set of GLX visuals\n"); ++ break; ++ case XF86_GlxVisualsAll: ++ GlxSetVisualConfig(GLX_ALL_VISUALS); ++ xf86Msg(xf86Info.aiglxFrom, "Exporting all GLX visuals\n"); ++ break; ++ } ++ + LoadExtension(&GLXExt, FALSE); + + return module;