Ce site est optimisé pour être consulté depuis un navigateur moderne dans lequel JavaScript est activé.

[ VOS SCRIPTS UTILES ] (et eventuelles demandes de scripts...)

lynn

Quelques remarques :

1 - Si le répertoire ~/.devilspie n'existe pas, ça ne fonctionne pas (No s-expressions loaded, quiting).
2 - Une fois les règles des fenêtres créées, il faudrait que ton script démarre devilspie sinon ça ne fonctionne pas (éventuellement, proposer de lancer devilspie au démarrage du pc).
3 - Chez moi, il y a un répertoire ds-FE qui est crée et qui empêche devilspie de démarrer correctement car il ne trouve pas de fichier de configuration .ds à la racine du répertoire ~/.devilspie (No s-expressions loaded, quiting).

Tawal

Bon je galère, mais ...

Le dossier ~/.devilspie doit exister ! Il est créé par l'installation de devilspie.
Devilspie est configuré pour aller lire les fichiers .ds dans CE répertoire.
Donc en gros, si t'as pas ~/.devilspie c'est que :
- soit devilspie n'est pas installé (ça s'est fait je teste tous les progs nécessaires)
- soit il est installé d'une manière "customisée" et donc TU dois savoir OÙ il doit aller lire ces fichiers.

De plus, j'ai testé en effet, si ~/.devilspie n'existe pas, ça ne marche pas.
Par contre, s'il est vide, ça marche quand même vu que j'y crée le fichier debug .

Devilspie cherche les fichiers .ds dans

Devil's Pie 0.23 starting...
Loading /etc/devilspie
/etc/devilspie doesn't exist
Loading /home/tawal/.devilspie
/home/tawal/.devilspie doesn't exist
0 s-expressions loaded.
No s-expressions loaded, quiting

/etc/devilspie et
${HOME}/.devilspie et c'est tout, s'il va ailleurs, c'est que c'est une install custom.
Donc problème du customizer ...

Pour ce qui est du redémarrage de devilspie avec ces nouvelles règles,
il faut passer par la déconnexion reconnexion session, ça regarde l'user là. il aura un avertissement.
Déjà, il y en a un qui manque : si tu démarres l'appli, ça flingue le daemon devilspie en cours.

Vli,vlà,vlou ^^

Voici une nouvelle version /!\ Le dossier ds-FE a changé de nom, il s'appelle ds-igle

#!/bin/bash

###############################################################################
#
# Nom : DevilsPie-IGEL	-	Devil's Pie Interface Graphique Extra Légère
#
# Commande : DevilsPie-IGEL
#
# Arguments : Aucuns
# Options : Aucunes
#
# Nécéssite : devilspie   wmctrl   xdotool   yad   zenity
#								par Tawal.
###############################################################################

RETOUR=0			# Code de retour si tout se passe bien

ERR_SORTIE_YAD=64		# Sortie utilisateur 1ere boite (attente_appli)
ERR_ABANDON_YAD=65		# Sortie utilisateur 2eme boite (yad_inf_fen)
ERR_ABS_PROG=71			# Retour si un prog nécéssaire manque
ERR_ABS_DOSS=72			# Retour si le dossier d'installation de devilspie n'existe pas.
ERR_PARSING_CONTINUE=80		# Retour zenity erreur parsing (ou split fichier) et utilisateur continue
ERR_PARSING_STOP=81		# Retour zenity erreur parsing (ou split fichier) des fichiers de règles et abandon utilisateur
ERR_CASE_ZENITY=91		# Code retour si case "reponse zenity erreur parsing" a échoue - Très peu probable mais bon
ERR_CASE_YAD=92			# Idem qu'au dessus mais pour yad_inf_fen - Très peu probable aussi
ERR_INCONNUE_FIN_SCRIPT=113	# Exit à la fin du script où il ne devrait jamais passer !




# Création du dossier temporaire Devil et des fichiers temporaires devil_tmp et yad_datas
Devil=$(mktemp -d /tmp/Devil-XXXXXXXXXXXXXXXX)	#+ (du moins les chemins sont contenus dans ces variables)
devil_tmp=$(mktemp -p $Devil devil_tmp-XXX)	# Gestion de l'effacement du dossier et des fichiers temporaires
yad_datas=$(mktemp -p $Devil yad_datas-XXX)	#+ par le 'trap rm' ci-après : un peu trop de signaux trapés ?
																		#
trap "rm -rf $Devil $devil_tmp $yad_datas" TERM INT ABRT HUP QUIT EXIT 	# TERM=15 INT=Ctrl+C ABRT=Abort HUP=Par.Proc.Mort QUIT=Crtl+D

ORIGIN=$(pwd)			# Sauvegarde de l'endroit d'où on vient, on va se ballader un peu
											
sep='|'				# Définition du séparateur pour 'yad' et pour les champs de 'awk' et ...
export icon=/usr/share/icons/Tango/32x32/apps/xfce4-session.png




########	4 Fonctions à exporter pour éviter un script extérieur - Appelées par les boutons 'yad'	 et par la fonction 'xdoyad'	

howtodo() {
	zenity --info --width 450 --window-icon $icon --title "Devil's Pie - IGEL - How To Do" \
		--text "\t\t\t\t  <u><b>HOW TO DO</b></u>\n\n\t- Ouvrez l'application à gérer et cliquez sur <b>OK</b>.\n\n\t- Redimensionnez et positionnez la fenêtre.\n\n\t- Puis cliquez sur <b>Attraper les données de la fenêtre</b>.\n\n\t- Sélectionnez le Bureau, puis\n\n\t- <u>Ouvrez une nouvelle fenêtre</u> à gérer.\n\n\t- Et cliquez sur <b>Nouvelle Fenêtre OK</b>.\n\n\t- Recommencez l'opération etc ...\n\n\t- Puis cliquez sur <b>Créer Règles</b> quand vous avez fini.\n\n\n<i>Le bouton <b>Attraper les données de la fenêtre</b> ne sauvegarde pas la règle qui s'affiche, celle-ci l'est lorsque vous passez à la fenêtre suivante ou que vous créez les règles.\n\nParcourrez une à une <u>toutes</u> les fenêtres de l'application en suivant la procédure ci-dessus.\n\nToutes les données sont modifiables !\nIl est conseillé de ne changer ni le nom ni la classe d'application.\nSurveillez bien les titres de fenêtres, car ils sont très restrictifs !\n\nChoisisez '<u>is</u>' pour un titre de fenêtre inchangeant.\nOptez pour '<u>contains</u>' pour un titre modifié de fenêtre.\n\nVous pouvez garder cette fenêtre ouverte pendant les opérations.</i>"
}

xdoyad() { 			# Capture des données fenêtre après redimensionnement et retour à 'yad' des données par les 'echo'
	local geom="" pos="" title="" totwinstack chope
	totwinstack=$(xdotool search --onlyvisible --classname "$1" getwindowname %@ 2>/dev/null | wc -l)
	chope=$(xdotool search --onlyvisible --classname "$1" getwindowgeometry %$totwinstack  getwindowname %$totwinstack 2>/dev/null)
	posxdo=( $(echo $chope | awk '{print $4}' | sed 's/,/ /g') )
	X=$((${posxdo[0]}-10)); Y=$((${posxdo[1]}-38))		# Rattrapage de la différence entre Devilspie et Xdotool (approx. quoique)
	pos="+"$X"+"$Y
	geom=$(echo $chope | awk '{print $8}')
	title=$(echo "$chope" | awk 'BEGIN {$1=""; $2=""; $3=""; $4=""; $5=""; $6=""; $7=""; $8=""}; END {print $N}' | sed 's/^ *//g')
	[ -z "$title" ] && zenity_pas_de_fen  && xdoyad $1     		# Appel de la fonction zenity_pas_de_fen + récursivité de 'xdoyad'
	echo "3:$title"
	echo "4:${geom}${pos}"
}

zenity_pas_de_fen() { 		# Gestion par la fonction 'xdoyad' en cas si la fenêtre n'est pas trouvée et appel affichage ici
	zenity --info --width 350 --window-icon $icon --title "Devil's Pie - IGEL - Pas Trouvé !" \
			--text "Réouvrez la fenêtre, cliquez sur <b>Valider</b>\n\npuis sur <b>Attraper les données de la fenêtre</b>"
}

export -f howtodo zenity_pas_de_fen xdoyad # Export des 4 fonctions (elles agissent dans un|des sous-shell|s)
######### Fin Export ##################################################################################################






################################### PARTIE FONCTIONS ##################################################################


sortie() {
	case $1 in
	   	   72|73 ) ;;
		64|65|80 ) activ_regles ;;
	esac
	killall devilspie
	cd $ORIGIN
	exit $1
}

