@Curtwagner1984 said in How can I make my app ignore window's "HIGH DPI SCALING"?: I made a file named qt.conf with the line <application> -platform windows:dpiawareness=0 Those are command line arguments. You pass the extra arguments while launching your .exe from the Command Prompt .

I'm afraid that doesn't help for my use case, since I need the images to appear as clear and clean as possible when being scaled down.

In one of my project, a bit of resolution seems to be lost when scaling (150%). It is plotting a complicated graph for signal processing. We are thinking whether we can just plot the graph according to the scaling factor (e.g. running the math calculation ourslef and generate a graph double the size for high resolution etc) and not to scale this part of the widget by using the high dpi setting.

The code to fix this problem was really unexpected and quite time consuming. The kicker is that QGuiApplication.devicePixelRatio() always returns 1.0 under Gnome, regardless of what scaling is actually set to. That means Gdk must be called to determine the scaling value. import gi gi.require_version('Gdk', '3.0') from gi.repository import Gdk def any_screen_scaled_gdk() -> bool: """ Detect if any of the screens on this system have scaling enabled. Uses GDK to do the querying. :return: True if found, else False """ try: display = Gdk.Display.get_default() except Exception: import logging logging.exception( 'An unexpected error occurred when querying the systems display parameters. Exception:' ) return False if display: try: for n in range(display.get_n_monitors()): monitor = display.get_monitor(n) if monitor.get_scale_factor() > 1: return True return False except AttributeError: # get_n_monitors() was introduced in gtk 3.22 try: screen = display.get_default_screen() for monitor in range(screen.get_n_monitors()): if screen.get_monitor_scale_factor(monitor) > 1: return True except Exception: import logging logging.exception('An unexpected error occurred when querying Gdk. Exception:') return False def any_screen_scaled_qt() -> bool: """ Detect if any of the screens on this system have scaling enabled. Call before QApplication is initialized. Uses temporary QGuiApplication. :return: True if found, else False """ app = QGuiApplication(sys.argv) return app.devicePixelRatio() > 1.0

@Maikkannan said in How to fix scaling issue in Qt desktop application.: increased Do you run it on a 2K screen？

Finally. This code works fine. void onPrint(QPrinter* printer) { QPagedPaintDevice* device = printer; QPainter painter; painter.begin(device); int w = device->width(); int h = device->height(); painter.drawLine(0,0,w,h); painter.drawLine(0,h,w,0); painter.drawEllipse(QPointF(w/2, h/2), w/10, w/10); painter.drawText(0, h, "pixels"); printer->newPage(); painter.end(); }

Hi, Did you already saw the related part of QIcon’s documentation ?

Hi! Have you seen the Qt 3D: Planets QML Example?

In C++ you register your image provider by providing a new resource prefix (say you chose "myimage") then in QML it will look like this: source: "myimage://myborderImage" Read Qt doc about QQuickImageProvider class, there is an example of how to use it

@johngod Thank you so much, you're right Screen.pixelDensity would be the complete solution if it was in qml, sifting trough the qt source i was able that it was derived from: double pixelpermm = QGuiApplication::primaryScreen()->physicalDotsPerInch() / 25.4 //physicalDotsPerInchX() & physicalDotsPerInchY() also exist and it seems to be correct on both my iPhone & iPad quite wel (better than all other ways I found so far) @Lorenz thanks, but for the time being I want to stick to Qt as it is a paid sdk as soon as you go commercial

Hi and welcome to devnet, I'd recommend posting this question to the Qt Creator mailing list. You'll find there Qt Creator's developers/maintainers. This forum is more user oriented.

ok will do

I have been looking into this myself, with no conclusive information on how to reliably accomplish this. It feels like Qt 5.6 ought to automagically do the scaling for you; I intend to post a new question in this forum asking about this. In the meanwhile, the first part of this video will be of interest to you: https://youtu.be/nNyhsdX6BsI?t=6m24s There is code at 06:24 that extracts the dpi value from the Android framework. Maybe that will work better, I have not tried it myself.

