`861b8c1`

fix pango_layout_get_pixel_size args

Authored by

espadonne 6 months ago

SHA: 861b8c12898fe697e4fd269b316ac8a046282436
Parents: 6a5d00a
Tree: 40c65c9

57 changed files

Status	File	+	-
A	`for the breadcrumb`	2	0
A	`BETTER-PROPERTIES-BUTTON.md`	13	0
A	`BUGFIX_SESSION.md`	64	0
A	`Casks/sniffly.rb`	16	0
A	`DYNAMIC_RENDERING_PLAN.md`	290	0
A	`INSTALL.md`	97	0
A	`MACOS_PACKAGING_WALKTHROUGH.md`	357	0
A	`PACKAGING.md`	440	0
A	`PROJECT_SUMMARY.md`	481	0
A	`SNIFFLY-TABS.md`	22	0
A	`SNIFFLY_MASTER_PLAN.md`	1101	0
A	`SPACESNIFFER_FEATURES.md`	135	0
A	`Sniffly.app/Contents/Info.plist`	32	0
A	`Sniffly.app/Contents/MacOS/sniffly-bin`	bin
A	`Sniffly.app/Contents/PkgInfo`	1	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/gschema.dtd`	75	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/gschemas.compiled`	bin
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.Demo4.gschema.xml`	26	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.gtk4.Inspector.gschema.xml`	40	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.ColorChooser.gschema.xml`	26	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.Debug.gschema.xml`	25	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.EmojiChooser.gschema.xml`	17	0
A	`Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.FileChooser.gschema.xml`	186	0
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/bn.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/da.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/de.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/es.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/et.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/fi.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/fr.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/hi.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/hu.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/it.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/ja.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/ko.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/lt.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/ms.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/nb.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/nl.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/pl.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/pt.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/ru.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/sv.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/th.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/uk.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/emoji/zh.gresource`	bin
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/gtk4builder.rng`	512	0
A	`Sniffly.app/Contents/Resources/share/gtk-4.0/valgrind/gtk.supp`	355	0
A	`Sniffly.app/Contents/_CodeSignature/CodeDirectory`	bin
A	`Sniffly.app/Contents/_CodeSignature/CodeRequirements`	bin
A	`Sniffly.app/Contents/_CodeSignature/CodeRequirements-1`	bin
A	`Sniffly.app/Contents/_CodeSignature/CodeResources`	999	0
A	`Sniffly.app/Contents/_CodeSignature/CodeSignature`	0	0
A	`TECHNICAL_STACK.md`	656	0
A	`TOOLBAR-TARGETS.md`	256	0
A	`fac_debug.txt`	20	0
M	`src/gui/breadcrumb_widget.f90`	4	3

BETTER-PROPERTIES-BUTTON.mdadded

 +# improving the proerties button in sniffly
++
 +right now this button just displays status text in the bottom
++
 +I propose we make that status text the default when any selection (not hover) is made
 +that is to say the current properties status indicator we added should be there whenever we have an active selection for that selection
++
 + so if i open to downloads and then select inMusic.app or whatever the dir is, I expect to see the status info at the bottom left by defaultt, and change if i select another file and disappear if i deselct.
++
 +I propose the properties button opens the finder/mac os system properties viewer since we seem to be leaning towards a mac os exlusive buid here
 +what're you're thoughts on the new behavior of the button and implementing the fixes to status behavior (always on selection))
++
++

BUGFIX_SESSION.mdadded

 +# Bug Fix Session - UI Issues
++
 +## Issues to Fix
++
 +### 1. Eye Button (Toggle Dotfiles) Not Working
 +**Status**: ✅ FIXED
 +**Description**: Clicking the eye button to toggle dotfiles visibility doesn't affect rendering. Testing in a project with `.git` - the `.git` directory doesn't appear/disappear when toggled.
++
 +**Expected Behavior**:
 +- Eye button ON → show `.git`, `.cache`, `.config`, etc.
 +- Eye button OFF → hide all dotfiles
++
 +**Files Modified**:
 +- `src/core/progressive_scanner.f90` - Added `show_hidden_files` flag and filtering logic
 +- `src/rendering/treemap_renderer.f90` - Updated `toggle_hidden_files()` to call both scanner modules
++
 +**Solution**: Added hidden file filtering to progressive scanner at all depth levels (depth 0 and depth > 0). The toggle now properly filters files starting with '.' during scanning.
++
 +---
++
 +### 2. Collapsed Path in File Selector
 +**Status**: ✅ FIXED
 +**Description**: When opening with `./build/sniffly .` the file selector shows `.` instead of the full absolute path.
++
 +**Expected Behavior**:
 +- Command: `./build/sniffly .`
 +- File selector should show: `/Users/matthewwolffe/Documents/GithubOrgs/FortranGoingOnForty/sniffly`
 +- Not: `.`
++
 +**Files Modified**:
 +- `app/main.f90` - Added `get_absolute_path()` call to expand relative paths
++
 +**Solution**: Modified main.f90 to call `get_absolute_path()` on the command-line argument before passing it to `sniffly_set_scan_path()`. This expands `.` to the full absolute path.
++
 +---
++
 +### 3. Toggle Flat/3D Rendering Mode Does Nothing
 +**Status**: ✅ FIXED
 +**Description**: The toggle flat/3D rendering button doesn't appear to change the visualization at all.
++
 +**Expected Behavior**:
 +- Flat mode → Simple colored rectangles
 +- 3D/Cushion mode → Shaded rectangles with depth effect
++
 +**Files Modified**:
 +- `src/rendering/treemap_renderer.f90` - Enhanced cushion shading parameters for more visible 3D effect
++
 +**Solution**: The toggle was working correctly, but the 3D cushion effect was too subtle to notice. Increased the ridge height factor from 0.5 to 2.0 and adjusted lighting (ambient from 0.4 to 0.3, diffuse from 0.6 to 0.7) to make the 3D effect much more pronounced and visually obvious.
++
 +---
++
 +## Progress Tracking
++
 +- [x] Issue 1: Fix dotfiles toggle ✅
 +- [x] Issue 2: Fix collapsed path display ✅
 +- [x] Issue 3: Fix flat/3D rendering toggle ✅
++
 +## Summary
++
 +All three UI issues have been fixed:
++
 +1. **Eye button** - Now properly filters dotfiles in progressive scanner
 +2. **Path display** - Now shows full absolute paths instead of relative paths
 +3. **Render mode toggle** - Enhanced cushion shading for clearly visible 3D effect

Casks/sniffly.rbadded

 +cask "sniffly" do
 +  version "0.2.4"
 +  sha256 :no_check  # Will calculate actual SHA256 once DMG is hosted
++
 +  url "https://github.com/FortranGoingOnForty/sniffly/releases/download/v#{version}/Sniffly-#{version}-macOS.dmg"
 +  name "Sniffly"
 +  desc "Fast, visual disk space analyzer built with Fortran and GTK4"
 +  homepage "https://github.com/FortranGoingOnForty/sniffly"
++
 +  # No dependencies needed - all GTK4 libraries are bundled!
 +  app "Sniffly.app"
++
 +  zap trash: [
 +    "~/Library/Logs/Sniffly.log",
 +  ]
 +end

DYNAMIC_RENDERING_PLAN.mdadded

 +# Dynamic Rendering Plan - SpaceSniffer-Style Progressive Scanning
++
 +## Goal
 +Implement real-time progressive rendering where treemap boxes grow, shrink, and reposition as directories are scanned, similar to SpaceSniffer's iconic behavior.
++
 +## Current State
 +- **Synchronous scanning**: Full directory tree is scanned before any rendering
 +- **Static layout**: Once rendered, boxes don't change size
 +- **Progress bar only**: User sees only a progress bar during scan, no visual feedback of structure
++
 +## Target Behavior (SpaceSniffer-like)
 +1. **Immediate rendering**: Start drawing boxes as soon as first directory is scanned
 +2. **Progressive updates**: Boxes dynamically resize as subdirectories are discovered
 +3. **Relative sizing**: Boxes continuously adjust relative to siblings as scan progresses
 +4. **Visual feedback**: User sees the file structure emerge in real-time
 +5. **Smooth experience**: No jarring jumps, boxes flow and adapt gracefully
++
 +## Technical Challenges
++
 +### 1. **Asynchronous Scanning**
 +- **Current**: Recursive `scan_directory()` blocks until complete
 +- **Needed**: Non-blocking scan that yields partial results
 +- **Options**:
 +  - Thread-based: Scan in background thread, communicate via shared state
 +  - Idle callback: Scan one directory per GTK idle iteration
 +  - Generator pattern: Yield after each directory scan
++
 +### 2. **Incremental Layout Updates**
 +- **Current**: `squarify_layout()` computes entire layout at once
 +- **Needed**: Re-layout on every size update
 +- **Performance**: Must be fast enough for 30-60 FPS during scan
 +- **Solution approaches**:
 +  - Cached layouts with partial invalidation
 +  - Incremental squarify (update only affected nodes)
 +  - Layout diffing to minimize recalculation
++
 +### 3. **Size Estimation**
 +- **Problem**: When scanning `/foo`, we don't know final size until all children scanned
 +- **SpaceSniffer approach**: Use "estimated" sizes that grow as scan progresses
 +- **Implementation**:
 +  - Track `scanned_size` vs `estimated_total_size` per node
 +  - Mark nodes as `scan_complete` flag
 +  - Use heuristics for estimation (e.g., average file size × file count estimate)
++
 +### 4. **Treemap Algorithm Modifications**
 +- **Standard squarify**: Assumes all sizes are final
 +- **Dynamic squarify**: Must handle changing sizes gracefully
 +- **Requirements**:
 +  - Stable positioning (boxes shouldn't jump around too much)
 +  - Smooth transitions (animate size changes)
 +  - Handle new children appearing mid-render
++
 +### 5. **Threading & GTK Integration**
 +- **GTK is not thread-safe**: All widget updates must be on main thread
 +- **Architecture**:
 +  ```
 +  Main Thread (GTK)              Background Thread (Scanner)
 +  ┌──────────────┐               ┌────────────────┐
 +  │ Render loop  │◄──Messages────│ scan_directory │
 +  │ (60 FPS)     │               │ (breadth-first)│
 +  │              │───Request────►│                │
 +  │ Layout calc  │               │ File I/O       │
 +  └──────────────┘               └────────────────┘
 +  ```
++
 +### 6. **State Synchronization**
 +- **Problem**: Scan thread modifies tree while render thread reads it
 +- **Solution options**:
 +  - Double buffering: Scan writes to buffer, swap atomically
 +  - Read-write locks: Readers don't block each other
 +  - Message passing: Scan sends deltas, render applies them
++
 +## Proposed Architecture
++
 +### Phase 1: Non-Blocking Scan (Idle Callback Approach)
 +**Simplest, no threading**
++
 +```fortran
 +module progressive_scanner
 +  type :: scan_state
 +    character(len=512) :: current_path
 +    integer :: depth
 +    type(file_node), pointer :: current_node
 +    logical :: complete
 +    ! Queue of directories to scan
 +    character(len=512), dimension(1000) :: pending_dirs
 +    integer :: queue_head, queue_tail
 +  end type scan_state
++
 +  type(scan_state), save :: scanner
++
 +contains
++
 +  ! Initialize scan
 +  subroutine start_progressive_scan(root_path)
 +    scanner%queue_head = 1
 +    scanner%queue_tail = 1
 +    scanner%pending_dirs(1) = root_path
 +    scanner%complete = .false.
++
 +    ! Register idle callback
 +    call g_idle_add(c_funloc(scan_one_directory), c_null_ptr)
 +  end subroutine
++
 +  ! Scan one directory per idle iteration
 +  function scan_one_directory(user_data) bind(c) result(continue)
 +    type(c_ptr), value :: user_data
 +    integer(c_int) :: continue
++
 +    if (scanner%queue_head > scanner%queue_tail) then
 +      scanner%complete = .true.
 +      continue = 0_c_int  ! Stop calling
 +      return
 +    end if
++
 +    ! Scan one directory
 +    call scan_single_directory(scanner%pending_dirs(scanner%queue_head))
 +    scanner%queue_head = scanner%queue_head + 1
++
 +    ! Request redraw
 +    call gtk_widget_queue_draw(widget_ptr)
++
 +    continue = 1_c_int  ! Keep calling
 +  end function
++
 +end module progressive_scanner
 +```
++
 +**Pros**:
 +- Simple, no threading complexity
 +- GTK-friendly
 +- Easy to debug
++
 +**Cons**:
 +- Slower than threaded (I/O blocks GUI)
 +- May feel sluggish on slow disks
++
 +### Phase 2: Background Thread Scan
 +**Better performance, more complex**
++
 +```fortran
 +module threaded_scanner
 +  use omp_lib
++
 +  type :: scan_message
 +    integer :: msg_type  ! 1=new_node, 2=update_size, 3=complete
 +    character(len=512) :: path
 +    integer(int64) :: size
 +    integer :: parent_id, node_id
 +  end type
++
 +  ! Thread-safe message queue
 +  type(scan_message), dimension(10000) :: message_queue
 +  integer :: queue_read_pos = 1, queue_write_pos = 1
 +  !$omp threadprivate(queue_read_pos, queue_write_pos)
++
 +contains
++
 +  subroutine start_background_scan(root_path)
 +    !$omp parallel
 +    !$omp single
 +    call scan_directory_async(root_path)
 +    !$omp end single
 +    !$omp end parallel
++
 +    ! Register timer to process messages on main thread
 +    call g_timeout_add(16_c_int, c_funloc(process_scan_messages), c_null_ptr)
 +  end subroutine
++
 +  recursive subroutine scan_directory_async(path)
 +    ! Scan directory, send messages for each discovery
 +    ! ...
 +    call send_message(NEW_NODE, path, size, parent_id)
 +    !$omp task
 +    call scan_directory_async(child_path)
 +    !$omp end task
 +  end subroutine
++
 +  function process_scan_messages(user_data) bind(c) result(continue)
 +    ! Process up to 100 messages per frame
 +    do i = 1, 100
 +      if (has_messages()) then
 +        call apply_message(read_message())
 +      end if
 +    end do
 +    call gtk_widget_queue_draw(widget_ptr)
 +    continue = 1_c_int
 +  end function
++
 +end module threaded_scanner
 +```
++
 +## Implementation Phases
++
 +### Phase 1: Foundation (1-2 days)
 +- [ ] Add `scan_complete` flag to `file_node` type
 +- [ ] Add `estimated_size` vs `actual_size` fields
 +- [ ] Modify `scan_directory` to be interruptible (return after N files)
 +- [ ] Create `scan_state` module to track progress
++
 +### Phase 2: Idle Callback Scanning (1 day)
 +- [ ] Implement breadth-first scan queue
 +- [ ] Add `g_idle_add` callback for progressive scanning
 +- [ ] Update sizes incrementally as scan progresses
 +- [ ] Trigger redraws after each directory
++
 +### Phase 3: Dynamic Layout (2-3 days)
 +- [ ] Cache last layout in tree nodes
 +- [ ] Implement layout diffing (detect what changed)
 +- [ ] Partial layout recalculation
 +- [ ] Smooth transitions (animate box movements)
++
 +### Phase 4: Performance Optimization (1-2 days)
 +- [ ] Throttle redraws (max 30 FPS)
 +- [ ] Batch size updates before layout
 +- [ ] Only re-layout visible nodes
 +- [ ] Add "scan paused" state for user interaction
++
 +### Phase 5: Threading (Optional, 2-3 days)
 +- [ ] Implement background thread scanner
 +- [ ] Message queue for thread communication
 +- [ ] Lock-free or minimal locking strategy
 +- [ ] Test on multi-core systems
++
 +## Visual Design Decisions
++
 +### 1. **Incomplete Nodes Visual Indicator**
 +- **Option A**: Pulsing border while scanning
 +- **Option B**: Different color saturation (dimmer until complete)
 +- **Option C**: Animated gradient sweep
 +- **Recommendation**: Subtle pulse + slightly dimmer
++
 +### 2. **Transition Animation**
 +- **Duration**: 100-200ms per size update
 +- **Easing**: Ease-out for natural feel
 +- **Method**: Linear interpolation in `render_node()`
++
 +### 3. **Performance Targets**
 +- **Min framerate**: 30 FPS during scan
 +- **Max layout time**: 16ms per frame (60 FPS budget)
 +- **Redraw throttle**: Every 3-5 directories scanned
++
 +## Edge Cases to Handle
++
 +1. **Permission denied**: Mark node as complete with error state
 +2. **Symlink loops**: Detect and skip
 +3. **Very deep trees**: Limit recursion depth
 +4. **Very wide directories**: Limit children per node (group small files)
 +5. **Rapid navigation**: Cancel in-progress scans
 +6. **Window resize during scan**: Re-layout without restarting scan
++
 +## Testing Strategy
++
 +1. **Unit tests**:
 +   - Scan queue push/pop
 +   - Message queue thread safety
 +   - Layout diffing algorithm
++
 +2. **Integration tests**:
 +   - Scan small directory (10 files)
 +   - Scan deep directory (10 levels)
 +   - Scan wide directory (1000 files)
 +   - Navigate during scan
++
 +3. **Performance tests**:
 +   - Measure framerate on large directory
 +   - Profile layout recalculation time
 +   - Memory leak detection
++
 +## Success Metrics
++
 +- ✅ Boxes appear within 100ms of starting scan
 +- ✅ Smooth animation (30+ FPS) throughout scan
 +- ✅ No visual artifacts or flickering
 +- ✅ User can interact (click, navigate) during scan
 +- ✅ Memory usage stays reasonable (< 500MB for typical home directory)
++
 +## Future Enhancements
++
 +- **Scan prioritization**: Scan visible areas first
 +- **Incremental updates**: Update only changed subtrees
 +- **Predictive scanning**: Prefetch likely navigation targets
 +- **Network filesystem awareness**: Adjust timeouts for slow disks
 +- **Cancellation**: Allow user to stop scan mid-progress
++
 +## References
++
 +- SpaceSniffer behavior analysis: https://www.youtube.com/watch?v=... (TBD)
 +- GTK idle callbacks: https://docs.gtk.org/glib/func.idle_add.html
 +- Fortran OpenMP: https://www.openmp.org/wp-content/uploads/openmp-4.5.pdf

INSTALL.mdadded

 +# Installing Sniffly
++
 +Sniffly is a fast, visual disk space analyzer built with Fortran and GTK4.
++
 +## Installation Methods
++
 +### Option 1: Download DMG (Recommended)
++
 +1. Download the latest release: [Sniffly-0.2.4-macOS.dmg](https://github.com/FortranGoingOnForty/sniffly/releases/latest)
 +2. Open the DMG
 +3. Drag `Sniffly.app` to your Applications folder
 +4. **First launch:** Right-click Sniffly → "Open" → Click "Open" again to bypass Gatekeeper
++
 +### Option 2: Homebrew (For Brew Users)
++
 +```bash
 +# Install Sniffly (once we publish the cask)
 +# No dependencies needed - everything is bundled!
 +brew install --cask sniffly
 +```
++
 +### Option 3: Build from Source
++
 +```bash
 +# Install dependencies
 +brew install gtk4 gtk-4-fortran meson
++
 +# Clone and build
 +git clone https://github.com/FortranGoingOnForty/sniffly.git
 +cd sniffly
 +meson setup build --buildtype=release
 +meson compile -C build
++
 +# Run
 +./build/sniffly
 +```
++
 +## System Requirements
++
 +- macOS 11.0 or later
 +- Apple Silicon or Intel Mac
++
 +## Usage
++
 +### Launch from Applications
 +Double-click Sniffly in your Applications folder.
++
 +### Launch from Terminal
 +```bash
 +# Scan your home directory (default)
 +/Applications/Sniffly.app/Contents/MacOS/sniffly
++
 +# Scan a specific directory
 +/Applications/Sniffly.app/Contents/MacOS/sniffly ~/Documents
++
 +# Show help
 +/Applications/Sniffly.app/Contents/MacOS/sniffly --help
++
 +# Show version
 +/Applications/Sniffly.app/Contents/MacOS/sniffly --version
 +```
++
 +## Troubleshooting
++
 +### "Sniffly is damaged and can't be opened"
++
 +This happens because the app isn't signed with an Apple Developer certificate. To bypass:
++
 +**Method 1: Right-click to open**
 +1. Right-click (or Control-click) Sniffly.app
 +2. Click "Open"
 +3. Click "Open" again in the dialog
++
 +**Method 2: Remove quarantine attribute**
 +```bash
 +xattr -cr /Applications/Sniffly.app
 +```
++
 +### Window doesn't appear
++
 +If Sniffly starts but no window appears, try running from terminal to see debug output:
 +```bash
 +/Applications/Sniffly.app/Contents/MacOS/sniffly ~/Downloads
 +```
++
 +## Uninstalling
++
 +### DMG Installation
 +```bash
 +rm -rf /Applications/Sniffly.app
 +rm ~/Library/Logs/Sniffly.log
 +```
++
 +### Homebrew Installation
 +```bash
 +brew uninstall --cask sniffly
 +```

MACOS_PACKAGING_WALKTHROUGH.mdadded

 +# Sniffly macOS Packaging Walkthrough
++
 +This is a step-by-step guide to package Sniffly for macOS distribution.
++
 +## Prerequisites
++
 +Before starting, make sure you have:
 +- ✅ Sniffly built successfully (`./build/sniffly` exists)
 +- ✅ `dylibbundler` installed: `brew install dylibbundler`
 +- ✅ An application icon (optional, but recommended)
 +- 📝 Apple Developer account (only needed for code signing)
++
 +## Version Management
++
 +The version is controlled by a single `VERSION` file at the project root. To release a new version:
++
 +```bash
 +echo "0.3.0" > VERSION
 +meson setup build --reconfigure
 +meson compile -C build
 +```
++
 +The version automatically appears in:
 +- The binary output (`./build/sniffly --version`)
 +- Info.plist in the app bundle
 +- The DMG filename
++
 +## Quick Start: Automated Packaging
++
 +```bash
 +# One command to create the .app and .dmg
 +./scripts/package-macos.sh
 +```
++
 +This creates:
 +- `Sniffly.app` - The application bundle
 +- `Sniffly-0.2.0-macOS.dmg` - Distributable installer
++
 +### What The Script Does
++
 +1. Reads version from `VERSION` file
 +2. Creates `.app` bundle structure
 +3. Copies the executable
 +4. Creates `Info.plist` with version info
 +5. Bundles GTK4 libraries using `dylibbundler`
 +6. Creates a distributable DMG
++
 +## Step-by-Step Manual Process
++
 +If you want to understand what's happening or customize the process:
++
 +### Step 1: Build the Release Binary
++
 +```bash
 +# Clean build for release
 +rm -rf build
 +meson setup build --buildtype=release
 +meson compile -C build
++
 +# Verify it works
 +./build/sniffly --version
 +```
++
 +### Step 2: Create the App Bundle Structure
++
 +```bash
 +mkdir -p Sniffly.app/Contents/MacOS
 +mkdir -p Sniffly.app/Contents/Resources
 +mkdir -p Sniffly.app/Contents/Frameworks
 +```
++
 +### Step 3: Copy the Executable
++
 +```bash
 +cp build/sniffly Sniffly.app/Contents/MacOS/sniffly
 +chmod +x Sniffly.app/Contents/MacOS/sniffly
 +```
++
 +### Step 4: Create Info.plist
++
 +```bash
 +cat > Sniffly.app/Contents/Info.plist << 'EOF'
 +<?xml version="1.0" encoding="UTF-8"?>
 +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 +<plist version="1.0">
 +<dict>
 +    <key>CFBundleExecutable</key>
 +    <string>sniffly</string>
 +    <key>CFBundleIdentifier</key>
 +    <string>org.fortrangoingonforty.sniffly</string>
 +    <key>CFBundleName</key>
 +    <string>Sniffly</string>
 +    <key>CFBundleDisplayName</key>
 +    <string>Sniffly</string>
 +    <key>CFBundleVersion</key>
 +    <string>0.2.0</string>
 +    <key>CFBundleShortVersionString</key>
 +    <string>0.2.0</string>
 +    <key>CFBundlePackageType</key>
 +    <string>APPL</string>
 +    <key>CFBundleIconFile</key>
 +    <string>sniffly</string>
 +    <key>LSMinimumSystemVersion</key>
 +    <string>11.0</string>
 +    <key>LSApplicationCategoryType</key>
 +    <string>public.app-category.utilities</string>
 +</dict>
 +</plist>
 +EOF
 +```
++
 +### Step 5: Add an Icon (Optional but Recommended)
++
 +You need a `.icns` file. If you have a 1024x1024 PNG:
++
 +```bash
 +# Create iconset directory
 +mkdir sniffly.iconset
