CODEWITHSUNDEEP
windowsresizewindowdesktop
Nelson
Nelson

Reputation:

Create Window larger than desktop (display resolution)

I need to resize a window larger than screen resolution or size of desktop, programmatically & preferably also manually.

Since MS-Windows XP/Vista disallows a window size larger than screen, does anybody have any ideas to work around this limitation?

I trying to make pan effect on a laptop to give me more space to work. An older laptop with a smaller LCD size did have such a feature.

See this: http://www.experts-exchange.com/OS/Microsoft_Operating_Systems/Windows/98/Q_21832063.html

Upvotes: 11

Views: 23856

Answers (10)

Synetech
Synetech

Reputation: 9925

Since MS-Windows XP/Vista disallows a window size larger than screen, does anybody have any ideas to work around this limitation?

This limitation only applies to windows that are maximized. If you "restore" the window, then you can set it to a size larger than the desktop area.

I just tested it with Firefox on Windows 7 and successfully set it to 3000×3000 (my screen is only 1920×1080). It even worked with the Run dialog-box. (While Windows 10+ have drastically decreased user freedom and turned Windows into a locked-down Fisher-Price OS, there's no reason to believe this one aspect has changed, so it should work in later Windows as well.)

Note, that while Windows does not restrict non-maximized windows to the desktop, programs can impose their own limits by overriding WM_GETMINMAXINFO to restrict their windows' sizes. In that case, you'd have to override their message-handler somehow.

Upvotes: 0

Isti115
Isti115

Reputation: 2746

I needed to push part of a window off the top of the screen and I was fnally able to do it using this AutoHotKey script:

SetTitleMatchMode, 2
WinTitle := "Visual Studio Code"

; --- WinMove version

; WinMove, %WinTitle%, , 0, -64, 1280, 1504

; -- DLL version

WinGet, id, , %WinTitle%
Result := DllCall("SetWindowPos", "uint", id, "uint", HWND_TOP, "Int", 0, "Int", -64, "Int", 1280, "Int", 1504, "UInt", 0x400)

(I wanted to maximize the editor area of VSCode by completely hiding the title bar and the tabs section, that are not configurable in the program itself.)

Upvotes: 0

user6170414
user6170414

Reputation: 31

You can do something like the following code in your WinProc();

case WM_GETMINMAXINFO:
    {
        LPMINMAXINFO lpmmi = (LPMINMAXINFO)lParam; 
        GetWindowRect(GetDesktopWindow(), &actualDesktop);
        lpmmi->ptMaxTrackSize.x = 3000;// set the value that you really need.
        lpmmi->ptMaxTrackSize.y = 3000;// set the value that you really need.
    }
    break;

An application can use this message to override the window's default maximized size and position, or its default minimum or maximum tracking size.

Upvotes: 3

Maxx Daymon
Maxx Daymon

Reputation: 488

If you would like to resize a window that you do not own (and without using any kind of hook), you can use the Windows SetWindowPos API with the SWP_NOSENDCHANGING (0x0400) flag set:

BOOL WINAPI SetWindowPos(
__in      HWND hWnd,
__in_opt  HWND hWndInsertAfter,
__in      int X,
__in      int Y,
__in      int cx,
__in      int cy,
__in      UINT uFlags // ** SWP_NOSENDCHANGING must be passed here **
);

This will prevent the WM_WINDOWPOSCHANGING message from being sent which is what triggers the WM_GETMINMAXINFO restriction. Any other sizing of the window will cause the restriction to snap the window back to desktop restricted sizes, as the message will be sent and the window size enforced.

Window Resizer (C#)

The following is a tiny example program that will resize Notepad to 6000x6000 (change the string "Untitled - Notepad" to the title of the window you want to resize, or take the window name and desired size from the command line args)

namespace Example
{
 class Program
 {
  [DllImport("USER32.DLL")]
  public static extern IntPtr FindWindow(String className, String windowName);

  [DllImport("USER32.DLL", SetLastError = true)]
  public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int left, int top, int width, int height, uint flags);

  static void Main(string[] args)
  {
   var TOP = new IntPtr(0);
   uint SHOWWINDOW = 0x0040, NOCOPYBITS = 0x0100, NOSENDCHANGING = 0x0400;
   var hwnd = FindWindow(null, "Untitled - Notepad");
   SetWindowPos(hwnd, TOP, 0, 0, 6000, 6000, NOCOPYBITS | NOSENDCHANGING | SHOWWINDOW);
  }
 }
}

Limitations and caveats

This approach is generally functional, but there are a number of limitations that might prevent a window from being resized, or resized in any useful manner.

Security

Starting with Windows Vista, Microsoft has implemented increasing security around window messages. An executable can only interact with windows at or below its own security context. For example, to resize the "Computer Management" window (which always runs elevated), this program would have to run elevated as well.

Fixed Windows and layout logic

Window sizes might be enforced passively or actively by a program. A window with a size enforced passively sets the initial size and simply exposes no ability for the user to resize the window (e.g., no size grip control). These windows can usually be resized by sending a message as described but, lacking layout logic, will not show anything other that additional empty client area.

Windows with active enforcement monitor the size, either by catching the windows messages such as WM_SIZE, or in more sophisticated layout logic. These windows may accept the message, but will restrict or limit the final size in their own code.

In either case, Windows with fixed sizes generally lack any layout logic to take advantage of larger sizes so, even if you can force it, resizing them confers no benefits.

WPF

The Window class in WPF has an HwndSource that handles window messages sent to the WPF window. The private method LayoutFilterMessage catches the WM_SYSCOMMAND, WM_SIZING, WM_WINDOWPOSCHANGING, and WM_SIZE messages. In this case, the WM_SIZE message is then handled by the private Process_WM_SIZE which, in effect, bypasses the NOSENDCHANGING flag and alters the RenderSize of the WPF client area. This is part of an overall process of adapting legacy Win32 messages to WPF events.

The net effect is that the Win32 host window is resized (unless SizeToContent is set to SizeToContent.WidthAndHeight), but the WPF render area is locked to the desktop area, as if the NOSENDCHANGING flag weren't set. When the above code sample is run against a WPF app, you can see the 6000x6000 window in Aero Peek from the task bar or the window preview in the Windows-Tab switcher, but you can also see the WPF content and layout logic being clipped to the desktop area. In this way, the WPF window is like the actively enforced window but, rather than enforcing a specific size, enforces a specific maximum (for RenderArea) and does not consider the WM_WINDOWPOSCHANGING message.

If it is your own app and you host the WPF within a Windows Forms window (via ElementHost) you can resize the window and the WPF content will respect the larger-than-desktop Windows Form window.

Other frameworks

Other frameworks such as GTK and Qt may or may not enforce size behavior and limits, and may have various workarounds possible to overcome those limits. Any given program may ignore, rewrite, or bypass a window message and a framework can enforce it across an entire class of application such as with WPF above.

More about the SetWindowPos API:

Reference Source for Process_WM_SIZE method of HwndSource:

http://referencesource.microsoft.com/#PresentationCore/Core/CSharp/System/Windows/Interop/HwndSource.cs,da4aa32ad121c1b9,references

Upvotes: 18

vasile
vasile

Reputation: 11

Only the recommended screen resolutions are listed. For additional settings, click the Advanced button on the Settings tab, click the Adapter tab, and then click List all Modes. Select the resolution, color level, and refresh rate you want.

I've just did it, here you can find the answer in the last point.

http://www.microsoft.com/resources/documentation/windows/xp/all/proddocs/en-us/display_change_screen_resolution.mspx?mfr=true

Upvotes: 1

Wolf5
Wolf5

Reputation: 17190

This code in C# does what you ask. The window is way wider than the desktop.

 protected override void WndProc(ref Message m) {
        if (m.ToString().Contains("GETMINMAXINFO")) {
            //Hent data
            MINMAXINFO obj = (MINMAXINFO)Marshal.PtrToStructure(m.LParam, typeof(MINMAXINFO));
            //Endre
            if (obj.ptMaxSize.X > 0) {
                obj.ptMaxSize.X = 60000;
                obj.ptMaxSize.Y = 60000;
                obj.ptMaxTrackSize.X = 60000;
                obj.ptMaxTrackSize.Y = 60000;
                //Oppdater
                Marshal.StructureToPtr(obj, m.LParam, true);
            }
        }
        if (m.ToString().Contains("WINDOWPOSCHANGING")) {
            //Hent data
            WINDOWPOS obj = (WINDOWPOS)Marshal.PtrToStructure(m.LParam, typeof(WINDOWPOS));
            //Endre
            if (obj.cx > 0) {
                obj.cx = 8000;
                //Oppdater
                Marshal.StructureToPtr(obj, m.LParam, true);
            }
        }
        //Debug.WriteLine(m.ToString());
        base.WndProc(ref m);
    }











    [StructLayout(LayoutKind.Sequential)]
    internal struct WINDOWPOS {
        internal IntPtr hwnd;
        internal IntPtr hWndInsertAfter;
        internal int x;
        internal int y;
        internal int cx;
        internal int cy;
        internal uint flags;
    }

    [StructLayout(LayoutKind.Sequential)]
    internal struct MINMAXINFO {
        internal POINT ptReserverd;
        internal POINT ptMaxSize;
        internal POINT ptMaxPosition;
        internal POINT ptMinTrackSize;
        internal POINT ptMaxTrackSize;
    }
    [StructLayout(LayoutKind.Sequential)]
    internal struct POINT {
        internal int X;
        internal int Y;
    }

Upvotes: 3

John K
John K

Reputation: 28917

The window size seems to be dependent on Desktop size, not screen resolution; however the Desktop conforms to resolution. The trick might be to change the Desktop size or start from there.

A while back, a developer named Robert Bresner (his website) made a product called sDesk (downloadable from here) which expanded Windows beyond the screen resolution.

What is SDesk? SDesk is not a multi-desktop program. It is a program that creates a single, giant desktop that extends beyond the visible region of the monitor. Only a portion of the SDesk is visible at a time, as defined by the Windows desktop settings.

The original homepage of the SDesk software is archived here There's no current page on the Internet (that I could find) but this archived version is accessed through the Way Back Machine which caches a lot of the Internet.

The SDesk product is freeware. No source code was included though. You might visit his contact page (also available in the archived version) to ask if the source is available or can be acquired for your research.

Upvotes: 1

Rafelb
Rafelb

Reputation: 11

If you have a video card with the possibility to connect more than one screen, another workaround is to setup your system as if it is using two screens next to eachother. Then you can resize your windows to the size of the two screens together.

Upvotes: 1

Nelson
Nelson

Reputation:

ok, I did try use keystrokes to move, resize windows. But system will automatically move windows back to visible region of desktop in my XP. I also tried SetWindowPos API, and no helps. The best chance will be to write a Video driver, but it may need more study. The 360 desktop claims you can expand desktop horizontally. But actually it just pan the current desktop in a virtual wider space. Any windows inside still have the size limitation of no larger than your screen resolution.

Video driver set the screen resolution(yes, have to compatibile to lcd/crt screen capability), and Windows did limit window-size by this thresholds. I just want to work around in user space API.

Upvotes: 0

Sparr
Sparr

Reputation: 7732

For the specific case of needing a more screen-friendly view of the MSDN, or on any other site (like StackOverflow) that makes poor use of screen real estate, I would suggest applying a custom stylesheet to the page, using a tool like IE7Pro (IE), Greasemonkey (Firefox), Stylish (Fireox), or the built in stylesheet picker in Opera.

Upvotes: -1

Related Questions