err_parsing() { 					# Gestion de l'erreur dans le parsing ...
	mess=""; mess2=""; mess3=""			#+ N'arrivera pas à mon avis, j'ai du créer les erreurs à la main
	[ "$3" -gt "1" ] && {				#+ sur les fichiers temporaires.
		mess="<u>sans importance</u>"
		mess2="dans une sous-règle."
		mess3="Elle ne 'matchera' pas, mais laissera le reste fonctionner."
	} || {
		mess="<u><b>GRAVE</b></u>"
		mess2="dans l'entête de fichier !"
		mess3="Ce fichier de règles ne fonctionnera pas.\nMais il peut être récupéré manuellement, il sera créé en continuant."
	}
	zenity --question --title "Devil's Pie - IGEL - ERREUR !" \
		--window-icon $icon --width 450 \
		--ok-label "OUI" --cancel-label "NON" \
		--text "\nUne erreur $mess est survenue lors de la création d'un fichier .ds\nLe fichier <b>$nom_fich_reel.ds</b> comporte le nom <u>$nom_fich_lu</u> en classe d'application $mess2\n\n$mess3\n\nVoulez-vous tout de même créer le fichier\Cliquer sur 'NON' et aucun fichier ne sera créé !"
	res=$?
	case $res in 
		0 ) RETOUR=$ERR_PARSING_CONTINUE ;;
		1 ) sortie $ERR_PARSING_STOP ;;
		* ) RETOUR=$ERR_CASE_ZENITY ;;
	esac
}

sauve_ds() { 		# On transfère les fichiers finaux du dossier temporaire au dossier DOSS_DEST
	local fich n=0 tab
	for fich in *.ds; do  		# Création d'un tableau ( fich1 fich2... DossierDest )
		tab[$n]=$fich
		n=$((n+1 ))
	done
	tab[$n]=$DOSS_DEST
	cp -f ${tab[@]} & 		# Copie des fichiers définitifs des règles (1 fichier par classe d'application)
	for n in `seq 1 100`; do 	#	en forcing et à la volée !!!
		echo $n																								 #  DE LA POUDRE AUX YEUX
		sleep 0.005																							 #		ce zenity là !
	done | zenity --progress --window-icon $icon --auto-close --no-cancel --title "Devil's Pie - IGEL - Copie" --text "\nCopie des fichiers ..."  
	cd $OLDPWD							# Je l'avais dit : de la balade suivez le chemin ^^
}
 
parse_fich() { # On crée le fichier final de règles. On extrait les données dim + loi ligne par ligne. + Gestion structure fichier final
	local num_lign app title geom class gui='"'
	for num_lign in `seq 1 $(wc -l $1 | awk '{print $1}')`; do
		nom_fich_reel=$1
		nom_fich_reel=${nom_fich_reel%*-} # On ôte le tiret '-' à nom_fich_reel pour bien matcher avec la class d'appli. et on l' utilise en
		nom_fich_lu=$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $1}' | sed 's/ *//g')   #+ nom de fich. final
		[ ! "$nom_fich_lu" = "$nom_fich_reel" ] && err_parsing $nom_fich_lu $nom_fich_reel $num_lign  # Teste si le nom du fichier 
		class='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $1}')'"'   #+ lu dans la ligne
		app='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $2}')'"'     #+ correspond à celui du fichier réel
		title='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $3}')'"'   #+ Appel de la fonction err_parsing
		geom='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $4}')'"'
		bur=$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $5}')
		loi=$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $6}')
		[ "$num_lign" = "1" ] && { 		   # C'est ici qu'on écrit vraiment les règles, 1 tour boucle = 1 ligne lue et éclatée = une règle 
			echo -e "(if (and (is (window_class) $class) (is (application_name) $app))" > "$Devil/$nom_fich_reel.ds"
			echo -e "	(begin\n" >> "$Devil/$nom_fich_reel.ds"																 # 
			[ ! "$bur" = "$defaut" ] && { echo -e "		(set_workspace $bur)\n"  >> "$Devil/$nom_fich_reel.ds"; set_bur=1; } # Entète et
			echo -e "		(if ($loi (window_name) $title)" >> "$Devil/$nom_fich_reel.ds"				     #+ 1ère règle
			echo -e "			(geometry $geom))\n" >> "$Devil/$nom_fich_reel.ds"											 #
		}
		[ "$num_lign" -gt "1" ] && {																						 #
			echo -e "		(if ($loi (window_name) $title)" >> "$Devil/$nom_fich_reel.ds"			   # Sous-règles 
			[ ! "$bur" = "$defaut" ] && echo -e "			(set_workspace $bur)" >> "$Devil/$nom_fich_reel.ds"#+ suivantes
			echo -e "			(geometry $geom))\n" >> "$Devil/$nom_fich_reel.ds"											 # 
		}
	done
	echo "    )" >> "$Devil/$nom_fich_reel.ds"
	echo ")" >> "$Devil/$nom_fich_reel.ds"
	[ "$num_lign" = "1" ] && {				# Si qu'une seule règle pour l'application alors on efface les lignes génantes
		[ "$set_bur" = "1" ] && sed -i '2d; 9d' "$Devil/$nom_fich_reel.ds" || sed -i '2d; 7d' "$Devil/$nom_fich_reel.ds" #+ le '(begin'
	}																													 #+ et la  ')'
}																										 

creer_ds() { # On envoie chaque fichier 'classe d'app' contenant les données de dim + règles
	local i				# + à la création du fichier .ds final correspondant.
	cd $Devil			# On va travailler dans le dossier temporaire (balade)
	for i in *-; do
		parse_fich $i
	done	
}

fich_split() { 	# On éclate le fichier de récupération des données utilisateur, on concatène les données règles par application/fichier
	local i line nom_fich						#+ le 1er champ de chaque ligne est la classe d'application 
	for i in `seq 1 $(wc -l $yad_datas | awk '{print $1}')`; do 	#+ qui sera le nom du fichier .ds final
		line=$(sed -n "$i p" $yad_datas)
		nom_fich=$(echo $line | awk -v var="$sep" 'BEGIN {FS=var}; END {print $1}' | sed 's/ *//g')
		echo $line >> "$Devil/$nom_fich-"
	done
}

creer_fichs_regles() {		# Alors là, je me demande bien ce que c'est :D 
	fich_split
	creer_ds
	sauve_ds	
}

enleve_o() { 			# on enlève l'appendice '-o' pour réactiver les règles. Voir plus bas
	local a=$1
	a=${a%*-o}
	mv $1 $a
}

met_o() { 			# On met un appendice '-o' à l'extension du fichier règle pour le désactiver
	local a=$1 		#+ (plus de reconnaissance de l'extension .ds par devilspie)
	a="$a-o"
	mv $1 $a
}

activ_regles() {				# On enlève l'appendice '-o' aux fichiers ~/.devilspie/*.ds
	cd "$DOSS_CONF"				# Il faut le 'cd' en cas d'abandon aprés erreur parsing
	fich_ds_o=( $(ls *.ds-o 2>/dev/null) )
	[ -n "$fich_ds_o" ] && {												
		for i in `seq 0 $(( ${#fich_ds_o[@]}-1 ))`; do
			enleve_o ${fich_ds_o[$i]}	# Appel des fonctions met_o et enleve_o
		done
	}
	met_o debug.ds					# Et on met le '-o' à debug.ds qui devient debug.ds-o 
}							#+ debug.ds désactivé du coup ;)


desactiv_regles() {									# On met un appendice '-o' aux fichiers ~/.devilspie/*.ds
	[ ! -e "debug.ds" ] && [ ! -e "debug.ds-o" ] && echo "(debug)" > debug.ds	#+ sauf à debug.ds et si debug.ds l'a dejà, on l'enlève
	fich_ds=( $(ls *.ds 2>/dev/null | grep -v "debug.ds") )				#+ bref cf. activ_regles.
	debug=$(ls debug.ds-o  2>/dev/null)
	[ -n "${fich_ds[@]}" ] && {
		for i in `seq 0 $(( ${#fich_ds[@]}-1 ))`; do
			met_o ${fich_ds[$i]}						# Appel des fonctions met_o et enleve_o
		done
	}
	[ -n "$debug" ] && enleve_o $debug						# On ne veut que le fichier debug.ds comme règle active
}

