I can only embed one image, so I’ll add a screenshot in a reply.

Here’s the structure in wxFormBuilder:

And all mentions of the Splitter in the generated Frame code:

        self.m_splitter1 = wx.SplitterWindow( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.SP_3D|wx.SP_THIN_SASH )
        self.m_splitter1.SetSashGravity( 0.5 )
        self.m_splitter1.Bind( wx.EVT_IDLE, self.m_splitter1OnIdle )
        self.m_splitter1.SetMinimumPaneSize( 50 )
...
        self.m_panel1 = wx.Panel( self.m_splitter1, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
...
        self.m_panel2 = wx.Panel( self.m_splitter1, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
...
        self.m_splitter1.SplitHorizontally( self.m_panel1, self.m_panel2, 0 )
        bSizer7.Add( self.m_splitter1, 1, wx.EXPAND, 5 )
...
    def m_splitter1OnIdle( self, event ):
        self.m_splitter1.SetSashPosition( 0 )
        self.m_splitter1.Unbind( wx.EVT_IDLE )

Any suggestions on how to get the sash to be visible?

Unless there’s a magic incantation for getting Raise() to work, I’ll just go with that.

Thanks

But now it gets more interesting. Raise() fails to work when the app is packaged by

pyinstaller -F -w appname.py

BUT, when run from within pyCharm (after enabling “allow multiple instances”) it DOES work as expected.

And: would Iconize(True); Iconize(False) work?

There is a caveat in the documentation which says:

Notice that this function only requests the window manager to raise this window to the top of Z-order. Depending on its configuration, the window manager may raise the window, not do it at all or indicate that a window requested to be raised in some other way, e.g. by flashing its icon if it is minimized.

        if frm.IsIconized(): frm.Iconize(False)
        frm.Raise()
        frm.mToday.SetFocus()

If the window is iconized, then frm.Iconize(False) both restores the window and raises it. However, if the window is not iconized, but partially or completely hidden under another window, the taskbar icon flashes but the window is not raised.

I also tried using CallAfter(frm.Raise) but it had no effect.

What am I missing? Is the fact that this runs in a daemon thread the problem? Is this just a limitation of Windows 11?

import wx
import wx.dataview as dv

class FileListPanel(wx.Panel):
    """Docstring for FileListPanel"""
    def __init__(self, parent, *args, **kwds):
        error_file = kwds.pop('file')
        super().__init__(parent, *args, **kwds)  # Call the parent class's constructor

        list_sizer = wx.BoxSizer(wx.VERTICAL)

        self.file_list = dv.DataViewListCtrl(self)
        list_sizer.Add(self.file_list, 1, wx.EXPAND, 0)

        file_col = self.file_list.AppendTextColumn('File')
        file_col.SetResizeable(True)
        file_col.SetMinWidth(200)
        count_col = self.file_list.AppendTextColumn('Embedded')
        count_col.SetWidth(80)
        count_col.SetResizeable(False)

        self.SetSizer(list_sizer)
        self.Layout()
        self.file_list.Bind(wx.EVT_SIZE, self.on_size)

    def on_size(self, evt) -> None:
        evt.Skip()
        self.size_columns()

    def size_columns(self) -> None:
        desired_count_width = 100
        size = self.file_list.GetSize()
        file_col, count_col = self.file_list.GetColumns()
        file_col.SetWidth(size.width - desired_count_width)
        count_col.SetWidth(desired_count_width)

Joe

For Linux, darkdetect seems to assume that “gitk-theme” is the reliable source of this information. I believe he original posting here, and as I have seen myself in some situations on Linux, “gtk-theme” can be different from wx.SystemSetting.GetAppearance().IsDark(). I don’t know enough about the details to know what is different.

By “embedded”, do you mean an application that owns the whole windowing system?

Right, my project embeds wxWidgets/wxPython inside AutoCAD. AutoCAD has its own dark/light mode independent of the OS. The plan is to call wxTheApp->MSWEnableDarkMode based on AutoCAD’s color theme. I’ve been testing a bit here GitHub - CEXT-Dan/WxArx: Example using wxWidgets with AutoCAD's ObjectARX · GitHub. I assume python users will be able to control this, as wxTheApp and wx.App.Get() are pointing to the same instance.
isDark is ambiguous, is wxWidgets currently set in dark mode, is the OS in dark mode? So it’s clear, I’m not against this, just asking

How would this effect embedded projects where dark/light mode is set in the host application through wxWidgets?

I don’t know. It’s possible that I don’t understand the question. By “embedded”, do you mean an
application that owns the whole windowing system? If so, then I definitely have no idea.
Can wxPython set change dark/light mode?

I can see that what’s happening is that wxWidgets is “selecting” a date after changing the calendar, and I guess it’s working as designed.

My question: Is there a way to distinguish a real “user chose a date” event from “a date was selected due to navigating within the calendar”? The DateEvent object doesn’t seem to have anything that would help. Or, maybe, a way to turn off those “spurious” events?

I couldn’t see a way to get the behaviour you want using the DataViewListCtrl.

The UltimateListCtrl has a ULC_AUTOSIZE_FILL setting, but I could only get it to work on a single column.

Here is a simple example:

import wx
import wx.lib.agw.ultimatelistctrl as ULC

DATA = (
    ("aaaaa bbbbb ccccc ddddd eeeee fffff", "Red"),
    ("aaaaa bbbbb ccccc ddddd eeeee fffff ggggg", "Green"),
    ("aaaaa bbbbb ccccc ddddd eeeee fffff ggggg hhhhh", "Blue"),
)


class MyFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, -1, "ULC_AUTOSIZE_FILL Demo")
        self.SetSize(560, 300)
        agw_style = ULC.ULC_REPORT | ULC.ULC_VRULES | ULC.ULC_HRULES | ULC.ULC_SINGLE_SEL
        self.ulc = ULC.UltimateListCtrl(self, wx.ID_ANY, agwStyle=agw_style)

        self.ulc.InsertColumn(0, "Col 0")
        # This has no effect, only "Col 1" automatically resizes
        self.ulc.SetColumnWidth(0, ULC.ULC_AUTOSIZE_FILL)

        self.ulc.InsertColumn(1, "Col 1")
        # This works - the column fills the remaining 
        # space and resizes when the frame is resized
        self.ulc.SetColumnWidth(1, ULC.ULC_AUTOSIZE_FILL)
        
        self.ulc.InsertColumn(2, "Col 2")

        for i, (a, b) in enumerate(DATA):
            index = self.ulc.InsertStringItem(i, "Row %d" % i)
            self.ulc.SetStringItem(index, 1, a)
            self.ulc.SetStringItem(index, 2, b)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.ulc, 1, wx.EXPAND)

        self.SetSizer(sizer)
        self.Layout()


