Tiempo de Tux

martes, 7 de enero de 2014

Tutorial python gtk3 Entry

En esta ocasión vamos a aprender a usar cajas de entrada de texto usando Python + Gtk. Los entry se usan para introducir texto,o mostrar texto en forma muy corta.

Para crear un entry se crea un objeto de la clase Gtk.Entry(),los cuales pueden tener algunos parámetros,funciones para hacer un entry mas customizado y funcional:

self.entry = Gtk.Entry()

Este es un entry muy muy básico:

# -*- coding: latin-1 -*-
from gi.repository import Gtk, GObject

class Ejemplo(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Ejemplo entry")
        self.set_size_request(200, 100)
        self.entry = Gtk.Entry()
        self.add(self.entry)
       
ventana = Ejemplo()
ventana.connect("delete-event", Gtk.main_quit)
ventana.show_all()
Gtk.main()

Ahora vamos a ver algunas funciones:

Añadir texto al crearlo:

Para añadir texto vamos a usar el argumento explicito text,al crearlo:

self.entry = Gtk.Entry(text="Hola Mundo!!")

Si se desea colocar texto en el entry aun cuando ya esta creado el objeto,podemos usar la función set_text("texto"):

self.entry.set_text("Hola Mundo!!")

De igual manera tenemos una función opuesta que llama el texto que se haya introducido :

self.entry.get_text()

Ejemplo de intercambiar texto de un entry a otro:

# -*- coding: latin-1 -*-

from gi.repository import Gtk, GObject

class Ejemplo(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Ejemplo entry")
        self.set_size_request(200, 100)
        self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL]
        self.vbox = Gtk.Box()
        self.vbox.set_spacing(1)
        self.vbox.set_orientation(self.pos[1])
        
        self.entry = Gtk.Entry(text="Hola Mundo!!") # Inicia con el texto "Hola Mundo!!"
        self.vbox.pack_start(self.entry,True,False,1) # Lo añadimos al box
        
        self.button = Gtk.Button(label="Cambiar")  # Añadimos un boton
        self.vbox.pack_start(self.button,True,False,1)
        self.button.connect("clicked", self.cambiar) # Si el boton se cliquea vamos a la  funcion cambiar
        self.entry2 = Gtk.Entry()
        self.vbox.pack_start(self.entry2,True,False,1)
        
        self.add(self.vbox)
    def cambiar(self,widget):
        texto = self.entry.get_text() # El texto es igual al get_text() del entry1
        self.entry2.set_text(texto) # Ponemos el texto del entry1 en el entry2
        
ventana = Ejemplo()
ventana.connect("delete-event", Gtk.main_quit)
ventana.show_all()
Gtk.main()

También contamos con funciones para esconder el texto ingresado:

Para ello solo usamos la función set_visibility(bool) con un valor booleano,en este caso False:

self.entry.set_visibility(False)

Ejemplo de login:

from gi.repository import Gtk, GObject

class Ejemplo(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="Ejemplo entry")
        self.set_size_request(200, 100)
        self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL]
        self.vbox = Gtk.Box()
        self.vbox.set_spacing(1)
        self.vbox.set_orientation(self.pos[1])
        
        self.entry = Gtk.Entry()
        self.vbox.pack_start(self.entry,True,False,1)

        self.entry2 = Gtk.Entry()
        self.entry2.set_visibility(False)
        self.vbox.pack_start(self.entry2,True,False,1)
        
        self.button = Gtk.Button(label="Login")   
        self.button.connect("clicked", self.login)     
        self.vbox.pack_start(self.button,True,False,1)
        
        self.add(self.vbox)
    
    def login(self,widget):
        user = self.entry.get_text()
        password = self.entry2.get_text()
        if (user == "Gtk" and password == "Gtk"):
            print "Login correcto"
        else:
            print "Login incorrecto"
        
        
ventana = Ejemplo()
ventana.connect("delete-event", Gtk.main_quit)
ventana.show_all()
Gtk.main()

En ese mismo ejemplo podemos usar algo que se usan en muchos logins,asignar un máximo de letras al usar el entry:

self.entry.set_max_length(numero_de_letras)

Tambien en el ejemplo de arriba si quisieramos indicar de que o para que sirve el entry podemos usar un placeholder,esto para que nos muestre de que sirve sin añadir un widget extra y que no estorbe en funcionalidad:

self.entry.set_placeholder_text("Texto")

Si quisiéramos hacer que el testo mostrado,por ejemplo desde el principio (como se ve arriba) fuera inmutable,podemos usar set_editable(), al cual le pasamos como argumento un bool,para ver si se podrá editar:

self.entry.set_editable(False) # Evita cambio

Si queremos que nuestro entry nos autocomplete podemos usar un EntryCompletion,esto lo veremos cuando veamos los Liststore,pero de momento pueden ver esta función que crea un EntryCompletion:

def set_completation(self):
       sistemas = [
        "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE",
        ]
        liststore = Gtk.ListStore(str)
        for sistema in sistemas:
           liststore.append([sistema])

        completion = Gtk.EntryCompletion()
        completion.set_model(liststore)
        completion.set_text_column(0)
        return completion

Esa función devuelve una EntryCompletion ahora solo tenemos que asignarla al entry,con la funcion

self.entry.set_completion(self.set_completation())

Este es un ejemplo que pregunta que distribución de Linux usas:

from gi.repository import Gtk, GObject

class Ejemplo(Gtk.Window):
   
    def __init__(self):
        Gtk.Window.__init__(self, title="Ejemplo entry")
        self.set_size_request(200, 100)
        self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL]
        
        self.vbox = Gtk.Box()
        self.vbox.set_spacing(1)
        self.vbox.set_orientation(self.pos[1])
        
        self.entry = Gtk.Entry()
        self.entry.set_placeholder_text("Que sistema Linux usas?")
        self.entry.set_completion(self.set_completation())

        self.vbox.pack_start(self.entry,True,False,1)
        
        self.button = Gtk.Button(label="Aceptar")   
        self.button.connect("clicked", self.uso)     
        self.vbox.pack_start(self.button,True,False,1)
        
        self.add(self.vbox)
        
    def set_completation(self):
        sistemas = [
        "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE",
        ]
        liststore = Gtk.ListStore(str)
        for sistema in sistemas:
           liststore.append([sistema])

        completion = Gtk.EntryCompletion()
        completion.set_model(liststore)
        completion.set_text_column(0)
        return completion
        
    def uso(self,widget):
        if self.entry.get_text() != "":
         print "Uso %s" %(self.entry.get_text())
        


ventana = Ejemplo()
ventana.connect("delete-event", Gtk.main_quit)
ventana.show_all()
Gtk.main()

Si quisiéramos que hubiera un boton en el mismo entry para no usar uno ajeno haríamos esto:

Primero añadimos un icono,por ejemplo uno de los stocks :

self.entry.set_icon_from_stock(icon_pos,stock)

En stock añadimos uno de los siguientes:

Enlace

Y en icon_pos,podemos usar:

Gtk.EntryIconPosition.SECONDARY # Derecha

Gtk.EntryIconPosition.PRIMARY # Izquierda

Ahora nos quedaría así,un boton para limpiar el texto(borrar el texto del entry):

self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,Gtk.STOCK_CLEAR)

Con eso añadiríamos el boton,pero ahora hay que definir la función,para ellor tendriamos que añadir la señal de icono presionado:

self.entry.connect("icon-press",self.limpiar,None)

El primer argumento es el tipo de señal,el segundo la función a llamar,y el tercero es algún parámetro extra.

Por ultimo podemos añadir un tooltip al boton del entry para que nos diga por ejemplo en este ejemplo que es lo que hace,en este caso borrar el texto,par ello solo debemos llamar la función set_icon_tooltip_text, y pasarle rn el primer parametro la posision(igual que arriba) y en el segundo el tooltip:

self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Borrar texto")

Ejemplo completo:

# -*- coding: latin-1  -*-

from gi.repository import Gtk, GObject