inf_chop() {	# On chope les informations des fenêtres que 'devilspie -d' nous laisse dans devil_tmp (on ne lit que la dernière ligne)
	line=$(tail -n 1 $devil_tmp)																			#+ et on éclate les données
	win_class=$(echo $line | awk 'BEGIN {FS=";"}; END {print $3}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ '//g; s/'$//g")
	win_name=$(echo $line | awk 'BEGIN {FS=";"}; END {print $2}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ '//g; s/'$//g")
	win_title=$(echo $line | awk 'BEGIN {FS=";"}; END {print $1}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ '//g; s/'$//g")
	win_geom=$(echo $line | awk 'BEGIN {FS=";"}; END {print $4}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ //g")
}

yad_attente_appli() { 		# Pour attendre que l'application à gérer soit ouverte + accès HOW TO DO (1ére fenêtre du script à apparaître)
	yad --form --width 350 --window-icon $icon --title="Devil's Pie - IGEL - Attente" \
		--align=center \
		--buttons-layout=center \
		--field=" ":LBL "" \
		--field="<b>Attente de l'application à gérer ...</b>\n\nDémarrez l'application à configurer.\nEt cliquez sur <b>OK</b>":LBL "" \
		--field=" ":LBL "" \
		--button="How To Do":'bash -c "howtodo"' \
		--button="OK":0 \
		--button="Sortie":1
 	[ "$?" -eq 0 ] || sortie $ERR_SORTIE_YAD # Cette boite a une commande sous le bouton How To Do, appel de 'howtodo' cf. Export Fonction
}

yad_inf_fen() { # La boite de récupération/saisie des données fenêtres à gérer - Interactive grâce au --field=" ":FBTN commande
	inf_chop								# On va chercher les infos avant d'afficher
	yad --form --window-icon $icon --title="Devil's Pie - IGEL - Chope Infos" \
		--item-separator="$sep" \
		--buttons-layout=edge \
		--align=right \
		--field="<b>CLASSE</b>" "$win_class" \
		--field="<b>NOM</b>" "$win_name" \
		--field="<b>TITRE DE FENÊTRE</b>" "$win_title" \
		--field="<b>GÉMOTRIE</b>" "$win_geom" \
		--field="<b>BUREAU</b>":CB "$list_bur" \
		--field="<b>Consistance Règle</b>":CB "is$sep^contains" \
		--field=" ":LBL "" \
		--field="*-*-*-*  	<b>Attraper les données de la fenêtre</b>  	*-*-*-*":FBTN '@bash -c "xdoyad %1"' \
		--button="<b>Nouvelle Fenêtre OK</b>":0 \
		--button="<b>Créer Règles</b>":2 \
		--button="<b>Abandon</b>":1 \
		--field="Un clic sur '<u>Nouvelle Fenêtre OK</u>' confirme la règle et passe à la suivante.           ":LBL "" \
		--field="La nouvelle fenêtre doit être ouverte                                         ":LBL "" >> $yad_datas
								# Pareil une cmd sous un bouton, appel de la fonction 'xdoyad'
	res=$?
	case $res in
		0 ) yad_inf_fen ;;				# Récursivité de yad_inf_fen
		1 ) sortie $ERR_ABANDON_YAD ;;			#+
		2 ) creer_fichs_regles ;;			#+ le reste sort en créant ou pas les fichiers .ds
		* ) RETOUR=$ERR_CASE_YAD ;;			#+ selon le choix utilisateur ou les erreurs possibles
	esac
}

zen_abs_prog() {
	zenity --error --width 350 --window-icon $icon --title "Devil's Pie - IGEL - Prog. Abs." \
		--text "\nUn ou plusieurs de ces programmes manquent :\n\tdevilspie\n\twmctrl\n\txdotool\n\tyad\n"
	sortie $ERR_ABS_PROG
}
zen_abs_doss() {
	zenity --error --timeout 5 --width 350 --window-icon $icon --title "Devil's Pie - IGEL - Dossier Absent" \
		--text "\nAucun dossier de configuration !\n\nSortie du programme ..."
	sortie $ERR_ABS_DOSS
}

########## Fin Partie Fonction




########## PROGRAMME PRINCIPAL ##################################
								#
pres_devil=$(whereis devilspie | awk '{print $2}')		# Test de la présence de 'devilspie' 'wmcrtl' 'xdotool' et 'yad'
pres_wmctrl=$(whereis wmctrl | awk '{print $2}')		#
pres_xdotool=$(whereis xdotool | awk '{print $2}')		#
pres_yad=$(whereis yad | awk '{print $2}')			# Si il manque un seul logiciel, on sort.
[ -z $"pres_devil" -o -z "$pres_wmctrl" -o -z "$pres_xdotool" -o -z "$pres_yad" ] && zen_abs_prog

[ -d "${HOME}/.devilspie" ] && {
	DOSS_CONF=${HOME}/.devilspie				# On teste la présence du dossier d'installation
	DOSS_DEST="${HOME}/.devilspie/ds-igel"			# par défaut de devilspie
	[ -d "$DOSS_DEST" ] || mkdir "$DOSS_DEST"		# si oui on crée le dossier destination
} || zen_abs_doss

cd "$DOSS_CONF"							# On travaille dans ~/.devilspie pour désactiver les règles en cours.

defaut="Sur le Bureau où démarre l'application"			# Création liste bureaux pour yad : de la forme 1|2|...|^Defaut
nb_bur=$(wmctrl -d | wc -l)					# Comptage du nombre de bureaux.		avec sep=|
for i in `seq 1 $nb_bur`; do
	[ "$i" = "1" ] && list_bur=$i$sep || list_bur=$list_bur$i$sep	# Création de la liste - Pour 'yad', le séparateur par défaut est !
	[ "$i" = "$nb_bur" ] && list_bur=$list_bur"^"$defaut		#+ c'est un peu génant comme caractère d'où la varaible "sep"
done

desactiv_regles							# On désactive toutes les règles sauf le fichier debug.ds 
echo "sortie desactiv"						#+ il est créé s'il le faut
																	
[ -n "$(pgrep -f devilspie)" ] && killall devilspie		# On tue devilspie si il est présent (pour être tranquille)
								#+ ça vaudra un redémarrage de session (needed to activate new laws)
devilspie -d 2>/dev/null >> $devil_tmp &			# On relance devilspie en mode 'debug' et on log stdout dans devil_tmp
echo "devil lancé"
yad_attente_appli						# On attend que l'application soit lancée,
								#+ l'utilsateur le signale par un clic
yad_inf_fen							# On affiche les données récupérées dans la fenêtre
								#+ de création de règle.
sortie $RETOUR							# Et on sort par la petite porte après multiples
								#+ boucles dans les fonctions.
exit $ERR_INCONNUE_FIN_SCRIPT 			# Le script ne doit jamais passer par là !

Je pense que ça tiens la route. Il y aura toujours quelques probs et des améliorations.
En tout cas, c'est toujours mieux que d'éditer les règles à la main non ?
Et puis avec mon script, si tu fais bien le tour de toutes les fenêtres possibles de l'application que tu configures,
tu ne te retrouves pas avec, tout d'un coup, une fenêtre du genre "Céer un dossier" qui fait la taille de la fenêtre mère.
Ça m'est arrivé, j'avais abandonné devilspie car pas d'outils pour le manier !
Si j'y reviens c'est bien qu'il fait le taf !
Et si mon script me gave trop (trop rigide ou autre),j 'irais peut être voir du coté de Gdevilspie.
mais à ce que j'en ai lu, il à l'air plutôt compliqué à prendre en main, mais apparemmment, il couvrirait toutes les fonctions de devilspie.

Au plaisir.

lynn

Tawal a écritLe dossier ~/.devilspie doit exister ! Il est créé par l'installation de devilspie.

Pas chez moi... J'ai testé l'installation de devilspie sur Ubuntu 18.04, 20.04 et 21.04 et le résultat est le même. Le répertoire ~/.devilspie n'est pas créé après installation de devilspie.

Tawal a écrit - soit il est installé d'une manière "customisée" et donc TU dois savoir OÙ il doit aller lire ces fichiers.

Si tu entends installation customisée une installation réalisée par le biais d'un terminal

sudo apt install devilspie

alors oui, c'est une installation customisée. 😛

Quel S.E utilises-tu ?

lynn

Par acquis de conscience, j'ai refait la manip sur une Ubuntu 20.04 fraîchement installée et quand je tapes devilspie -d :

devilspie -d
Devil's Pie 0.23 starting...
Loading /etc/devilspie
/etc/devilspie doesn't exist
Loading /home/lynn/.devilspie
/home/lynn/.devilspie doesn't exist
0 s-expressions loaded.
No s-expressions loaded, quiting
lynn@Ubuntu-20.04:~$ ls

On peut voir que le répertoire situé dans le dossier personnel n'existe pas par défaut; Il n'est pas créé par l'installation de devilspie. C'est pourquoi dans ton ton script, il serait peut-être bon de vérifier la présence de celui ci et de le créer au besoin.

PS: Je n'avais pas bien fait attention mais le retour de ta commande devilspie -d confirme ce que j'écris au dessus... ton répertoire ~/.devilspie n'existe pas non plus :

Tawal a écritDevil's Pie 0.23 starting...
Loading /etc/devilspie
/etc/devilspie doesn't exist
Loading /home/tawal/.devilspie
/home/tawal/.devilspie doesn't exist
0 s-expressions loaded.
No s-expressions loaded, quiting

Tu disais quoi sur l'installation customisée..? :lol:

Tawal

Bonjour,

En effet, ça me revient, c'est moi qui a crée le ~/.devilspie
C'était indiqué sur un site concernant l'installation de devilspie (peut être Debian Wiki, je sais plus)

Donc, je regarde pour l'existence du dossier et sa création en cas d'absence. OK

lynn a écritPS: Je n'avais pas bien fait attention mais le retour de ta commande devilspie -d confirme ce que j'écris au dessus... ton répertoire ~/.devilspie n'existe pas non plus :

Non, non, il existe mais je l'avais renommé pour tests. Mais forcément, Devilspie ne tournait pas et ne loggait aucune apparition de fenêtres.