++
 +# Generate all sizes
 +sips -z 16 16     icon-1024.png --out sniffly.iconset/icon_16x16.png
 +sips -z 32 32     icon-1024.png --out sniffly.iconset/icon_16x16@2x.png
 +sips -z 32 32     icon-1024.png --out sniffly.iconset/icon_32x32.png
 +sips -z 64 64     icon-1024.png --out sniffly.iconset/icon_32x32@2x.png
 +sips -z 128 128   icon-1024.png --out sniffly.iconset/icon_128x128.png
 +sips -z 256 256   icon-1024.png --out sniffly.iconset/icon_128x128@2x.png
 +sips -z 256 256   icon-1024.png --out sniffly.iconset/icon_256x256.png
 +sips -z 512 512   icon-1024.png --out sniffly.iconset/icon_256x256@2x.png
 +sips -z 512 512   icon-1024.png --out sniffly.iconset/icon_512x512.png
 +sips -z 1024 1024 icon-1024.png --out sniffly.iconset/icon_512x512@2x.png
++
 +# Convert to .icns
 +iconutil -c icns sniffly.iconset -o Sniffly.app/Contents/Resources/sniffly.icns
++
 +# Cleanup
 +rm -rf sniffly.iconset
 +```
++
 +### Step 6: Bundle GTK4 Libraries
++
 +This is the crucial step that makes your app "just work" on any Mac:
++
 +```bash
 +dylibbundler -od -b \
 +    -x Sniffly.app/Contents/MacOS/sniffly \
 +    -d Sniffly.app/Contents/Frameworks/ \
 +    -p @executable_path/../Frameworks/
 +```
++
 +What this does:
 +- Finds all dylib dependencies (GTK4, Cairo, GLib, etc.)
 +- Copies them into `Frameworks/`
 +- Rewrites the executable to look in `@executable_path/../Frameworks/`
 +- Makes the app fully self-contained
++
 +**Expected size**: ~100-150MB (GTK4 is big!)
++
 +### Step 7: Test the App Bundle
++
 +```bash
 +open Sniffly.app
 +```
++
 +If it works, you're ready to create the DMG!
++
 +### Step 8: Create the DMG
++
 +```bash
 +# Create temporary folder
 +mkdir dmg_temp
 +cp -r Sniffly.app dmg_temp/
++
 +# Add Applications folder shortcut
 +ln -s /Applications dmg_temp/Applications
++
 +# Create DMG
 +hdiutil create -volname "Sniffly" \
 +    -srcfolder dmg_temp \
 +    -ov -format UDZO \
 +    Sniffly-0.2.0-macOS.dmg
++
 +# Cleanup
 +rm -rf dmg_temp
 +```
++
 +## Code Signing (Optional but Recommended)
++
 +If you have an Apple Developer account:
++
 +```bash
 +# Sign the app
 +codesign --deep --force --verify --verbose \
 +    --sign "Developer ID Application: Your Name (TEAM_ID)" \
 +    Sniffly.app
++
 +# Verify signature
 +codesign -dv Sniffly.app
++
 +# Create DMG from signed app
 +# (repeat Step 8 after signing)
++
 +# Notarize (required for distribution outside App Store)
 +xcrun notarytool submit Sniffly-0.2.0-macOS.dmg \
 +    --apple-id "your@email.com" \
 +    --password "app-specific-password" \
 +    --team-id "YOUR_TEAM_ID" \
 +    --wait
++
 +# Staple notarization ticket
 +xcrun stapler staple Sniffly-0.2.0-macOS.dmg
 +```
++
 +**Why sign and notarize?**
 +- Without: Users see "unidentified developer" warning
 +- With: Clean installation experience, no warnings
++
 +**Cost**: $99/year for Apple Developer account
++
 +## Distribution
++
 +Once you have `Sniffly-0.2.0-macOS.dmg`:
++
 +1. **Test on a clean Mac** (or VM) without development tools installed
 +2. **Upload to your server**:
 +   ```bash
 +   scp Sniffly-0.2.0-macOS.dmg user@yourserver.com:/var/www/downloads/
 +   ```
 +3. **Create a download page** with:
 +   - Link to the DMG
 +   - System requirements (macOS 11.0+)
 +   - Installation instructions
 +   - Screenshot/demo
++
 +### Example Download Page
++
 +```html
 +<!DOCTYPE html>
 +<html>
 +<head>
 +    <title>Download Sniffly</title>
 +</head>
 +<body>
 +    <h1>Download Sniffly v0.2.0</h1>
 +    <p>A fast, visual disk space analyzer for macOS</p>
++
 +    <a href="Sniffly-0.2.0-macOS.dmg" class="download-button">
 +        Download for macOS (150 MB)
 +    </a>
++
 +    <h2>Requirements</h2>
 +    <ul>
 +        <li>macOS 11.0 (Big Sur) or later</li>
 +        <li>Apple Silicon or Intel processor</li>
 +    </ul>
++
 +    <h2>Installation</h2>
 +    <ol>
 +        <li>Download Sniffly-0.2.0-macOS.dmg</li>
 +        <li>Open the DMG file</li>
 +        <li>Drag Sniffly to Applications folder</li>
 +        <li>Launch from Applications</li>
 +    </ol>
 +</body>
 +</html>
 +```
++
 +## Release Checklist
++
 +Before releasing a new version:
++
 +- [ ] Update `VERSION` file
 +- [ ] Test on clean macOS installation
 +- [ ] Verify `--version` shows correct version
 +- [ ] Test basic functionality (scan, navigation, etc.)
 +- [ ] Build release binary (`--buildtype=release`)
 +- [ ] Bundle GTK4 libraries with dylibbundler
 +- [ ] Test app bundle works standalone
 +- [ ] Create DMG
 +- [ ] (Optional) Code sign and notarize
 +- [ ] Upload to distribution server
 +- [ ] Update download page
 +- [ ] Announce release (social media, website, etc.)
++
 +## Troubleshooting
++
 +### "Sniffly is damaged and can't be opened"
++
 +This happens when macOS quarantines unsigned apps. Users can bypass with:
 +```bash
 +xattr -cr /Applications/Sniffly.app
 +```
++
 +Or you need to code sign and notarize the app.
++
 +### App crashes immediately
++
 +- Check if GTK4 libraries are bundled: `ls Sniffly.app/Contents/Frameworks/`
 +- Should see many `.dylib` files
 +- Verify with: `otool -L Sniffly.app/Contents/MacOS/sniffly`
 +  - Should show `@executable_path/../Frameworks/` paths
++
 +### DMG too large (>200MB)
++
 +Normal! GTK4 is big. Options:
 +- Accept it (users download once)
 +- Require system GTK4 (smaller DMG, but users must `brew install gtk4`)
++
 +### Can't sign the app
++
 +You need an Apple Developer account ($99/year). For free distribution:
 +- Skip signing (users will see warning)
 +- Document how to bypass Gatekeeper
++
 +## Version Number Advice
++
 +You asked about version numbering. Here's my take:
++
 +**Current State of Sniffly (0.2.0 suggestion)**:
 +- ✅ Core functionality works (scanning, treemap, navigation)
 +- ✅ Progressive scanning is solid
 +- ✅ 3D effects, navigation locking
 +- ⚠️ Some rough edges (had bugs we fixed)
 +- ⚠️ No installers yet (this guide creates them)
 +- ❌ Not feature-complete vs original SpaceSniffer
++
 +**Version recommendations**:
 +- **0.1.0** - Tech preview, barely works
 +- **0.2.0** - Alpha release (current state) ← **I recommend this**
 +- **0.5.0** - Beta release (feature complete, but bugs)
 +- **0.9.0** - Release candidate
 +- **1.0.0** - Stable, production-ready
++
 +**Why 0.2.0?**
 +- Shows progress from initial experiments
 +- Sets expectations (alpha quality)
 +- Room to grow before 1.0
 +- Conservative (you prefer this)
++
 +**Semantic versioning for future**:
 +- `0.x.y` - Pre-1.0 development
 +- `1.0.0` - First stable release
 +- `1.1.0` - Add features (backwards compatible)
 +- `1.0.1` - Bug fixes
 +- `2.0.0` - Breaking changes
++
 +## Next Steps
++
 +After successful macOS packaging, consider:
 +- Linux AppImage (simpler than .deb/.rpm)
 +- Homebrew cask formula (`brew install --cask sniffly`)
 +- Automatic updates (Sparkle framework)
 +- Analytics (crash reporting, usage stats)
 +- Website with documentation
++
 +---
++
 +**Questions?** The packaging script at `scripts/package-macos.sh` automates all of this!

PACKAGING.mdadded

 +# Sniffly Packaging Guide
++
 +This document explains how to package Sniffly for distribution on macOS and Linux.
++
 +## Current State
++
 +Sniffly is built using:
 +- **Meson** build system
 +- **GTK4** for the GUI
 +- **gtk-fortran** bindings
 +- **gfortran** compiler (GCC Fortran)
++
 +The executable is currently located at `build/sniffly` after running `meson compile -C build`.
++
 +---
++
 +## macOS Packaging (.dmg)
++
 +### Overview
 +On macOS, applications are distributed as:
 +1. **.app bundles** - Directory structure that looks like a single file
 +2. **.dmg files** - Disk images containing the .app bundle
++
 +### Steps to Create a macOS .app Bundle
++
 +#### 1. Create the Bundle Structure
++
 +```bash
 +# Create the app bundle directories
 +mkdir -p Sniffly.app/Contents/MacOS
 +mkdir -p Sniffly.app/Contents/Resources
 +mkdir -p Sniffly.app/Contents/Frameworks
 +```
++
 +#### 2. Copy the Executable
++
 +```bash
 +# Copy the compiled binary
 +cp build/sniffly Sniffly.app/Contents/MacOS/sniffly
 +```
++
 +#### 3. Create Info.plist
++
 +Create `Sniffly.app/Contents/Info.plist`:
++
 +```xml
 +<?xml version="1.0" encoding="UTF-8"?>
 +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 +<plist version="1.0">
 +<dict>
 +    <key>CFBundleExecutable</key>
 +    <string>sniffly</string>
 +    <key>CFBundleIdentifier</key>
 +    <string>org.fortrangoingonforty.sniffly</string>
 +    <key>CFBundleName</key>
 +    <string>Sniffly</string>
 +    <key>CFBundleDisplayName</key>
 +    <string>Sniffly</string>
 +    <key>CFBundleVersion</key>
 +    <string>0.1.0</string>
 +    <key>CFBundleShortVersionString</key>
 +    <string>0.1.0</string>
 +    <key>CFBundlePackageType</key>
 +    <string>APPL</string>
 +    <key>CFBundleSignature</key>
 +    <string>SNIF</string>
 +    <key>CFBundleIconFile</key>
 +    <string>sniffly</string>
 +    <key>LSMinimumSystemVersion</key>
 +    <string>11.0</string>
 +    <key>NSHighResolutionCapable</key>
 +    <true/>
 +    <key>NSRequiresAquaSystemAppearance</key>
 +    <false/>
 +</dict>
 +</plist>
 +```
++
 +#### 4. Create an Application Icon
++
 +You need a `.icns` file. Create one from a PNG using:
++
 +```bash
 +# Create iconset directory
 +mkdir sniffly.iconset
++
 +# Create different sizes (you'll need a source image)
 +# 16x16, 32x32, 128x128, 256x256, 512x512, 1024x1024
 +sips -z 16 16     icon-1024.png --out sniffly.iconset/icon_16x16.png
 +sips -z 32 32     icon-1024.png --out sniffly.iconset/icon_16x16@2x.png
 +sips -z 32 32     icon-1024.png --out sniffly.iconset/icon_32x32.png
 +sips -z 64 64     icon-1024.png --out sniffly.iconset/icon_32x32@2x.png
 +sips -z 128 128   icon-1024.png --out sniffly.iconset/icon_128x128.png
 +sips -z 256 256   icon-1024.png --out sniffly.iconset/icon_128x128@2x.png
 +sips -z 256 256   icon-1024.png --out sniffly.iconset/icon_256x256.png
 +sips -z 512 512   icon-1024.png --out sniffly.iconset/icon_256x256@2x.png
 +sips -z 512 512   icon-1024.png --out sniffly.iconset/icon_512x512.png
 +sips -z 1024 1024 icon-1024.png --out sniffly.iconset/icon_512x512@2x.png
++
 +# Convert to .icns
 +iconutil -c icns sniffly.iconset -o Sniffly.app/Contents/Resources/sniffly.icns
 +```
++
 +#### 5. Bundle GTK4 Libraries
++
 +This is the tricky part! The app needs GTK4 libraries. You have two options:
++
 +**Option A: Use Homebrew's GTK4 (requires user to have GTK4 installed)**
 +```bash
 +# User must run: brew install gtk4
 +# Then the app will find libraries via dylib search paths
 +```
++
 +**Option B: Bundle libraries (recommended for distribution)**
++
 +```bash
 +# Copy GTK4 libraries into the bundle
 +cp -r /opt/homebrew/lib/libgtk-4*.dylib Sniffly.app/Contents/Frameworks/
 +cp -r /opt/homebrew/lib/libglib-2.0*.dylib Sniffly.app/Contents/Frameworks/
 +cp -r /opt/homebrew/lib/libgobject-2.0*.dylib Sniffly.app/Contents/Frameworks/
 +# ... and all other GTK4 dependencies
++
 +# Use install_name_tool to fix library paths
 +install_name_tool -change /opt/homebrew/lib/libgtk-4.dylib \
 +    @executable_path/../Frameworks/libgtk-4.dylib \
 +    Sniffly.app/Contents/MacOS/sniffly
 +```
++
 +**Better Option: Use `dylibbundler`**
 +```bash
 +# Install dylibbundler
 +brew install dylibbundler
++
 +# Automatically bundle all dependencies
 +dylibbundler -od -b \
 +    -x Sniffly.app/Contents/MacOS/sniffly \
 +    -d Sniffly.app/Contents/Frameworks/ \
 +    -p @executable_path/../Frameworks/
 +```
++
 +#### 6. Create the .dmg
++
 +```bash
 +# Create a temporary directory for DMG contents
 +mkdir dmg_temp
 +cp -r Sniffly.app dmg_temp/
++
 +# Optional: Create a symbolic link to /Applications for easy drag-install
 +ln -s /Applications dmg_temp/Applications
++
 +# Create the DMG
 +hdiutil create -volname "Sniffly" \
 +    -srcfolder dmg_temp \
 +    -ov -format UDZO \
 +    Sniffly-0.1.0-macOS.dmg
++
 +# Clean up
 +rm -rf dmg_temp
 +```
++
 +#### 7. Code Signing (Optional but Recommended)
++
 +```bash
 +# Sign the app (requires Apple Developer account)
 +codesign --deep --force --verify --verbose \
 +    --sign "Developer ID Application: Your Name" \
 +    Sniffly.app
++
 +# Notarize with Apple (required for distribution outside App Store)
 +xcrun notarytool submit Sniffly-0.1.0-macOS.dmg \
 +    --apple-id "your@email.com" \
 +    --password "app-specific-password" \
 +    --team-id "YOUR_TEAM_ID" \
 +    --wait
++
 +# Staple the notarization ticket
 +xcrun stapler staple Sniffly-0.1.0-macOS.dmg
 +```
++
 +---
++
 +## Linux Packaging
++
 +### Option 1: AppImage (Recommended - Works on All Distros)
++
 +AppImage is a universal package format that works across all Linux distributions.
++
 +#### Create AppImage Structure
++
 +```bash
 +# Create AppDir structure
 +mkdir -p Sniffly.AppDir/usr/bin
 +mkdir -p Sniffly.AppDir/usr/lib
 +mkdir -p Sniffly.AppDir/usr/share/applications
 +mkdir -p Sniffly.AppDir/usr/share/icons/hicolor/256x256/apps
++
 +# Copy executable
 +cp build/sniffly Sniffly.AppDir/usr/bin/
++
 +# Copy icon
 +cp assets/sniffly.png Sniffly.AppDir/usr/share/icons/hicolor/256x256/apps/sniffly.png
 +cp assets/sniffly.png Sniffly.AppDir/sniffly.png
++
 +# Create .desktop file
 +cat > Sniffly.AppDir/sniffly.desktop << 'EOF'
 +[Desktop Entry]
 +Type=Application
 +Name=Sniffly
 +Comment=Disk Space Analyzer
 +Exec=sniffly
 +Icon=sniffly
 +Categories=Utility;System;
 +Terminal=false
 +EOF
++
 +# Copy to required location
 +cp Sniffly.AppDir/sniffly.desktop Sniffly.AppDir/usr/share/applications/
