### Basic HTMLLabel Usage in Tkinter

Source: https://github.com/bauripalash/tkhtmlview/blob/main/README.md

Demonstrates how to create and display an HTMLLabel widget with basic HTML styling. Ensure tkinter and tkhtmlview are installed.

```python
import tkinter as tk
from tkhtmlview import HTMLLabel

root = tk.Tk()
html_label = HTMLLabel(root, html='<h1 style="color: red; text-align: center"> Hello World </H1>')
html_label.pack(fill="both", expand=True)
html_label.fit_height()
root.mainloop()
```

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

### Create a TkHTMLView Application

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

A comprehensive example demonstrating the use of HTMLLabel and HTMLScrolledText within a tkinter application structure.

```python
import tkinter as tk
from tkinter import ttk
from tkhtmlview import HTMLScrolledText, HTMLLabel

class HTMLViewer:
    def __init__(self, root):
        self.root = root
        self.root.title("TkHTMLView Demo Application")
        self.root.geometry("800x700")

        # Header
        header = HTMLLabel(
            root,
            html='<h1 style="color: #2c3e50; text-align: center;">TkHTMLView Demo</h1>'
        )
        header.pack(fill="x", padx=10, pady=5)
        header.fit_height()

        # Navigation buttons
        nav_frame = tk.Frame(root)
        nav_frame.pack(fill="x", padx=10, pady=5)

        ttk.Button(nav_frame, text="Home", command=self.show_home).pack(side=tk.LEFT, padx=2)
        ttk.Button(nav_frame, text="Features", command=self.show_features).pack(side=tk.LEFT, padx=2)
        ttk.Button(nav_frame, text="Examples", command=self.show_examples).pack(side=tk.LEFT, padx=2)

        # Main content area
        self.content = HTMLScrolledText(root)
        self.content.pack(fill="both", expand=True, padx=10, pady=10)

        self.show_home()

    def show_home(self):
        self.content.set_html("""
            <h2 style="color: #3498db;">Welcome to TkHTMLView</h2>
            <p>A lightweight HTML rendering library for tkinter applications.</p>

            <h3>Quick Start</h3>
            <pre style="font-family: Consolas;">
from tkhtmlview import HTMLLabel
import tkinter as tk

root = tk.Tk()
label = HTMLLabel(root, html='&lt;h1&gt;Hello&lt;/h1&gt;')
label.pack()
root.mainloop()
            </pre>

            <p>Click the navigation buttons above to explore more features.</p>
        """)

    def show_features(self):
        self.content.set_html("""
            <h2 style="color: #27ae60;">Supported Features</h2>

            <h3>Text Formatting</h3>
            <ul>
                <li><b>Bold text</b> with &lt;b&gt; or &lt;strong&gt;</li>
                <li><i>Italic text</i> with &lt;i&gt; or &lt;em&gt;</li>
                <li><u>Underlined text</u> with &lt;u&gt;</li>
                <li><mark>Highlighted text</mark> with &lt;mark&gt;</li>
            </ul>

            <h3>Headings</h3>
            <h1>H1 Heading</h1>
            <h2>H2 Heading</h2>
            <h3>H3 Heading</h3>

            <h3>Hyperlinks</h3>
            <p><a href="https://github.com">Links open in browser</a></p>
        """)

    def show_examples(self):
        self.content.set_html("""
            <h2 style="color: #9b59b6;">Code Examples</h2>

            <h3>Ordered List</h3>
            <ol type="1">
                <li>First step</li>
                <li>Second step</li>
                <li>Third step</li>
            </ol>

            <h3>Data Table</h3>
            <table>
                <tr>
                    <th style="background-color: #ecf0f1;">Feature</th>
                    <th style="background-color: #ecf0f1;">Status</th>
                </tr>
                <tr>
                    <td>HTML Parsing</td>
                    <td style="color: green;">Supported</td>
                </tr>
                <tr>
                    <td>CSS Styles</td>
                    <td style="color: green;">Partial</td>
                </tr>
                <tr>
                    <td>Images</td>
                    <td style="color: green;">Supported</td>
                </tr>
            </table>

            <h3>Styled Paragraph</h3>
            <p style="background-color: #f9e79f; color: #7d6608; font-size: 16px;">
                This paragraph demonstrates multiple CSS properties applied together.
            </p>
        """)

if __name__ == "__main__":
    root = tk.Tk()
    app = HTMLViewer(root)
    root.mainloop()
```

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

