Scripts para suspender la computadora si usas un Gestor de ventanas (Openbox)

He vuelto!!! He vuelto luego de más de una año de ausencia, no es que me hubiera olvidado del blog, tampoco que me hubiese aburrido, simplemente, tenía demasiadas cosas por hacer y lamentablemente poco tiempo para escribir, pero lo importante es que aquí estoy de nuevo en pie de lucha, pero bueno vamos al meollo del asunto.

Actualmente estoy usando de nuevo Openbox, por su simplicidad, flexibilidad a la hora de configurar el entorno y también por que sí jeje… Bueno para gustos ya saben… Quienes están acostumbrados a usar un entorno de escritorio (Gnome, Kde), lo que me propongo a compartir puede parecer una nimiedad, una pequeña tontera sin fundamento y es que se trata de un pequeño script escrito en python que tiene como cometido suspender la computadora cuando el nivel de la batería es crítico, puntualmente cuando alcanza un nivel inferior a 17%.

Justificación

Ahora bien, a mi favor debo decir que no estoy reinventando la rueda, puesto en mi caso particular por alguna razón, el suspender mi portátil usando un gestor de energía tradicional, era una opción que no estaba disponible, ignoro la razón, pero en vez de solucionar este aparente problema, decidí crear un pequeño problema adicional y darle solución por supuesto, como resultado el Script.

Para compartirlo con ustedes aquí tienen el repositorio en GitHub

https://github.com/cooper15/pythonscripts/blob/master/SuspendComputer.py

Las instrucciones para ejecutarlo son bastante simples bastará con:

  1. Tener instalado Python 2.7.x
  2. Descargar el archivo SuspendComputer.py
  3. Colocarlo en una carpeta de su preferencia ejm: /home/cooper/.scripts
  4. Colocarlo en el autostart de Openbox ubicado en /etc/X11/openbox/autostart ejem: (sleep 2s && python /home/cooper/.scripts/SuspendComputer.py) &
  5. Reiniciar y listo.

Espero les sirva y cualquier sugerencia o mejora ya saben que pueden escribirme o dejar un comentario.

Saludos.

El blog continua con vida!!

Mi ausencia se ha prolongado por diversos motivos, entre ellos proyectos personales, la universidad (la cual dichosamente estoy por concluir), y otros asuntos que han requerido de mi tiempo. Por tanto, escribo está entrada para dejar constancia de que mi blog no esta abandonado y que en los próximos días probablemente estaré publicando nuevo contenido.

Este proyecto que empezó como un pasatiempo, se ha convertido en parte de mi vida, una parte muy importante y no me queda más que agradecerle a todos los que lo han hecho posible. ¡¡Gracias!!

Sin más que decir me despido y esperen el nuevo contenido a la brevedad.
Saludos Cooper15.

Programando en Linux: Listas enlazadas simples.

Java es un lenguaje que posee una extensa variedad de clases, entre ellas podemos encontrar las famosas colecciones de estructuras, mismas que están compuestas por listas enlazadas, pilas entre otras; lo cual si bien es cierto cumplen con todo lo que necesitamos a la hora de programar, no son validas para realizar las asignaturas en cursos universitarios o de técnicos en programación, en los cuales se prioriza el entendimiento sobre como funcionan estás estructuras de datos. Por todo lo anterior, hoy les traigo un tutorial sobre listas enlazadas, en el cual cubriré los conceptos básicos, como se construyen (a “mano”) y por supuesto, como usarlas en una aplicación.

 

¿Qué es una lista enlazada?

Podemos decir que una lista enlazada no es otra cosa que una cadena, en la cual cada uno de sus elementos está enlazado al siguiente mediante una conexión, en nuestra caso una dirección de memoria.