++
 +# Create AppRun script
 +cat > Sniffly.AppDir/AppRun << 'EOF'
 +#!/bin/bash
 +SELF=$(readlink -f "$0")
 +HERE=${SELF%/*}
 +export PATH="${HERE}/usr/bin:${PATH}"
 +export LD_LIBRARY_PATH="${HERE}/usr/lib:${LD_LIBRARY_PATH}"
 +export XDG_DATA_DIRS="${HERE}/usr/share:${XDG_DATA_DIRS}"
 +exec "${HERE}/usr/bin/sniffly" "$@"
 +EOF
++
 +chmod +x Sniffly.AppDir/AppRun
++
 +# Download appimagetool
 +wget https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
 +chmod +x appimagetool-x86_64.AppImage
++
 +# Build AppImage
 +./appimagetool-x86_64.AppImage Sniffly.AppDir Sniffly-0.1.0-x86_64.AppImage
 +```
++
 +**Note**: AppImage requires GTK4 to be installed on the system. For a fully self-contained AppImage, you'd need to bundle GTK4 libraries.
++
 +### Option 2: Debian Package (.deb)
++
 +For Debian/Ubuntu users:
++
 +```bash
 +# Create package structure
 +mkdir -p sniffly-0.1.0/DEBIAN
 +mkdir -p sniffly-0.1.0/usr/bin
 +mkdir -p sniffly-0.1.0/usr/share/applications
 +mkdir -p sniffly-0.1.0/usr/share/icons/hicolor/256x256/apps
++
 +# Copy files
 +cp build/sniffly sniffly-0.1.0/usr/bin/
 +cp assets/sniffly.png sniffly-0.1.0/usr/share/icons/hicolor/256x256/apps/
 +cp assets/sniffly.desktop sniffly-0.1.0/usr/share/applications/
++
 +# Create control file
 +cat > sniffly-0.1.0/DEBIAN/control << 'EOF'
 +Package: sniffly
 +Version: 0.1.0
 +Section: utils
 +Priority: optional
 +Architecture: amd64
 +Depends: libgtk-4-1, libglib2.0-0
 +Maintainer: FortranGoingOnForty <your@email.com>
 +Description: Disk Space Analyzer
 + A fast, beautiful disk space analyzer built with Fortran and GTK4.
 + Visualizes disk usage with interactive treemaps.
 +EOF
++
 +# Build the package
 +dpkg-deb --build sniffly-0.1.0
 +```
++
 +### Option 3: RPM Package (Fedora/RedHat)
++
 +```bash
 +# Create RPM build directories
 +mkdir -p ~/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
++
 +# Create spec file
 +cat > ~/rpmbuild/SPECS/sniffly.spec << 'EOF'
 +Name:           sniffly
 +Version:        0.1.0
 +Release:        1%{?dist}
 +Summary:        Disk Space Analyzer
 +License:        MIT
 +URL:            https://github.com/FortranGoingOnForty/sniffly
 +Source0:        %{name}-%{version}.tar.gz
++
 +BuildRequires:  meson, gcc-gfortran, gtk4-devel
 +Requires:       gtk4
++
 +%description
 +A fast, beautiful disk space analyzer built with Fortran and GTK4.
++
 +%prep
 +%setup -q
++
 +%build
 +meson setup build
 +meson compile -C build
++
 +%install
 +install -Dm755 build/sniffly %{buildroot}%{_bindir}/sniffly
 +install -Dm644 assets/sniffly.desktop %{buildroot}%{_datadir}/applications/sniffly.desktop
 +install -Dm644 assets/sniffly.png %{buildroot}%{_datadir}/icons/hicolor/256x256/apps/sniffly.png
++
 +%files
 +%{_bindir}/sniffly
 +%{_datadir}/applications/sniffly.desktop
 +%{_datadir}/icons/hicolor/256x256/apps/sniffly.png
++
 +%changelog
 +* Mon Jan 01 2024 Your Name <your@email.com> - 0.1.0-1
 +- Initial release
 +EOF
++
 +# Create source tarball
 +tar czf ~/rpmbuild/SOURCES/sniffly-0.1.0.tar.gz ../sniffly/
++
 +# Build RPM
 +rpmbuild -ba ~/rpmbuild/SPECS/sniffly.spec
 +```
++
 +---
++
 +## Automated Packaging with CI/CD
++
 +### GitHub Actions Example
++
 +Create `.github/workflows/release.yml`:
++
 +```yaml
 +name: Release Build
++
 +on:
 +  push:
 +    tags:
 +      - 'v*'
++
 +jobs:
 +  build-macos:
 +    runs-on: macos-latest
 +    steps:
 +      - uses: actions/checkout@v3
 +      - name: Install dependencies
 +        run: |
 +          brew install meson gtk4 gcc
 +      - name: Build
 +        run: |
 +          meson setup build
 +          meson compile -C build
 +      - name: Create DMG
 +        run: |
 +          # Add DMG creation steps here
 +      - name: Upload Release Asset
 +        uses: actions/upload-artifact@v3
 +        with:
 +          name: Sniffly-macOS.dmg
 +          path: Sniffly-*.dmg
++
 +  build-linux:
 +    runs-on: ubuntu-latest
 +    steps:
 +      - uses: actions/checkout@v3
 +      - name: Install dependencies
 +        run: |
 +          sudo apt-get update
 +          sudo apt-get install -y meson gfortran libgtk-4-dev
 +      - name: Build
 +        run: |
 +          meson setup build
 +          meson compile -C build
 +      - name: Create AppImage
 +        run: |
 +          # Add AppImage creation steps here
 +      - name: Upload Release Asset
 +        uses: actions/upload-artifact@v3
 +        with:
 +          name: Sniffly-Linux-x86_64.AppImage
 +          path: Sniffly-*.AppImage
 +```
++
 +---
++
 +## Quick Start Summary
++
 +### macOS
 +1. Build the app: `meson compile -C build`
 +2. Create .app bundle structure
 +3. Use `dylibbundler` to bundle GTK4 libraries
 +4. Create .dmg with `hdiutil`
 +5. (Optional) Code sign and notarize
++
 +**Result**: `Sniffly-0.1.0-macOS.dmg`
++
 +### Linux
 +1. Build the app: `meson compile -C build`
 +2. Create AppDir structure
 +3. Use `appimagetool` to create AppImage
 +4. Or create .deb/.rpm for specific distros
++
 +**Result**: `Sniffly-0.1.0-x86_64.AppImage` or `.deb`/`.rpm`
++
 +---
++
 +## Distribution Checklist
++
 +- [ ] Create application icon (1024x1024 PNG)
 +- [ ] Create .desktop file for Linux
 +- [ ] Test on clean system without development tools
 +- [ ] Document system requirements (GTK4, etc.)
 +- [ ] Add installation instructions to README
 +- [ ] Create GitHub releases page
 +- [ ] Consider Homebrew formula for macOS
 +- [ ] Consider Flatpak for Linux (alternative to AppImage)
++
 +---
++
 +## Notes on GTK4 Dependencies
++
 +Sniffly requires GTK4 at runtime. You have three options:
++
 +1. **User installation**: Require users to install GTK4 (`brew install gtk4` on macOS, `apt install libgtk-4-1` on Debian)
 +2. **Bundle libraries**: Include GTK4 in your app bundle (increases size ~100MB but works anywhere)
 +3. **Hybrid**: Bundle on macOS, rely on system packages on Linux
++
 +For the best user experience, option 2 (bundling) is recommended for macOS, while option 1 (system packages) works well for Linux where GTK4 is commonly available.
++
 +---
++
 +## Future Improvements
++
 +- **Flatpak**: Cross-distro sandboxed app (like macOS .app)
 +- **Snap**: Alternative Linux universal package
 +- **Homebrew Cask**: Easy installation on macOS (`brew install --cask sniffly`)
 +- **AUR Package**: For Arch Linux users
 +- **Windows**: Cross-compile with MinGW-w64 (if desired)

PROJECT_SUMMARY.mdadded

 +# Sniffly Project Summary
++
 +**Status:** Planning Complete ✅
 +**Date:** 2025-11-04
 +**Next Step:** Begin Phase 1 Development
++
 +---
++
 +## What We're Building
++
 +**Sniffly** is a pure Fortran GUI application that visualizes disk space usage with interactive treemap diagrams. It's a near 1:1 clone of SpaceSniffer (a popular Windows tool) but for Unix systems (macOS and Linux).
++
 +### The Big Idea
++
 +Prove that Fortran isn't just for scientific computing—it can build beautiful, modern GUI applications that rival commercial software written in C++/C#.
++
 +---
++
 +## Technology Stack (Final Decision)
++
 +| Component | Technology | Why |
 +|-----------|-----------|-----|
 +| **Language** | Fortran 2008+ | Pure Fortran philosophy, performance |
 +| **GUI Framework** | GTK4 | Modern, cross-platform, has Fortran bindings |
 +| **Bindings** | gtk-fortran 3.24.41+ | Only mature Fortran GUI library |
 +| **Graphics** | Cairo 1.18+ | Hardware-accelerated 2D drawing |
 +| **Text** | Pango | Font rendering, ellipsization |
 +| **Build System** | Meson (primary) | GTK standard, handles dependencies |
 +| **Platforms** | macOS, Linux | Priority targets (no Windows) |
++
 +---
++
 +## Core Features
++
 +### Must-Have (v1.0)
++
 +1. **Real-time Treemap Visualization**
 +   - Animated growth during scanning
 +   - Nested rectangles proportional to file sizes
 +   - Smooth layout transitions
++
 +2. **Two Layout Algorithms**
 +   - Squarified treemap (already implemented in sniffert)
 +   - Cushioned treemap (3D shading effect like SpaceSniffer)
++
 +3. **Interactive Navigation**
 +   - Click to zoom into directories
 +   - Breadcrumb navigation bar
 +   - Context menus (right-click)
 +   - Keyboard shortcuts (same as sniffert: q, c, d, arrows)
++
 +4. **Search and Filter**
 +   - Search by filename (regex support)
 +   - Filter by file type, size, date
 +   - Highlight matching files
++
 +5. **Safe File Deletion**
 +   - Delete with confirmation dialog
 +   - Show full path and size
 +   - Large deletions require typing name
++
 +6. **Visual Customization**
 +   - Multiple color schemes (Light, Dark, High Contrast)
 +   - Color by file type, age, or custom
 +   - Configurable fonts and sizes
++
 +7. **High Performance**
 +   - Handle 1M+ files
 +   - 60fps rendering
 +   - Background scanning without blocking UI
++
 +### Nice-to-Have (Post-v1.0)
++
 +- Export treemap as PNG/SVG
 +- Compare two directory snapshots
 +- Bookmarks for frequent directories
 +- Hidden files toggle
 +- Multiple tabs
++
 +---
++
 +## Architecture Overview
++
 +```
 +┌─────────────────────────────────────────┐
 +│         GTK4 Main Window                │
 +│  ┌───────────────────────────────────┐  │
 +│  │ Toolbar: Scan | Layout | Search   │  │
 +│  ├───────────────────────────────────┤  │
 +│  │                                   │  │
 +│  │   Treemap Widget (Custom)        │  │
 +│  │   ┌───────────────────────────┐  │  │
 +│  │   │  Cairo Drawing Surface    │  │  │
 +│  │   │  (Rectangles, gradients)  │  │  │
 +│  │   └───────────────────────────┘  │  │
 +│  │                                   │  │
 +│  ├───────────────────────────────────┤  │
 +│  │ Status: Scanning /foo/bar        │  │
 +│  └───────────────────────────────────┘  │
 +└─────────────────────────────────────────┘
 +           │
 +           ↓
 +┌─────────────────────────────────────────┐
 +│      Application State Manager          │
 +│  • Directory tree (file_node)           │
 +│  • Layout cache                         │
 +│  • Selection state                      │
 +│  • Scan progress                        │
 +└─────────────────────────────────────────┘
 +           │
 +    ┌──────┴───────┐
 +    ↓              ↓
 +┌────────┐    ┌────────┐
 +│Scanner │    │Renderer│
 +│(thread)│    │(Cairo) │
 +└────────┘    └────────┘
 +```
++
 +### Module Organization
++
 +```
 +src/
 +├── core/          # Reused from sniffert
 +│   ├── types.f90
 +│   ├── file_system.f90
 +│   ├── disk_scanner.f90
 +│   └── utils.f90
 +│
 +├── layout/        # Treemap algorithms
 +│   ├── squarified.f90  (port from sniffert)
 +│   ├── cushioned.f90   (new implementation)
 +│   └── layout_manager.f90
 +│
 +├── gui/           # GTK4 interface
 +│   ├── gtk_app.f90
 +│   ├── main_window.f90
 +│   ├── treemap_widget.f90
 +│   └── dialogs.f90
 +│
 +├── rendering/     # Cairo drawing
 +│   ├── cairo_renderer.f90
 +│   ├── colors.f90
 +│   └── effects.f90
 +│
 +└── state/         # App state
 +    ├── app_state.f90
 +    ├── selection.f90
 +    └── scan_manager.f90
 +```
++
 +---
++
 +## Development Timeline
++
 +**Total Duration:** 12-14 weeks to v1.0
++
 +| Phase | Weeks | Goal | Key Deliverables |
 +|-------|-------|------|-----------------|
 +| **Phase 1** | 1-2 | Foundation & GTK Setup | Basic GTK window, Cairo drawing |
 +| **Phase 2** | 3-4 | Core Data & Scanning | Background scanning, state management |
 +| **Phase 3** | 5-6 | Layout Algorithms | Squarified + Cushioned layouts |
 +| **Phase 4** | 7-8 | Cairo Rendering | Beautiful rendering, cushion effects |
 +| **Phase 5** | 9-10 | Interactivity | Navigation, context menus, keyboard |
 +| **Phase 6** | 11 | Search & Filter | Search box, filtering UI |
 +| **Phase 7** | 12 | Polish & Config | Settings, animations, accessibility |
 +| **Phase 8** | 13-14 | Testing & Packaging | Packages for macOS/Linux |
++
 +### Current Status
++
 +✅ **Planning Complete** (Week 0)
 +- All documentation written
 +- Architecture designed
 +- Stack chosen and validated
++
 +🚧 **Phase 1 Starting** (Week 1)
 +- Install dependencies
 +- Build hello world GTK app
 +- Set up project structure
++
 +---
++
 +## Key Technical Decisions
++
 +### 1. Pure Fortran (No C++/Python hybrid)
++
 +**Decision:** Use ONLY Fortran via gtk-fortran
 +**Rationale:** Proves the point that Fortran can do GUIs
 +**Trade-off:** Steeper learning curve, less examples
 +**Mitigation:** gtk-fortran is mature and well-documented
++
 +### 2. GTK4 (Not Qt, wxWidgets, or custom OpenGL)
++
 +**Decision:** GTK4 via gtk-fortran
 +**Rationale:**
 +- Only mature Fortran GUI bindings exist
 +- Native on Linux, good on macOS (Cocoa backend)
 +- Cairo integration for custom drawing
++
 +**Trade-off:** Not as native-looking on macOS as Qt
 +**Mitigation:** GTK4 is much better than GTK3 on macOS
++
 +### 3. Cushioned Treemap (Not Spiral)
++
 +**Decision:** Implement cushioned treemap (like SpaceSniffer)
 +**Rationale:** Research shows SpaceSniffer uses cushioned, not spiral
 +**Implementation:** Van Wijk algorithm with Cairo gradients
 +**Benefit:** More visually appealing than flat squarified
++
 +### 4. Meson Build System (Not Make or pure FPM)
++
 +**Decision:** Meson primary, FPM fallback
 +**Rationale:**
 +- Meson is GTK standard
 +- Handles pkg-config dependencies elegantly
 +- Cross-platform without pain
++
 +**Trade-off:** Fortran community less familiar with Meson
 +**Mitigation:** Provide clear build instructions
++
 +### 5. Package Manager Distribution (Not just GitHub releases)
++
 +**Decision:** Target Homebrew, apt, pacman
 +**Rationale:** Users expect `brew install sniffly`, not "build from source"
 +**Implementation:** Create packages in Phase 8
 +**Benefit:** Wider adoption, professional image
++
 +---
++
 +## Success Metrics
++
 +### Technical Success
++
 +- ✅ Builds on macOS and Linux without errors
 +- ✅ Handles 1M+ files in < 10 seconds scan time
 +- ✅ Renders at 60fps with 1000s of visible nodes
 +- ✅ Uses < 1GB RAM for 1M files
 +- ✅ No memory leaks (valgrind clean)
++
 +### Community Success
++
 +- 🎯 1,000 GitHub stars in first 3 months
 +- 🎯 10,000 downloads in first 6 months
 +- 🎯 Accepted into Homebrew and major Linux repos
 +- 🎯 5+ external contributors
 +- 🎯 Featured on Hacker News or /r/programming
++
 +### Philosophy Success
++
 +- 🎯 Proves Fortran can build modern GUIs
 +- 🎯 Becomes showcase example for gtk-fortran
 +- 🎯 Inspires other Fortran GUI projects
 +- 🎯 Mentioned in "Fortran can do that?!" articles
++
 +---
++
 +## Risk Assessment
++
 +| Risk | Probability | Impact | Mitigation |
 +|------|------------|--------|------------|
 +| gtk-fortran bugs/limitations | Medium | High | Join community early, contribute fixes |
 +| Performance insufficient | Low | High | Profile early, optimize, viewport culling |
 +| GTK4 not native on macOS | Low | Medium | Accept "good enough", focus on functionality |
 +| Build complexity scares users | Medium | Medium | Package managers, pre-built binaries |
 +| Cushion algorithm too complex | Low | Low | Well-documented (Van Wijk paper), examples exist |
 +| Timeline slips | Medium | Low | Phases are independent, can adjust scope |
++
 +---
++
 +## Documentation Created
++
 +All planning documents are complete and ready:
++
 +1. **README.md** - Project overview, status, quick links
 +2. **SNIFFLY_MASTER_PLAN.md** - Complete 14-week roadmap (comprehensive!)
 +3. **TECHNICAL_STACK.md** - Deep dive on all technology choices
 +4. **QUICKSTART.md** - 30-minute setup guide with examples
 +5. **GETTING_STARTED.md** - Contributor guide, workflow, style
 +6. **PROJECT_SUMMARY.md** - This document
 +7. **LICENSE** - MIT License
 +8. **meson.build** - Build configuration
 +9. **.gitignore** - Git ignore rules
++
 +**Total Documentation:** ~15,000 words across 9 files
++
 +---
++
 +## Project Structure Created
++
 +```
 +sniffly/
 +├── README.md
 +├── SNIFFLY_MASTER_PLAN.md
 +├── TECHNICAL_STACK.md
 +├── QUICKSTART.md
 +├── GETTING_STARTED.md
 +├── PROJECT_SUMMARY.md
 +├── LICENSE
 +├── meson.build
 +├── .gitignore
 +│
 +├── app/                 # (empty, ready for main.f90)
 +├── src/
 +│   ├── core/            # (empty, ready for modules)
 +│   ├── layout/
 +│   ├── gui/
 +│   ├── rendering/
 +│   └── state/
 +├── test/                # (empty, ready for tests)
 +├── docs/                # (empty, ready for docs)
 +└── examples/            # (empty, ready for examples)
 +```
++
 +---
++
 +## Next Steps (Immediate)
++
 +### Week 1: Environment Setup
++
 +1. **Install Dependencies**
 +   ```bash
 +   # macOS
 +   brew install gtk4 gfortran meson ninja
++
 +   # Ubuntu
 +   sudo apt install libgtk-4-dev gfortran meson ninja-build
 +   ```
++
 +2. **Build gtk-fortran**
 +   ```bash
 +   git clone https://github.com/vmagnin/gtk-fortran.git
 +   cd gtk-fortran
 +   cmake -B build && cmake --build build
 +   sudo cmake --install build
 +   ```
++
 +3. **Test GTK4 Works**
 +   - Follow QUICKSTART.md hello world example
 +   - Verify window opens
 +   - Verify Cairo drawing works
++
 +4. **Create First Modules**
 +   - Port `src/types.f90` from sniffert
 +   - Port `src/file_system.f90` from sniffert
 +   - Create `app/main.f90` with basic GTK app
++
 +### Week 2: Basic UI
++
 +1. **Create gtk_app Module**
 +   - Initialize GTK application
 +   - Create main window
 +   - Add menu bar skeleton
++
 +2. **Create treemap_widget Module**
 +   - Custom GtkDrawingArea
 +   - Connect draw signal
 +   - Draw static rectangles (test)
++
 +3. **Test Build System**
 +   - Update meson.build with sources
 +   - Build and run
 +   - Verify end-to-end compilation
++
 +---
++
 +## Long-term Vision
++
 +### Version 1.0 (Week 14)
++
 +- ✅ Feature parity with terminal sniffert
 +- ✅ Beautiful GUI with cushion effects
 +- ✅ Packages for macOS and Linux
 +- ✅ Documentation complete
++
 +### Version 1.x (Months 2-6)
++
 +- Multiple tabs for different scans
 +- Export treemap as images
 +- Compare directory snapshots
 +- Cloud storage integration (?)
++
 +### Version 2.0 (6+ months)
++
 +- Plugin system for custom layouts
 +- Network drive scanning
 +- Advanced filtering (by owner, permissions)
 +- Duplicate file detection
++
 +---
++
 +## Relationship to sniffert
++
 +Sniffly is the GUI companion to sniffert:
++
 +| Feature | sniffert (terminal) | sniffly (GUI) |
 +|---------|-------------------|---------------|
 +| **Interface** | Terminal (ncurses) | Native window (GTK4) |
 +| **Input** | Keyboard only | Mouse + keyboard |
 +| **Visual** | ASCII art | Beautiful cushion maps |
 +| **Performance** | Lightweight | More resource-intensive |
 +| **Use Case** | SSH, servers | Desktop workstations |
 +| **Shared Code** | Types, scanning, layout algorithms | |
++
 +Both prove Fortran can do modern UIs!
++
 +---
++
 +## Why This Will Succeed
++
 +1. **Solid Foundation**
 +   - Proven algorithms from sniffert
 +   - gtk-fortran is mature and maintained
 +   - GTK4 is modern and well-documented
++
 +2. **Clear Plan**
 +   - 8 phases with specific deliverables
 +   - Each phase builds on previous
 +   - Realistic timeline with buffer
++
 +3. **Technical Excellence**
 +   - Performance targets defined
 +   - Testing strategy planned
 +   - Package distribution planned
++
 +4. **Community Appeal**
 +   - "Fortran can do that?!" factor
 +   - Useful tool people actually need
 +   - Open source, easy to contribute
++
 +5. **Proven Demand**
 +   - SpaceSniffer is popular on Windows
 +   - Unix users want equivalent
 +   - No good open-source alternative exists
++
 +---
++
 +## Quotes to Remember
++
 +> "Why Fortran?"
 +> **"Why not? It's fast, proven, and this proves it can do anything."**
++
 +> "Is gtk-fortran mature enough?"
 +> **"Yes! It's been around since 2011, actively maintained, and production-ready."**
++
 +> "Can Fortran really do GUIs?"
 +> **"Watch us. We're building a SpaceSniffer clone that will blow your mind."**
++
 +---
++
 +## Final Checklist
++
 +Planning Phase Complete:
++
 +- ✅ Research SpaceSniffer features
 +- ✅ Research gtk-fortran capabilities
 +- ✅ Choose technology stack
 +- ✅ Design architecture
 +- ✅ Create module structure
 +- ✅ Write comprehensive documentation
 +- ✅ Create project structure
 +- ✅ Define success metrics
 +- ✅ Assess risks
 +- ✅ Create timeline
++
 +**Status: Ready to Begin Development! 🚀**
++
 +---
++
 +## Contact & Links
++
 +- **Project Location:** `/Users/matthewwolffe/Documents/GithubOrgs/FortranGoingOnForty/sniffly`
 +- **Related Project:** `../sniffert` (terminal version)
 +- **Main Documentation:** `SNIFFLY_MASTER_PLAN.md`
 +- **Quick Start:** `QUICKSTART.md`
++
 +---
++
 +**Sniffly: Proving Fortran Can Build Beautiful GUIs**
++
 +*Created: 2025-11-04*
 +*Planning Phase: Complete ✅*
 +*Next Phase: Development Begins 🚀*

SNIFFLY-TABS.mdadded

 +# tabs in sniffly
++
 +one thing that spacesniffer had that we dont is control of some kind of multi directory view
++
 +spacesniffer achieved this with something akin to panes
 +  - if i recall it was actually sub windows within the main window
++
 +I have a slightly different  vision.
 +I always found the panes approach to be cluttered.
++
 +We have a natural space for a tab bar. It's on the far right on the same level as the breadcrumn
 +they'll be small to fit in the space but they'll have active highlighting with a yellowish border and maybe slight highlighting
 +you'll be able to navigate between tabs with cmd-<number key>
 +tabs will have small x's on them to close
 +tabs open to the left, that is there's a small + button on the left side of the most recently made tab
 +the program starts in tab 0 (alt-1) by default.
++
 +we'll have to be careful about state.
 +We'll have to be careful about scans in quicl succession or concurrent scans since that will require juggling many threads unless we can be smart about it and be clean and safe.
++
 +what other pitfalls do you see? Let's discuss and plan this feature'
++

SNIFFLY_MASTER_PLAN.mdadded

1101 lines changed — click to load

 +# SNIFFLY - Pure Fortran GUI Disk Analyzer
 +## The SpaceSniffer Clone That Proves Fortran Can Do Anything
++
 +---
++
 +## 🎯 Project Vision
++
 +Build a near 1:1 clone of SpaceSniffer using **pure Fortran** with GTK4, proving that Fortran can create modern, performant GUI applications that rival commercial Windows software. Target macOS and Linux with package manager distribution.
++
 +---
++
 +## 📋 Executive Summary
++
 +**What:** Native GUI disk analyzer with real-time treemap visualization
 +**Why:** Prove Fortran's capabilities while providing Unix users with a SpaceSniffer alternative
 +**How:** gtk-fortran + GTK4 + Cairo for rendering, leveraging sniffert's proven algorithms
 +**When:** 12-week development cycle with 4 major milestones
 +**Success:** Native performance, handles 1M+ files, packaged for Homebrew/apt/pacman
++
 +---
++
 +## 🏗️ Technology Stack
++
 +### Core Technologies
++
 +| Component | Technology | Rationale |
 +|-----------|-----------|-----------|
 +| **Language** | Fortran 2008+ (gfortran 9.0+) | Pure Fortran philosophy, proven performance |
 +| **GUI Framework** | GTK4 via gtk-fortran | Modern, cross-platform, well-maintained |
 +| **Graphics** | Cairo 1.18+ | Hardware-accelerated 2D drawing |
 +| **Build System** | Meson + FPM fallback | GTK standard, Fortran-friendly |
 +| **Dependencies** | GLib 2.80+, GDK4, Pango | GTK ecosystem |
++
 +### Why gtk-fortran?
++
 +1. **Full GTK4 Support**: Latest gtk-fortran (3.24.41) includes GTK4 bindings
 +2. **Cairo Integration**: Direct access to Cairo drawing API for custom rendering
 +3. **Cross-Platform**: Linux, macOS, FreeBSD native support
 +4. **Active Development**: Maintained by Vincent Magnin, regular updates
 +5. **Fortran-Native**: High-level interface using Fortran optional arguments
 +6. **Production-Ready**: Used in scientific visualization applications
++
 +---
++
 +## 🎨 SpaceSniffer Feature Analysis
++
 +### Core Features (Must-Have)
++
 +1. **Real-time Treemap Visualization**
 +   - Animated growth as scanning progresses
 +   - Nested rectangles proportional to file sizes
 +   - Smooth transitions on layout changes
++
 +2. **Interactive Navigation**
 +   - Click to zoom into directories
 +   - Breadcrumb navigation bar
 +   - Right-click context menus
 +   - Keyboard shortcuts (same as sniffert)
++
 +3. **Visual Enhancements**
 +   - Cushioned treemap effect (3D shading)
 +   - Color coding by file type/age
 +   - Smart label placement (only when space permits)
 +   - Hover tooltips with full path and details
++
 +4. **Scanning Features**
 +   - Background scanning with progress indicator
 +   - Pause/resume scanning
 +   - Skip inaccessible directories gracefully
 +   - Show free space and unknown space
++
 +5. **File Management**
 +   - Open files/directories in default app
 +   - Delete with confirmation dialog
 +   - Show in file manager
 +   - Copy path to clipboard
++
 +6. **Search and Filter**
 +   - Text search by filename
 +   - Filter by file type (regex patterns)
 +   - Filter by size range
 +   - Filter by date range
++
 +7. **Configuration**
 +   - Layout algorithm selection (Squarified/Cushioned)
 +   - Color scheme customization
 +   - Animation speed control
 +   - Font size adjustment
++
 +### Optional Features (Nice-to-Have)
++
 +- Export treemap as PNG/SVG
 +- Compare two directory snapshots
 +- Bookmarks for frequent directories
 +- Hidden files toggle
 +- Multiple tabs for different scans
++
 +---
++
 +## 📐 Architecture Design
++
 +### Module Structure
++
 +```
 +sniffly/
 +├── meson.build                 # Primary build system
 +├── fpm.toml                    # Fallback build system
 +├── app/
 +│   └── main.f90                # GTK application entry point
 +├── src/
 +│   ├── core/                   # Reusable from sniffert
 +│   │   ├── types.f90           # Core data types (file_node, rect)
 +│   │   ├── file_system.f90     # POSIX filesystem operations
 +│   │   ├── disk_scanner.f90    # Background scanning with callbacks
 +│   │   └── utils.f90           # String formatting, size conversion
 +│   │
 +│   ├── layout/                 # Treemap algorithms
 +│   │   ├── squarified.f90      # Port from sniffert (enhanced)
 +│   │   ├── cushioned.f90       # Cushion treemap with shading
 +│   │   └── layout_manager.f90  # Algorithm selection/switching
 +│   │
 +│   ├── gui/                    # GTK4 interface
 +│   │   ├── gtk_app.f90         # GtkApplication setup
 +│   │   ├── main_window.f90     # Main application window
 +│   │   ├── treemap_widget.f90  # Custom GtkDrawingArea widget
 +│   │   ├── toolbar.f90         # Top toolbar with controls
 +│   │   ├── statusbar.f90       # Bottom status bar
 +│   │   ├── dialogs.f90         # Confirmation, settings dialogs
 +│   │   └── menus.f90           # Context menus, menu bar
 +│   │
 +│   ├── rendering/              # Cairo drawing
 +│   │   ├── cairo_renderer.f90  # Core rendering engine
 +│   │   ├── colors.f90          # Color schemes and gradients
 +│   │   ├── text_layout.f90     # Pango text rendering
 +│   │   └── effects.f90         # Cushion shading, animations
 +│   │
 +│   └── state/                  # Application state
 +│       ├── app_state.f90       # Global state management
 +│       ├── selection.f90       # Selection and navigation
 +│       ├── config.f90          # User settings persistence
 +│       └── scan_manager.f90    # Background scan coordination
 +│
 +└── test/
 +    ├── test_layouts.f90        # Layout algorithm tests
 +    ├── test_rendering.f90      # Rendering tests
 +    └── test_gui.f90            # GUI interaction tests
 +```
++
 +### Data Flow Architecture
++
 +```
 +┌─────────────────────────────────────────────────────────┐
 +│                    GTK4 Main Loop                       │
 +│                  (Event Processing)                     │
 +└─────────────────────────────────────────────────────────┘
 +                           │
 +                           ↓
 +┌─────────────────────────────────────────────────────────┐
 +│                   Main Window (GTK)                     │
 +│  ┌─────────────────────────────────────────────────┐   │
 +│  │  Toolbar: Scan Path | Layout | Color | Search  │   │
 +│  └─────────────────────────────────────────────────┘   │
 +│  ┌─────────────────────────────────────────────────┐   │
 +│  │         Treemap Widget (GtkDrawingArea)        │   │
 +│  │                                                 │   │
 +│  │  ┌────────────────────────────────────────┐    │   │
 +│  │  │   Cairo Drawing Surface               │    │   │
 +│  │  │   (Custom rendering via ::draw signal) │    │   │
 +│  │  └────────────────────────────────────────┘    │   │
 +│  └─────────────────────────────────────────────────┘   │
 +│  ┌─────────────────────────────────────────────────┐   │
 +│  │  Statusbar: Scanning... | Selected: /foo/bar   │   │
 +│  └─────────────────────────────────────────────────┘   │
 +└─────────────────────────────────────────────────────────┘
 +                           │
 +                           ↓
 +┌─────────────────────────────────────────────────────────┐
 +│              Application State Manager                  │
 +│  • Current directory tree (file_node)                   │
 +│  • Layout cache (cached bounds)                         │
 +│  • Selection state (current node, breadcrumb)           │
 +│  • Scan progress (% complete, items scanned)            │
 +└─────────────────────────────────────────────────────────┘
 +                           │
 +        ┌──────────────────┼──────────────────┐
 +        ↓                  ↓                  ↓
 +┌──────────────┐  ┌──────────────┐  ┌──────────────┐
 +│Disk Scanner  │  │Layout Engine │  │Cairo Renderer│
 +│(Background   │  │(Squarified/  │  │(Drawing API) │
 +│ Thread)      │  │ Cushioned)   │  │              │
 +└──────────────┘  └──────────────┘  └──────────────┘
 +```
++
 +### Threading Model
++
 +1. **Main Thread (GTK Event Loop)**
 +   - Handle all GUI events
 +   - Process user input
 +   - Trigger redraws (gtk_widget_queue_draw)
++
 +2. **Scanning Thread (GLib Thread)**
 +   - Background directory traversal
 +   - Periodic callbacks to main thread with updates
 +   - Use g_idle_add for thread-safe UI updates
++
 +3. **Layout Calculation**
 +   - Triggered by scan updates or window resize
 +   - Can be deferred if user is interacting
 +   - Cache results to avoid recalculation
++
 +---
++
 +## 🎨 Treemap Algorithms
++
 +### 1. Squarified Treemap (Already Implemented!)
++
 +**Status:** Port from sniffert with minor enhancements
 +**Algorithm:** Bruls et al. 2000
 +**Advantages:**
 +- Excellent aspect ratios (more square rectangles)
 +- Easy to compare sizes at a glance
 +- Already proven in sniffert
++
 +**Implementation Notes:**
 +- Reuse existing squarified.f90 from sniffert
 +- Enhance with real-time updates (incremental layout)
 +- Add smooth animation between layout changes
++
 +### 2. Cushioned Treemap (New Implementation)
++
 +**Status:** New development
 +**Algorithm:** Van Wijk & Van de Wetering 1999
 +**Visual Effect:** Adds 3D shading to rectangles using bump mapping
++
 +**How Cushion Shading Works:**
++
 +1. **Recursive Surface Function**
 +   ```
 +   For each rectangle at depth d:
 +   - Base surface: f(x, y) = 0
 +   - Add height function: h(x, y) = ax² + by²
 +   - Parameters a, b decrease with depth
 +   ```
++
 +2. **Lighting Model**
 +   ```
 +   - Light source direction: L = (lx, ly, lz)
 +   - Surface normal: N = (-∂f/∂x, -∂f/∂y, 1)
 +   - Color intensity: I = ambient + diffuse * (N · L)
 +   ```
++
 +3. **Implementation Steps**
 +   - Calculate cushion parameters for each node
 +   - Store in enhanced file_node structure
 +   - Apply during Cairo rendering pass
++
 +**Rendering in Cairo:**
 +```fortran
 +! For each cushioned rectangle:
 +! 1. Create linear gradient based on cushion function
 +! 2. Apply gradient as fill pattern
 +! 3. Add border for clarity
 +cairo_pattern_create_linear(x1, y1, x2, y2)
 +cairo_pattern_add_color_stop_rgba(pattern, 0.0, r1, g1, b1, 1.0)
 +cairo_pattern_add_color_stop_rgba(pattern, 1.0, r2, g2, b2, 1.0)
 +cairo_set_source(cr, pattern)
 +cairo_rectangle(cr, x, y, w, h)
 +cairo_fill(cr)
 +```
++
 +---
++
 +## 🎯 Implementation Phases
++
 +### Phase 1: Foundation & GTK Setup (Weeks 1-2)
++
 +**Goal:** Get GTK4 + gtk-fortran working with basic window
++
 +#### Tasks:
 +1. **Environment Setup**
 +   - Install GTK4 development libraries (macOS: Homebrew, Linux: package manager)
 +   - Install gtk-fortran from source or package
 +   - Create Meson build configuration
 +   - Test minimal GTK app (Hello World window)
++
 +2. **Project Structure**
 +   - Create module skeleton
 +   - Set up git repository structure
 +   - Configure build system (Meson + FPM fallback)
 +   - Create basic CI/CD workflow
++
 +3. **Basic GTK Application**
 +   - Implement GtkApplication setup
 +   - Create main window with title bar
 +   - Add basic menu bar (File → Scan, Quit)
 +   - Test on both macOS and Linux
++
 +4. **GtkDrawingArea Integration**
 +   - Create custom treemap widget
 +   - Implement ::draw signal handler
 +   - Test basic Cairo drawing (draw rectangle, text)
 +   - Verify rendering performance (target 60fps)
++
 +**Success Criteria:**
 +- Window opens with custom drawing area
 +- Can draw colored rectangles and text
 +- Builds on macOS and Linux
 +- No memory leaks (valgrind clean)
++
 +**Estimated Time:** 2 weeks
++
 +---
++
 +### Phase 2: Core Data & Scanning (Weeks 3-4)
++
 +**Goal:** Port sniffert's scanning logic with GTK integration
++
 +#### Tasks:
 +1. **Port Core Modules**
 +   - Adapt types.f90 for GUI needs
 +   - Port file_system.f90 unchanged
 +   - Port disk_scanner.f90 with callback support
 +   - Add thread-safe state management
++
 +2. **Background Scanning**
 +   - Implement GLib threading wrapper
 +   - Create scan_manager for coordinating scans
 +   - Add progress callbacks to main thread
 +   - Test with various directory sizes
++
 +3. **Progress UI**
 +   - Add progress bar to main window
 +   - Show scan statistics (files scanned, total size)
 +   - Implement pause/resume/cancel controls
 +   - Add estimated time remaining
++
 +4. **State Management**
 +   - Implement app_state module
 +   - Track current directory tree
 +   - Handle scan updates without blocking UI
 +   - Add basic error handling
++
 +**Success Criteria:**
 +- Can scan /tmp without blocking GUI
 +- Progress bar updates in real-time
 +- Can cancel mid-scan cleanly
 +- No crashes on permission denied
++
 +**Estimated Time:** 2 weeks
++
 +---
++
 +### Phase 3: Layout Algorithms (Weeks 5-6)
++
 +**Goal:** Implement both squarified and cushioned layouts
++
 +#### Tasks:
 +1. **Port Squarified Algorithm**
 +   - Copy squarified.f90 from sniffert
 +   - Adapt for real-time updates (incremental)
 +   - Optimize for large datasets (1M+ nodes)
 +   - Add unit tests comparing to sniffert output
++
 +2. **Implement Cushioned Algorithm**
 +   - Research cushion function parameters
 +   - Implement recursive cushion calculation
 +   - Store cushion data in file_node
 +   - Add toggle between layouts
++
 +3. **Layout Manager**
 +   - Abstract layout selection
 +   - Cache layout results
 +   - Invalidate cache on window resize
 +   - Implement smart recalculation (only changed subtrees)
++
 +4. **Performance Optimization**
 +   - Profile layout calculation time
 +   - Target < 100ms for 10k nodes
 +   - Use lazy evaluation for deep trees
 +   - Consider viewport culling for large trees
++
 +**Success Criteria:**
 +- Both layouts produce visually correct treemaps
 +- Can switch between layouts in < 1 second
 +- Handles 100k files without lag
 +- Layout respects window size constraints
++
 +**Estimated Time:** 2 weeks
++
 +---
++
 +### Phase 4: Cairo Rendering (Weeks 7-8)
++
 +**Goal:** Beautiful, performant rendering with cushion effects
++
 +#### Tasks:
 +1. **Basic Treemap Rendering**
 +   - Implement cairo_renderer module
 +   - Draw rectangles with borders
 +   - Render text labels (using Pango)
 +   - Handle clipping for nested rectangles
++
 +2. **Cushion Shading**
 +   - Implement lighting calculations
 +   - Create Cairo gradients for cushions
 +   - Add depth-based color variation
 +   - Test different light angles
++
 +3. **Color Schemes**
 +   - Implement file type coloring (directories, files, media, code, etc.)
 +   - Add color by age (old files, recent files)
 +   - Create multiple color schemes (Light, Dark, High Contrast)
 +   - Allow user customization
++
 +4. **Text Rendering**
 +   - Use Pango for text layout
 +   - Smart label placement (only show when space permits)
 +   - Ellipsize long filenames
 +   - Show size labels with proper formatting (KB, MB, GB)
++
 +5. **Performance**
 +   - Implement viewport culling (only draw visible rectangles)
 +   - Batch Cairo operations
 +   - Profile draw time (target < 16ms / 60fps)
 +   - Add FPS counter for debugging
++
 +**Success Criteria:**
 +- Treemap looks beautiful with cushion effect
 +- Smooth scrolling and zooming
 +- Text is readable at all zoom levels
 +- Maintains 60fps on 10k visible nodes
++
 +**Estimated Time:** 2 weeks
++
 +---
++
 +### Phase 5: Interactivity (Weeks 9-10)
++
 +**Goal:** Full SpaceSniffer-style navigation and interaction
++
 +#### Tasks:
 +1. **Mouse Interaction**
 +   - Implement hit testing (which rectangle was clicked?)
 +   - Single-click: select and highlight
 +   - Double-click: zoom into directory
 +   - Right-click: show context menu
 +   - Hover: show tooltip with details
++
 +2. **Keyboard Navigation**
 +   - Arrow keys: navigate siblings
 +   - Enter: zoom into selected
 +   - Backspace: zoom out to parent
 +   - Delete: delete with confirmation (from sniffert)
 +   - /: focus search box
 +   - Escape: cancel/clear selection
++
 +3. **Navigation UI**
 +   - Breadcrumb bar at top
 +   - Back/Forward buttons
 +   - "Go up" button
 +   - Animation on zoom transitions
++
 +4. **Context Menus**
 +   - Open in file manager
 +   - Open file with default app
 +   - Copy path to clipboard
 +   - Delete with confirmation
 +   - Properties dialog (size, modified date, permissions)
++
 +5. **Selection State**
 +   - Highlight selected rectangle
 +   - Show details in status bar
 +   - Persist selection across layout changes
 +   - Visual feedback on hover
++
 +**Success Criteria:**
 +- Navigation feels smooth and intuitive
 +- All keyboard shortcuts work
 +- Context menu matches macOS/Linux conventions
 +- No lag on interaction
++
 +**Estimated Time:** 2 weeks
++
 +---
++
 +### Phase 6: Search & Filter (Week 11)
++
 +**Goal:** Find files quickly in large trees
++
 +#### Tasks:
 +1. **Search UI**
 +   - Add search entry in toolbar
 +   - Show search results in tree view or list
 +   - Highlight matching rectangles in treemap
 +   - Clear search with Escape
++
 +2. **Search Implementation**
 +   - Full-text filename search
 +   - Regex pattern support
 +   - Case-insensitive option
 +   - Search scope (current directory vs entire tree)
++
 +3. **Filtering**
 +   - Filter by file type (extensions)
 +   - Filter by size range (e.g., files > 100MB)
 +   - Filter by date range (modified in last 7 days)
 +   - Combine multiple filters
++
 +4. **Filter UI**
 +   - Filter panel in sidebar (toggleable)
 +   - Quick filters in toolbar (e.g., "Large files")
 +   - Visual indication when filters active
 +   - Reset filters button
++
 +**Success Criteria:**
 +- Can find specific files in < 1 second
 +- Filters work on 100k+ files
 +- Search results update in real-time
 +- Filter state persists across zooms
++
 +**Estimated Time:** 1 week
++
 +---
++
 +### Phase 7: Polish & Configuration (Week 12)
++
 +**Goal:** Production-ready with user customization
++
 +#### Tasks:
 +1. **Settings Dialog**
 +   - General: animation speed, default layout
 +   - Colors: scheme selection, custom colors
 +   - Scanning: skip patterns, depth limit
 +   - Save settings to config file (~/.config/sniffly/config.ini)
++
 +2. **Toolbar**
 +   - Add all main actions
 +   - Icon design (consistent with GTK)
 +   - Tooltips for all buttons
 +   - Responsive layout (collapse on small windows)
++
 +3. **Status Bar**
 +   - Show scan progress
 +   - Show selected item details
 +   - Show totals (files, directories, size)
 +   - Show free space on drive
++
 +4. **Error Handling**
 +   - Graceful handling of permission denied
 +   - User-friendly error messages
 +   - Logging for debugging
 +   - Crash recovery (save scan state)
++
 +5. **Animations**
 +   - Smooth zoom transitions
 +   - Layout change animations
 +   - Progress indicator animations
 +   - Fade in/out for tooltips
++
 +6. **Accessibility**
 +   - Keyboard-only navigation support
 +   - High-contrast mode
 +   - Screen reader compatibility (GTK accessibility API)
 +   - Configurable font sizes
++
 +7. **Documentation**
 +   - User manual (markdown)
 +   - Keyboard shortcuts reference
 +   - Build instructions
 +   - Developer documentation
++
 +**Success Criteria:**
 +- App feels polished and professional
 +- All settings persist correctly
 +- No crashes under normal usage
 +- Passes accessibility audit
++
 +**Estimated Time:** 1 week
++
 +---
++
 +### Phase 8: Testing & Packaging (Weeks 13-14)
++
 +**Goal:** Release-ready packages for macOS and Linux
++
 +#### Tasks:
 +1. **Testing**
 +   - Unit tests for all modules
 +   - Integration tests for GUI workflows
 +   - Performance tests (1M files benchmark)
 +   - Memory leak testing (valgrind)
 +   - Test on multiple distributions
++
 +2. **Packaging - macOS**
 +   - Create .app bundle
 +   - Sign with Apple Developer ID
 +   - Create DMG installer
 +   - Homebrew formula (homebrew-core PR)
 +   - Test on macOS 12+ (Monterey, Ventura, Sonoma)
++
 +3. **Packaging - Linux**
 +   - Debian package (.deb) for Ubuntu/Debian
 +   - RPM package (.rpm) for Fedora/RHEL
 +   - AUR package for Arch
 +   - Flatpak for universal Linux
 +   - AppImage for portability
++
 +4. **Distribution**
 +   - Set up GitHub releases
 +   - Create release notes
 +   - Build CI/CD pipeline (GitHub Actions)
 +   - Automated builds for each platform
++
 +5. **Documentation**
 +   - README with screenshots
 +   - INSTALL guide for each platform
 +   - CONTRIBUTING guide
 +   - LICENSE (choose appropriate)
++
 +6. **Marketing**
 +   - Demo video showing features
 +   - Comparison with SpaceSniffer
 +   - Blog post: "Fortran Can Do GUIs!"
 +   - Submit to package managers
++
 +**Success Criteria:**
 +- Packages install cleanly on target platforms
 +- No runtime dependencies missing
 +- Passes package manager guidelines
 +- Downloads available from GitHub releases
++
 +**Estimated Time:** 2 weeks
++
 +---
++
 +## 🔧 Technical Challenges & Solutions
++
 +### Challenge 1: gtk-fortran Learning Curve
++
 +**Problem:** gtk-fortran is less documented than GTK's C API
 +**Solution:**
 +- Study gtk-fortran examples repo
 +- Reference GTK C documentation and translate
 +- Join gtk-fortran mailing list for support
 +- Contribute documentation back to project
++
 +### Challenge 2: Real-time Layout Updates
++
 +**Problem:** Layout recalculation can be slow for large trees
 +**Solution:**
 +- Incremental layout updates (only changed subtrees)
 +- Cache layout results aggressively
 +- Use dirty flagging to track what needs recalc
 +- Defer layout during rapid resizing (debounce)
++
 +### Challenge 3: Memory Management
++
 +**Problem:** Large directory trees consume significant memory
 +**Solution:**
 +- Use move_alloc to avoid deep copies (already in sniffert)
 +- Lazy loading for deep trees (only load visible levels)
 +- Configurable depth limit
 +- Manual deallocation of pruned subtrees
++
 +### Challenge 4: Thread Safety with GTK
++
 +**Problem:** GTK is not thread-safe; can't update UI from background thread
 +**Solution:**
 +- Use g_idle_add to queue UI updates from scan thread
 +- Wrap in gtk-fortran interface (c_funloc for callbacks)
 +- Keep shared state minimal and use mutex where needed
 +- Test thoroughly with ThreadSanitizer
++
 +### Challenge 5: Cushion Shading Performance
++
 +**Problem:** Gradient calculation for each rectangle can be slow
 +**Solution:**
 +- Pre-calculate cushion parameters during layout
 +- Use Cairo pattern caching
 +- Simplify lighting model (2-stop gradients)
 +- Profile and optimize hot paths
++
 +### Challenge 6: Cross-Platform Differences
++
 +**Problem:** macOS and Linux have different GTK behaviors
 +**Solution:**
 +- Test on both platforms regularly (CI/CD)
 +- Use GTK4's native backends (Cocoa on macOS)
 +- Avoid platform-specific code where possible
 +- Document known differences in README
++
 +---
++
 +## 📊 Performance Targets
++
 +### Scanning Performance
++
 +| Metric | Target | Stretch Goal |
 +|--------|--------|--------------|
 +| Files per second | 10,000 | 50,000 |
 +| Memory per file | < 500 bytes | < 300 bytes |
 +| Initial scan (100k files) | < 10 seconds | < 5 seconds |
 +| Background scan overhead | < 5% CPU | < 2% CPU |
++
 +### Rendering Performance
++
 +| Metric | Target | Stretch Goal |
 +|--------|--------|--------------|
 +| Frame rate (1k visible nodes) | 60 fps | 120 fps |
 +| Frame rate (10k visible nodes) | 30 fps | 60 fps |
 +| Layout calculation (10k nodes) | < 100ms | < 50ms |
 +| Zoom animation duration | 300ms | 200ms |
++
 +### Memory Usage
++
 +| Metric | Target | Stretch Goal |
 +|--------|--------|--------------|
 +| Base application memory | < 50 MB | < 30 MB |
 +| Per-file overhead | < 500 bytes | < 300 bytes |
 +| Layout cache overhead | < 2x file data | < 1.5x file data |
 +| Total for 1M files | < 1 GB | < 500 MB |
++
 +---
++
 +## 🎨 Visual Design
++
 +### Color Schemes
++
 +**Light Theme** (default on macOS)
 +- Background: #FFFFFF
 +- Directories: Shades of blue (#E3F2FD → #1976D2)
 +- Files: Shades of green (#E8F5E9 → #388E3C)
 +- Selected: Orange highlight (#FF6F00)
++
 +**Dark Theme** (default on Linux)
 +- Background: #1E1E1E
 +- Directories: Shades of purple (#4A148C → #BA68C8)
 +- Files: Shades of teal (#004D40 → #26A69A)
 +- Selected: Yellow highlight (#FDD835)
++
 +**High Contrast Theme**
 +- Strong borders on all rectangles
 +- High saturation colors
 +- Larger fonts
 +- No subtle gradients
++
 +### File Type Colors
++
 +| Type | Extension Examples | Color |
 +|------|-------------------|-------|
 +| Directories | (N/A) | Blue family |
 +| Documents | .pdf, .doc, .txt | Green family |
 +| Images | .jpg, .png, .gif | Orange family |
 +| Videos | .mp4, .mkv, .avi | Red family |
 +| Audio | .mp3, .flac, .wav | Purple family |
 +| Code | .c, .py, .js, .f90 | Cyan family |
 +| Archives | .zip, .tar, .gz | Brown family |
 +| Executables | .exe, .app, .bin | Gray family |
++
 +### Typography
++
 +- **Main Labels:** System font (San Francisco on macOS, Ubuntu on Linux)
 +- **Size Labels:** Monospace font for alignment
 +- **Minimum Readable Size:** 10pt
 +- **Label Visibility:** Only show when rectangle width > 60px and height > 20px
++
 +---
++
 +## 🚀 Distribution Strategy
++
 +### Package Managers
++
 +**macOS:**
 +1. **Homebrew** (primary)
 +   ```bash
 +   brew install sniffly
 +   ```
 +   - Submit formula to homebrew-core
 +   - Automatic updates
 +   - High visibility
++
 +2. **MacPorts** (secondary)
 +   ```bash
 +   sudo port install sniffly
 +   ```
++
 +**Linux:**
 +1. **Debian/Ubuntu** (APT)
 +   ```bash
 +   sudo apt install sniffly
 +   ```
 +   - Upload to Debian repositories
 +   - Backport to older releases
++
 +2. **Arch** (AUR)
 +   ```bash
 +   yay -S sniffly
 +   ```
 +   - Maintain PKGBUILD in AUR
 +   - Community-maintained
++
 +3. **Fedora/RHEL** (DNF)
 +   ```bash
 +   sudo dnf install sniffly
 +   ```
 +   - Submit to Fedora repositories
++
 +4. **Universal** (Flatpak)
 +   ```bash
 +   flatpak install sniffly
 +   ```
 +   - Works on all distributions
 +   - Sandboxed environment
++
 +### GitHub Releases
++
 +- Provide pre-built binaries for:
 +  - macOS (arm64, x86_64)
 +  - Linux (x86_64, arm64)
 +- Include source tarballs
 +- Automated release via GitHub Actions
 +- Semantic versioning (v1.0.0, v1.1.0, etc.)
++
 +---
++
 +## 📚 Dependencies
++
 +### Build Dependencies
++
 +| Dependency | Version | Package Name (Homebrew) | Package Name (APT) |
 +|------------|---------|-------------------------|-------------------|
 +| gfortran | 9.0+ | gcc | gfortran |
 +| GTK4 | 4.0+ | gtk4 | libgtk-4-dev |
 +| gtk-fortran | 3.24.41+ | (build from source) | (build from source) |
 +| GLib | 2.80+ | glib | libglib2.0-dev |
 +| Cairo | 1.18+ | cairo | libcairo2-dev |
 +| Pango | 1.50+ | pango | libpango1.0-dev |
 +| Meson | 0.60+ | meson | meson |
 +| Ninja | 1.10+ | ninja | ninja-build |
++
 +### Runtime Dependencies
++
 +| Dependency | Version | Included In |
 +|------------|---------|-------------|
 +| GTK4 runtime | 4.0+ | Package |
 +| GLib runtime | 2.80+ | Package |
 +| Cairo runtime | 1.18+ | Package |
++
 +---
++
 +## 🧪 Testing Strategy
++
 +### Unit Tests
++
 +**Location:** `test/` directory
 +**Framework:** FUnit or simple assertion framework
 +**Coverage:** > 80% of non-GUI code
++
 +**Test Categories:**
 +1. Layout algorithms (verify aspect ratios, area conservation)
 +2. File scanning (mock filesystem)
 +3. State management (selection, navigation)
 +4. Color calculations (verify gradients)
 +5. String formatting (size display)
++
 +### Integration Tests
++
 +**Framework:** Python + GTK inspector + screenshot comparison
++
 +**Test Scenarios:**
 +1. Launch app and scan /tmp
 +2. Navigate into directory via click
 +3. Zoom out via breadcrumb
 +4. Switch layout algorithm
 +5. Apply filters
 +6. Delete file with confirmation
 +7. Search for file
 +8. Change color scheme
++
 +### Performance Tests
++
 +**Benchmarks:**
 +1. Scan 1M files (measure time, memory)
 +2. Layout calculation (measure time for various node counts)
 +3. Rendering (measure FPS for various node counts)
 +4. Memory growth over time (detect leaks)
++
 +**Tools:**
 +- gprof for profiling
 +- valgrind for memory leaks
 +- perf for Linux profiling
 +- Instruments for macOS profiling
++
 +### Manual Testing
++
 +**Checklist:**
 +- [ ] Install on clean macOS system
 +- [ ] Install on clean Ubuntu system
 +- [ ] Install on clean Arch system
 +- [ ] Scan various directories (/usr, /home, /Applications)
 +- [ ] Resize window aggressively
 +- [ ] Navigate deep directory trees
 +- [ ] Delete files and verify
 +- [ ] Close and reopen (verify settings persist)
 +- [ ] Run for 1 hour (verify stability)
++
 +---
++
 +## 🔒 Security Considerations
++
 +### File System Access
++
 +- **Principle:** Only access what user explicitly scans
 +- **Implementation:**
 +  - No background scanning without user action
 +  - Respect system permissions
 +  - Skip symlinks to avoid cycles
 +  - Warn on permission denied
++
 +### Deletion Safety
++
 +- **Principle:** Make it hard to delete by accident
 +- **Implementation:**
 +  - Always show confirmation dialog
 +  - Show full path and size
 +  - For large deletions (>1GB), require typing name
 +  - No "remember my choice" option
 +  - Log deletions for audit trail
++
 +### Sandboxing
++
 +- **Flatpak:** Request filesystem access permission
 +- **macOS:** Request Full Disk Access if needed
 +- **General:** Run with user privileges (never root)
++
 +---
++
 +## 📈 Success Metrics
++
 +### Development Success
++
 +- [ ] All phases completed on schedule
 +- [ ] No P0 bugs at launch
 +- [ ] Performance targets met
 +- [ ] Passes all tests on both platforms
++
 +### Adoption Success
++
 +- [ ] 1,000 stars on GitHub in first 3 months
 +- [ ] 10,000 downloads in first 6 months
 +- [ ] Accepted into Homebrew and apt repositories
 +- [ ] Featured on Hacker News or /r/programming
++
 +### Community Success
++
 +- [ ] 5+ external contributors
 +- [ ] 10+ issues/PRs from community
 +- [ ] Mentioned in "Fortran can do that?" articles
 +- [ ] Used as gtk-fortran showcase example
++
 +---
++
 +## 🎓 Learning Resources
++
 +### gtk-fortran
++
 +- Official Wiki: https://github.com/vmagnin/gtk-fortran/wiki
 +- Examples: https://github.com/vmagnin/gtk-fortran/tree/master/examples
 +- Mailing List: gtk-fortran-devel@lists.sourceforge.net
++
 +### GTK4
++
 +- API Reference: https://docs.gtk.org/gtk4/
 +- Tutorial: https://www.gtk.org/docs/getting-started/
 +- Migration Guide (GTK3→4): https://docs.gtk.org/gtk4/migrating-3to4.html
++
 +### Cairo
++
 +- API Reference: https://www.cairographics.org/manual/
 +- Tutorial: https://www.cairographics.org/tutorial/
 +- Samples: https://www.cairographics.org/samples/
++
 +### Treemap Algorithms
++
 +- Squarified Treemaps: https://www.win.tue.nl/~vanwijk/stm.pdf
 +- Cushion Treemaps: https://www.win.tue.nl/~vanwijk/ctm.pdf
 +- Treemap History: http://www.cs.umd.edu/hcil/treemap-history/
++
 +---
++
 +## 🗺️ Roadmap
++
 +### Version 1.0 (12 weeks)
++
 +Core features:
 +- Real-time scanning with progress
 +- Squarified and cushioned layouts
 +- Interactive navigation (click, zoom, breadcrumb)
 +- Search and filter
 +- Delete with confirmation
 +- Settings persistence
 +- Package for macOS and Linux
++
 +### Version 1.1 (Post-launch +1 month)
++
 +Polish and community feedback:
 +- Bug fixes from user reports
 +- Performance improvements
 +- Additional color schemes
 +- Export treemap as image
 +- Localization support (i18n)
++
 +### Version 1.2 (Post-launch +3 months)
++
 +Advanced features:
 +- Compare two directory snapshots
 +- Show file age heatmap
 +- Bookmarks for frequent directories
 +- Multiple tabs
 +- Plugins/extensions system
++
 +### Version 2.0 (Post-launch +6 months)
++
 +Major enhancements:
 +- Network drive support
 +- Cloud storage integration (investigate)
 +- Advanced filters (by owner, permissions)
 +- Duplicate file detection
 +- Custom layout algorithms
++
 +---
++
 +## 🤝 Contributing
++
 +### For Fortran Developers
++
 +This project is a showcase of Fortran's capabilities! Contributions welcome:
 +- Algorithm optimizations
 +- New layout algorithms
 +- Performance improvements
 +- Code reviews
++
 +### For GUI Developers
++
 +Help make sniffly beautiful:
 +- UI/UX improvements
 +- Icon design
 +- Color scheme contributions
 +- Accessibility enhancements
++
 +### For Package Maintainers
++
 +Help distribute sniffly:
 +- Create packages for your favorite distro
 +- Test on various platforms
 +- Report packaging issues
 +- Maintain downstream packages
++
 +---
++
 +## 📄 License
++
 +**Recommendation:** MIT or BSD-3-Clause
++
 +**Rationale:**
 +- Permissive enough for wide adoption
 +- Compatible with GTK's LGPL
 +- Allows commercial use
 +- Simple and well-understood
++
 +---
++
 +## 🎉 Conclusion
++
 +This project will prove that Fortran can create modern, beautiful GUI applications that rival commercial software. By combining gtk-fortran's solid bindings with your already-excellent treemap algorithms, sniffly will be a showcase of:
++
 +1. **Fortran's Versatility:** Not just for scientific computing!
 +2. **Open Source Quality:** Unix users deserve great tools
 +3. **Performance:** Native code, no interpreter overhead
 +4. **Cross-Platform:** One codebase, multiple platforms
++
 +**Let's build this!** 🚀
++
 +---
++
 +**Next Steps:**
 +1. Install GTK4 and gtk-fortran
 +2. Create minimal GTK window test
 +3. Port core scanning logic
 +4. Start Phase 1 implementation
++
 +**Questions? Need help?**
 +- gtk-fortran community is friendly and helpful
 +- GTK documentation is extensive
 +- This plan is a living document - iterate as needed!
++
 +---
++
 +**Document Version:** 1.0
 +**Last Updated:** 2025-11-04
 +**Status:** Ready to Begin Development

SPACESNIFFER_FEATURES.mdadded

 +# SpaceSniffer Feature Parity Checklist
++
 +## 🎯 Goal: Near 1:1 Clone of SpaceSniffer for Unix
++
 +### ✅ Completed (Phase 1-2)
 +- [x] GTK4 window with Cairo rendering
 +- [x] Real directory scanning
 +- [x] Squarified treemap layout algorithm
 +- [x] Basic color coding
 +- [x] Handles large directories (32GB tested)
 +- [x] Window resize/redraw
++
 +### 🚧 In Progress (Phase 3-4)
 +- [x] **Directory Chooser** - Command-line argument support (GUI dialog deferred)
 +- [x] **File Names on Rectangles** - Show names when space permits
 +- [x] **Toolbar** - Scan and Quit buttons
 +- [x] **Status Bar** - Show ready status
 +- [x] **Top-Level Rendering** - Show only direct children (no deep nesting)
 +- [ ] **Size Labels** - Display MB/GB on large rectangles
++
 +### 📋 Critical Features (Phase 5-6)
 +- [ ] **Click to Select** - Highlight selected rectangle
 +- [ ] **Double-click to Zoom** - Navigate into directories
 +- [ ] **Breadcrumb Bar** - Show current path, allow navigation back
 +- [ ] **Hover Tooltips** - Show full path and details on hover
 +- [ ] **Context Menu** - Right-click: Open, Delete, Properties
 +- [ ] **Keyboard Navigation** - Arrow keys, Enter, Backspace
 +- [ ] **Delete with Confirmation** - Safe deletion workflow
++
 +### 🎨 Visual Enhancements (Phase 7)
 +- [ ] **Cushioned Treemap** - 3D shading effect (Van Wijk algorithm)
 +- [ ] **Better Color Schemes** - By file type, age, or extension
 +- [ ] **Smart Label Placement** - Only show when readable
 +- [ ] **Selection Highlight** - Clear visual feedback
 +- [ ] **Hover Effect** - Lighten/darken on mouse over
 +- [ ] **Smooth Animations** - Fade in/out, zoom transitions
++
 +### 🔍 Advanced Features (Phase 8)
 +- [ ] **Search Bar** - Find files by name (regex)
 +- [ ] **Filter Panel** - By type, size, date
 +- [ ] **Real-time Scanning** - Animate growth as files are found
 +- [ ] **Pause/Resume Scan** - Control during scanning
 +- [ ] **Free Space Display** - Show available disk space
 +- [ ] **Multiple Color Modes** - Switch between schemes
++
 +### 📊 Information Display
 +- [ ] **Status Bar Items:**
 +  - Currently scanning: /path/to/dir
 +  - Items scanned: 1,234 / 5,678
 +  - Total size: 32.5 GB
 +  - Selected: filename.ext (1.2 MB)
 +  - Free space: 128 GB
++
 +### 🖱️ Mouse & Keyboard
 +- [ ] **Mouse:**
 +  - Left click: Select
 +  - Double-click: Zoom in
 +  - Right-click: Context menu
 +  - Hover: Show tooltip
++
 +- [ ] **Keyboard:**
 +  - Arrow keys: Navigate siblings
 +  - Enter: Zoom into selected
 +  - Backspace: Zoom out to parent
 +  - Delete: Delete selected (with confirmation)
 +  - Ctrl+F: Search
 +  - Ctrl+Q: Quit
 +  - /: Focus search
 +  - Escape: Clear selection
++
 +### 🎨 Visual Polish
 +- [ ] **Colors:**
 +  - Directories: Blue family
 +  - Documents: Green family
 +  - Images: Orange family
 +  - Videos: Red family
 +  - Audio: Purple family
 +  - Code: Cyan family
 +  - Archives: Brown family
++
 +- [ ] **Fonts:**
 +  - Names: System font, bold for directories
 +  - Sizes: Monospace for alignment
 +  - Min size: 10pt readable
++
 +### 🔧 Settings/Preferences
 +- [ ] **Configurable:**
 +  - Layout algorithm (Squarified vs Cushioned)
 +  - Color scheme
 +  - Animation speed
 +  - Font size
 +  - Skip directories (.git, node_modules, etc.)
 +  - Scan depth limit
++
 +---
++
 +## 📈 Current Progress: ~45% Complete
++
 +### What Works Now:
 +✅ Scanning (4GB+ tested, scans entire tree)
 +✅ Layout calculation (squarified treemap algorithm)
 +✅ Smart rendering (shows only top-level, not nested)
 +✅ Window resizing with proper layout recalculation
 +✅ Directory selection (via command-line argument)
 +✅ File/directory names on rectangles (when space permits)
 +✅ Toolbar with Scan and Quit buttons
 +✅ Status bar showing scan status
++
 +### Immediate Priorities (Next 3 Commits):
 +1. **Click-to-select** - Highlight selected rectangle
 +2. **Double-click navigation** - Zoom into directories
 +3. **Breadcrumbs** - Show current path and navigate back
++
 +### Next Week Goals:
 +4. Click selection
 +5. Zoom navigation
 +6. Breadcrumbs
 +7. Tooltips
++
 +---
++
 +## 🎯 Success Criteria
++
 +A successful SpaceSniffer clone must:
 +- ✅ Scan and visualize any directory
 +- ⏳ Show file names and sizes clearly
 +- ⏳ Allow navigation (click, zoom, back)
 +- ⏳ Provide deletion with safety
 +- ⏳ Look professional (toolbar, status bar)
 +- ⏳ Handle large directories (millions of files)
 +- ⏳ Be as fast or faster than SpaceSniffer
++
 +---
++
 +**We're making great progress, but we're just getting started!** 🚀

Sniffly.app/Contents/Info.plistadded

 +<?xml version="1.0" encoding="UTF-8"?>
 +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 +<plist version="1.0">
 +<dict>
 +    <key>CFBundleExecutable</key>
 +    <string>sniffly</string>
 +    <key>CFBundleIdentifier</key>
 +    <string>org.fortrangoingonforty.sniffly</string>
 +    <key>CFBundleName</key>
 +    <string>Sniffly</string>
 +    <key>CFBundleDisplayName</key>
 +    <string>Sniffly</string>
 +    <key>CFBundleVersion</key>
 +    <string>0.2.7</string>
 +    <key>CFBundleShortVersionString</key>
 +    <string>0.2.7</string>
 +    <key>CFBundlePackageType</key>
 +    <string>APPL</string>
 +    <key>CFBundleSignature</key>
 +    <string>SNIF</string>
 +    <key>CFBundleIconFile</key>
 +    <string>sniffly</string>
 +    <key>LSMinimumSystemVersion</key>
 +    <string>11.0</string>
 +    <key>NSHighResolutionCapable</key>
 +    <true/>
 +    <key>NSRequiresAquaSystemAppearance</key>
 +    <false/>
 +    <key>LSApplicationCategoryType</key>
 +    <string>public.app-category.utilities</string>
 +</dict>
 +</plist>

Sniffly.app/Contents/MacOS/sniffly-binadded

Binary file changed.

Sniffly.app/Contents/PkgInfoadded

`@@ -0,0 +1,1 @@`
	1	+APPLSNIF

Sniffly.app/Contents/Resources/share/glib-2.0/schemas/gschema.dtdadded

 +<!ELEMENT schemalist (schema|enum|flags)* >
 +<!ATTLIST schemalist gettext-domain CDATA #IMPLIED >
++
 +<!ELEMENT schema (key|child|override)* >
 +<!ATTLIST schema id             CDATA #REQUIRED
 +                 path           CDATA #IMPLIED
 +                 gettext-domain CDATA #IMPLIED
 +                 extends        CDATA #IMPLIED
 +                 list-of        CDATA #IMPLIED >
++
 +<!-- enumerated and flags types -->
 +<!-- each value element maps a nick to a numeric value -->
 +<!ELEMENT enum (value*) >
 +<!ATTLIST enum id CDATA #REQUIRED >
++
 +<!ELEMENT flags (value*) >
 +<!ATTLIST flags id CDATA #REQUIRED >
++
 +<!ELEMENT value EMPTY >
 +<!-- nick must be at least 2 characters long -->
 +<!-- value must be parsable as a 32-bit integer -->
 +<!ATTLIST value nick  CDATA #REQUIRED
 +                value CDATA #REQUIRED >
++
 +<!ELEMENT key (default|summary?|description?|range?|choices?|aliases?)* >
 +<!-- name can only contain lowercase letters, numbers and '-' -->
 +<!-- type must be a GVariant type string -->
 +<!-- enum must be the id of an enum type that has been defined earlier -->
 +<!-- flags must be the id of a flags type that has been defined earlier -->
 +<!-- exactly one of type, enum or flags must be given -->
 +<!ATTLIST key name  CDATA #REQUIRED
 +              type  CDATA #IMPLIED
 +              enum  CDATA #IMPLIED
 +              flags CDATA #IMPLIED >
++
 +<!-- the default value is specified as a serialized GVariant,
 +     i.e. you have to include the quotes when specifying a string -->
 +<!ELEMENT default (#PCDATA) >
 +<!-- the presence of the l10n attribute marks a default value for
 +     translation, its value is the gettext category to use -->
 +<!-- if context is present, it specifies msgctxt to use -->
 +<!ATTLIST default l10n    (messages|time) #IMPLIED
 +                  context CDATA           #IMPLIED >
++
 +<!ELEMENT summary (#PCDATA) >
 +<!ELEMENT description (#PCDATA) >
++
 +<!-- range is only allowed for keys with numeric type -->
 +<!ELEMENT range EMPTY >
 +<!-- min and max must be parseable as values of the key type and
 +     min must be less than or equal to max -->
 +<!ATTLIST range min CDATA #IMPLIED
 +                max CDATA #IMPLIED >
++
 +<!-- choices is only allowed for keys with string or string array type -->
 +<!ELEMENT choices (choice+) >
 +<!-- each choice element specifies one possible value -->
 +<!ELEMENT choice EMPTY >
 +<!ATTLIST choice value CDATA #REQUIRED >
++
 +<!-- aliases is only allowed for keys with enumerated type or with choices -->
 +<!ELEMENT aliases (alias+) >
 +<!-- each alias element specifies an alias for one of the possible values -->
 +<!ELEMENT alias EMPTY >
 +<!ATTLIST alias value  CDATA #REQUIRED
 +                target CDATA #REQUIRED >
++
 +<!ELEMENT child EMPTY >
 +<!ATTLIST child name   CDATA #REQUIRED
 +                schema CDATA #REQUIRED >
++
 +<!ELEMENT override (#PCDATA) >
 +<!ATTLIST override name    CDATA #REQUIRED
 +                   l10n    CDATA #IMPLIED
 +                   context CDATA #IMPLIED >

Sniffly.app/Contents/Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.FileChooser.gschema.xmladded

 +<?xml version="1.0" encoding="UTF-8"?>
 +<!--
 +  Copyright © 2010 Christian Persch
++
 +  This library is free software; you can redistribute it and/or modify
 +  it under the terms of the GNU Lesser General Public License as published by
 +  the Free Software Foundation; either version 2.1, or (at your option)
 +  any later version.
++
 +  This library is distributed in the hope that it will be useful,
 +  but WITHOUT ANY WARRANTY; without even the implied warranty of
 +  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +  GNU Lesser General Public License for more details.
++
 +  You should have received a copy of the GNU Lesser General Public License
 +  along with this library. If not, see <http://www.gnu.org/licenses/>.
 +-->
 +<schemalist>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.LocationMode'>
 +    <value nick='path-bar' value='0'/>
 +    <value nick='filename-entry' value='1'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.SortColumn'>
 +    <value nick='name' value='0'/>
 +    <value nick='size' value='1'/>
 +    <value nick='type' value='2'/>
 +    <value nick='modified' value='3'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.SortOrder'>
 +    <value nick='ascending' value='0'/>
 +    <value nick='descending' value='1'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.StartupMode'>
 +    <value nick='recent' value='0'/>
 +    <value nick='cwd' value='1'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.ClockFormat'>
 +    <value nick='24h' value='0'/>
 +    <value nick='12h' value='1'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.DateFormat'>
 +    <value nick='regular' value='0'/>
 +    <value nick='with-time' value='1'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.TypeFormat'>
 +    <value nick='mime' value='0'/>
 +    <value nick='description' value='1'/>
 +    <value nick='category' value='2'/>
 +  </enum>
++
 +  <enum id='org.gtk.gtk4.Settings.FileChooser.ViewType'>
 +    <value nick='list' value='0'/>
 +    <value nick='grid' value='1'/>
 +  </enum>
++
 +  <schema id='org.gtk.gtk4.Settings.FileChooser' path='/org/gtk/gtk4/settings/file-chooser/'>
 +    <key name='location-mode' enum='org.gtk.gtk4.Settings.FileChooser.LocationMode'>
 +      <default>'path-bar'</default>
 +      <summary>Location mode</summary>
 +      <description>
 +	Controls whether the file chooser shows just a path bar, or a visible entry
 +        for the filename as well, for the benefit of typing-oriented users. The
 +        possible values for these modes are "path-bar" and "filename-entry".
 +      </description>
 +    </key>
 +    <key name='show-hidden' type='b'>
 +      <default>false</default>
 +      <summary>Show hidden files</summary>
 +      <description>
 +	Controls whether the file chooser shows hidden files or not.
 +      </description>
 +    </key>
 +    <key type="b" name="sort-directories-first">
 +      <default>true</default>
 +      <summary>Show folders first</summary>
 +      <description>
 +        If set to true, then folders are shown before files in the list.
 +      </description>
 +    </key>
 +    <key name='expand-folders' type='b'>
 +      <default>false</default>
 +      <summary>Expand folders</summary>
 +      <description>This key is deprecated; do not use it.</description>
 +    </key>
 +    <key name='show-size-column' type='b'>
 +      <default>true</default>
 +      <summary>Show file sizes</summary>
 +      <description>
 +	Controls whether the file chooser shows a column with file sizes.
 +      </description>
 +    </key>
 +    <key name='show-type-column' type='b'>
 +      <default>true</default>
 +      <summary>Show file types</summary>
 +      <description>
 +	Controls whether the file chooser shows a column with file types.
 +      </description>
 +    </key>
 +    <key name='sort-column' enum='org.gtk.gtk4.Settings.FileChooser.SortColumn'>
 +      <default>'name'</default>
 +      <summary>Sort column</summary>
 +      <description>
 +	Can be one of "name", "modified", or "size".  It controls
 +	which of the columns in the file chooser is used for sorting
 +	the list of files.
 +      </description>
 +    </key>
 +    <key name='sort-order' enum='org.gtk.gtk4.Settings.FileChooser.SortOrder'>
 +      <default>'ascending'</default>
 +      <summary>Sort order</summary>
 +      <description>
 +	Can be one of the strings "ascending" or "descending".
 +      </description>
 +    </key>
 +    <key name='window-position' type='(ii)'>
 +      <default>(-1, -1)</default>
 +      <summary>Window position</summary>
 +      <description>
 +        This key is ignored.
 +      </description>
 +    </key>
 +    <key name='window-size' type='(ii)'>
 +      <default>(-1, -1)</default>
 +      <summary>Window size</summary>
 +      <description>
 +	The size (width, height) of the GtkFileChooserDialog's window, in pixels.
 +      </description>
 +    </key>
 +    <key name='startup-mode' enum='org.gtk.gtk4.Settings.FileChooser.StartupMode'>
 +      <default>'recent'</default>
 +      <summary>Startup mode</summary>
 +      <description>
 +	Either "recent" or "cwd"; controls whether the file chooser
 +	starts up showing the list of recently-used files, or the
 +	contents of the current working directory.
 +      </description>
 +    </key>
 +    <key name='sidebar-width' type='i'>
 +      <default>-1</default>
 +      <summary>Sidebar width</summary>
 +      <description>
 +	Width in pixels of the file chooser's places sidebar.
 +      </description>
 +    </key>
 +    <key name="clock-format" enum="org.gtk.gtk4.Settings.FileChooser.ClockFormat">
 +      <default>'24h'</default>
 +      <summary>Time format</summary>
 +      <description>
 +        Whether the time is shown in 24h or 12h format.
 +      </description>
 +    </key>
 +    <key name="date-format" enum="org.gtk.gtk4.Settings.FileChooser.DateFormat">
 +      <default>'regular'</default>
 +      <summary>Date format</summary>
 +      <description>
 +        The amount of detail to show in the Modified column.
 +      </description>
 +    </key>
 +    <key name="type-format" enum="org.gtk.gtk4.Settings.FileChooser.TypeFormat">
 +      <default>'category'</default>
 +      <summary>Type format</summary>
 +      <description>
 +        Different ways to show the 'Type' column information.
 +        Example outputs for a video mp4 file:
 +        'mime' -> 'video/mp4'
 +        'description' -> 'MPEG-4 video'
 +        'category' -> 'Video'
 +      </description>
 +    </key>
 +    <key name="view-type" enum="org.gtk.gtk4.Settings.FileChooser.ViewType">
 +      <default>'list'</default>
 +      <summary>View type</summary>
 +      <description>
 +        Whether the files are shown in a list or in a grid.
 +      </description>
 +    </key>
 +  </schema>
++
 +</schemalist>

Sniffly.app/Contents/Resources/share/gtk-4.0/gtk4builder.rngadded

 +<?xml version="1.0"?>
 +<grammar xmlns="http://relaxng.org/ns/structure/1.0" ns="">
 +  <start>
 +    <element name="interface">
 +      <optional>
 +        <attribute name="domain">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="requires"/>
 +          <ref name="object"/>
 +          <ref name="template"/>
 +          <ref name="menu"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </start>
 +  <define name="requires">
 +    <element name="requires">
 +      <attribute name="lib">
 +        <text/>
 +      </attribute>
 +      <attribute name="version">
 +        <text/>
 +      </attribute>
 +    </element>
 +  </define>
 +  <define name="object">
 +    <element name="object">
 +      <optional>
 +        <attribute name="id">
 +          <data type="ID" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
 +        </attribute>
 +      </optional>
 +      <attribute name="class">
 +        <text/>
 +      </attribute>
 +      <optional>
 +        <attribute name="type-func">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="constructor">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="property"/>
 +          <ref name="signal"/>
 +          <ref name="child"/>
 +          <ref name="constraints"/>
 +          <ref name="ANY"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="template">
 +    <element name="template">
 +      <attribute name="class">
 +        <text/>
 +      </attribute>
 +      <attribute name="parent">
 +        <text/>
 +      </attribute>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="property"/>
 +          <ref name="signal"/>
 +          <ref name="child"/>
 +          <ref name="ANY"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="property">
 +    <element name="property">
 +      <attribute name="name">
 +        <text/>
 +      </attribute>
 +      <optional>
 +        <attribute name="translatable">
 +          <choice>
 +            <value>yes</value>
 +            <value>no</value>
 +          </choice>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="comments">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="context">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <group>
 +          <attribute name="bind-source">
 +            <text/>
 +          </attribute>
 +          <optional>
 +            <attribute name="bind-property">
 +              <text/>
 +            </attribute>
 +          </optional>
 +          <optional>
 +            <attribute name="bind-flags">
 +              <text/>
 +            </attribute>
 +          </optional>
 +        </group>
 +      </optional>
 +      <choice>
 +        <text/>
 +        <ref name="object"/>
 +        <ref name="constant"/>
 +        <ref name="lookup"/>
 +        <ref name="closure"/>
 +        <ref name="menu"/>
 +      </choice>
 +    </element>
 +  </define>
 +  <define name="signal">
 +    <element name="signal">
 +      <attribute name="name">
 +        <text/>
 +      </attribute>
 +      <attribute name="handler">
 +        <text/>
 +      </attribute>
 +      <optional>
 +        <attribute name="after">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="swapped">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="object">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="last_modification_time">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <empty/>
 +    </element>
 +  </define>
 +  <define name="child">
 +    <element name="child">
 +      <optional>
 +        <attribute name="type">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="internal-child">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="object"/>
 +          <ref name="ANY"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="menu">
 +    <element name="menu">
 +      <optional>
 +        <attribute name="id">
 +          <data type="ID" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="domain">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="item"/>
 +          <ref name="submenu"/>
 +          <ref name="section"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="item">
 +    <element name="item">
 +      <optional>
 +        <attribute name="id">
 +          <data type="ID" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="attribute_"/>
 +          <ref name="link"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="attribute_">
 +    <element name="attribute">
 +      <attribute name="name">
 +        <text/>
 +      </attribute>
 +      <optional>
 +        <attribute name="type">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="translatable">
 +          <choice>
 +            <value>yes</value>
 +            <value>no</value>
 +          </choice>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="context">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="comments">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <text/>
 +      </optional>
 +    </element>
 +  </define>
 +  <define name="link">
 +    <element name="link">
 +      <optional>
 +        <attribute name="id">
 +          <data type="ID" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
 +        </attribute>
 +      </optional>
 +      <attribute name="name">
 +        <text/>
 +      </attribute>
 +      <zeroOrMore>
 +        <ref name="item"/>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="submenu">
 +    <element name="submenu">
 +      <optional>
 +        <attribute name="id">
 +          <data type="ID" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="attribute_"/>
 +          <ref name="item"/>
 +          <ref name="submenu"/>
 +          <ref name="section"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="section">
 +    <element name="section">
 +      <optional>
 +        <attribute name="id">
 +          <data type="ID" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes"/>
 +        </attribute>
 +      </optional>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="attribute_"/>
 +          <ref name="item"/>
 +          <ref name="submenu"/>
 +          <ref name="section"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="ANY">
 +    <element>
 +      <anyName>
 +        <except>
 +          <name>interface</name>
 +          <name>requires</name>
 +          <name>object</name>
 +          <name>property</name>
 +          <name>signal</name>
 +          <name>child</name>
 +          <name>menu</name>
 +          <name>item</name>
 +          <name>attribute</name>
 +          <name>link</name>
 +          <name>submenu</name>
 +          <name>section</name>
 +          <name>lookup</name>
 +          <name>closure</name>
 +          <name>constant</name>
 +          <name>constraint</name>
 +          <name>guide</name>
 +        </except>
 +      </anyName>
 +      <zeroOrMore>
 +        <attribute>
 +          <anyName/>
 +          <text/>
 +        </attribute>
 +      </zeroOrMore>
 +      <interleave>
 +        <zeroOrMore>
 +          <ref name="ALL"/>
 +        </zeroOrMore>
 +        <optional>
 +          <text/>
 +        </optional>
 +      </interleave>
 +    </element>
 +  </define>
 +  <define name="ALL">
 +    <element>
 +      <anyName/>
 +      <zeroOrMore>
 +        <attribute>
 +          <anyName/>
 +          <text/>
 +        </attribute>
 +      </zeroOrMore>
 +      <interleave>
 +        <zeroOrMore>
 +          <ref name="ALL"/>
 +        </zeroOrMore>
 +        <optional>
 +          <text/>
 +        </optional>
 +      </interleave>
 +    </element>
 +  </define>
 +  <define name="constant">
 +    <element name="constant">
 +      <attribute name="type">
 +        <text/>
 +      </attribute>
 +      <optional>
 +        <attribute name="translatable">
 +          <choice>
 +            <value>yes</value>
 +            <value>no</value>
 +          </choice>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="context">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="comments">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <text/>
 +      </optional>
 +    </element>
 +  </define>
 +  <define name="lookup">
 +    <element name="lookup">
 +      <optional>
 +        <attribute name="name">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="type">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <choice>
 +        <text/>
 +        <ref name="constant"/>
 +      </choice>
 +    </element>
 +  </define>
 +  <define name="closure">
 +    <element name="closure">
 +      <attribute name="type">
 +        <text/>
 +      </attribute>
 +      <attribute name="function">
 +        <text/>
 +      </attribute>
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="constant"/>
 +          <ref name="lookup"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +  <define name="guide">
 +    <element name="guide">
 +      <optional>
 +        <attribute name="name">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="min-width">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="min-height">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="nat-width">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="nat-height">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="max-width">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="max-height">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="strength">
 +          <text/>
 +        </attribute>
 +      </optional>
 +    </element>
 +  </define>
 +  <define name="constraint">
 +    <element name="constraint">
 +      <attribute name="target">
 +        <text/>
 +      </attribute>
 +      <attribute name="target-attribute">
 +        <text/>
 +      </attribute>
 +      <optional>
 +        <group>
 +          <attribute name="source">
 +            <text/>
 +          </attribute>
 +          <attribute name="source-attribute">
 +            <text/>
 +          </attribute>
 +        </group>
 +      </optional>
 +      <optional>
 +        <attribute name="relation">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="constant">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="multiplier">
 +          <text/>
 +        </attribute>
 +      </optional>
 +      <optional>
 +        <attribute name="strength">
 +          <text/>
 +        </attribute>
 +      </optional>
 +    </element>
 +  </define>
 +  <define name="constraints">
 +    <element name="constraints">
 +      <zeroOrMore>
 +        <choice>
 +          <ref name="guide"/>
 +          <ref name="constraint"/>
 +        </choice>
 +      </zeroOrMore>
 +    </element>
 +  </define>
 +</grammar>

Sniffly.app/Contents/Resources/share/gtk-4.0/valgrind/gtk.suppadded

 +# Actual GTK things
 +{
 +  GtkWidgetClass action GPtrArray
 +  Memcheck:Leak
 +  fun:malloc
 +  fun:g_malloc
 +  fun:g_slice_alloc
 +  fun:g_ptr_array_sized_new
 +  fun:g_ptr_array_new
 +  fun:gtk_widget_class_add_action
 +}
++
 +{
 +   GIO modules
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:calloc
 +   ...
 +   fun:_g_io_module_get_default
 +}
++
 +{
 +   GTK media extension gio modules
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:calloc
 +   ...
 +   fun:g_io_module_new
 +   ...
 +   fun:gtk_media_file_extension_init
 +}
++
 +# AMD driver
 +{
 +  radeonsi_dri general
 +  Memcheck:Leak
 +  fun:calloc
 +  ...
 +  obj:/usr/lib*/dri/radeonsi_dri.so
 +}
 +{
 +  radeonsi_dri general
 +  Memcheck:Leak
 +  fun:malloc
 +  ...
 +  obj:/usr/lib*/dri/radeonsi_dri.so
 +}