class Ejemplo(Gtk.Window):
   
    def __init__(self):
        Gtk.Window.__init__(self, title="Ejemplo entry")
        self.set_size_request(200, 100)
        self.pos = [Gtk.Orientation.HORIZONTAL,Gtk.Orientation.VERTICAL]
        
        self.vbox = Gtk.Box()
        self.vbox.set_spacing(1)
        self.vbox.set_orientation(self.pos[1])
        
        self.entry = Gtk.Entry()
        self.entry.set_placeholder_text("Que sistema Linux usas?")
        self.entry.set_completion(self.set_completation())
        self.entry.set_icon_tooltip_text(Gtk.EntryIconPosition.SECONDARY, "Borrar texto")
        self.entry.set_icon_from_stock(Gtk.EntryIconPosition.SECONDARY,Gtk.STOCK_CLEAR)
        self.entry.connect("icon-press",self.limpiar,None)
        self.vbox.pack_start(self.entry,True,False,1)
        
        self.button = Gtk.Button(label="Aceptar")   
        self.button.connect("clicked", self.uso)     
        self.vbox.pack_start(self.button,True,False,1)
        
        self.add(self.vbox)
        
    def limpiar(self,*args):
        self.entry.set_text("")
        
    def set_completation(self):
        sistemas = [
        "Ubuntu","Arch","Gentoo","Debian","Mint","openSUSE",
        ]
        liststore = Gtk.ListStore(str)
        for sistema in sistemas:
           liststore.append([sistema])

        completion = Gtk.EntryCompletion()
        completion.set_model(liststore)
        completion.set_text_column(0)
        return completion
        
    def uso(self,widget):
        if self.entry.get_text() != "":
         print "Uso %s" %(self.entry.get_text())
        


ventana = Ejemplo()
ventana.connect("delete-event", Gtk.main_quit)
ventana.show_all()
Gtk.main()

Eso es todo :D

Referencia : developer.gnome.org/

lunes, 6 de enero de 2014

Como recuperar el login de Ubuntu 12.04 13.10

Esta es una entrada rápida de como recuperar el login de Ubuntu por si instalaste otro escritorio como Gnome shell,KDE y te cambio el inicio de sesión no solo es para las versiones que mencione ya que esto funciona desde que ubuntu usa el mismo login que seria desde ubuntu 11.10(si no me equivoco).

Solo tenemos que reconfigurar lightdm:

sudo dpkg-reconfigure lightdm

Nos sale esta pantalla:

Elegimos lightdm y listo :D

Eso es todo.

sábado, 4 de enero de 2014

Programacion Orientada a Objetos con Perl parte 2

Continuamos con los tutoriales de OOP de Perl,en esta ocasión vamos a tocar otro tema importante de la OOP,la herencia.

En perl la herencia se puede hacer igual que en los otros lenguajes de programación,perl maneja las clases como paquetes y para que estos hereden de otros paquetes tienes que estar relacionados entre si,las clases padre se guardan en la variable isa de UNIVERSAL,UNIVERSAL es de donde heredan todas las clases de Perl implícitamente.

Para que una clase herede de otra debemos añadirla al array ISA,pero no es necesario en estos tiempos,lo que haremos sera facilitarnos el trabajo con parent:

En perl existen muchas pero muchas formas de hacer lo mismo ya que incluso lleva el lema There's more than one way to do it,voy a intentar hacerlo de la manera mas simple posible.

Vamos a usar de ejemplo una mascota virtual,(también lo veremos en Java),creamos un archivo llamado Mascota.pm:

vim Mascota.pm

Ahora vamos a crear la clase como vimos en el tutorial pasado.

package Mascota;

use feature 'say';

sub new 
{
    my $class = shift;
    my $self = { 
        'Hambre' => 1, 
    };
    bless $self,$class;
    return $self;
}

sub tienesHambre 
{
    my $self = shift;
    if (int($self->{Hambre}) == 1) 
    {
        say "Tengo hambre";
    } 
    else 
    {
        say "No tengo hambre";    
    }
}
sub darDeComer
{
    my $self = shift;
    $self->{Hambre} = 0;
}
1;

Como ven añadí dos funciones una por si tiene hambre y otra para quitarle el hambre(sobra explicarlo).

Ahora vamos a crear un Perro que herede esas funciones de la clase Mascota,creamos un archivo Perro.pm:

vim Perro.pm

Primero definimos el paquete:

package Perro; # Suponiendo que esta en el mismo directorio

Luego usamos Mascota como clase padre:

use parent 'Mascota';

Eso nos ahorra mucho trabajo,ya que verifica las cosas mas importantes como añadir ha isa,verificar autoherencia,etc.

Eso es todo para que un archivo heredara de otro las funciones.

