Czasami zachodzi potrzeba wyświetlenia informacji z naszego skryptu w formie graficznej. Czy to gdy piszemy skrypt dla kogoś, kto niezbyt jest zaznajomiony z konsolą albo po prostu ma to ładnie wyglądać. Z pomocą przychodzi Zenity. Jest to zestaw różnych okien dialogowych, które w połączeniu z paroma parametrami zastępują konieczność pisania całej aplikacji z użyciem biblioteki np gtk.

Sposób użycia:

Najprostsze czyli okienka informacyjne:

zenity –error/info –text=”To jest okienko błędu/informacyjne”

Jeśli natomiast chcemy by w okienku dało się coś wpisywać, należy skorzystać z opcji entry:

zenity –entry –text=”Wpisz swoje imie”

Jednak w taki sposób nie uzyskamy żadnej wartości zwrotnej (wpisanej przez użytkownika). Aby ją uzyskać można albo przypisać polecenie zenity do zmiennej (pamietajac o używaniu znaków ` ` ) albo w taki oto sposób:

zenity –info –text=”Witaj “`zenity –entry –text=”Podaj imię”`

http://wklej.org/id/172247/

Este sencillo tutorial lo he encontrado en el blog de Xubuntu y lo traduzco para ustedes. La idea es que cuando estemos en un directorio dentro de Thunar, en el menú desplegable al hacer clic derecho, aparezca la opción de buscar archivos o carpetas como se muestra en la imagen posterior:

Para lograr esto lo primero que tenemos que hacer es instalar zenity:

$ sudo aptitude install zenity

Luego abrimos la consola y ponemos:

$ mkdir ~/.bash-scripts/

para crear un directorio que contendrá el script que ejecutará la acción en si. Ahora creamos un fichero llamado search-for-files adentro de la siguiente forma:

mousepad ~/.bash-scripts/search-for-files

y le pegamos esto adentro:

#!/bin/bash
#search-for-files

# change this figure to suit yourself – I find zenity dies from about 1000 results but YMMV
maxresults=500

# again, change the path to the icon to suit yourself. But who doesn’t like tango?
window_icon=”/usr/share/icons/Tango/scalable/actions/search.svg”

# this script will work for any environment that has bash and zenity, so the filemanager is entirely down to you! you can add extra arguments to the string as long as the last argument is the path of the folder you open
filemanager=”thunar”

window_title=”Search for Files”

srcPath=”$*”

if ! [ -d "$srcPath" ] ; then
cd ~/
srcPath=`zenity –file-selection –directory –title=”$window_title – Look in folder” –window-icon=”$window_icon”`
fi

if [ -d "$srcPath" ] ; then

