Manualinux
http://www.nvu.com http://www.gimp.org InicioPresentaciónActualizacionesManualesDescargasNoticiasAgradecimientoEnlaces

Entornos GráficosAplicaciones

Administradores de SesionesAdministradores de VentanasEscritoriosUtilidades de Escritorio

Administradores de Ventanas - Fvwm-CrystalAdministradores de Ventanas - JWM

Administradores de Ventanas - Golem




Administradores de Ventanas - Golem




Copyright

Copyright © José Luis Lara Carrascal  2006-2018   http://manualinux.eu



Sumario

Introducción
Características
Preliminares
Instalación
Configuración de Golem
1) El archivo de configuración principal
2) Editar el menú de aplicaciones
3) Configurar la minimización de las ventanas
4) Configurar las opciones del paginador
5) Configurar el dock de Golem
6) Configurar el plugin setroot
7) Aplicaciones al inicio de Golem
Configurar el inicio de Golem
Iniciamos Golem
Enlaces




Introducción

Golem es un administrador de ventanas muy similar a WindowMaker, incluso existe un script que permite convertir los estilos del segundo al primero. Al estar en desarrollo hace que sea un poco más inestable que WindowMaker pero en mi opinión el soporte de Plugins lo convierte en un administrador de ventanas altamente personalizable. Quizá a los que no les guste tirar del editor de texto para configurar su entorno se les atragante un poco, pero para los que están acostumbrados a esa tarea, Golem se convierte en una perita en dulce. El programa no soporta fuentes suavizadas ni codificación de caracteres UTF-8, lo que supone un inconveniente para los usuarios que tengan las locales establecidas en es_ES.UTF-8.



Características  

* Bajo consumo de memoria
* Soporte de temas
* Soporte de atajos de teclado
* Múltiples escritorios virtuales
* Soporte de animaciones y sonido
* Soporte multipantalla Xinerama
* Plugins



Preliminares  

1) Comprobar que la ruta de instalación de los binarios del programa la tenemos en nuestro PATH


Abrimos una ventana de terminal y ejecutamos el siguiente comando,

[jose@Fedora-18 ~]$ echo $PATH
/usr/lib/qt-3.3/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:/home/jose/bin

Si no aparece entre las rutas mostradas el directorio /usr/local/bin, abrimos un editor de texto y añadimos lo siguiente,

#!/bin/sh

export PATH=/usr/local/bin:$PATH

Lo guardamos con el nombre variables.sh, y lo instalamos en /etc/profile.d.

$ su
# install -m755 variables.sh /etc/profile.d

Tenemos que cerrar el emulador de terminal y volverlo a abrir para que la variable de entorno aplicada sea efectiva. Es conveniente guardar una copia de este script para posteriores instalaciones de nuestro sistema, teniendo en cuenta que es el que se va a utilizar a partir de ahora en todos los manuales de esta web, para establecer variables de entorno globales, excepto en aquellas que sólo afectan al usuario, en las que se utilizará el archivo de configuración personal, ~/.bashrc.

La ventaja de utilizar el directorio /etc/profile.d es que es común a todas las distribuciones y nos evita tener que editar otros archivos del sistema como por ejemplo, /etc/profile.

2) Desinstalar versiones anteriores del programa ubicadas en el directorio /usr

Aún en el caso de que la versión a compilar la vayamos a instalar en el mismo directorio que la que proporciona la distribución, siempre se debe desinstalar previamente la versión antigua, para evitar conflictos innecesarios.



Instalación

Dependencias

Herramientas de Compilación


Entre paréntesis la versión con la que se ha compilado Golem para la elaboración de este documento.

* GCC - (7.2.0)
* Make - (4.2.1)
* Automake - (1.15.1)
* Autoconf - (2.69)
* Bison - (3.0.4)
* Flex - (2.6.4)

Librerías de Desarrollo

* Xorg - (7.7 / xorg-server 1.19.6)
   LibICE - (1.0.9)
   LibX11 - (1.6.5)
* ESD - (0.2.41)



Descarga

golem-0.0.6.tar.bz2

Optimizaciones

Golem no compila con las habituales optimizaciones que se aplican en los manuales de la web.

Extracción y Configuración  Bloc de Notas Información general sobre el uso de los comandos

$ tar jxvf golem-0.0.6.tar.bz2
$ cd golem-0.0.6
$ sed -i '104c/* #include <asm/system.h> */' complib/asm-i386/cl_atomic_asm.h
$ ./configure --disable-dependency-tracking --enable-sound --mandir=/usr/local/share/man

Explicación de los comandos

sed -i '104c/* #include <asm/system.h> */' complib/asm-i386/cl_atomic_asm.h : Soluciona un error producido por la ausencia del archivo de cabecera, /usr/include/asm/system.h. El mensaje de error mostrado en la terminal es el siguiente:

In file included from /home/jose/descargas/golem-0.0.6/complib/cl_atomic_osd.h:87:0,
                 from /home/jose/descargas/golem-0.0.6/complib/cl_atomic.h:84,
                 from cl_threadpool.c:82:
/home/jose/descargas/golem-0.0.6/complib/asm-i386/cl_atomic_asm.h:104:24: error fatal: asm/system.h: No existe el fichero o el directorio
compilación terminada.
make[2]: *** [cl_threadpool.o] Error 1
make[1]: *** [all] Error 2
make: *** [all] Error 2

--disable-dependency-tracking : Acelera el tiempo de compilación.
--enable-sound : Activa el soporte de eventos de sonido.

