pyqt5 | PyQt5 from riverbank

The problem is simple: QWidgets are hidden by default so isVisible() will return false, the solution is to invoke the show() method in init() to make it visible:

In first it is not necessary to make the verification be done in a new class, it is also logical that you invoke func_create_newitem since as you point out that method must be invoked when the item was not found.

There are several options:

• setBackgroundBrush():

The main problem is that you're adding widgets that can get focus, while the "viewer" doesn't have a focus, nor it can accept one by keyboard/mouse if not programmatically.

The result is that when the window is shown the first time, Qt will try to set the focus on the widget that can accept one within the central widget, but since there's none, any keyboard event is ignored. Whenever you try to use the arrow keys, then, Qt will use the "keyboard navigation" mode, and will find the first widget that can accept focus (the "search" button, if you go left), making the event accepted, and thus not propagated to the main window; going further, if you go left once more, the "tags" combo will get focused, again accepted and not propagated.

A temporary workaround could be to ensure that the buttons and line edit only get focus by clicking (but buttons should probably not get focus at all):

When you use VideoCapture with a file if you call "cap.read()" you will obtain the next frame on the video, regardless of its actual framerate. Hence, you should use a "msleep" every time you capture a frame:

The problem is that you're setting a QWidget for the item, and since you're using a universal selector (with the wildcard), the result is that all QWidget will have that background color, including those added as item widgets for the list view.
The color you used for the :selected pseudo is only valid for the item painted by the view, since the item widget has its own background set from the universal selector, that background won't be visible.

The solution is to use a proper selector combination ensuring that the rule only matches children of the list view that have a usable selector, and set a transparent color for those widgets.

A possibility is to set a custom property for the widgets that must be set before adding the widgets to the list (otherwise, you need to set the stylesheet after adding them, or request a style.unpolish()).

You have to use the QPixmap established in the QLabel that can be obtained through the pixmap() method. The problem is that you are obfuscating the access to that method since you have an attribute with a similar name. So the solution is to use pixmap() and rename the attribute pixmap.

Qt uses a concept called "Signal/Slot mechanism".

Every Qt object (QObject, which is inherited by all Qt widgets) is able to "emit" signals with a (possibly empty) amount of arguments, and that signal can be "registered" to slots, which are functions that will be called everytime that signal are emitted.^[1]

A typical case is a button (normally, a QPushButton), which has a clicked signal^[2] that is emitted whenever the button is clicked, meaning that the mouse cursor is over the button both when the mouse button is pressed and then released.

Every Qt widget has different signals depending on its purpose.
For instance, the QLineEdit control has a textChanged (that is emitted whenever the text is changed, even programmatically) and textEdited (which is only emitted when the user actually types something in it).
A QComboBox has the currentIndexChanged signal, emitted whenever the current item is changed (for instance, opening the popup and selecting a different item, or by using the mouse wheel over it).

In the following code, I'll be connecting to "slots" (in this case, simple python functions) by completely ignoring the arguments of the related signals, but there are cases for which those arguments are actually needed.

The idea is that whenever the user types something in any of the line edit fields, the related function tries to convert the typed value to a numeric one, and then, based on the current content of the comboboxes will do the proper conversion.

Consider that:

1. QLineEdit is not a suggested control for numeric input. A QSpinBox (for integers, otherwise a QDoubleSpinBox for floating points) is more suited for such situations; alternatively, setting a QIntValidator or QDoubleValidator on the line edit is possible.
2. Using combobox.addItem() allows setting user data for each item along with the visible label; I'm using that "hidden" data by means of currentData() for multiplicators that are used for the conversion; this also means that you should remove any existing item for those comboboxes from the UI in Designer.
3. Editing files generated by pyuic is considered bad practice (for a lot of reasons); I strongly suggest you to carefully read the official guidelines about using Designer, generate again the files from the UI and never touch them again (unless by overwriting with pyuic): those files should always be used as imports only. In the following code I'm assuming you've updated your UI (by removing the items in the first two combos) and converted them again to a file named unitConverterUi.py, which will NOT be the actual script you'll be running.
4. Using fixed geometries (manually positioning and resizing widgets) is rarely a good idea. Remember that what you see on your screen is almost always never what others will see on theirs. Read more about layout managers and how to use them in Designer. User interfaces should be able to adapt to the screen and system settings of the user (what is called "responsive design" in modern website design).