skip = TkGetDisplayOf(interp, objc - 1, objv + 1, &tkwin);
    if (skip < 0) {
	return TCL_ERROR;
    }
    screenPtr = Tk_Screen(tkwin);
    if (objc - skip == 1) {
#ifdef PLATFORM_SDL
	double d2;
	int widthM, widthS, heightM, heightS;

	ScreenGetMMWidthHeight(Tk_Display(tkwin), screenPtr, &widthM, &widthS,
	       &heightM, &heightS);
	d = 25.4 / 72;
	d *= widthS;
	d /= widthM;
	d2 = 25.4 / 72;
	d2 *= heightS;
	d2 /= heightM;
	if (d2 > d) {
	    d = d2;
	}
#else
	d = 25.4 / 72;
	d *= WidthOfScreen(screenPtr);
	d /= WidthMMOfScreen(screenPtr);
#endif
	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(d));
    } else if (objc - skip == 2) {

	}
	Tcl_SetObjResult(interp, Tcl_NewBooleanObj(alive));
	break;
    }
    case WIN_FPIXELS: {
	double mm, pixels;
#ifdef PLATFORM_SDL
	double pixels2;
	int widthM, widthS, heightM, heightS;
#endif

	if (objc != 4) {
	    Tcl_WrongNumArgs(interp, 2, objv, "window number");
	    return TCL_ERROR;
	}
	if (TkGetWindowFromObj(interp, tkwin, objv[2], &tkwin) != TCL_OK) {
	    return TCL_ERROR;
	}
	string = Tcl_GetString(objv[3]);
	if (Tk_GetScreenMM(interp, tkwin, string, &mm) != TCL_OK) {
	    return TCL_ERROR;
	}
#ifdef PLATFORM_SDL
	ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
		&widthM, &widthS, &heightM, &heightS);
	pixels = mm * widthS / widthM;
	pixels2 = mm * heightS / heightM;
	if (pixels2 > pixels) {
	    pixels = pixels2;
	}
#else
	pixels = mm * WidthOfScreen(Tk_Screen(tkwin))
		/ WidthMMOfScreen(Tk_Screen(tkwin));
#endif
	Tcl_SetObjResult(interp, Tcl_NewDoubleObj(pixels));
	break;
    }

int
TkFontGetPixels(
    Tk_Window tkwin,		/* For point->pixel conversion factor. */
    int size)			/* Font size. */
{
    double d;
    int widthM, widthS;
#ifdef PLATFORM_SDL
    double d2;
    int heightM, heightS;
#endif

    if (size < 0) {
	return -size;
    }

#ifdef PLATFORM_SDL
    ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
	    &widthM, &widthS, &heightM, &heightS);
    d2 = size * 25.4 / 72.0;
    d2 *= heightS;
    d2 /= heightM;
#else
    widthS = WidthOfScreen(Tk_Screen(tkwin));
    widthM = WidthMMOfScreen(Tk_Screen(tkwin));
#endif

    d = size * 25.4 / 72.0;
    d *= widthS;
    d /= widthM;
#ifdef PLATFORM_SDL
    if (d2 > d) {
	d = d2;
    }
#endif
    return (int) (d + 0.5);
}

/*
 *---------------------------------------------------------------------------
 *
 * TkFontGetPoints --

int
TkFontGetPoints(
    Tk_Window tkwin,		/* For pixel->point conversion factor. */
    int size)			/* Font size. */
{
    double d;
    int widthM, widthS;
#ifdef PLATFORM_SDL
    double d2;
    int heightM, heightS;
#endif

    if (size >= 0) {
	return size;
    }

#ifdef PLATFORM_SDL
    ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
	    &widthM, &widthS, &heightM, &heightS);
    d2 = -size * 72.0 / 25.4;
    d2 *= heightM;
    d2 /= heightS;
#else
    widthS = WidthOfScreen(Tk_Screen(tkwin));
    widthM = WidthMMOfScreen(Tk_Screen(tkwin));
