精华内容
下载资源
问答
  • 修改游戏窗口大小
    2021-12-10 10:39:01
    1. 打开Doxbox安装路径,找到DOXBox 0.74-2 Option.bat,双击打开。
    2. 找到windowresolution和output,将其值修改为下图中的值。

     

    注意:图中,1280x800   “x”  是字母 ,不是 乘号 “*”  

    更多相关内容
  • 今天小编就为大家分享一篇关于易语言更改指定窗口位置和大小的方法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 窗口大小调整工具.zip

    2021-04-30 14:10:15
    这是一个窗口大小调整工具(winxmove),无需安装直接打开.exe文件使用,启动后直接在后台显示。该工具也是支持视频录制的,也可以拖动游戏窗口的大小。 使用方法: ①启动后按住 ALT 键; ②将鼠标移到窗口中; ③...
  • 任意修改窗口大小,自定义窗口的宽高比!还可以调整窗口在桌面上的坐标位!
  • 窗口更改大小

    2015-08-10 13:25:24
    改变窗口大小,使用于固定窗口的网游类,单机类游戏
  • VC++源码 一个窗口工具,拖拽图标到窗口释放鼠标获取目标窗口句柄,获取目标窗口的标题,坐标,大小(区域),可改变窗口的位置和大小,可以使目标窗口置顶或取消置顶(快捷键Alt+F10)
  • 整体来说我们需要修改两个文件,第一个index.html、第...压缩包内有修改前与修改后的内容。可参考修改!!! 下面是文章修改链接具体修改可供参考: https://blog.csdn.net/weixin_43392473/article/details/124553861
  • Unity win平台 调整窗口大小强制固定比例

    千次阅读 热门讨论 2021-02-07 11:10:25
    它通过拦截窗口调整大小事件(特别是WinProc回调函数)并对其进行修改以保持所需的宽高比来工作。 using UnityEngine; using System; using System.Collections; using System.Runtime.InteropServices; using...

    我写了一个脚本,对独立的Windows版本(仅Windows,32/64位)强制执行任意宽高比。
    它通过拦截窗口调整大小事件(特别是WinProc回调函数)并对其进行修改以保持所需的宽高比来工作。

    AspectRatioController.cs添加到场景中的任何GameObject。然后在Inspector中设置所需的纵横比和最小分辨率值。

    using UnityEngine;
    using System;
    using System.Collections;
    using System.Runtime.InteropServices;
    using System.Text;
    using UnityEngine.Events;
    
    /// <summary>
    ///强制设置Unity游戏窗口的长宽比。你可以调整窗口的大小,他会强制保持一定比例
    ///通过拦截窗口大小调整事件(WindowProc回调)并相应地修改它们来实现的
    ///也可以用像素为窗口设置最小/最大宽度和高度
    ///长宽比和最小/最大分辨率都与窗口区域有关,标题栏和边框不包括在内
    ///该脚本还将在应用程序处于全屏状态时强制设置长宽比。当你切换到全屏,
    ///应用程序将自动设置为当前显示器上可能的最大分辨率,而仍然保持固定比。如果显示器没有相同的宽高比,则会在左/右或上/下添加黑条
    ///确保你在PlayerSetting中设置了“Resizable Window”,否则无法调整大小
    ///如果取消不支持的长宽比在PlayerSetting中设置“Supported Aspect Rations”
    ///注意:因为使用了WinAPI,所以只能在Windows上工作。在Windows 10上测试过
    /// </summary>
    public class AspectRatioController : MonoBehaviour
    {
        /// <summary>
        /// 每当窗口分辨率改变或用户切换全屏时,都会触发此事件
        ///  参数是新的宽度、高度和全屏状态(true表示全屏)
        /// </summary>
        public ResolutionChangedEvent resolutionChangedEvent;
        [Serializable]
        public class ResolutionChangedEvent : UnityEvent<int, int, bool> { }
    
        // 如果为false,则阻止切换到全屏
        [SerializeField]
        private bool allowFullscreen = true;
    
        // 长宽比的宽度和高度
        [SerializeField]
        private float aspectRatioWidth = 16;
        [SerializeField]
        private float aspectRatioHeight = 9;
    
        // 最小值和最大值的窗口宽度/高度像素
        [SerializeField]
        private int minWidthPixel = 512;
        [SerializeField]
        private int minHeightPixel = 512;
        [SerializeField]
        private int maxWidthPixel = 2048;
        [SerializeField]
        private int maxHeightPixel = 2048;
    
        // 当前锁定长宽比。
        private float aspect;
    
        // 窗口的宽度和高度。不包括边框和窗口标题栏
        // 当调整窗口大小时,就会设置这些值
        private int setWidth = -1;
        private int setHeight = -1;
    
        // 最后一帧全屏状态。
        private bool wasFullscreenLastFrame;
    
        // 是否初始化了AspectRatioController
        // 一旦注册了WindowProc回调函数,就将其设置为true
        private bool started;
    
        // 显示器的宽度和高度。这是窗口当前打开的监视器
        private int pixelHeightOfCurrentScreen;
        private int pixelWidthOfCurrentScreen;
    
        //一旦用户请求终止applaction,则将其设置为true
        private bool quitStarted;
    
        // WinAPI相关定义
        #region WINAPI
    
        // 当窗口调整时,WM_SIZING消息通过WindowProc回调发送到窗口
        private const int WM_SIZING = 0x214;
    
        // WM大小调整消息的参数
        private const int WMSZ_LEFT = 1;
        private const int WMSZ_RIGHT = 2;
        private const int WMSZ_TOP = 3;
        private const int WMSZ_BOTTOM = 6;
    
        // 获取指向WindowProc函数的指针
        private const int GWLP_WNDPROC = -4;
    
        // 委托设置为新的WindowProc回调函数
        private delegate IntPtr WndProcDelegate(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);
        private WndProcDelegate wndProcDelegate;
    
        // 检索调用线程的线程标识符
        [DllImport("kernel32.dll")]
        private static extern uint GetCurrentThreadId();
    
        // 检索指定窗口所属类的名称
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern int GetClassName(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
    
        // 通过将句柄传递给每个窗口,依次传递给应用程序定义的回调函数,枚举与线程关联的所有非子窗口
        [DllImport("user32.dll")]
        private static extern bool EnumThreadWindows(uint dwThreadId, EnumWindowsProc lpEnumFunc, IntPtr lParam);
        private delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
    
        // 将消息信息传递给指定的窗口过程
        [DllImport("user32.dll")]
        private static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
    
        // 检索指定窗口的边框的尺寸
        // 尺寸是在屏幕坐标中给出的,它是相对于屏幕左上角的
        [DllImport("user32.dll", SetLastError = true)]
        private static extern bool GetWindowRect(IntPtr hwnd, ref RECT lpRect);
    
        //检索窗口客户区域的坐标。客户端坐标指定左上角
        //以及客户区的右下角。因为客户机坐标是相对于左上角的
        //在窗口的客户区域的角落,左上角的坐标是(0,0)
        [DllImport("user32.dll")]
        private static extern bool GetClientRect(IntPtr hWnd, ref RECT lpRect);
    
        // 更改指定窗口的属性。该函数还将指定偏移量的32位(长)值设置到额外的窗口内存中
        [DllImport("user32.dll", EntryPoint = "SetWindowLong", CharSet = CharSet.Auto)]
        private static extern IntPtr SetWindowLong32(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
    
        //更改指定窗口的属性。该函数还在额外的窗口内存中指定的偏移量处设置一个值
        [DllImport("user32.dll", EntryPoint = "SetWindowLongPtr", CharSet = CharSet.Auto)]
        private static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
    
        //用于查找窗口句柄的Unity窗口类的名称
        private const string UNITY_WND_CLASSNAME = "UnityWndClass";
    
        // Unity窗口的窗口句柄
        private IntPtr unityHWnd;
    
        // 指向旧WindowProc回调函数的指针
        private IntPtr oldWndProcPtr;
    
        // 指向我们自己的窗口回调函数的指针
        private IntPtr newWndProcPtr;
    
        /// <summary>
        /// WinAPI矩形定义。
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int Left;
            public int Top;
            public int Right;
            public int Bottom;
        }
    
        #endregion
    
        void Start()
        {
            // 不要在Unity编辑器中注册WindowProc回调函数,它会指向Unity编辑器窗口,而不是Game视图
    
    #if !UNITY_EDITOR
            //注册回调,然后应用程序想要退出
            Application.wantsToQuit += ApplicationWantsToQuit;
    
            // 找到主Unity窗口的窗口句柄
            EnumThreadWindows(GetCurrentThreadId(), (hWnd, lParam) =>
            {
                var classText = new StringBuilder(UNITY_WND_CLASSNAME.Length + 1);
                GetClassName(hWnd, classText, classText.Capacity);
    
                if (classText.ToString() == UNITY_WND_CLASSNAME)
                {
                    unityHWnd = hWnd;
                    return false;
                }
                return true;
            }, IntPtr.Zero);
    
            // 将长宽比应用于当前分辨率
            SetAspectRatio(aspectRatioWidth, aspectRatioHeight, true);
    
            // 保存当前的全屏状态
            wasFullscreenLastFrame = Screen.fullScreen;
    
            // Register (replace) WindowProc callback。每当一个窗口事件被触发时,这个函数都会被调用
            //例如调整大小或移动窗口
            //保存旧的WindowProc回调函数,因为必须从新回调函数中调用它
            wndProcDelegate = wndProc;
            newWndProcPtr = Marshal.GetFunctionPointerForDelegate(wndProcDelegate);
            oldWndProcPtr = SetWindowLong(unityHWnd, GWLP_WNDPROC, newWndProcPtr);
    
            // 初始化完成
            started = true;
    #endif
    
        }
    
        /// <summary>
        ///将目标长宽比设置为给定的长宽比。
        /// </summary>
        /// <param name="newAspectWidth">宽高比的新宽度</param>
        /// <param name="newAspectHeight">纵横比的新高度</param>
        /// <param name="apply">true,当前窗口分辨率将立即调整以匹配新的纵横比 false,则只在下次手动调整窗口大小时执行此操作</param>
        public void SetAspectRatio(float newAspectWidth, float newAspectHeight, bool apply)
        {
            //计算新的纵横比
            aspectRatioWidth = newAspectWidth;
            aspectRatioHeight = newAspectHeight;
            aspect = aspectRatioWidth / aspectRatioHeight;
    
            // 调整分辨率以匹配长宽比(触发WindowProc回调)
            if (apply)
            {
                Screen.SetResolution(Screen.width, Mathf.RoundToInt(Screen.width / aspect), Screen.fullScreen);
            }
        }
    
        /// <summary>
        /// WindowProc回调。应用程序定义的函数,用来处理发送到窗口的消息 
        /// </summary>
        /// <param name="msg">用于标识事件的消息</param>
        /// <param name="wParam">额外的信息信息。该参数的内容取决于uMsg参数的值 </param>
        /// <param name="lParam">其他消息的信息。该参数的内容取决于uMsg参数的值 </param>
        /// <returns></returns>
        IntPtr wndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
        {
            // 检查消息类型
            // resize事件
            if (msg == WM_SIZING)
            {
                // 获取窗口大小结构体
                RECT rc = (RECT)Marshal.PtrToStructure(lParam, typeof(RECT));
    
                // 计算窗口边框的宽度和高度
                RECT windowRect = new RECT();
                GetWindowRect(unityHWnd, ref windowRect);
    
                RECT clientRect = new RECT();
                GetClientRect(unityHWnd, ref clientRect);
    
                int borderWidth = windowRect.Right - windowRect.Left - (clientRect.Right - clientRect.Left);
                int borderHeight = windowRect.Bottom - windowRect.Top - (clientRect.Bottom - clientRect.Top);
    
                // 在应用宽高比之前删除边框(包括窗口标题栏)
                rc.Right -= borderWidth;
                rc.Bottom -= borderHeight;
    
                // 限制窗口大小
                int newWidth = Mathf.Clamp(rc.Right - rc.Left, minWidthPixel, maxWidthPixel);
                int newHeight = Mathf.Clamp(rc.Bottom - rc.Top, minHeightPixel, maxHeightPixel);
    
                // 根据纵横比和方向调整大小
                switch (wParam.ToInt32())
                {
                    case WMSZ_LEFT:
                        rc.Left = rc.Right - newWidth;
                        rc.Bottom = rc.Top + Mathf.RoundToInt(newWidth / aspect);
                        break;
                    case WMSZ_RIGHT:
                        rc.Right = rc.Left + newWidth;
                        rc.Bottom = rc.Top + Mathf.RoundToInt(newWidth / aspect);
                        break;
                    case WMSZ_TOP:
                        rc.Top = rc.Bottom - newHeight;
                        rc.Right = rc.Left + Mathf.RoundToInt(newHeight * aspect);
                        break;
                    case WMSZ_BOTTOM:
                        rc.Bottom = rc.Top + newHeight;
                        rc.Right = rc.Left + Mathf.RoundToInt(newHeight * aspect);
                        break;
                    case WMSZ_RIGHT + WMSZ_BOTTOM:
                        rc.Right = rc.Left + newWidth;
                        rc.Bottom = rc.Top + Mathf.RoundToInt(newWidth / aspect);
                        break;
                    case WMSZ_RIGHT + WMSZ_TOP:
                        rc.Right = rc.Left + newWidth;
                        rc.Top = rc.Bottom - Mathf.RoundToInt(newWidth / aspect);
                        break;
                    case WMSZ_LEFT + WMSZ_BOTTOM:
                        rc.Left = rc.Right - newWidth;
                        rc.Bottom = rc.Top + Mathf.RoundToInt(newWidth / aspect);
                        break;
                    case WMSZ_LEFT + WMSZ_TOP:
                        rc.Left = rc.Right - newWidth;
                        rc.Top = rc.Bottom - Mathf.RoundToInt(newWidth / aspect);
                        break;
                }
    
                // 保存实际分辨率,不包括边界
                setWidth = rc.Right - rc.Left;
                setHeight = rc.Bottom - rc.Top;
    
                // 添加边界
                rc.Right += borderWidth;
                rc.Bottom += borderHeight;
    
                // 触发分辨率更改事件
                resolutionChangedEvent.Invoke(setWidth, setHeight, Screen.fullScreen);
    
                // 回写更改的窗口参数
                Marshal.StructureToPtr(rc, lParam, true);
            }
    
            // 调用原始的WindowProc函数
            return CallWindowProc(oldWndProcPtr, hWnd, msg, wParam, lParam);
        }
    
        void Update()
        {
            // 如果不允许全屏,则阻止切换到全屏
            if (!allowFullscreen && Screen.fullScreen)
            {
                Screen.fullScreen = false;
            }
    
            if (Screen.fullScreen && !wasFullscreenLastFrame)
            {
                //切换到全屏检测,设置为最大屏幕分辨率,同时保持长宽比
                int height;
                int width;
    
                //根据当前长宽比和显示器的比例进行比较,上下或左右添加黑边
                bool blackBarsLeftRight = aspect < (float)pixelWidthOfCurrentScreen / pixelHeightOfCurrentScreen;
    
                if (blackBarsLeftRight)
                {
                    height = pixelHeightOfCurrentScreen;
                    width = Mathf.RoundToInt(pixelHeightOfCurrentScreen * aspect);
                }
                else
                {
                    width = pixelWidthOfCurrentScreen;
                    height = Mathf.RoundToInt(pixelWidthOfCurrentScreen / aspect);
                }
    
                Screen.SetResolution(width, height, true);
                resolutionChangedEvent.Invoke(width, height, true);
            }
            else if (!Screen.fullScreen && wasFullscreenLastFrame)
            {
                // 从全屏切换到检测到的窗口。设置上一个窗口的分辨率。
                Screen.SetResolution(setWidth, setHeight, false);
                resolutionChangedEvent.Invoke(setWidth, setHeight, false);
            }
            else if (!Screen.fullScreen && setWidth != -1 && setHeight != -1 && (Screen.width != setWidth || Screen.height != setHeight))
            {
                //根据高度设置宽度,因为Aero Snap不会触发WM_SIZING。
                setHeight = Screen.height;
                setWidth = Mathf.RoundToInt(Screen.height * aspect);
    
                Screen.SetResolution(setWidth, setHeight, Screen.fullScreen);
                resolutionChangedEvent.Invoke(setWidth, setHeight, Screen.fullScreen);
            }
            else if (!Screen.fullScreen)
            {
                // 保存当前屏幕的分辨率
                // 下次切换到全屏时,此分辨率将被设置为窗口分辨率
                // 只有高度,如果需要,宽度将根据高度和长宽比设置,以确保长宽比保持在全屏模式
                pixelHeightOfCurrentScreen = Screen.currentResolution.height;
                pixelWidthOfCurrentScreen = Screen.currentResolution.width;
            }
    
            //保存下一帧的全屏状态
            wasFullscreenLastFrame = Screen.fullScreen;
    
            // 当游戏窗口调整大小时,在编辑器中触发分辨率改变事件。
    #if UNITY_EDITOR
            if (Screen.width != setWidth || Screen.height != setHeight)
            {
                setWidth = Screen.width;
                setHeight = Screen.height;
                resolutionChangedEvent.Invoke(setWidth, setHeight, Screen.fullScreen);
            }
    #endif
        }
    
        /// <summary>
        /// 调用SetWindowLong32或SetWindowLongPtr64,取决于可执行文件是32位还是64位。
        /// 这样,我们就可以同时构建32位和64位的可执行文件而不会遇到问题。
        /// </summary>
        /// <param name="hWnd">The window handle.</param>
        /// <param name="nIndex">要设置的值的从零开始的偏移量</param>
        /// <param name="dwNewLong">The replacement value.</param>
        /// <returns>返回值是指定偏移量的前一个值。否则零.</returns>
        private static IntPtr SetWindowLong(IntPtr hWnd, int nIndex, IntPtr dwNewLong)
        {
            //32位系统
            if (IntPtr.Size == 4)
            {
                return SetWindowLong32(hWnd, nIndex, dwNewLong);
            }
            return SetWindowLongPtr64(hWnd, nIndex, dwNewLong);
        }
    
        /// <summary>
        /// 退出时调用。 返回false将中止并使应用程序保持活动。True会让它退出。
        /// </summary>
        /// <returns></returns>
        private bool ApplicationWantsToQuit()
        {
            //仅允许在应用程序初始化后退出。
            if (!started)
                return false;
    
            //延迟退出,clear up
            if (!quitStarted)
            {
                StartCoroutine("DelayedQuit");
                return false;
            }
    
            return true;
        }
    
        /// <summary>
        /// 恢复旧的WindowProc回调,然后退出。
        /// </summary>
        IEnumerator DelayedQuit()
        {
    
            // 重新设置旧的WindowProc回调,如果检测到WM_CLOSE,这将在新的回调本身中完成, 64位没问题,32位可能会造成闪退
    
            SetWindowLong(unityHWnd, GWLP_WNDPROC, oldWndProcPtr);
    
            yield return new WaitForEndOfFrame();
    
            quitStarted = true;
            Application.Quit();
        }
    }

    项目源码:https://download.csdn.net/download/u014661152/15116978

    展开全文
  • 改变游戏窗口

    2013-11-26 18:48:40
    钩子改变游戏窗口大小代码
  • Doxbox更改窗口大小

    2022-03-14 17:54:23
    Doxbox更改窗口大小: 在安装目录中找到以下配置文件 打开后找到windowresolution和output这两个选项,将其选项值修改为如下 windowresolution也可修改为其他任意分辨率

    Doxbox更改窗口大小:

    1. 在安装目录中找到以下配置文件
      找到DosBox 0.74 Options.bat文件并打开

    在这里插入图片描述

    1. 打开后找到windowresolution和output这两个选项,将其选项值修改为如下

    在这里插入图片描述
    windowresolution的值也可修改为其他任意分辨率(依据个人)

    如果不喜欢以上方式,也可在dosbox窗口点击alt+enter以全屏方式使用
    这种效果会更具有沉浸感(个人体会)

    展开全文
  • 1.可获取窗口标题,句柄,类名 2.可随意更改窗口标题 3.可随意更改窗口位置及大小(某些游戏窗口会有窗口固定比例保护) 3.可按照自己改过的大小一键自动排列
  • 1.Java 如何动态改变改变组件大小(跟随窗口)java(1)根据event消息进行动态改变,可是大神们说这样效率不高。小程序(2)根据窗口布局进行动态改变。下面有一个很好的例子,在一个论坛上看到的。具体在哪,记不得了。...

    1. Java 如何动态改变改变组件大小(跟随窗口)java

    (1)根据event消息进行动态改变,可是大神们说这样效率不高。小程序

    (2)根据窗口布局进行动态改变。下面有一个很好的例子,在一个论坛上看到的。具体在哪,记不得了。布局

    下面是程序显示窗口:this

    130541ae5a4d33b8cb003601541cf073.png

    import java.awt.BorderLayout;

    import java.awt.Color;

    import java.awt.Dimension;

    import javax.swing.JFrame;

    import javax.swing.JPanel;

    public class BorderLayoutTest

    {

    public static void main(String[] args)

    {

    JFrame frame = new JFrame("xxx");

    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    frame.setLocation(400, 200);

    frame.setLayout(new BorderLayout());

    JPanel left = new JPanel();

    left.setPreferredSize(new Dimension(300, 320));

    JPanel right = new JPanel();

    right.setPreferredSize(new Dimension(200, 320));

    left.setLayout(new BorderLayout());

    JPanel left_1 = new JPanel();

    left_1.setPreferredSize(new Dimension(300, 300));

    left_1.setBackground(Color.RED);

    JPanel left_2 = new JPanel();

    left_2.setPreferredSize(new Dimension(300, 100));

    left_2.setBackground(Color.GREEN);

    left.add(left_1, BorderLayout.CENTER);

    left.add(left_2, BorderLayout.SOUTH);

    right.setLayout(new BorderLayout());

    JPanel right_1 = new JPanel();

    right_1.setBackground(Color.WHITE);

    right_1.setPreferredSize(new Dimension(200, 100));

    JPanel right_2 = new JPanel();

    right_2.setBackground(Color.BLUE);

    right_2.setPreferredSize(new Dimension(200, 100));

    JPanel right_3 = new JPanel();

    right_3.setBackground(Color.BLACK);

    right_3.setPreferredSize(new Dimension(200, 120));

    right.add(right_1, BorderLayout.NORTH);

    right.add(right_2, BorderLayout.CENTER);

    right.add(right_3, BorderLayout.SOUTH);

    frame.add(left, BorderLayout.CENTER);

    frame.add(right, BorderLayout.EAST);

    frame.setVisible(true);

    frame.pack();

    }

    }

    本人感觉:spa

    (1)若是想让组件都填充满本身的容器(如panel,frame),使用上面的例子比较好。而且其能够随你的容器大小来改变大小,若是你使用消息进行响应的话,就比较麻烦,而且效率低(就是卡屏)。在这里面所用的组件都是用setPreferSize来进行大小的设置,其实这里的设置并非其最终的结果,这得取决于全部的组件包括容器大小的影响。布局真是个好东西啊。强大强大!!可是菜鸟就是搞不懂啊,难道我开始升级了??.net

    (2)有些人(就是菜鸟我)总想用一个控件填充一个panel,而且随panel大小进行调整控件的大小。其实这时使用布局就对了。首先对你的容器(如panel)设定一个布局:code

    this.setLayout(new BorderLayout());而后添加你的惟一组件:

    this.add(splitPane, BorderLayout.CENTER);这样就完成了,好强大有没有!!!!好吧,也许是本身太菜了,唉JAVA的基础知识很差啊。

    2. 根据实际屏幕大小更改本身窗口的大小。有一个记事本的小程序。orm

    blog

    http://blog.csdn.net/zollty/article/details/6852380get

    ea732e0879816db636469bd51c20e971.png

    import java.awt.Dimension;

    import java.awt.Toolkit;

    import javax.swing.JFrame;

    import javax.swing.JMenu;

    import javax.swing.JMenuBar;

    import javax.swing.JScrollPane;

    import javax.swing.JTextArea;

    public class Calculator extends JFrame

    {

    public Calculator()

    {

    super("无标题 - 记事本");

    JMenuBar menuBar = new JMenuBar();

    JMenu fileMenu = new JMenu("文件");

    JMenu editMenu = new JMenu("编辑");

    JMenu formatMenu = new JMenu("格式");

    JMenu checkMenu = new JMenu("查看");

    JMenu helpMenu = new JMenu("帮助");

    menuBar.add(fileMenu);

    menuBar.add(editMenu);

    menuBar.add(formatMenu);

    menuBar.add(checkMenu);

    menuBar.add(helpMenu);

    JScrollPane scrollPane = new JScrollPane();

    scrollPane

    .setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

    scrollPane

    .setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);

    JTextArea textArea = new JTextArea();

    scrollPane.setViewportView(textArea);

    this.getContentPane().add(scrollPane);

    this.setJMenuBar(menuBar);

    this.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

    //用来设置窗口随屏幕大小改变

    sizeWindowOnScreen(this, 0.6, 0.6);

    this.setVisible(true);

    }

    /**

    *

    * @param calculator

    * @param widthRate 宽度比例

    * @param heightRate 高度比例

    */

    private void sizeWindowOnScreen(Calculator calculator, double widthRate,

    double heightRate)

    {

    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

    calculator.setSize(new Dimension((int) (screenSize.width * widthRate),

    (int) (screenSize.height * heightRate)));

    }

    public static void main(String[] args)

    {

    Calculator calculator = new Calculator();

    }

    }

    展开全文
  • 电脑软件窗口大小调整

    千次阅读 2021-07-25 05:59:32
    怎么修改成桌面大小?可以调整桌面的图标大小,具体方法如下:方法一1. 此时的电脑桌面。2.鼠标在电脑桌面空白处单击右键,然后在弹出的对话框点击【查看】,然后会出现【大图标】、【中等图标】、【小图标】三个...
  • 1.可获取窗口标题,句柄,类名 2.可随意更改窗口标题 3.可随意更改窗口位置及大小(某些游戏窗口会有窗口固定比例保护) 3.可按照自己改过的大小一键自动排列
  • UE4窗口模式切换,修改窗口大小

    万次阅读 2019-04-24 11:32:23
    其中ResolutionSizeX、ResolusionSizeY为设置项目运行时的分辨率,(如果你使用窗口模式,它将影响你窗口大小) FullscreenMode、PreferredFullscreenMode为设置项目运行模式( 0 = Fullscreen ,1 = Windowed ...
  • Unity 简易窗口: 首先咱们看一下是不是自己想要的效果 组件可调整参数: 下面是同比例缩放的调整效果,如果只是缩放这个窗口里面的内容,这个是个不错的选择 资源链接: 下载地址.
  • Cocos2d-x 窗口大小调整

    千次阅读 2022-03-09 17:49:43
    打开src目录下的AppDelegate.cpp文件,若无修改则在第45行处找到全局声明的Size变量,修改`designResolutionSize`中的大小即可。
  • Win7下,开始菜单,输入CMD,先调出DOS窗口。...调整DOS窗口大小的方法。 在DOS命令行窗口输入以下指令: cmd /k "mode 120,40" cmd /k "mode con:cols=120 lines=40" 调整上面的数值,即可调整相应的大小。 ...
  • 如何调整python窗口(Tkinter)大小

    千次阅读 2021-01-29 16:21:31
    调整python窗口大小的方法:1、输入“import tkinter“命令导入tk模块,“win=tkinter.TK()“命令创建窗口;2、输入“win=getometry()“引入方法,在方法中输入宽度和高度的尺寸即可调整窗口大小。导入tk模块,创建...
  • 2.调整窗口大小 1.页面加载 load load等页面内容全部加载完毕包括页面DOM元素、图片、css、flash等等 DOMContentLoaded DOMContentLoaded 是DOM加载完毕,不包含图片 flash css 等就可以执行 加载速度...
  • cmd.exe显示窗口大小和字体大小调整

    千次阅读 2021-10-16 15:02:30
    1、依次打开“开始-所有程序-cmd.exe”。 2、在命令提示符窗口边框上右键鼠标,选择“属性”。 3、切换到“字体”选项卡, 在“大小”栏,选中下面...4、相似地,在“布局”选项卡,你也可以调节窗口大小。 ...
  • 原因四: 界面上窗口很多,而且改变大小时很多窗口都要移动和改变大小,如果使用MoveWindow或者SetWindowPos两个API来 改变窗口大小和位置,由于他们是等待窗口重画完成后才返回,所以过程很慢,这样视觉效果就...
  • 关于python写游戏时,在load读取图片后想要视窗展示,但图片和视窗大小不统一等,导致如同游戏背景等展示不如意,现介绍一种背景图片大小修改设置 问题描述: 代码 import pygame Background_img = pygame....
  • unity改变运行窗口的位置和大小

    千次阅读 2020-08-14 15:31:23
    if (id == lParam) // 找到进程对应的主窗口句柄 { ptrWnd = hwnd; // 把句柄缓存起来 SetLastError(0); // 设置无错误 return false; // 返回 false 以终止枚举窗口 } } return true; }), pid); return (!bResult ...
  • 解决Unity的PC版运行时窗口大小为0的问题
  • 调整DOSBOX窗口大小并运行程序

    万次阅读 多人点赞 2018-05-08 16:53:26
    想用DOSBOX玩ZORK,然而窗口小到眼睛酸痛。解决方案如下。 修改过程: 1、点开配置文件 2、修改并保存配置文件 windowresolution=1280x800 output=opengl 3、修改前后对比 修改前: 修改后: ...
  • 一句话总结:由于应用协议的原因可能会导致tcp窗口大小过小致使接收速率变慢,或由于系统的原因导致tcp可变窗口大小不可用,导致窗口大小始终不变(大概率不超过65536b也就是64kb)导致网络速率不理想。 众所周知,...
  • 阴阳师pc端固定窗口大小多开 随着阴阳师2020年周年的到来, 阴阳师官方对手机端和pc端也是进行了强制更新, 更新后导致pc端的阴阳师没法像之前一样固定游戏开启时的大小, 在网上查阅了一些资料, 在众多方法中整理出了...
  • pygame实现全屏模式和窗口大小可调

    千次阅读 2020-07-10 23:06:01
    pygame如何实现全屏模式和窗口大小可调 在pygame中可以设置通过pygame.display.set_mode(size=(0, 0), flags=0, depth=0)对窗口参数进行设置,这个函数会返回一个Surface对象。 在四个参数中,size表示窗口大小,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,683
精华内容 15,873
关键字:

修改游戏窗口大小