if __name__ == "__main__":
    app = wx.App(0)
    frame = MyFrame(None)
    frame.Show()
    app.MainLoop()

I want the last column of a DataViewLIstCtrl to have a fixed size, with remaining space spread out over all the other columns. Google results suggest this is accomplished by

• Setting the last column width to a fixed amount (i.e. 100px) and removing the wxDATAVIEW_COL_RESIZABLE flag
• Making all the other columns resizable

I did this but the last column still takes up all remaining space. Is this just a limitation of the Windows implementation?

Preferably, I don’t want to use any external packages

Do you mean “I don’t want to use any external packages except for the very large and complex external package called wxPython which is the focus of this discussion forum”?

darkdetect is pure python with minimal external dependencies (None on Window/Linux, 1 optional one on Mac), and is independent of the GUI toolkit.

My suggestion here is that wxPython add it as a dependency and use it, or (worse) simply borrow the code (BSD licensed).

As for the best practice for enabling dark mode on Windows, I’ll simply wait until everything is finalized and, if possible, for a concrete example of its use with wxPython.

Over at wxutils (GitHub - newville/wxutils: wxPython utilities and convenience functions · GitHub) (yes, an external package, so you may not be interested), I recently added darkdetect as a dependency and use it to set many colors by “logical name” (‘text’, ‘text_bg’, etc) that will have different values in Light and Dark mode. It also uses darkdetect 'listener" to run a daemon thread to run registered callbacks when the System mode changes. That means the widgets not only get usable colors when an App starts, but they change when the System mode changes. These changes are fairly new, and there may be a some issues, but the results are readable and don’t give dark text on a dark background or light text on a light background. That may be of interest to some readers here.