Ahora lo mas importante,el constructor de la clase Perro,para que la clase Perro herede las funciones y las variables de Mascota tenemos que inicializar el constructor de Mascota,para eso creamos una clase new para perro y definimos que el self sea el self de mascota usando la palabra SUPER:

sub new {
    my $class = shift;
    my $self = $class->SUPER::new();
    return $self;
}

De esa manera ya estan construidos las dos clases,asi queda la clase Perro añadiendo una funcion propia de los perros:

package Perro;
use feature 'say';
use parent 'Mascota';

sub new {
    my $class = shift;
    my $self = $class->SUPER::new();
    return $self;
}

sub ladra {
    say 'woww';
}
1;

Ahora en el principal podemos llamar a la clase Perro y usar las funciones de mascota y de perro:

#!/usr/bin/env perl

use strict;
use warnings;

use Perro;

my $perro = Perro->new(); # Creamos un Perro

$perro->tienesHambre(); # Le preguntamos si tiene hambre

$perro->darDeComer(); # Le damos de comer

$perro->tienesHambre(); # Le preguntamos de nuevo

$perro->ladra(); # Y ladra

Eso prueba la herencia de un archivo,veamos la herencia en otro,para eso vamos a crear la clase Gato,toda la clase sera igual solo con sus funciones únicas de un Gato:

package Gato;
use feature 'say';
use parent 'Mascota';

sub new 
{
    my $class = shift;
    my $self = $class->SUPER::new();
    return $self;
}

sub maulla 
{
    say 'miau';
}
1;

Ahora en el programa principal podemos hacer esto:

#!/usr/bin/env perl

use feature 'say';
use Perro;
use Gato;

my $perro = Perro->new();

$perro->tienesHambre();

$perro->darDeComer();

$perro->tienesHambre();

$perro->ladra();

my $gato = Gato->new();

$gato->maulla();

$gato->tienesHambre();

Como ven el Gato hereda las funciones y variables de Mascota,al igual que el Perro. Tambien podemos poner todo en un mismo archivo.

Como dije en Perl se pueden hacer las cosas de muchas formas esto es un ejemplo de otra forma de herencia en Perl:

Enlace

Mas informacion : perldoc.perl.org

viernes, 3 de enero de 2014

Tutorial Java en Linux Basico 5

Estructuras selectivas Estructuras repetitivas

Otra cosa fundamental de todo lenguaje de programacion son las estructuras de seleccion repetitivas,llamados bucles loops,en Java contamos con los siguientes bucles:

while

for

do/while

Un bulcle siempre debe tener un final y un inicio,y este se basa en lógica boleana como lo vimos en el tutorial pasado:

Enlace

Un bucle que no tiene fin se conoce como bucle infinito,en teoria si tiene fin ya que se tiene que detener algun dia,pero es llamado asi por que si no se detiene por errores no programados o si existiera una maquina que se pudiera ejecutar infinitamente nunca terminaria.

Un bucle sirve para repetir cierto numero de veces o infinitamente una orden:

Por ejemplo:

Queremos repetir cinco veces hola mundo:

class Ejemplo {
   public static void main(String[] args) {
      System.out.println("hola mundo");
      System.out.println("hola mundo");
      System.out.println("hola mundo");
      System.out.println("hola mundo");
      System.out.println("hola mundo");
   }
}

Eso se haría si no existieran los loops,veamos como funciona un bucle while:

Un bucle while se ejecuta mientras la condición sea verdadera:

Bucle infinito while:

/*
   Archivo : ewhile.java
   Ejecuta : javac ewhile.java && java ewhile
*/

public class ewhile {
    public static void main(String [] args) {
        while (true) { // Mientras sea true nunca terminara
            System.out.println("hola mundo");
        }
    }
}

Si quisiéramos ejecutar cinco veces hola mundo necesitaríamos tener una variable de control,esta se definiría a 0,y la condición seria que si es menor a cinco ejecute el bucle,pero en el cuerpo del bucle incrementaremos el valor de la variable bandera hasta que no sea cierta la condición de ejecución:

/*
   Archivo : ewhile.java
   Ejecuta : javac ewhile.java && java ewhile
*/

public class ewhile {
    public static void main(String [] args) {
        int i = 0; // variable bandera
        while (i < 5) { // Mientras sea true nunca terminara
            System.out.println("hola mundo");
            i++: // Incrementamos su valor en uno
        }
        // Esto se ejecuta cuando termine el bucle
    }
}