++
 +# mesa driver stuff
 +{
 +   i965 addr4
 +   Memcheck:Addr4
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   i965 addr8
 +   Memcheck:Addr8
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   i965 memcpy
 +   Memcheck:Addr8
 +   fun:memcpy*
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   i965 memcpy
 +   Memcheck:Addr2
 +   fun:memcpy*
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   mesa memcmp 8
 +   Memcheck:Addr8
 +   fun:*memcmp*
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   mesa memcmp 1
 +   Memcheck:Addr1
 +   fun:*memcmp*
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   mesa memset 8
 +   Memcheck:Addr8
 +   fun:*memset*
 +   obj:/usr/lib*/dri/i965_dri.so
 +}
++
 +{
 +   mesa realpath
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:malloc
 +   fun:realpath@@GLIBC_2.3
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   fun:epoxy_eglInitialize_global_rewrite_ptr
 +}
++
 +{
 +   mesa calloc
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:calloc
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   fun:epoxy_eglInitialize_global_rewrite_ptr
 +}
++
 +{
 +   epoxy strncmp
 +   Memcheck:Addr8
 +   fun:strncmp
 +   ...
 +   fun:epoxy_eglInitialize_global_rewrite_ptr
 +}
++
 +{
 +   mesa malloc
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:malloc
 +   obj:/usr/lib*/dri/i965_dri.so*
 +}