This is now used in the latest version of wxmplot (again, an external package and with its own external dependencies including matplotlib which you would probably not want to use, but that others might find useful), and in several downstream applications that I support. Some of these have somewhat complex GUI components and context-sensitive text colors, say using validators to color-code invalid values or warning levels. These are working well at both respecting the System mode at startup and adapting when that mode changes.

Those might count as concrete examples.

There is also the UltimateListCtrl widget which is often suggested here as many of the enhanced features from the mixins are already available.
However, I’ve never used this myself but could be worth also looking through the examples to see if it fits your needs,

GabboCH

• How to create a list control (info)

• How to create a list control (Phoenix)

• How to create a virtual list control (Phoenix)

• How to create a list control with a SQLite database (Phoenix)

  or updated:
  How to use the wx.ListCtrl widget with an SQLite 3 database

• How to create a virtual list control and a SQLite database (Phoenix)

• How to create a list control with drag and drop (Phoenix)

• How to create a validating editable list control extension (Phoenix)

• How to create a SQLite database easily (Phoenix)

• wx.ListCtrl Tips and Tricks

Regards

A possible alternative for that for-loop:

        for key, (icao, airfield) in self.itemDataMap.items():
            self.list_ctrl.Append((icao, airfield))
            # This is needed by ColumnSorterMixin
            self.list_ctrl.SetItemData(key, key)

Traceback (most recent call last):
File “R:\SimpleExample.py”, line 75, in
frame = MyFrame(None, wx.ID_ANY)
File “R:\SimpleExample.py”, line 42, in init
index = self.list_ctrl.InsertItem(sys.maxsize, icao)
wx._core.wxAssertionError: C++ assertion “info.m_itemId != -1” failed at …..\src\msw\listctrl.cpp(2001) in wxListCtrl::InsertItem(): Item ID must be set.

Rob

import sys
import wx
from wx.lib.mixins.listctrl import ColumnSorterMixin

AIRFIELDS = (
    ("EGBB", "Birmingham"),
    ("EGCC", "Manchester"),
    ("EGKB", "Biggin Hill"),
    ("EGKK", "Gatwick"),
    ("EGLC", "London City"),
    ("EGLF", "Farnborough"),
    ("EGLL", "Heathrow"),
    ("EGSS", "Stansted"),
)

COLUMN_SETTINGS = (
    ("ICAO", 100),
    ("Airfield", 160)
)

NUM_COLUMNS = len(COLUMN_SETTINGS)


class MyFrame(wx.Frame, ColumnSorterMixin):
    def __init__(self, parent, id=wx.ID_ANY):
        super().__init__(parent, id, "Click headings to sort")
        self.SetSize((400, 300))

        main_sizer = wx.BoxSizer(wx.VERTICAL)
        style = wx.LC_HRULES | wx.LC_REPORT | wx.LC_VRULES
        self.list_ctrl = wx.ListCtrl(self, wx.ID_ANY, style=style)

        ColumnSorterMixin.__init__(self, NUM_COLUMNS)

        for i, (heading, width) in enumerate(COLUMN_SETTINGS):
            self.list_ctrl.InsertColumn(i, heading, format=wx.LIST_FORMAT_CENTRE)
            self.list_ctrl.SetColumnWidth(i, width)

        self.itemDataMap = self.getDataDict()

        for key, (icao, airfield) in self.itemDataMap.items():
            index = self.list_ctrl.InsertItem(sys.maxsize, icao)
            self.list_ctrl.SetItem(index, 1, airfield)
            # This is needed by ColumnSorterMixin
            self.list_ctrl.SetItemData(index, key)

        main_sizer.Add(self.list_ctrl, 1, wx.EXPAND, 0)
        self.SetSizer(main_sizer)
        self.Layout()

        self.image_list = wx.ImageList(16, 16)
        self.down_arrow = self.image_list.Add(wx.Bitmap("arrow-down.png", wx.BITMAP_TYPE_PNG))
        self.up_arrow   = self.image_list.Add(wx.Bitmap("arrow-up.png", wx.BITMAP_TYPE_PNG))
        self.list_ctrl.SetImageList(self.image_list, wx.IMAGE_LIST_SMALL)


    @staticmethod
    def getDataDict():
        data_dict = {}
        for i, item in enumerate(AIRFIELDS):
            data_dict[i] = item
        return data_dict


    def GetListCtrl(self):
        return self.list_ctrl


    def GetSortImages(self):
        return self.up_arrow, self.down_arrow