### Rendering HTML from a File with HTMLText

Source: https://github.com/bauripalash/tkhtmlview/blob/main/README.md

Shows how to load and render HTML content from a local file into an HTMLText widget. This is useful for managing larger HTML structures separately. The RenderHTML utility is used for this purpose.

```html
<!DOCTYPE html>
<html>
    <body>
        <h1>Orange is so Orange</h1>
        <img
        src="https://interactive-examples.mdn.mozilla.net/media/cc0-images/grapefruit-slice-332-332.jpg"
        />
        <p>
        The orange is the fruit of various citrus species in the family Rutaceae;
        it primarily refers to Citrus × sinensis, which is also called sweet
        orange, to distinguish it from the related Citrus × aurantium, referred to
        as bitter orange.
        </p>
    </body>
</html>
```

```python
import tkinter as tk
from tkhtmlview import HTMLText, RenderHTML

root = tk.Tk()
html_label = HTMLText(root, html=RenderHTML('index.html'))
html_label.pack(fill="both", expand=True)
html_label.fit_height()
root.mainloop()
```

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

### Method: set_html

Source: https://github.com/bauripalash/tkhtmlview/blob/main/README.md

Updates the content of the widget by parsing and rendering the provided HTML string.

```APIDOC
## set_html(html, strip=True)

### Description
Sets the text content of the widget using HTML formatting.

### Parameters
#### Arguments
- **html** (string) - Required - The input HTML string to be rendered.
- **strip** (boolean) - Optional - If True (default), handles spaces in HTML-like style.
```

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

### Method: fit_height

Source: https://github.com/bauripalash/tkhtmlview/blob/main/README.md

Adjusts the widget height to ensure all wrapped lines are visible.

```APIDOC
## fit_height()

### Description
Calculates and sets the widget height to display all wrapped lines without clipping.
```

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

### Load HTML from External File using RenderHTML

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Utilize the RenderHTML class to load HTML content from an external .html file. This allows for better separation of HTML content and Python code. The loaded HTML can then be used with HTML widgets, and the raw HTML string can be accessed using get_html().

```python
import tkinter as tk
from tkhtmlview import HTMLText, RenderHTML

# First, create an HTML file (content.html):
# <!DOCTYPE html>
# <html>
#     <body>
#         <h1>Welcome</h1>
#         <p>This content is loaded from an external file.</p>
#         <img src="logo.png" width="100" height="100" />
#     </body>
# </html>

root = tk.Tk()
root.title("RenderHTML Example")

# Load HTML from external file
rendered_html = RenderHTML('content.html')

# Use rendered HTML with widget
html_widget = HTMLText(root, html=rendered_html)
html_widget.pack(fill="both", expand=True)
html_widget.fit_height()

# You can also access the raw HTML string
print(rendered_html.get_html())

root.mainloop()
```

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

### Class: RenderHTML

Source: https://github.com/bauripalash/tkhtmlview/blob/main/README.md

Utility class used to load and render HTML content from external files.

```APIDOC
## RenderHTML(file_path)

### Description
Loads an HTML file from the local filesystem to be used as input for widget rendering.

### Parameters
#### Arguments
- **file_path** (string) - Required - The path to the .html file to be rendered.
```

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

### Render Preformatted Text and Code in Tkinter

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Uses pre and code tags to display monospaced text and code snippets while preserving whitespace.