++
 +{
 +   mesa glReadPixels
 +   Memcheck:Addr16
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   fun:epoxy_glReadPixels_global_rewrite_ptr
 +}
++
 +{
 +   epoxy glxQueryServerString 1
 +   Memcheck:Leak
 +   fun:malloc
 +   fun:XextAddDisplay
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   fun:epoxy_glXQueryServerString_global_rewrite_ptr
++
 +}
++
 +{
 +   epoxy glxQueryServerString 2
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:malloc
 +   fun:realpath*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   fun:epoxy_glXQueryServerString_global_rewrite_ptr
 +}
++
 +{
 +   epoxy glGetTexImage
 +   Memcheck:Addr16
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   obj:*
 +   fun:epoxy_glGetTexImage_global_rewrite_ptr
 +}
++
++
++
++
 +# Fontconfig
 +{
 +   FcFontSetList
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:malloc
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libfontconfig.so*
 +   fun:FcFontSetList
 +}
++
 +{
 +   FcPatternObjectInsertElt
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:malloc
 +   fun:FcPatternObjectInsertElt
 +}
++
 +{
 +   FcPatternObjectInsertElt2
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:realloc
 +   fun:FcPatternObjectInsertElt
 +}
++
 +{
 +   FcFontRenderPrepare
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:realloc
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libfontconfig.so*
 +   fun:FcFontRenderPrepare
 +}