#endif

    d = -size * 72.0 / 25.4;
    d *= widthM;
    d /= widthS;
#ifdef PLATFORM_SDL
    if (d2 < d) {
	d = d2;
    }
#endif
    return (int) (d + 0.5);
}

/*
 *-------------------------------------------------------------------------
 *
 * TkFontGetAliasList --

    while ((*end != '\0') && isspace(UCHAR(*end))) {
	end++;
    }
    switch (*end) {
    case 0:
#ifdef PLATFORM_SDL
    {
	int wM, wS, hM, hS;
	double d2 = d;

	ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
		&wM, &wS, &hM, &hS);
	d /= wS;
	d *= wM;
	d2 /= hS;
	d2 *= hM;
	if (d2 < d) {
	    d = d2;
	}
    }
#else
	d /= WidthOfScreen(Tk_Screen(tkwin));
	d *= WidthMMOfScreen(Tk_Screen(tkwin));
#endif
	break;
    case 'c':

				 * units. */
    const char *string,		/* String describing a number of pixels. */
    double *doublePtr)		/* Place to store converted result. */
{
    char *end;
    double d;
    int widthM, widthS;
#ifdef PLATFORM_SDL
    int heightM, heightS;
    double d2, d3;
#endif

    d = strtod((char *) string, &end);
    if (end == string) {
	goto error;
    }
    while ((*end != '\0') && isspace(UCHAR(*end))) {
	end++;
    }
#ifdef PLATFORM_SDL
    ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
	    &widthM, &widthS, &heightM, &heightS);
    d2 = widthS;
    d2 /= widthM;
    d3 = heightS;
    d3 /= heightM;
    if (d3 > d2) {
	widthS = heightS;
	widthM = heightM;
    }
#else
    widthS = WidthOfScreen(Tk_Screen(tkwin));
    widthM = WidthMMOfScreen(Tk_Screen(tkwin));