```python
import tkinter as tk
from tkhtmlview import HTMLScrolledText

root = tk.Tk()
root.title("Code Example")
root.geometry("600x500")

html_content = """
    <h2>Code Examples</h2>

    <h3>Preformatted Block (preserves spacing)</h3>
    <pre style="font-family: Consolas; font-size: 80%">
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Calculate first 10 numbers
for i in range(10):
    print(fibonacci(i))
    </pre>

    <h3>Inline Code</h3>
    <p>Use the <code>print()</code> function to output text.</p>
    <p>Variables are declared with <code>name = value</code> syntax.</p>

    <h3>Styled Pre Block</h3>
    <pre style="font-family: Courier; background-color: #f4f4f4;">
┌──────────┬──────────┐
│  Column1 │  Column2 │
├──────────┼──────────┤
│  Value1  │  Value2  │
└──────────┴──────────┘
    </pre>
"""

widget = HTMLScrolledText(root, html=html_content)
widget.pack(fill="both", expand=True, padx=10, pady=10)

root.mainloop()
```

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

### Render Hyperlinks in Tkinter

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Uses HTMLLabel to display clickable links that open in the default system browser. Links automatically inherit blue underline styling and cursor changes.

```python
import tkinter as tk
from tkhtmlview import HTMLLabel

root = tk.Tk()
root.title("Hyperlinks Example")

html_content = """
    <h2>Useful Links</h2>

    <p>Check out these resources:</p>

    <ul>
        <li><a href="https://www.python.org">Python Official Website</a></li>
        <li><a href="https://docs.python.org/3/library/tkinter.html">Tkinter Documentation</a></li>
        <li><a href="https://github.com/bauripalash/tkhtmlview">TkHTMLView on GitHub</a></li>
    </ul>

    <p>Links with custom styling:</p>
    <a href="https://example.com" style="color: green;">Green styled link</a>

    <p>Visited links change to purple color.</p>
"""

widget = HTMLLabel(root, html=html_content)
widget.pack(fill="both", expand=True, padx=10, pady=10)
widget.fit_height()

root.mainloop()
```

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

### Create and Display HTMLText

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Use HTMLText for displaying HTML content that fits within a fixed area without a scrollbar. It is editable by default. Call fit_height() to adjust the widget's height to its content.

```python
import tkinter as tk
from tkhtmlview import HTMLText

root = tk.Tk()
root.title("HTMLText Example")

# Create HTML text widget with multiple formatted elements
html_text = HTMLText(root, html="""
    <h2>Product Description</h2>
    <p style="color: #333;">
        This product features <b>premium quality</b> materials
        and <i>innovative design</i>.
    </p>
    <ul>
        <li>Lightweight construction</li>
        <li>Durable materials</li>
        <li>Easy assembly</li>
    </ul>
""")
html_text.pack(fill="both", expand=True, padx=10, pady=10)
html_text.fit_height()
```

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

### Create and Display HTMLLabel

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Use HTMLLabel to display static HTML content styled as a label. It inherits from tkinter.Text but is non-editable by default. Call fit_height() to adjust the widget's height to its content.

```python
import tkinter as tk
from tkhtmlview import HTMLLabel

root = tk.Tk()
root.title("HTMLLabel Example")

# Create an HTML label with styled heading
html_label = HTMLLabel(
    root,
    html='<h1 style="color: red; text-align: center">Hello World</h1>'
)
html_label.pack(fill="both", expand=True)
html_label.fit_height()  # Adjust widget height to fit content

root.mainloop()
```

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

### Update HTML Content Dynamically with set_html()

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Use set_html() to change the displayed HTML content of an HTMLLabel widget after initialization. The strip parameter can be used to control whitespace preservation.

