If you have heard that dcop has been withdrawn, that is right. My old script for tracking music for pidgin from amarok has stopped working, and I navigated from amarok to listen. So I had to write a new one. The script keeps your current status message and updates the song to the end of the status message. So here is the script.

pidginstatusupdater

pcurrstatus=`purple-remote getstatus`
pcurrstatusmsg=`purple-remote getstatusmessage`
pcurrstatusmsg=`echo $pcurrstatusmsg| cut -d’:’ -f1`
listen=`listen -c`
purple-remote “setstatus?status=$pcurrstatus&message=$pcurrstatusmsg :: Currently listening to – $listen”
olisten=$listen
while [ TRUE ]; do
if [ "$olisten" != "$listen" ]
then
purple-remote “setstatus?status=$pcurrstatus&message=$pcurrstatusmsg :: Currently listening to – $listen”
olisten=$listen
fi
listen=`listen -c`
pcurrstatus=`purple-remote getstatus`
pcurrstatusmsg=`purple-remote getstatusmessage`
pcurrstatusmsg=`echo $pcurrstatusmsg| cut -d’:’ -f1`
done

To autostart the pidgin along with tracker i wrote a new script to start both of them, named pidgin and placed it in the first location of $PATH.

It is pidgin

/home/openhappiness/pidgin/bin/pidgin& my pidgin installation
sleep 5
/home/openhappiness/pidginstatus my musictracker location

Having problems? Do ping me.

NOTE: make sure that there is no other instance of pidginstatusupdater running.

Wearing both hats of developer and SysAdmin, I believe you shouldn’t work hard as a SysAdmin. It is for a reason that sometimes developers look at SysAdmins as inferior. It’s not because SysAdmins are really inferior, or has an easier job. I think it is mainly because a large portion of their workload could be automated. And if it can’t be automated (very little things), you should at least be able to do it quickly.

Obviously, we cannot buy time, but we can at least be efficient. In the following post I’ll introduce a few of my most useful aliases (or functions) I’d written and used in the last few years. Some of them are development related while the others could make you a happy SysAdmin.
You may find them childish – but trust me, sometimes the most childish alias is your best friend.

Jumping on the tree

Our subversion trunk really reminds me of a tree sometimes. The trunk is very thick, but it has many branches and eventually many leaves. While dealing with the leaves is rare, jumping on the branches is very common. Many times i have found myself typing a lot of ‘cd’ commands, where some are longer than others, repeatedly, just to get to a certain place. Here my stupid aliases come to help me.

lib takes me straight away to our libraries sub directory, where sim takes me to the simulators sub directory. Not to mention tr (shortcut for trunk), which takes me exactly to the sub directory where the sources are checked out. Oh, and pup which takes me to my puppet root, on my puppet master. Yes, I’m aware to the fact that you probably wonder now “Hey, is this guy going to teach me something new today? – Aliases are for babies!!”, I can identify. I didn’t come to teach you how to write aliases, I’m here to preach you to start using aliases. Ask yourself how many useful day-to-day aliases you really have defined. Do you have any at all? – Don’t be shy to answer no.

*nix jobs are diverse and heterogeneous, but let’s see if I can encourage you to write some useful aliases after all.
In case you need some ideas for aliases, run the following:

$ history | tr -s ' ' | cut -d' ' -f3- | sort | uniq -c | sort -n

Yes, this will show the count of the most recent commands you have used. Still not getting it? – OK, I’ll give you a hint, it should be similar to this:

$ alias recently_used_commands="history | tr -s ' ' | cut -d' ' -f3- | sort | uniq -c | sort -n"

If you did it – you’ve just kick-started your way to liberation. Enjoy.
As a dessert – my last childish alias:

$ alias rsrc='source ~/.bashrc'

Always useful if you want to re-source your .bashrc while working on some new aliases.

Two more things I must mention though:

1. Enlarge your history size, I guess you can figure out alone how to do it.
2. If you’re feeling generous – periodically collect the history files from your fellow team members (automatically of course, with another alias) and create aliases that will suit them too.

The serial SSHer

Our network is on 192.168.8.0/24. Many times I’ve found myself issuing commands like:

$ ssh root@192.168.8.1
$ ssh root@192.168.8.2
$ ssh root@192.168.8.3

Dozens of these in a single day. It was really frustrating. One day I decided to make an end to it:

# function for easier ssh
# $1 - network
# $2 - subnet
# $3 - host in subnet
_ssh_specific_network() {
	local network=$1; shift
	local subnet=$1; shift
	local host=$1; shift
	ssh root@$network.$subnet.$host
}

# easy ssh to 192.168.8.0/24
# $1 - host
_ssh_net_192_168_8() {
	local host=$1; shift
	_ssh_specific_network 192.168 8 $host
}
alias ssh8='_ssh_net_192_168_8'

Splendid, now I can run the following:

$ ssh8 1

Which is equal to:

$ ssh root@192.168.8.1

Childish, but extremely efficient. Do it also for other commands you would like to use, such as ping, telnet, rdesktop and many others.

The cop

Using KDE’s konsole? – I really like DCOP, let’s add some spice to the above function, we’ll rename the session name to the host we’ll ssh to, and then restore the session name back after logging out:

# returns session name
_konsole_get_session_name() {
	# using dcop - obtain session name
	dcop $KONSOLE_DCOP_SESSION sessionName
}

# renames a konsole session
# $1 - session name
_konsole_rename_session_name() {
	local session_name=$1; shift
	_konsole_store_session_name `_konsole_get_session_name`
	dcop $KONSOLE_DCOP_SESSION renameSession "$session_name"
}

# store the current session name
_konsole_store_session_name() {
	STORED_SESSION_NAME=`_konsole_get_session_name`
}

# restores session name
_konsole_restore_session_name() {
	if [ x"$STORED_SESSION_NAME" != x ]; then
		_konsole_rename_session_name "$STORED_SESSION_NAME"
	fi
}

# function for easier ssh
# $1 - network
# $2 - subnet
# $3 - host in subnet
_ssh_specific_network() {
	local network=$1; shift
	local subnet=$1; shift
	local host=$1; shift
	# rename the konsole session name
	_konsole_rename_session_name .$subnet.$host
	ssh root@$network.$subnet.$host
	# restore the konsole session name
	_konsole_restore_session_name
}

Extend it as needed, this is only the tip of the iceberg! I can assure you that my aliases are much more complex than these.

Finders keepers

For the next one I’m not taking full credit – this one belongs to Uri Sivan – obviously one of the better developers I’ve met along the way.
Grepping cpp files is essential, many times I’ve found myself looking for a function reference on all of our cpp files.
The following usually does it:

$ find . -name "*.cpp" | xargs grep -H -r 'HomeCake'

But seriously, do I look like someone that likes to work hard?

# $* - string to grep
grepcpp() {
	local grep_string="$*";
	local filename=""
	find . -name "*.cpp" -exec grep -l "$grep_string" "{}" ";" | while read filename; do
		echo "=== $filename"
		grep -C 3 --color=AUTO "$grep_string" "$filename"
		echo ""
	done
}

OK, let’s generalize it:

# grepping made easy, taken from the suri
# grepext - grep by extension
# $1 - extension of file
# $* - string to grep
_grepext() {
	local extension=$1; shift
	local grep_string="$*"
	local filename=""
	find . -name "*.${extension}" -exec grep -l "$grep_string" "{}" ";" | while read filename; do
		echo "=== $filename"
		grep -C 3 --color=AUTO "$grep_string" "$filename"
		echo ""
	done
}

# meta generate the grepext functions
declare -r GREPEXT_EXTENSIONS="h c cpp spec vpj sh php html js"
_meta_generate_grepext_functions() {
	local tmp_grepext_functions=`mktemp`
	local extension=$1; shift
	for extension in $GREPEXT_EXTENSIONS; do
		echo "grep$extension() {" >> $tmp_grepext_functions
		echo '  local grep_string=$*' >> $tmp_grepext_functions
		echo '  _grepext '"$extension"' "$grep_string"' >> $tmp_grepext_functions
		echo "}" >> $tmp_grepext_functions
	done
	source $tmp_grepext_functions
	rm -f $tmp_grepext_functions
}

After this, you have all of your C++/Bash/PHP/etc developers happy!

Time to showoff

My development environment is my theme park, here is my proof:

$ (env; declare -f; alias) | wc -l
2791

I encourage you to run this as well, if my line count is small and I’m bragging about something I shouldn’t – let me know!