Pero vamos un poco más despacio, pensemos en una cadena común, de esas que se utilizan para asegurar portones, vemos en ella un conjunto de elementos conectados llamados eslabones, dichos eslabones son los que conforman la cadena y si uno de ellos pierde su conexión con el siguiente, entonces la cadena se rompe; de igual forma  en una lista enlazada, cada eslabón (llamado nodo, tradicionalmente) está conectado al siguiente y es este conjunto de nodos son los que conforman la lista, si uno de ellos pierde su conexión con el siguiente, entonces jamás podremos acceder a los nodos posteriores.

nicubunu_Chain¿Qué elementos conforman una lista enlazada?

Como mencioné recién, una lista enlazada está compuesta por eslabones llamados nodos, estos nodos están conectados mediante referencias a direcciones de memoria, pero debemos hablar sobre un eslabón muy importante, el primero que conforma la lista, hace poco dije que si un nodo pierde su conexión con el siguiente entonces  sería imposible acceder a los nodos posteriores, por lo tanto y por sentido común, notamos que si se pierde la dirección del primer elemento, la lista completa quedará inaccesible, así que el nodo más importante en nuestra lista es sin lugar a dudas el primero que la conforma.

A su vez, cada nodo está conformado por dos partes, la primera llamada parte de datos es la que permite almacenar lo que el programador desea guardar, por ejemplo un String, un Int, e inclusive una clase, y la segunda la dirección de memoria de la que tanto he hablado.

NodoAhora bien, para crear un nodo necesitamos crear una clase que contenga estos dos elementos y luego naturalmente un objeto para manipular la lista.

¿Qué  operaciones se pueden realizar sobre una lista enlazada?

Las operaciones básicas en una lista son 4:

  1. Insertar un elemento
  2. Mostrar la lista completa
  3. Buscar y (mostrar o modificar) un elemento
  4. Eliminar un elemento
 Manos a la obra:

En este tutorial veremos las dos primeras operaciones, Insertar un elemento y Mostrar el contenido de la lista, pero antes de pasar al código necesitamos entender el fundamento de cada operación.

Insertar un elemento en una lista enlazada:

Para insertar un elemento dentro de una lista enlaza, primero debemos entender que sucede con la lista, es decir, requerimos conocer el estado de la lista (si está vacía o por el contrario si posee elementos).

En caso de que la lista esté vacía procederemos de la siguiente manera:

  1. ElementoaInsertar.siguiente = nada
  2. PrimerElemento = ElementoaInsertar

Insertar_primerNodoComo notamos en la imagen, el primer elemento en realidad es una referencia y no un nodo como tal, en otras palabras, no contiene una parte de datos, pues su propósito como mencioné antes, es el de mantener la referencia de memoria para acceder a los nodos posteriores. Si se quiere puede tomarse al primer elemento como un nodo sin su parte de datos.

En caso de que la lista sí contenga elementos, entonces se procede como sigue:

Necesitamos establecer si vamos a insertar al inicio de la lista o al final, la diferencia radica en el orden que se apilan los nodos, de modo que si escogemos insertar al inicio, el último nodo insertado será el primero en ser recorrido (mostrado) mientras que  si insertamos al final de la lista,  mantendríamos  cierto orden lógico.

Insertar al inicio de la lista:

  1. ElementoaInsertar.siguiente = primerElemento
  2. primerElemento = ElementoaInsertar

 

Insertar_primer_elemento_inicioLa imagen nos dice lo siguiente: Toma el nodo a insertar y haz que su parte de dirección apunte hacía donde apunta el primer elemento, esto con el propósito de enganchar el nuevo elemento a la lista. Segundo, toma el primer elemento y colócalo apuntando a la dirección de nuevo elemento, con esto logramos actualizar el valor de dirección del primer elemento que se colocaría en apuntando al nodo recién insertado.

 Ahora que entendemos los conceptos de inserción procedemos a ver un poco del código en Java.

Primero necesitamos crear una clase Nodo, en la cual procedemos a declarar dos atributos, uno del mismo tipo de la clase, que será en el que guardemos la dirección de memoria, y el otro del tipo de dato deseado, ya sea un tipo primitivo o una clase.