fragment=`zenity –entry –title=”$window_title – Name contains:” –window-icon=”$window_icon” –text=”Search strings less than 2 characters are ignored”`
if ! [ ${#fragment} -lt 2 ] ; then

(

echo 10
O=$IFS IFS=$’\n’ files=( `find “$srcPath” -iname “*$fragment*” -printf \”%Y\”\ \”%f\”\ \”%k\ KB\”\ \”%t\”\ \”%h\”\\\n | head -n $maxresults` ) IFS=$O
echo 100

selected=`eval zenity –list –title=\”${#files[@]} Files Found – $window_title\” –window-icon=”$window_icon” –width=”600″ –height=”400″ –text=\”Search results:\” –print-column=5 –column \”Type\” –column \”Name\” –column \”Size\” –column \”Date modified\” –column \”Path\” ${files[@]}`
if [ -e "$selected" ] ; then “$filemanager” “$selected” ; fi

) | zenity –progress –auto-close –pulsate –title=”Searching…” –window-icon=”$window_icon” –text=”Searching for \”$fragment\”"

fi

fi

exit

y le damos permisos de ejecución:

chmod a+x ~/.bash-scripts/search-for-files

Ahora haces un backup del fichero uca.xml:

$ sudo cp /etc/xdg/Thunar/uca.xml /etc/xdg/Thunar/uca.xml.old

al que le pondremos al final esto:

<action>
<icon>/usr/share/icons/Tango/scalable/actions/search.svg</icon>
<name>Search for Files</name>
<command>bash ~/.bash-scripts/search-for-files %f</command>
<description>Search this folder for files</description>
<patterns>*</patterns>
<directories/>
</action>

Ahora lo que nos queda es abrir Thunar » Editar » Configurar acciones personalizadas y creamos una nueva. Y llenamos los siguientes campos:
En la pestaña Básico:

Nombre: Buscador
Descripción: Buscador de archivos/carpetas
Comando: bash ~/.bash-scripts/search-for-files %f
Icono: Seleccionamos el que más nos guste.

Ahora en la pestaña Condiciones de apariencia lo siguientes campos:

Patrón de archivo: *
Aparece si la selección contiene: Directorio.

Y listo!!!

Набрел я как то на французском форуме убунту на очень интересную ветку Script bash – Importer automatiquement les photos d’un appareil

Собственно сама идея меня захватила тем более что media-libs/libgphoto2 и media-gfx/gphoto2 в сумме все равно меньше чем к примеру media-gfx/f-spot которому еще и нужен dev-lang/mono

Итак для начала я просто локализовал то что было сделано до меня французами

#!/bin/bash
#Licence GPL
#Version 2 : Refonte du programme, ajout de la creation de catalogue
#
#
#Version 1 : Importe des photos via PTP ou un repertoire quelconque (dont appareil monté en USB mass-storage),
#            renomme les photos selon les exifs, avec choix de methode de renommage,
#            pivote les photos selon les exifs (avec jpegtran)
#            trie les photos selon la date des exifs avec choix de l'arborescence de tri,
#            modifie le LensType des .CR2 (Utile pour un canon 350D pour retoucher la photo avec DPP (wine) (correction de l'objectif accessible))
#
#Necessite : exiftool, zenity, gphoto2, jpegtran
#
# aide de zenity : yelp file:///usr/share/gnome/help/zenity/fr/zenity.xml
#

###########
#IMPORTANT#
###########
#choses à modifier selon l'appareil : - les champs exifs dependent de l'appareil photo. il est preferable de les verifier, particulierement le champ de modele de l'appareil (selon ce que vous voulez que ca affiche. Pour moi, ca affiche "350D" alors que le champ complet est "Canon EOS 350D DIGITAL").
#                                     - la fonction de changement de lenstype n'est pas utile a tous le monde...

#############
##Fonctions##
#############

####Pivoter selon exifs
function pivot {
orient="$(exiftool -orientation $i | cut -d " " -f24)"
if [ "$orient" = "90" ]; then
 jpegtran -rotate 90 -copy all $i > tmp
 mv tmp $i
 exiftool -orientation="Horizontal (normal)" -overwrite_original $i
elif [ "$orient" = "270" ]; then
 jpegtran -rotate 270 -copy all $i > tmp
 mv tmp $i
 exiftool -orientation="Horizontal (normal)" -overwrite_original $i
fi
}

####Modifier le LensType
function LType {
lens=$(exiftool -Lens $i)
if [ "$(echo $lens | cut -d " " -f3-5)" = "18.0 - 55.0mm" ]; then
 exiftool -LensType="Canon EF-S 18-55mm f/3.5-5.6" $i
elif [ "$(echo $lens | cut -d " " -f3)" = "200.0mm" ]; then
 exiftool -LensType="Canon EF 200mm f/2.8L II" $i
elif [ "$(echo $lens | cut -d " " -f3)" = "50.0mm" ]; then
 exiftool -LensType="Canon EF 50mm f/1.8" $i
fi
}

####Sortie volontaire par le bouton annuler
function sortie {
zenity --warning --text="Не указан каталог \nДальнейшая работа сценария невозможна."
exit
}

######################
##Début du Programme##
######################

#detection de l'appareil photo : gphoto2 => si il y a quelque chose, proposer de prendre l'appareil photo detecte et alors -> action.
if [ "$(gphoto2 --auto-detect | wc -l)" -ge 3 ]; then
 apn="$(gphoto2 --auto-detect)"
 zenity --question --text="Камера обнаружена ? \n\n$apn" --title="Автоматическое обнаружение"
 okgphoto=$?
else
 okgphoto=1
fi

#Si pas d'appareil detecté ou annulation, choisir un repertoire avec zenity --file-selection --directory contenant des photos (ou alors selectionner les photos), puis action
if [ "$okgphoto" = "1" ]; then
 rep=$(zenity --file-selection --directory --title="Выбор каталога для импорта")
 if [ "$rep" = "" ]; then
  sortie
 fi
fi

#choix des actions a effectuer
action=$(zenity --list --checklist\
         --width=390 --height=290\
         --title="Что делать?"\
         --text="Выберите действия для выполнения либо нажмите отменить"\
         --column=" " --column="Описание"\
         TRUE    "Импорт фотографий"\
         FALSE    "Удаление файлов на устройстве"\
         FALSE    "Переименование фотографий"\
         TRUE    "Организовать фотографии"\
         TRUE    "Поворот jpeg согласно exifs"\
         FALSE    "Создать файл каталога"\
         TRUE    "Установите тип цели в EXIFS из .cr2")
import=$(echo "$action" | grep "Импорт фотографий")
if [ "$action" = "" ]; then
 sortie
elif [ "$import" = "" ]; then
 zenity --warning --text="Нечего делать, \nДальнейшая работа сценария невозможна."
 exit
fi
#choix du repertoire de base
repbase=$(zenity --file-selection --directory --title="Выбор целевого каталога" --text="Выбрать базовый каталог, куда фотографии будут скопированы :")
if [ "$repbase" = "" ]; then
  sortie
fi

#import des photos dans le repertoire de base
cd $repbase
supprime=$(echo "$action" | grep "Удаление файлов на устройстве")
if [ "$supprime" = "" ]; then
 if [ "$okgphoto" = "1" ]; then  #pas PTP
  cp -v "$rep"/*.jpg "$rep"/*.JPG "$rep"/*.cr2 "$rep"/*.CR2 . | zenity --progress --text="Пожалуйста, подождите\nИмпорт текущих фото..." --pulsate --auto-close
 else #PTP
  gphoto2 --get-all-files | zenity --progress --text="Пожалуйста, подождите\nИмпорт текущих фото..." --pulsate --auto-close
 fi
else
 if [ "$okgphoto" = "1" ]; then  #pas PTP
  mv -v "$rep"/*.jpg "$rep"/*.JPG "$rep"/*.cr2 "$rep"/*.CR2 . | zenity --progress --text="Пожалуйста, подождите\nПеремещение фотографий..." --pulsate --auto-close
 else #PTP
  gphoto2 --get-all-files | zenity --progress --text="Пожалуйста, подождите\nИмпорт текущих фото..." --pulsate --auto-close
  gphoto2 --delete-all-files --recurse | zenity --progress --text="Пожалуйста, подождите\nУдаление текущей фотографии..." --pulsate --auto-close
 fi
fi
if [ "$?" != "0" ]; then
 zenity --error --text="Произошла ошибка при импорте камеры.\nОстановить сценарий." --title="Ошибка"
 exit
fi

###########################
##Préparation des actions##
###########################

#Modifier le LensType
modifltype=$(echo "$action" | grep "Установите тип цели в EXIFS из .cr2")

#Renommage
renommer=$(echo "$action" | grep "Переименование фотографий")
if [ "$renommer" != "" ]; then
 zenity --info --text="В следующем окне выберите как переименовать фотографии. Эти данные (год, месяц, день, ...), взяты из информации exifs каждой фотографии.\n\nВарианты :\n%a : Аббревиатура дней (например Пн)\n%A : День (например Понедельник)\n%b : Абберевиатура месяца (например Ян)\n%B : Месяц\n%d : День месяца (например 01)\n%H : Часы\n%M : Минуты\n%m : Месяц по счету\n%y : Последние две цифры года (например 90)'\n%Y : Год (например 2600)\n%P : Модель камеры \n\nНапример : %P-%H-%M для имен типа : Модель-Часы-Минуты"
 renom=$(zenity --entry \
         --title="Классификация" \
         --text="Укажите как переименовывать фотографии (например %P-%H-%M) :"\
         --entry-text "%P-%H-%M")
fi

#Pivoter
pivoter=$(echo "$action" | grep "Поворот jpeg согласно exifs")

#Tri
classer=$(echo "$action" | grep "Организовать фотографии")
if [ "$classer" != "" ]; then
 zenity --info --text="В следующем окне выберите как классифицировать каталог. Эти данные (год, месяц, день, ...), взяты из информации exifs каждой фотографии.\n\nВарианты :\n%a : Аббревиатура дней (например Пн)\n%A : День (например Понедельник)\n%b : Абберевиатура месяца (например Ян)\n%B : Месяц\n%d : День месяца (например 01)\n%H : Часы\n%M : Минуты\n%m : Месяц по счету\n%y : Последние две цифры года (например 90)'\n%Y : Год (например 2600)\n%P : Модель камеры \n\nНапример : %Y/%B/%d/ для имен типа : путь/к/базе/год/месяц/день/"
 Class=$(zenity --entry \
         --title="Классификация" \
         --text="Укажите как организовать базу (например %Y/%B/%d/) :"\
         --entry-text "%Y/%B/%d/")
fi

#Catalogue
cata=$(echo "$action" | grep "Создать файл каталога")
if [ "$cata" != "" ]; then
 cat=$(zenity --entry \
       --title="Каталог" \
       --text="Введите имя каталога :")
 repcat=""$repbase"/"$cat""
 imagescat=$(zenity --file-selection --multiple --title="Выбор картинок для каталога" --text="Выберите изображения, которые будут находиться в каталоге :")
 if test ! -e "$repcat"; then
  mkdir -p "$repcat"
 fi
else
 imagescat=""
fi

#Nombre d'images
njpg=$(ls *.jpg *.JPG | wc -w)
ncr2=$(ls *.CR2 *.cr2 | wc -w)

###########################
####Programme par image####
###########################

ajpg=0
for i in *.jpg *.JPG; do
#variables contenant les differents exifs
 exiftime=$(exiftool -CreateDate -d "%a %A %b %B %d %H %m %y %Y %M" $i)
 a="$(echo $exiftime | cut -d " " -f4)"
 A="$(echo $exiftime | cut -d " " -f5)"
 b="$(echo $exiftime | cut -d " " -f6)"
 B="$(echo $exiftime | cut -d " " -f7)"
 d="$(echo $exiftime | cut -d " " -f8)"
 H="$(echo $exiftime | cut -d " " -f9)"
 m="$(echo $exiftime | cut -d " " -f10)"
 y="$(echo $exiftime | cut -d " " -f11)"
 Y="$(echo $exiftime | cut -d " " -f12)"
 M="$(echo $exiftime | cut -d " " -f13)"
 P="$( exiftool -Model $i | cut -d " " -f21)"
#renommage
 if [ "$renommer" != "" ]; then
  nom=$(echo "$renom" | sed s/"%a"/"$a"/ | sed s/"%A"/"$A"/ | sed s/"%b"/"$b"/ | sed s/"%B"/"$B"/ | sed s/"%d"/"$d"/ | sed s/"%H"/"$H"/ | sed s/"%m"/"$m"/ | sed s/"%y"/"$y"/ | sed s/"%Y"/"$Y"/ | sed s/"%M"/"$M"/ | sed s/"%P"/"$P"/)-$(echo "$i" | cut -d "_" -f2)
  mv $i $nom
  i="$nom"
 fi
#pivotage
 if [ "$pivoter" != "" ]; then
  pivot $i;
 fi
#classer
 if [ "$classer" != "" ]; then
  reptri="$repbase"/$(echo "$Class" | sed s/"%a"/"$a"/ | sed s/"%A"/"$A"/ | sed s/"%b"/"$b"/ | sed s/"%B"/"$B"/ | sed s/"%d"/"$d"/ | sed s/"%H"/"$H"/ | sed s/"%m"/"$m"/ | sed s/"%y"/"$y"/ | sed s/"%Y"/"$Y"/ | sed s/"%P"/"$P"/)
  if test ! -e $reptri; then
   mkdir -p $reptri
  fi
  mv $i $reptri
 else reptri="$repbase"
 fi
#cataloguer
 if [ "$(echo $imagescat | grep "$i")" != "" ]; then
  ln -s "$reptri""$i" "$repcat"/
 fi
ajpg=$[$ajpg + 1]
echo $[100*$ajpg/$njpg]
done | zenity --progress --text="Пожалуйста, подождите\nВыполнение действий над jpeg..." --auto-close

acr2=0
for i in *.cr2 *.CR2; do
#variables contenant les exifs
 exiftime=$(exiftool -CreateDate -d "%a %A %b %B %d %H %m %y %Y %M" $i)
 a="$(echo $exiftime | cut -d " " -f4)"
 A="$(echo $exiftime | cut -d " " -f5)"
 b="$(echo $exiftime | cut -d " " -f6)"
 B="$(echo $exiftime | cut -d " " -f7)"
 d="$(echo $exiftime | cut -d " " -f8)"
 H="$(echo $exiftime | cut -d " " -f9)"
 m="$(echo $exiftime | cut -d " " -f10)"
 y="$(echo $exiftime | cut -d " " -f11)"
 Y="$(echo $exiftime | cut -d " " -f12)"
 M="$(echo $exiftime | cut -d " " -f13)"
 P="$( exiftool -Model $i | cut -d " " -f21)"
#modifier le lenstype
 if [ "$modifltype" != "" ]; then
  LType $i;
 fi
#renommage
 if [ "$renommer" != "" ]; then
  nom=$(echo "$renom" | sed s/"%a"/"$a"/ | sed s/"%A"/"$A"/ | sed s/"%b"/"$b"/ | sed s/"%B"/"$B"/ | sed s/"%d"/"$d"/ | sed s/"%H"/"$H"/ | sed s/"%m"/"$m"/ | sed s/"%y"/"$y"/ | sed s/"%Y"/"$Y"/ | sed s/"%M"/"$M"/ | sed s/"%P"/"$P"/)-$(echo "$i" | cut -d "_" -f2)
  mv $i $nom
  i="$nom"
 fi
#classer
 if [ "$classer" != "" ]; then
reptri="$repbase"/$(echo "$Class" | sed s/"%a"/"$a"/ | sed s/"%A"/"$A"/ | sed s/"%b"/"$b"/ | sed s/"%B"/"$B"/ | sed s/"%d"/"$d"/ | sed s/"%H"/"$H"/ | sed s/"%m"/"$m"/ | sed s/"%y"/"$y"/ | sed s/"%Y"/"$Y"/ | sed s/"%P"/"$P"/)
 if test ! -e $reptri; then
  mkdir -p $reptri
 fi
 mv $i $reptri
 else reptri="$repbase"
 fi
#cataloguer
 if [ "$(echo $imagescat | grep "$i")" != "" ]; then
  ln -s "$reptri""$i" "$repcat"/
 fi
acr2=$[$acr2 + 1]
echo $[100*$acr2/$ncr2]
done | zenity --progress --text="Пожалуйста, подождите\nВыполнение действий над cr2..." --auto-close

#Fin du programme
zenity --info --text="Импорт окончен !"
exit

Однако многое лично меня смутило… Для начала я хотел чтобы все zenity отображающие процессы показывали не бездумно

zenity --progress --auto-close --pulsate

а реально отображали бы состояние процесса.
Ну и опять же даже не сильно вникая можно очень многое сделать гораздо проще.
В общем немного подаставав обитателей канала #linux сети RusNet IRC Network а главное получив неоценимую помощь и подсказки от ramok в конце концов дошел вот до такого.

#!/bin/bash

#import-photos

#################################################################################
#Copyright (C) 2007 Free Software Foundation.

#This program is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 of the License, or
#(at your option) any later version.

#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.

#You should have received a copy of the GNU General Public License
#along with this program; if not, write to the Free Software
#Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

##################################################################################

################################################
#Purpose: Automate import photos from digital camera using gphoto2 through PTP and /bin/bash
#Based on http://forum.ubuntu-fr.org/viewtopic.php?id=146629&p=1
#Date: Пятница, 31 Июль 2009
#Authors: init_6, ramok
#Improvements, Feedback, comments: Please go to http://sudormrf.wordpress.com/2009/07/31/импорт-фотографий-из-цифровых-камер/
#Notes: To use script first install media-gfx/gphoto2, media-libs/exiftool
#Version: 1.?
################################################

#ВАЖНО! - ДЕЛИТЕСЬ УСОВЕРШЕНСТВОВАНИЯМИ СКРИПТА С ОБЩЕСТВЕННОСТЬЮ

function config {
    cd `dirname $0`;

    rep=$HOME"/Photos";

    if [ "$(gphoto2 --auto-detect | wc -l)" -ge 3 ]; then
        zenity --question --text="Камера обнаружена ? \n\n$(gphoto2 --auto-detect)" --title="Автоматическое обнаружение";
        ok_gphoto=$?;
    else
        ok_gphoto=1;
    fi
}

function num_files {
    if [ ${ok_gphoto} = 0 ]; then
        num_files=$(gphoto2 --list-files | grep -ve '^There' | wc -l);
    fi
}

function copy_pictures {
    if [ ${ok_gphoto} = 0 ]; then
        (for ((file=1;file/dev/null; echo $(($file*100/$num_files)); done) | zenity --progress --auto-close --text="Пожалуйста подождите,\nИмпорт текущих фото...";
        if [ $? != 0 ]; then
            zenity --error --text="Ошибка импорта фотографий";
            cancel;
        fi
    fi
}

function delete_pictures {
    if [ ${ok_gphoto} = 0 ]; then
        (for ((file=1;file/dev/null; echo $(($file*100/$num_files)); done) | zenity --progress --auto-close --text="Пожалуйста подождите,\nУдаление фотографий...";
        if [ $? != 0 ]; then
            zenity --error --text="Ошибка удаления фотографий";
            cancel;
        fi
    fi
}

function move_pictures {
    copy_pictures;
    delete_pictures;
}

function extract {
    if [ ${num_files} = 0 ]; then
        zenity --error --text="Нет фотографий" --title="Ошибка";
        cancel;
    fi

    cd "$rep";

    echo "$ACTION" | grep "Сохранить файлы на устройстве" >/dev/null;
    if [ "$?" = 0 ]; then
        copy_pictures;
    else
        move_pictures;
    fi
    if [ "${PIPESTATUS[0]}" != 0 ]; then
        zenity --error --text="Произошла ошибка при импорте камеры" --title="Ошибка";
        cancel;
    fi

    zenity --info --text="В следующем окне выберите как классифицировать каталог. Эти данные (год, месяц, день, ...), взяты из информации exifs каждой фотографии.\n\nВарианты :\n%a : Аббревиатура дней (например Пн)\n%A : День (например Понедельник)\n%b : Абберевиатура месяца (например Ян)\n%B : Месяц\n%d : День месяца (например 01)\n%H : Часы\n%M : Минуты\n%m : Месяц по счету\n%y : Последние две цифры года (например 90)'\n%Y : Год (например 2600)\n%P : Модель камеры \n\nНапример : %Y/%B/%d/ для имен типа : путь/к/базе/год/месяц/день/"
    Class=$(zenity --entry \
         --title="Классификация" \
         --text="Укажите как организовать базу (например %Y/%B/%d/) :"\
         --entry-text "%Y/%B/%d/")

    ajpg=0
    for i in *.jpg *.JPG; do
        eval $(exiftool -CreateDate -d "a=%a A=%A b=%b B=%B d=%d h=%H m=%m y=%y Y=%Y M=%M" $i | sed -e 's/.*: //')
        repcible="$rep"/$(echo "$Class" | sed s/"%a"/"$a"/ | sed s/"%A"/"$A"/ | sed s/"%b"/"$b"/ | sed s/"%B"/"$B"/ | sed s/"%d"/"$d"/ | sed s/"%H"/"$H"/ | sed s/"%m"/"$m"/ | sed s/"%y"/"$y"/ | sed s/"%Y"/"$Y"/ | sed s/"%P"/"$P"/)
        if test ! -e $repcible; then
            mkdir -p $repcible
        fi
        mv $i $repcible
        ajpg=$[$ajpg + 1]
        echo $[100*$ajpg/$num_files]
    done | zenity --progress --text="Пожалуйста, подождите\nВыполнение действий над jpeg..." --auto-close

    zenity --info --text="Фотографии были успешно импортированы" --title="Информация";

}

function cancel {
    if [ "${PIPESTATUS[0]}" != 0 ]; then
        exit
    fi
}

function actions {
    extract;
}

config;

num_files;

ACTION=$(zenity --list --checklist --width=390 --height=290\
            --title="Выбор операций для выполнения"\
            --text="Нажмите кнопку ОК, чтобы начать импортирующими фотографии.\nВыберите для выполнения операций : "\
            --column=" " --column="Описание"\
            TRUE    "Сохранить файлы на устройстве" );

cancel;

actions;

Собственно основные моменты база фотографий располагается в $HOME”/Photos”. Далее происходит импорт фотографий в каталог база/год/месяц/день/ создания фотографии.

Использование вообще банально сохраняете скрипт к примеру в /usr/local/bin/import-photos делаете его исполнимым

chmod +x /usr/local/bin/import-photos

Далее для gnome в gnome-volume-properties “Сменные устройства и носители” для цифровых камер просто устанавливаете команду /usr/local/bin/import-photos
Вот приблизительно так

Далее при появлении цифровых камер происходит следующее в начале появляется пара диалоговых окон гнома

В первом надо поставить галочку напротив “Всегда выполнять это действие” и нажать Ок. Иначе это окно будет появляться постоянно при вставке носителя.

И вот такое окно

Во втором окне необходимо нажать на “Импортировать фотографии” тогда начинает работать скрипт

Собственно скрипт автоматически обнаружил носитель с фотографиями. Далее диалог о сохранении файлов на обнаруженном носителе.

Сам процесс копирования…

Окно с напоминанием форматов времени.

И диалог задания формата сортировки базы данных картинок.

Ну и собственно

На этом все.

So che un buntu è presente uno strumento per gli aggiornamenti automatici, ma come al solito… se non so come funzionano le cose non sono contento!

Per aggiornare il sistema ho quindi scritto un paio di script che…sfruttando i comandi apt-get ed aptitude agiornano il sistema.

Gli script sono compatibili con tutti i sistemi che usano apt-get ed aptittude (prerequisiti).

Praticamente sono una semplice sequenza di comandi, ne ho creati 2 per permettere di scegliere la versione da shell o la versione “grafica” con zenity, va da se che la versione con zenity ha zenity come prerequisito!!

Prerequisiti:

apt-get
aptitude
zenity (per la versione grafica

Qualora mancassero aptitude o zenity …
per i meno scafati, aprite un terminale e digitate:
sudo apt-get install aptitude
sudo apt-get install zenity

Oppure installateli da synaptic…

Per lanciare lo script da shell:

Una volta creato il file con lo script all’interno e resolo eseguibile:

Aprire un terminale e digitare:

sudo ./nomefile

Per la nciare lo script grafico:

Una volta creato il file con lo script e resolo eseguibile si hanno 2 strade; la prima è di lanciarlo come se fosse uno script da shell.

L’altra strada (che è quella per cui è nato) è di lanciarlo da Nautilus (praticamente averlo nel tasto destro del mouse), per farlo bisogna copiare lo script in /home/nomeutente/.gnome2/nautilus-script   per arrivare nela cartella corretta consiglio:

Risorse -> Cartella home

premere ctrl-h per visualizzare le cartelle nascoste

doppio click su .gnome2

doppio click su nautilus-script

copiare lo script

ora se andate sul desktop e premete il tasto destro troverete una voce “script” all’interno vi sarà il vostro script!

NOTE TECNICHE:

Chi come me usa un proxy per connettersi ad internet deve decommentare (togliere il #) le righe con la parloa “export” e sostituire a
username -> il proprio username (sul proxy)
pasword -> la propria password (sul proxy)
proxy -> indirizzo o nome del proxy
porta -> la porta utilizzata dal proxy

Ecco i 2 script

Da Shell (non grafico)

#!/bin/bash
# Script di: Runner75
# Sito: runner75.wordpress.com
# Script per aggiornamento di un sistema che usa apt-get ed aptitude.
# Nato su Ubuntu Jaunty 9.04
# 29_07_09
# /*
# * —————————————————————————-
# * “LA LICENZA BEER-WARE” (Versione 42):
# * Questo file è stato scritto da Runner75. Fin quando questo testo
# * di licenza rimane invariato, puoi fare quel cavolo che ti pare con questa roba.
# * Se un giorno ci incontreremo, e se pensi che il mio codice sia servito a qualcosa,
# * puoi offrirmi una birra come ringraziamento. Runner75
# * —————————————————————————-
# */
echo “#Eseguo export del proxy”
#export http_proxy=http://username:password@proxy:porta
#export ftp_proxy=http://username:password@proxy:porta
echo “# Aggiornamento lista pacchetti nei repository\n(comando sudo apt-get update lanciato 2 volte)”
sudo apt-get update
sudo apt-get update
echo “# Controllo dipendenze mancanti\n(comando sudo apt-get -y check)”
sudo apt-get -y check
echo “# Aggiornamento pacchetti\n(comando sudo aptitude -y safe-upgrade”
sudo aptitude -y safe-upgrade
echo “# Aggiornamento lista pacchetti nei repository\n(comando sudo apt-get update lanciato 2 volte)”
sudo apt-get update
sudo apt-get update
echo “# Rimozione pacchetti scaricati ed installati\n(comando sudo aptitude clean”
sudo aptitude clean

Script con grafica:

#!/bin/bash
# Script di: Runner75
# Sito: runner75.wordpress.com
# Script per aggiornamento di un sistema che usa apt-get ed aptitude.
# Nato su Ubuntu Jaunty 9.04
# 29_07_09
# /*
# * —————————————————————————-
# * “LA LICENZA BEER-WARE” (Versione 42):
# * Questo file è stato scritto da Runner75. Fin quando questo testo
# * di licenza rimane invariato, puoi fare quel cavolo che ti pare con questa roba.
# * Se un giorno ci incontreremo, e se pensi che il mio codice sia servito a qualcosa,
# * puoi offrirmi una birra come ringraziamento. Runner75
# * —————————————————————————-
# */
(
echo “#Eseguo export del proxy”
export http_proxy=http://mtartar:F4nt4m4n@139.128.19.7:8080
export ftp_proxy=http://mtartar:F4nt4m4n@139.128.19.7:8080
echo “# Aggiornamento lista pacchetti nei repository\n(comando sudo apt-get update lanciato 2 volte)”
gksu apt-get update
sudo apt-get update
echo “# Controllo dipendenze mancanti\n(comando sudo apt-get -y check)”
sudo apt-get -y check
echo “# Aggiornamento pacchetti\n(comando sudo aptitude -y safe-upgrade”
sudo aptitude -y safe-upgrade
echo “# Aggiornamento lista pacchetti nei repository\n(comando sudo apt-get update lanciato 2 volte)”
sudo apt-get update
sudo apt-get update
echo “# Rimozione pacchetti scaricati ed installati\n(comando sudo aptitude clean)”
sudo aptitude clean ) | (zenity –width=300 –height=100 –progress –pulsate –auto-close –title=”Aggiornamento”)

사용법:
zenity [옵션...]

도움말 옵션:
-?, –help 도움말 옵션을 봅니다
–help-all 모든 도움말 옵션을 봅니다
–help-general 일반 옵션을 표시합니다
–help-calendar 달력 옵션을 표시합니다
–help-entry 텍스트 입력란 옵션을 표시합니다
–help-error 오류 옵션을 표시합니다
–help-info 정보 옵션을 표시합니다
–help-file-selection 파일 선택 옵션을 표시합니다
–help-list 목록 옵션을 표시합니다
–help-notification 알림 아이콘 옵션을 표시합니다
–help-progress 진행 옵션을 표시합니다
–help-question 물음 옵션을 표시합니다
–help-warning 주의 옵션을 표시합니다
–help-scale 눈금 옵션을 표시합니다
–help-text-info 텍스트 정보 옵션을 표시합니다
–help-misc 기타 옵션을 표시합니다
–help-gtk GTK+ 옵션 표시

프로그램 옵션:
–calendar 달력 대화 상자를 표시합니다
–entry 텍스트 입력 대화 창을 표시합니다
–error 오류 대화 상자를 표시합니다
–info 정보 대화 상자를 표시합니다
–file-selection 파일 선택상자를 표시합니다
–list 목록 대화 상자를 표시합니다
–notification 알림을 표시합니다
–progress 진행 표시상자를 표시합니다
–question 질문 대화 상자를 표시합니다
–warning 주의 대화 상자를 표시합니다
–scale 눈금값 대화 상자를 표시합니다
–text-info 텍스트 정보 대화 창을 표시합니다
–display=DISPLAY X display to use

Zenity is a tool that help you to create a common functional GTK+ dialogs. It have various dialogs that each of them have different ways of presenting data and acquire data from user input.

Some example scripts

* szDate=$(zenity —calendar —text “Pick a day” —title “Medical Leave” —day 28 —month 8 —year 2009); echo $szDate

This would display the given date in calendar

* szAnswer=$(zenity —entry —text “where are you?” —entry-text “at lab”); echo $szAnswer

This would display a box with given text

* zenity —error —text “Error Message! “

An error message

* zenity —info —text “Join us at www.glugjntucep.wikidot.com.”

A text window

* szSavePath=$(zenity —file-selection —save —confirm-overwrite);echo $szSavePath

File selection dialog box

Ho scritto questo semplice applicativo (basandomi su una versione di ffmpeg modificata per convertire gli amv) per permettere a tutti semplicemente di convertire i propri video in amv, unico formato video supportato da alcuni lettori mp3;
Il programma offre una semplice interfaccia in Zenity, e salva il file convertito nella home;
Una volta installato, si può trovare un collegamento al programma in Applicazioni–>Audio e Video.
È scaricabile qui
Spero di esservi stato utile!
Bye!

Voici un script Python pour connaître les modifications subies par un répertoire entre un instant A et un instant B. Comble du bonheur, ce n’est pas un programme en ligne de commande.

Ce programme comble (enfin je crois) un manque en la matière car des commandes existent qui font plus ou moins ça :

• diff : permet de comparer deux répertoires, mais il ne permet pas de comparer un répertoire avec lui-même…
• dnotify : permet de suivre les modifications en temps réel et d’exécuter un action quand une modification a lieu.  S’il n y a pas de modification, dnotify ne rend pas la main…

Pré-requis

Le programme utilise zenity et yelp qui devraient être installés par défaut sur Ubuntu (Gnome).

Installation

Télécharger le script.

Copier le script dans votre répertoire ~/bin. Il peut porter le nom que vous voulez, moi je l’ai appelé “Répertoire avant-après”, n’ayons pas peur des accents et des espaces !

Donnez-lui les droits en exécution :

Donner les droits en exécution au script

Il est ensuite possible de créer un lanceur sur le bureau. Sous Nautilus, faites apparaître le menu contextuel en cliquant avec le bouton de droite de la souris sur le bureau :

Menu contextuel de Nautilus

Cliquer sur Créer un lanceur…, la fenêtre suivante apparaît :

Créer un lanceur sur le bureau

Choisissez Application comme type de lanceur, donnez le nom que vous voulez et sélectionnez le script avec le bouton Parcours…. Il est également possible de changer l’icône en cliquant dessus.

Utilisation

Ce programme est très simple d’utilisation :

• vous sélectionnez un ou plusieurs répertoires, un cliché est automatiquement pris,
• vous exécutez les tâches dont vous voulez connaitre le comportement,
• vous cliquez sur le bouton Valider,
• vous lisez le résultat.

Le cliché inclut tous les sous-répertoires qu’il peut trouver.

Le programme est très rapide car les fichiers ne sont pas lus, seules les informations accessibles par la commande ls sont comparées.

Note : Il peut aussi être appelé depuis la ligne de commande en donnant les répertoires en paramètres, cela évite de devoir passer par la fenêtre de sélection. Le reste est identique.

Exemple

Dans cet exemple, je vais suivre les modifications de mon répertoire .mozilla lorsque je lance Firefox 3.

Avant de lancer Firefox, je lance le programme. La fenêtre de sélection de répertoire apparaît. Je sélectionne le répertoire et clique sur Valider.

Sélection du répertoire

Le premier cliché est réalisé et le message suivant apparaît :

Premier cliché réalisé

Je lance donc Firefox comme prévu. Une fois Firefox lancé, je clique sur Valider. La fenêtre des résultats s’affiche alors :

Fenêtre des résultats

Et voilà !

Fonctionnement

Sélection de répertoire

La sélection du ou des répertoires se fait avec zenity :

zenity --file-selection --directory --multiple

Explications :

• –file-selection : fait apparaître la fenêtre de sélection de fichiers,
• –directory : fonctionne en mode sélection de répertoire
• –multiple : permet de sélectionner plusieurs répertoires

En mode sélection multiple, zenity retourne une ligne contenant les répertoires séparés par un |.

Prise de cliché

Le programme utilise la commande ls pour récupérer les répertoires, les fichiers et leur état à un instant donné :

ls -AlRZ --time-style=long-iso repertoire | grep -v -e "^total" -e "^$"

Description :

• ls :
  
  • -A : affiche tous les fichiers, même cachés à l’exception de . et ..,
  • -l : affichage complet,
  • -R : analyse récursive,
  • -Z : récupère le contexte SELinux.
  • repertoire : répertoire(s) à analyser
• grep :
  • -v : inverse le filtrage de grep,
  • -e “^total” : élimine les lignes de totaux,
  • -e “^$” : élimine les lignes vides.

Toutes ces informations sont enregistrées à chaque prise de cliché pour ensuite être analysées.

La toute première lettre des droits fournis par ls -l permet de connaître le type de fichier :

• d : répertoire,
• - : fichier standard,
• b : fichier bloc spécial (device),
• c : fichier caractère spécial (device),
• l : lien symbolique,
• p : tube nommé,
• s : socket.

Analyse des différences

Les clichés sont indexés avec le chemin absolu de chaque fichier et répertoire.

L’algorithme d’analyse est plutôt simple :

• ajout : on regarde les entrées présentes dans le second cliché mais pas dans le premier,
• suppression : on regarde les entrées présentes dans le premier cliché mais pas dans le second,
• modification : on regarde si les informations de l’entrée ont changé entre les 2 clichés (type d’entrée, propriétaire, groupe, contexte SELinux, taille, jour et heure de modification).

Affichage des résultats

Pour afficher les résultats, on génère un bête fichier HTML que yelp se chargera d’afficher. Yelp est normalement l’afficheur d’aide en ligne de Gnome mais il peut afficher n’importe quel fichier HTML (sans trop pousser non plus…) que vous lui fournissez.

Idéal pour notre cas.

Code source

Oui, le code source est lourd et mal commenté (quick and dirty)…

#!/usr/bin/env python
# coding=utf8
import sys
from subprocess import call,Popen,PIPE
from os.path import abspath,join,dirname,basename
from tempfile import NamedTemporaryFile

def decoupe_entree(ligne):
  elements=ligne.split(None,8)
  entree={
    "droits"      :elements[0],
    "proprietaire":elements[2],
    "groupe"      :elements[3],
    "contexte"    :elements[4],
    "taille"      :elements[5],
    "jour"        :elements[6],
    "heure"       :elements[7],
    "nom"         :elements[8]
  }

  lettre_type=elements[0][0]
  entree["type"]="fichier de type inconnu"
  if lettre_type=="d": entree["type"]="répertoire"
  if lettre_type=="-": entree["type"]="fichier"
  if lettre_type=="b": entree["type"]="fichier bloc spécial"
  if lettre_type=="c": entree["type"]="fichier caractère spécial"
  if lettre_type=="l": entree["type"]="lien symbolique"
  if lettre_type=="p": entree["type"]="tube nommé"
  if lettre_type=="s": entree["type"]="socket"

  return entree

def exec_analyse(repertoires):
  cmd1=['ls','-AlRZ','--time-style=long-iso']+repertoires
  cmd2=['grep','-v','-e','^total','-e','^$']

  p1=Popen(cmd1,stdout=PIPE,stderr=PIPE)
  p2=Popen(cmd2,stdin=p1.stdout,stdout=PIPE,stderr=None)

  lignes=p2.communicate()[0].splitlines()

  repcourant=""
  entrees   ={}
  for ligne in lignes:
    if ligne.startswith("/"):
      repcourant=ligne[0:-1]
    else:
      entree=decoupe_entree(ligne)
      entrees[join(repcourant,entree['nom'])]=entree

  return entrees

def compare_entree(avant,apres):
  differences=[]
  comparaisons={
    "type"        : "le type a changé",
    "proprietaire": "le propriétaire a changé",
    "groupe"      : "le groupe a changé",
    "contexte"    : "le contexte SELinux a changé",
    "taille"      : "la taille a changé",
    "jour"        : "la date de modification a changé",
    "heure"       : "l’heure de modification a changé"
  }

  for composant in comparaisons:
    if avant[composant]!=apres[composant]:
      differences.append(comparaisons[composant]+" (%s → %s)"%(avant[composant],apres[composant]))

  return differences

def compare_entrees(entrees_avant,entrees_apres):
  ajouts       =[]
  suppressions =[]
  modifications=[]

  # Recherche les suppressions et les modifications
  for entree in entrees_avant:
    if entree not in entrees_apres:
      # Entrée supprimée
      suppressions.append(entree)
      continue

    if entrees_avant[entree]!=entrees_apres[entree]:
      # Entrées différentes
      modifications.append(entree)

  # Recherche les ajouts:
  for entree in entrees_apres:
    if entree not in entrees_avant:
      # Nouvelle entrée
      ajouts.append(entree)

  return [ajouts,suppressions,modifications]

def prepare_nom(chemin):
  chemin=chemin.replace("&","&amp;").replace(">","&gt;").replace("<","&tt;")
  return dirname(chemin)+"/<strong>"+basename(chemin)+"</strong>"

def affiche_differences(entrees_avant,entrees_apres,ajouts,suppressions,modifications):
  html ='<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN" "http://www.w3.org/TR/html4/strict.dtd">\n'
  html+='<html lang="fr">\n'

  html+='<head>\n'
  html+='<title>Suivi des modifications</title>\n'
  html+='<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />\n'
  html+='</head>\n'

  html+='<body>\n'
  html+='<h1>Suivi des modifications</h1>'

  html+='<h2>Ajouts</h2>\n'
  if len(ajouts)==0:
    html+='<p>Aucun ajout</p>\n'
  else:
    html+='<ul>\n'
    for ajout in ajouts:
      html+='<li>'+prepare_nom(ajout)+' (<i>'+entrees_apres[ajout]["type"]+'</i>)</li>\n'
    html+='</ul>\n'

  html+='<h2>Suppressions</h2>\n'
  if len(suppressions)==0:
    html+='<p>Aucune suppression</p>\n'
  else:
    html+='<ul>\n'
    for suppression in suppressions:
      html+='<li>'+prepare_nom(suppression)+' (<i>'+entrees_avant[suppression]["type"]+'</i>)</li>\n'
    html+='</ul>\n'

  html+='<h2>Modifications</h2>\n'
  if len(modifications)==0:
    html+='<p>Aucune modification</p>\n'
  else:
    html+='<ul>\n'
    for modification in modifications:
      html+='<li>'+prepare_nom(modification)
      diffs=compare_entree(entrees_avant[modification],entrees_apres[modification])
      html+='<ul>\n'
      for diff in diffs:
        html+='<li>'+diff+'</li>\n'
      html+="</ul>\n"
      html+='</li>\n'
    html+='</ul>\n'

  html+='</body>\n'
  html+='</html>'

  return html  

if len(sys.argv)>=2:
  rep_donnes=sys.argv[1:]
else:
  rep_donnes=Popen(['zenity','--file-selection','--directory','--multiple'],stdout=PIPE).communicate()[0].splitlines()[0]
  if rep_donnes=="": exit(0)
  rep_donnes=rep_donnes.split('|')

repertoires=[]
for rep in rep_donnes:
  rep=rep.strip()
  if rep=="": continue
  rep=abspath(rep)
  if rep in repertoires: continue
  repertoires.append(abspath(rep))

if len(repertoires)==0: exit(0)

entrees_avant=exec_analyse(repertoires)

call(["zenity","--info","--title=Premier cliché réalisé","--text=Un premier cliché du répertoire a été réalisé.\nVeuillez cliquer sur le bouton pour lancer le second et afficher les différences"])

entrees_apres=exec_analyse(repertoires)

(ajouts,suppressions,modifications)=compare_entrees(entrees_avant,entrees_apres)

html=affiche_differences(entrees_avant,entrees_apres,ajouts,suppressions,modifications)
sortie=NamedTemporaryFile(suffix=".html")
sortie.write(html)
sortie.flush()
call(["yelp",sortie.name])

Con solo un comando podemos enviar mensajes de error, información, etc. Pero hay que tener instalado ssh.

Para instalar ssh escribimos en la terminal:

sudo aptitude install ssh

Ya que tenemos instalado ssh, entramos en el ordenador al que le queremos enviar el mensaje con la línea de comandos:

ssh usuario@IP

Donde:

• usuario, es el usuario del PC al que queremos entrar.
• IP, es la IP del PC al que queremos entrar.

Una vez dentro, ejecutamos para enviar el mensaje, el comando:

zenity --error --text "Esto es una prueba" --display :0

donde:

• zenity, es el comando que necesitamos.
• –error, es el tipo de mensaje que queremos enviar. Para ver todos los tipos de mensajes que hay, puedes poner en la terminal:

man zenity

y buscas todos los tipos de mensajes que podrás poner.

• –text, sirve para que podamos escribir el texto.
• “Esto es una prueba”, es el texto que queremos escribir en el mensaje.
• –display :0, es obligatorio ponerlo, sino, no funcionaría.

Are you thinking to search and query for google from terminal shell with bash script. And what if you want to redirect the output to a text file. You can do it with the following code.

This code also features zenity in order to save the output and query for what you are searching. This code is very productive and you can use it for many purposes.

Enjoy!


#!/bin/bash

squery=$(zenity --text)
file="/home/tushar/Desktop/search.txt"
(lynx "http://www.google.com/search?q=$(echo $squery|sed -e 's/+/%2B/g' -e 's/ /+/g')">$file) | zenity --progress \
--title="Quering for the provided tag in google" \
--text="Searching google ..... "\
--percentage=0
-- pulsate


I use Songbird 1.0.0 to listen to music and manage my ipod, and it’s a really great app with many cool features and add ons. The only feature I was missing was iTunes-style library consolidation – where all your music files are copied to folders on your hard drive by artist  then album.

Being new to the Linux environment as well as Python I decided that a good excercise in learning both would be to make my own little script to consolidate a Sonbird library. And so jerome was born.

jerome uses python with pysqlite to access the Songbird library and zenity as a simple GUI, with output folder selection and progress bar.

So if anyone out there is using Songbird and wishes to consolidate their music library, check out jerome!

jerome – Google Code.

Hi,

I have just written a script which should help everyone who wants to configure which programs wine uses to open certain filetypes (e.g. you can set all .doc files to open with OpenOffice.org). The script is written in bash and uses zenity and sed.

Look here for more info:

http://opensuse1501.wordpress.com/my-programsscripts/

Additional Features form old version

## Snooze for 10mins
## Starts triggering only if HDD temperature above 40 degrees
## Pops when temp is above 49 degrees wateva the time it is 
## Additional package needed from previous version : hddtemp
## Resets the counter to 60 when system goes idle for 5 mins

sudo apt-get install hddtemp

The new code is
work=TRUE
tee=40
teex=49
echo "60" > /home/cyriac/logs/timeupdude/testf
while [ $work = TRUE ]
do
hdte=`sudo hddtemp -n /dev/sda1|cut -d':' -f3|sed 's/ //g'`
if [ $hdte -lt $tee ]
then
test=cont
fi
if [ $hdte -gt $tee ]
then
timeot=w|grep x-session-m|cut -d':' -f3|cut -d' ' -f5|cut -d'.' -f1
if [ $timeot > 5 ]
then
echo "60" > /home/cyriac/logs/timeupdude/testf
fi
tt=`cat /home/cyriac/logs/timeupdude/testf`
#echo $tt
if [ $tt -eq 0 ]
#if [ $x >10 ]
then
#if [ $hrs -eq $con ]
#then
# work=FALSE
ans=`zenity --title "TIME UP DUDE" --text "YOUR UPTIME IS OVER AN HOUR NOW " --list --radiolist --column "SELECTION" --column "ACTION" False SHUTDOWN True CONTINUE_WORKING(next_pop_at_30mins) False SNOOZE_for_10mins`
if [ $ans = CONTINUE_WORKING\(next_pop_at_30mins\) ]
then
push=30
fi
if [ $ans = SNOOZE_for_10mins ]
then
push=10
fi

done

please leave comments on the code

Necessity is the mother of all inventions. Yes that is true. And for inventions to take place there should be a motivator.

I had very bad HDD crashes recently and i think the problem is the extreme use of my system which is on almost for 22 hrs a day on holidays and 14hrs on weekdays.

So i decided to make a tool to notify me when it is 1hr of use and give me options to shutdown and continue using.
This was the first thing i did after installing an OS on the replaced HDD this time. My of the insipriation for trying it out is my senior at college srijith.

He also has a similar tool but more better.
So here goes the stuff.

my username is cyriac
and i belong to a group script on my system.

Basic things to do prior to working my script.

edit the sudoers file.
log in as root
visudo
add the line
%script ALL=NOPASSWD: ALL

note that i belong to the group script
now create a folders in the home directory with names /logs and /logs/timeupdude

mkdir ~/logs/timeupdude -p

make a textfile with name timeupdude
and paste the code below.

work=TRUE
echo "60" > /home/cyriac/logs/timeupdude/testf
while [ $work = TRUE ]
do
tt=`cat /home/cyriac/logs/timeupdude/testf`
if [ $tt -eq 0 ]
then
ans=`zenity - -title "TIME UP DUDE" - -text "YOUR UPTIME IS OVER AN HOUR NOW " - -list - -radiolist - -column "SELECTION" - -column "ACTION" False SHUTDOWN True CONTINUE_WORKING`
if [ $ans = CONTINUE ]
then
echo "60" > /home/cyriac/logs/timeupdude/testf
else
sudo shutdown -ah now
fi
else
sleep 60
tt=`expr $tt - 1`
echo $tt> /home/cyriac/logs/timeupdude/testf
fi
done

Save the file and make it excec by

chmod +x timeupdude

copy the file to /etc/init.d
and add it to the boot up

update-rc.d timeupdude defaults

Now restart the computer and the timeupdude is on the run..
The tool first shows the screen below when it is 1hr.

If SHUTDOWN is pressed the system shuts down else if CONTINUE_WORKING is pressed you can continue working until this window again pops up in 30mins

You can also edit the time by scannin my script.
And this script works with Gnome machines only.

Please note that the options in the zenity needs to be – - ie minusminus. not –
Will come up with a new version with the ideas my `guru`;) suggested..

New code available

Please leave comments so that i can find mistakes i made and improve..

Depuis que Debian me fait des misères, il me faut redémarrer sous Ubuntu pour jouir de la télévision (heureusement, ce supplice est rare, mais bon, la C1 étant repartie je ne désespère pas de voir bientôt les multiples défaites lyonnaises, par exemple hein

Attendre patiemment l’invite de Grub c’est loin d’être palpitant, tout comme devoir le laisser paramétré à 5s, c’est un temps fou de perdu à chaque démarrage !

Bref, ceci peut très bien être appliqué à un redémarrage sous n’importe quel OS, par exemple sous Windows pour les plus fous d’entre nous

Passons aux choses sérieuses et modifions le fichier /boot/grub/menu.lst (avec les droits root, gedit /boot/grub/menu.lst par exemple) plus particulièrement le passage
default 0
que nous transformons en
default saved
comme expliqué juste au dessus :
# You can specify 'saved' instead of a number. In this case, the default entry
# is the entry saved with the command 'savedefault'.

Maintenant, il nous faut donc modifier le fameux savedefault, c’est bien, vous êtes bilingue et vous suivez !

Nous nous rendons donc dans la section concernant le système “alternatif”, chez moi Ubuntu, elle ressemble à ça :
title Ubuntu, kernel 2.6.20-15-generic
root (hd0,0)
kernel /boot/vmlinuz-2.6.20-15-generic [...]
initrd /boot/initrd.img-2.6.20-15-generic
quiet

Et nous rajoutons la ligne
savedefault 0

Le 0 correspond au (n-1)ième title dans le menu grub, ce qui veut dire que le décompte commence à 0 et que l’éventuelle ligne “Other OS…” est comptée. Pour le premier système d’exploitation, il faut donc indiquer 0.

Bien, maintenant que le menu grub est paramétré, découvrons la commande magique : grub-set-default

Celle-ci fonctionne de la même manière que précédemment, pour que le prochain démarrage se fasse sur le système d’exploitation correspondant au 3e title il faut donc indiquer
grub-set-default 2

Et voilà

Vous avez compris le principe ? Vous savez donc désormais comment jongler avec vos systèmes d’exploitation, sans oublier en cas de jonglage multisystème le fameux savedefault x où il se doit.

Bonus track : le script de tonton Bionic pour redémarrer, attention, ça décoiffe !

#!/bin/bash

if zenity --question --title "Redémarrer sous Ubuntu ?" --text 'Redémarrer sous Ubuntu ?' ;
then
grub-set-default 2
reboot
else
exit
fi

Le tout appelé en gksu par une icône sur le tableau de bord, l’est fort quand même ce Bionic…

Have fun !

It’s been a while since I last blogged, because I’ve been quite busy lately and haven’t found an interesting topic to blog about.

I’ve asked my good friend, Bernd, to write a small application for me that would let me edit the EXIF data of my photos. He wrote me this basic tool that pretty much just adds a comment to the EXIF data of my photos.

You start the application, then a little pop-up dialog appears and asks you to type in the text for your comment field. After choosing the right text you click OK, and then you can select the photos you want to provide with this comment. It’s very easy, and very similar to ID3-tagging with mp3s.

The tool is written in Python, which means it’s platform independent and you can run it everywhere where Python is installed. It depends on the following packages zenity and exiv2, so make sure you have these installed before running the application.

Download the source code from here and then rename it from ‘ec.sh.txt’ to ‘ec.sh’. You can now run exif comment from your console by typing sh ec.sh or simply make a shortcut on your desktop to ‘./ec.sh’. As said before this will run anywhere and you don’t need to install it, just run it as it is.

If you know a similar tool, that is even more powerful, then please let me know. Also if you have any ideas on how it could be improved let me know and I’ll pass it onto Bernd.

Enjoy your Exif Comment!

Here is an example of Zenity progress pulsate bar dialog. Depending on your desktop manager your output may be different:

yes | zenity --progress --width 350 --pulsate --text "Testing Zenity Progress Bar" --title "Zenity Pulsate Progress Bar"

Spesso vorremmo scaricare o vedere un video da youtube. Purtroppo youtube necessita di flash player, una applicazione proprietaria che, per Linux, va solo su x86. Proprio oggi ho dovuto configurare un ibook g3 (processore ppc), e ho elaborato un sistema per risolvere il problema. Un semplice script che, una volta immesso il link della pagina dove è presente il video, scarica il filmato in formato flv. A questo punto possiamo aprirlo con VLC o un programma che usi xine, come gxine o totem-xine. Consiglio di mettere lo script in /usr/share/bin, in modo tale da poter essere richiamato facilmente, nel caso dovessimo richiamarlo da linea di comando o da uno starter da mettere sul nostro pannello di gnome/kde/xfce. Lo script richiede zenity, wget e youtube-dl per funzionare. Creiamo un file, chiamato youtube-download.sh, con questo codice:


#!/bin/bash
URL=$(youtube-dl -g $(zenity --entry --title="Youtube Download" --text="Inserisci qui il link del video"))
NAME=$(zenity --entry --title="Youtube Download" --text="Inserisci il nome del video")
wget $URL -O "$NAME.flv" 2>&1 | sed -u 's/.*\ \([0-9]\+%\)\ \+\([0-9.]\+\ [KMB\/s]\+\)$/\1\n# Downloading \2/' |\
zenity --progress --title="Downloading..."

Se vogliamo che alla fine del download venga avviato il video, basta inserire alla fine:

vlc "$NAME.flv"

…oppure, al posto di vlc, mettere gxine o totem. Se vogliamo che questi video finiscano direttamente in una cartella, tra la prima e la seconda riga dello script, inseriamo:

cd /home/utente/youtube/

…dove /home/utente/youtube è il percorso dove avremo i nostri video.
Ricordate che per poter eseguire lo script dovete dare il permesso di esecuzione, con:

chmod +x youtube-download.sh

Il bello di questo script è che non necessita di essere avviato da terminale, in quanto si basa su zenity; una applicazione gtk che permette di visualizzare semplici finestre che, in questo caso, ci permettono di inserire informazioni o di visualizzare lo stato di un download.

Lo script è migliorabile ovviamente, si possono inserire più opzioni o modificarlo a proprio piacimento. Spero che possa esservi utile