MD-to-Prrint/README.md

# MD_to_Print - Script automatique Markdown → PDF → Impression

Application CLI complète pour convertir des fichiers Markdown en PDF et les imprimer automatiquement sur Debian/Linux, avec support Docker, prévisualisation, options d'impression avancées, et gestion d'erreurs robuste.

## Fonctionnalités

- **Conversion automatique** Markdown → PDF avec Pandoc
- **Prévisualisation** avant impression (evince/okular/xdg-open)
- **Options d'impression avancées** (copies, pages, orientation, qualité, couleur, recto-verso)
- **Fichier de configuration** optionnel (format INI)
- **Installation automatique** des dépendances
- **Support Docker** pour isolation et portabilité
- **Gestion d'erreurs** complète avec codes de retour appropriés
- **Système de logging** détaillé avec niveaux (DEBUG, INFO, WARN, ERROR)
- **Interface en ligne de commande** avec options complètes
- **Intégration bureau** : Menu contextuel MATE/Caja avec sélection multiple

## Installation

### Installation locale

1. Cloner ou télécharger le projet:
```bash
cd MD_to_print
chmod +x md_to_print.sh
```

2. Installer les dépendances manuellement ou automatiquement:
```bash
# Installation automatique
./md_to_print.sh --install-deps

# Ou installation manuelle
sudo apt-get update
sudo apt-get install -y pandoc texlive-latex-base texlive-fonts-recommended \
    texlive-latex-extra texlive-lang-french cups
```

3. (Optionnel) Installation système:
```bash
make install
```

### Installation avec Docker

**Note importante sur le temps de construction :**
La première construction de l'image Docker peut prendre **5-10 minutes** car elle doit télécharger et installer les packages TeX Live (plusieurs centaines de MB). C'est normal et nécessaire pour la conversion PDF. Les constructions suivantes seront beaucoup plus rapides grâce au cache Docker.

**Pour accélérer la construction :**
- Utilisez le cache Docker : ne reconstruisez que si nécessaire
- Utilisez `docker build --cache-from md-to-print:latest` pour réutiliser le cache
- Une fois construite, l'image est réutilisable indéfiniment

1. Construire l'image Docker:
```bash
make build
# ou
docker build -t md-to-print:latest .
```

2. Créer les répertoires nécessaires:
```bash
mkdir -p documents output logs
```

## Utilisation

### Utilisation locale

#### Commande de base
```bash
./md_to_print.sh document.md
```

#### Avec prévisualisation
```bash
./md_to_print.sh document.md --preview
```

#### Options avancées
```bash
./md_to_print.sh document.md \
    --printer HP_LaserJet \
    --copies 2 \
    --color \
    --duplex duplex \
    --quality high \
    --pages 1-5 \
    --orientation landscape \
    --keep-pdf
```

#### Avec fichier de configuration
```bash
# Créer votre configuration
cp config.example.conf config.conf
# Éditer config.conf selon vos besoins

# Utiliser la configuration
./md_to_print.sh document.md --config config.conf
```

### Utilisation avec Docker

#### Via le wrapper script
```bash
chmod +x docker_run.sh
./docker_run.sh documents/mon_fichier.md --preview
```

#### Directement avec docker
```bash
docker run --rm -it \
    -v $(pwd)/documents:/workspace/documents:ro \
    -v $(pwd)/output:/workspace/output \
    -v $(pwd)/logs:/workspace/logs \
    --network host \
    md-to-print:latest \
    /workspace/documents/document.md --preview
```

#### Via Docker Compose
```bash
# Modifier docker-compose.yml si nécessaire
docker-compose run --rm md-to-print \
    /workspace/documents/document.md --preview
```

### Via Makefile

```bash
# Construire l'image
make build

# Tester avec fichier exemple
make test

# Ouvrir un shell dans le conteneur
make shell

# Nettoyer les fichiers générés
make clean
```

## Utilisation de bureau (MATE/Caja)

MD_to_Print peut être intégré dans votre environnement de bureau MATE pour une utilisation via le menu contextuel (clic droit).

### Installation de l'intégration bureau

**IMPORTANT :** Caja nécessite l'extension **caja-actions** pour afficher les actions dans le menu contextuel.

1. **Installer caja-actions** (requis):
```bash
sudo apt-get install caja-actions
```

2. **Installation automatique** (recommandée):
```bash
cd MD_to_print
./desktop/install-desktop.sh
```

3. **Configuration Caja Actions** (important):
```bash
# Ouvrir l'outil de configuration
caja-actions-config-tool
```

Dans l'outil de configuration :
- Allez dans **Édition > Préférences**
- Onglet **Préférences d'exécution**
- **Désactivez** l'option "Créer un menu racine 'Caja-Actions'"
- Cela permet aux actions d'apparaître directement dans le menu contextuel

4. **Redémarrer Caja** pour voir les nouvelles actions:
```bash
caja -q
```

### Utilisation depuis le menu contextuel