Actualización: 28 de Julio de 2009. Con la salida de KDE4 DCOP fue sustituido por DBUS.

Me entero a través de Cristian (mirar primer comentario de esta entrada) que KDE ya no usa DCOP sino que ahora usa DBUS. Fué sustituido en KDE4. Por lo tanto, si a alguien le llegara a ocurrir un problema similar al mencionado en esta entrada debería ponerse en contacto con el creado del script o del programa para indicarle, a el, que DCOP está obsoleto en KDE y que ahora se usa DBUS.

Ayer me disponía a instalar un nuevo tema de íconos para mi KDE4. Dicho tema de íconos trae un script sh (¿así se dice o no?) que se debe ejecutar para que se generen los íconos correspondientes a nuestra distribución. Al momento de ejecutar el archivo sh me apareció el siguiente error:

$ ./buildset.sh
AdriX KDE icon theme buildscript
——————————–

Checking dependencies…

Checking for bzip2… found /usr/bin/bzip2
Checking for tar… found /bin/tar
Checking for convert… found /usr/bin/convert
Checking for bc… found /usr/bin/bc
checking for kdialog… found /usr/bin/kdialog

Dependencies met.

./buildset.sh: line 415: 23632 Terminado display -immutable kmenu_icons.png
ERROR: Couldn’t attach to DCOP server!
ERROR: Couldn’t attach to DCOP server!
ERROR: Couldn’t attach to DCOP server!
ERROR: Couldn’t attach to DCOP server!
./buildset.sh: line 216: [: ==: se esperaba un operador unario
ERROR: Couldn't attach to DCOP server!
./buildset.sh: line 216: [: ==: se esperaba un operador unario
ERROR: Couldn't attach to DCOP server!

Googlee un buen rato y encontré varias soluciones, casi todas relacionadas al mismo error pero que ocurre cuando se inicia una sesión en KDE. Por supuesto esas soluciones, pensé, no me servirían de mucho, ya que mi problema ocurría al tratar de ejecutar un script y no al iniciar una sesión.

Finalmente dí con un blog que contiene esta entrada, en la cual se enumeran una serie de soluciones. A continuación paso a explicar cuál funcionó para mi sistema.

DCOP es el mecanismo de IPC/RPC de KDE. Si comprendes lo que significa esta frase, puedes saltarte el siguiente párrafo.^[1]

El nombre DCOP deriva de las siglas de Desktop Communications Protocol (Protocolo de comunicaciones de escritorio), IPC viene de las siglas de Inter-Process Communication (Comunicación entre procesos); RPC son las siglas de Remote Procedure Call (Llamada a Procedimiento Remoto). Basicamente, son formas en que dos programas pueden comunicarse entre sí, ya sea dos procesos que se encuentran en la misma máquina o a través de una red.^[1] Esencialmente, DCOP es un sistema de control remoto , que permite a una aplicación o script solicitar ayuda de otras aplicaciones.^[2] En este sentido, DCOP es similar al OLE Automation de Microsoft: proporciona a los desarrolladores una forma simple de facilitar el acceso a las funciones disponibles en una aplicación.^[1]

El error que mencioné anteriormente se produce porque, al momento de ejecutar un script, que necesita ayuda de otras aplicaciones, DCOP no se está ejecutando. Para corroborar esto simplemente escribimos en la terminal dcop:

$ dcop
ERROR: Couldn't attach to DCOP server!

Esto confirma lo dicho anteriormente. Para solucionarlo, es decir, para que DCOP inicie debemos ejecutar kdeinit:

$ /usr/bin/kdeinit

Ahora volvemos a escribir dcop en la terminal y veremos los programas que lo están utilizando (o al menos no debiéramos recibir algún error). Esto indica que dcop ya está en funcionamiento.

Saludos

^[1]MundoGeek: Usando DCOP desde línea de comandos.

^[2]Wapedia:DCOP

Truly speaking, do we really admire our desktop wallpapers a lot ???.  I have large collection of desktop wallpapers and use the “Slide Show” mode for my  wallpaper. I am talking about my KDE 3.5 desktop . Most of the time my Matlab, kdevelop or my texmacs would be in use. So I miss to see the nice desktop wallpapers running behind. So I wrote this piece of code using the DCOP and Qt.

Simple steps:

a) Get the current wallpaper name using dcop interface

dcop kdesktop KBackgroundIface currentWallpaper 3

This returns the current wallpaper from desktop number 3.

e.g /home/abcd/Pictures/image1.jpg

b) Create a QWidget and a QLabel object to it. Set the pixmap property of the QLabel with the QPixmap object.