```python
import tkinter as tk
from tkhtmlview import HTMLLabel

root = tk.Tk()
root.title("Dynamic HTML Update")

html_label = HTMLLabel(root)
html_label.pack(fill="both", expand=True, padx=10, pady=10)

# Initial content
html_label.set_html('<p style="color: gray;">Click a button to load content</p>')

def load_content_a():
    html_label.set_html("""
        <h2 style=\"color: blue;">Content A</h2>
        <p>This is the <b>first</b> content section.</p>
    """)
    html_label.fit_height()

def load_content_b():
    # strip=False preserves whitespace exactly as written
    html_label.set_html("""
        <h2 style=\"color: green;">Content B</h2>
        <pre>Preformatted   text   with   spaces</pre>
    """, strip=True)
    html_label.fit_height()

btn_frame = tk.Frame(root)
btn_frame.pack(pady=10)
tk.Button(btn_frame, text="Load A", command=load_content_a).pack(side=tk.LEFT, padx=5)
tk.Button(btn_frame, text="Load B", command=load_content_b).pack(side=tk.LEFT, padx=5)

root.mainloop()
```

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

### Automatically Adjust Widget Height with fit_height()

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

The fit_height() method adjusts the widget's height to fit its content, useful for dynamically changing content. It works for both short and long text, including wrapped lines.

```python
import tkinter as tk
from tkhtmlview import HTMLLabel

root = tk.Tk()
root.title("fit_height() Example")

# Short content
label1 = HTMLLabel(root, html='<p>Short text</p>')
label1.pack(fill="x", padx=10, pady=5)
label1.fit_height()  # Adjusts to minimal height

# Longer content
label2 = HTMLLabel(root, html="""
    <h3>Longer Content</h3>
    <p>This widget contains more text that wraps across multiple lines
    when the window is narrow enough. The fit_height method calculates
    the required height to show all wrapped lines.</p>
    <ul>
        <li>Item one</li>
        <li>Item two</li>
        <li>Item three</li>
    </ul>
")
label2.pack(fill="x", padx=10, pady=5)
label2.fit_height()  # Adjusts to fit all content

root.mainloop()
```

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

### Apply Inline CSS for HTML Styling

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Customize the appearance of text within TkHTMLView widgets using inline CSS styles. Supported properties include color, background-color, font-family, font-size, text-align, and text-decoration.

```python
import tkinter as tk
from tkhtmlview import HTMLScrolledText

root = tk.Tk()
root.title("CSS Styling Example")
root.geometry("600x500")

html_content = """
    <h1 style=\"color: #2c3e50; text-align: center;">Styled Content</h1>

    <p style=\"font-size: 16px; color: #34495e;">
        Regular paragraph with custom size and color.
    </p>

    <p style=\"background-color: #f1c40f; color: #000;">
        Highlighted text with yellow background.
    </p>

    <span style=\"font-family: Georgia; font-size: 18px; color: #8e44ad;">
        Custom font family text
    </span>

    <p style=\"text-decoration: underline; color: #e74c3c;">
        Underlined red text
    </p>

    <p style=\"text-decoration: line-through;">
        Strikethrough text
    </p>

    <div style=\"text-align: right; color: #27ae60;">
        Right-aligned green text
    </div>

    <div style=\"text-align: center;">
        <mark style=\"background-color: #3498db; color: white;">
            Centered marked text with custom colors
        </mark>
    </div>
"""

widget = HTMLScrolledText(root, html=html_content)
widget.pack(fill="both", expand=True, padx=10, pady=10)

root.mainloop()
```

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

### Render Lists in Tkinter

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Demonstrates the use of HTMLScrolledText to render ordered and unordered lists, including nested structures and various list markers.

```python
import tkinter as tk
from tkhtmlview import HTMLScrolledText

root = tk.Tk()
root.title("Lists Example")
root.geometry("500x600")

html_content = """
    <h2>Unordered List</h2>
    <ul>
        <li>First item</li>
        <li>Second item</li>
        <li>Third item with nested list:
            <ul>
                <li>Nested item A</li>
                <li>Nested item B</li>
            </ul>
        </li>
        <li>Fourth item</li>
    </ul>

    <h2>Ordered List (Numeric)</h2>
    <ol type="1">
        <li>Step one</li>
        <li>Step two</li>
        <li>Step three</li>
    </ol>

    <h2>Ordered List (Lowercase)</h2>
    <ol type="a">
        <li>Option a</li>
        <li>Option b</li>
        <li>Option c</li>
    </ol>

    <h2>Ordered List (Uppercase)</h2>
    <ol type="A">
        <li>Category A</li>
        <li>Category B</li>
        <li>Category C</li>
    </ol>
"""

widget = HTMLScrolledText(root, html=html_content)
widget.pack(fill="both", expand=True, padx=10, pady=10)

root.mainloop()
```

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