++
 +{
 +   FcDefaultSubstitute
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:realloc
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libfontconfig.so*
 +   fun:FcDefaultSubstitute
 +}
++
 +{
 +   FcDefaultSubstituteWithPat
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:realloc
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libfontconfig.so*
 +   fun:FcDefaultSubstituteWithPat
 +}
++
 +{
 +   FcConfigSubstituteWithPat
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:realloc
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libfontconfig.so*
 +   fun:FcConfigSubstituteWithPat
 +}
++
 +# Pixman
 +{
 +   pixman_image_composite32
 +   Memcheck:Cond
 +   obj:/usr/lib*/libpixman-1.so*
 +   obj:/usr/lib*/libpixman-1.so*
 +   fun:pixman_image_composite32
 +}
++
 +# Pango
 +{
 +   pango 1
 +   Memcheck:Leak
 +   match-leak-kinds: definite
 +   fun:realloc
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libfontconfig.so*
 +   obj:/usr/lib*/libcairo.so*
 +   fun:pango_cairo_fc_font_map_fontset_key_substitute
 +}
++
 +{
 +  pango 2
 +  Memcheck:Leak
 +  fun:realloc
 +  obj:/usr/lib*/libfontconfig.so*
 +  obj:/usr/lib*/libfontconfig.so*
 +  fun:_cairo_ft_font_options_substitute
 +}
++
 +# GLib
 +{
 +  glib GQuark
 +  Memcheck:Leak
 +  match-leak-kinds: definite
 +  fun:malloc
 +  ...
 +  fun:g_quark_*
 +}
 +{
 +  glib GQuark
 +  Memcheck:Leak
 +  match-leak-kinds: definite
 +  fun:malloc
 +  ...
 +  fun:g_intern_static_string
 +}
 +{
 +  glib GQuark
 +  Memcheck:Leak
 +  match-leak-kinds: definite
 +  fun:malloc
 +  ...
 +  fun:g_intern_string
 +}
 +{
 +  xdg-mime init
 +  Memcheck:Leak
 +  match-leak-kinds: definite
 +  fun:malloc
 +  ...
 +  fun:xdg_mime_init*
 +}
 +{
 +  xdg-mime init
 +  Memcheck:Leak
 +  match-leak-kinds: definite
 +  fun:calloc
 +  ...
 +  fun:xdg_mime_init*
 +}
 +{
 +  glib init
 +  Memcheck:Leak
 +  match-leak-kinds: definite
 +  fun:malloc
 +  ...
 +  fun:glib_init_ctor
 +}
++
 +# Threads
 +{
 +   pthread
 +   Memcheck:Leak
 +   fun:calloc
 +   fun:_dl_allocate_tls
 +}

Sniffly.app/Contents/_CodeSignature/CodeDirectoryadded

Binary file changed.

Sniffly.app/Contents/_CodeSignature/CodeRequirementsadded

Binary file changed.

Sniffly.app/Contents/_CodeSignature/CodeRequirements-1added

Binary file changed.

