602 lines
22 KiB
Python
602 lines
22 KiB
Python
"""
|
||
File operations mixin for pyPhotoAlbum
|
||
"""
|
||
|
||
from PyQt6.QtWidgets import (
|
||
QFileDialog, QDialog, QVBoxLayout, QHBoxLayout, QLabel,
|
||
QDoubleSpinBox, QSpinBox, QPushButton, QGroupBox, QRadioButton,
|
||
QButtonGroup, QLineEdit, QTextEdit
|
||
)
|
||
from pyPhotoAlbum.decorators import ribbon_action, numerical_input
|
||
from pyPhotoAlbum.project import Project, Page
|
||
from pyPhotoAlbum.async_project_loader import AsyncProjectLoader
|
||
from pyPhotoAlbum.loading_widget import LoadingWidget
|
||
from pyPhotoAlbum.project_serializer import save_to_zip
|
||
from pyPhotoAlbum.models import set_asset_resolution_context
|
||
from pyPhotoAlbum.version_manager import format_version_info, CURRENT_DATA_VERSION
|
||
from pyPhotoAlbum.asset_heal_dialog import AssetHealDialog
|
||
|
||
|
||
class FileOperationsMixin:
|
||
"""Mixin providing file-related operations"""
|
||
|
||
@ribbon_action(
|
||
label="New",
|
||
tooltip="Create a new project",
|
||
tab="Home",
|
||
group="File",
|
||
shortcut="Ctrl+N"
|
||
)
|
||
def new_project(self):
|
||
"""Create a new project with initial setup dialog"""
|
||
# Create new project setup dialog
|
||
dialog = QDialog(self)
|
||
dialog.setWindowTitle("New Project Setup")
|
||
dialog.setMinimumWidth(450)
|
||
|
||
layout = QVBoxLayout()
|
||
|
||
# Project name group
|
||
name_group = QGroupBox("Project Name")
|
||
name_layout = QVBoxLayout()
|
||
name_input = QLineEdit()
|
||
name_input.setText("New Project")
|
||
name_input.selectAll()
|
||
name_layout.addWidget(name_input)
|
||
name_group.setLayout(name_layout)
|
||
layout.addWidget(name_group)
|
||
|
||
# Default page size group
|
||
size_group = QGroupBox("Default Page Size")
|
||
size_layout = QVBoxLayout()
|
||
|
||
info_label = QLabel("This will be the default size for all new pages in this project.")
|
||
info_label.setWordWrap(True)
|
||
info_label.setStyleSheet("font-size: 9pt; color: gray;")
|
||
size_layout.addWidget(info_label)
|
||
|
||
# Width
|
||
width_layout = QHBoxLayout()
|
||
width_layout.addWidget(QLabel("Width:"))
|
||
width_spinbox = QDoubleSpinBox()
|
||
width_spinbox.setRange(10, 1000)
|
||
width_spinbox.setValue(140) # Default 14cm
|
||
width_spinbox.setSuffix(" mm")
|
||
width_layout.addWidget(width_spinbox)
|
||
size_layout.addLayout(width_layout)
|
||
|
||
# Height
|
||
height_layout = QHBoxLayout()
|
||
height_layout.addWidget(QLabel("Height:"))
|
||
height_spinbox = QDoubleSpinBox()
|
||
height_spinbox.setRange(10, 1000)
|
||
height_spinbox.setValue(140) # Default 14cm
|
||
height_spinbox.setSuffix(" mm")
|
||
height_layout.addWidget(height_spinbox)
|
||
size_layout.addLayout(height_layout)
|
||
|
||
# Add common size presets
|
||
presets_layout = QHBoxLayout()
|
||
presets_layout.addWidget(QLabel("Presets:"))
|
||
|
||
def set_preset(w, h):
|
||
width_spinbox.setValue(w)
|
||
height_spinbox.setValue(h)
|
||
|
||
preset_a4 = QPushButton("A4 (210×297)")
|
||
preset_a4.clicked.connect(lambda: set_preset(210, 297))
|
||
presets_layout.addWidget(preset_a4)
|
||
|
||
preset_a5 = QPushButton("A5 (148×210)")
|
||
preset_a5.clicked.connect(lambda: set_preset(148, 210))
|
||
presets_layout.addWidget(preset_a5)
|
||
|
||
preset_square = QPushButton("Square (200×200)")
|
||
preset_square.clicked.connect(lambda: set_preset(200, 200))
|
||
presets_layout.addWidget(preset_square)
|
||
|
||
presets_layout.addStretch()
|
||
size_layout.addLayout(presets_layout)
|
||
|
||
size_group.setLayout(size_layout)
|
||
layout.addWidget(size_group)
|
||
|
||
# DPI settings group
|
||
dpi_group = QGroupBox("DPI Settings")
|
||
dpi_layout = QVBoxLayout()
|
||
|
||
# Working DPI
|
||
working_dpi_layout = QHBoxLayout()
|
||
working_dpi_layout.addWidget(QLabel("Working DPI:"))
|
||
working_dpi_spinbox = QSpinBox()
|
||
working_dpi_spinbox.setRange(72, 1200)
|
||
working_dpi_spinbox.setValue(300)
|
||
working_dpi_layout.addWidget(working_dpi_spinbox)
|
||
dpi_layout.addLayout(working_dpi_layout)
|
||
|
||
# Export DPI
|
||
export_dpi_layout = QHBoxLayout()
|
||
export_dpi_layout.addWidget(QLabel("Export DPI:"))
|
||
export_dpi_spinbox = QSpinBox()
|
||
export_dpi_spinbox.setRange(72, 1200)
|
||
export_dpi_spinbox.setValue(300)
|
||
export_dpi_layout.addWidget(export_dpi_spinbox)
|
||
dpi_layout.addLayout(export_dpi_layout)
|
||
|
||
dpi_group.setLayout(dpi_layout)
|
||
layout.addWidget(dpi_group)
|
||
|
||
# Buttons
|
||
button_layout = QHBoxLayout()
|
||
cancel_btn = QPushButton("Cancel")
|
||
cancel_btn.clicked.connect(dialog.reject)
|
||
create_btn = QPushButton("Create Project")
|
||
create_btn.clicked.connect(dialog.accept)
|
||
create_btn.setDefault(True)
|
||
|
||
button_layout.addStretch()
|
||
button_layout.addWidget(cancel_btn)
|
||
button_layout.addWidget(create_btn)
|
||
layout.addLayout(button_layout)
|
||
|
||
dialog.setLayout(layout)
|
||
|
||
# Show dialog
|
||
if dialog.exec() == QDialog.DialogCode.Accepted:
|
||
# Get values
|
||
project_name = name_input.text().strip() or "New Project"
|
||
width_mm = width_spinbox.value()
|
||
height_mm = height_spinbox.value()
|
||
working_dpi = working_dpi_spinbox.value()
|
||
export_dpi = export_dpi_spinbox.value()
|
||
|
||
# Cleanup old project if it exists
|
||
if hasattr(self, 'project') and self.project:
|
||
self.project.cleanup()
|
||
|
||
# Create project with custom settings
|
||
self.project = Project(project_name)
|
||
self.project.page_size_mm = (width_mm, height_mm)
|
||
self.project.working_dpi = working_dpi
|
||
self.project.export_dpi = export_dpi
|
||
|
||
# Set asset resolution context
|
||
set_asset_resolution_context(self.project.folder_path)
|
||
|
||
# Update view
|
||
self.update_view()
|
||
|
||
self.show_status(f"New project created: {project_name} ({width_mm}×{height_mm} mm)")
|
||
print(f"New project created: {project_name}, default page size: {width_mm}×{height_mm} mm")
|
||
else:
|
||
# User cancelled - keep current project
|
||
print("New project creation cancelled")
|
||
|
||
@ribbon_action(
|
||
label="Open",
|
||
tooltip="Open an existing project",
|
||
tab="Home",
|
||
group="File",
|
||
shortcut="Ctrl+O"
|
||
)
|
||
def open_project(self):
|
||
"""Open an existing project with async loading and progress bar"""
|
||
file_path, _ = QFileDialog.getOpenFileName(
|
||
self,
|
||
"Open Project",
|
||
"",
|
||
"pyPhotoAlbum Projects (*.ppz);;All Files (*)"
|
||
)
|
||
|
||
if file_path:
|
||
print(f"Opening project: {file_path}")
|
||
|
||
# Create loading widget if not exists
|
||
if not hasattr(self, '_loading_widget'):
|
||
self._loading_widget = LoadingWidget(self)
|
||
|
||
# Show loading widget
|
||
self._loading_widget.show_loading("Opening project...")
|
||
|
||
# Create and configure async loader
|
||
self._project_loader = AsyncProjectLoader(file_path)
|
||
|
||
# Connect signals
|
||
self._project_loader.progress_updated.connect(self._on_load_progress)
|
||
self._project_loader.load_complete.connect(self._on_load_complete)
|
||
self._project_loader.load_failed.connect(self._on_load_failed)
|
||
|
||
# Start async loading
|
||
self._project_loader.start()
|
||
|
||
def _on_load_progress(self, current: int, total: int, message: str):
|
||
"""Handle loading progress updates"""
|
||
if hasattr(self, '_loading_widget'):
|
||
self._loading_widget.set_progress(current, total)
|
||
self._loading_widget.set_status(message)
|
||
|
||
def _on_load_complete(self, project):
|
||
"""Handle successful project load"""
|
||
# Cleanup old project if it exists
|
||
if hasattr(self, 'project') and self.project:
|
||
self.project.cleanup()
|
||
|
||
# Set new project
|
||
self.project = project
|
||
self.gl_widget.current_page_index = 0 # Reset to first page
|
||
|
||
# Hide loading widget
|
||
if hasattr(self, '_loading_widget'):
|
||
self._loading_widget.hide_loading()
|
||
|
||
# Update view (this will trigger progressive image loading)
|
||
self.update_view()
|
||
|
||
self.show_status(f"Project opened: {project.name}")
|
||
print(f"Successfully loaded project: {project.name}")
|
||
|
||
def _on_load_failed(self, error_msg: str):
|
||
"""Handle project load failure"""
|
||
# Hide loading widget
|
||
if hasattr(self, '_loading_widget'):
|
||
self._loading_widget.hide_loading()
|
||
|
||
error_msg = f"Failed to open project: {error_msg}"
|
||
self.show_status(error_msg)
|
||
self.show_error("Load Failed", error_msg)
|
||
print(error_msg)
|
||
|
||
@ribbon_action(
|
||
label="Save",
|
||
tooltip="Save the current project",
|
||
tab="Home",
|
||
group="File",
|
||
shortcut="Ctrl+S"
|
||
)
|
||
def save_project(self):
|
||
"""Save the current project"""
|
||
file_path, _ = QFileDialog.getSaveFileName(
|
||
self,
|
||
"Save Project",
|
||
"",
|
||
"pyPhotoAlbum Projects (*.ppz);;All Files (*)"
|
||
)
|
||
|
||
if file_path:
|
||
print(f"Saving project to: {file_path}")
|
||
|
||
# Save project to ZIP
|
||
success, error = save_to_zip(self.project, file_path)
|
||
|
||
if success:
|
||
self.show_status(f"Project saved: {file_path}")
|
||
print(f"Successfully saved project to: {file_path}")
|
||
else:
|
||
error_msg = f"Failed to save project: {error}"
|
||
self.show_status(error_msg)
|
||
print(error_msg)
|
||
|
||
@ribbon_action(
|
||
label="Heal Assets",
|
||
tooltip="Reconnect missing image assets",
|
||
tab="Home",
|
||
group="File"
|
||
)
|
||
def heal_assets(self):
|
||
"""Open the asset healing dialog to reconnect missing images"""
|
||
dialog = AssetHealDialog(self.project, self)
|
||
dialog.exec()
|
||
|
||
# Update the view to reflect any changes
|
||
self.update_view()
|
||
|
||
@ribbon_action(
|
||
label="Project Settings",
|
||
tooltip="Configure project-wide page size and defaults",
|
||
tab="Home",
|
||
group="File"
|
||
)
|
||
@numerical_input(
|
||
fields=[
|
||
('width', 'Width', 'mm', 10, 1000),
|
||
('height', 'Height', 'mm', 10, 1000)
|
||
]
|
||
)
|
||
def project_settings(self):
|
||
"""Configure project-wide settings including default page size"""
|
||
# Create dialog
|
||
dialog = QDialog(self)
|
||
dialog.setWindowTitle("Project Settings")
|
||
dialog.setMinimumWidth(500)
|
||
|
||
layout = QVBoxLayout()
|
||
|
||
# Page size group
|
||
size_group = QGroupBox("Default Page Size")
|
||
size_layout = QVBoxLayout()
|
||
|
||
# Width
|
||
width_layout = QHBoxLayout()
|
||
width_layout.addWidget(QLabel("Width:"))
|
||
width_spinbox = QDoubleSpinBox()
|
||
width_spinbox.setRange(10, 1000)
|
||
width_spinbox.setValue(self.project.page_size_mm[0])
|
||
width_spinbox.setSuffix(" mm")
|
||
width_layout.addWidget(width_spinbox)
|
||
size_layout.addLayout(width_layout)
|
||
|
||
# Height
|
||
height_layout = QHBoxLayout()
|
||
height_layout.addWidget(QLabel("Height:"))
|
||
height_spinbox = QDoubleSpinBox()
|
||
height_spinbox.setRange(10, 1000)
|
||
height_spinbox.setValue(self.project.page_size_mm[1])
|
||
height_spinbox.setSuffix(" mm")
|
||
height_layout.addWidget(height_spinbox)
|
||
size_layout.addLayout(height_layout)
|
||
|
||
size_group.setLayout(size_layout)
|
||
layout.addWidget(size_group)
|
||
|
||
# DPI settings group
|
||
dpi_group = QGroupBox("DPI Settings")
|
||
dpi_layout = QVBoxLayout()
|
||
|
||
# Working DPI
|
||
working_dpi_layout = QHBoxLayout()
|
||
working_dpi_layout.addWidget(QLabel("Working DPI:"))
|
||
working_dpi_spinbox = QSpinBox()
|
||
working_dpi_spinbox.setRange(72, 1200)
|
||
working_dpi_spinbox.setValue(self.project.working_dpi)
|
||
working_dpi_layout.addWidget(working_dpi_spinbox)
|
||
dpi_layout.addLayout(working_dpi_layout)
|
||
|
||
# Export DPI
|
||
export_dpi_layout = QHBoxLayout()
|
||
export_dpi_layout.addWidget(QLabel("Export DPI:"))
|
||
export_dpi_spinbox = QSpinBox()
|
||
export_dpi_spinbox.setRange(72, 1200)
|
||
export_dpi_spinbox.setValue(self.project.export_dpi)
|
||
export_dpi_layout.addWidget(export_dpi_spinbox)
|
||
dpi_layout.addLayout(export_dpi_layout)
|
||
|
||
dpi_group.setLayout(dpi_layout)
|
||
layout.addWidget(dpi_group)
|
||
|
||
# Content scaling options (only if pages exist and size is changing)
|
||
scaling_group = None
|
||
scaling_buttons = None
|
||
|
||
if self.project.pages:
|
||
scaling_group = QGroupBox("Apply to Existing Pages")
|
||
scaling_layout = QVBoxLayout()
|
||
|
||
info_label = QLabel("How should existing content be adjusted?\n(Pages with manual sizing will not be affected)")
|
||
info_label.setWordWrap(True)
|
||
scaling_layout.addWidget(info_label)
|
||
|
||
scaling_buttons = QButtonGroup()
|
||
|
||
proportional_radio = QRadioButton("Resize proportionally (fit to smallest axis)")
|
||
proportional_radio.setToolTip("Scale content uniformly to fit the new page size")
|
||
scaling_buttons.addButton(proportional_radio, 0)
|
||
scaling_layout.addWidget(proportional_radio)
|
||
|
||
stretch_radio = QRadioButton("Resize on both axes (stretch)")
|
||
stretch_radio.setToolTip("Scale width and height independently")
|
||
scaling_buttons.addButton(stretch_radio, 1)
|
||
scaling_layout.addWidget(stretch_radio)
|
||
|
||
reposition_radio = QRadioButton("Keep content size, reposition to center")
|
||
reposition_radio.setToolTip("Maintain element sizes but center them on new page")
|
||
scaling_buttons.addButton(reposition_radio, 2)
|
||
scaling_layout.addWidget(reposition_radio)
|
||
|
||
none_radio = QRadioButton("Don't adjust content (page size only)")
|
||
none_radio.setToolTip("Only change page size, leave content as-is")
|
||
none_radio.setChecked(True) # Default
|
||
scaling_buttons.addButton(none_radio, 3)
|
||
scaling_layout.addWidget(none_radio)
|
||
|
||
scaling_group.setLayout(scaling_layout)
|
||
layout.addWidget(scaling_group)
|
||
|
||
# Buttons
|
||
button_layout = QHBoxLayout()
|
||
cancel_btn = QPushButton("Cancel")
|
||
cancel_btn.clicked.connect(dialog.reject)
|
||
ok_btn = QPushButton("OK")
|
||
ok_btn.clicked.connect(dialog.accept)
|
||
ok_btn.setDefault(True)
|
||
|
||
button_layout.addStretch()
|
||
button_layout.addWidget(cancel_btn)
|
||
button_layout.addWidget(ok_btn)
|
||
layout.addLayout(button_layout)
|
||
|
||
dialog.setLayout(layout)
|
||
|
||
# Show dialog
|
||
if dialog.exec() == QDialog.DialogCode.Accepted:
|
||
# Get new values
|
||
new_width = width_spinbox.value()
|
||
new_height = height_spinbox.value()
|
||
new_working_dpi = working_dpi_spinbox.value()
|
||
new_export_dpi = export_dpi_spinbox.value()
|
||
|
||
# Determine scaling mode
|
||
scaling_mode = 'none'
|
||
if scaling_buttons:
|
||
selected_id = scaling_buttons.checkedId()
|
||
modes = {0: 'proportional', 1: 'stretch', 2: 'reposition', 3: 'none'}
|
||
scaling_mode = modes.get(selected_id, 'none')
|
||
|
||
# Apply settings
|
||
old_size = self.project.page_size_mm
|
||
self.project.page_size_mm = (new_width, new_height)
|
||
self.project.working_dpi = new_working_dpi
|
||
self.project.export_dpi = new_export_dpi
|
||
|
||
# Update existing pages (exclude manually sized ones)
|
||
if self.project.pages and old_size != (new_width, new_height):
|
||
self._apply_page_size_to_project(old_size, (new_width, new_height), scaling_mode)
|
||
|
||
self.update_view()
|
||
self.show_status(f"Project settings updated: {new_width}×{new_height} mm", 2000)
|
||
print(f"Project settings updated: {new_width}×{new_height} mm, scaling mode: {scaling_mode}")
|
||
|
||
def _apply_page_size_to_project(self, old_size, new_size, scaling_mode):
|
||
"""
|
||
Apply new page size to all non-manually-sized pages
|
||
|
||
Args:
|
||
old_size: Old page size (width, height) in mm
|
||
new_size: New page size (width, height) in mm
|
||
scaling_mode: 'proportional', 'stretch', 'reposition', or 'none'
|
||
"""
|
||
old_width, old_height = old_size
|
||
new_width, new_height = new_size
|
||
|
||
width_ratio = new_width / old_width if old_width > 0 else 1.0
|
||
height_ratio = new_height / old_height if old_height > 0 else 1.0
|
||
|
||
for page in self.project.pages:
|
||
# Skip manually sized pages
|
||
if page.manually_sized:
|
||
continue
|
||
|
||
# Update page size
|
||
old_page_width, old_page_height = page.layout.size
|
||
|
||
# For double spreads, maintain the 2x multiplier
|
||
if page.is_double_spread:
|
||
page.layout.size = (new_width * 2, new_height)
|
||
else:
|
||
page.layout.size = (new_width, new_height)
|
||
|
||
# Apply content scaling based on mode
|
||
if scaling_mode == 'proportional':
|
||
# Use smallest ratio to fit content
|
||
scale = min(width_ratio, height_ratio)
|
||
self._scale_page_elements(page, scale, scale)
|
||
elif scaling_mode == 'stretch':
|
||
# Scale independently on each axis
|
||
self._scale_page_elements(page, width_ratio, height_ratio)
|
||
elif scaling_mode == 'reposition':
|
||
# Keep size, center content
|
||
self._reposition_page_elements(page, old_size, new_size)
|
||
# 'none' - do nothing to elements
|
||
|
||
def _scale_page_elements(self, page, x_scale, y_scale):
|
||
"""
|
||
Scale all elements on a page
|
||
|
||
Args:
|
||
page: Page object
|
||
x_scale: Horizontal scale factor
|
||
y_scale: Vertical scale factor
|
||
"""
|
||
for element in page.layout.elements:
|
||
# Scale position
|
||
x, y = element.position
|
||
element.position = (x * x_scale, y * y_scale)
|
||
|
||
# Scale size
|
||
width, height = element.size
|
||
element.size = (width * x_scale, height * y_scale)
|
||
|
||
def _reposition_page_elements(self, page, old_size, new_size):
|
||
"""
|
||
Reposition elements to center them on the new page size
|
||
|
||
Args:
|
||
page: Page object
|
||
old_size: Old page size (width, height) in mm
|
||
new_size: New page size (width, height) in mm
|
||
"""
|
||
old_width, old_height = old_size
|
||
new_width, new_height = new_size
|
||
|
||
x_offset = (new_width - old_width) / 2.0
|
||
y_offset = (new_height - old_height) / 2.0
|
||
|
||
for element in page.layout.elements:
|
||
x, y = element.position
|
||
element.position = (x + x_offset, y + y_offset)
|
||
|
||
@ribbon_action(
|
||
label="Export PDF",
|
||
tooltip="Export project to PDF",
|
||
tab="Export",
|
||
group="Export"
|
||
)
|
||
def export_pdf(self):
|
||
"""Export project to PDF using async backend (non-blocking)"""
|
||
# Check if we have pages to export
|
||
if not self.project or not self.project.pages:
|
||
self.show_status("No pages to export")
|
||
return
|
||
|
||
# Show file save dialog
|
||
file_path, _ = QFileDialog.getSaveFileName(
|
||
self,
|
||
"Export to PDF",
|
||
"",
|
||
"PDF Files (*.pdf);;All Files (*)"
|
||
)
|
||
|
||
if not file_path:
|
||
return
|
||
|
||
# Ensure .pdf extension
|
||
if not file_path.lower().endswith('.pdf'):
|
||
file_path += '.pdf'
|
||
|
||
# Use async PDF export (non-blocking, UI stays responsive)
|
||
success = self.gl_widget.export_pdf_async(self.project, file_path, export_dpi=300)
|
||
if success:
|
||
self.show_status("PDF export started...", 2000)
|
||
else:
|
||
self.show_status("PDF export failed to start", 3000)
|
||
|
||
@ribbon_action(
|
||
label="About",
|
||
tooltip="About pyPhotoAlbum and data format version",
|
||
tab="Home",
|
||
group="File"
|
||
)
|
||
def show_about(self):
|
||
"""Show about dialog with version information"""
|
||
dialog = QDialog(self)
|
||
dialog.setWindowTitle("About pyPhotoAlbum")
|
||
dialog.setMinimumWidth(600)
|
||
dialog.setMinimumHeight(400)
|
||
|
||
layout = QVBoxLayout()
|
||
|
||
# Application info
|
||
app_info = QLabel("<h2>pyPhotoAlbum</h2>")
|
||
app_info.setWordWrap(True)
|
||
layout.addWidget(app_info)
|
||
|
||
description = QLabel(
|
||
"A photo album layout and design application with advanced "
|
||
"page composition features and PDF export capabilities."
|
||
)
|
||
description.setWordWrap(True)
|
||
layout.addWidget(description)
|
||
|
||
# Version information
|
||
version_text = QTextEdit()
|
||
version_text.setReadOnly(True)
|
||
version_text.setPlainText(format_version_info())
|
||
layout.addWidget(version_text)
|
||
|
||
# Close button
|
||
close_button = QPushButton("Close")
|
||
close_button.clicked.connect(dialog.accept)
|
||
layout.addWidget(close_button)
|
||
|
||
dialog.setLayout(layout)
|
||
dialog.exec()
|