QPixmap pixmap(filename);
label->setPixmap(pixmap);

c) Additionally, If you desktop wallpaper changes as a slideshow,  you can add a QTimer object and connect the timeout signal of the timer to a function (slot) to update the pixmap of the QLabel.

Thats all floks !!

Source Files : picviewer.zip (2.4KB)

Não costumo fazer guerra religiosa com sistemas operacionais. Sempre ouço falar das facilidades que certos sistemas operacionais oferecem, e tenho que admitir que o Linux às vezes peca na usabilidade. Mesmo me considerando um usuário de Linux avançado, a instalação e configuração de um modem pode se tornar uma tarefas tortuosa. Mesmo assim, usar uma das principais distribuições Linux, para a grande maioria dos casos é fácil e agradável. Muitas coisas no Linux não são mais difíceis, só diferentes. O problema é que tolerar diferenças nunca foi uma das maiores virtudes naturais dos seres humanos.

Difícil ou fácil, o que faz o Linux assunto obrigatório para um profissional de Informática é tornar possível tarefas muito difíceis. A meu pedido recebo alguns boletos bancários em PDF (para evitar gasto de papel desnecesário), pago-os pelo sítio na Internet do banco que sou cliente. O código do boleto é algo como:

23792.37205 66281.169319 11011.260004 1 00000000000000

Não posso simplesmente copiar do boleto e cola no sítio do banco, por causa dos espaço e ponto. Preciso que quando o código for colado no sítio do banco vá sem pontos nem espaço, como:

23792372056628116931911011260004100000000000000

Em Shell posso fazer: echo ‘23792.37205 66281.169319 11011.260004 1 00000000000000‘ | sed ’s/[\.|[:space:]]//g’

A sintaxe do comando de substituição do sed é: s/RegexProcurada/ValorSubstitutivo/

O /g no final do comando faz com que todas as ocorrências que casam com a regex sejam substituída, não só a primeira. Podemos ler a regex usada como: casa com ponto ou espaço. Percebam que o campo referente ao valor a ser substituído está vázio, i.e. o que casar com o padrão será substituído por nada (vazio). Sobre regex, vale apena ler o Expressões Regulares – Guia de Consulta Rápida do Aurélio Marinho Jargas. Entre outras coisa é bem divertido.

Agora, como gravar na área de transferência, depois ler da área de transferência, modificar o conteúdo e gravar o resultado na área de transferência. É hora do milagre chamado DCOP. Com o uso desse protocolo do KDE podemos executar essa tarefa, através de um comando com o mesmo nome do protocolo. O primeiro passo é criar um script shell com os comandos requeridos.

#!/bin/bash
parselessString=`/opt/kde3/bin/dcop klipper klipper getClipboardContents`
result=`echo $parselessString | sed 's/[\.|[:space:]]//g'`
/opt/kde3/bin/dcop klipper klipper setClipboardContents $result

Na primeira linha salvamos o conteúdo da área de transferência em uma variável chamada parselessString. Na segunda, usamos a variável para que o sed possa agir no conteúdo e guardar o resultado em uma variável chamada result. Na terceira, gravamos o conteúdo de volta à área de transferência.

Se dermos mais uma olhada na primeira linha, podemos ver que através do comando dcop, chamamos do módulos klipper do aplicativo klipper, um método chamado getClipboardContents. Esse método retorna o conteúdo da área de transferência. Para gravar o resultado foi usada uma mecânica similar.

Falta ainda vencer um desafio. Como criar atalhos de teclado que de uma só vez copie o texto selecionado à área de transferência e acione o script. A resposta está nas Ações de entrada do KDE, que podem ser acessadas chamando kcontrol. Em geral podemos chegar até elas via o menu do botão principal, ou digitando kcontrol no console ou no Executar Comando (alt+f2). Uma vez no kcontrol (Configurações Pessoais), vá até Regional & Acessibilidade e depois Ações de Entrada. Basicamente temos que criar uma nova ação, dar um nome para ela, designar seu tipo como genérico, escolher o conjunto de teclas que serão gatinho para ação e finalmente acrescentar as duas ações propriamente ditas, que serão executadas ao pressionar-se as teclas gatilho. O acréscismo das ações propriamente ditas é feito com o botão Novo. Precisamos de uma entrada de teclado (ctrl+c) e uma chamada a comando (executa o script). A entrada de teclado funciona como se o usuário tivesse digitado aquela seqüência de teclas, tendo o mesmo efeito da ação real.