Las condiciones son muy sencillas,por ejemplo podemos ejecutar una instrucción hasta que no sea verdadera,un ejemplo muy útil es escanear la entrada estándar hasta que el numero sea el requerido:

import java.io.IOException;
import java.util.Scanner;

/**
 * Archivo ewhile.java Ejecuta : javac ewhile.java && java ewhile
 *
 * @author Atheyus
 *
 */

public class ewhile {

	public static void main(String[] args) throws IOException {
		final int oculto = 4; // Definimos un numero oculto
		boolean valor = true; // Variable bandera
		System.out.print("Adivina el numero oculto: ");
		while (valor) {
			Scanner scan = new Scanner(System.in); // Escaner
			try { // Lo hacemos en un try(lo veremos en futuros tutoriales)
				int i = scan.nextInt(); // Definimos el numero escaneado
				if (i == oculto) { // Si acertamos
					System.out.println("Acertaste :D");
					valor = false; // La variable bandera cambia de valor y rompe el loop
				} else {
					System.out
							.print("(Intenta otra vez) Adivina el numero oculto :");
				}
			} catch (java.util.InputMismatchException e) { // Error de entrada
				System.out
						.print("(Intenta otra vez) Adivina el (numero) oculto :");
			}
			
		}
		System.out.println("Ahora estas afuera del while");
	}
}

Como vemos se puede controlar un bucle fácilmente con una variable bandera,este no es mejor ejemplo pero podemos usar la palabra reservada break,para usar una terminación inesperada:

Cambia en el código:

valor = false:

Por :

break;

break nos puede ser útiles para romper bucles sin variables bandera como es el caso del primer ejemplo.

Ademas de break que sirve para terminar un bucle contamos con continue que sirve para saltarnos una sentencia que seguiría después del continue:

/**
 * Archivo Ejemplo.java Ejecuta : javac Ejemplo.java && java Ejemplo
 *
 * @author Atheyus
 *
 */

public class Ejemplo {

	public static void main(String[] args) {
		int i = 1; // Variable para ver numero de ejecuciones
		System.out.println("Ejemplo de continue,no se veran 8 y 7 ejecuciones:\n");
		while (true) {
			if (i == 11) // Asi detenemos este bucle,solo 10 repeticiones
				break;
			if (i == 7 || i == 8) { // Si i es igual a 7 o 8,nos saltamos lo que sigue
				i++; // Subimos en 1 la variable aunque sea 7 o no se ejecutara correctamente
				continue;
			}
			System.out.println("Ejecucion numero : " + i);
			i++;
		}

	}
}

Como vemos es muy simple saltarnos las sentencias,esto aunque se vea un poco raro les aseguro que muchas veces lo necesitaran.

Bucle for,un bucle for se usa para controlar una ejecución un cierto numero de veces sin necesidad de variables banderas ajenas al bloque de ejecución,la sintaxis es:

1
2
3

for (variable_bandera;condicion;modificacion_de_variable_bandera) {
 /* Bloque */
}

En variable usamos un controlador,por ejemplo si quisiéramos repetir cinco veces hola mundo seria:

En variable bandera:

int i = 0;

En condición:

i < 5;

En modificación_de_variable_bandera:

i++

Así quedaría:

/**
 * Archivo Ejemplo.java Ejecuta : javac Ejemplo.java &&java Ejemplo
 *
 * @author Atheyus
 *
 */

public class Ejemplo {

	public static void main(String[] args) {
		for (int i = 0;i < 5;i++)
			System.out.println("Hola mundo");
	}
}

Una variable puede ser de incremento o decremento,ya que una forma inversa de hacer eso seria así:

/**
 * Archivo Ejemplo.java Ejecuta : javac Ejemplo.java && java EJemplo
 *
 * @author Atheyus
 *
 */

public class Ejemplo {

	public static void main(String[] args) {
		for (int i = 10;i > 5;i--) // Valor en decremento
			System.out.println("Hola mundo");
	}
}

También un bucle for nos permite múltiples sentencias de condicion y declaracion,este ejemplo ilustra como mientras una variable se incrementa,otra se disminuye:

for (int i = 100,o = 0;i > 5;i--,o++) {
	System.out.println("Valor de i: "+i);
	System.out.println("Valor de o: "+o);	
}

