### Setup Asynchronous Event Loop in PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/Test/Network/README.md

This code snippet initializes an asynchronous event loop in a PyQt5 application to enable integration with asyncio for handling asynchronous HTTP requests. It depends on libraries such as quamash, asyncio, and aiohttp, which must be installed separately. The code sets up the QApplication, replaces the default event loop with a QEventLoop, and instantiates a Window object, allowing for concurrent async tasks without blocking the GUI.

```python
app = QApplication(sys.argv)
loop = QEventLoop(app)
asyncio.set_event_loop(loop)
w = Window()
```

--------------------------------

### Configure PyQt5 compilation settings for NinePatch library

Source: https://github.com/pyqt5/pyqt/blob/master/QLabel/README.md

Sets platform and Qt installation paths required to build the NinePatch C++ extension for PyQt5. This snippet is used before running the configure script and must match the local Visual C++ version and Qt directory. It outputs configuration values consumed by the build process.

```python
# 这里是你的VC版本和对应的Qt目录中的文件夹
config.platform = "win32-msvc2010"
qt_path = 'D:/soft/Qt/Qt5.5.1/5.5/msvc2010'
```

--------------------------------

### Create window fade in/out effect with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QPropertyAnimation/README.md

Implements window fade in and fade out animations using QPropertyAnimation on the windowOpacity property. When the window starts, it animates opacity from 0 to 1. When closing, it animates from 1 to 0 and connects the finished signal to close the window. Requires stopping previous animations before starting new ones.

```python
# Window fade in/out implementation would typically involve:
# 1. Creating QPropertyAnimation targeting 'windowOpacity'
# 2. Setting startValue(0.0) and endValue(1.0) for fade in
# 3. Setting startValue(1.0) and endValue(0.0) for fade out
# 4. Connecting finished signal to close() for fade out
# See FadeInOut.py for complete implementation
```

--------------------------------

### Create page switching/slider animation with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QPropertyAnimation/README.md

Implements sliding page transition animations for QStackedWidget using QPropertyAnimation. Animates position properties of child widgets to create smooth page switching effects. Includes functions for next/previous page navigation and automatic slideshow mode with configurable timing. Based on Qt wiki examples with added auto-switch functionality.

```python
# Page switching implementation would typically involve:
# 1. Extending QStackedWidget class
# 2. Using QPropertyAnimation on widget positions
# 3. Implementing slideInNext(), slideInPrev(), setCurrentIndex()
# 4. Adding autoStart(msec) for slideshow mode
# See PageSwitching.py for complete implementation
```

--------------------------------

### JavaScript WebSocket and QWebChannel Integration

Source: https://github.com/pyqt5/pyqt/blob/master/QWebChannel/Data/CallEachWithJs.html

This JavaScript code sets up a WebSocket connection to a local server and utilizes QWebChannel to communicate with a PyQt5 application. It handles WebSocket events like opening, closing, and errors, and connects to signals from the Python backend, such as window title changes.

```javascript
function appendText(message) { 
  var textArea = document.getElementById("textArea");
  output.innerHTML = output.innerHTML + message + "\n"; 
}
window.onload = function () { 
  var socket = new WebSocket("ws://localhost:12345");
  socket.onclose = function () {
    appendText("WebSocket连接关闭");
  };
  socket.onerror = function () {
    appendText("WebSocket连接发生错误");
  };
  socket.onopen = function () {
    appendText("WebSocket连接成功");
    window.channel = new QWebChannel(socket, function (channel) {
      window.WebChannelObject = channel.objects.WebChannelObject;
      window.qtwindow = channel.objects.qtwindow;
      window.qtwindow.windowTitleChanged.connect(function (title) {
        appendText('标题变化：' + title);
      });
    });
  };
};
```

--------------------------------

### Invoke Python method from JavaScript using QWebChannel

Source: https://github.com/pyqt5/pyqt/blob/master/QWebEngineView/Data/JsSignals.html

Demonstrates how to call a Python-exposed method from JavaScript via the Bridge object created by QWebChannel. The Python method must be decorated with @pyqtSlot(str) to be callable. This example passes a test string to the Python slot.

```Script
Bridge.callFromJs('test');
```

--------------------------------

### Create window shake animation with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QPropertyAnimation/README.md

Creates window shaking effect by applying QPropertyAnimation to control position properties. Rapidly modifies the pos attribute to simulate shaking motion. Useful for drawing attention to windows or indicating errors. Simple implementation that directly manipulates widget positioning properties over time.