Ensuite, j'ai une nouvelle version plus ergonomique/intuitive :
- Le clic sur "Nouvelle Fenêtre OK" ne ferme plus la boite yad d'infos sur les dim et pos de la fenêtre mais enregistre toujours la règle affichée avant le clic
- Du coup, on se sent moins perdu sans cette boite yad qui bouge tout le temps (fermeture et réapparition ça c'est fini 😉 )
Je ne poste pas de suite cette version, je regarde pour le dossier ~/.devilspie.

Pour ce qui est de mon S.E, je suis sur Debian 10 stable Xfce
Alors en effet, il peut y avoir quelques différences.

Merci de tes tests et investigations 🙂

Edit: Pour moi, une installation "customisée", c'est quand tu changes des paramètres dans les fichiers conf de l'appli.
Et une console t'en diras toujours plus qu'une appli graphique. C'est pour moi, une des meilleures méthodes d'installation de paquets ... fin bref.

Editt2: Je crois que je suis amoureux d'Edith ^^.
Non SERIEUX, il y avait une erreur dans le dernier post du script : un # s'était collé à la fin d'une ligne après le remaniement mise en page. C'est corrigé.

Edit3: mmm Edith ....
Présence du dossier ~/.devilspie FAIT
Par contre, j'ai toujours laissé l'enregistrement des règles dans le dossier ~/.devilspie/ds-igle. Pourquoi :
- Les fichiers de règles nouvelles ne peuvent être actifs qu'après un redémarrage session.
- Si des fichiers de règles sont déjà existants et portent le même nom que le fichier de règle qui va être créé, il y aura écrasement !
(je n'arrive pas à retrouver un prompt pour avoir une confirmation de l'user, d'où le forcing à la copie)

PS : citation de Wiki Ubuntu

Wiki Ubuntu a écritCréer un répertoire caché /.devilspie dans votre Dossier Personnel (si vous préférez le terminal : mkdir ~/.devilspie).

Tawal

Hello,

Y'a du neuf !

Une nouvelle version plus ergonomique !

Détection des programmes nécessaires.
Détection de la présence du dossier ~/.devilspie

Le script gère maintenant le redémarrage de Devil's Pie (sans déconnexion de session) avec les nouvelles règles ou bien les anciennes au choix.
On a aussi le choix de ne pas démarrer Devil's Pie.
Même en cas de Sortie dès la 1ere boite ou d'abandon dans la 2eme, on sera invité à démarrer Devil's Pie ou non. (forcément avec les anciennes règles vu qu'il n'y en a pas de nouvelles créées)
Si on choisi de "Créer les nouvelles règles", un avertissement apparaît pour prévenir que les fichiers dans ~/.devilspie/ds-igel risquent d'êtres écrasés.
Ensuite, on est invité à "Démarrer avec les nouvelles règles" où on est prévenu du risque d’écrasement des fichiers dans ~/.devilspie.

Coté Ergonomie :
La boite de données de dimension et position de la fenêtre ne se referme plus à l'appui sur "Nouvelle Fenêtre OK".
Ce qui fait qu'elle ne se balade plus de droite à gauche (de haut en bas aussi ^^) lors de sa réapparition (elle se ferme plus, elle réapparaît pas, elle reste en place).
Le clic sur ce bouton enregistre toujours la règle affichée avant le clic et passe à la fenêtre suivante (qui doit être ouverte juste avant le clic).

Voici le script :

#!/bin/bash

###############################################################################
#
# Nom : DevilsPie-IGEL	-	Devil's Pie Interface Graphique Extra Légère
#
# Commande : DevilsPie-IGEL
#
# Arguments : Aucuns
# Options : Aucunes
#
# Nécéssite : devilspie   wmctrl   xdotool   yad   zenity
#								     par Tawal.
###############################################################################

RETOUR=0			# Code de retour si tout se passe bien

ERR_SORTIE_YAD=64		# Sortie utilisateur 1ere boite (attente_appli)
ERR_ABANDON_YAD=65		# Sortie utilisateur 2eme boite (yad_inf_fen)
ERR_NON_LANCE=66		# Retour si l'user ne veut pas demarrer devilspie
ERR_NO_TRANSFER=67		# Retour si l'user demarre devilspie sur ses anciennes règles
ERR_ABS_PROG=71			# Retour si un prog nécéssaire manque
ERR_PARSING_CONTINUE=80		# Retour zenity erreur parsing (ou split fichier) et utilisateur continue
ERR_PARSING_STOP=81		# Retour zenity erreur parsing (ou split fichier) des fichiers de règles et abandon utilisateur
ERR_CASE_ZENITY=91		# Code retour si case "reponse zenity erreur parsing" a échoue - Très peu probable mais bon
ERR_CASE_YAD=92			# Idem qu'au dessus mais pour yad_inf_fen - Très peu probable aussi
ERR_CASE_DEMAND=93		# Idem qu'au dessus mais pour demande_dem_devilspie - Très peu probable aussi
ERR_CASE_SORTIE=94		# Idem qu'au dessus mais pour sortie (après demande_dem_devilspie) - Très peu probable aussi
ERR_INCONNUE_FIN_SCRIPT=113	# Exit à la fin du script où il ne devrait jamais passer !




# Création du dossier temporaire Devil et des fichiers temporaires devil_tmp et yad_datas
Devil=$(mktemp -d /tmp/Devil-XXXXXXXXXXXXXXXX)	#+ (du moins les chemins sont contenus dans ces variables)
devil_tmp=$(mktemp -p $Devil devil_tmp-XXX)	# Gestion de l'effacement du dossier et des fichiers temporaires
yad_datas=$(mktemp -p $Devil yad_datas-XXX)	#+ par le 'trap rm' ci-après : un peu trop de signaux trapés ?
trap "rm -rf $Devil $devil_tmp $yad_datas" TERM INT ABRT HUP QUIT EXIT 	
						# TERM=15 INT=Ctrl+C ABRT=Abort HUP=Par.Proc.Mort QUIT=Crtl+D

ORIGIN=$(pwd)			# Sauvegarde de l'endroit d'où on vient, on va se ballader un peu
											
sep='|'				# Définition du séparateur pour 'yad' et pour les champs de 'awk' et ...
export icon=/usr/share/icons/Tango/32x32/apps/xfce4-session.png

export devil_tmp yad_datas	# Vont être utilsées par la fonction exportée 'inf_chop' et 'inf_nouv_nf'
				# + elles ont besoin de "voir" les variable devil_tmp et yad_datas



########### Fonctions à exporter pour éviter un script extérieur ########################################
#	Toutes ces fonctions sont dans un sous shell crée par les commandes sous les boutons de 'yad'	  #

howtodo() {
	zenity --info --width 450 --window-icon $icon --title "Devil's Pie - IGEL - How To Do" \
		--text "\t\t\t\t  <u><b>HOW TO DO</b></u>\n\n\t- Ouvrez l'application à gérer et cliquez sur <b>OK</b>.\n\n\t- Redimensionnez et positionnez la fenêtre.\n\n\t- Puis cliquez sur <b>Attraper les données de la fenêtre</b>.\n\n\t- Sélectionnez le Bureau, puis\n\n\t- <u>Ouvrez une nouvelle fenêtre</u> à gérer.\n\n\t- Et cliquez sur <b>Nouvelle Fenêtre OK</b>.\n\n\t- Recommencez l'opération etc ...\n\n\t- Puis cliquez sur <b>Créer Règles</b> quand vous avez fini.\n\n\n<i>Le bouton <b>Attraper les données de la fenêtre</b> ne sauvegarde pas la règle qui s'affiche, celle-ci l'est lorsque vous passez à la fenêtre suivante ou que vous créez les règles.\n\nParcourrez une à une <u>toutes</u> les fenêtres de l'application en suivant la procédure ci-dessus.\n\nToutes les données sont modifiables !\nIl est conseillé de ne changer ni le nom ni la classe d'application.\nSurveillez bien les titres de fenêtres, car ils sont très restrictifs !\n\nChoisisez '<u>is</u>' pour un titre de fenêtre inchangeant.\nOptez pour '<u>contains</u>' pour un titre modifié de fenêtre.\n\nVous pouvez garder cette fenêtre ouverte pendant les opérations.</i>"
}

xdoyad() { 			# Capture des données fenêtre après redimensionnement et retour à 'yad' des données par les 'echo'
	local geom="" pos="" title="" totwinstack chope
	totwinstack=$(xdotool search --onlyvisible --classname "$1" getwindowname %@ 2>/dev/null | wc -l)
	chope=$(xdotool search --onlyvisible --classname "$1" getwindowgeometry %$totwinstack  getwindowname %$totwinstack 2>/dev/null)
	posxdo=( $(echo $chope | awk '{print $4}' | sed 's/,/ /g') )
	X=$((${posxdo[0]}-10)); Y=$((${posxdo[1]}-38))		# Rattrapage de la différence entre Devilspie et Xdotool (approx. quoique)
	pos="+"$X"+"$Y
	geom=$(echo $chope | awk '{print $8}')
	title=$(echo "$chope" | awk 'BEGIN {$1=""; $2=""; $3=""; $4=""; $5=""; $6=""; $7=""; $8=""}; END {print $N}' | sed 's/^ *//g')
	[ -z "$title" ] && zenity_pas_de_fen  && xdoyad $1     		# Appel de la fonction zenity_pas_de_fen + récursivité de 'xdoyad'
	echo "3:$title"
	echo "4:${geom}${pos}"
}

inf_chop() {	# On chope les informations des fenêtres que 'devilspie -d' nous laisse dans devil_tmp (on ne lit que la dernière ligne)
	line=$(tail -n 1 $devil_tmp)									#+ et on éclate les données
	win_class=$(echo $line | awk 'BEGIN {FS=";"}; END {print $3}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ '//g; s/'$//g")
	win_name=$(echo $line | awk 'BEGIN {FS=";"}; END {print $2}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ '//g; s/'$//g")
	win_title=$(echo $line | awk 'BEGIN {FS=";"}; END {print $1}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ '//g; s/'$//g")
	win_geom=$(echo $line | awk 'BEGIN {FS=";"}; END {print $4}' | awk 'BEGIN {FS=":"}; END {print $2}' | sed "s/^ //g")
	[ -n "$1" ] && {
		eval $1=\$win_class
		eval $2=\$win_name
		eval $3=\$win_title
		eval $4=\$win_geom
	}
}

inf_nouv_fen() {					
	echo "$1|$2|$3|$4|$5|$6" >> "$yad_datas"	# On enregistre la règle créée par l'user et
	inf_chop nf_class nf_name nf_title nf_geom 	# on chope les infos de la nouvelle fenêtre et
	echo "1:$nf_class"			
	echo "2:$nf_name"				# on renvoie à yad les données par les echo
	echo "3:$nf_title"
	echo "4:$nf_geom"
	echo "5:$list_bur"
	echo "6:$list_loi"
}

zenity_pas_de_fen() { 	# Gestion par la fonction 'xdoyad' en cas si la fenêtre n'est pas trouvée et appel affichage ici
	zenity --info --width 350 --window-icon $icon --title "Devil's Pie - IGEL - Pas Trouvé !" \
			--text "Réouvrez la fenêtre, cliquez sur <b>Valider</b>\n\npuis sur <b>Attraper les données de la fenêtre</b>"
}

export -f howtodo
export -f xdoyad 				# Export des fonctions (elles agissent dans un|des sous-shell|s)
export -f inf_nouv_fen  
export -f zenity_pas_de_fen
export -f inf_chop
######### Fin Export ##################################################################################################






################################### PARTIE FONCTIONS ##################################################################


sortie() {
	killall devilspie
	case $1 in
		0|64|65|80 ) activ_regles ;;
			 * ) ;;
	esac
	lance=pass
	case $1 in
		 0|80 ) demande_dem_devilspie ;;		# on demande si l'user veut demarrer devilspie
		64|65 ) demande_dem_devilspie abort;;
		    * )  ;;
	esac
	case $lance in
		nada ) RETOUR=$ERR_NON_LANCE ;;
		oui  ) trans_et_dem ;;
		non  ) just_dem ;;
		pass ) ;;
		   * ) RETOUR=$ERR_CASE_SORTIE
	esac
	cd $ORIGIN
	exit $1
}