--mandir=/usr/local/share/man : Instala la página de manual del programa en /usr/local/share/man, en lugar de /usr/local/man.

Compilación

$ make

Parámetros de compilación opcionales  

-j2 : Si tenemos un procesador de doble núcleo (dual-core), y el kernel está optimizado para el mismo y es SMP, con este parámetro aumentaremos el número de procesos de compilación simultáneos a un nivel de 2 y aceleraremos el tiempo de compilación del programa de forma considerable.
-j4 : Lo mismo que arriba pero con procesadores de 4 núcleos (quad-core).

Instalación como root

$ su -c "make install"

Instalación de los archivos de configuración personal en nuestro home

$ golem.install

Este comando copiará los archivos de configuración a ~/.golem y nos preguntará, en caso de que tuvieramos un archivo ~/.xinitrc o un archivo ~/.xsession si lo queremos sobreescribir para que Golem se inicie al ejecutar startx o desde XDM, en el caso del segundo.

Estadísticas de Compilación e Instalación de Golem

Estadísticas de Compilación e Instalación de Golem
CPU AMD Athlon(tm) II X2 260 Processor
MHz 3214.610
RAM 4096 MB
Sistema de archivos XFS
Versión de Glibc 2.26
Enlazador dinámico GNU gold (Binutils 2.29.1) 1.14
Compilador GCC 7.2.0 + Ccache 3.3.4
Parámetros de compilación -j2
Tiempo de compilación 17"
Archivos instalados 288
Mostrar/Ocultar la lista de archivos instalados
Ocupación de espacio en disco 2,8 MB

Consumo inicial de CPU y RAM de Golem

Consumo inicial de CPU y RAM de Golem
Proceso
CPU Memoria física
golem 0 % 3,3 MB

Directorio de configuración personal

~/.golem Es el directorio de configuración personal de Golem en nuestro home.
~/.golem/mythemes Los temas que nos bajemos de la red y los originales que hayamos editado, los copiamos a este subdirectorio.
~/.golem/themes@ Enlace simbólico que apunta al directorio del sistema donde están ubicados los temas que trae por defecto el programa.
~/.golem/plugins Es el subdirectorio que contiene todos los complementos de Golem.
~/.golem/golemrc Es el archivo de configuración principal del programa.
~/.golem/autostart Un ejemplo de script de inicio de aplicaciones, cuya configuración explico más abajo.

Desinstalación como root

1) MODO TRADICIONAL

En el directorio de compilación ejecutamos el siguiente comando:

$ su -c "make uninstall"

2) MODO MANUALINUX  

El principal inconveniente del comando anterior es que tenemos que tener el directorio de compilación en nuestro sistema para poder desinstalar el programa. En algunos casos esto supone muchos megas de espacio en disco. Con el paquete de scripts que pongo a continuación logramos evitar el único inconveniente que tiene la compilación de programas, y es el tema de la desinstalación de los mismos sin la necesidad de tener obligatoriamente una copia de las fuentes compiladas.

golem-0.0.6-scripts.tar.gz

$ su
# tar zxvf golem-0.0.6-scripts.tar.gz
# cd golem-0.0.6-scripts
# ./Desinstalar_golem-0.0.6

Copia de Seguridad como root

Con este otro script creamos una copia de seguridad de los binarios compilados, recreando la estructura de directorios de los mismos en un directorio de copias de seguridad (copibin) que se crea en el directorio /var. Cuando se haya creado el paquete comprimido de los binarios podemos copiarlo como usuario a nuestro home y borrar el que ha creado el script de respaldo, teniendo en cuenta que si queremos volver a restaurar la copia, tendremos que volver a copiarlo al lugar donde se ha creado.

$ su
# tar zxvf golem-0.0.6-scripts.tar.gz
# cd golem-0.0.6-scripts
# ./Respaldar_golem-0.0.6

Restaurar la Copia de Seguridad como root

Y con este otro script (que se copia de forma automática cuando creamos la copia de respaldo del programa) restauramos la copia de seguridad como root cuando resulte necesario.

$ su
# cd /var/copibin/restaurar_copias
# ./Restaurar_golem-0.0.6



Configuración de Golem  Bloc de Notas

1) El archivo de configuración principal  

1a) ~/.golem/golemrc


Es el archivo de configuración principal de Golemen el mismo se configura el tema que vamos a cargar, el número de escritorios virtuales que queremos usar, el tipo de enfoque de las ventanas, los atajos de teclado y por último los plugins que queremos que se carguen al inicio. Hay más opciones pero éstas son las más destacables, así que voy por partes.

#
# Include theme rcfile
#
#.include "themes/MudGolem/rc"
#.include "themes/eBlueSteel/rc"
#.include "themes/twm/rc"
#.include "themes/AbsoluteE/rc"
#.include "themes/microGUI/rc"
.include "mythemes/KristallGolem/rc"

1b) Temas

Los temas que trae por defecto están en el directorio ~/.golem/themes que es un enlace al directorio principal donde se ha instalado Golem. Los temas de usuario se instalan en el directorio ~/.golem/mythemes y para cargarlos hay que editar la sección del archivo de configuración siguiente:

#
# Include theme rcfile
#
#.include "themes/MudGolem/rc"
#.include "themes/eBlueSteel/rc"
#.include "themes/twm/rc"
#.include "themes/AbsoluteE/rc"
#.include "themes/microGUI/rc"
.include "mythemes/KristallGolem/rc"

El tema que deseemos cargar se descomenta, en este caso es el KristallGolem.