public class Nodo{
  int numero;
  Nodo siguiente;
public Nodo (int nuevoNumero){
   this.numero = nuevoNumero;
   this.siguiente = null;
}
}

Posteriormente creamos una clase con los métodos de la lista, primeramente el de insertar, luego el de mostrar; es importante aclarar que estas dos clases deben ir en el mismo paquete de Java, por lógica y por comodidad.

public class Lista{

 Nodo primerElemento;
  public Lista(){
  this.primerElemento = null;

}
public void insertar(int nuevoNumero){

   Nodo nuevoElemento = new Nodo(nuevoNumero);

   if (primerElemento == null){
       nuevoElemento.siguiente = null;
       primerElemento = nuevoElemento;
  }
   else{
       nuevoElemento.siguiente = primerElemento;
       primerElemento = nuevoElemento;
    }
}
}

Repasando de nuevo los elementos de esta clase:

El constructor de la clase Lista es llamado cuando se crea el objeto en cualquier otra parte del código para el usuario, dicho constructor es usado una vez para crear una instancia de la lista, por lo tanto en ese momento el primer elemento se inicializa en null, luego cuando el dato es obtenido del usuario y se desea insertar en la lista, se llama al método insertar, seguidamente se verifica si la lista está vacía, si lo está, entonces ejecuta el código del IF, en caso contrario, ejecuta el código del Else, ambos códigos ya fueron explicados conceptualmente por lo que no debería ser nada complicado entenderlos.

 Bien, ahora vamos a implementar nuestro código para ver que todo funcione correctamente, para ello escribimos una clase main en la cual instanciaremos un objeto de tipo Lista, que utilice el método insertar de dicha clase:

import javax.swing.JOptionPane;
public class Main {
    
    public static void main (String args[]) {
        Lista nuevaLista = new Lista();
        String opcion = "";
        
        
        while(!opcion.equals("3")){      
             nuevaLista.insertar(Integer.parseInt(JOptionPane.showInputDialog(null,"Escriba un número")));
             opcion = JOptionPane.showInputDialog(null, "Escriba 3 para salir, o cualquiera para continuar");
        }
    }
}

 

Esta clase Main es bastante sencilla, su finalidad es la de crear un objeto para poder utilizar el método insertar de la clase Lista, para lo cual se vale de un while que ejecuta el código dentro de el mientras se cumpla la condición establecida, opción distinta de 3.

Note como no necesitamos importar la clase Lista, más arriba mencioné que por comodidad nos convenía colocar todo en el mismo paquete Java, pues bien, esta es una de las razones; en caso contrario si lo hubiéramos colocado en un paquete distinto, entonces por obligación tendríamos que declarar el import.

 Mostrar los elementos de la lista:

Bien el procedimiento para mostrar los datos almacenados en una lista enlazada es muy simple, basta con recorrer cada uno de sus elementos mientras  no sea igual a Null, es decir, vacío.

A su vez para cada elemento recorrido mostraremos su valor y lo concatenaremos con el resto.

Definamos el método mostrar en la clase Lista:

public String mostrar(){
        Nodo auxiliar = primerElemento;
        String numeros = "";
        
        while(auxiliar != null){
                numeros += auxiliar.numero;
                auxiliar = auxiliar.siguiente;
            }
        return numeros;
    }

Lo que hace este método es concatenar cada elemento de la lista en un String llamado números, para posteriormente ser retornado al objeto que lo invoca dentro de la clase main.

Vemos que, Auxiliar nos permite iniciar desde la posición uno e ir efectuando el recorrido mientras no se haya llegado al final de la lista, mismo que está indicado por NULL; como ven es muy simple.

Para utilizarlo basta con crear un objeto JOptionPane dentro de main y mandarle los valores de retorno del método:

JOptionPane.showMessageDialog(null,nuevaLista.mostrar());

Esta última porción de código la debemos colocar fuera del While presente en la clase Main, puesto que así se ejecutará cuando se haya terminado de definir la lista.