transfer() {
	mv -f $DOSS_DEST/*.ds $DOSS_CONF
	poudreauxyeux
}

trans_et_dem() {
	RETOUR=0
	transfer
	devilspie &
	disown %1
}

just_dem() {
	RETOUR=$ERR_NO_TRANSFER
	devilspie &
	disown %1
}

demande_dem_devilspie() {
	[ -z "$1" ] && {
		yad --form --width 450 --window-icon $icon --title "Devil's Pie - IGEL - Lancer Devil's Pie ?" \
			--align=center \
			--buttons-layout=spread \
			--field=" ":LBL "" \
			--field="Voulez-vous lancer Devil's Pie avec les nouvelles règles ?":LBL "" \
			--field=" ":LBL "" \
			--field="Si <b>OUI</b> les nouvelles règles seront :":LBL "" \
			--field="\t- copiées dans le dossier ${HOME}/.devilspie":LBL "" \
			--field="\t- avec un risque d'écrasement des fichiers déjà existant !":LBL "" \
			--field=" ":LBL "" \
			--field="Si <b>NON</b> Devil's Pie sera lancé avec les règles déjà exixtantes":LBL "" \
			--button="Ne Pas Lancer":0 \
			--button="     OUI     ":1 \
			--button="     NON     ":2
		res="$?"
		case $res in
			0 ) lance="nada" ;;
			1 ) lance="oui" ;;
			2 ) lance="non" ;;
			* ) sortie $ERR_CASE_DEMAND ;;
		esac
	} || {
		yad --form --width 450 --window-icon $icon --title "Devil's Pie - IGEL - Lancer Devil's Pie ?" \
			--align=center \
			--buttons-layout=center \
			--field=" ":LBL "" \
			--field="Devil's Pie et vos règles sont désactivées":LBL "" \
			--field="Voulez-vous réactiver et les règles et Devil's Pie ?":LBL "" \
			--field=" ":LBL "" \
			--button="OUI":0 \
			--button="NON":1
		[ "$?" -eq 0 ] && lance="non" || lance="nada"
	}
}

poudreauxyeux() {
	for n in `seq 1 100`; do 	
		echo $n
		sleep 0.005
	done | zenity --progress --window-icon $icon --auto-close --no-cancel --title "Devil's Pie - IGEL - Copie" --text "\nCopie des fichiers ..." 
}

err_parsing() { 					# Gestion de l'erreur dans le parsing ...
	mess=""; mess2=""; mess3=""			#+ N'arrivera pas à mon avis, j'ai du créer les erreurs à la main
	[ "$3" -gt "1" ] && {				#+ sur les fichiers temporaires.
		mess="<u>sans importance</u>"
		mess2="dans une sous-règle."
		mess3="Elle ne 'matchera' pas, mais laissera le reste fonctionner."
	} || {
		mess="<u><b>GRAVE</b></u>"
		mess2="dans l'entête de fichier !"
		mess3="Ce fichier de règles ne fonctionnera pas.\nMais il peut être récupéré manuellement, il sera créé en continuant."
	}
	zenity --question --title "Devil's Pie - IGEL - ERREUR !" \
		--window-icon $icon --width 450 \
		--ok-label "OUI" --cancel-label "NON" \
		--text "\nUne erreur $mess est survenue lors de la création d'un fichier .ds\nLe fichier <b>$nom_fich_reel.ds</b> comporte le nom <u>$nom_fich_lu</u> en classe d'application $mess2\n\n$mess3\n\nVoulez-vous tout de même créer le fichier\Cliquer sur 'NON' et aucun fichier ne sera créé !"
	res=$?
	case $res in 
		0 ) RETOUR=$ERR_PARSING_CONTINUE ;;
		1 ) sortie $ERR_PARSING_STOP ;;
		* ) RETOUR=$ERR_CASE_ZENITY ;;
	esac
}

sauve_ds() { 				# On transfère les fichiers finaux du dossier temporaire au dossier DOSS_DEST
	local fich n=0 tab
	for fich in *.ds; do  		# Création d'un tableau ( fich1 fich2... DossierDest )
		tab[$n]=$fich
		n=$((n+1 ))
	done
	tab[$n]=$DOSS_DEST
	cp -f ${tab[@]}			# Copie des fichiers définitifs des règles (1 fichier par classe d'application)#+ en forcing et à la volée !!!
	poudreauxyeux			# Pour l'effet
	cd $OLDPWD			# Je l'avais dit : de la balade suivez le chemin ^^
}
 
parse_fich() { # On crée le fichier final de règles. On extrait les données dim + loi ligne par ligne. + Gestion structure fichier final
	local num_lign app title geom class gui='"'
	for num_lign in `seq 1 $(wc -l $1 | awk '{print $1}')`; do
		nom_fich_reel=$1
		nom_fich_reel=${nom_fich_reel%*-} # On ôte le tiret '-' à nom_fich_reel pour bien matcher avec la class d'appli. et on l' utilise en
		nom_fich_lu=$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $1}' | sed 's/ *//g')   #+ nom de fich. final
		[ ! "$nom_fich_lu" = "$nom_fich_reel" ] && err_parsing $nom_fich_lu $nom_fich_reel $num_lign  # Teste si le nom du fichier 
		class='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $1}')'"'   #+ lu dans la ligne
		app='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $2}')'"'     #+ correspond à celui du fichier réel
		title='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $3}')'"'   #+ Appel de la fonction err_parsing
		geom='"'$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $4}')'"'
		bur=$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $5}')
		loi=$(sed -n "$num_lign p" $1 | awk -v var="$sep" 'BEGIN {FS=var}; END {print $6}')
		[ "$num_lign" = "1" ] && { 	 # C'est ici qu'on écrit vraiment les règles, 1 tour boucle = 1 ligne lue et éclatée = une règle 
			echo -e "(if (and (is (window_class) $class) (is (application_name) $app))" > "$Devil/$nom_fich_reel.ds"
			echo -e "	(begin\n" >> "$Devil/$nom_fich_reel.ds"
			[ ! "$bur" = "$defaut" ] && { echo -e "		(set_workspace $bur)\n"  >> "$Devil/$nom_fich_reel.ds"; set_bur=1; }
			echo -e "		(if ($loi (window_name) $title)" >> "$Devil/$nom_fich_reel.ds"			# Entète et
			echo -e "			(geometry $geom))\n" >> "$Devil/$nom_fich_reel.ds"			#+ 1ère règle
		}
		[ "$num_lign" -gt "1" ] && {
			echo -e "		(if ($loi (window_name) $title)" >> "$Devil/$nom_fich_reel.ds"			# Sous-règles 
			[ ! "$bur" = "$defaut" ] && echo -e "			(set_workspace $bur)" >> "$Devil/$nom_fich_reel.ds" 
			echo -e "			(geometry $geom))\n" >> "$Devil/$nom_fich_reel.ds"			#+ suivantes
		}
	done
	echo "    )" >> "$Devil/$nom_fich_reel.ds"
	echo ")" >> "$Devil/$nom_fich_reel.ds"
	[ "$num_lign" = "1" ] && {			# Si qu'une seule règle pour l'application alors on efface les lignes génantes
		[ "$set_bur" = "1" ] && sed -i '2d; 9d' "$Devil/$nom_fich_reel.ds" || sed -i '2d; 7d' "$Devil/$nom_fich_reel.ds" 
	}												#+ le '(begin'  et la  ')'
}																										 

