Add RenderWindow class for Pygame window management

[Copilot]

Overview

This PR adds a new RenderWindow class that encapsulates Pygame initialization and window management, providing a clean and modular interface for rendering applications.

What's New

RenderWindow Class

A new render_window.py module provides the RenderWindow class with the following features:

• Automatic Pygame Setup: Handles pygame.init(), window creation, and display configuration
• Simple API: Clean methods for common operations:
  • get_surface() - Access the display surface for rendering
  • should_continue() - Process events and check if the window should remain open
  • tick(fps) - Control frame rate
  • register_event_handler(handler) - Add custom event handlers
• Built-in QUIT Handling: Automatically handles window close events internally
• Composition-Friendly: Designed to be used as a component rather than requiring inheritance

Usage Examples and Documentation

Added render_window_example.py with three complete working examples demonstrating:

• Simple Example: Basic RenderWindow initialization and usage
• Event Handler Example: Custom event registration and handling
• Integration Example: Shows how to refactor main.py to use RenderWindow with the existing Graphik class

Updated README.md with a dedicated RenderWindow section including feature overview, basic usage example, and reference to the example file.

Usage Example

from render_window import RenderWindow
import pygame

# Create window with title and dimensions
window = RenderWindow("My Application", 800, 600)
surface = window.get_surface()

# Register custom event handlers
def handle_keyboard(event):
    if event.type == pygame.KEYDOWN:
        print(f"Key pressed: {event.key}")

window.register_event_handler(handle_keyboard)

# Main application loop
while window.should_continue():
    surface.fill((50, 50, 100))
    # ... render your content ...
    pygame.display.update()
    window.tick(60)  # 60 FPS

pygame.quit()

Composition Pattern

The class is designed for composition, making it easy to integrate into existing applications:

class MyGame:
    def __init__(self):
        self.window = RenderWindow("My Game", 640, 480)
        self.surface = self.window.get_surface()
        self.window.register_event_handler(self.on_input)
    
    def run(self):
        while self.window.should_continue():
            # ... game logic ...
            self.window.tick(60)

Benefits

• Reduced Boilerplate: No need to manually initialize Pygame or handle window setup
• Modular: Clean separation between window management and application logic
• Flexible: Multiple event handlers can be registered and managed independently
• Testable: Easy to mock and test without requiring a display
• Ready for Apex: Provides the foundation requested for use in the Apex project
• Well-Documented: Includes comprehensive examples and documentation

Additional Changes

• Updated .gitignore to exclude __pycache__/ directories
• Added render_window_example.py with three usage examples
• Updated README.md with RenderWindow documentation

Testing

The implementation has been thoroughly tested with:

• Window initialization with various sizes
• Surface access and rendering operations
• Event handling (keyboard, mouse, custom events)
• Multiple event handler registration
• Frame rate control
• QUIT event handling
• Composition pattern verification
• Integration with existing Graphik class

Resolves the issue requesting a RenderWindow class for managing Pygame initialization and enables modular, flexible use across multiple projects.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Create a RenderWindow class to manage Pygame initialization</issue_title>
<issue_description>Patchwork should provide a RenderWindow class that encapsulates Pygame setup logic and manages the window, surface, event loop, and frame rate.

The class should be designed for composition, not inheritance, so that clients like Apex can use it as a container for rendering rather than subclassing it.

Key Features

• Initialize Pygame with title and window size
• Expose get_surface(), tick(fps), and should_continue() methods
• Allow registration of custom event handlers with register_event_handler(handler)
• Call each handler on events, while handling QUIT internally

This enables modular, flexible use in multiple projects.</issue_description>

Comments on the Issue (you are @copilot in this section)

Fixes #6

---

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.

[dmccoystephenson]

@copilot The new class does not appear to be used anywhere

[Copilot]

@copilot The new class does not appear to be used anywhere

Added usage examples in render_window_example.py demonstrating integration with the existing Graphik class, and updated README with documentation. The example shows how to use RenderWindow in the Patchwork context, including how main.py could be refactored. Commit: ee5ffb0