Este ha sido el primer tutorial sobre listas enlazadas espero les sea de ayuda; ante cualquier duda o inconveniente no duden en comentar. Saludos y un abrazo.

Cumpleaños de mi blog. Gracias a quienes me siguen

Hoy hace 3 años decidí abrir mi blog,  para comunicar entre otras cosas mi forma de ver el mundo linuxero, nació pues, con la esperanza de contribuir y ayudar a quienes no sabían nada del tema.

La idea que me embarco en esto, fue la de no permitir que otros pasaran por lo que yo pasé al iniciarme en estos menesteres, no sé si lo conseguí, ignoro a cuantas personas han ayudado mis posts, pero les aseguro que aunque fuera una sola, me doy por satisfecho.

A los que me siguen les doy las gracias sinceramente, no soy de los que escriben muchas entradas por semana, pero siempre estoy buscando la manera de escribir lo mejor posible y en mi mente  siempre tengo muy presente a quienes consideran que este humilde sitio es interesante.

De nuevo gracias y estoy a sus ordenes.

 

 

Como hacer que las categorías de Whisker Menu aparezcan a la Izquierda

Ayer publiqué un post en donde les compartí un Wisker Menu modificado por mi, en el cual las categorías se muestran a la izquierda y las aplicaciones a la derecha (como en cualquier menú  tradicional), el caso es que a petición de Eduardo, hoy les mostraré como pueden realizar este cambio ustedes mismos.

Para empezar debo aclarar que no es nada del otro mundo (de hecho carece de ciencia), por lo tanto inclusive aquellos sin conocimientos en programación pueden hacerlo, eso sí, acatando mis instrucciones al pie de la letra.

Paso 1

Descargar e instalar las herramientas indispensables para compilar:


aptitude install build-essential checkinstall cmake libexo-1-dev libgarcon-1-0-dev libxfce4ui-1-dev libxfce4util-dev xfce4-panel-dev make git

Paso 2

Clonamos el repositorio de WiskerMenu desde la terminal con el siguiente comando.

git clone https://github.com/gottcode/xfce4-whiskermenu-plugin

Paso 3

 

Abrimos nuestro explorador de archivos (Thunar) y nos ubicamos en el directorio WiskerMenu dentro de nuestra carpeta /home, posteriormente ingresamos al subdirectorio /panel-plugin, una vez allí, abrimos el archivo window.cpp con nuestro editor favorito (gedit, leafpad, mousepad, geany) y en él identificamos las siguientes lineas.