1c) Los escritorios virtuales y el aspecto visual de la ventana al desplazarla

El número de escritorios virtuales y la opción de desplazamiento opaco de la ventana se configuran en esta sección:

    desktop_count        2;
    desktop_width        2;
    desktop_height        1;
    fullscreen_zoom        true;
    opaquemove        false;

    # use to change the color/width of the line used to draw
    # winboxes.
    #linewidth        3;
    #linefg            "green";

Definición de los elementos configurables relativos a los escritorios virtuales y el aspecto visual de la ventana al desplazarla
desktop_count      2; Define el número de escritorios virtuales a utilizar. 
desktop_width      2; Define el número de vistas (viewports) proporcionales a la resolución de la pantalla por las que se multiplicará el espacio disponible para un escritorio virtual, en horizontal.
desktop_height      1; Define el número de vistas (viewports) proporcionales a la resolución de la pantalla por las que se multiplicará el espacio disponible para un escritorio virtual, en vertical. 
fullscreen_zoom        true; Si lo establecemos en false, las ventanas no se podrán poner a pantalla completa.
opaquemove        false; Si lo establecemos en true, se mostrará el contenido de las ventanas al desplazarlas. Por defecto se muestra sólo el contorno de la figura geométrica de la ventana.
linewidth        3; Define la anchura en píxeles de la línea del borde de la figura geométrica de la ventana que es visible cuando la desplazamos y la opción "opaquemove" está establecida en false.
linefg             "green"; Define el color de la línea del borde de la figura geométrica de la ventana que es visible cuando la desplazamos y la opción "opaquemove" está establecida en false.

1d) El modelo de enfoque de las ventanas

Si no nos queremos volver locos con el tradicional "el enfoque sigue al ratón", dejamos este apartado bien claro, con la opción que no está comentada.

    # various focusing options
    #focus            focus_sloppy;
    #focus            focus_pointer;
    #focus_new        false;
    focus            focus_click;

1e) Atajos de teclado

Los atajos de teclado se configuran en la siguiente sección:

#
# Define hotkeys.
#
# these examples aren't mnemonic; rather they are placed to allow
# you to control all keyboard stuff from the left hand, so that
# you may leave the right hand on the mouse.  Needless to say,
# that leaves left-handers with a bit of a problem...  
#
# I have these using modifier keys that might not make sense
# depending on your system.  xmodmap(1) can be used to determine
# or modify modifier keys; on my machine Mod1 is the alt key,
# and Mod4 is my meta key (my Windows(tm) key is bound to Meta).
#
# another tip: if you're the sort who likes _lots_ of hotkeys,
# you may want to put your keys section in ~/.golem/keysrc and
# then just use a .include "keysrc" here.
#
keys {
    #
    # because key_command passes it's arg to /bin/sh, put an exec
    # in front of the program to prevent it from leaving an sh -c
    # process laying around
    #
    key_command        "q"    (Mod4Mask) "exec xterm";
    key_command          "j"    (Mod1Mask) "exec rox ~/";

(Mod4Mask) = Tecla "Windows"
(Mod1Mask) = Tecla "Alt"
(ControlMask) = Tecla "Ctrl"

Si por ejemplo queremos ejecutar Firefox con CONTR+ALT+F lo definimos de la siguiente manera:

key_command        "f"    (ControlMask) | (Mod1Mask) "exec firefox";

En Golem cuando pulsamos en el botón de maximizado de la ventana esta se maximiza al máximo eliminando los bordes de la misma, para volver al modo ventana pulsamos la combinación "windows" + z

1e) Plugins

Es la última sección del archivo de configuración principal, y pongo por ejemplo el mío:

#
# Plugin loading, we include from rc files, so we don't
# make a huge mess here.  Note that plugins are operated
# on in the order that they were loaded; so, for instance,
# you should choose order of precedence by putting
# wmclass_defs after mwm_hints if you want it to override
# what mwmhints has set.
#
.include "plugins/setroot/rc"
.include "plugins/pier/rc"
.include "plugins/simple_menus/rc"
.include "plugins/pager/rc"
.include "plugins/box_iconify/rc"
.include "plugins/animations/rc"
#.include "plugins/mwm_hints/rc"


# other plugins you may be interested in
#.include "plugins/sound/rc"
#.include "plugins/gnome/rc"
#.include "plugins/setroot/rc"
.include "plugins/wmclass_defs/rc"
#.include "plugins/start_slide/rc"

Es recomendable colocar el plugin setroot en la primera línea de la lista de inicio de los plugins, para no tener problemas al cargar la imagen de fondo del tema que estemos usando. El plugin mwm_hints lo comento porque no existe.

2) Editar el menú de aplicaciones  Bloc de Notas

2a) ~/.golem/plugins/simple_menus/rc


Es el menú de Golem y su edición no es nada complicada, pero para facilitar su edición, vamos a adaptar la funcionalidad de la utilidad de generación automática de menús compatibles con el estándar de freedesktop.org, Xdgmenumaker, al formato específico del menú de Golem. Abrimos con un editor de texto, el archivo de configuración del menú, y lo dejamos tal y como aparece a continuación, utilizando el mismo sistema de configuración que he empleado en el manual de Xdgmenumaker.

#
# rcfile for simple_menus plugin
#