Une fois installé, les actions suivantes sont disponibles dans le menu contextuel (clic droit) sur les fichiers `.md`:

- **"Imprimer avec MD_to_Print"** : Conversion + Impression directe
- **"Convertir en PDF (MD_to_Print)"** : Conversion uniquement, sans impression
- **"Prévisualiser avant impression"** : Conversion + Prévisualisation + Impression optionnelle

### Fonctionnalités

- ✅ **Sélection multiple** : Traitez plusieurs fichiers en une seule fois
- ✅ **Notifications de bureau** : Feedback visuel pour chaque étape
- ✅ **Détection automatique** : Utilise l'installation locale ou Docker selon disponibilité
- ✅ **Gestion d'erreurs** : Messages clairs en cas de problème
- ✅ **Confirmation** : Dialogue de confirmation pour traitement multiple

### Exemples d'utilisation

**Sélection unique :**
1. Clic droit sur `document.md`
2. Sélectionner "Imprimer avec MD_to_Print"
3. Le fichier est converti et imprimé automatiquement

**Sélection multiple :**
1. Sélectionner plusieurs fichiers `.md` (Ctrl+Clic)
2. Clic droit → "Convertir en PDF (MD_to_Print)"
3. Confirmer le traitement multiple
4. Tous les fichiers sont convertis séquentiellement avec notifications

### Désinstallation

Pour désinstaller l'intégration bureau:
```bash
./desktop/install-desktop.sh --uninstall
```

### Dépendances bureau

**Critique :**
- `caja-actions` : Extension Caja pour les actions personnalisées (REQUIS)

**Optionnelles :**
- `zenity` ou `yad` : Dialogues graphiques
- `libnotify-bin` : Notifications (`notify-send`)
- `caja` : Gestionnaire de fichiers MATE (déjà installé)

Installation des dépendances:
```bash
sudo apt-get install caja-actions zenity libnotify-bin
```

### Dépannage menu contextuel

**Les actions n'apparaissent pas dans le menu :**
```bash
# 1. Vérifier que caja-actions est installé (CRITIQUE)
dpkg -l | grep caja-actions
# Si absent: sudo apt-get install caja-actions

# 2. Vérifier que les fichiers .desktop sont installés
ls ~/.local/share/caja/actions/md-to-print-*.desktop

# 3. Ouvrir l'outil de configuration Caja Actions
caja-actions-config-tool
# Vérifier que les actions sont présentes et activées
# Dans Préférences: désactiver "Créer un menu racine Caja-Actions"

# 4. Vérifier que les scripts sont dans le PATH
which md_to_print_gui.sh

# 5. Redémarrer Caja
caja -q
```

**Erreur "md_to_print_gui.sh: command not found" :**
```bash
# Vérifier l'installation
./desktop/install-desktop.sh

# Vérifier que ~/.local/bin est dans le PATH
echo $PATH | grep -q ".local/bin" || echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
```

**Notifications ne s'affichent pas :**
```bash
# Vérifier que libnotify est installé
dpkg -l | grep libnotify-bin

# Tester manuellement
notify-send "Test" "Les notifications fonctionnent"
```

## Options disponibles

| Option | Description | Défaut |
|--------|-------------|--------|
| `-p, --preview` | Prévisualiser le PDF avant impression | false |
| `-P, --printer NOM` | Spécifier l'imprimante | Imprimante système |
| `-c, --copies N` | Nombre de copies | 1 |
| `-r, --pages RANGE` | Pages à imprimer (ex: 1-3,5,7-9) | Toutes |
| `-o, --orientation DIR` | Orientation (portrait/landscape) | portrait |
| `-s, --size SIZE` | Taille du papier (A4, A3, Letter, etc.) | A4 |
| `-q, --quality QUALITY` | Qualité (draft, normal, high) | normal |
| `-C, --color` | Impression en couleur | false |
| `-d, --duplex MODE` | Mode recto-verso (none, simplex, duplex) | none |
| `-i, --install-deps` | Installer les dépendances automatiquement | false |
| `-k, --keep-pdf` | Conserver le fichier PDF après impression | false |
| `--config FILE` | Fichier de configuration | Aucun |
| `-v, --verbose` | Mode verbeux (logging DEBUG) | false |
| `-l, --log FILE` | Fichier de log | Aucun |
| `-h, --help` | Afficher l'aide | - |
| `--version` | Afficher la version | - |

## Configuration

Le fichier de configuration utilise le format INI avec trois sections:

### Section `[default]`
Options d'impression par défaut (printer, copies, orientation, size, quality, color, duplex, preview, keep_pdf)

### Section `[paths]`
Chemins des répertoires (output_dir, log_dir)

### Section `[logging]`
Paramètres de logging (level, file, verbose)

Exemple de fichier `config.conf`:
```ini
[default]
printer=HP_LaserJet
copies=1
orientation=portrait
size=A4
quality=normal
color=false
duplex=none
preview=false
keep_pdf=false

[paths]
output_dir=./output
log_dir=./logs

[logging]
level=INFO
file=md_to_print.log
verbose=false
```