Nota: Perdonen si la indentación en el blog no se muestra.

 

	// Create box for packing launcher pages
	m_panels_box = GTK_BOX(gtk_vbox_new(false, 0));
	gtk_box_pack_start(m_contents_box, GTK_WIDGET(m_panels_box), true, true, 0);
	gtk_box_pack_start(m_panels_box, m_favorites->get_widget(), true, true, 0);
	gtk_box_pack_start(m_panels_box, m_recent->get_widget(), true, true, 0);
	gtk_box_pack_start(m_panels_box, m_applications->get_widget(), true, true, 0);

	// Create box for packing sidebar
	m_sidebar_box = GTK_BOX(gtk_vbox_new(false, 0));
	gtk_box_pack_start(m_sidebar_box, GTK_WIDGET(m_favorites_button->get_button()), false, false, 0);
	gtk_box_pack_start(m_sidebar_box, GTK_WIDGET(m_recent_button->get_button()), false, false, 0);
	gtk_box_pack_start(m_sidebar_box, gtk_hseparator_new(), false, true, 0);

	m_sidebar = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
	gtk_box_pack_start(m_contents_box, GTK_WIDGET(m_sidebar), false, false, 0);
	gtk_scrolled_window_set_shadow_type(m_sidebar, GTK_SHADOW_NONE);
	gtk_scrolled_window_set_policy(m_sidebar, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	GtkWidget* viewport = gtk_viewport_new(gtk_scrolled_window_get_hadjustment(m_sidebar),
		gtk_scrolled_window_get_vadjustment(m_sidebar));
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
	gtk_container_add(GTK_CONTAINER(m_sidebar), viewport);
	gtk_container_add(GTK_CONTAINER(viewport), GTK_WIDGET(m_sidebar_box));

	GtkSizeGroup* sidebar_size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
	gtk_size_group_add_widget(sidebar_size_group, GTK_WIDGET(m_sidebar));
	gtk_size_group_add_widget(sidebar_size_group, GTK_WIDGET(m_commands_align));

Lo anterior significa en palabras cristianas que, el primer elemento agregado al contenedor (digamos la ventana del menú) de izquierda a derecha,
sera el “panel_box” es decir, el área de aplicaciones, seguido del “sidebar” área de categorías, por lo tanto respetando el orden respectivo, la ventana mostrará primero las aplicaciones a la izquierda y luego las categorías a la derecha.

Por lo tanto lo único que debemos hacer para cambiar esto, es invertir el orden en el que son agregados los componentes, lo que naturalmente se logra cambiando de lugar el componente que se agregará de primero; de manera práctica, cortamos la parte que dice  // Create box for packing launcher pages  hasta antes de // Create box for packing sidebar y la pegamos debajo de esta. Nos quedará de la siguiente forma.

 

 

// Create box for packing sidebar
	m_sidebar_box = GTK_BOX(gtk_vbox_new(false, 0));
	gtk_box_pack_start(m_sidebar_box, GTK_WIDGET(m_favorites_button->get_button()), false, false, 0);
	gtk_box_pack_start(m_sidebar_box, GTK_WIDGET(m_recent_button->get_button()), false, false, 0);
	gtk_box_pack_start(m_sidebar_box, gtk_hseparator_new(), false, true, 0);

	m_sidebar = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
	gtk_box_pack_start(m_contents_box, GTK_WIDGET(m_sidebar), false, false, 0);
	gtk_scrolled_window_set_shadow_type(m_sidebar, GTK_SHADOW_NONE);
	gtk_scrolled_window_set_policy(m_sidebar, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	GtkWidget* viewport = gtk_viewport_new(gtk_scrolled_window_get_hadjustment(m_sidebar),
		gtk_scrolled_window_get_vadjustment(m_sidebar));
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
	gtk_container_add(GTK_CONTAINER(m_sidebar), viewport);
	gtk_container_add(GTK_CONTAINER(viewport), GTK_WIDGET(m_sidebar_box));

	GtkSizeGroup* sidebar_size_group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
	gtk_size_group_add_widget(sidebar_size_group, GTK_WIDGET(m_sidebar));
	gtk_size_group_add_widget(sidebar_size_group, GTK_WIDGET(m_commands_align));

	// Create box for packing launcher pages
	m_panels_box = GTK_BOX(gtk_vbox_new(false, 0));
	gtk_box_pack_start(m_contents_box, GTK_WIDGET(m_panels_box), true, true, 0);
	gtk_box_pack_start(m_panels_box, m_favorites->get_widget(), true, true, 0);
	gtk_box_pack_start(m_panels_box, m_recent->get_widget(), true, true, 0);
	gtk_box_pack_start(m_panels_box, m_applications->get_widget(), true, true, 0);

Bien con esto ya hemos cambiado las categorías a la izquierda y las aplicaciones a la derecha, sin embargo, si cambiamos el menú de posición a una que no sea tradicional, es decir en el borde derecho de la pantalla tendremos problemas con el re posicionamiento de los elementos del menú, les ilustro.

Por defecto WiskerMenu  ubica las aplicaciones a la izquierda y las categorías a la derecha (ya aburro con esa hablada jeje) pero esto sólo es así, cuando el menú se encuentra en las esquinas superior e inferior izquierda de la pantalla. Si por el contrario se encuentra en las esquinas derechas, el menú cambia a nuestra posición deseada (categorías izquierda; aplicaciones derecha) es ilógico lo sé, pero así lo pensaron los desarrolladores, entonces con nuestra siguiente modificación, vamos a alterar dicho reordenamiento para que sea inverso y lógico.

Paso 4

Ubicamos está linea  y en la sección else,  cambiamos m_panels_box, 2 por un 1 y m_sidebar, 1 por un 2.

if ((layout_left && !wm_settings->position_categories_alternate)
            || (!layout_left && wm_settings->position_categories_alternate))
    {
        gtk_box_reorder_child(m_contents_box, GTK_WIDGET(m_panels_box), 1);
        gtk_box_reorder_child(m_contents_box, GTK_WIDGET(m_sidebar), 2);
    }
    else
    {
        gtk_box_reorder_child(m_contents_box, GTK_WIDGET(m_panels_box), 2);
        gtk_box_reorder_child(m_contents_box, GTK_WIDGET(m_sidebar), 1);
    }

Paso 5

 

Ahora sí, guardamos nuestros cambios y procedemos a compilar, para ello abrimos una terminal en el directorio
~/xfce4-whiskermenu-plugin/panel-plugin/ y ejecutamos lo siguiente:

cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr
make

y como súper usuario

checkinstall

Paso 6

Por último, reiniciamos panel.

xfce4-panel --restart

Paso 7

Disfruten!!!
Cualquier duda o crítica pueden dejar un comentario, saludos.

WhiskerMenú con categorias a la izquierda

Cuando probé por primera vez Whisker Menu no me agrado para nada que tuviera las categorías del lado derecho y las aplicaciones a la izquierda; de plano me pareció incómodo  y pensé para mi, en que pensaría el desarrollador cuando colocó las opciones de tal forma, esa vez no le di mayor importancia y desinstalé el plugin.

Ayer por la mañana decidí probar Xubuntu 14.04 y para mi sorpresa vi que traía por defecto el tan famoso Menu alternativo, lo estuve traveseando y vi que en efecto, a pesar de las maravillas que posee, era imposible colocar las categorías a la izquierda y las aplicaciones a la derecha como en los menús tradicionales (Linux Mint o KDE), por lo que me di a la tarea de remediar tal situación.

Hoy temprano bajé el código fuente (Bendito Software Libre)  lo modifiqué hasta conseguir un acomodo a mi gusto, luego, con el espíritu que caracteriza a la comunidad comparto esa modificación con ustedes, pero antes les muestro el “antes y después”

Antes

Con Categorías a la izquierda y las aplicaciones a la derecha
Con Categorías a la derecha y las aplicaciones a la izquierda

Después

Con Categorías a la izquierda y aplicaciones a la derecha
Con Categorías a la izquierda y aplicaciones a la derecha

 

https://dl.dropboxusercontent.com/u/68911480/xfce4-whiskermenu-plugin-1.3.2.gz

Una vez que bajen el archivo y los descompriman, pueden ejecutar el .deb que coloqué dentro o compilar el código.  Si les apetece lo segundo, sigan mis instrucciones.

Instalen lo siguiente:

 aptitude install build-essential checkinstall cmake libexo-1-dev libgarcon-1-0-dev libxfce4ui-1-dev libxfce4util-dev xfce4-panel-dev

Abran una terminal en donde descomprimieron el archivo, en mi caso  /home/cooper15/Descargas/xfce4-whiskermenu-plugin-1.3.2 y luego ejecuten lo siguiente.

cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr
make

Luego, como superusuarios escriban el siguiente comando y sigan las opciones recomendadas.

checkinstall

Por último solo queda que reinicien el panel así:

xfce4-panel --restart

Ahora espero que disfruten del Wisker Menú tanto como yo, si tienen algún inconveniente comenten. Saludos

 

JGpg mi gestor para cifrar archivos mediante GPG

Primero deseo pedir disculpas a mis lectores, he pasado un poco ocupado con muchos trabajos y no he tenido tiempo para responder preguntas, ni mucho menos para actualizar el blog, por otra parte como para mi lo importante no es la cantidad sino la calidad, no puedo pasar por acá escribiendo cualquier sandez, así que de nuevo les ruego me perdonen.

Bien el motivo para esta entrada ha sido la interfaz construida en java, que recién programé para cifrar archivos mediante GPG, sí yo sé, existen muchas aplicaciones de calidad que pueden lograr esto, sin embargo, la mía fue concebida con fines puramente didácticos, lo que no excluye claro está, que algunos de ustedes la encuentren útil y hasta curiosa.

Fue escrita en java, su intensión como lo dije, es facilitar el uso de GPG, así que en pocas palabras es tan sólo una “interfaz gráfica de usuario”, para usarla van a requerir tener previamente instalado el JRE o el Open JRE, cosa que se logra fácilmente en cualquier distribución  Gnu/Linux.

Algunos cambios en la aplicación (La parte para el descifrado está en “implementación” :P)

JGpg-1.0.1

Enlace para descarga de la versión 1.0.1

Esta es la interfaz

JGpg
Ahora si alguno de ustedes se anima a probarla y a comunicarme sus errores o algo que deseen implementar, no duden en comunicármelo, repito esto es para mi un hobby pero cualquier tipo de crítica es bienvenida y tengan la seguridad de que mejoraré la aplicación.

Sin más que decir, les dejo el link para que la prueben.

https://dl.dropboxusercontent.com/u/68911480/JGpg.jar

Tanglu 1.0 al fin ha sido liberada

Son las 12 md y me encuentro escribiendo esta “nota”, la misma sólo pretende informarles acerca de la disponibilidad de esta distribución, misma que generó en su momento tanta expectativa, hace poco les hable sobre el lanzamiento de la RC.

Para aquellos que aun no sepan que es Tanglu, les diré en resumidas cuentas, que es un debian rolling release en toda regla, sin congelamiento de paquetes y con escritorios puros sin ningún tipo de retoques, ojo tampoco es que este aspecto varíe mucho jeje…

Sí desean probarla les dejo el enlace para que la descarguen.

 

http://tanglu.org/en/download/

 

[Tips] Cambiar icono de Parcellite, en la bandeja del sistema (systray)

Los que usamos Parcellite (portapapeles) cotidianamente, no logramos una integración del icono por defecto de la aplicación (el cual es feo), con nuestro tema favorito de iconos, esto resulta sumamente molesto (al menos a mi me lo parece) por esta razón me propuse encontrar una solución y aquí se las comparto.

Para empezar aclaro algunas cosas.

  • Mi tema de iconos se llama Moka, si desean descargarlo hagan clic aquí.
  • La solución es independiente del entorno de escritorio que usen (ya verán por qué).
  • Si reciben una actualización de Parcellite el icono por defecto “regresará” de nuevo.

La bandeja del sistema se ve así:

systray_parcellitePueden notar lo que les dije anteriormente, el icono desentona totalmente.

En materia:

Escogemos un icono de portapapeles que nos guste, yo usaré el que trae Faenza-Darkest, ustedes pueden utilizar el que quieran es cuestión de gustos, lo único que debemos tener presente es la ruta del icono.

Abriré una terminal  como superusuario y me voy a la ruta del icono que deseo poner en vez del de Parcellite.

 
cd /usr/share/icons/Faenza-Darkest/actions/22/

Luego elimino el icono de parcellite con el siguiente comando.

rm /usr/share/pixmaps/parcellite.png

Y por último copio el icono renombrado, del directorio actual a /usr/share/pixmaps/

cp /usr/share/icons/Faenza-Darkest/actions/22/edit-paste.png /usr/share/pixmaps/parcellite.png

Ahora cierro el Parcellite con clic derecho – salir y posteriormente lo inicio de nuevo; al final me queda así.

systray2

Sí les gusto el icono y usan un panel oscuro pueden descargarlo del siguiente enlace, le hice unas pequeñas modificaciones.

Descargar Icono Parcellite monocromático

Espero que les sea de utilidad, si tienen alguna duda o sugerencia, pueden comentar. Saludos.