load "simple_menus" {
    param "menu_stacklayer"    "top";    # where menus go in the stacking layer
    param "menu_button"    "3";    # button to open root menu

    param "rootmenu" "Title" {
        param "command" "Urxvt"    { param "dat" "exec urxvt"; }
        param "command" "Firefox"    { param "dat" "exec firefox"; }
        #
        # a submenu of remote host terms.
        # alternativly this may be done with:
        #.exec "menu-ssh-hosts"
        # menu-ssh-hosts is a script included with golem's distro
        # in the util directory that outputs a simple_menus param
        # subtree from your ~/.ssh/known_hosts and known_hosts2 files.
        # you need to copy it to somewhere on your PATH to use it here
        #
#XDGSTART
        param "submenu" "Remote Terminal" {
            param "command" "Bifur"        { param "dat" "exec xterm -e ssh bifur"; }
            param "command" "Bofur"        { param "dat" "exec xterm -e ssh bofur"; }
            param "command" "Bombur"    { param "dat" "exec xterm -e ssh bombur"; }
            param "command" "Fili"        { param "dat" "exec xterm -e ssh fili"; }
            param "command" "Kili"        { param "dat" "exec xterm -e ssh kili"; }
            param "command" "Thorin"    { param "dat" "exec xterm -e ssh thorin"; }
        }
        param "command" "Netscape"        { param "dat" "exec netscape"; }
        param "command" "GQmpeg"        { param "dat" "exec gqmpeg"; }
        param "command" "BitchX"        { param "dat" "exec xterm -name BitchX -e BitchX"; }
#XDGEND
        param "submenu" "Menú Golem" {
        param "command" "Regenerar el menú" { param "dat" "exec /home/jose/.golem/xdgmenu.sh "; }
            param "restart" "Reiniciar";
            param "submenu" "Otros" {
                param "restart" "Iniciar WindowMaker"    { param "dat" "wmaker"; }
                param "restart" "Iniciar BlackBox"    { param "dat" "startblackbox"; }
                param "restart" "iniciar Fluxbox"    { param "dat" "startfluxbox"; }
                param "restart" "Iniciar Afterstep"    { param "dat" "afterstep"; }
            }
            param "abort" "Cancelar";
            param "exit" "Salir";
        }
    }
}


Sustituir jose por el nombre de usuario de cada uno. Lo guardamos en la ruta ~/.golem/plugins/simple_menus/rc , limpiamos el contenido del editor y añadimos lo siguiente:

#!/bin/sh

xdgmenumaker -nf pekwm | iconv -f UTF-8 -t ISO-8859-15 > /tmp/menuxdg.txt
sed -i 's:Submenu =:param "submenu":g' /tmp/menuxdg.txt
sed -i 's:Entry =:param "command":g' /tmp/menuxdg.txt
sed -i 's:Actions = "Exec:param "dat" "exec:g' /tmp/menuxdg.txt
sed -i 's:&":";:g' /tmp/menuxdg.txt
ed -s ~/.golem/plugins/simple_menus/rc <<EOF
/#XDGSTART/+,/#XDGEND/-d
/#XDGSTART/ r /tmp/menuxdg.txt
w
q
EOF

Lo guardamos con el nombre xdgmenu.sh, le damos permisos de ejecución y lo copiamos al directorio de configuración personal de Golem en nuestro home.

$ chmod +x xdgmenu.sh
$ cp xdgmenu.sh ~/.golem/xdgmenu.sh

Haciendo clic en la entrada Menú Golem >> Regenerar el menú y posteriormente en Reiniciar, se actualizarán las entradas del menú de aplicaciones insertado.

Es muy recomendable que la configuración de la fuente de texto del menú, esté incluida en este archivo de configuración, para evitar que ésta sea sobreescrita por las que vienen con los temas. De esta forma podemos ir probando temas, sin que el tamaño de la fuente de texto del menú, sea modificado. Muy útil para los usuarios de monitores de alta resolución. Basta añadir la entrada correspondiente al mismo:

#
# rcfile for simple_menus plugin
#

load "simple_menus" {
    param "menu_stacklayer"    "top";    # where menus go in the stacking layer
    param "menu_button"    "3";    # button to open root menu
    param "menu_font"    "-*-helvetica-medium-r-normal-*-14-*-*-*-*-*-*-*";

    param "rootmenu" "Title" {

3) Configurar la minimización de las ventanas  Bloc de Notas

3a) ~/.golem/plugins/box_iconify/rc


Este plugin tiene funciones similares a la caja de iconos de Enlightenment - E16 y la opción de iconificación de las ventanas de ROX Desktop. Es lo que tradicionalmente llamamos "minimización de las ventanas", y que al no haber barra de tareas, éstas se muestran como iconos en un espacio de la pantalla o en un contenedor específico. En el caso de Golem, puede mostrar una captura de pantalla proporcional en miniatura de la ventana minimizada, opción no activada por defecto.

Los iconos minimizados de las ventanas los podemos desplazar libremente por toda la pantalla con el clic izquierdo del ratón presionado, pero por defecto se ubican siempre en la parte inferior izquierda de la misma, justamente encima de los ojos que siguen al movimiento de las ventanas y acumulándose de izquierda a derecha a medida que vamos minimizando ventanas. Se puede cambiar el emplazamiento predefinido, pero es el más recomendable, por lo menos en mi caso.

#
# load plugin
#

