JFrame 仅可调整高度

Question

JFrame.setResizable(true) 允许用户调整窗口的宽度和高度。是否存在允许用户仅调整高度大小的方法？

谢谢。

编辑：以下解决方案似乎不起作用。在 360x600 JFrame 上，

setResizable(true);
pack();
setMaximizedBounds(new java.awt.Rectangle(0, 0, 360, 1200));
setMaximumSize(new java.awt.Dimension(360, 1200));
setMinimumSize(new java.awt.Dimension(360, 600));
setPreferredSize(new java.awt.Dimension(360, 600));
setVisible(true);

Still 允许完全拉伸 JFrame 的宽度，并且设置 setResizes(false) 不允许拉伸任何内容。

Answer 1

下面的代码可以正确完成工作。

addComponentListener(new ComponentAdapter() {

    @Override
    public void componentResized(ComponentEvent e) {
        setSize(new Dimension(preferredWidth, getHeight()));
        super.componentResized(e);
    }

});

Answer 2

如果您有 JNI 经验，那么这是一个可能的解决方案。

在 Windows 和 Oracle Hotspot 中，此代码将允许在最小和最大尺寸之间调整窗口大小，而不会闪烁或导致任何令人讨厌的 JFrame 调整大小后副作用。如果在创建 JFrame 并使其可见后调用此代码，则可以完全取消上面在 componentResized() 中用于捕获调整大小事件的代码，因为 Windows 具有防止用户能够调整上方或下方大小的功能指定的最小/最大尺寸。

// Java 代码：

static {
    if (System.getProperty("sun.arch.data.model").equals("32"))
    {   // 32-bit JVM
        System.loadLibrary("my32bitdll");
        System.out.println("Running 32-bit JVM");

    } else {
        // 64-bit JVM
        System.loadLibrary("my64bitdll");
        System.out.println("Running 64-bit JVM");
    }
}
// Sets a window to never be resized above or below these minimum widths/heights
public static native int setMinMaxResizeBoundaries(int hwnd, int minWidth, int minHeight, int maxWidth, int maxHeight);

// C++ 代码（包括标准 windows.h、winbase.h 等）

// Global variables defined in DllMain.cpp
// Used for setMinMaxResizeBoundaries()
struct SHwndMinMax
{
    HWND    hwnd;
    int     minWidth;
    int     minHeight;
    int     maxWidth;
    int     maxHeight;
    WNDPROC prefWndProc;
};
SHwndMinMax gsHwndMinMax[2048];
int gsHwndMinMaxCount = 0;
LRESULT CALLBACK MinMaxWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);


// Code added somwhere:
// setMinMaxResizeBoundaries()
// Sets the resize boundary window sizes, so the window will not be resized above/below that size
JNIEXPORT jint JNICALL Java_your_class_here_setMinMaxResizeBoundaries(JNIEnv* env, jclass cls,
    jint hwnd,
    jint minWidth, jint minHeight,
    jint maxWidth, jint maxHeight)
{
    // We create a hook for the window, and intercept the WM_GETMINMAXINFO message occurs, and update the info
    if (IsWindow((HWND)hwnd))
    {   // Let's add it
        if (gsHwndMinMaxCount < 2048)
        {   // We're good
            // Can add code here to check if this option is valid or not--so it can later be "unhooked" by a separate function call
            gsHwndMinMax[gsHwndMinMaxCount].hwnd        = (HWND)hwnd;
            gsHwndMinMax[gsHwndMinMaxCount].minWidth    = minWidth;
            gsHwndMinMax[gsHwndMinMaxCount].minHeight   = minHeight;
            gsHwndMinMax[gsHwndMinMaxCount].maxWidth    = maxWidth;
            gsHwndMinMax[gsHwndMinMaxCount].maxHeight   = maxHeight;
            gsHwndMinMax[gsHwndMinMaxCount].prefWndProc = (WNDPROC)SetWindowLongPtr((HWND)hwnd, GWLP_WNDPROC, (LONG_PTR)&MinMaxWindowProc);
            // Success
            ++gsHwndMinMaxCount;
            return(0);

        } else {
            // Failuire, too many hooks
            return(-2);
        }

    } else {
        // Failure, HWND is not valid
        return(-1);
    }
}