Sniffly.app/Contents/_CodeSignature/CodeResourcesadded

 +<?xml version="1.0" encoding="UTF-8"?>
 +<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 +<plist version="1.0">
 +<dict>
 +	<key>files</key>
 +	<dict>
 +		<key>Resources/share/glib-2.0/schemas/gschema.dtd</key>
 +		<data>
 +		BY2rQNdph/3FfTHf7nnlVZ+U2/0=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/gschemas.compiled</key>
 +		<data>
 +		PUbZavbyH7VUpsQKezAGbofeWEo=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.Demo4.gschema.xml</key>
 +		<data>
 +		iFjAPaAxzf6zp4IKKXUsaS2Wi8g=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Inspector.gschema.xml</key>
 +		<data>
 +		jgzjvDTQrcwV4hrD/HgQ+N4AFhM=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.ColorChooser.gschema.xml</key>
 +		<data>
 +		/iNWMcJOzPva8L3ulwQ6HwtRgXM=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.Debug.gschema.xml</key>
 +		<data>
 +		qL7MxCdaSI3mj4iLFTPn1m7nrrw=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.EmojiChooser.gschema.xml</key>
 +		<data>
 +		PJHFmo5OoI3zUvKllylBp0gALEE=
 +		</data>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.FileChooser.gschema.xml</key>
 +		<data>
 +		U9fKvSUl9DJ/cEdecFSvzRxA16M=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/bn.gresource</key>
 +		<data>
 +		Tt0UUyhxmAqGPDQhIghAnO1//cE=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/da.gresource</key>
 +		<data>
 +		qofpYMTzCx5rurhSCQ49Eq/gQd4=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/de.gresource</key>
 +		<data>
 +		UiZSMGYJhJI45AzwpH2uNu0I19M=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/es.gresource</key>
 +		<data>
 +		b4UyvR+WYMy2I1vuC9+0cH46cj8=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/et.gresource</key>
 +		<data>
 +		bhg3hLjbjGntSbc6hpUGyIJBIxc=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/fi.gresource</key>
 +		<data>
 +		jlJsJG7RP0tZypyLFafqVgSUsUc=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/fr.gresource</key>
 +		<data>
 +		eTI1ovErYI/kFxgga0MlceFwxAY=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/hi.gresource</key>
 +		<data>
 +		I3Ur/v5aarS3QPeCQkOPobCq8t4=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/hu.gresource</key>
 +		<data>
 +		xlwpk+cy3V7DReSYDiXPb7WIatk=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/it.gresource</key>
 +		<data>
 +		nwlNj5cx3HGmPLlEIoZch9538ZQ=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/ja.gresource</key>
 +		<data>
 +		cvOWCi+1srwn1yX8CAuDqO4wI0o=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/ko.gresource</key>
 +		<data>
 +		bKjuMyXqmqLWm+A6RQCmmoJe3jA=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/lt.gresource</key>
 +		<data>
 +		LMQx/lMs3iwIKzc1w4CfuueNjEA=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/ms.gresource</key>
 +		<data>
 +		X3/AN4eWGYG/dq4w8SExYqTwG70=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/nb.gresource</key>
 +		<data>
 +		FyeaCXibNgtT4H2/v94AqcN4P9Q=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/nl.gresource</key>
 +		<data>
 +		1JRe4GqcXqPIz0elmFY6sgvKcxU=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/pl.gresource</key>
 +		<data>
 +		pUi/VXwKnYDW6vW1XFDYpbcDPM8=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/pt.gresource</key>
 +		<data>
 +		++WVXFGgVBcz+mw2tAW3jlQnRTI=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/ru.gresource</key>
 +		<data>
 +		20h8jXi2Xl/CpqDgSDFvFW4tgW8=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/sv.gresource</key>
 +		<data>
 +		ZIgYlHeEl4zkH9DZ0tTFAV7fZCY=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/th.gresource</key>
 +		<data>
 +		XOao2Fz+KGA62HJPY1Zz6TrQQPg=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/uk.gresource</key>
 +		<data>
 +		f5mTp7g47Tu5E6uxfb/Hje+aoYE=
 +		</data>
 +		<key>Resources/share/gtk-4.0/emoji/zh.gresource</key>
 +		<data>
 +		acEBrz5jBFRfrrlMYH7TY2Dt5CY=
 +		</data>
 +		<key>Resources/share/gtk-4.0/gtk4builder.rng</key>
 +		<data>
 +		X93vrJ9nzUWc1PDsKhmRjfy5Q+U=
 +		</data>
 +		<key>Resources/share/gtk-4.0/valgrind/gtk.supp</key>
 +		<data>
 +		6B5NUN/9YTSLoE1eHra2FDmNNGE=
 +		</data>
 +	</dict>
 +	<key>files2</key>
 +	<dict>
 +		<key>Frameworks/libX11.6.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			LDk33XspR4u404J+T7DLNfTb3eY=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"2c3937dd7b29478bb8d3827e4fb0cb35f4dbdde6"</string>
 +		</dict>
 +		<key>Frameworks/libXau.6.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			cjIEIGitnJwlg3b708q/xO4smu8=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"7232042068ad9c9c258376fbd3cabfc4ee2c9aef"</string>
 +		</dict>
 +		<key>Frameworks/libXdmcp.6.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			fC6ZM/p6a/1v9lnWViyake9hXCI=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"7c2e9933fa7a6bfd6ff659d6562c9a91ef615c22"</string>
 +		</dict>
 +		<key>Frameworks/libXext.6.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			s+K/hMmpwnzaid73d2mDsSawgTA=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"b3e2bf84c9a9c27cda89def7776983b126b08130"</string>
 +		</dict>
 +		<key>Frameworks/libXrender.1.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			Dfsx9zrg99RidETW6aelsbOnIac=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"0dfb31f73ae0f7d4627444d6e9a7a5b1b3a721a7"</string>
 +		</dict>
 +		<key>Frameworks/libcairo-gobject.2.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			Lud1tyfMNY5p8sBrvRPo4vtch2s=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"2ee775b727cc358e69f2c06bbd13e8e2fb5c876b"</string>
 +		</dict>
 +		<key>Frameworks/libcairo-script-interpreter.2.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			NnGzyt2knOrMH3OiJCQRd7NRFcY=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"3671b3cadda49ceacc1f73a224241177b35115c6"</string>
 +		</dict>
 +		<key>Frameworks/libcairo.2.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			ajyuORlwA5FrIeVuUdF2zje9eWk=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"6a3cae39197003916b21e56e51d176ce37bd7969"</string>
 +		</dict>
 +		<key>Frameworks/libepoxy.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			Vb243hjxI3niAZSQIm5nHHN+Jqc=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"55bdb8de18f12379e2019490226e671c737e26a7"</string>
 +		</dict>
 +		<key>Frameworks/libfontconfig.1.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			mzD8tFzWBMRiq81ySj96aMs1ldA=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"9b30fcb45cd604c462abcd724a3f7a68cb3595d0"</string>
 +		</dict>
 +		<key>Frameworks/libfreetype.6.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			g24zAEmY3DJEZBxV1ChACcAKQPk=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"836e33004998dc3244641c55d4284009c00a40f9"</string>
 +		</dict>
 +		<key>Frameworks/libfribidi.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			f6ZlTzrBxyLa+n3VP8n6TBsLbwc=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"7fa6654f3ac1c722dafa7dd53fc9fa4c1b0b6f07"</string>
 +		</dict>
 +		<key>Frameworks/libgcc_s.1.1.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			nvqjNDCOgKVNM1Zfbg4hWL7OgIk=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"9efaa334308e80a54d33565f6e0e2158bece8089"</string>
 +		</dict>
 +		<key>Frameworks/libgdk_pixbuf-2.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			28DT35Q8ktBkbgVuviLN2NVF8h0=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"dbc0d3df943c92d0646e056ebe22cdd8d545f21d"</string>
 +		</dict>
 +		<key>Frameworks/libgfortran.5.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			vYvxI7D4BYYyY0HTiQm49jFvRi8=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"bd8bf123b0f80586326341d38909b8f6316f462f"</string>
 +		</dict>
 +		<key>Frameworks/libgio-2.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			4+PNWv2Vs+BlZpRm2jYZQ9so/2Y=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"e3e3cd5afd95b3e065669466da361943db28ff66"</string>
 +		</dict>
 +		<key>Frameworks/libglib-2.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			gvtmKbsuTFiWMUI0GPHw+5u4mrI=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"82fb6629bb2e4c589631423418f1f0fb9bb89ab2"</string>
 +		</dict>
 +		<key>Frameworks/libgmodule-2.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			Db3TSMmuehqWC0G1VeUA0nJzxsA=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"0dbdd348c9ae7a1a960b41b555e500d27273c6c0"</string>
 +		</dict>
 +		<key>Frameworks/libgobject-2.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			tdvhcPsqx9b72kdQ8Ca3eQxpkCw=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"b5dbe170fb2ac7d6fbda4750f026b7790c69902c"</string>
 +		</dict>
 +		<key>Frameworks/libgraphene-1.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			elPyvwqxLjgjcg4IiIWOB2lsLrk=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"7a53f2bf0ab12e3823720e0888858e07696c2eb9"</string>
 +		</dict>
 +		<key>Frameworks/libgraphite2.3.2.1.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			NtiXuiz1iTnSZaAfC8RPkpuzpQU=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"36d897ba2cf58939d265a01f0bc44f929bb3a505"</string>
 +		</dict>
 +		<key>Frameworks/libgtk-4-fortran.4.8.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			amz8h9UTGS4xgQTDykG/Pki6w9Q=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"6a6cfc87d513192e318104c3ca41bf3e48bac3d4"</string>
 +		</dict>
 +		<key>Frameworks/libgtk-4.1.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			QXHOKwiHh7p6/RNEjnAgkrzXrnM=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"4171ce2b088787ba7afd13448e702092bcd7ae73"</string>
 +		</dict>
 +		<key>Frameworks/libharfbuzz-subset.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			sLBb5HwRxxun30tPhDx/T+ItFgc=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"b0b05be47c11c71ba7df4b4f843c7f4fe22d1607"</string>
 +		</dict>
 +		<key>Frameworks/libharfbuzz.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			i/2oLoVTp+pH+qTegSuDx8oiOTw=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"8bfda82e8553a7ea47faa4de812b83c7ca22393c"</string>
 +		</dict>
 +		<key>Frameworks/libintl.8.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			OCVnxvDVD+Ebh9UMuDT4L6V1vLs=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"382567c6f0d50fe11b87d50cb834f82fa575bcbb"</string>
 +		</dict>
 +		<key>Frameworks/libjpeg.8.3.2.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			FfZP819/6xNN4AkbFKA3NsCU8NI=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"15f64ff35f7feb134de0091b14a03736c094f0d2"</string>
 +		</dict>
 +		<key>Frameworks/liblzma.5.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			HQAsQ50CZpB3ERrZwtvb2tW5zsk=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"1d002c439d02669077111ad9c2dbdbdad5b9cec9"</string>
 +		</dict>
 +		<key>Frameworks/liblzo2.2.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			t610X2lzaQQ/2kuzYdmsNNM82hU=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"b7ad745f697369043fda4bb361d9ac34d33cda15"</string>
 +		</dict>
 +		<key>Frameworks/libpango-1.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			Hblim3CQFWq3Qy2/UcwkrNQnUT8=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"1db9629b7090156ab7432dbf51cc24acd427513f"</string>
 +		</dict>
 +		<key>Frameworks/libpangocairo-1.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			uiiEy4/uSlZZh7Kurqc3wNOaA8g=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"ba2884cb8fee4a565987b2aeaea737c0d39a03c8"</string>
 +		</dict>
 +		<key>Frameworks/libpangoft2-1.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			X1ee14eTcH7guRPlG55jZyrP2LI=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"5f579ed78793707ee0b913e51b9e63672acfd8b2"</string>
 +		</dict>
 +		<key>Frameworks/libpcre2-8.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			3kNOB6FIAWkm+mogHboGxoX492g=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"de434e07a148016926fa6a201dba06c685f8f768"</string>
 +		</dict>
 +		<key>Frameworks/libpixman-1.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			LQrlgNp2w3iL2XiMtvVjxASREIE=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"2d0ae580da76c3788bd9788cb6f563c404911081"</string>
 +		</dict>
 +		<key>Frameworks/libpng16.16.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			mnwXT27cjXdVla/g+vU6/LR2gSQ=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"9a7c174f6edc8d775595afe0faf53afcb4768124"</string>
 +		</dict>
 +		<key>Frameworks/libquadmath.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			dRya+3oAAimeq6uWbVMO/7pepl8=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"751c9afb7a0002299eabab966d530effba5ea65f"</string>
 +		</dict>
 +		<key>Frameworks/librsvg-2.2.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			NkaepcOr4QsGQj/lxCVXaGUJXqo=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"36469ea5c3abe10b06423fe5c425576865095eaa"</string>
 +		</dict>
 +		<key>Frameworks/libtiff.6.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			uQcfsNCEYplNkYRLvcqOehW9BJo=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"b9071fb0d08462994d91844bbdca8e7a15bd049a"</string>
 +		</dict>
 +		<key>Frameworks/libxcb-render.0.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			NrLL3e+vcac1VKAa+tiiZSIrI7A=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"36b2cbddefaf71a73554a01afad8a265222b23b0"</string>
 +		</dict>
 +		<key>Frameworks/libxcb-shm.0.0.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			ae8afTjwpR1ec8E0w2eMUklOouQ=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"69ef1a7d38f0a51d5e73c134c3678c52494ea2e4"</string>
 +		</dict>
 +		<key>Frameworks/libxcb.1.1.0.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			+k6hRFyDOmPsxtUgqpQJ9nPWvac=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"fa4ea1445c833a63ecc6d520aa9409f673d6bda7"</string>
 +		</dict>
 +		<key>Frameworks/libzstd.1.5.7.dylib</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			1uZ8qwWkT3qJgIo2u38UM5oWYDA=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"d6e67cab05a44f7a89808a36bb7f14339a166030"</string>
 +		</dict>
 +		<key>MacOS/sniffly-bin</key>
 +		<dict>
 +			<key>cdhash</key>
 +			<data>
 +			UnRkFSQSV/ohuGYufIEZd3ovoAU=
 +			</data>
 +			<key>requirement</key>
 +			<string>cdhash H"52746415241257fa21b8662e7c8119777a2fa005"</string>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/gschema.dtd</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			BY2rQNdph/3FfTHf7nnlVZ+U2/0=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			RKEvM5BCo/VWipzIa7YX+rr0olg2uMlRCqneIkMZMMY=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/gschemas.compiled</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			PUbZavbyH7VUpsQKezAGbofeWEo=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			6Fzs8WxqLP/mND0xgrewHAT6Mj/fzW0FJtkhIHkn48s=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.Demo4.gschema.xml</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			iFjAPaAxzf6zp4IKKXUsaS2Wi8g=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			aOHHxecsalK9xqeh7blQzlfmRoJOOeVasU8ocy4WS+Y=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Inspector.gschema.xml</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			jgzjvDTQrcwV4hrD/HgQ+N4AFhM=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			CnFkVsVv9qTzrR1ysiBbLpgqIxqVhsujK8fRvMk89Fo=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.ColorChooser.gschema.xml</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			/iNWMcJOzPva8L3ulwQ6HwtRgXM=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			PGCgIKyCOtnAI5TIV5KWcRoUj7bhXawcTf+jRwMDrzI=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.Debug.gschema.xml</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			qL7MxCdaSI3mj4iLFTPn1m7nrrw=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			8wk7AOkYShkonwdVNF40FJIar+FUMzQrNrMnreIEiZg=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.EmojiChooser.gschema.xml</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			PJHFmo5OoI3zUvKllylBp0gALEE=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			iTsmBWnoMruWv6X/lYk/hdgVQwaXmfIr9m3UGa1QpwI=
 +			</data>
 +		</dict>
 +		<key>Resources/share/glib-2.0/schemas/org.gtk.gtk4.Settings.FileChooser.gschema.xml</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			U9fKvSUl9DJ/cEdecFSvzRxA16M=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			56dIL3k3oFiJYWE98rFOUJsIwSgb2wsSqyeYVtfY/Oo=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/bn.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			Tt0UUyhxmAqGPDQhIghAnO1//cE=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			eVCtdtJdwWHuwPvMRr8ymM5dcWPgxNGXaqkY1T3PjVs=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/da.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			qofpYMTzCx5rurhSCQ49Eq/gQd4=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			e7wK1U9wYuMzYVqvl8yIKS68cnjKV/itZpgwOQC6K2k=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/de.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			UiZSMGYJhJI45AzwpH2uNu0I19M=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			SiT2BW+MaH9dn/fiwakcBlc+PkEPt+Ri3tPQOkADpFQ=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/es.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			b4UyvR+WYMy2I1vuC9+0cH46cj8=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			3imS6uyMeTfGIP4/M9mVTupvlL7+0eUqTe0WiLo10a8=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/et.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			bhg3hLjbjGntSbc6hpUGyIJBIxc=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			aFJrcw8R95AMI15xDh69RS4duL0ZdPDgyGcDE0qFVoE=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/fi.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			jlJsJG7RP0tZypyLFafqVgSUsUc=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			qHJFplneMnFm9d5bVbG9d+upcSoU0SwnT+loluAFZOc=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/fr.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			eTI1ovErYI/kFxgga0MlceFwxAY=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			WB5hhy485ylC1HQXRXHpUbj3bNj97nF+aSxOLPwMFm0=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/hi.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			I3Ur/v5aarS3QPeCQkOPobCq8t4=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			4MNL6PLEDrRhUp0Ad08PkzEneUjuj3pnklcag2cu5lQ=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/hu.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			xlwpk+cy3V7DReSYDiXPb7WIatk=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			wGpSXfPARQkHd0FziRluM5e+dPOn08AxosV9yKLP5aE=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/it.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			nwlNj5cx3HGmPLlEIoZch9538ZQ=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			id9nXjNvF+gQG6etlz1mAbdqDjYJ3XvMjNeJ2KQ6lGE=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/ja.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			cvOWCi+1srwn1yX8CAuDqO4wI0o=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			YP+KgJdlz+D9V7T/sUwwERdWGC1BY3LdeN0vsGhu+ZE=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/ko.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			bKjuMyXqmqLWm+A6RQCmmoJe3jA=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			YnbYZkhmCri/4IaslHCnTUVj5wxjanKyUMqwZIwrtco=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/lt.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			LMQx/lMs3iwIKzc1w4CfuueNjEA=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			mLFpHPxoG7PdDbjMPNWerDKTrMd2tRjSp+oHDxs5C3M=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/ms.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			X3/AN4eWGYG/dq4w8SExYqTwG70=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			WO+oNp2J+0MiNS2qEMVY3XtSGnTtsybmDe3ILHIT8Ls=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/nb.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			FyeaCXibNgtT4H2/v94AqcN4P9Q=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			h/l3JQk5DFuOWnDryYZjNJNN/e9LtLkFecA01wLH9/I=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/nl.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			1JRe4GqcXqPIz0elmFY6sgvKcxU=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			cM714QsReGOYu2Om3Oohzjhi5bn68A+8/j/MutaGQdw=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/pl.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			pUi/VXwKnYDW6vW1XFDYpbcDPM8=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			TG3SiVmFRu0OMYuneTqPGOfBd/ytsdnXJLVyZTqyMFc=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/pt.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			++WVXFGgVBcz+mw2tAW3jlQnRTI=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			Ne4kJw5Ttd7KhPPalVEDc+z1qOXdaUF/I5Qth9TtOo8=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/ru.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			20h8jXi2Xl/CpqDgSDFvFW4tgW8=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			tIajLQZv1OGyuu+87wxf7/bgAQpI6f51T5Ikaz6lyIk=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/sv.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			ZIgYlHeEl4zkH9DZ0tTFAV7fZCY=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			b3jgoHgKCA0QOdsSrrZ7ePZ3n3ZMYGROlilGU269a5Q=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/th.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			XOao2Fz+KGA62HJPY1Zz6TrQQPg=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			swvnsTHEFso3hO7RNl0Q82P49anNjcjLWZ6BTwX2/4I=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/uk.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			f5mTp7g47Tu5E6uxfb/Hje+aoYE=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			0rzLvDsqBLat/HtRD6bq0CzolVd/XcCNjARnKt8mbUY=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/emoji/zh.gresource</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			acEBrz5jBFRfrrlMYH7TY2Dt5CY=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			zw6veg/zYZ0niQBOCUWPWVjCnq3Voqu588iPt0Cdz1A=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/gtk4builder.rng</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			X93vrJ9nzUWc1PDsKhmRjfy5Q+U=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			wrrOUrTZshDzoqFV6g+m32Gp1wFQ7Q+C31tCYNGRzXI=
 +			</data>
 +		</dict>
 +		<key>Resources/share/gtk-4.0/valgrind/gtk.supp</key>
 +		<dict>
 +			<key>hash</key>
 +			<data>
 +			6B5NUN/9YTSLoE1eHra2FDmNNGE=
 +			</data>
 +			<key>hash2</key>
 +			<data>
 +			bf5KnWpZJgMScRn7Gy9aQOgVYKbCDWuq+n6oo/w/FjQ=
 +			</data>
 +		</dict>
 +	</dict>
 +	<key>rules</key>
 +	<dict>
 +		<key>^Resources/</key>
 +		<true/>
 +		<key>^Resources/.*\.lproj/</key>
 +		<dict>
 +			<key>optional</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>1000</real>
 +		</dict>
 +		<key>^Resources/.*\.lproj/locversion.plist$</key>
 +		<dict>
 +			<key>omit</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>1100</real>
 +		</dict>
 +		<key>^Resources/Base\.lproj/</key>
 +		<dict>
 +			<key>weight</key>
 +			<real>1010</real>
 +		</dict>
 +		<key>^version.plist$</key>
 +		<true/>
 +	</dict>
 +	<key>rules2</key>
 +	<dict>
 +		<key>.*\.dSYM($|/)</key>
 +		<dict>
 +			<key>weight</key>
 +			<real>11</real>
 +		</dict>
 +		<key>^(.*/)?\.DS_Store$</key>
 +		<dict>
 +			<key>omit</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>2000</real>
 +		</dict>
 +		<key>^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/</key>
 +		<dict>
 +			<key>nested</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>10</real>
 +		</dict>
 +		<key>^.*</key>
 +		<true/>
 +		<key>^Info\.plist$</key>
 +		<dict>
 +			<key>omit</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>20</real>
 +		</dict>
 +		<key>^PkgInfo$</key>
 +		<dict>
 +			<key>omit</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>20</real>
 +		</dict>
 +		<key>^Resources/</key>
 +		<dict>
 +			<key>weight</key>
 +			<real>20</real>
 +		</dict>
 +		<key>^Resources/.*\.lproj/</key>
 +		<dict>
 +			<key>optional</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>1000</real>
 +		</dict>
 +		<key>^Resources/.*\.lproj/locversion.plist$</key>
 +		<dict>
 +			<key>omit</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>1100</real>
 +		</dict>
 +		<key>^Resources/Base\.lproj/</key>
 +		<dict>
 +			<key>weight</key>
 +			<real>1010</real>
 +		</dict>
 +		<key>^[^/]+$</key>
 +		<dict>
 +			<key>nested</key>
 +			<true/>
 +			<key>weight</key>
 +			<real>10</real>
 +		</dict>
 +		<key>^embedded\.provisionprofile$</key>
 +		<dict>
 +			<key>weight</key>
 +			<real>20</real>
 +		</dict>
 +		<key>^version\.plist$</key>
 +		<dict>
 +			<key>weight</key>
 +			<real>20</real>
 +		</dict>
 +	</dict>
 +</dict>
 +</plist>

Sniffly.app/Contents/_CodeSignature/CodeSignatureadded

TECHNICAL_STACK.mdadded

 +# Sniffly Technical Stack Deep Dive
++
 +## Core Stack Justification
++
 +### Why Pure Fortran?
++
 +**Philosophy:** Prove that Fortran can build modern GUI applications that rival commercial software written in C++/C#.
++
 +**Practical Advantages:**
 +1. **Performance:** Native compilation, no VM/interpreter overhead
 +2. **Memory Safety:** Strong typing, bounds checking (with compiler flags)
 +3. **Existing Code:** Leverage proven algorithms from sniffert
 +4. **Mathematical Operations:** Natural for size calculations, layout algorithms
 +5. **Array Operations:** Efficient bulk operations on file trees
++
 +**Challenges Addressed:**
 +- String handling: Use allocatable character arrays (Fortran 2003+)
 +- Pointers: Use Fortran's C interoperability for GTK callbacks
 +- OOP: Use Fortran 2008 type-bound procedures where beneficial
++
 +---
++
 +## GTK4 via gtk-fortran
++
 +### Why GTK4 (not Qt, wxWidgets, etc.)?
++
 +**Technical Reasons:**
 +1. **gtk-fortran exists:** Mature, maintained Fortran bindings
 +2. **Native on Linux:** GTK is the de facto standard
 +3. **macOS Support:** GTK4 uses native Cocoa backend
 +4. **Modern:** GTK4 is actively developed, not legacy
 +5. **Cairo Integration:** Built-in 2D drawing library
++
 +**Comparison to Alternatives:**
++
 +| Framework | Fortran Bindings | Native Look | Performance | Verdict |
 +|-----------|-----------------|-------------|-------------|---------|
 +| GTK4 | gtk-fortran | Yes (Linux/macOS) | Excellent | ✅ Chosen |
 +| Qt | None (would need C++ wrapper) | Yes | Excellent | ❌ No bindings |
 +| wxWidgets | None | Yes | Good | ❌ No bindings |
 +| FLTK | None | No | Excellent | ❌ No bindings, dated look |
 +| Tk | None (would need Tcl) | No | Poor | ❌ Dated, slow |
++
 +**gtk-fortran Maturity:**
 +- First release: 2011
 +- Current version: 3.24.41 (2024)
 +- Active maintainer: Vincent Magnin
 +- Production use: Scientific visualization tools
 +- Platform support: Linux, macOS, FreeBSD, Windows (MSYS2)
++
 +### GTK4 Architecture
++
 +```
 +┌─────────────────────────────────────────────────────────┐
 +│                    Your Fortran Code                     │
 +│                   (sniffly modules)                      │
 +└─────────────────────────────────────────────────────────┘
 +                           │
 +                           ↓ (iso_c_binding)
 +┌─────────────────────────────────────────────────────────┐
 +│                      gtk-fortran                         │
 +│        (Fortran interfaces to GTK C functions)           │
 +└─────────────────────────────────────────────────────────┘
 +                           │
 +                           ↓ (FFI)
 +┌─────────────────────────────────────────────────────────┐
 +│                    GTK4 C Library                        │
 +│  ┌─────────────┬──────────────┬────────────────────┐    │
 +│  │   Widgets   │    GDK       │      GSK           │    │
 +│  │  (buttons,  │  (events,    │  (GPU rendering)   │    │
 +│  │   windows)  │   input)     │                    │    │
 +│  └─────────────┴──────────────┴────────────────────┘    │
 +└─────────────────────────────────────────────────────────┘
 +                           │
 +                           ↓
 +┌─────────────────────────────────────────────────────────┐
 +│                    Platform Backend                      │
 +│   Linux: Wayland/X11    macOS: Cocoa    BSD: X11       │
 +└─────────────────────────────────────────────────────────┘
 +```
++
 +---
++
 +## Cairo for 2D Graphics
++
 +### Why Cairo?
++
 +**Technical Strengths:**
 +1. **Vector Graphics:** Resolution-independent rendering
 +2. **Anti-aliasing:** Beautiful, smooth edges
 +3. **Hardware Acceleration:** GPU-backed on modern systems
 +4. **Compositing:** Alpha blending, gradients, patterns
 +5. **Text Rendering:** Pango integration for complex text
++
 +**Cairo Features We'll Use:**
++
 +| Feature | Usage in Sniffly |
 +|---------|-----------------|
 +| `cairo_rectangle()` | Draw treemap rectangles |
 +| `cairo_fill()` | Fill rectangles with color |
 +| `cairo_stroke()` | Draw borders |
 +| `cairo_set_source_rgb()` | Set solid colors |
 +| `cairo_pattern_create_linear()` | Cushion gradients |
 +| `cairo_clip()` | Clip nested rectangles |
 +| `cairo_save()`/`restore()` | State management |
 +| Pango integration | Render file names |