icons depend on DevicePixelRatio and are named this way: myIcon.png - corresponds to 1.0 and mdpi - use this name in qml myIcon@2x.png - 2.0 and xhdpi myIcon@3x.png - 3.0 and xxhdpi myIcon@4x.png - 4.0 and xxxhdpi if you want to know the DevicePixelRatio: C++ qApp->primaryScreen()......

Thanks !

Thank you. Both worked though I guess it is supposed to be int w = ui->label->width (); int h = ui->label->height (); ui->label->setPixmap (pix.scaled (w,h,Qt::KeepAspectRatio));

@DerBaer The QML version did/does not scale Android UIs correctly. The Qt C++ UI may be the same. With the version I am using, I was forced to create a ratio based on the Android device screen resolution relative to the desktop resolution for all on screen objects..text, fonts, images, etc. Probably may not be what you want to hear, but you may have to handle the scaling yourself...unless this behavior has been fixed.

@p3c0, Thanks for advice. I removed clip, but unfortunately it did not help. Further testing shows that as long as image fits to 2048x2048 size there is no loss in image quality. After some searching, I am guessing that this might be caused by Android texture size limitation. Dealing with Android's texture size limit I don't know how Qt handles this internally, but it definitely looks like there is some automatic scaling happening when image is not fitting into certain size. Maybe there is some workaround for this. Otherwise displaying large images requires more than "image + flickable" approach. Bob

CSS lets you use relative length units, see this: http://www.w3schools.com/cssref/css_units.asp As suggested in that link before, em and rem create perfectly scalable sizes. Don't let the name and description fool you: although the size refers to the size of the M character, they can be applied to width, height and any other CSS property as well. Also, if you use a main CSS class like this: main_class { width: 1em; height: 1em; font-size: 10em; } and all the other objects (or CSS styles) are childs of this class: main_class.div { .... } // or something like this in HTML <BODY class="main_class"> <div class="other_class">something</div> </BODY> // in C++ the BODY widget would the parent of the div widget You can then only change the main_class sizes, and all the child items of that class will scale accordingly to their parent. Suppose you have this CSS for that div element before: other_class { width: 10em; height: 4em; font-size: 1.3em; } and suppose that the main_class CSS is this: main_class { width: 3em; height; 3m; font-size: 10em; } then the real sizes of that other_class are actually: width: 30 em; // 3 * 10 height: 12 em; // 3 * 4 font_size: 13 em; // 10 * 1.3 because they have been scaled by 3, 3 and 10ems, respectively. Using ems is for sure the best way in CSS to scale items proportionally. I hope this helps :)

@A-Former-User said in Properly scaling SVG Images: Hi swegmann! The following code is more an ugly trick than a solution, but at least it does what it's supposed to do and you get rid of the binding loop: Image { source: "file:///home/pw/Downloads/SVG_logo.svg" sourceSize: Qt.size( img.sourceSize.width*2, img.sourceSize.height*2 ) Image { id: img source: parent.source width: 0 height: 0 } } (Funny. When I clicked "reply" the forum wanted to caution me that this thread is quite old. And yet... I arrived here because I still needed to learn the sourceSize hack this many years later.) The code snippet above demonstrating how to fix SVG blur using sourceSize is great. I'm surely not the first to notice, but you can also then go "one small step further" and make a reusable custom element that will be well-behaved for scaling factors other than "2". Indeed, it should be generalized/reusable for an SVG of any size (any "native" or "starting" size) and any target size or any stretch-due-to-anchoring. It would look like this: import QtQuick 2.12 import QtQuick.Controls 2.12 Image { // Thanks to this hack, qml can now only DOWN-SCALE/SHRINK the SVG, which won't cause blurriness/pixelation sourceSize: Qt.size( // first "trick" qml that the SVG is larger than we EVER NEED Math.max(hiddenImg.sourceSize.width, 250), // change 250 to a per-project "biggest icon in project" value Math.max(hiddenImg.sourceSize.height, 250)) Image { id: hiddenImg source: parent.source width: 0 height: 0 } } You can build-and-run a full working sample here. (It can also be launched simply with qmlscene).