LRESULT CALLBACK MinMaxWindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    int i;
    MINMAXINFO* mmi;

    for (i = 0; i < gsHwndMinMaxCount; i++)
    {
        if (hwnd == gsHwndMinMax[i].hwnd)
        {   // This is our man, see if it's our message
            if (msg == WM_GETMINMAXINFO)
            {   // It is
                // When maximized, window is at upper-left
                mmi = (MINMAXINFO*)lParam;
                mmi->ptMaxSize.x        = gsHwndMinMax[i].maxWidth;
                mmi->ptMaxSize.y        = gsHwndMinMax[i].maxHeight;
                mmi->ptMaxPosition.x    = 0;  // Can add code here to properly position the window centered in the screen, etc.
                mmi->ptMaxPosition.y    = 0;  // Same here
                // Set the minimum and maximum tracking size (when the user is resizing, what's the smallest and biggest window they see)
                mmi->ptMinTrackSize.x   = gsHwndMinMax[i].minWidth;
                mmi->ptMinTrackSize.y   = gsHwndMinMax[i].minHeight;
                mmi->ptMaxTrackSize.x   = gsHwndMinMax[i].maxWidth;
                mmi->ptMaxTrackSize.y   = gsHwndMinMax[i].maxHeight;
                return(DefWindowProc(hwnd, msg, wParam, lParam));

            } else {
                // Nope, pass it on
                return(CallWindowProc(gsHwndMinMax[i].prefWndProc, hwnd, msg, wParam, lParam));
            }
        }
    }
    return(0);
}

// 以下是准确获取 HWND 的代码：

// Java 代码（添加到上面的 Java 代码

// Returns the HWND for the specified component, or -1 if does not exist
public static native int getComponentHWND(Component c);

中） // C++ 代码

// getComponentHWND()
// Called to return the HWND of the component, if it has one.
JNIEXPORT jint JNICALL Java_your_class_here_getComponentHWND(JNIEnv* env, jclass cls, jobject obj)
{
    HWND hWnd = 0;
    typedef jboolean (JNICALL *PJAWT_GETAWT)(JNIEnv*, JAWT*);
    JAWT awt;
    JAWT_DrawingSurface* ds;
    JAWT_DrawingSurfaceInfo* dsi;
    JAWT_Win32DrawingSurfaceInfo* dsi_win;
    jboolean result;
    jint lock;
    HMODULE _hAWT = 0;

    // Load AWT Library
    if (!_hAWT)
        _hAWT = LoadLibrary(L"jawt.dll");   // for Java 1.4+

    if (!_hAWT)
        _hAWT = LoadLibrary(L"awt.dll");    // for Java 1.3

    if (_hAWT)
    {
        PJAWT_GETAWT JAWT_GetAWT = (PJAWT_GETAWT)GetProcAddress(_hAWT, "JAWT_GetAWT");
        if (JAWT_GetAWT)
        {
            awt.version = JAWT_VERSION_1_4;     // Init here with JAWT_VERSION_1_3 or JAWT_VERSION_1_4
            // Get AWT API Interface
            result = JAWT_GetAWT(env, &awt);
            if (result != JNI_FALSE)
            {
                ds = awt.GetDrawingSurface(env, obj);
                if (ds != NULL)
                {
                    lock = ds->Lock(ds);
                    if ((lock & JAWT_LOCK_ERROR) == 0)
                    {
                        dsi = ds->GetDrawingSurfaceInfo(ds);
                        if (dsi)
                        {
                            dsi_win = (JAWT_Win32DrawingSurfaceInfo*)dsi->platformInfo;
                            if (dsi_win)
                                hWnd = dsi_win->hwnd;
                            else
                                hWnd = (HWND) -1;   // Failed to obtain the handle (not running on Windows)

                            ds->FreeDrawingSurfaceInfo(dsi);

                        } else {
                            hWnd = (HWND)-2;    // Failed to get the drawing surface info block
                        }
                        ds->Unlock(ds);

                    } else {
                        hWnd = (HWND)-3;    // Failed to lock the drawing surface to obtain information about it
                    }
                    awt.FreeDrawingSurface(ds);

                } else {
                    hWnd = (HWND)-4;    // Failed to get the drawing surface from the compoment
                }
            } else {
                hWnd = (HWND)-5;    // Failed to obtain a proper result from _JAWT_GetAWT()
            }
        } else {
            hWnd = (HWND)-6;    // Failed to find "_JAWT_GetAWT()" function
        }
    } else {
        hWnd = (HWND)-7;    // Failed to load awt.dll
    }
    return (jint)hWnd;
}