No exemplo que fiz com o atalho win+crtl+c, cópio para área de transfência o texto já modificado e com o crtl+v normal colo o resultado.

]]> http://grigory.wordpress.com/2008/06/03/%d0%b1%d1%83%d0%b4%d0%b8%d0%bb%d1%8c%d0%bd%d0%b8%d0%ba-amarok/ Tue, 03 Jun 2008 09:09:03 +0000 grigory http://grigory.wordpress.com/2008/06/03/%d0%b1%d1%83%d0%b4%d0%b8%d0%bb%d1%8c%d0%bd%d0%b8%d0%ba-amarok/

Вот без этого маленького трюка я бы просто не просыпался по утрам (или обедам):

Так что dcop не такая уж и плохая штука!

Пояснение:

команда “dcop amarok player play” запускает проигрывание текущей песни в амароке. Т.е., выставляем будильник (KAlarm в данном случае, умеет выполнять консольные команды) на восемь утра, выбираем песню и оставляем амарок открытым – в 8 утра песня заиграет. Главное звук сделать громче

Inspired by this post.

It is interesting how simple specialised devices cope with their functions much better than a all-in-one PC. Sometimes, I wish to fall asleep with some music on. But how annoying it becomes, when you have to get up in the middle of the night to turn off your PC, which has been playing something all this time. Digital radios have mastered the trick decades ago. Of course there is a way to make a PC do it.

Running linux, I thought that it should be fairly straightforward to shut it down after say half an hour automatically.

Something like shutdown (below) will kill the X. The KDE then will just exit without saving the session. Next time you log on, you will see some session from a distant past. If you do this often, it gets really annoying. Also this requires superuser privileges on some distributions.

/sbin/shutdown -h now "Power button pressed"
# or
halt

Then how to make KDE quit without calling any dialogs (I am sound asleep by this time and I can’t afford to wake up and press ‘OK’)? There is a way.

dcop ksmserver ksmserver logout 0 2 2

The three numbers are explained below (see source):

First parameter: confirm
Obey the user’s confirmation setting: -1
Don’t confirm, shutdown without asking: 0
Always confirm, ask even if the user turned it off: 1
Second parameter: type
Select previous action or the default if it’s the first time: -1
Only log out: 0
Log out and reboot the machine: 1
Log out and halt the machine: 2
Third parameter: mode
Select previous mode or the default if it’s the first time: -1
Schedule a shutdown (halt or reboot) for the time all active sessions have
exited: 0
Shut down, if no sessions are active. Otherwise do nothing: 1
Force shutdown. Kill any possibly active sessions: 2
Pop up a dialog asking the user what to do if sessions are still active: 3

Toda mi música la tengo organizada con Amarok y creando un programa para realizar un listado de mi colección musical me encontré con el problema de cómo conseguir la carátula de un álbum. Obtener la carátula del disco que está sonando es trivial a través de la función coverImage, que puede ser llamada desde DCOP y nos devuelve la ruta al fichero de la carátula:

[javi@cydonia ~]$ dcop amarok player coverImage

/home/javi/.kde/share/apps/amarok/albumcovers/cache/130@9b9d5ef76774f4a3e13cf02f4cb90865

El problema está cuando el disco no está sonando: no hay ninguna función disponible para pedir una carátula de un disco que esté en la colección, y tampoco hay un campo en la base de datos que indique cuál carátula corresponde a cuál álbum.

Amarok maneja las carátulas de la siguiente manera: las guarda en la carpeta ~/.kde/share/apps/amarok/albumcovers/large/ en formato PNG, asignándole como nombre el md5sum de la concatenación en minúsculas del nombre del artista y del título del álbum. Así, al disco Around The Fur de Deftones le corresponde el siguiente nombre de fichero:

[javi@cydonia ~]$ echo -n "deftonesaround the fur"|md5sum

e5f8534f07e607aad36b9c6f19a47187 -