## Structure du projet

```
MD_to_print/
├── md_to_print.sh              # Script principal
├── config.example.conf          # Fichier de configuration exemple
├── Dockerfile                   # Configuration Docker
├── docker-compose.yml           # Configuration Docker Compose
├── docker_run.sh                # Wrapper Docker
├── Makefile                     # Commandes Make
├── desktop/                     # Intégration bureau
│   ├── md-to-print-print.desktop    # Action "Imprimer"
│   ├── md-to-print-convert.desktop  # Action "Convertir"
│   ├── md-to-print-preview.desktop  # Action "Prévisualiser"
│   └── install-desktop.sh           # Script d'installation
├── scripts/                     # Scripts utilitaires
│   ├── md_to_print_gui.sh          # Wrapper GUI
│   └── md_to_print_notify.sh       # Script notifications
├── .dockerignore                # Fichiers à exclure du build Docker
├── .gitignore                   # Fichiers à ignorer dans Git
├── README.md                    # Documentation (ce fichier)
├── CHANGELOG.md                 # Historique des versions
├── documents/                   # Fichiers Markdown sources
├── output/                      # PDFs générés
└── logs/                        # Fichiers de logs
```

## Exemples d'utilisation

### Impression simple
```bash
./md_to_print.sh rapport.md
```

### Impression avec prévisualisation
```bash
./md_to_print.sh rapport.md --preview
```

### Impression recto-verso en couleur
```bash
./md_to_print.sh rapport.md --duplex duplex --color --copies 2
```

### Impression de pages spécifiques
```bash
./md_to_print.sh rapport.md --pages 1-10,15,20-25
```

### Impression paysage haute qualité
```bash
./md_to_print.sh presentation.md --orientation landscape --quality high
```

### Avec logging détaillé
```bash
./md_to_print.sh document.md --verbose --log mon_log.txt
```

## Codes de retour

| Code | Signification |
|------|---------------|
| 0 | Succès |
| 1 | Erreur générale |
| 2 | Fichier introuvable |
| 3 | Dépendances manquantes |
| 4 | Erreur conversion PDF |
| 5 | Erreur impression |
| 6 | Erreur configuration |
| 7 | Erreur Docker |
| 8 | Permissions insuffisantes |
| 9 | Argument invalide |
| 10 | Imprimante non disponible |

## Configuration de l'impression dans Docker

Pour que l'impression fonctionne depuis Docker, vous devez configurer l'accès à CUPS:

1. Installer CUPS sur l'hôte:
```bash
sudo apt-get install cups
```

2. Configurer le partage réseau dans `/etc/cups/cupsd.conf`:
```
Listen localhost:631
Port 631
```

3. Redémarrer CUPS:
```bash
sudo systemctl restart cups
```

4. Le socket CUPS sera monté automatiquement via docker-compose.yml ou docker_run.sh

## Dépannage

### Erreur: "pandoc n'est pas installé"
```bash
./md_to_print.sh document.md --install-deps
```

### Erreur: "Imprimante non disponible"
```bash
# Lister les imprimantes disponibles
lpstat -p

# Utiliser l'imprimante par défaut
./md_to_print.sh document.md
```

### Erreur: "Permission de lecture refusée"
```bash
# Vérifier les permissions du fichier
ls -l document.md

# Donner les permissions de lecture
chmod +r document.md
```

### Erreur Docker: "Cannot connect to the Docker daemon"
```bash
# Vérifier que Docker est démarré
sudo systemctl status docker

# Démarrer Docker si nécessaire
sudo systemctl start docker

# Ajouter votre utilisateur au groupe docker
sudo usermod -aG docker $USER
# Déconnexion/reconnexion nécessaire
```

### Prévisualisation ne fonctionne pas dans Docker
La prévisualisation graphique nécessite l'accès X11. Assurez-vous que:
- `DISPLAY` est défini dans votre environnement
- `/tmp/.X11-unix` est accessible
- Les permissions X11 sont correctes:
```bash
xhost +local:docker
```

## Dépendances

### Dépendances système
- pandoc
- texlive-latex-base
- texlive-fonts-recommended
- texlive-latex-extra
- texlive-lang-french (support français)
- cups (pour l'impression)
- evince ou okular (pour la prévisualisation, optionnel)

Toutes les dépendances sont installées automatiquement avec l'option `--install-deps` ou dans l'image Docker.

## Contribution

Les contributions sont les bienvenues! N'hésitez pas à:
- Signaler des bugs
- Proposer des améliorations
- Soumettre des pull requests

## Licence

Ce projet est fourni tel quel, sans garantie.

## Auteur

MD_to_Print - Script automatique Markdown → PDF → Impression

## Historique

Voir [CHANGELOG.md](CHANGELOG.md) pour l'historique des versions.