En la condición podemos usar múltiples operaciones lógicas basadas en or,and,etc pero es un poco mas avanzado y lo veremos después:

for (int i = 100,o = 0;i > 5 && o < 10;i--,o++) {
	System.out.println("Valor de i: "+i);
	System.out.println("Valor de o: "+o);
}

Un bucle infinito for:

Los bucles infinitos for son aquellos sin cuerpo solo un bloque:

1
2
3

for (;;) {
   System.out.println("Bucle infinito solo se rompe con break o el sistema operativo");
}

Un bucle for se puede anidar de forma muy sencilla,un ejemplo es un simple algoritmo de impresión:

/**
 * Archivo ejemplo.java
 * Compila : javac ejemplo.java
 * Ejecuta : java ejemplo 11
 * @author Atheyus
 *
 */

public class ejemplo {
	private static int top;
	private static int i;
	private static int n;

	public static void main(String[] args) {
                int len = args.length;
                if (len == 0) {
                  System.out.println("Usa un argumento numerico");
                  System.exit(0);
                }
		top = Integer.parseInt(args[0])+1;
		for (i = 1; i < top; i++) {
			for (n = 1; n < i; ++n) {
				System.out.printf("%d\t", n);
			}
			System.out.println("");
		}
		for (i = top; i > 0; --i) {
			for (n = 1; n < i; ++n) {
				System.out.printf("%d\t", n);
			}
			System.out.println("");
		}
	}
}

Un ejemplo mas sencillo es este,por cada repeticion de un bucle externo ejecutar cinco veces uno interno:

for (int i = 0;i < 10;i++) {
	System.out.println("Ejecucion de primer bucle : "+i);
	for (int o = 0;o < 5;o++) {
		System.out.println("Ejecucion de segundo bucle : "+o);
	}
}

El bucle do/while,el bucle do a diferencia de while se ejecuta una vez sin importar nada,luego verifica la condicion en el while y si es true sigue en ejecucion,veamos como se ejecuta 5 veces hola mundo en do/while:

int i = 0;
do {
	System.out.println("Hola mundo");
	++i;
} while (i < 5);

Como vemos los ++ están al revés esto no corresponde ahora pero puedo decir que en teoría resta una ejecución.

Un buen ejemplo es el que vimos arriba de ewhile,pero con do/while queda mucho mejor:

import java.util.Scanner;

/**
 * Archivo Ejemplo.java Ejecuta : javac Ejemplo.java && java Ejemplo
 * 
 * @author Atheyus
 * 
 */

public class Ejemplo {

	public static void main(String[] args) {
		final int oculto = 4;
		int i = 0;
		do {
			try {
				System.out.print("Adivina el numero oculto: ");
				Scanner scan = new Scanner(System.in); // Escaner
				i = scan.nextInt();
			} catch (Exception e) {
				;
			}
		} while (i != oculto); // Si i no es el numero oculto repite de nuevo
		System.out.println("Acertaste :D");
		System.out.println("Ahora estas afuera del bucle");
	}
}

Eso es todo :D

miércoles, 1 de enero de 2014

Solucion Eclipse no muestra menus en Ubuntu 13.04 13.10

Hace un tiempo traigo un problema de menus en Ubuntu 13.10,lo que pasa es que no muestra las opciones como debe,y es que se puede deber a que la versión que tengo de eclipse la descargue de Internet y no de los repos.

No se si ocurra este problema con mas programas ya que también me ha sucedido en rhythmbox y eso que viene por defecto en Ubuntu,pero bueno encontré una solución en internet:

Tutorial

Abrimos una terminal:

Ctrl+Alt+T

Luego editamos el lanzador:

Primero vamos a donde se guardan:

cd /usr/share/applications

Ahora por ejemplo yo cree el lanzador de mi aplicación,se llama android-dev.desktop:

Abren con nano como super usaurio su lanzador,por defecto puede ser eclipse-* o si lo crearon ustedes lo abren con su nombre,en mi caso:

sudo nano android-dev.desktop

Ahora añadimos antes de la ejecucion:

Por ejemplo yo tengo asi:

Exec=/home/user/adt-bundle-linux-x86/eclipse/eclipse

Añado entre el exec y la ruta:

env UBUNTU_MENUPROXY=0

También puede decir:

Exec=eclipse