```python
# Window shake implementation would typically involve:
# 1. Creating QPropertyAnimation targeting 'pos' property
# 2. Defining keyframes for shake positions
# 3. Setting animation duration and easing curve
# See ShakeWindow.py for complete implementation
```

--------------------------------

### Create context menu animation with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QPropertyAnimation/README.md

Applies animation to context menu geometry property using QPropertyAnimation. The animation triggers when contextMenuEvent is fired and shows the menu during the animation. This creates smooth menu appearance transitions by modifying the menu's geometry properties over time.

```python
# Context menu animation implementation would typically involve:
# 1. Override contextMenuEvent method
# 2. Create QPropertyAnimation targeting menu 'geometry'
# 3. Set start and end geometry values
# 4. Start animation and show menu
# See MenuAnimation.py for complete implementation
```

--------------------------------

### Create window flip animation with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QPropertyAnimation/README.md

Implements 3D-like window flipping animation similar to QQ client. Uses two QLabels in a QStackedWidget to represent front/back interfaces. Captures screenshots of current views and passes them to flip animation widget. Controls main window visibility using setWindowOpacity while performing flip transitions. Handles 0-90 and 90-180 degree rotation phases with appropriate scaling.

```python
# Window flip implementation would typically involve:
# 1. Two QLabels in QStackedWidget for front/back views
# 2. Screenshot capture of current interfaces
# 3. FlipWidget for handling image rotation animation
# 4. setWindowOpacity for main window show/hide
# See FlipWidgetAnimation.py for complete implementation
```

--------------------------------

### Initialize QWebChannel and bind Qt signals in JavaScript

Source: https://github.com/pyqt5/pyqt/blob/master/QWebEngineView/Data/JsSignals.html

Creates a QWebChannel connection between the web page and the PyQt5 application, binds the windowTitleChanged and customSignal signals to JavaScript handlers, and a helper function to log messages to a textarea. Requires the Qt WebChannel JavaScript library and a QWebChannel object exposed from Python. Logs are appended with newline characters.

```Java
new QWebChannel(qt.webChannelTransport, function(channel) {\n    window.Bridge = channel.objects.Bridge;\n    // 这里绑定窗口的标题变化信号（这个信号是由QWidget内部的）\n    Bridge.windowTitleChanged.connect(function(title) {\n        showLog(\"标题被修改为：\" + title);\n    });\n    // 绑定自定义的信号customSignal\n    Bridge.customSignal.connect(function(text) {\n        showLog(\"收到自定义信号内容：\" + text);\n    });\n});\nfunction showLog(text) {\n    var ele = document.getElementById(\"result\");\n    ele.value = ele.value + text + "\n";\n}
```

--------------------------------

### Python: Implement Multi-Select QMenu

Source: https://github.com/pyqt5/pyqt/blob/master/QMenu/README.md

This code snippet demonstrates how to create a QMenu with multi-selection capabilities and prevents the menu from closing after each item selection. It involves overriding the mouseReleaseEvent to handle action clicks and allowing for custom logic based on the clicked action's properties.  The example aims to mimic desired behavior where multiple menu items can be selected without closing the menu.

```python
def _menu_mouseReleaseEvent(self, event):
    action = self._menu.actionAt(event.pos())
    if not action:
        # 没有找到action就交给QMenu自己处理
        return QMenu.mouseReleaseEvent(self._menu, event)
    if action.property('canHide'):  # 如果有该属性则给菜单自己处理
        return QMenu.mouseReleaseEvent(self._menu, event)
    # 找到了QAction则只触发Action
    action.activate(action.Trigger)
```

--------------------------------

### Find closest points algorithm in JavaScript and Python

Source: https://github.com/pyqt5/pyqt/blob/master/QPropertyAnimation/README.md

Implementation of point proximity algorithm to find 5 closest points for each point in a set. Used for creating lattice/particle effects where connected points are visually linked. The JavaScript version performs better than Python due to language differences. Both versions iterate through point sets and calculate distances to determine relationships.

```javascript
// for each point find the 5 closest points
for(var i = 0; i < points.length; i++) {
    var closest = [];
    var p1 = points[i];
    for(var j = 0; j < points.length; j++) {
        var p2 = points[j]
        if(!(p1 == p2)) {
            var placed = false;
            for(var k = 0; k < 5; k++) {
                if(!placed) {
                    if(closest[k] == undefined) {
                        closest[k] = p2;
                        placed = true;
                    }
                }
            }

            for(var k = 0; k < 5; k++) {
                if(!placed) {
                    if(getDistance(p1, p2) < getDistance(p1, closest[k])) {
                        closest[k] = p2;
                        placed = true;
                    }
                }
            }
        }
    }
    p1.closest = closest;
}
```