++
 +**Performance Characteristics:**
 +- **Fast Paths:** Solid fills, axis-aligned rectangles
 +- **Slow Paths:** Bezier curves, complex paths (we won't use)
 +- **Caching:** Cairo surfaces can be cached
 +- **Expected Performance:** 60fps for 1000s of rectangles
++
 +### Cairo vs. OpenGL
++
 +We chose Cairo over OpenGL because:
 +- **Simpler API:** 2D-focused, easier to learn
 +- **Better Integration:** Built into GTK4
 +- **Text Rendering:** Pango support out of the box
 +- **Sufficient Performance:** 60fps achievable for our use case
++
 +If performance becomes an issue (unlikely), we can:
 +1. Use GTK4's GSK (GPU Scene Kit) backend
 +2. Batch render calls
 +3. Implement viewport culling (only draw visible nodes)
++
 +---
++
 +## Pango for Text
++
 +### Why Pango?
++
 +**Features:**
 +1. **Font Management:** System font detection, fallbacks
 +2. **Text Layout:** Ellipsization, wrapping, alignment
 +3. **Internationalization:** Full Unicode support, RTL text
 +4. **Integration:** Native Cairo rendering
++
 +**Pango Features We'll Use:**
++
 +```fortran
 +! Create Pango layout
 +layout = pango_cairo_create_layout(cairo_context)
++
 +! Set text
 +call pango_layout_set_text(layout, c_str("filename.txt"))
++
 +! Set font
 +font_desc = pango_font_description_from_string(c_str("Sans 10"))
 +call pango_layout_set_font_description(layout, font_desc)
++
 +! Set ellipsization for long text
 +call pango_layout_set_ellipsize(layout, PANGO_ELLIPSIZE_END)
 +call pango_layout_set_width(layout, width * PANGO_SCALE)
++
 +! Render
 +call pango_cairo_show_layout(cairo_context, layout)
 +```
++
 +---
++
 +## GLib for Core Utilities
++
 +### Threading
++
 +**GLib Threads** (not pthreads) for portability:
++
 +```fortran
 +! Start background scan thread
 +thread = g_thread_new(c_str("scanner"), c_funloc(scan_thread_func), c_loc(scan_data))
++
 +! Thread-safe UI updates from background thread
 +call g_idle_add(c_funloc(update_ui_callback), c_loc(progress_data))
 +```
++
 +**Why g_idle_add?**
 +- GTK is **not thread-safe**
 +- g_idle_add queues callback on main thread
 +- Callback runs in GTK event loop
 +- Safe to update UI from callback
++
 +### Event Loop
++
 +GTK's main loop handles:
 +- User input (mouse, keyboard)
 +- Window events (resize, close)
 +- Timers and idle callbacks
 +- Background task callbacks (g_idle_add)
++
 +```fortran
 +! Start GTK main loop (blocks until app quits)
 +call gtk_main()
 +```
++
 +### GLib Data Structures
++
 +We'll primarily use Fortran's native arrays, but GLib provides:
 +- `GList`/`GSList`: Linked lists (if needed for dynamic UI)
 +- `GHashTable`: Hash maps (for quick file lookup)
 +- `GString`: Dynamic strings (if Fortran strings insufficient)
++
 +---
++
 +## Build System: Meson
++
 +### Why Meson (not Make, CMake, FPM)?
++
 +**Meson Advantages:**
 +1. **GTK Standard:** All GTK projects use Meson
 +2. **Dependency Detection:** Auto-finds GTK, Cairo, etc. via pkg-config
 +3. **Fast:** Ninja backend, parallel builds
 +4. **Cross-Platform:** Works on Linux, macOS, BSD
 +5. **Clean Syntax:** Python-like, easy to read
++
 +**Meson vs. FPM:**
 +- FPM is great for pure Fortran projects
 +- FPM doesn't handle C library dependencies well
 +- We'll provide **both** Meson (primary) and FPM (fallback) builds
++
 +**Sample meson.build:**
++
 +```meson
 +project('sniffly', 'fortran',
 +  version: '1.0.0',
 +  default_options: ['warning_level=3'])
++
 +# Dependencies
 +gtk4_dep = dependency('gtk4')
 +cairo_dep = dependency('cairo')
 +pango_dep = dependency('pango')
++
 +# Source files
 +src = [
 +  'src/core/types.f90',
 +  'src/core/file_system.f90',
 +  'src/core/disk_scanner.f90',
 +  'src/layout/squarified.f90',
 +  'src/layout/cushioned.f90',
 +  'src/gui/gtk_app.f90',
 +  'src/rendering/cairo_renderer.f90',
 +  'app/main.f90',
 +]
++
 +# Executable
 +executable('sniffly', src,
 +  dependencies: [gtk4_dep, cairo_dep, pango_dep],
 +  install: true)
 +```
++
 +**Building:**
 +```bash
 +meson setup build
 +meson compile -C build
 +meson install -C build
 +```
++
 +---
++
 +## Development Tools
++
 +### Compiler
++
 +**gfortran 9.0+** (GCC Fortran compiler)
++
 +**Why gfortran?**
 +- Free and open source
 +- Excellent Fortran 2008 support
 +- C interoperability works well
 +- Available on all platforms
++
 +**Compiler Flags:**
 +```bash
 +# Debug build
 +-g -Wall -Wextra -fcheck=all -fbacktrace
++
 +# Release build
 +-O3 -march=native -flto
 +```
++
 +**Alternative:** Intel Fortran (ifx) also works but not required
++
 +### Debugger
++
 +**GDB** (GNU Debugger)
 +```bash
 +gdb ./build/sniffly
 +```
++
 +**LLDB** (macOS default)
 +```bash
 +lldb ./build/sniffly
 +```
++
 +### Profiling
++
 +**Linux: perf**
 +```bash
 +perf record ./sniffly /large/directory
 +perf report
 +```
++
 +**macOS: Instruments**
 +```bash
 +instruments -t "Time Profiler" ./sniffly /large/directory
 +```
++
 +**gprof** (cross-platform)
 +```bash
 +# Compile with -pg flag
 +gfortran -pg -o sniffly ...
 +./sniffly /large/directory
 +gprof sniffly gmon.out
 +```
++
 +### Memory Analysis
++
 +**valgrind** (Linux)
 +```bash
 +valgrind --leak-check=full ./sniffly /tmp
 +```
++
 +**AddressSanitizer** (both platforms)
 +```bash
 +gfortran -fsanitize=address -o sniffly ...
 +./sniffly /tmp
 +```
++
 +---
++
 +## Dependency Installation
++
 +### macOS (Homebrew)
++
 +```bash
 +# Install GTK4 and dependencies
 +brew install gtk4 cairo pango glib
++
 +# Install gtk-fortran (build from source)
 +git clone https://github.com/vmagnin/gtk-fortran.git
 +cd gtk-fortran
 +cmake -B build
 +cmake --build build
 +sudo cmake --install build
++
 +# Install build tools
 +brew install gfortran meson ninja
 +```
++
 +### Ubuntu/Debian
++
 +```bash
 +# Install GTK4 and dependencies
 +sudo apt install libgtk-4-dev libcairo2-dev libpango1.0-dev libglib2.0-dev
++
 +# Install gtk-fortran (build from source)
 +git clone https://github.com/vmagnin/gtk-fortran.git
 +cd gtk-fortran
 +cmake -B build
 +cmake --build build
 +sudo cmake --install build
++
 +# Install build tools
 +sudo apt install gfortran meson ninja-build
 +```
++
 +### Arch Linux
++
 +```bash
 +# Install GTK4 and dependencies
 +sudo pacman -S gtk4 cairo pango glib2
++
 +# gtk-fortran from AUR
 +yay -S gtk-fortran
++
 +# Install build tools
 +sudo pacman -S gcc-fortran meson ninja
 +```
++
 +### Fedora/RHEL
++
 +```bash
 +# Install GTK4 and dependencies
 +sudo dnf install gtk4-devel cairo-devel pango-devel glib2-devel
++
 +# Install gtk-fortran (build from source)
 +git clone https://github.com/vmagnin/gtk-fortran.git
 +cd gtk-fortran
 +cmake -B build
 +cmake --build build
 +sudo cmake --install build
++
 +# Install build tools
 +sudo dnf install gcc-gfortran meson ninja-build
 +```
++
 +---
++
 +## GTK4 Inspector
++
 +**What is it?**
 +- Built-in GUI debugger for GTK apps
 +- Inspect widget hierarchy
 +- View CSS styles
 +- Monitor signals and events
 +- Performance profiling
++
 +**How to Enable:**
 +```bash
 +# Set environment variable
 +export GTK_DEBUG=interactive
++
 +# Run app (inspector opens automatically)
 +./sniffly
 +```
++
 +**Features:**
 +- Widget tree browser
 +- Property editor (live changes)
 +- CSS inspector
 +- Signal log
 +- Performance metrics
++
 +---
++
 +## Testing Infrastructure
++
 +### Unit Testing: FUnit
++
 +**Why FUnit?**
 +- Pure Fortran testing framework
 +- Simple assertion API
 +- Integrates with Meson
++
 +**Sample Test:**
 +```fortran
 +module test_squarified
 +  use squarified
 +  use funit
 +  implicit none
 +contains
++
 +  @test
 +  subroutine test_aspect_ratio()
 +    real :: ratio
++
 +    ratio = aspect_ratio(10, 10)
 +    @assertEqual(1.0, ratio, tolerance=0.01)
++
 +    ratio = aspect_ratio(20, 10)
 +    @assertEqual(2.0, ratio, tolerance=0.01)
 +  end subroutine
++
 +end module test_squarified
 +```
++
 +### Integration Testing: Python
++
 +**Why Python?**
 +- Easy to script GTK interactions
 +- Screenshot comparison libraries
 +- Rich assertion libraries
++
 +**Sample Test:**
 +```python
 +import gi
 +gi.require_version('Gtk', '4.0')
 +from gi.repository import Gtk, GLib
 +import subprocess
 +import time
++
 +def test_launch_and_scan():
 +    # Launch sniffly
 +    proc = subprocess.Popen(['./sniffly'])
 +    time.sleep(2)
++
 +    # TODO: Automate UI interaction
 +    # For now, manual testing with checklist
++
 +    proc.terminate()
 +    assert proc.returncode == 0 or proc.returncode is None
 +```
++
 +---
++
 +## Continuous Integration
++
 +### GitHub Actions Workflow
++
 +**.github/workflows/build.yml:**
 +```yaml
 +name: Build and Test
++
 +on: [push, pull_request]
++
 +jobs:
 +  build-linux:
 +    runs-on: ubuntu-latest
 +    steps:
 +      - uses: actions/checkout@v3
 +      - name: Install dependencies
 +        run: |
 +          sudo apt update
 +          sudo apt install -y libgtk-4-dev gfortran meson ninja-build
 +      - name: Build gtk-fortran
 +        run: |
 +          git clone https://github.com/vmagnin/gtk-fortran.git
 +          cd gtk-fortran
 +          cmake -B build && cmake --build build
 +          sudo cmake --install build
 +      - name: Build sniffly
 +        run: |
 +          meson setup build
 +          meson compile -C build
 +      - name: Run tests
 +        run: meson test -C build
++
 +  build-macos:
 +    runs-on: macos-latest
 +    steps:
 +      - uses: actions/checkout@v3
 +      - name: Install dependencies
 +        run: |
 +          brew install gtk4 gfortran meson ninja
 +      - name: Build gtk-fortran
 +        run: |
 +          git clone https://github.com/vmagnin/gtk-fortran.git
 +          cd gtk-fortran
 +          cmake -B build && cmake --build build
 +          sudo cmake --install build
 +      - name: Build sniffly
 +        run: |
 +          meson setup build
 +          meson compile -C build
 +      - name: Run tests
 +        run: meson test -C build
 +```
++
 +---
++
 +## Alternative Stacks Considered
++
 +### 1. Rust + gtk-rs
++
 +**Pros:**
 +- Excellent GTK bindings
 +- Memory safety guarantees
 +- Growing ecosystem
++
 +**Cons:**
 +- Not Fortran (defeats the purpose!)
 +- Would need to rewrite all sniffert logic
 +- Steeper learning curve
++
 +**Verdict:** ❌ Wrong language
++
 +### 2. Fortran + QML (Qt Quick)
++
 +**Pros:**
 +- Modern declarative UI
 +- Hardware-accelerated
++
 +**Cons:**
 +- No Fortran bindings for QML
 +- Would need C++/Python bridge
 +- Qt is heavy dependency
++
 +**Verdict:** ❌ No Fortran support
++
 +### 3. Fortran + Web (Electron-style)
++
 +**Pros:**
 +- HTML/CSS for UI
 +- Easy prototyping
++
 +**Cons:**
 +- Huge resource usage
 +- Slow startup
 +- Not native look & feel
 +- Would need REST API layer
++
 +**Verdict:** ❌ Defeats performance goals
++
 +### 4. Fortran + Custom OpenGL
++
 +**Pros:**
 +- Maximum performance
 +- Full control
++
 +**Cons:**
 +- Reinvent wheel (buttons, text input, etc.)
 +- Months of UI infrastructure work
 +- Platform-specific window management
++
 +**Verdict:** ❌ Too much work
++
 +---
++
 +## Summary: Why This Stack is Optimal
++
 +| Requirement | Solution | Rationale |
 +|-------------|----------|-----------|
 +| Pure Fortran | gtk-fortran | Only mature Fortran GUI option |
 +| Cross-platform | GTK4 | Native on Linux, good on macOS |
 +| 2D rendering | Cairo | Built-in, hardware-accelerated |
 +| Text rendering | Pango | Unicode, fonts, ellipsization |
 +| Build system | Meson | GTK standard, dependency handling |
 +| Threading | GLib | Safe GTK integration |
 +| Performance | Native compilation | No interpreter overhead |
 +| Maintainability | Reuse sniffert | Proven algorithms |
++
 +---
++
 +## Risk Mitigation
++
 +### Risk: gtk-fortran bugs or limitations
++
 +**Mitigation:**
 +- Join gtk-fortran community early
 +- Contribute fixes upstream
 +- Fallback: C shim layer for problematic functions
++
 +### Risk: GTK4 not looking native on macOS
++
 +**Mitigation:**
 +- GTK4 uses Cocoa backend (better than GTK3)
 +- Test early and often on macOS
 +- Accept "good enough" if perfect not achievable
++
 +### Risk: Performance insufficient
++
 +**Mitigation:**
 +- Profile early (Week 4)
 +- Viewport culling for large trees
 +- Consider GSK (GTK's GPU backend) if needed
++
 +### Risk: Build complexity scares users
++
 +**Mitigation:**
 +- Provide pre-built binaries
 +- Package for all major package managers
 +- Clear installation instructions
 +- CI/CD for automated builds
++
 +---
++
 +## Conclusion
++
 +This stack provides:
 +1. ✅ **Pure Fortran** (proving the point)
 +2. ✅ **Modern GUI** (GTK4)
 +3. ✅ **Cross-platform** (macOS, Linux)
 +4. ✅ **Performant** (native code)
 +5. ✅ **Maintainable** (reuse sniffert)
 +6. ✅ **Packageable** (standard tools)
++
 +**We're ready to build!** 🚀

TOOLBAR-TARGETS.mdadded

 +# Sniffly Toolbar Feature Targets
++
 +## Vision
 +Redesign the Sniffly toolbar to match SpaceSniffer's usability while maintaining clean, intuitive design. Focus on most-used operations with clear iconography.
++
 +---
++
 +## Phase 1: Core Toolbar Redesign (PRIORITY)
++
 +### Remove
 +- **Quit button** - Defer to OS window close button (red X on macOS, X on Windows/Linux)
++
 +### Add/Reorganize
++
 +#### Left Section
 +1. **Open Directory Button** (Filing Cabinet Icon)
 +   - Opens OS native file picker (GtkFileChooserDialog)
 +   - Allows user to select directory to scan
 +   - Keyboard shortcut: `Cmd+O` / `Ctrl+O`
++
 +2. **Path Display** (Read-only text entry or label)
 +   - Shows current scan root path
 +   - Click filing cabinet icon next to it to trigger Open Directory
 +   - Should support text selection for copy/paste
++
 +3. **Scan Button** (Magnifying Glass Icon)
 +   - Positioned immediately after path display
 +   - Triggers rescan of current directory
 +   - Keyboard shortcut: `F5` or `Cmd+R`
++
 +4. **Progress Bar**
 +   - Keep current implementation
 +   - Expands to fill remaining space
 +   - Shows scan progress with percentage
++
 +#### Right Section (floated right)
 +5. **Open in Finder/Explorer Button** (File with Arrow Icon)
 +   - Opens currently selected item in OS file browser
 +   - macOS: `open -R <path>` (reveals in Finder)
 +   - Linux: `xdg-open <path>` or `nautilus <path>`
 +   - Windows: `explorer /select,<path>`
 +   - Disabled when no selection
 +   - Keyboard shortcut: `Cmd+Shift+R` / `Ctrl+Shift+R`
++
 +6. **Delete Button** (Red Trash/X Icon)
 +   - Deletes currently selected item
 +   - Priority: System trash → `rm` command as fallback
 +   - Shows confirmation dialog
 +   - Disabled when no selection
 +   - Keyboard shortcut: `d` or `Delete`
 +   - Right-click context menu also triggers this
++
 +---
++
 +## Phase 2: Enhanced File Operations
++
 +### Additional Toolbar Buttons
 +7. **Copy Path Button** (Clipboard Icon)
 +   - Copies full path of selected item to clipboard
 +   - Keyboard shortcut: `Cmd+Shift+C` / `Ctrl+Shift+C`
++
 +8. **Properties/Details Button** (Info Icon)
 +   - Opens side panel or dialog with file/folder details:
 +     - Full path
 +     - Size (human-readable + bytes)
 +     - Item count (for directories)
 +     - Created/modified dates
 +     - Permissions
 +     - File type
 +   - Keyboard shortcut: `i` or `Cmd+I`
++
 +9. **Refresh Button** (Circular Arrow Icon)
 +   - Forces rescan without cache
 +   - Clears directory cache before scanning
 +   - Keyboard shortcut: `Cmd+Shift+R` / `Ctrl+Shift+R`
++
 +---
++
 +## Phase 3: Search & Filter Features
++
 +### Filter Toolbar (Second Row, Collapsible)
 +10. **Search/Filter Entry**
 +    - Filter by filename pattern (wildcards: `*.txt`, `*cache*`)
 +    - Live filtering as you type
 +    - Keyboard shortcut: `Cmd+F` / `Ctrl+F` to focus
++
 +11. **File Type Filter Dropdown**
 +    - Quick filters: All, Documents, Images, Videos, Audio, Archives, Code
 +    - Based on file extensions
 +    - Multiple selection support
++
 +12. **Size Filter Range**
 +    - Min/max size sliders or entry fields
 +    - Quick presets: "Large files (>100MB)", "Tiny files (<1MB)"
++
 +13. **Date Filter**
 +    - Filter by modified date: Last day, week, month, year, custom range
 +    - "Old files" (not modified in 1+ years) preset
++
 +14. **Show Hidden Files Toggle**
 +    - Toggle visibility of hidden files/folders (starting with `.`)
 +    - Keyboard shortcut: `Cmd+Shift+H`
++
 +---
++
 +## Phase 4: Navigation & History
++
 +15. **Back/Forward Buttons** (Arrow Icons)
 +    - Navigate through directory history
 +    - Like a web browser
 +    - Keyboard shortcuts: `Cmd+[` / `Cmd+]` or `Alt+Left` / `Alt+Right`
++
 +16. **Up to Parent Button** (Up Arrow Icon)
 +    - Navigate to parent directory
 +    - Alternative to Backspace key
 +    - Shows parent path in tooltip
++
 +17. **Breadcrumb Navigation** (Already implemented!)
 +    - Enhance: Make each path segment clickable
 +    - Click any segment to jump to that level
++
 +---
++
 +## Phase 5: Advanced Features (SpaceSniffer Parity)
++
 +### View Options
 +18. **Toggle File Extensions**
 +    - Show/hide file extensions in labels
 +    - Keyboard shortcut: `e`
++
 +19. **Age-based Coloring**
 +    - Color files by modification date:
 +      - Blue = Recent (< 1 month)
 +      - Yellow = Medium (1-12 months)
 +      - Red = Old (> 1 year)
 +    - Toggle on/off
++
 +20. **Size Display Mode**
 +    - Toggle between actual size vs. allocated size (disk usage)
 +    - Useful for showing real disk space usage
++
 +### Export & Reporting
 +21. **Export to CSV/JSON**
 +    - Export directory tree with sizes
 +    - Useful for archiving or analysis
++
 +22. **Copy File List**
 +    - Copy list of all files matching current filter
 +    - Plain text format, one path per line
++
 +### Multi-Selection
 +23. **Multiple Selection Support**
 +    - `Cmd+Click` / `Ctrl+Click` to select multiple items
 +    - `Shift+Click` to select range
 +    - Show total size of selection in status bar
 +    - Bulk delete support
++
 +24. **Select All Matching Pattern**
 +    - Select all items matching a wildcard pattern
 +    - Example: "Select all *.log files"
++
 +### Comparison Mode
 +25. **Compare Two Scans**
 +    - Scan directory, then scan again later
 +    - Highlight differences (new, deleted, grown, shrunk files)
 +    - Useful for tracking disk usage changes over time
++
 +---
++
 +## Implementation Notes
++
 +### Icon Sources
 +- Use GTK stock icons where possible (`gtk_image_new_from_icon_name`)
 +- Common icon names:
 +  - `folder-open` - Open directory
 +  - `view-refresh` - Rescan/refresh
 +  - `edit-find` - Search
 +  - `edit-delete` - Delete
 +  - `edit-copy` - Copy path
 +  - `document-properties` - Properties/info
 +  - `go-up` - Navigate up
 +  - `go-previous` / `go-next` - Back/forward
 +  - `document-open` - Open in Finder
++
 +### GTK Components Needed
 +- `GtkFileChooserDialog` - For directory picker
 +- `GtkPopover` or `GtkDialog` - For properties panel
 +- `GtkEntry` - For search/filter input
 +- `GtkComboBox` - For filter dropdowns
 +- `GtkSwitch` - For toggles (hidden files, etc.)
 +- `GtkClipboard` - For copy path functionality
++
 +### Platform-Specific Code
 +- **Open in Finder/Explorer**: Use system commands via `iso_c_binding`
 +- **Delete to Trash**:
 +  - macOS: `osascript -e 'tell app "Finder" to delete POSIX file "..."'`
 +  - Linux: `gio trash <path>` or `trash-put <path>`
 +  - Fallback: `rm -rf` with confirmation
 +- **Copy to Clipboard**: Use GTK clipboard API
++
 +### Keyboard Shortcuts Summary
 +| Shortcut | Action |
 +|----------|--------|
 +| `Cmd+O` / `Ctrl+O` | Open directory picker |
 +| `F5` / `Cmd+R` | Rescan current directory |
 +| `Cmd+Shift+R` | Open in Finder/Explorer |
 +| `d` / `Delete` | Delete selected item |
 +| `Cmd+Shift+C` | Copy path to clipboard |
 +| `i` / `Cmd+I` | Show properties |
 +| `Cmd+F` | Focus search/filter |
 +| `Cmd+Shift+H` | Toggle hidden files |
 +| `Cmd+[` / `Cmd+]` | Back/forward in history |
 +| `Backspace` | Navigate to parent |
 +| `q` | Quit (already implemented) |
 +| `Space` | Select item (already implemented) |
 +| `Enter` | Navigate into item (already implemented) |
 +| `Arrow keys` | Navigate treemap (already implemented) |
++
 +---
++
 +## Current Status (Updated 2025-11-05)
 +- ✅ Basic toolbar with Scan button
 +- ✅ Progress bar (moved to toolbar)
 +- ✅ Breadcrumb display (path only, not clickable yet)
 +- ✅ Keyboard navigation (arrows, enter, backspace, space)
 +- ✅ Mouse hover and selection
 +- ✅ Directory caching for fast re-scans
 +- ✅ **Phase 1 Complete**: Open Directory, Path Display, Scan, Open in Finder, Copy Path, Delete buttons
 +- ✅ **Tooltips**: Hover shows filename, size, item count
 +- ✅ **Status Bar Stats**: Shows "N items (M files) - X.XX GB"
 +- ✅ **Color by File Type**: Images, videos, audio, documents, code, archives colored
 +- ✅ **Size Labels**: Shows formatted sizes on rectangles (when space permits)
 +- ✅ **Copy Path to Clipboard**: Toolbar button + Cmd+Shift+C shortcut
 +- ✅ **Cushioned Treemap**: Van Wijk algorithm for 3D shading effect
++
 +## Next Steps
 +1. ✅ ~~Implement Phase 1 core toolbar redesign~~ **DONE**
 +2. ✅ ~~Add GtkFileChooserDialog for directory picker~~ **DONE**
 +3. ✅ ~~Implement "Open in Finder" functionality~~ **DONE**
 +4. ✅ ~~Add delete functionality with system trash support~~ **DONE**
 +5. Enhance breadcrumb bar to be clickable (navigate to parent levels)
 +6. Add keyboard shortcut handler for Copy Path (Cmd+Shift+C)
 +7. Implement context menu (right-click)
 +8. Add Properties/Info dialog
 +9. Implement Back/Forward navigation history
++
 +---
++
 +## Design Decisions (CONFIRMED)
 +- ✅ **Drag-and-drop**: YES - Drag directory onto app window to initiate scan
 +- ✅ **Filter toolbar**: Always visible (we have plenty of header space)
 +- ✅ **Context menu**: YES - Right-click context menu on selections
 +- ✅ **Undo for delete**: YES - Implement Cmd/Ctrl+Z undo for delete operations
 +- ✅ **Settings dialog**: Defer to later phases
++
 +## Priority: ALL FEATURES - Full SpaceSniffer parity!

fac_debug.txtadded

 +=== FINAL TREE STRUCTURE ===
 +. is_file=F has_next_sib=F
 +app is_file=F has_next_sib=T
 +main.f90 is_file=T has_next_sib=F
 +src is_file=F has_next_sib=T
 +core is_file=F has_next_sib=T
 +dir_helpers.c is_file=T has_next_sib=T
 +file_system.f90 is_file=T has_next_sib=T
 +types.f90 is_file=T has_next_sib=F
 +gui is_file=F has_next_sib=F
 +gtk_app.f90 is_file=T has_next_sib=F
 +.gitignore is_file=T has_next_sib=T
 +GETTING_STARTED.md is_file=T has_next_sib=T
 +LICENSE is_file=T has_next_sib=T
 +PROJECT_SUMMARY.md is_file=T has_next_sib=T
 +QUICKSTART.md is_file=T has_next_sib=T
 +README.md is_file=T has_next_sib=T
 +SNIFFLY_MASTER_PLAN.md is_file=T has_next_sib=T
 +TECHNICAL_STACK.md is_file=T has_next_sib=T
 +meson.build is_file=T has_next_sib=F

      type(c_ptr), value :: area, cr, user_data
      integer(c_int), value :: width, height
      type(c_ptr) :: layout, font_desc
 -    integer(c_int) :: text_width, text_height, x_offset
 +    integer(c_int), target :: text_width, text_height
 +    integer(c_int) :: x_offset
      integer :: i
      character(len=:), allocatable :: separator
                                    int(len_trim(cached_segment_names(i)), c_int))
        ! Get text size
 -      call pango_layout_get_pixel_size(layout, text_width, text_height)
 +      call pango_layout_get_pixel_size(layout, c_loc(text_width), c_loc(text_height))
        ! Store bounds for hit-testing
        segment_rects(i)%x = x_offset
          call pango_layout_set_text(layout, trim(separator)//c_null_char, &
                                      int(len_trim(separator), c_int))
 -        call pango_layout_get_pixel_size(layout, text_width, text_height)
 +        call pango_layout_get_pixel_size(layout, c_loc(text_width), c_loc(text_height))
          call cairo_move_to(cr, real(x_offset, c_double), &
                             real((height - text_height) / 2, c_double))
          call pango_cairo_show_layout(cr, layout)

`@@ -0,0 +1,2 @@`
	1	+[trunk fa16041] only use
	2	+ 1 file changed, 14 insertions(+), 3 deletions(-)

 +<?xml version="1.0" encoding="UTF-8"?>
++
 +<schemalist>
++
 +  <enum id='org.gtk.Demo4.Color'>
 +    <value nick='red'   value='0'/>
 +    <value nick='green' value='1'/>
 +    <value nick='blue'  value='2'/>
 +  </enum>
++
 +  <schema id='org.gtk.Demo4' path='/org/gtk/Demo4/'>
 +    <key name='color' enum='org.gtk.Demo4.Color'>
 +      <default>'red'</default>
 +    </key>
 +    <key name='window-size' type='(ii)'>
 +      <default>(-1, -1)</default>
 +    </key>
 +    <key name='maximized' type='b'>
 +      <default>false</default>
 +    </key>
 +    <key name='fullscreen' type='b'>
 +      <default>false</default>
 +    </key>
 +  </schema>
++
 +</schemalist>

 +<?xml version="1.0" encoding="UTF-8"?>
 +<schemalist>
++
 +  <schema id='org.gtk.gtk4.Inspector.Recorder' path='/org/gtk/gtk4/inspector/recorder/'>
 +    <key name='debug-nodes' type='b'>
 +      <default>false</default>
 +      <summary>Insert debug nodes</summary>
 +      <description>
 +        If this setting is true, the recorder will insert debug nodes
 +        into the recording.
 +      </description>
 +    </key>
 +    <key name='record-events' type='b'>
 +      <default>false</default>
 +      <summary>Record events</summary>
 +      <description>
 +        If this setting is true, the recorder will include events
 +        in the recording.
 +      </description>
 +    </key>
 +    <key name='highlight-sequences' type='b'>
 +      <default>false</default>
 +      <summary>Highlight sequences</summary>
 +      <description>
 +        If this setting is true, the recorder will highlight events
 +        that are part of an event sequence.
 +      </description>
 +    </key>
 +    <key name='dark' type='b'>
 +      <default>false</default>
 +      <summary>Set the recorder to dark</summary>
 +      <description>
 +        If this setting is true, the recorder will display render nodes
 +        on a dark background.
 +      </description>
 +    </key>
 +  </schema>
++
 +</schemalist>
++

 +<?xml version="1.0" encoding="UTF-8"?>
 +<schemalist>
++
 +  <schema id='org.gtk.gtk4.Settings.ColorChooser' path='/org/gtk/gtk4/settings/color-chooser/'>
 +    <key name='custom-colors' type='a(dddd)'>
 +      <default>[]</default>
 +      <summary>Custom colors</summary>
 +      <description>
 +        An array of custom colors to show in the color chooser. Each color is
 +        specified as a tuple of four doubles, specifying RGBA values between
 +        0 and 1.
 +      </description>
 +    </key>
 +    <key name='selected-color' type='(bdddd)'>
 +      <default>(false,1.0,1.0,1.0,1.0)</default>
 +      <summary>The selected color</summary>
 +      <description>
 +         The selected color, described as a tuple whose first member is a
 +         boolean that is true if a color was selected, and the remaining
 +         four members are four doubles, specifying RGBA values between
 +         0 and 1.
 +      </description>
 +    </key>
 +  </schema>
++
 +</schemalist>