#endif
    switch (*end) {
    case 0:
	break;

	    goto retry;
	}
	if ((pixelPtr->tkwin != tkwin) || dblPtr) {
	    d = pixelPtr->value;
	    if (pixelPtr->units >= 0) {
		int widthM, widthS;
#ifdef PLATFORM_SDL
		int heightM, heightS;
		double d2, d3;

		ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
			&widthM, &widthS, &heightM, &heightS);
		d2 = widthS;
		d2 /= widthM;
		d3 = heightS;
		d3 /= heightM;
		if (d3 > d2) {
		    widthS = heightS;
		    widthM = heightM;
		}
#else
		widthS = WidthOfScreen(Tk_Screen(tkwin));
		widthM = WidthMMOfScreen(Tk_Screen(tkwin));
#endif
		d *= bias[pixelPtr->units] * widthS;
		d /= widthM;
	    }

    }

    mmPtr = objPtr->internalRep.twoPtrValue.ptr1;
    if (mmPtr->tkwin != tkwin) {
	d = mmPtr->value;
	if (mmPtr->units == -1) {
#ifdef PLATFORM_SDL
	    int wM, wS, hM, hS;
	    double d2 = d;

	    ScreenGetMMWidthHeight(Tk_Display(tkwin), Tk_Screen(tkwin),
		    &wM, &wS, &hM, &hS);
	    d /= wS;
	    d *= wM;
	    d2 /= hS;
	    d2 *= hM;
	    if (d2 < d) {
		d = d2;
	    }
#else
	    d /= WidthOfScreen(Tk_Screen(tkwin));
	    d *= WidthMMOfScreen(Tk_Screen(tkwin));
#endif
	} else {
	    d *= bias[mmPtr->units];
	}

{
    IndicatorSpec *spec = clientData;
    IndicatorElement *indicator = elementRecord;
    Ttk_Padding margins;
    Display *display = Tk_Display(tkwin);
    int dim;
#ifdef PLATFORM_SDL
    int wM, wS, hM, hS;

    ScreenGetMMWidthHeight(display, DefaultScreenOfDisplay(display),
	    &wM, &wS, &hM, &hS);
    if ((hS/hM) > (wS/wM)) {
	wM = hM;
	wS = hS;
    }
    dim = 2 * wS;
    dim /= wM;
#else
    dim = 2 * WidthOfScreen(DefaultScreenOfDisplay(display));
    dim /= WidthMMOfScreen(DefaultScreenOfDisplay(display));
#endif
    if (((dim >= 11) && (dim < 22)) || (dim >= 33)) {
	/* more than 140 DPI */
	if (spec == &checkbutton_spec_small) {
	    spec = &checkbutton_spec_large;
	} else if (spec == &radiobutton_spec_small) {
	    spec = &radiobutton_spec_large;
	}
    }

    XColor *fgColor, *frameColor, *shadeColor, *indicatorColor, *borderColor;
    int index, ix, iy, w, h, dim;
    XGCValues gcValues;
    GC copyGC;
    unsigned long imgColors[8];
    XImage *img;
#ifdef PLATFORM_SDL
    int wM, wS, hM, hS;
#endif

    Ttk_GetPaddingFromObj(NULL, tkwin, indicator->marginObj, &padding);
    b = Ttk_PadBox(b, padding);

#ifdef PLATFORM_SDL
    ScreenGetMMWidthHeight(display, DefaultScreenOfDisplay(display),
	    &wM, &wS, &hM, &hS);
    if ((hS/hM) > (wS/wM)) {
	wM = hM;
	wS = hS;
    }
    dim = 2 * wS;
    dim /= wM;
#else
    dim = 2 * WidthOfScreen(DefaultScreenOfDisplay(display));
    dim /= WidthMMOfScreen(DefaultScreenOfDisplay(display));
#endif
    if (((dim >= 11) && (dim < 22)) || (dim >= 33)) {
	/* more than 140 DPI */
	if (spec == &checkbutton_spec_small) {
	    spec = &checkbutton_spec_large;
	} else if (spec == &radiobutton_spec_small) {
	    spec = &radiobutton_spec_large;
	}
    }

    dim = w;
    w = spec->width;
    h = spec->height;
    for (iy=0 ; iy<h ; iy++) {
	if (dim > w) {
	    for (ix=0 ; ix<w ; ix++) {
		XPutPixel(img, ix*2, iy*2,
		    imgColors[spec->pixels[iy][index*w+ix] - 'A'] );
		XPutPixel(img, ix*2+1, iy*2,
		    imgColors[spec->pixels[iy][index*w+ix] - 'A'] );
		XPutPixel(img, ix*2, iy*2+1,
		    imgColors[spec->pixels[iy][index*w+ix] - 'A'] );
		XPutPixel(img, ix*2+1, iy*2+1,
		    imgColors[spec->pixels[iy][index*w+ix] - 'A'] );
	    }
	} else {
	    for (ix=0 ; ix<w ; ix++) {
		XPutPixel(img, ix, iy,
		    imgColors[spec->pixels[iy][index*w+ix] - 'A'] );
	    }
	}
    }
    if (dim > w) {
	w += spec->width;
	h += spec->height;
    }

    /*
     * Copy onto our target drawable surface.
     */
    memset(&gcValues, 0, sizeof(gcValues));
    copyGC = Tk_GetGC(tkwin, 0, &gcValues);

    TkPutImage(NULL, 0, display, d, copyGC, img, 0, 0, b.x, b.y, w, h);


    /*
     * Tidy up.
     */
    Tk_FreeGC(display, copyGC);
    XDestroyImage(img);
}

    #	operations.
    #
    method Create {} {
	variable hull
	set sbar [ttk::scrollbar $hull.sbar -orient horizontal -takefocus 0]
	catch {$sbar configure -highlightthickness 0}
	set canvas [canvas $hull.canvas -highlightthick 0 -takefocus 1 \
			-width 400 -height 166 -background white]
	pack $sbar -side bottom -fill x -padx 2 -pady {0 2}
	pack $canvas -expand yes -fill both -padx 2 -pady {2 0}

	$sbar configure -command [list $canvas xview]
	$canvas configure -xscrollcommand [list $sbar set]

	# Initializes the max icon/text width and height and other variables

    XColor *selectColor,	/* color when selected */
    XColor *disableColor,	/* color when disabled */
    int on,			/* are we on? */
    int disabled,		/* are we disabled? */
    int mode)			/* kind of indicator to draw */
{
    int ix, iy;
    int dimW, dimWI, dimH, dimHI;
    int imgsel, imgstart;
    TkBorder *bg_brdr = (TkBorder*)bgBorder;
    XGCValues gcValues;
    GC copyGC;
    unsigned long imgColors[8];
    XImage *img;
    Pixmap pixmap;

    if (selectColor == NULL) {
	selectColor = bg_brdr->bgColorPtr;
    }

    depth = Tk_Depth(tkwin);

    ScreenGetMMWidthHeight(display, DefaultScreenOfDisplay(display),
	    &dimW, &dimWI, &dimH, &dimHI);
    if ((dimHI/dimH) > (dimWI/dimW)) {
	dimW = dimH;
	dimWI = dimHI;
    }
    dimWI *= 2;
    dimWI /= dimW;
    if (dimWI < 11) {
	/* < 140 DPI */
	button_images = button_images_small;
	img_dim = &img_dim_small;
    } else {
	button_images = button_images_large;
	img_dim = &img_dim_large;
    }

    /*
     * Compute starting point and dimensions of image inside button_images to
     * be used.
     */

    switch (mode) {
    default:
    case CHECK_BUTTON:
	imgsel = on == 2 ? CHECK_DISON_OFFSET :
		on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
	imgsel += disabled && on != 2 ? CHECK_DISOFF_OFFSET : 0;
	imgstart = CHECK_START;
	dimW = CHECK_BUTTON_DIM;
	break;

    case CHECK_MENU:
	imgsel = on == 2 ? CHECK_DISOFF_OFFSET :
		on == 1 ? CHECK_ON_OFFSET : CHECK_OFF_OFFSET;
	imgsel += disabled && on != 2 ? CHECK_DISOFF_OFFSET : 0;
	imgstart = CHECK_START + CHECK_START_YOFFSET;
	imgsel += CHECK_START_XOFFSET;
	dimW = CHECK_MENU_DIM;
	break;

    case RADIO_BUTTON:
	imgsel = on == 2 ? RADIO_DISON_OFFSET :
		on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
	imgsel += disabled && on != 2 ? RADIO_DISOFF_OFFSET : 0;
	imgstart = RADIO_START;
	dimW = RADIO_BUTTON_DIM;
	break;

    case RADIO_MENU:
	imgsel = on == 2 ? RADIO_DISOFF_OFFSET :
		on==1 ? RADIO_ON_OFFSET : RADIO_OFF_OFFSET;
	imgsel += disabled && on != 2 ? RADIO_DISOFF_OFFSET : 0;
	imgstart = RADIO_START + RADIO_START_YOFFSET;
	imgsel += RADIO_START_XOFFSET;
	dimW = RADIO_MENU_DIM;
	break;
    }

    /*
     * Allocate the drawing areas to use. Note that we use double-buffering
     * here because not all code paths leading to this function do so.
     */

    /*
     * Double image when density above 280 DPI.
     */

    if (dimWI < 22) {
	dimWI = dimW;
    } else {
	dimWI = dimW * 2;
    }

    pixmap = Tk_GetPixmap(display, d, dimWI, dimWI, depth);
    if (pixmap == None) {
	return;
    }

    x -= dimWI/2;
    y -= dimWI/2;

    img = XGetImage(display, pixmap, 0, 0,
	    (unsigned int)dimWI, (unsigned int)dimWI, AllPlanes, ZPixmap);
    if (img == NULL) {
	return;
    }

    /*
     * Set up the color mapping table.
     */

    imgColors[7 /*H*/] =
	    Tk_GetColorByValue(tkwin, disableColor)->pixel;

    /*
     * Create the image, painting it into an XImage one pixel at a time.
     */

    for (iy=0 ; iy<dimW ; iy++) {
	if (dimWI > dimW) {
	    for (ix=0 ; ix<dimW ; ix++) {
		XPutPixel(img, ix * 2, iy * 2,
		    imgColors[button_images[imgstart+iy][imgsel+ix] - 'A']);
		XPutPixel(img, ix * 2 + 1, iy * 2,
		    imgColors[button_images[imgstart+iy][imgsel+ix] - 'A']);
		XPutPixel(img, ix * 2, iy * 2 + 1,
		    imgColors[button_images[imgstart+iy][imgsel+ix] - 'A']);
		XPutPixel(img, ix * 2 + 1, iy * 2 + 1,
		    imgColors[button_images[imgstart+iy][imgsel+ix] - 'A']);
	    }
	} else {
	    for (ix=0 ; ix<dimW ; ix++) {
		XPutPixel(img, ix, iy,
		    imgColors[button_images[imgstart+iy][imgsel+ix] - 'A']);
	    }
	}
    }

    /*
     * Copy onto our target drawable surface.
     */

    memset(&gcValues, 0, sizeof(gcValues));
    gcValues.background = bg_brdr->bgColorPtr->pixel;
    gcValues.graphics_exposures = False;
    copyGC = Tk_GetGC(tkwin, 0, &gcValues);

    XPutImage(display, pixmap, copyGC, img, 0, 0, 0, 0,
	    (unsigned)dimWI, (unsigned)dimWI);
    XCopyArea(display, pixmap, d, copyGC, 0, 0,
	    (unsigned)dimWI, (unsigned)dimWI, x, y);

    /*
     * Tidy up.
     */

    Tk_FreeGC(display, copyGC);
    XDestroyImage(img);

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

void
TkpComputeMenuButtonGeometry(
    TkMenuButton *mbPtr)	/* Widget record for menu button. */
{
    int width, height;
    int	avgWidth, txtWidth, txtHeight;
    int haveImage = 0, haveText = 0;
    Tk_FontMetrics fm;

    mbPtr->inset = mbPtr->highlightWidth + mbPtr->borderWidth;

    width = 0;

    if (! haveImage) {
	width += 2*mbPtr->padX;
	height += 2*mbPtr->padY;
    }

    if (mbPtr->indicatorOn) {
	int mmW, mmH, pixW, pixH;

	ScreenGetMMWidthHeight(mbPtr->display, Tk_Screen(mbPtr->tkwin),
		&mmW, &pixW, &mmH, &pixH);
	if ((pixH/mmH) > (pixW/mmW)) {
	    mmW = mmH;
	    pixW = pixH;
	}
	mbPtr->indicatorHeight= (INDICATOR_HEIGHT * pixW)/(10*mmW);
	mbPtr->indicatorWidth = (INDICATOR_WIDTH * pixW)/(10*mmW)
		+ 2*mbPtr->indicatorHeight;
	width += mbPtr->indicatorWidth;
    } else {
	mbPtr->indicatorHeight = 0;
	mbPtr->indicatorWidth = 0;
    }

            break;
        }

        mWidth = width;
        mHeight = height;
        DisplayMetrics dm = new DisplayMetrics();
        mDisplay.getMetrics(dm);
        int rot = mDisplay.getRotation();
        if (rot == Surface.ROTATION_90 || rot == Surface.ROTATION_270) {
            SDLActivity.onNativeResize(width, height, sdlFormat,
                                       (int) dm.ydpi, (int) dm.xdpi);
        } else {
            SDLActivity.onNativeResize(width, height, sdlFormat,
                                       (int) dm.xdpi, (int) dm.ydpi);
        }
        Log.v(TAG, "Window size: " + width + "x" + height);
        dm = null;

        // Set mIsSurfaceReady to 'true' *before* making a call to handleResume
        SDLActivity.mIsSurfaceReady = true;
        SDLActivity.onNativeSurfaceChanged();