creer_ds() { # On envoie chaque fichier 'classe d'app' contenant les données de dim + règles
	local i				# + à la création du fichier .ds final correspondant.
	cd $Devil			# On va travailler dans le dossier temporaire (balade)
	for i in *-; do
		parse_fich $i
	done	
}

fich_split() { 	# On éclate le fichier de récupération des données utilisateur, on concatène les données règles par application/fichier
	local i line nom_fich						#+ le 1er champ de chaque ligne est la classe d'application 
	for i in `seq 1 $(wc -l $yad_datas | awk '{print $1}')`; do 	#+ qui sera le nom du fichier .ds final
		line=$(sed -n "$i p" $yad_datas)
		nom_fich=$(echo $line | awk -v var="$sep" 'BEGIN {FS=var}; END {print $1}' | sed 's/ *//g')
		echo $line >> "$Devil/$nom_fich-"
	done
}

avertissement() {
	zenity --info --width 350 --window-icon $icon --title "Devil's Pie - IGEL - Avertissement" \
			--text "\n\tLes fichiers présents dans\n\n<b>${HOME}/.devilspie/ds-igel</b>\n\n\tseront <b><u>écrasés</u></b> !"
}

creer_fichs_regles() {		# Alors là, je me demande bien ce que c'est :D
	avertissement
	fich_split
	creer_ds
	sauve_ds	
}

enleve_o() { 			# on enlève l'appendice '-o' pour réactiver les règles. Voir plus bas
	local a=$1
	a=${a%*-o}
	mv $1 $a
}

met_o() { 			# On met un appendice '-o' à l'extension du fichier règle pour le désactiver
	local a=$1 		#+ (plus de reconnaissance de l'extension .ds par devilspie)
	a="$a-o"
	mv $1 $a
}

activ_regles() {				# On enlève l'appendice '-o' aux fichiers ~/.devilspie/*.ds
	cd "$DOSS_CONF"				# Il faut le 'cd' en cas d'abandon aprés erreur parsing
	fich_ds_o=( $(ls *.ds-o 2>/dev/null) )
	[ -n "${fich_ds_o[0]}" ] && {												
		for i in `seq 0 $(( ${#fich_ds_o[@]}-1 ))`; do
			enleve_o ${fich_ds_o[$i]}	# Appel des fonctions met_o et enleve_o
		done
	}
	met_o debug.ds					# Et on met le '-o' à debug.ds qui devient debug.ds-o 
							#+ debug.ds désactivé du coup ;)
}


desactiv_regles() {									# On met un appendice '-o' aux fichiers ~/.devilspie/*.ds
	[ ! -e "debug.ds" ] && [ ! -e "debug.ds-o" ] && echo "(debug)" > debug.ds	#+ sauf à debug.ds et si debug.ds l'a dejà, on l'enlève
	fich_ds=( $(ls *.ds 2>/dev/null | grep -v "debug.ds") )				#+ bref cf. activ_regles.
	debug=$(ls debug.ds-o  2>/dev/null)
	[ -n "${fich_ds[0]}" ] && {
		for i in `seq 0 $(( ${#fich_ds[@]}-1 ))`; do
			met_o ${fich_ds[$i]}						# Appel des fonctions met_o et enleve_o
		done
	}
	[ -n "$debug" ] && enleve_o $debug						# On ne veut que le fichier debug.ds comme règle active
}

yad_attente_appli() { 	# Pour attendre que l'application à gérer soit ouverte + accès HOW TO DO (1ére fenêtre du script à apparaître)
	yad --form --width 350 --window-icon $icon --title="Devil's Pie - IGEL - Attente" \
		--align=center \
		--buttons-layout=center \
		--field=" ":LBL "" \
		--field="<b>Attente de l'application à gérer ...</b>\n\nDémarrez l'application à configurer.\nEt cliquez sur <b>OK</b>":LBL "" \
		--field=" ":LBL "" \
		--button="How To Do":'bash -c "howtodo"' \
		--button="OK":0 \
		--button="Sortie":1
 	[ "$?" -eq 0 ] || sortie $ERR_SORTIE_YAD 
}					# Cette boite a une commande sous le bouton How To Do, appel de 'howtodo' cf. Export Fonction

yad_inf_fen() { # La boite de récupération/saisie des données fenêtres à gérer - Interactive grâce au --field=" ":FBTN commande
	inf_chop								# On va chercher les infos avant d'afficher
	yad --form --window-icon $icon --title="Devil's Pie - IGEL - Chope Infos" \
		--item-separator="$sep" \
		--buttons-layout=edge \
		--align=right \
		--field="<b>CLASSE</b>" "$win_class" \
		--field="<b>NOM</b>" "$win_name" \
		--field="<b>TITRE DE FENÊTRE</b>" "$win_title" \
		--field="<b>GÉMOTRIE</b>" "$win_geom" \
		--field="<b>BUREAU</b>":CB "$list_bur" \
		--field="<b>Consistance Règle</b>":CB "$list_loi" \
		--field=" ":LBL "" \
		--field="*-*-*-*  	<b>Attraper les données de la fenêtre</b>  	*-*-*-*":FBTN '@bash -c "xdoyad %1"' \
		--field="Un clic sur '<u>Nouvelle Fenêtre OK</u>' enregistre la règle et passe à la suivante.":LBL "" \
		--field="La nouvelle fenêtre doit être ouverte                              ":LBL "" \
		--field="<b>Nouvelle Fenêtre OK</b>":FBTN '@bash -c "inf_nouv_fen %1 %2 %3 %4 %5 %6"' \
		--button="<b>Créer Règles</b>":2 \
		--button="<b>Abandon</b>":1 >> $yad_datas
		
	res=$?							# Pareil 2 comandes sous 2 boutons, appel de la fonction 'xdoyad'
	case $res in										#+ appel de la fonction inf_nouv_fen
		1 ) sortie $ERR_ABANDON_YAD ;;			# Soit on sort par volonté (Abandon)
		2 ) creer_fichs_regles ;;			#+ soit ont en créant les règles (Créer Règles)
		* ) RETOUR=$ERR_CASE_YAD ;;			#+ ou pire le case a planté !
	esac
}

zen_abs_prog() {						# Boite si un prog manque et on sort ensuite
	zenity --error --width 350 --window-icon $icon --title "Devil's Pie - IGEL - Prog. Abs." \
		--text "\nUn ou plusieurs de ces programmes manquent :\n\tdevilspie\n\twmctrl\n\txdotool\n\tyad\n"
	sortie $ERR_ABS_PROG
}
########## Fin Partie Fonction




########## PROGRAMME PRINCIPAL ###############
								                              #
pres_devil=$(which devilspie)		                              # Test de la présence de 'devilspie' 'wmcrtl' 'xdotool' et 'yad'
pres_wmctrl=$(which wmctrl)		                                      #
pres_xdotool=$(which xdotool)		                              #
pres_yad=$(which yad)			                                      # Si il manque un seul logiciel, on sort.
[ -z $"pres_devil" -o -z "$pres_wmctrl" -o -z "$pres_xdotool" -o -z "$pres_yad" ] && zen_abs_prog

[ -d "${HOME}/.devilspie" ] && {				              # On teste la présence du dossier d'installation
	DOSS_CONF=${HOME}/.devilspie			      # par défaut de devilspie
	DOSS_DEST="${HOME}/.devilspie/ds-igel"		      #
	[ -d "$DOSS_DEST" ] || mkdir "$DOSS_DEST"	      # si oui on crée le dossier destination
} || {
	mkdir ${HOME}/.devilspie				              # si non on crée les dossiers ~/.devilspie et
	mkdir ${HOME}/.devilspie/ds-igel			              #+ le dossier ~/.devilspie/ds-igel
	DOSS_CONF="${HOME}/.devilspie"
	DOSS_DEST="${HOME}/.devilspie/ds-igel"
}