load "box_iconify" {
   # Pixmap used to draw the window. This pixmap is used if
   # ``take_screenshots'' has been set to ``false'' (default) or if
   # no screenshot could be taken.
   fileparam    "pixmap"        "tile.xpm";

   # Determines if the pixmap should be scaled when the icon size is greater
   # than the pixmap
   param    "scale_pixmaps"  "true";

   # Sets if screenshots should be taken or not. Default is not to
   # take screenshots.
   param        "take_screenshots"    "true";

   # Sets if icons should be scaled to match the proportion of their
   # client window.
   param        "proportional_icons"    "true";

   # Sets the size of the icon windows. Hardly any range-checking is
   # performed, so you can screw up here. You have been warned.. The
   # default is 64 (yes, pixels) which seems reasonable..
   param        "icon_size"        "64";

   # Determines what is done with a window that is smaller than the
   # screenshot icon size. if false, the icon is bigger than the src
   # window and things are scaled "up". If true, the default pixmap
   # is substituted
   param    "icon_must_be_smaller_than_src" "false";

   # Determines whether a moved icon will remember it's position for the
   # next iconification
   param    "icon_stays_when_moved" "true";

   # Determines how icons are arranged on screen. options are:
   #  "icon_follows_window", the icon will be placed under the client window
   #  "icon_on_edge", icons will be placed along the edge of the screen in a
   #                  "icon_size" grid.
   param    "icon_placement_type" "icon_on_edge";

   # Only valid if "icon_placement_type" is "icon_on_edge". Determines which edge
   # will hold the icons. options are: "top" "bottom" "left" "right"
   param    "icon_edge" "bottom";

   # Only valid if "icon_placement_type" is "icon_on_edge". Determines which edge
   # which direction the icons will be added.
   # options are: "left_to_right", "right_to_left", "top_to_bottom", "bottom_to_top"
   param    "icon_flow" "left_to_right";
}


Definición de los elementos del archivo de configuración del plugin box_iconify
fileparam  "pixmap"  "tile.xpm"; Define el archivo de imagen en formato XPM utilizado que se utilizará cuando la opción de captura de ventana está establecida en false, o la misma no se ha podido realizar.
param "scale_pixmaps" "true"; Si lo establecemos en false, la imagen anterior no será escalada al tamaño del icono de la ventana minimizada.
param "take_screenshots"  "true"; Si lo establecemos en true, se mostrará una miniatura proporcional en tamaño de la ventana minimizada. Es recomendable que esto lo pongamos en true.
param "proportional_icons" "true"; Si lo establecemos en false, el icono de la ventana minimizada no se escalará de forma proporcionada al tamaño de la misma. 
param  "icon_size"  "64"; Define el tamaño en píxeles del icono de la ventana minimizada. El tamaño por defecto es el mismo que suelen utilizar las dockapps por defecto: 64 píxeles.
param "icon_must_be_smaller_than_src" "false"; Define qué hacer cuando el tamaño real de la ventana minimizada es menor que el tamaño del icono. Escalar la ventana al tamaño del icono es el valor por defecto. 
param "icon_stays_when_moved" "true"; Define si podemos mover o no, el icono de la ventana minimizada. Por defecto sí lo podemos mover por la pantalla.
param  "icon_placement_type" "icon_on_edge"; Define el tipo de ubicación del icono de la ventana minimizada. Por defecto se ubica siempre en el borde de la pantalla en una rejilla definida por el tamaño del icono. Si utilizamos la opción icon_follows_window, el icono se mostrará justo debajo de la ventana minimizada.
param  "icon_edge" "bottom"; Define el borde de la pantalla en el que se ubicarán los iconos de las ventanas minimizadas. Los valores posibles son: top (arriba), bottom (abajo), left (a la izquierda) y right (a la derecha). 
param  "icon_flow" "left_to_right"; Define el orden de ubicación de los iconos de las ventanas minimizadas en el borde de la pantalla. Los valores posibles son: left_to_right (de izquierda a derecha), right_to_left (de derecha a izquierda), top_to_bottom (de arriba hacia abajo) y  bottom_to_top (de abajo hacia arriba)

4) Configurar las opciones del paginador  Bloc de Notas

4a) ~/.golem/plugins/pager/rc


Un administrador de ventanas con paginador incluido no deja ser nunca una opción muy interesante, y Golem nos lo proporciona. Como la información existente es inexistente, los parámetros que no entiendo los omito por defecto.

#
# load the pager plugin
#

load "pager" {
    #
    # the ratio of the size of a pager's screen to a real screen.
    # the default value is 0.04, which is appropriate for most
    # resolutions/tastes.  You can play with the value here: be
    # warned against using values that are too large, heh heh.
    #
    param "size_ratio"        "0.04";

    # this will cause the pager bgpixmap to be
    # ParentRelative.
    #param "parentrelative"    "true";

    param "nomove"            "true";

    # stacking layer (bottom, below, normal, above, top, or tiptop)
    param "pager_stacklayer"    "below";

    param "drag_button"        "2";
    param "wspace_button"        "1";

   param "focwin_pixmap_from_screenshot"  "true";
   # does nothing currently.. param "win_pixmap_from_screenshot"  "false";

    # this is how to specify pager positioning; leave it
    # out and the pager windows get stacked from 0,0 down
    #param "positions" "nop" {
    #    #this is screen,desktop x,y
    #    param "0,0" "100,20";
    #    param "0,1" "-100, -50";    # neg values wrap the screen
    #}
}

Definición de los elementos activos del archivo de configuración del plugin pager
param  "size_ratio"  "0.04"; Define el tamaño proporcional del paginador respecto a la resolución de la pantalla. El valor establecido por defecto es bastante adecuado para la mayoría de resoluciones.
param "nomove" "true"; Si lo establecemos en false, podremos desplazar el paginador por la pantalla.
param "pager_stacklayer"  "below"; Define la jerarquía de ubicación en la pantalla de la ventana del paginador respecto a las otras ventanas. Los valores posibles son: below (debajo), normal, above (encima), top y tiptop.
param "drag_button" "2"; Define el botón del ratón que será utilizado para arrastrar las ventanas por el paginador. Por defecto es el central.
param  "wspace_buttion"  "1"; Define el botón del ratón que será utilizado para cambiar de escritorio o vista en el paginador. Por defecto es el izquierdo.