Su carátula, por tanto, estará ubicada en ~/.kde/share/apps/amarok/albumcovers/large/e5f8534f07e607aad36b9c6f19a47187

Volviendo al problema inicial de obtener las carátulas de los discos que estén en la colección de Amarok, con DCOP podemos ejecutar consultas SQL sobre la base de datos y, por lo tanto, es posible obtener todos los nombres de artistas y de álbumes. Y si tenemos esos datos podemos saber cuál es la carátula de cada álbum. Con la siguiente consulta SQL obtendremos todas las parejas artista+disco y carátula.

SELECT DISTINCT CONCAT(artist.name, '-', album.name), CONCAT('~/.kde/share/apps/amarok/albumcovers/large/', MD5(LOWER(CONCAT(artist.name,album.name)))) FROM album, artist, tags WHERE album.id=tags.album AND artist.id=tags.artist

Para ejecutar esa consulta usamos la función query mediante DCOP:

[javi@cydonia ~]$ dcop amarok collection query "SELECT DISTINCT CONCAT(artist.name, '-', album.name), CONCAT('~/.kde/share/apps/amarok/albumcovers/large/', MD5(LOWER(CONCAT(artist.name,album.name)))) FROM album, artist, tags WHERE album.id=tags.album AND artist.id=tags.artist"

Serj Tankian-Elect The Dead Bonus CD
~/.kde/share/apps/amarok/albumcovers/large/591398f2dc2aff74627f577fd53da4e3
Linkin Park-Minutes To Midnight (Tour Edition)
~/.kde/share/apps/amarok/albumcovers/large/6d3dbccad0c4d9ceddd818d29e0ac7f7
Nirvana-Nevermind
~/.kde/share/apps/amarok/albumcovers/large/e2555e3a3bcd47ecf9d84fdacb1462a0
Linkin Park-Shadow Of The Day
~/.kde/share/apps/amarok/albumcovers/large/fe8780583e43f9f5cdf473a8fc4daf84
Linkin Park-Reanimation
~/.kde/share/apps/amarok/albumcovers/large/0717ba640841ff84c52cf846397b1b1c

Sencillo, ¿verdad?

Fuente: Amarok Forum, Amarok Wiki, Ubuntu Forums

Well the solution to getting my Play/Pause button to actually work as a play/pause toggle was pretty easy.

Amarok supports a playPause() method that is registered to the dcop server so in my hotkeys.conf file the command for the Play button became

dcop amarok player playPause

dcop is the command line based client to talk to the dcop server, amarok is of course the application I want to talk to.

player is the section of the amarok services and playPause is the function/method I want to call.

To find this out I used kdcop the graphical interface and explored what it offered under the amarok application.

ACTUALIZACIÓN: Éste tutorial és… inútil, xD (salvo si se quieren aprender algunas cosillas interesantes), la solución a los problemas que menciono és más sencilla que la expuesta en este tutorial, simplemente se tiene que instalar el paquete kmilo (o alguno que contenga el programa, dependiendo de qué distribución de Linux uséis).

Hará un tiempo mi portátil funcionaba bajo Debian Testing con KDE, en su momento lo configuré tan bien como pude y todo funcionaba de maravilla… hasta que el hardware se empezó a estropear (lo que le llevó a la muerte hará pocas semanas). Después de morir mi portátil fue transportado al cielo de los portátiles, junto con su Creador (HP) , allí se le dio una segunda oportunidad por haber sido tan bueno… y a los tres días resucitó.

El caso es que volvió a mis manos infectado con Windows (se lo contagiaron los otros ordenadores que no merecieron volver a la vida y todavía hoy permanecen en el purgatorio). A la semana conseguí curarlo con Debian Testing (KDE) pero parecía que algo no iba bién, seguía un poco acatarrado.

Por lo visto (no sé bien bien porqué) con la versión actual Testing de Debian han dejado de funcionar bien muchas cosas que antes iban como la seda: el sistema de sonido, y como no, el teclado (de ahí el título del artículo). Antes, configurar el teclado sólo consistía en tocar cuatro tonterías en los paneles de configuración de KDE (me parece que ya posteé hace tiempo sobre como hacerlo de esa manera). Ahora no es tan sencillo, y tenemos que currar un poco más (al menos en mi modelo HP Pavillion dv2104 eu).
Iremos por pasos (nota, todo lo que ponga con comillas, vosotros ponedlo SIN comillas):