```python
def findClose(points):
    plen = len(points)
    for i in range(plen):
        closest = [None, None, None, None, None]
        p1 = points[i]
        for j in range(plen):
            p2 = points[j]
            dte1 = getDistance(p1, p2)
            if p1 != p2:
                placed = False
                for k in range(5):
                    if not placed:
                        if not closest[k]:
                            closest[k] = p2
                            placed = True
                for k in range(5):
                    if not placed:
                        if dte1 < getDistance(p1, closest[k]):
                            closest[k] = p2
                            placed = True
        p1.closest = closest
```

--------------------------------

### Call Python Method from JavaScript

Source: https://github.com/pyqt5/pyqt/blob/master/QWebView/Data/JsSignals.html

This example showcases how to call a Python function defined in PyQt5 from JavaScript. The Python function is decorated with `@pyqtSlot(str)` to expose it. The provided JavaScript code calls `Bridge.callFromJs('test')` to invoke the Python function with the argument 'test'.

```JavaScript
Bridge.callFromJs('test')
```

--------------------------------

### Execute Default and Custom Sorting Operations

Source: https://github.com/pyqt5/pyqt/blob/master/QListView/README.md

Demonstrates how to apply sorting in QListView using the custom proxy model. The first block restores original order by sorting on IdRole. The second block shows the complete sequence for classification-based sorting: setting the置顶 index, configuring roles, and executing the sort operation on column 0.

```python
# 恢复默认排序
self.fmodel.setSortRole(IdRole)     # 必须设置排序角色为ID
self.fmodel.sort(0)                 # 排序第一列按照ID升序

# 根据分类排序
self.fmodel.setSortIndex(1)
self.fmodel.setSortRole(IdRole)
self.fmodel.setSortRole(ClassifyRole)
self.fmodel.sort(0)
```

--------------------------------

### Signal Binding in PyQt5 QML Interaction - JavaScript

Source: https://github.com/pyqt5/pyqt/blob/master/QtQuick/README.md

This snippet shows QML code for binding signals and slots between QML components and Python objects in a PyQt5 application. It uses Component.onCompleted to connect QML signals to Python methods and vice versa. Requires a PyQt5 setup with a registered Python object and appropriate decorators on Python methods.

```javascript
Component.onCompleted: {
    // 绑定信号槽到python中的函数
    valueChanged.connect(_Window.onValueChanged)
    // 绑定python中的信号到qml中的函数
    _Window.timerSignal.connect(appendText)
}
```

--------------------------------

### Implement setSortIndex Method in Proxy Model

Source: https://github.com/pyqt5/pyqt/blob/master/QListView/README.md

Adds a custom method to QSortFilterProxyModel to store the classification ID that should be pinned to the top during sorting. This method accepts an index parameter and stores it as an instance variable for use in the sorting logic.

```python
def setSortIndex(self, index):
    self._topIndex = index
```

--------------------------------

### Define Classification Dictionaries for Sorting

Source: https://github.com/pyqt5/pyqt/blob/master/QListView/README.md

Creates bidirectional mappings for Chinese dynasty classifications. NameDict maps dynasty names to English translations and numerical IDs. IndexDict provides reverse lookup from IDs to dynasty names. These dictionaries enable implementing custom sorting logic based on historical categories in QListView.

```python
NameDict = {
    '唐': ['Tang', 0],
    '宋': ['Song', 1],
    '元': ['Yuan', 2],
    '明': ['Ming', 3],
    '清': ['Qing', 4],
}
IndexDict = {
    0: '唐',
    1: '宋',
    2: '元',
    3: '明',
    4: '清',
}
```

--------------------------------

### Override lessThan Method for Pin-to-Top Sorting

Source: https://github.com/pyqt5/pyqt/blob/master/QListView/README.md

Implements custom comparison logic in QSortFilterProxyModel to prioritize a specific classification. When sorting by ClassifyRole, items matching the置顶 index are treated as -1, ensuring they appear first. The method compares left and right indices in ascending order while respecting the pinned item priority.

```python
if self.sortRole() == ClassifyRole and \
        source_left.column() == self.sortColumn() and \
        source_right.column() == self.sortColumn():
    # 获取左右两个的分类
    leftIndex = source_left.data(ClassifyRole)
    rightIndex = source_right.data(ClassifyRole)

    # 升序
    if self.sortOrder() == Qt.AscendingOrder:
        # 保持在最前面
        if leftIndex == self._topIndex:
            leftIndex = -1
        if rightIndex == self._topIndex:
            rightIndex = -1

        return leftIndex < rightIndex
```