### Embed Local and Remote Images

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Embed images in TkHTMLView widgets using the img tag. Supports both remote URLs and local file paths. Optional width and height attributes can be used for resizing. Images are cached for performance.

```python
import tkinter as tk
from tkhtmlview import HTMLScrolledText

root = tk.Tk()
root.title("Images Example")
root.geometry("700x500")

html_content = """
    <h2>Image Examples</h2>

    <h3>Remote Image</h3>
    <p>Loading image from URL:</p>
    <img src="https://www.python.org/static/community_logos/python-logo.png"
         width="200" height="60" />

    <h3>Resized Image</h3>
    <p>Same image with different dimensions:</p>
    <img src="https://www.python.org/static/community_logos/python-logo.png"
         width="100" height="30" />

    <h3>Local Image</h3>
    <p>Load from local file path:</p>
    <img src="./images/logo.png" width="150" height="150" />

    <p>Images are cached after first load for better performance.</p>
"""

widget = HTMLScrolledText(root, html=html_content)
widget.pack(fill="both", expand=True, padx=10, pady=10)

root.mainloop()
```

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

### Render Tables in Tkinter

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Displays tabular data using standard HTML table tags within an HTMLScrolledText widget.

```python
import tkinter as tk
from tkhtmlview import HTMLScrolledText

root = tk.Tk()
root.title("Table Example")
root.geometry("500x400")

html_content = """
    <h2>Data Table</h2>

    <table>
        <tr>
            <th style="background-color: silver;">Name</th>
            <th style="background-color: silver;">Age</th>
            <th style="background-color: silver;">City</th>
        </tr>
        <tr>
            <td>Alice</td>
            <td>28</td>
            <td>New York</td>
        </tr>
        <tr>
            <td>Bob</td>
            <td>34</td>
            <td>Los Angeles</td>
        </tr>
        <tr>
            <td><b>Charlie</b></td>
            <td><i>42</i></td>
            <td><em>Chicago</em></td>
        </tr>
    </table>

    <p>Table cells support text formatting tags.</p>
"""

widget = HTMLScrolledText(root, html=html_content)
widget.pack(fill="both", expand=True, padx=10, pady=10)

root.mainloop()
```

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

### Create and Display HTMLScrolledText

Source: https://context7.com/bauripalash/tkhtmlview/llms.txt

Use HTMLScrolledText for displaying longer HTML content that may exceed the visible area, providing built-in vertical scrolling and optional horizontal scrolling. It supports various HTML elements including headings, lists, preformatted text, and hyperlinks.

```python
import tkinter as tk
from tkhtmlview import HTMLScrolledText

root = tk.Tk()
root.title("HTMLScrolledText Example")
root.geometry("800x600")

# Create scrolled HTML widget with extensive content
html_scrolled = HTMLScrolledText(
    root,
    html="""
        <h1 style="color: navy; text-align: center">Documentation</h1>

        <h2>Introduction</h2>
        <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.
        Sed ut quam sapien. Maecenas porta tempus mauris sed ullamcorper.</p>

        <h2>Features</h2>
        <ol type="1">
            <li>HTML rendering support</li>
            <li>CSS inline styles</li>
            <li>Image embedding</li>
            <li>Clickable hyperlinks</li>
        </ol>

        <h2>Code Example</h2>
        <pre style="font-family: Consolas; font-size: 80%">
def hello_world():
    print("Hello, World!")
        </pre>

        <p>Visit <a href="https://github.com/bauripalash/tkhtmlview">GitHub</a>
        for more information.</p>
    "")
html_scrolled.pack(fill="both", expand=True)

root.mainloop()
```

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