cd "$DOSS_CONF"							       # On travaille dans ~/.devilspie pour désactiver les règles en cours.

defaut="Sur le Bureau où démarre l'application"		       # Création liste bureaux pour yad : de la forme 1|2|...|^Defaut
nb_bur=$(wmctrl -d | wc -l)					               #+ Comptage du nombre de bureaux.		avec sep=|
for i in `seq 1 $nb_bur`; do					               #
	[ "$i" = "1" ] && list_bur=$i$sep || list_bur=$list_bur$i$sep
	[ "$i" = "$nb_bur" ] && list_bur=$list_bur"^"$defaut        #+ Création de la liste - Pour 'yad', le séparateur par défaut est !
done 								                       #+ c'est un peu génant comme caractère d'où la varaible "sep"
list_loi="is$sep^contains"

export list_bur list_loi 

desactiv_regles							                # On désactive toutes les règles sauf le fichier debug.ds 
								                                #+ il est créé s'il le faut
																	
[ -n "$(pgrep -f devilspie)" ] && killall devilspie		        # On tue devilspie si il est présent (pour être tranquille)
								                                #

devilspie -d 2>/dev/null >> $devil_tmp &			        # On relance devilspie en mode 'debug' et on log stdout dans devil_tmp

yad_attente_appli						                        # On attend que l'application soit lancée,
								                                #+ l'utilsateur le signale par un clic
yad_inf_fen						                        	# On affiche les données récupérées dans la fenêtre
								                                #+ de création de règle.
sortie $RETOUR							                # Et on sort par la petite porte après multiples
								                                #+ boucles dans les fonctions.
exit $ERR_INCONNUE_FIN_SCRIPT 		# Le script ne doit jamais passer par là !

Bien à vous, au plaisir ...
pour les fautes d'orthographe, ne soyez pas trop criard, signalez les simplement.

Edit: [sup] elle prend cher Edith [/sup]
Ce que je n'ai pas dit, c'est qu'il n'y a plus de récursivité de la fonction principale (celle qui affiche les données fenêtre)
Du coup, c'est plus léger en CPU et ça ma fait sauter quelques fonctions donc un peu moins de RAM consommée.

Edit: Modif Test Présence Prog Nécessaires

Tawal

Plop, plop

Dernier post sur ce sujet (à moins que ...)

Donc la dernière version est dans le post au dessus.
Pour moi, elle est aboutie, elle fait ce que je lui demande.
Et elle n'est pas si déroutante à utiliser, même agréable je dirais.

J'ai fait un petit "Lisez-moi" plus complet que que le "How To Do" embarqué.
Le voici pour ceux qui voudraient savoir comment l'utiliser correctement :

Devil's Pie Interface Graphique Extra Légère


