A!leys Galerie

#!/usr/bin/env python3
import sqlite3
import sys
from typing import List, Dict, Optional, Tuple
import curses
import time
from dataclasses import dataclass
import random

# Retrowave Farbschema
NEON_CYAN = 46
NEON_MAGENTA = 51
NEON_YELLOW = 33
NEON_GREEN = 32
NEON_RED = 31
NEON_BLUE = 44
DARK_GRAY = 240
WHITE = 256 + 15
BLACK = 0

@dataclass
class DatabaseTable:
    name: str
    schema: str

class NeonDB:
    def __init__(self, database_path: str):
        self.conn = sqlite3.connect(database_path)
        self.tables: List[DatabaseTable] = []
        self.current_table: Optional[str] = None
        self.offset = 0
        self.limit = 10
        self.column_names: List[str] = []

    def get_tables(self) -> List[str]:
        cursor = self.conn.cursor()
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
        return [row[0] for row in cursor.fetchall()]

    def get_table_schema(self, table_name: str) -> str:
        cursor = self.conn.cursor()
        cursor.execute(f"PRAGMA table_info({table_name});")
        return str(cursor.fetchall())

    def get_table_data(self, table_name: str, offset: int = 0, limit: int = 10) -> Tuple[List[Tuple], List[str]]:
        cursor = self.conn.cursor()
        cursor.execute(f"SELECT * FROM {table_name} LIMIT ? OFFSET ?;", (limit, offset))
        self.column_names = [description[0] for description in cursor.description]
        return cursor.fetchall(), self.column_names

    def get_row_count(self, table_name: str) -> int:
        cursor = self.conn.cursor()
        cursor.execute(f"SELECT COUNT(*) FROM {table_name};")
        return cursor.fetchone()[0]

    def close(self):
        self.conn.close()