--------------------------------

### Monitor QWebEngineDownloadItem progress in PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/Test/partner_625781186/6.QWebEngineView下载文件/readme.md

Connects the downloadProgress and finished signals of QWebEngineDownloadItem to track download progress and completion. These signals provide updates during the download process and notify when the download is complete.

```Python
QWebEngineDownloadItem().downloadProgress.connect(self._downloadProgress)
```

```Python
QWebEngineDownloadItem().finished.connect(self._finished)
```

--------------------------------

### SKU Widget Class

Source: https://github.com/pyqt5/pyqt/blob/master/Test/partner_625781186/5.hoverMenu/Documentation/5.hoverMenu.U_FuncWidget.UCompetitiveProduct2.SKU_Widget.md

The SKU Widget class provides the interface for SKU analysis menu in the PyQt5 application.

```APIDOC
## SKU Widget Class

### Description
Class representing the SKU analysis menu interface in PyQt5.

### Derived From
QWidget, Ui_Form

### Class Attributes
- **app** - Application reference
- **ui** - UI reference

### Methods
#### Form (Constructor)

##### Description
Initializes the SKU Widget.

##### Parameters
- **parent** (QWidget) - Optional - Reference to the parent widget
```

--------------------------------

### Set Stretch Factors in PyQt5 VerticalLayout

Source: https://github.com/pyqt5/pyqt/blob/master/QVBoxLayout/README.md

This Python code sets stretch factors for a QVBoxLayout to allocate proportional space among three widgets, with ratios 1:2:3. It requires PyQt5 and assumes a self.verticalLayout object exists. Outputs adjust widget sizes dynamically; limitations include dependency on layout initialization and widget addition order for proper stretch application.

```python
self.verticalLayout.setStretch(0, 1)
self.verticalLayout.setStretch(1, 2)
self.verticalLayout.setStretch(2, 3)
```

--------------------------------

### Connect QWebEngineView download signals in PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/Test/partner_625781186/6.QWebEngineView下载文件/readme.md

Connects the downloadRequested signal of QWebEngineView to a handler function. This allows the application to intercept and handle file download requests initiated by the web view.

```Python
QWebEngineView().page().profile().downloadRequested.connect(self.on_downloadRequested)
```

--------------------------------

### Bind Window Title Changed Signal (JavaScript)

Source: https://github.com/pyqt5/pyqt/blob/master/QWebView/Data/JsSignals.html

This snippet demonstrates binding the window title changed signal from a PyQt5 window to a JavaScript function. The `showLog` function is used to display the new title in a log area. This allows JavaScript to react to changes in the window title.

```JavaScript
Bridge.windowTitleChanged.connect({fun: function(title) { showLog("标题被修改为:" + title); }}, "fun");
function showLog(text) {
  var ele = document.getElementById("result");
ele.value = ele.value + text + "\\n";
}
```

--------------------------------

### Send Custom Signal (JavaScript)

Source: https://github.com/pyqt5/pyqt/blob/master/QWebView/Data/JsSignals.html

This snippet shows how to send a custom signal from PyQt5 and receive it in JavaScript. Clicking a button triggers the `customSignal`, and the JavaScript code displays the received signal content in the log area. This enables communication between PyQt5 and JavaScript through custom signals.

```JavaScript
Bridge.customSignal.connect({fun: function(text) { showLog("收到自定义信号内容:" + text); }}, "fun");
function showLog(text) {
  var ele = document.getElementById("result");
ele.value = ele.value + text + "\\n";
}
```

--------------------------------

### Invoke Slot with Args and Return Value (Sync) in PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QMetaObject/README.md

Shows how to invoke a slot function with a boolean argument and retrieve an integer return value synchronously using QMetaObject.invokeMethod with a direct connection. Both `Q_RETURN_ARG` and `Q_ARG` are used to manage the return type and input parameters.

```python
from PyQt5.QtCore import QMetaObject, Qt

# Assuming 'uiobj' is a valid QObject instance and 'slot_method' takes bool, returns int
argument_value = False
return_value = QMetaObject.invokeMethod(uiobj, 'slot_method', Qt.DirectConnection, Q_RETURN_ARG(int), Q_ARG(bool, argument_value))
print(f'Received integer return value: {return_value}')
```

--------------------------------