5) Configurar el dock de Golem  Bloc de Notas

5a) ~/.golem/plugins/pier/rc


Es el equivalente al dock de Window Maker, podemos añadir lanzadores y las típicas "dockapp" o aplicaciones empotradas, un ejemplo de archivo de configuración que es el que uso en las capturas de pantalla.

#
# golem pier plugin, similar to windowmaker's dock
# or afterstep's wharf
#

load "pier" {
    param "singleclick"    "false"; # false is default
    param "nodragging"    "false"; # false is default

    param "pier" "vertical" {
        param "screen"    "0";
        param "x"    "-1";    # -1 means as far as possibile & fitting in screen
        param "y"    "0";
                       
                param "item" "launch" {
            param "cmd" "exec rox ~/";
            fileparam "pixmap" "home.xpm";
        }
                param "item" "launch" {
            param "cmd" "exec rox /mnt/win_c";
            fileparam "pixmap" "disco.xpm";
        }
                param "item" "launch" {
            param "cmd" "exec rox /mnt/win_d";
            fileparam "pixmap" "disco.xpm";
        }
                param "item" "launch" {
            param "cmd" "exec rox /mnt/cdrom";
            fileparam "pixmap" "cdrom.xpm";
        }
                param "item" "launch" {
            param "cmd" "exec rox /mnt/cd-rw";
            fileparam "pixmap" "cdrw.xpm";
        }
        param "item" "launch" {
            param "cmd" "exec mrxvt";
            fileparam "pixmap" "terminal.xpm";
        }
        param "item" "launch" {
            param "cmd" "exec firefox";
            fileparam "pixmap" "firefox.xpm";
        }
        # this is how to do wmaker-style dock apps
         param "item" "dock" {
            param "cmd" "exec gai-bgswitcher";   
            param "class" "gai-bgswitcher.gai-bgswitcher";       
        }
        param "item" "dock" {
            param "cmd" "exec wmix";   
            param "class" "wmix.wmix";       
        }
        param "item" "dock" {
            param "cmd" "exec asmail -withdrawn";   
            param "class" "asmail.ASMAIL";       
        }
        param "item" "dock" {
            param "cmd" "exec asclock -withdrawn";   
            param "class" "asclock.ASClock";       
        }
         param "item" "dock" {
            param "cmd" "exec wmsystemtray";   
            param "class" "wmsystemtray0.wmsystemtray";       
        }
    }

    param "pier" "horizontal" {
        # default screen, x == 0
        param "y"    "-1";

        param "item" "swallow" {
            param "cmd" "exec xeyes -geometry 42x42";
            param "class" "xeyes.XEyes";
        }
        param "item" "swallow" {
            param "cmd" "exec xclock -fg black -bg darkgrey -hl red -geometry 40x40 -padding 0";
            param "class" "xclock.XClock";
        }
    }
}


Las imágenes tienen que estar en formato XPM y es recomendable colocarlas en el directorio del plugin. El modelo de configuración para los lanzadores de aplicaciones es el siguiente:

        param "item" "launch" {
            param "cmd" "exec mrxvt";
            fileparam "pixmap" "terminal.xpm";
        }

Y para las dockapps el siguiente:

        param "item" "dock" {
            param "cmd" "exec asmail -withdrawn";   
                        param "class" "asmail.ASMAIL";       

Necesitaremos la utilidad xprop para poder identificar el parámetro WM_CLASS (STRING) de las dockapps que queramos insertar en Pier, ejecutamos por ejemplo en una ventana de terminal,  asmail, abrimos otra ventana de terminal o pestaña y ejecutamos en la misma el comando 'xprop | grep WM_CLASS', el puntero del ratón se convertirá en una cruceta y con la misma hacemos clic sobre la ventana de asmail, de la información que se muestre en la ventana de terminal, cogemos los valores mostrados sin las comillas, lo que está en rojo.

[jose@localhost ~]$ xprop | grep WM_CLASS
WM_CLASS(STRING) = "asmail", "ASMAIL"

Que es exactamente lo mismo que tenemos que poner en el archivo de configuración de Pier, unidos por un punto, como se muestra en el ejemplo.

        param "item" "dock" {
            param "cmd" "exec asmail -withdrawn";   
                        param "class" "asmail.ASMAIL";       

6) Configurar setroot  Bloc de Notas

6a) ~/.golem/plugins/setroot/rc


Es el plugin encargado de seleccionar el programa que se usará para establecer la imagen de fondo que contenga el tema que vayamos a utilizar, un ejemplo:

load "setroot" {
    #
    # here we specify how the plugin should launch an external
    # program to set the root background.  Here's how to do it
    # with wmsetbg, Esetroot, or xv.
    #

    #if you like wmsetbg
    #param "rootset_bin"        "wmsetbg";
    #param "rootset_tileflag"    "-t";
    #param "rootset_scaleflag"    "-s";

    # if you like Esetroot
    #param "rootset_bin"        "Esetroot";
    #param "rootset_scaleflag"    "-c";

    # if you use xv
    param "rootset_bin"        "fbsetbg -a";
    #param "rootset_scaleflag"    "-max";
}