1. Aplicamos el primer mini-tutorial (en mi caso todo funciona, pero Kmix no reconoce las teclas Mute, Subir Volumen y Bajar Volum, de ahí que esté haciendo este segundo mini-tutorial).
2. (Suponiendo que estamos en KDE) Vamos a Preferencias->Regional i accesibilidad->Introducir acciones.
3. Ahora crearemos una acción para Mute: Apretamos el botón ‘Nueva acción’.
4. En el campo ‘Nombre de la acción’ ponemos lo que queramos (aunque estaría bien un nombre identificativo, por ejemplo ‘Mute’).
5. En el campo ‘Tipo de la acción’ escogemos la opción ‘Acceso rápido de teclado -> Llamada a DCOP (simple)’.
6. Vamos a la pestaña ‘Acceso rápido de teclado’. Allí seleccionamos el botón que hay en medio y apretamos el botón especial Mute. (Esto sirve para indicar al programa con qué tecla asociaremos la acción).
7. Vamos a la pestaña ‘Preferencias de llamada a DCOP’. Rellenenamos el campo ‘Aplicación remota’ con el valor ‘kmix’. Rellanamos el campo ‘Objeto remoto’ con el valor ‘Mixer0′ (Hasta este paso todo se hace igual para Mute, Subir Volumen y Bajar Volumen, excepto con los nombres y las teclas asociadas, claro).
8. Para Mute el campo ‘Función llamada’ tomará el valor ‘toggleMasterMute’. Para Subir Volumen el mismo campo tomará el valor ‘increaseVolume’ y para Bajar Volumen ‘decreaseVolume’.
9. El campo ‘Argumentos’ no tomará ningún valor para Mute. Para Subir y Bajar Volumen tendremos que asegurarnos de cual es el valor apropiado. Ejecutamos en consola la siguiente instrucción para saberlo (la salida que nos dé será el número que queremos):
dcop kmix Mixer0 masterDeviceIndex
10. Apretamos el botón ‘Aplicar’ y ya estamos .
11. Para casos superespeciales (no me ha pasado): cabe destacar que yo he utilizado Mixer0 a la ligera como ‘Objeto remoto’, pero ¿No podría haber Mixer1? Creo que sí, pero no debe ser muy usual. En todo caso nos podemos asegurar ejecutando el comando (Nos dará una lista de los valores aceptables para ese campo):
    dcop kmix | grep Mixer

Espero que haya sido útil éste mini-tutorial. De hecho, creo que introduce también la idea de utilizar dcop para nuestros propios pequeños programas. Sin duda es una muy buena herramienta para intercomunicar programas.

Ala, hasta otra!

Иногда необходимо выполнить одни и теже разовые действия на нескольких однотипных серверах. Как вариант – используем Konsole с одновременным вводом на все сеансы (закладки). Вручную открывать 21 сеанс (в моем случае) довольно утомительно, поэтому написал небольшой скрипт на bash’е для автоматизации открытия консолей всех нужных серверов.

#!/bin/bash
# Запускаем konsole с расширенными возможностями управления
KONSOLE=$(dcopstart konsole-script)
# Файл ~/servers содержит список серверов через пробелы
for SERVER in `cat ~/servers`
do
    # Открываем новую вкладку (сессию) в Konsole
    SESSION=$(dcop $KONSOLE konsole newSession)
    # Переименовываем вкладку по имени сервера
    dcop $KONSOLE $SESSION renameSession $SERVER
    #Посылаем команду в сессию
    dcop $KONSOLE $SESSION sendSession "ssh root@$SERVER"
done
#Закрываем первую (открытую по умолчанию) вкладку
dcop $KONSOLE "session-1" closeSession

P.S.: для изучения dcop-функций пригодится kdcop

Si hacéis uso de la utilidad “Slide Show” de kdesktop para gestionar el fondo de pantalla puede que esta entrada os sea útil.

El problema radica es que una vez fijado el directorio del que elegir el fondo no se puede hacer un “pasa al siguiente”. O al menos yo no lo he encontrado

La posible solución era probar haciendo uso de DCOP y ha resultado tan sencillo… en fin, aquí tenéis el comando para forzar un avance dentro de la colección:

$ dcop kdesktop KBackgroundIface changeWallpaper