De igual forma que quede así:

Exec=env UBUNTU_MENUPROXY=0 eclipse

Eso es todo :

Esto no funciona en rhythmbox ya que usa otro tipo de menus :(

Fuente : askubuntu.com/

Tutorial Java en Linux Basico 4

Estructuras selectivas Condicionales

Algo muy muy básico en los lenguajes de programación son las estructuras selectivas,de ahora en adelante condicionales,en java me tarde un poco en hablar de esto,pero es que primero debíamos conocer lo que hasta ahora he escrito(según mi enseñanza).

Las condicionales deciden que camino tomar en nuestro código,esto puede cambiar totalmente el funcionamiento del mismo,ya que depende a que nivel ejecutemos una sentencia selectiva.

En Java las condicionales se definen con las palabras:

if

else

else if

Las estructuras tienen una sintaxis tipo Perl con la condición entre paréntesis y el bloque entre llaves:

if (condicion) {
   /*
      Un bloque
      grande
   */
} else {
   /*
      Otro bloque
      Grande
   */
}

O bien si es una pequeña ejecución no necesita bloque y se puede usar con la sintaxis de terminación de una linea (punto y coma):

if (condicio)
   /* a ejecutar */;
else
   /* a ejecutar */;

Primero que nada devemos saber que la condicion a la que responde el if es un valor boleano,el cual si es true se ejecuta,por ejemplo:

1 2	if (true) System.out.println("Es true");

Aquí cabe clarar que esto es inútil:

if (true)
   System.out.println("Es true");
else
   System.out.println("Es false");

Ya que true es un valor inmutable y el else sale sobrando.

Algo mas acorde seria:

void ver(boolean x){
   if (x)
   System.out.println("Es true");
   else
   System.out.println("Es false");
}

Ya que podriamos hacer en el main o donde llamaramos esa funcion:

ver(true);

ver(false);

Bien esto no solo va a valores falsos o verdaderos ya definidos,podemos crear nuestra logica boleana,por ejemplo:

Es cierto que 1 es mayor que 0,si.

Es cierto que 10 es menor a 100,si.

Es cierto que 10 es igual a 10,si.

Es cierto que 10 no es igual a 10,no.

Como se ve eso en Java?

Lo primero es comprender los operadores de condición:

Simbolo	Significado	Ejemplo	Resultado
==	Igual que	0 == 0	true
=!	No igual que	1 =! 1	false
<	Menor que	10 < 2	false
>	Mayor que	3 > 2	true
<=	Menor o igual que	2 <= 2	true
>=	Mayor o igual que	2 >= 1	true

Esa tabla representa las comparaciones,si quisiéramos comparar Strings podríamos usar equals,pero lo vemos mas abajo:

Vamos a ver un ejemplo de como trabaja la comparación numérica con dos caminos a tomar:

int x = 10;
int y = 1;

if (x > y)
   System.out.println("x es mayor");
else
   System.out.println("y es mayor");

if (x < y)
   System.out.println("y es mayor");
else 
   System.out.println("x es mayor");

Vamos a ver un ejemplo que a la vez ayude al aprendizaje:

Enlace

Solo copien y ejecuten:

El código no es lo importante solo la ejecución en próximos tutoriales comprenderemos bien ese código.

Para comparación de cadenas usamos una función de cadena llamada equals o compareTo:

String s = "Hola";

if (s.compareTo("Hola"))
   System.out.println("Verdadero");
 
if (s.equals("Hola"))
   System.out.println("Tambien verdadero");
 
if (s.compareTo("hola"))
   System.out.println("Verdadero");
else
   System.out.println("Falso"); // esta vez se ejecuta esto

if (s.compareToIgnoreCase("hola")) // No importan las mayusculas o minusculas
   System.out.println("Verdadero");
else
   System.out.println("Falso"); // esta vez no se ejecuta esto

Si no sabemos el resultado de una comparación basado en dos posibles resultados podemos usar else if:

int x = 10;

if (x == 1) {
 System.out.println("Se ejecuta esto si x es 1");
} else if (x < 10) {
 System.out.println("Se ejecuta esto si x es menor a 10");
} else if (x == 10) {
 System.out.println("Se ejecuta esto si x es igual a 10");
} else {
 System.out.println("Se ejecuta esto si no es ninguno de los anteriores");
}