FYI, for the ones who haven't seen it yet:

There's an added problem when you have dddw close to the bottom of your screen:

https://www.appeon.com/standardsupport/search/view?id=3713

I guess we'll just have to tell our users to run our powerbuilder applications with compatibility settings for DPI to 100% system ( I tried "enhanced" but that didn't work out as well, can't remember why).

Or ...

Tell our users to use 100% scaling in windows. Which for now is the best, but also less user friendly solution.

regards,

MiguelL

Hi Dan.

Look at here:

https://community.appeon.com/index.php/qna/q-a/monitor-scale-factor

Guys already help me solve similar problem.

I need to check user display resolution for some some screens in our app, i am doing on the screen level.

First, global functions need to be declared, i did at the application level:

FUNCTION Longptr GetDC ( Longptr hWnd ) LIBRARY "user32.dll"
FUNCTION Longptr GetDesktopWindow ( ) LIBRARY "user32.dll"
FUNCTION UnsignedLong GetDeviceCaps ( Longptr hDC, UnsignedLong nIndex ) LIBRARY "gdi32.dll"
FUNCTION Long ReleaseDC ( Longptr hWnd, Longptr hDC ) LIBRARY "user32.dll"

Second, i create functions:

global type f_check_display_settings from function_object
end type

forward prototypes
global function boolean f_check_display_settings (long ar_l_screen_width, long ar_l_screen_height, string ar_s_window_title)
end prototypes

global function boolean f_check_display_settings (long ar_l_screen_width, long ar_l_screen_height, string ar_s_window_title);environment env
int i_rc
long l_screenwidth, l_screenheight
string s_width, s_height

Constant ULong LOGPIXELSX = 88, LOGPIXELSY = 90
Long ll_rc, ll_percent
ULong lul_dpi_x, lul_dpi_y
Longptr llptr_hwnd, llptr_hdc

i_rc = GetEnvironment(env)

IF i_rc <> 1 THEN
messagebox('System Error', 'Cannot verify monitor screen size.~nPlease contact system administrator.~n~nGetEnvironment()=' + string(i_rc), exclamation!)
return false
end if

l_screenwidth = env.ScreenWidth
l_screenheight = env.ScreenHeight

if isnull(l_screenwidth) then
s_width = 'Null'
else
s_width = string(l_screenwidth)
end if

if isnull(l_screenheight) then
s_height = 'Null'
else
s_height = string(l_screenheight)
end if

IF isnull(l_screenwidth + l_screenheight) = true or l_screenwidth + l_screenheight < 1 THEN
messagebox('System Error', 'Cannot verify monitor screen size.~nPlease contact system administrator.~n~nScreenWidth=' + s_width + ', ScreenHeight=' + s_height, exclamation!)
return false
end if

if env.osmajorrevision < 10 then
// Script begin ...
/*
Global external functions need to be declared in the application object:
FUNCTION Longptr GetDC ( Longptr hWnd ) LIBRARY "user32.dll"
FUNCTION Longptr GetDesktopWindow ( ) LIBRARY "user32.dll"
FUNCTION UnsignedLong GetDeviceCaps ( Longptr hDC, UnsignedLong nIndex ) LIBRARY "gdi32.dll"
FUNCTION Long ReleaseDC ( Longptr hWnd, Longptr hDC ) LIBRARY "user32.dll"
*/

llptr_hwnd = GetDesktopWindow() // Get handle to desktop window
llptr_hdc = GetDC(llptr_hwnd) // Get handle to desktop's device context

// 96 dots/inch is normal (100%), 120 is 125%, 144 is 150%
lul_dpi_x = GetDeviceCaps(llptr_hdc, LOGPIXELSX)
lul_dpi_y = GetDeviceCaps(llptr_hdc, LOGPIXELSY)

ll_percent = (lul_dpi_x * 100) / 96

ll_rc = ReleaseDC(llptr_hwnd, llptr_hdc) // Release the device context
// Script end ... BIG THANKYOU to John Fauss: https://community.appeon.com/index.php/qna/q-a/profile/2184-john-fauss
else
ll_percent = 100
end if

choose case true
case l_screenwidth >= ar_l_screen_width and l_screenheight >= ar_l_screen_height and ll_percent = 100
return true
case else
MessageBox(ar_s_window_title, 'Minimum resolution to run this screen is ' + string(ar_l_screen_width) + ' X ' + string(ar_l_screen_height) + '.~n~nYour monitor display settings are: ' + s_width + ' X ' + s_Height + &
'~n~nPlease readjust you monitor:~n Display Settings/Scale Layout to run this screen.', Exclamation!)
return false
end choose

end function

Third, just before opening window, in our case in the w_frame, i am passing minimum width (1920) and height (1080) to functions, so i can check if user can run this window:

if not f_check_display_settings(1920,1080,'My window title') then
return

else

// open window ...
end if

Hope it will help you at least for a start.

OK, thanks all. I think I have a function now that returns the info I want. Some of the code is based on heuristics and experience, but I think it's overall correct.

You first need the external function declaration:

// Get screen dimensions etc.
Function long GetSystemMetrics(long nIndex) Library "User32.dll"

and the constants:

// Arguments to GetSystemMetrics
constant int SM_CXSCREEN = 0
constant int SM_CYSCREEN = 1

Then this is the function:

public subroutine uf_screen_info (ref long statedwidth, ref long statedheight, ref long scalingpercent, ref long logicalwidth, ref long logicalheight);

// Return a bunch of details about the main/default screen.
// The stated dimensions are what the user sees them being set to in Control Panel's Display Settings, like 1920 x 1080.
// The scalePercent is the DPI scaling, usually 100, 125 or 150.
// The logical dimensions are the effective usable pixels based on that scaling - and what env.ScreenWidth and env.ScreenHeight
// return. So for instance at 1920 x 1080, with 125% scaling, the logical dimensions are 1536 x 864.
// Note: Calculations done with the UnitsToPixels and PixelsToUnits functions are also in logical dimensions.

ulong ll_dpi = 96 // default if no results
string ls_dpi
Environment env

GetEnvironment(env)

// GET THE DPI

// the following setting works on at least Windows 10 - only changed, if you change the scaling, after a reboot or log off and on
if RegistryGet("HKEY_CURRENT_USER\Control Panel\Desktop\WindowMetrics", "AppliedDPI", ReguLong!, &
ll_dpi) <> 1 &
then
// the following setting works on Windows NT and 2000 (though it may not be present if the
// machine has never been switched from small to large fonts, but that's OK)
if RegistryGet("HKEY_CURRENT_CONFIG\Software\Fonts", "LogPixels", ReguLong!, &
ll_dpi) <> 1 &
then
// the following setting works on Windows 95 and 98
if RegistryGet("HKEY_CURRENT_CONFIG\Display\Settings", "DPILogicalX", RegString!, &
ls_dpi) = 1 &
then
ll_dpi = Long(ls_dpi)
end if
end if
end if

scalingPercent = Round(ll_dpi * 100 / 96.0, 0)

/* A user with dual monitors gets the incorrect (too small) results from env.ScreenWidth and env.ScreenHight,
* try double-checking the primary monitor's dimensions directly with the Windows API,
* and then use the max answer, from that, or from GetEnvironment's settings.
*/
logicalWidth = GetSystemMetrics(SM_CXSCREEN)
logicalHeight = GetSystemMetrics(SM_CYSCREEN)
if logicalWidth <> env.ScreenWidth or logicalHeight <> env.ScreenHeight then
logicalWidth = Max(logicalWidth, env.ScreenWidth)
logicalHeight = Max(logicalHeight, env.ScreenHeight)
end if

statedWidth = Round(logicalWidth * scalingPercent / 100.0, 0)
statedHeight = Round(logicalHeight * scalingPercent / 100.0, 0)

end subroutine

So with this function, if I think all of my windows will fit on a monitor with an effective size of 1024 x 768, I compare that to the returned logicalWidth and logicalHeight. Then if I want to give messaging to the user (because their screen may be too small for our windows), I can tell them that their screen dimensions are statedWidth by statedHeight, with a scaling factor of scalingPercent, but their effective screen dimensions are thus logicalWidth and logicalHeight, which some of the program's windows may not fit within.

Hey Dan, I'm not sure what the right screen dimensions to report are - if  I had to choose just one set. Reason:

• GetEnvironment uses legacy Windows APIs (it used to, and I expect it continues to do so)
• Windows' compatibility mode can "lie" to the app process about a whole bunch of stuff. E.g.:
  • OS version
  • Screen size (where monitor scaling makes a difference)
  • Color depth
  • CPU and memory

Just like running in a VM emulates an environment different from the physical hardware underneath. So question is when you query for some metric => What do you want in return? The emulated environment or the underlying environment? There you may have multiple virtual layers of "truth".

I can see benefit in expanding the documentation to highlight that GetEnvironment returns the emulated environment which may differ from the physical environment. Then each of us can decide if we need to call other APIs to get info on a "lower layer of reality."

HTH /Michael

Hi Dan,

check Windows API function GetSystemMetrics.

HTH,

René

Hi Dan,

Not a real solution here but maybe this link can have some information on which API's to use? https://community.appeon.com/index.php/qna/q-a/monitor-scale-factor?limitstart=0#reply-16814

(Myself I'm using some routines to check if a window has been opened on a second monitor (stored positions from DB) and now the monitor might be off. You just made me realize I might have to revise that).