Scaling on Windows pc with mix of ctk and tk widgets

[RutgerLit]

Hi Tom,

Thank you for the great product, it's awesome!

I have a question about scaling on a Windows pc.
If I drag a ctk window to my other monitor (with a different scaling than my main monitor), I see that ctk nicely takes the scaling of the new monitor into account. I can also see this because the method "update_scaling_callbacks_for_window" in the file "scaling_tracker.py" is called. So that is very nice!

But I also have some regular tkinter widgets in my app and they do not get scaled. So the ctk widgets are nicely scaled and the tk widgets are not.

Do you, or the community, know of a way to align the behaviour so that both type of widgets get scaled when the app is dragged to a different monitor with different scaling?

Thank you very much.

[Akascape]

@RutgerLit
Try adding this in top:

import ctypes    
ctypes.windll.shcore.SetProcessDpiAwareness(0)

[TomSchimansky]

The DPI settings are all applied by the library according to the current platform. Adding SetProcessDpiAwareness(0) will cause an undefined behaviour, it will disable the scaling applied by Windows but without letting the library now. What you can do is set ScalingTracker.deactivate_automatic_dpi_awareness = True. Then you can set your own DPI settings. But Adding SetProcessDpiAwareness(0) will either cause the widgets to be too small, or to be upscaled by Windows, which results in a blurry rendering.

[RutgerLit]

Yes, although switching off dpi awareness solves the problem, it does result in blurry rendering.
Any other ideas? Is there a way to scale the regular tkinter widgets in the same way as ctk does it in:

@classmethod
def update_scaling_callbacks_for_window(cls, window):
    for set_scaling_callback in cls.window_widgets_dict[window]:
        if not cls.deactivate_automatic_dpi_awareness:
            set_scaling_callback(cls.window_dpi_scaling_dict[window] * cls.widget_scaling,
                                 cls.window_dpi_scaling_dict[window] * cls.spacing_scaling,
                                 cls.window_dpi_scaling_dict[window] * cls.window_scaling)
        else:
            set_scaling_callback(cls.widget_scaling,
                                 cls.spacing_scaling,
                                 cls.window_scaling)

[TomSchimansky]

You can use the CTkScalingBaseClass, but currently this exists only in the develop branch:

import customtkinter
from customtkinter.windows.widgets.scaling.scaling_base_class import CTkScalingBaseClass
import tkinter


class ScalableTkButton(tkinter.Button, CTkScalingBaseClass):
    def __init__(self,
                 *args,
                 width: int = 0,
                 height: int = 1,
                 font: tuple = ("TkDefaultFont", -12, ""),
                 **kwargs):
        tkinter.Button.__init__(self, *args, **kwargs)
        CTkScalingBaseClass.__init__(self, scaling_type="widget")

        self._width = width
        self._height = height
        self._font = font
        super().configure(width=round(self._apply_widget_scaling(self._width)),
                          height=round(self._apply_widget_scaling(self._height)),
                          font=self._apply_font_scaling(self._font))

    def _set_scaling(self, new_widget_scaling, new_window_scaling):
        CTkScalingBaseClass._set_scaling(self, new_widget_scaling, new_window_scaling)

        super().configure(width=round(self._apply_widget_scaling(self._width)),
                          height=round(self._apply_widget_scaling(self._height)),
                          font=self._apply_font_scaling(self._font))

    def configure(self, **kwargs):
        if "width" in kwargs:
            self._width = kwargs.pop("width")
            super().configure(width=round(self._apply_widget_scaling(self._width)))
        if "height" in kwargs:
            self._width = kwargs.pop("height")
            super().configure(height=round(self._apply_widget_scaling(self._height)))
        if "font" in kwargs:
            self._width = kwargs.pop("font")
            super().configure(font=self._apply_font_scaling(self._font))

        super().configure(**kwargs)


def set_scaling(scaling):
    customtkinter.set_widget_scaling(scaling)
    customtkinter.set_window_scaling(scaling)


app = customtkinter.CTk()

scaling_button = customtkinter.CTkSegmentedButton(app, values=[0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.5, 2.0], command=set_scaling)
scaling_button.pack(pady=10)

button_1 = ScalableTkButton(app, text="ScalableTkButton")
button_1.pack(pady=10)

app.mainloop()

Every argument of the Tk widget you want to scale, has to be stored separately from the Tk widget. Then you can apply the widget scaling or font scaling methods you get from the CTkScalingBaseClass. The _set_scaling method is automatically called if a change in the system scaling or user scaling occurs.

[RutgerLit]

Thank you! I will look at it.