if __name__ == "__main__":
    app = wx.App()
    frame = MyFrame(None, wx.ID_ANY)
    frame.Show()
    app.MainLoop()

You will need these icons:
icons.zip (1.2 KB)

Tested using: wxPython 4.2.5 gtk3 (phoenix) wxWidgets 3.2.9 + Python 3.12.3 + Linux Mint 22.3

When you unpack that file, you will get a wxPython-demo-4.2.3 folder.

Inside that folder there is a demo sub-folder.

To start the demo application, run the demo.py python script from that sub-folder.

https://extras.wxpython.org/wxPython4/extras/linux/gtk3/ubuntu-24.04/

I’m having issues with wx.glcanvas.GLCanvas. I originally wanted to create a wxVTKRenderWindowInteractor which failed due to problems that boil down to wxpython’s GLCanvas.

Most notably the GLCanvas.__init__ method, but even glcanvas.GLCanvas.IsDisplaySupported([glcanvas.WX_GL_RGBA]) fail with an error along the lines of SystemError: <built-in function IsDisplaySupported> returned a result with an exception set.

Full stack trace is

NotImplementedError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/home/user/developer/3d-medical-imaging/wx_test.py", line 4, in <module>
    glcanvas.GLCanvas.IsDisplaySupported([glcanvas.WX_GL_RGBA])
SystemError: <built-in function IsDisplaySupported> returned a result with an exception set

My specs are

Linux 6.14.0-37-generic #37~24.04.1-Ubuntu SMP PREEMPT_DYNAMIC x86_64 GNU/Linux
wxPython 4.2.5 from pypi
Python 3.11.14

I am not able to get any more meaningful debug messages. I tried

XDG_SESSION_TYPE=x11
WXTRACE=glcanvas
WXTRACE=all
WXDEBUG=1
G_MESSAGES_DEBUG=all
GDK_DEBUG=gl
GDK_BACKEND=x11

Maybe the problems are also called by other libraries. But I am unsure about how to approach that.

Thanks for any advice.

In my non-working initial example I had sizers directly nested within sizers. I understand this is supposed to be allowed, but in this case must have confused some part of the layout code.

Thanks for taking the time to treat my question seriously, your example helped.

RichardT:

I used wxGlade to initially create my example. It automatically adds a Panel to every Frame.

The panel handles keyboard navigation (e.g. the Tab key). Also, a frame without a panel has a different background colour on some systems, e.g. on Windows.
From looking at the example above, it seems that wxFormbuilder requires a sizer ‘between’ frame and panel. wxGlade did so until some years ago and I have removed this as it was really odd.

wxGlade does not directly support the DataViewListCtrl. What I do for unsupported controls is add a “custom widget” and then set it to the required class. See the documentation at Custom Widget — wxGlade 1.1.1 documentation

I have a Linux system as well and I’ll try it there. If I get the same results as you I guess I’ll file a bug, but it’s not clear against which component. Could be the Windows versions of wxWidgets or wxPython.

Also I’ll check out wxGlade. Thanks again.

Edit: when I run your example on my linux PC it does show the data items:

Edit2: when I added wx.EXPAND to this line:

bSizer4.Add( self.dvRegList, 1, wx.EXPAND|wx.ALL, 5 )

then dvRegList expanded vertically:

You have a top-level panel as a child of the frame, and wxFormBuilder won’t allow that.
Here’s what I see in wxFormBuilder:

The displayed window looks identical to what wxFormBuilder previews but I can’t add a second image.

The code generated by wxFormBuilder:

# -*- coding: utf-8 -*-

###########################################################################
## Python code generated with wxFormBuilder (version 4.2.1-0-g80c4cb6)
## http://www.wxformbuilder.org/
##
## PLEASE DO *NOT* EDIT THIS FILE!
###########################################################################

import wx
import wx.xrc
import wx.dataview

import gettext
_ = gettext.gettext

###########################################################################
## Class Sample2FrameBase
###########################################################################

class Sample2FrameBase ( wx.Frame ):

    def __init__( self, parent ):
        wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = wx.EmptyString, pos = wx.DefaultPosition, size = wx.Size( 571,369 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )

        self.SetSizeHints( wx.DefaultSize, wx.DefaultSize )

        bSizer1 = wx.BoxSizer( wx.VERTICAL )

        bSizer2 = wx.BoxSizer( wx.HORIZONTAL )

        self.m_panel2 = wx.Panel( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
        self.m_panel2.SetForegroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_WINDOW ) )
        self.m_panel2.SetBackgroundColour( wx.Colour( 128, 255, 255 ) )

        bSizer2.Add( self.m_panel2, 1, wx.EXPAND |wx.ALL, 5 )


        bSizer1.Add( bSizer2, 1, wx.EXPAND, 5 )

        bSizer3 = wx.BoxSizer( wx.VERTICAL )

        self.m_panel3 = wx.Panel( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
        self.m_panel3.SetBackgroundColour( wx.Colour( 255, 128, 64 ) )

        bSizer3.Add( self.m_panel3, 1, wx.EXPAND |wx.ALL, 5 )


        bSizer1.Add( bSizer3, 1, wx.EXPAND, 5 )

        bSizer4 = wx.BoxSizer( wx.HORIZONTAL )

        self.dvRegList = wx.dataview.DataViewListCtrl( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.dataview.DV_ROW_LINES )
        self.cRegType = self.dvRegList.AppendTextColumn( _(u"Type"), wx.dataview.DATAVIEW_CELL_ACTIVATABLE, -1, wx.ALIGN_LEFT, wx.dataview.DATAVIEW_COL_RESIZABLE )
        self.cWaitList = self.dvRegList.AppendTextColumn( _(u"W"), wx.dataview.DATAVIEW_CELL_INERT, -1, wx.ALIGN_LEFT, wx.dataview.DATAVIEW_COL_RESIZABLE )
        self.cRegName = self.dvRegList.AppendTextColumn( _(u"Name"), wx.dataview.DATAVIEW_CELL_INERT, -1, wx.ALIGN_LEFT, wx.dataview.DATAVIEW_COL_RESIZABLE )
        bSizer4.Add( self.dvRegList, 1, wx.ALL, 5 )


        bSizer1.Add( bSizer4, 3, wx.EXPAND, 5 )


        self.SetSizer( bSizer1 )
        self.Layout()

        self.Centre( wx.BOTH )

    def __del__( self ):
        pass

And the main program:

import Sample
import wx

class Sample2Frame(Sample.Sample2FrameBase):
    def __init__(self, parent):
        super(Sample2Frame, self).__init__(parent)
    def OnQuit(self, event):
        self.Close(True)

app = wx.App()
frm = Sample2Frame(None)

frm.dvRegList.AppendItem(["Type 1", "N", "John Doe"])
frm.dvRegList.AppendItem(["Type 2", "N", "Fred Bloggs"])
frm.dvRegList.AppendItem(["Type 1", "N", "Jane Doe"])

frm.Show()
frm.dvRegList.Refresh()

app.MainLoop()

In the example it didn’t seem to make any difference if bSizer4 was horizontal or vertical, dvRegList is displayed and resizes as I would expect, but perhaps I am not understanding the problem.

import wx
import wx.dataview as dv

class MyFrame(wx.Frame):
    def __init__(self, *args, **kwds):
        wx.Frame.__init__(self, *args, **kwds)

        self.panel1 = wx.Panel(self, wx.ID_ANY)
        bsizer1 = wx.BoxSizer(wx.VERTICAL)
        bsizer2 = wx.BoxSizer(wx.HORIZONTAL)
        bsizer1.Add(bsizer2, 1, wx.EXPAND, 0)
        self.panel2 = wx.Panel(self.panel1, wx.ID_ANY)
        self.panel2.SetBackgroundColour(wx.Colour(0, 127, 255))
        bsizer2.Add(self.panel2, 1, wx.EXPAND, 0)
        bsizer3 = wx.BoxSizer(wx.VERTICAL)
        bsizer1.Add(bsizer3, 1, wx.EXPAND, 0)
        self.panel3 = wx.Panel(self.panel1, wx.ID_ANY)
        self.panel3.SetBackgroundColour(wx.Colour(127, 255, 0))
        bsizer3.Add(self.panel3, 1, wx.EXPAND, 0)
        bsizer4 = wx.BoxSizer(wx.VERTICAL)
        bsizer1.Add(bsizer4, 3, wx.EXPAND, 0)
        self.dvRegList = dv.DataViewListCtrl(self.panel1, wx.ID_ANY, style=dv.DV_HORIZ_RULES|dv.DV_VERT_RULES)
        bsizer4.Add(self.dvRegList, 1, wx.EXPAND, 0)
        self.panel1.SetSizer(bsizer1)
        self.Layout()
        
        for c in range(3):
            self.dvRegList.AppendTextColumn(f"Column {c+1}")
            
        self.dvRegList.AppendItem(["1", "2", "3"])
        self.dvRegList.AppendItem(["4", "5", "6"])
        

if __name__ == "__main__":
    app = wx.App()
    frame = MyFrame(None, wx.ID_ANY, "DataViewList Layout", size=(400, 300))
    frame.Show()
    app.MainLoop()

Tested using: wxPython 4.2.5 gtk3 (phoenix) wxWidgets 3.2.9 + Python 3.12.3 + Linux Mint 22.3

I have created a Frame in wxFormBuilder with the following nested BoxSizer structure:

• bSizer1 (Vertical)
  • bSizer2 (Horizontal, proportion 1)
  • bSizer3 (Vertical, proportion 1)
  • bSizer4 (Horizontal, proportion 3)
    • DataViewListCtrl (name dvRegList)
      • DataViewListColumn
      • DataViewListColumn
      • DataViewListColumn

If bSizer4 is Vertical orientation, dvRegList does not expand horizontally to fill the sizer. It’s just a tiny border on the far left of the sizer, the height of the header row and just a few pixels wide. This is surprising because a button and static text in a vertical sizer display normally.

If bSizer4 is Horizontal, dvRegList expands horizontally but displays only the header, with none of the rows, even if I resize the window so that there’s obviously room for the rows.

The only way I can get it to display rows is to set a minimum height, and when I do it now behaves as expected… it fills its sizer both vertically and horizontally, and resizes with the window.

So I have 2 questions:

• Why does the DataViewListCtrl not fill the sizer when the sizer’s orientation is Vertical
• Why (when the sizer is Horizontal) does it need to have an explicit minimum vertical height set.

I would have expected the control to fill its sizer by default, and I can’t find anything in the docs that specifies the observed behavior.

I’m sure I’m missing something obvious, but would like to know where this is documented.

Thanks

test__dark_mode.py (5.4 KB)

After consulting the wxWidgets documentation and making a modification for Linux, I tried to enable dark mode on Windows with “w**xpython-4.3.0a16030”, unfortunately without success.

after you populate it, make sure you’ve called:

• SetScrollRate(...)
• Layout()
• FitInside() (if using sizers)
• and optionally Refresh() / Update()

also if you’re drawing manually, set SetVirtualSize() before showing the frame.

what’s happening is nothing triggers an initial paint, and the first scroll forces one — that’s why it suddenly appears. classic Scrolled Window Behaviour.

https://docs.wxwidgets.org/latest/classwx_system_appearance.html