En este caso he seleccionado fbsetbg, la imagen que se cargue la podemos cambiar en el directorio correspondiente del tema, de todas formas los usuarios más experimentados posiblemente elijan otras formas de cargar el fondo de pantalla. Si no queremos establecer la imagen de fondo a través del tema, tendremos que editar las correspondientes entradas referentes a la misma, y comentarlas, editando como se muestra en el ejemplo con el tema KristallGolem, el archivo de configuración ubicado en la ruta ~/.golem/mythemes/KristallGolem/forplug/setroot/rc

#
# our forplug to tell setroot what image we want on the background
#

#plugdat {
#    fileparam "imagefn" "1347.jpg";
#}

7) Aplicaciones al inicio de Golem  

A diferencia de Fluxbox, Golem no tiene script de inicio personal para añadir las aplicaciones que queremos que se inicien al mismo tiempo que el programa. Para este cometido crearemos un script con el nombre startgolem y lo copiaremos a /usr/local/bin, posteriormente crearemos un script de inicio personal con el nombre de autostart en el directorio de configuración personal de Golem, para evitar tener que editar como root, el script de inicio del programa, cada vez que queramos añadir o quitar una aplicación para que se inicie junto a Golem.

La desinstalación y respaldo del script startgolem viene incluida en los scripts correspondientes publicados con este manual. No olvidar que la última línea del script siempre tiene que estar ocupada por el comando de ejecución del administrador de ventanas.

Abrimos un editor de texto y añadimos lo siguiente:

$HOME/.golem/autostart
exec /usr/local/bin/golem

Lo guardamos como startgolem, y lo instalamos en /usr/local/bin

$ su -c "install -m755 startgolem /usr/local/bin"

Luego, en el mismo editor de texto borramos lo antes escrito y añadimos por ejemplo lo siguiente:

#!/bin/sh

cwallpaper -l
sleep 3; adesklets &


Lo guardamos como autostart, lo copiamos a ~/.golem y le damos permisos de ejecución.

$ mkdir -p ~/.golem
$ cp autostart ~/.golem
$ chmod +x ~/.golem/autostart



Configurar el inicio de Golem  

1) Para los que inician X desde terminal con el comando startx

Editamos el archivo ~/.xinitrc que se encuentra en nuestro home, si no existe lo creamos, y añadimos lo siguiente:

exec startgolem


2) XDM

Editamos el archivo ~/.xsession que se encuentra en nuestro home, si no existe lo creamos, y añadimos lo siguiente:

exec startgolem


3) GDM/KDM en OpenMandriva

Creamos un archivo y lo nombramos 42Golem, lo editamos y añadimos lo siguiente:

NAME=Golem
ICON=
EXEC=/usr/local/bin/startgolem
DESC=
SCRIPT:
exec /usr/local/bin/startgolem

Lo instalamos en el directorio /etc/X11/wmsession.d, y ejecutamos el comando fndSession para que genere los correspondientes archivos desktop que se crearán de forma automática en los respectivos directorios de ubicación de las sesiones de GDM y KDM.

$ su
# install -m644 42Golem /etc/X11/wmsession.d
# fndSession

Ubicación de los archivos desktop creados en Mandriva
GDM /etc/X11/dm/Sessions/42Golem.desktop
KDM /usr/share/apps/kdm/sessions/42Golem.desktop


4) GDM en Fedora

Abrimos un editor de texto y añadimos lo siguiente al mismo,

[Desktop Entry]
Encoding=UTF-8
Name=Golem
Comment=
Exec=/usr/local/bin/startgolem
Terminal=False
TryExec=/usr/local/bin/startgolem

Lo guardamos con el nombre golem.desktop, con la codificación de caracteres, UTF-8, y lo instalamos en /usr/share/xsessions.

$ su
# install -m644 golem.desktop /usr/share/xsessions

En el caso de KDM no es necesario crear ningún archivo, ya que éste se instala en Fedora con un número bastante amplio de archivos desktop configurados de los entornos gráficos más conocidos de GNU/Linux, entre los que se encuentra, Golem.

Ubicación de los archivos desktop creados y existentes (KDM) en Fedora
GDM /usr/share/xsessions/golem.desktop
KDM /usr/share/kde4/apps/kdm/sessions/golem.desktop


5) GDM en Slackware y derivados

Abrimos un editor de texto y añadimos lo siguiente al mismo,

#!/bin/sh
# $XConsortium: xinitrc.cpp,v 1.4 91/08/22 11:41:34 rws Exp $

userresources=$HOME/.Xresources
usermodmap=$HOME/.Xmodmap
sysresources=/etc/X11/xinit/.Xresources
sysmodmap=/etc/X11/xinit/.Xmodmap

# merge in defaults and keymaps

if [ -f $sysresources ]; then
    xrdb -merge $sysresources
fi

if [ -f $sysmodmap ]; then
    xmodmap $sysmodmap
fi

if [ -f $userresources ]; then
    xrdb -merge $userresources
fi

if [ -f $usermodmap ]; then
    xmodmap $usermodmap
fi

# Start the window manager:
exec /usr/local/bin/startgolem

          
Lo guardamos con el nombre xinitrc.golem, y lo instalamos en /etc/X11/xinit.

$ su
# install -m755 xinitrc.golem /etc/X11/xinit

En el mismo editor de texto que tenemos abierto, borramos lo anterior y añadimos lo siguiente,

[Desktop Entry]
Encoding=UTF-8
Name=Golem
Comment=
Exec=/etc/X11/xinit/xinitrc.golem
Icon=
Type=Application