Comment Faire :

	- Donnez les droits d'exécution au fichier DevilsPie-IGEL.
		Dans un terminal : chmod +x DEvilsPie-IGEL

	- Ensuite entrez la commande suivante pour lancer Devil's Pie I.G.L.E.
		Dans un terminal : DevilsPie-IGEL
	- Ou créez un lanceur.

	- Un 1ère fenêtre apparaît vous demandant d'ouvrir l'application à gérer.
	- Ouvrez l'application désirée.
	
	- Cliquez sur OK dans la fenêtre DevilsPie-IGEL.
	- Une nouvelle fenêtre s'ouvre avec les propriétés de la fenêtre de l'application.
		- Le nom de la classe d'application
		- le nom de l'application
		- le titre de la fenêtre
		- les dimensions et position de la fenêtre

	- Manipulez votre fenêtre d'application pour la postionner et la dimensionner.

	- Cliquez sur "Attraper les données de la fenêtre".
		il est possible d'"Attraper les données" de la fenêtre plusieurs fois,
		cela n'engendre pas de règles.
		Elle sera engendrée à l'appui sur "Nouvelle Fenêtre OK".
		Mais ce sera les dernières données qui serviront à la règle.

	- Choisissez le bureau sur lequel vous voulez que l'application démarre.
		1 = Bureau 1	2 = Bureau 2	 etc ....
		Le choix "Sur le Bureau où démarre l'application" laisse 
			votre application s'afficher sur le bureau actuel.

	- Choisssez la consistance de la règle à appliquer : "is" ou "contains"
		is : la correspondance avec le titre de la fenêtre doit être EXACTE (le titre est XXXXX).
		contains : le titre de la fenêtre contient la chaine de caractère XXXXX.
			Beaucoup de titres fenêtre d'application sont interactifs avec leur contenu.
			Par exemple : "Lisez-moi - Mousepad" est le titre de ma fenêtre actuelle.
				Donc si je veux contrôler cette fenêtre d'une manière générale.
					(sans prendre en compte que ce soit lisez- moi ou un autre document)
				Je choisi la consistance "contains"
					ET je MODIFIE LE TITRE DE LA FENÊTRE en conséquence.
					( j'enlève "Lisez-moi - " et je laisse "Mousepad" dans le champ de titre.)
				Si, au contraire, je veux contrôler cette fenêtre précisément,
					je choisi "is" et je laisse le titre intact.

	- Ne changez pas le nom d'application ni la classe. IMPORTANT

	- Une fois les réglages de dimension, position, 
		choix de bureau, choix de consistance
		et changement ou non du titre faits,
	- OUVREZ UNE NOUVELLE FENÊTRE

	- Cliquez sur "Nouvelle Fenêtre OK".

	 - Les nouvelles informations apparaissent, recommencez la procédure.
		Attraper les données.
		Dimensionnement, Positionnement, choix Bureau,
			choix Consistance et modification Titre.
		Ouvrir une nouvelle fenêtre.
		Cliquer sur "Nouvelle Fenêtre OK".

	- Parcourez ainsi TOUTES les fenêtres de votre application.

	- quand toutes les fenêtres ont été parcourues,
		cliquez sur "Créer Règles" et laissez vous guider.

	- Il se peut que l'application utilise un programme extérieur.
		ce n'est pas grave, un fichier à son nom sera créé,
		mais il faudra peut-être soit désactiver ce fichier (supprimer)
		soit contrôler cette nouvelle application entièrement avec DevilsPie-IGEL.

Que Fait Exactement DevilsPie-IGEL :

	- DevilsPie-IGEL considère la 1ère fenêtre d'une application
		comme étant la fenêtre mère.
		il prend les informations :
			Classe d'application,
			Nom d'application,
			Titre de Fenêtre (modifié ou pas),
			Géométrie,
			Bureau et
			Loi
	pour créer la première règle du fichier de la forme :
-----------------------------------------------------------------------------------------

(if (and (is (window_class) "CLASSE APPLICATION") (is (application_name) "NOM APPLICATION"))

		(set_workspace N)	<--------------------selon le choix fait pour le bureau
									(n'apparaît pas si aucun choix)
		(if (LOI (window_name) "TITRE FENÊTRE (modifié ou pas")  <-LOI est le choix
			(geometry "DIM+POS"))                                                    entre "is" et "contains"

)
-----------------------------------------------------------------------------------------

	- Ensuite si d'autres règles pour des fenêtres
		ayant le même nom d'application sont trouvées (saisies par l'utilsateur)
		il les rajoute au fichier de la façon suivante :
-----------------------------------------------------------------------------------------


(if (and (is (window_class) "CLASSE APPLICATION") (is (application_name) "NOM APPLICATION"))
	(begin

		(set_workspace N)

		(if (LOI (window_name) "TITRE FENÊTRE (modifié ou pas")
			(geometry "DIM+POS"))

		(if (LOI2 (window_name) "TITRE FENÊTRE 2 (modifié ou pas")  <---2ème règle
			(set_workspace N2)                                                <--------n'apparaît pas si 
			(geometry "DIM2+POS2"))                                           pas de choix de Bureau
	)
)
-----------------------------------------------------------------------------------------

Et ainsi de suite jusqu'à épuisement des règles à ajouter.

Ce qu'il faut comprendre dans cette structure,
c'est que l'application assujétie l'est tout d'abord par sa Classe et son Nom.
Ensuite le 1er choix de bureau assujéti aussi toute l'application,
il n'est pas nécéssaire de choisir le bureau pour toutes les fenêtres
à partir du moment où il a été choisi pour la 1ère fenêtre.
Certaines fenêtres ne sont pas séparables de leur fenêtres mère.
Par exemple, n'essayez pas de faire afficher les "préférences" d'une application
sur un autre bureau que celui de l'application.
CA NE MARCHE PAS !

Il est possible fabriquer des règles pour plusieurs applications en 1 fois.
Pour se faire, il suffit quand on a fini avec une application
d'ouvrir une nouvelle application et de cliquer sur "Nouvelle Fenêtre OK"
Et pas sur "Créer Règles" qui fini la prospection
et enregistre les fichiers règles précédemment saisis.

Un dossier ~/.devilspie/ds-igel est créé pour stocker
les règles construites avec DevilsPie-IGEL.
Si vous choisissez de redémarrer devilspie,
ce dossier sera vidé dans le dossier ~/.devilspie
(plus rien dans ~/.devilspie/ds-igel)
Si vous choisissez de ne pas démarrer avec les nouvelles règles,
les fichiers créés restent dans le dossier ~/.devilspie/ds-igel
Toutes les copies de fichiers se font avec "écrasement" en cas de fichier déjà exixtant.
Un message d'avertissemnt apparaît avant l'action de copie,
ce qui vous laisse la liberté sur les fichiers risquant d'être écrasés.

Devil's Pie Interface Graphique Extra Légère n'a pas la prétention
d'englober toutes les fonctionnalités de Devil's Pie.
Il est là surtout pour des règles simples, sans édition à la main.
Il est toujours possible d'utiliser Devil's Pie I.G.E.L
pour obtenir les informations de dimension et position
afin de créer soit même ses propres règles.
                                                                        Fait par Tawal.

Vli,vlà,vlou

À la bonne heure et au plaisir ...

PS : une petite fonctionnalité non décrite dans le lisez-moi :
On peut se servir de ce script pour "redémarrer devilspie" après un changement de règles (edit à la mano ou autre).
Et ce sans dans déconnexion de session.
Une fois la règle modifiée, on ouvre Devil'sPie I.G.E.L., on clique sur "Sortie" directement et on a l'invite pour redémarrer devilspie.

Edit: Nouvelle Version !
Elle prend en charge les positionnements et dimensionnement prédéfinis (center, minimize, maximize et fullscreen).
Voici un fichier .ds crée à l'instant :

(if (and (is (window_class) "Xfburn") (is (application_name) "Xfburn"))
	(begin

		(set_workspace 2)

		(if (is (window_name) "Xfburn")
			(begin
				(geometry "1077x214")
				(minimize)
			)
		)

		(if (is (window_name) "Préférences")
			(begin
				(set_workspace 2)
				(geometry "775x400")
				(center)
			)
		)

		(if (is (window_name) "Répertoire temporaire")
			(begin
				(set_workspace 2)
				(geometry "595x534")
				(maximize)
			)
		)

		(if (is (window_name) "À propos de Xfburn")
			(begin
				(set_workspace 2)
				(geometry "355x230")
				(center)
			)
		)

    )
)

Et ça marche ! Malgré la configuration un peu loufoque !
Je pourrais même ajouter la loi "matches" ...
Je ne poste pas le script, ça n'a pas l'air d'intéresser ....
Edit2: Loi "matches" ajoutée ...
Edit3: Rajout des codes retour commandes 'cp' et 'mv', donc si on a un code retour non listé il faut regarder de coté là en 1er
Edit4: Un dernier fichier .ds généré par mon script (je ne l'aurais certainement pas fait à la main, j'aurais raté des fenêtres etc ...)

(if (and (is (window_class) "Gedit") (is (application_name) "gedit"))
	(begin

		(if (contains (window_name) "gedit")
			(geometry "1290x920+-36+-31"))

		(if (is (window_name) "Ouvrir")
			(begin
				(geometry "742x535")
				(center)
			)
		)

		(if (is (window_name) "Enregistrer sous")
			(begin
				(geometry "742x535")
				(center)
			)
		)

		(if (is (window_name) "Quick Open")
			(begin
				(geometry "450x300")
				(center)
			)
		)

		(if (is (window_name) "Rechercher et remplacer")
			(begin
				(geometry "582x223")
				(center)
			)
		)

		(if (is (window_name) "Find in Files")
			(begin
				(geometry "408x223")
				(center)
			)
		)

		(if (is (window_name) "Select a _folder")
			(begin
				(geometry "742x535")
				(center)
			)
		)

		(if (is (window_name) "Mode de coloration")
			(begin
				(geometry "477x513")
				(center)
			)
		)

		(if (is (window_name) "Vérifier l'orthographe")
			(begin
				(geometry "534x356")
				(center)
			)
		)

		(if (is (window_name) "Définir la langue")
			(begin
				(geometry "405x283")
				(center)
			)
		)

		(if (is (window_name) "Statistiques du document")
			(begin
				(geometry "434x263")
				(center)
			)
		)

		(if (is (window_name) "Préférences")
			(begin
				(geometry "559x528")
				(center)
			)
		)

		(if (is (window_name) "Choisissez la police de l’éditeur")
			(begin
				(geometry "424x480")
				(center)
			)
		)

		(if (is (window_name) "Insérer la date et l’heure")
			(begin
				(geometry "440x378")
				(center)
			)
		)

		(if (is (window_name) "À propos de Commentateur de code")
			(begin
				(geometry "424x332")
				(center)
			)
		)

		(if (is (window_name) "À propos de Complétion de mots")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Complétion de parenthèses")
			(begin
				(geometry "424x329")
				(fullscreen)
			)
		)

		(if (is (window_name) "À propos de Console Python")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Éditeur de jeu de couleurs")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Édition multiple")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Espaces intelligents")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Fournisseur de données Zeitgeist")
			(begin
				(geometry "471x329")
				(center)
			)
		)


		(if (is (window_name) "À propos de Fragments de code")
			(begin
				(geometry "429x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Git")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Indicateur d'espaces")
			(begin
				(geometry "424x346")
				(center)
			)
		)

		(if (is (window_name) "À propos de Insérer la date et l’heure")
			(begin
				(geometry "431x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Joindre/couper les lignes")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Ligne de commande")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Modificateurs")
			(begin
				(geometry "452x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Outils externes")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (contains (window_name) "À propos de Outils externes")
			(begin
				(geometry "434x353")
				(center)
			)
		)
		
		(if (is (window_name) "À propos de Ouverture rapide")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Panneau de l’explorateur de fichiers")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Recherche dans des fichiers")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Sélecteur de couleurs")
			(begin
				(geometry "499x349")
				(center)
			)
		)

		(if (is (window_name) "À propos de Signets")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Statistiques du document")
			(begin
				(geometry "463x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Surlignage rapide")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de SyncTeX")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Table de caractères")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Terminal intégré")
			(begin
				(geometry "424x329")
				(center)
			)
		)

		(if (is (window_name) "À propos de Translate")
			(begin
				(geometry "424x332")
				(center)
			)
		)

		(if (is (window_name) "À propos de Trier")
			(begin
				(geometry "424x249")
				(center)
			)
		)

		(if (is (window_name) "À propos de Vérificateur orthographique")
			(begin
				(geometry "424x249")
				(center)
			)
		)

		(if (is (window_name) "Color Scheme Editor")
			(begin
				(geometry "700x550")
				(center)
			)
		)

		(if (is (window_name) "Pick the foreground color")
			(begin
				(geometry "488x277")
				(center)
			)
		)

		(if (is (window_name) "À propos de gedit")
			(begin
				(geometry "503x380")
				(center)
			)
		)

		(if (contains (window_name) "Untitled window")
			(begin
				(geometry "561x167")
				(center)
			)
		)

    )
)

À bon entendeur ....
Edit: Tiens, en relisant mon fichier, je me suis rendu compte que j'ai mis une boite "À propos qqchose" en "fullscreen" !
Ça, c'est une erreur de saisie de ma part ! Comme quoi, il faut faire attention, sinon on fait n'importe quoi.
Allez, petite correction à la mano pour moi ...

nordinatueur

Merci beaucoup !

Bien sûr que ça intéresse. Et si ce n'est pas maintenant, ce sera plus tard !

Tawal

J'ai une nouvelle version plus complète que la dernière postée.
Tu dis si tu la veux 😉

loutch

Bonjour

recherche aide pour ce script (ne fonctionne plus ) jepense que google @ de nouveau changer un truc .

Pas obliger que ce soit google qui fait la recherche cela peut etre un autre moteur de recherche.

Merci d'avance.

qdbus com.github.radiotray_ng /com/github/radiotray_ng com.github.radiotray_ng.get_player_state | grep artist |sed 's/^.*" \: "//' |sed 's/",.*$//' > artiste_titre.txt
qdbus com.github.radiotray_ng /com/github/radiotray_ng com.github.radiotray_ng.get_player_state | grep title  |sed 's/^.*" \: "//' |sed 's/",.*$//' >> artiste_titre.txt
titre=$(cat artiste_titre.txt)
lynx --source -useragent="Googlebot-Image/1.0" "www.google.com/search?q=$titre\&tbm=isch" | perl -pe 's!.*?<img .*?src="([^"]*)".*!$1!' > lienMiniaturefile
sed -i 's/^.* http\:/http\:/' lienMiniaturefile
sed -i '/gstatic/!d' lienMiniaturefile

lienMiniature=$(cat lienMiniaturefile)
lynx -dump "$lienMiniature" > miniatureGoogleImage

convert miniatureGoogleImage pochette.png

cette partie qui cause problème.

lynx --source -useragent="Googlebot-Image/1.0" "www.google.com/search?q=$titre\&tbm=isch" | perl -pe 's!.*?<img .*?src="([^"]*)".*!$1!' > lienMiniaturefile
sed -i 's/^.* http\:/http\:/' lienMiniaturefile
sed -i '/gstatic/!d' lienMiniaturefile

lienMiniature=$(cat lienMiniaturefile)
lynx -dump "$lienMiniature" > miniatureGoogleImage

« Page précédente