### Invoke Slot with Return Value (Sync) in PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QMetaObject/README.md

Demonstrates how to invoke a slot function synchronously and retrieve its string return value using QMetaObject.invokeMethod with a direct connection. This is useful when a result is immediately needed from the UI thread.

```python
from PyQt5.QtCore import QMetaObject, Qt

# Assuming 'uiobj' is a valid QObject instance and 'slot_method' returns a string
return_value = QMetaObject.invokeMethod(uiobj, 'slot_method', Qt.DirectConnection, Q_RETURN_ARG(str))
print(f'Received return value: {return_value}')
```

--------------------------------

### Execute Function in Delayed Thread - Python

Source: https://github.com/pyqt5/pyqt/blob/master/Test/全局热键/README.md

Schedules a function to run asynchronously in a new thread after a short delay. Accepts a function reference, argument tuple, and delay duration. Prevents blocking the main execution flow by offloading work to a separate thread, useful for processing events in UI applications.

```python
def call_later(fn, args=(), delay=0.001):
    """
    Calls the provided function in a new thread after waiting some time.
    Useful for giving the system some time to process an event, without blocking
    the current execution flow.
    """
    thread = _Thread(target=lambda: (_time.sleep(delay), fn(*args)))
    thread.start()
```

--------------------------------

### Invoke Slot with Arguments in Thread (PyQt5)

Source: https://github.com/pyqt5/pyqt/blob/master/QMetaObject/README.md

Illustrates invoking a slot with string arguments on a UI object from a separate thread using QMetaObject.invokeMethod with a queued connection. The `Q_ARG` macro is used to specify the argument type and value.

```python
from PyQt5.QtCore import QMetaObject, Qt

# Assuming 'uiobj' is a valid QObject instance and 'method' is a slot accepting a string
text_to_send = 'Hello from thread!'
QMetaObject.invokeMethod(uiobj, 'method', Qt.QueuedConnection, Q_ARG(str, text_to_send))
```

--------------------------------

### Invoke Slot in Thread with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QMetaObject/README.md

Demonstrates how to invoke a slot function on a UI object from a separate thread using QMetaObject.invokeMethod with a queued connection. This is the recommended approach for safely updating UI elements from non-GUI threads.

```python
from PyQt5.QtCore import QMetaObject, Qt

# Assuming 'uiobj' is a valid QObject instance and 'slot_method' is a defined slot
QMetaObject.invokeMethod(uiobj, 'slot_method', Qt.QueuedConnection)
```

--------------------------------

### Invoke Signal in Thread with PyQt5

Source: https://github.com/pyqt5/pyqt/blob/master/QMetaObject/README.md

Shows how to invoke a signal on a UI object from a separate thread using QMetaObject.invokeMethod with a queued connection. This allows emitting signals from worker threads that are connected to slots in the UI thread.

```python
from PyQt5.QtCore import QMetaObject, Qt

# Assuming 'uiobj' is a valid QObject instance and 'signal_method' is a defined signal
QMetaObject.invokeMethod(uiobj, 'signal_method', Qt.QueuedConnection)
```

--------------------------------

### Override QSlider Mouse Press for Click-to-Jump (Python)

Source: https://github.com/pyqt5/pyqt/blob/master/QSlider/README.md

Implements custom mouse press event handling for QSlider to enable direct jumping to the clicked position. It calculates the slider handle's rectangle and, if the click is within it, delegates to the default behavior. Otherwise, it calculates the new value based on the click position and slider orientation, then sets the slider's value. This requires PyQt5.

```python
def mousePressEvent(self, event):
    # 获取上面的拉动块位置
    option = QStyleOptionSlider()
    self.initStyleOption(option)
    rect = self.style().subControlRect(
        QStyle.CC_Slider, option, QStyle.SC_SliderHandle, self)
    if rect.contains(event.pos()):
        # 如果鼠标点击的位置在滑块上则交给Qt自行处理
        super(JumpSlider, self).mousePressEvent(event)
        return
    if self.orientation() == Qt.Horizontal:
        # 横向，要考虑invertedAppearance是否反向显示的问题
        self.setValue(self.style().sliderValueFromPosition(
            self.minimum(), self.maximum(),
            event.x() if not self.invertedAppearance() else (self.width(
            ) - event.x()), self.width()))
    else:
        # 纵向
        self.setValue(self.style().sliderValueFromPosition(
            self.minimum(), self.maximum(),
            (self.height() - event.y()) if not self.invertedAppearance(
            ) else event.y(), self.height()))
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.