Answer 3

我认为没有一种方法明确用于此目的。但是，您可以预设 JFrame 的首选尺寸、最小尺寸和最大尺寸，以使宽度全部相等。

Dimension dimPreferred = frame.getPreferedSize();
Dimension dimMinimum = frame.getMinimumSize();
Dimension dimMaximum = frame.getMaximumSize();
dimPreferred.setWidth( FIXED_WIDTH );
dimMinimum.setWidth( FIXED_WIDTH );
dimMaximum.setWidth( FIXED_WIDTH );
frame.setPreferredSize( dimPreferred );
frame.setMinimumSize( dimMinimum );
frame.setMaximumSize( dimMaximum );

您可能希望在frame.pack()之后和frame.setVisible(true)之前执行此操作。

Answer 4

我相信大多数平台都会尊重 setMaximumSize 和 setMinimumSize。还有setMaximizedBounds。

不起作用的是添加一个侦听器来重置宽度。线程问题使它看起来不愉快。如果您有 PL&F 装饰的窗口（Windows PL&F 不支持），那么它们可能会被黑客攻击。

Answer 5

使用 setResizing(false) 而不是 setResizable(true)
事实上 setResizable(false) 为我解决了这个问题。 它甚至禁用了最大化（使图标变暗）

好吧，我应该更好地解释自己。我也想让可调整大小的东西发挥作用。这就是我提出这个问题的原因。但我最终还是同意了，认为这会对OP有所帮助。

我也想做可调整大小的操作，但我想如果我无法调整大小来工作，禁用会更好，因为它不会弄乱您的内容放置。我想我会建议将其作为解决方案。

Answer 6

为了避免闪烁，您可以重写 JFrame 中的 #setBounds 方法。似乎每次调整大小都会调用它。类似的东西

@Override
public void setBounds(int x, int y, int width, int height) {
    if (width == FIXED_WIDTH) {
        super.setBounds(x, y, width, height);
    }
}

对我有用。

Answer 7

我正是出于此目的使用此代码并且它有效（它实际上是编辑的@Hoazhun解决方案，因为他的原始代码将锁定宽度和高度，但在我的版本中，您可以手动设置高度，但具有宽度固定的）：

int defWindowW = 300;
int defWindowH = 600;
JFrame MAIN_WINDOW = new JFrame();

MAIN_WINDOW.addComponentListener(new ComponentAdapter() {

    public void componentResized(ComponentEvent e) {

        int W = Integer.parseInt(e.paramString().split(",")[1].split(" ")[1].split("x")[0].replace(")", ""));
        int H = Integer.parseInt(e.paramString().split(",")[1].split(" ")[1].split("x")[1].replace(")", ""));

        /* FOR FIXED WIDTH - ACTIVE NOW, COMMENT IT OUT FOR DISABLING*/ MAIN_WINDOW.setSize(new Dimension(defWindowW, H));
        
        /* FOR FIXED HEIGHT - UNCOMMENT TO MAKE IT ACTIVE */
        //MAIN_WINDOW.setSize(new Dimension(W, defWindowH));

        super.componentResized(e);
    }
});