Einstellung der Größe des inneren Bereichs des Java SWT-Shell-Fensters

Question

Wie kann ich in einem Java SWT-Shell-Fenster die innere Größe des Fensters gegenüber der Größe des gesamten Fensterrahmens festlegen?

Wenn ich zum Beispiel shell.setSize(300, 250) verwende, wird das gesamte Fenster genau 300x250 groß. Diese 300x250 umfassen die Größe des Fensterrahmens.

Wie kann ich stattdessen die innere Größe, d.h. den Anzeigebereich des Shell-Fensters, auf 300x250 einstellen? Das ist diese 300x250 schließt die Breite des Fensterrahmens.

Ich habe versucht, einige Offset-Werte zu verringern, aber die Sache ist, dass verschiedene Betriebssysteme unterschiedliche Fensterrahmengrößen haben. So mit einem konstanten Offset wäre nicht genau sein.

Gracias.

Answer 1

Aus Ihrer Frage habe ich entnommen, dass Sie die Dimension des Client Area . Und im SWT-Jargon ist es definiert als a rectangle which describes the area of the receiver which is capable of displaying data (that is, not covered by the "trimmings").

Sie können nicht direkt die Dimension von Client Area weil es dafür keine API gibt. Sie können dies jedoch mit einem kleinen Hack erreichen. Im folgenden Beispielcode möchte ich, dass mein Kundenbereich wie folgt aussieht 300 by 250 . Um dies zu erreichen, habe ich die shell.addShellListener() Ereignishörer. Wenn die Shell vollständig aktiv ist (siehe die public void shellActivated(ShellEvent e) ), dann berechne ich die verschiedenen Ränder und lege wieder die Größe meiner Schale fest. Durch das Berechnen und Zurücksetzen der Schalengröße erhalte ich die gewünschte Schalengröße.

>>Code:

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ShellEvent;
import org.eclipse.swt.events.ShellListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;

public class MenuTest {

    public static void main (String [] args) 
    {
        Display display = new Display ();
        final Shell shell = new Shell (display);

        GridLayout layout = new GridLayout();
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        layout.horizontalSpacing = 0;
        layout.verticalSpacing = 0;
        layout.numColumns = 1;
        shell.setLayout(layout);
        shell.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true,true));
        final Menu bar = new Menu (shell, SWT.BAR);
        shell.setMenuBar (bar);

        shell.addShellListener(new ShellListener() {

            public void shellIconified(ShellEvent e) {
            }
            public void shellDeiconified(ShellEvent e) {
            }
            public void shellDeactivated(ShellEvent e) {
            }
            public void shellClosed(ShellEvent e) {
                System.out.println("Client Area: " + shell.getClientArea());
            }
            public void shellActivated(ShellEvent e) {
                int frameX = shell.getSize().x - shell.getClientArea().width;
                int frameY = shell.getSize().y - shell.getClientArea().height;
                shell.setSize(300 + frameX, 250 + frameY);
            }
        });     

        shell.open ();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch ()) display.sleep ();
        }
        display.dispose ();
    }
}

Answer 2

Wenn ich Sie richtig verstehe, sollten Sie die Größe der inneren Komponente auf die benötigte Größe einstellen und die Methode pack() (des Rahmens).

Answer 3

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;

public class SWTClientAreaTest
{
    Display display;
    Shell shell;
    final int DESIRED_CLIENT_AREA_WIDTH = 300;
    final int DESIRED_CLIENT_AREA_HEIGHT = 200;

    void render()
    {
        display = Display.getDefault();
        shell = new Shell(display, SWT.SHELL_TRIM | SWT.CENTER);

        Point shell_size = shell.getSize();
        Rectangle client_area = shell.getClientArea();

        shell.setSize
        (
            DESIRED_CLIENT_AREA_WIDTH + shell_size.x - client_area.width,
            DESIRED_CLIENT_AREA_HEIGHT + shell_size.y - client_area.height
        );

        shell.open();

        while (!shell.isDisposed()) 
        {
            if (!display.readAndDispatch()) 
            {
                display.sleep();
            }
        }

        display.dispose();
    }

    public static void main(String[] args)
    {
        SWTClientAreaTest appl = new SWTClientAreaTest();
        appl.render();
    }
}

Answer 4

使用する computeTrim um die Grenzen zu berechnen, die für die Anzeige eines bestimmten Kundenbereichs erforderlich sind. Die Methode gibt ein Rechteck zurück, das die Grenzen beschreibt, die erforderlich sind, um Platz für den in den Argumenten angegebenen Kundenbereich zu schaffen.

In diesem Beispiel wird die Größe der Shell so eingestellt, dass sie einen Client-Bereich von 100 x 200 (Breite x Höhe) anzeigen kann:

Rectangle bounds = shell.computeTrim(0, 0, 100, 200);
shell.setSize(bounds.width, bounds.height);

Dieser Artikel beschreibt die von SWT verwendeten Begriffe für Widget-Dimensionen: https://www.eclipse.org/articles/Article-Understanding-Layouts/Understanding-Layouts.htm