def draw_banner(stdscr):
    height, width = stdscr.getmaxyx()
    banner = [
        "  _____ __  __ _____ ____   _____ ____ _____ ____ _____ ____",
        " |_   _|  \\/  |_   _|  _ \\ / ____|  _ \\_   _|  _ \\_   _/ __ \\",
        "   | | | \\/ |  | | | | | | (___ | |_) || | | | | | | | (___ |",
        "   | | | |\\/|  | | | | |_| \\___ \\|  _ < | | | | | | |_   _|",
        "  _| |_| |  | _| |_| |___/____) | |_) || | | |_| | |__| |___ ",
        " |_____|_|  |_____|_____/     |____/ |____/|_|  \\____/\\____|",
        "",
        "  Retrowave SQLite Browser  v1.0  "
    ]

    for i, line in enumerate(banner):
        y = max(0, (height - len(banner)) // 2 + i)
        if y < height:
            stdscr.addstr(y, 0, line, curses.color_pair(NEON_CYAN))

def draw_table_header(stdscr, table_name: str, columns: List[str]):
    height, width = stdscr.getmaxyx()
    header_width = sum(len(col) + 2 for col in columns)
    header_pad = (width - header_width) // 2 if width > header_width else 0

    stdscr.addstr(5, header_pad, f"TABLE: {table_name}", curses.color_pair(NEON_MAGENTA))
    stdscr.addstr(6, header_pad, "=" * (len(f"TABLE: {table_name}") + 2), curses.color_pair(NEON_YELLOW))

    if columns:
        column_line = ""
        for col in columns:
            column_line += f" {col.ljust(10)} |"
        stdscr.addstr(7, header_pad, column_line, curses.color_pair(NEON_GREEN))

        separator = ""
        for col in columns:
            separator += "-" * 12 + "+"
        stdscr.addstr(8, header_pad, separator, curses.color_pair(NEON_YELLOW))

def draw_table_data(stdscr, data: List[Tuple], columns: List[str], offset: int, db: NeonDB):
    height, width = stdscr.getmaxyx()
    header_pad = (width - sum(len(col) + 2 for col in columns)) // 2 if columns else 0

    for i, row in enumerate(data):
        y_pos = 9 + i
        if y_pos < height:
            row_line = ""
            for j, (col, val) in enumerate(zip(columns, row)):
                row_line += f" {str(val).ljust(10)} |"
            stdscr.addstr(y_pos, header_pad, row_line, curses.color_pair(NEON_BLUE))

    if len(data) < 10:
        stdscr.addstr(height - 1, 0, f"End of data (showing {len(data)} rows)", curses.color_pair(DARK_GRAY))
    else:
        stdscr.addstr(height - 1, 0, f"Rows {offset}-{offset + len(data) - 1} of {db.get_row_count(db.current_table)}", curses.color_pair(DARK_GRAY))

def draw_tables_list(stdscr, tables: List[str], selected: int):
    height, width = stdscr.getmaxyx()
    list_pad = (width - 20) // 2

    for i, table in enumerate(tables):
        y_pos = 5 + i
        if y_pos < height:
            if i == selected:
                stdscr.addstr(y_pos, list_pad, f" > {table} < ", curses.color_pair(NEON_RED) | curses.A_REVERSE)
            else:
                stdscr.addstr(y_pos, list_pad, f"  {table}  ", curses.color_pair(NEON_CYAN))

def draw_schema(stdscr, table_name: str, schema: str):
    height, width = stdscr.getmaxyx()
    list_pad = (width - 20) // 2

    stdscr.addstr(3, list_pad, f"Schema for {table_name}:", curses.color_pair(NEON_MAGENTA))
    lines = schema.split('\n')
    for i, line in enumerate(lines):
        y_pos = 4 + i
        if y_pos < height:
            stdscr.addstr(y_pos, list_pad, line, curses.color_pair(DARK_GRAY))

def draw_pagination(stdscr, offset: int, limit: int, total: int):
    height, width = stdscr.getmaxyx()
    stdscr.addstr(height - 2, 0, f"Page: {offset//limit + 1} | Rows: {offset}-{min(offset + limit, total)} of {total}", curses.color_pair(NEON_YELLOW))

def main(stdscr):
    curses.init_pair(NEON_CYAN, BLACK, WHITE)
    curses.init_pair(NEON_MAGENTA, BLACK, 204)
    curses.init_pair(NEON_YELLOW, BLACK, 226)
    curses.init_pair(NEON_GREEN, BLACK, 40)
    curses.init_pair(NEON_RED, BLACK, 196)
    curses.init_pair(NEON_BLUE, BLACK, 45)
    curses.init_pair(DARK_GRAY, BLACK, 240)
    curses.init_pair(WHITE, BLACK, 255)

    stdscr.clear()
    draw_banner(stdscr)
    stdscr.refresh()
    time.sleep(0.5)

    if len(sys.argv) != 2:
        stdscr.addstr(10, 0, "Usage: python neon_db.py <database_file.db>", curses.color_pair(NEON_RED))
        stdscr.refresh()
        time.sleep(1)
        return

    database_path = sys.argv[1]
    db = NeonDB(database_path)
    tables = db.get_tables()
    selected_table = 0
    view_mode = "tables"  # tables, data, schema

    while True:
        stdscr.erase()
        if view_mode == "tables":
            draw_tables_list(stdscr, tables, selected_table)
            draw_pagination(stdscr, 0, 10, len(tables))
        elif view_mode == "schema":
            if selected_table < len(tables):
                table_name = tables[selected_table]
                schema = db.get_table_schema(table_name)
                draw_schema(stdscr, table_name, schema)
        elif view_mode == "data":
            if selected_table < len(tables):
                table_name = tables[selected_table]
                data, columns = db.get_table_data(table_name, db.offset, db.limit)
                draw_table_header(stdscr, table_name, columns)
                draw_table_data(stdscr, data, columns, db.offset, db)
                draw_pagination(stdscr, db.offset, db.limit, db.get_row_count(table_name))

        stdscr.refresh()
        key = stdscr.getch()

        if key == curses.KEY_UP and selected_table > 0:
            selected_table -= 1
        elif key == curses.KEY_DOWN and selected_table < len(tables) - 1:
            selected_table += 1
        elif key == curses.KEY_ENTER or key == 10:
            if view_mode == "tables":
                db.current_table = tables[selected_table]
                db.offset = 0
                view_mode = "data"
            elif view_mode == "data":
                view_mode = "schema"
        elif key == curses.KEY_BACKSPACE or key == 127:
            if view_mode == "schema":
                view_mode = "data"
            elif view_mode == "data":
                view_mode = "tables"
        elif key == ord('q') or key == ord('Q'):
            break
        elif key == ord('r') or key == ord('R'):
            if view_mode == "data":
                db.offset += db.limit
                data, _ = db.get_table_data(db.current_table, db.offset, db.limit)
                if not data:
                    db.offset -= db.limit
        elif key == ord('e') or key == ord('E'):
            if view_mode == "data" and db.offset > 0:
                db.offset = max(0, db.offset - db.limit)
        elif key == ord('s') or key == ord('S'):
            view_mode = "schema"
        elif key == ord('t') or key == ord('T'):
            view_mode = "tables"
        elif key == ord('d') or key == ord('D'):
            view_mode = "data"

    db.close()
    curses.endwin()

if __name__ == "__main__":
    curses.wrapper(main)

```swift
import SwiftUI
import Combine

struct ContentView: View {
    @State private var selectedImage: Image?
    @State private var zoomScale: CGFloat = 1.0
    @State private var offset: CGSize = .zero
    @State private var isDragging = false
    @State private var lastScale: CGFloat = 1.0

    private let photos: [UIImage] = {
        let assets = [
            "1",
            "2",
            "3",
            "4",
            "5",
            "6",
            "7",
            "8",
            "9",
            "10",
            "11",
            "12"
        ]
        return assets.compactMap { UIImage(named: $0) }
    }()

    private let gridLayout = [GridItem(.flexible()), GridItem(.flexible()), GridItem(.flexible())]

    var body: some View {
        VStack(spacing: 0) {
            // Header with back button and title
            HStack {
                Button(action: { selectedImage = nil }) {
                    Image(systemName: "chevron.backward")
                        .font(.title2)
                        .foregroundColor(.primary)
                }

                Spacer()

                Text("FocalFlow")
                    .font(.headline)
                    .foregroundColor(.primary)
            }
            .padding(.horizontal, 16)
            .padding(.top, 8)

            // Main photo grid
            GeometryReader { geometry in
                ZStack {
                    // Grid background
                    LazyVGrid(columns: gridLayout) {
                        ForEach(0..<photos.count, id: \.self) { index in
                            Image(uiImage: photos[index])
                                .resizable()
                                .scaledToFill()
                                .frame(width: geometry.size.width / 3, height: geometry.size.height / 2)
                                .clipped()
                                .onTapGesture {
                                    selectedImage = Image(uiImage: photos[index])
                                    zoomScale = 1.0
                                    offset = .zero
                                    isDragging = false
                                }
                        }
                    }

                    // Selected image with zoom
                    if let selectedImage = selectedImage {
                        Image(uiImage: selectedImage)
                            .resizable()
                            .scaledToFill()
                            .frame(width: geometry.size.width, height: geometry.size.height - 100)
                            .offset(offset)
                            .scaleEffect(zoomScale)
                            .animation(
                                Animation.interpolatingSpring(
                                    mass: 0.5,
                                    stiffness: 200,
                                    damping: 20
                                ),
                                value: isDragging ? (offset, zoomScale) : nil
                            )
                            .gesture(
                                MagnificationGesture()
                                    .onMagnified { value in
                                        if value > 1.1 && zoomScale < 5 {
                                            let newScale = min(zoomScale * value, 5)
                                            if !isDragging {
                                                lastScale = zoomScale
                                            }
                                            zoomScale = newScale
                                            isDragging = true
                                        }
                                    }
                            )
                            .gesture(
                                DragGesture()
                                    .onChanged { value in
                                        offset = value.translation
                                        isDragging = true
                                    }
                                    .onEnded { value in
                                        offset = .zero
                                        isDragging = false
                                    }
                            )
                    }
                }
            }