Lo guardamos con el nombre golem.desktop, con la codificación de caracteres, UTF-8, y lo instalamos en /usr/share/xsessions.

$ su
# install -m644 golem.desktop /usr/share/xsessions

En el caso de KDM no es necesario crear ningún archivo, ya que éste se instala en Slackware y derivados con un número bastante amplio de archivos desktop configurados de los entornos gráficos más conocidos de GNU/Linux, entre los que se encuentra, Golem.

Ubicación de los archivos desktop creados y existentes (KDM) en Slackware y derivados
GDM /usr/share/xsessions/golem.desktop
KDM /usr/share/apps/kdm/sessions/golem.desktop


6) GDM en openSUSE

Abrimos un editor de texto y añadimos lo siguiente al mismo,

[Desktop Entry]
X-SuSE-translate=true
Encoding=UTF-8
Type=XSession
Exec=/usr/local/bin/startgolem
TryExec=/usr/local/bin/startgolem
Name=Golem
Comment=

Lo guardamos con el nombre golem.desktop, con la codificación de caracteres, UTF-8, y lo instalamos en /usr/share/xsessions.

$ su
# install -m644 golem.desktop /usr/share/xsessions

En el caso de KDM no es necesario crear ningún archivo, ya que éste se instala en openSUSE con un número bastante amplio de archivos desktop configurados de los entornos gráficos más conocidos de GNU/Linux, entre los que se encuentra, Golem.

Ubicación de los archivos desktop creados y existentes (KDM) en openSUSE
GDM /usr/share/xsessions/golem.desktop
KDM /usr/share/kde4/apps/kdm/sessions/golem.desktop


7) GDM en Debian y derivados

Abrimos un editor de texto y añadimos lo siguiente al mismo,

[Desktop Entry]
Encoding=UTF-8
Type=XSession
Exec=/usr/local/bin/startgolem
TryExec=/usr/local/bin/startgolem
Name=Golem

Lo guardamos con el nombre golem.desktop, con la codificación de caracteres, UTF-8, y lo instalamos en /usr/share/xsessions.

$ su
# install -m644 golem.desktop /usr/share/xsessions

En el caso de KDM no es necesario crear ningún archivo, ya que éste se instala en Debian y derivados con un número bastante amplio de archivos desktop configurados de los entornos gráficos más conocidos de GNU/Linux, entre los que se encuentra, Golem.

Ubicación de los archivos desktop creados y existentes (KDM) en Debian y derivados
GDM /usr/share/xsessions/golem.desktop
KDM /usr/share/kde4/apps/kdm/sessions/golem.desktop


8) Qingy

Abrimos un editor de texto y añadimos lo siguiente al mismo,

/usr/local/bin/startgolem

Lo guardamos con el nombre Golem, y lo instalamos en /etc/qingy/Xsessions.

$ su
# install -m755 Golem /etc/qingy/Xsessions


9) SLiM

Primero editamos el archivo /etc/slim.conf y añadimos el nombre del entorno a la lista de los que tengamos en el sistema instalados, si queremos que sea el entorno que se inicie por defecto hay que colocarlo en el primer lugar de la lista.

# Sesiones disponibles (la primera es la predefinida).
# El actual nombre de sesión es reemplazado en el login_cmd
# anterior, para que su comando de acceso pueda manejar diferentes sesiones.
# vea el archivo xinitrc.ejemplo proporcionado con el código fuente de slim.
sessions            Fluxbox,WindowMaker,Blackbox,XFce4,E17,Golem,IceWM,Openbox,ROX,Pekwm,AfterStep

Para finalizar editamos el archivo .xinitrc de nuestro home y añadimos la configuración del mismo, la variable DEFAULT_SESSION sobreescribe el entorno gráfico de inicio predefinido que pueda existir en el archivo /etc/slim.conf, permitiendo añadir el ejecutable de otro entorno que no esté configurado en el apartado anterior para ser iniciado por defecto, si queremos que sea Golem, añadimos su script de ejecución, aunque si lo tenemos configurado el primero de la lista, esto no es necesario.

# La siguiente variable define la sesión que será iniciada si el usuario
# no elige de forma explícita una sesión
DEFAULT_SESSION=startgolem

case $1 in
XFce4)
    exec startxfce4
    ;;
IceWM)
    exec icewm-session
    ;;
WindowMaker)
    exec wmaker
    ;;
Blackbox)
    exec startblackbox
    ;;
Fluxbox)
    exec startfluxbox
    ;;
E17)
    exec enlightenment_start
    ;;
Golem)
    exec startgolem
    ;;

Openbox)
    exec openbox-session
    ;;
Pekwm)
    exec pekwm
    ;;
ROX)
    exec rox-session
    ;;
AfterStep)
    exec afterstep
    ;;
*)
    exec $DEFAULT_SESSION
    ;;
esac

Con pulsar F1 ya podremos seleccionarlo de la lista e iniciarlo, si es el predefinido no es necesario seleccionarlo de la lista, se iniciará por defecto.



Iniciamos Golem  

Captura Golem-1


Captura Golem-2




Enlaces  


http://golem.sourceforge.net >> La web de Golem

http://golem.sourceforge.net/themes.html >>Temas

wm2golem-0.8.tar.gz >> Script que permite convertir temas de WindowMaker a Golem


Foro Galería Blog


Actualizado el 01-01-2018

Administradores de Ventanas - Golem

Administradores de Ventanas - Fvwm-CrystalAdministradores de Ventanas - JWM