In this post we’ll see how to create a simple text editor for Linux systems using Java and GTK+.

First of all we will need to have a Linux system with:

• JRE and JDK
• GTK (if you are using a Gnome-based distro like Ubuntu it’s already there)
• Gnome-Java GTK+ bindings for Java
  If you are using Ubuntu Karmic you can install these with:
  sudo apt-get install libjava-gnome-java libjava-gnome-jni libjava-gnome-java-doc
  Otherwise you can grab the bindings from here and follow these instructions for manual installation.
• Glade Interface Designer (It must be available through your distribution’s package management tool)
• Your favorite Java editor/IDE – I’ll be using Netbeans (if you don’t, make sure you have a grasp of how the classpath works).

Now that we have everything we need installed and configured, we start Netbeans and create a new Java Application Project named MyGtkTextEditor.

Next, we have to tell Netbeans to include the necessary java-gnome JAR files in order to be able to compile our project. Right click on “Libraries” and choose “Add JAR/folder”.

Now, navigate to /usr/share/java , select gtk.jar and gtk-4.0.jar and click on “OK”.

From now on we can use GTK+ in our Java application!
Next we will design the GUI using Glade Interface Designer. Start Glade and select “Libglade” as the project’s file format. The libglade format is scheduled for deprecation and will be replaced by GtkBuilder, but java-gnome only supports libglade in its current version.

Now create a window and add a vertical box with 4 slots. Then add a menubar, a toolbar, a ScrolledWindow and a statusbar. We add a TextView inside the ScrolledWindow. Then populate the toolbar (using the “pencil” icon on Glade’s main toolbar which appears after selecting the toolbar) to look like the one on the following picture:

Now save the project as “main_window.glade” in a folder named “glade” inside your Netbeans project directory and close Glade:

You can download the glade file from here.

In order to be able to build/run our project with Netbeans and create redistributable “dist” folder we must tell Ant to copy out glade file in our build/dist folder somewhere where we can locate it at runtime – e.g. to build/glade/main_window.glade  and dist/glade/main_window.glade . Open build.xml using your favorite text editor and add the following before </project> :

<target name="-post-compile">
    <copy todir="build/glade">
        <fileset dir="glade"/>
    </copy>
</target>
<target name="-post-jar">
    <copy todir="dist/glade">
        <fileset dir="glade"/>
    </copy>
</target>

Now go to NetBeans and create a new Java class named “MyGtkTextEditor” inside mygtktexteditor:

First we will create a method that returns the path of the gladefile at runtime:

private String getGladefilePath() {
    try {
        URI uri = this.getClass().getProtectionDomain().getCodeSource().getLocation().toURI();
        File f = new File(uri);
        String canonicalPath = f.getParentFile().getCanonicalPath();
        File f2 = new File(canonicalPath + File.separator + "glade" + File.separator + "main_window.glade");
        return f2.getCanonicalPath();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}

Next a method that parses the XML glade file and gets object references:

private void initComponents(String path) {
    try {
        XML gladeXML = Glade.parse(path, "window1");

        this.mainWindow = (Window) gladeXML.getWidget("window1");
        this.openButton = (ToolButton) gladeXML.getWidget("toolbutton2");
        this.textView = (TextView) gladeXML.getWidget("textview1");

        this.textBuffer = new TextBuffer();
        this.textView.setBuffer(this.textBuffer);

        this.mainWindow.showAll();
    } catch (FileNotFoundException fnfe) {
        fnfe.printStackTrace();
    }

}

A method that connects widgets and events:

private void connectWidgetsAndEvents() {

    this.mainWindow.connect(new Window.DeleteEvent() {
        public boolean onDeleteEvent(Widget source, Event event) {
        Gtk.mainQuit();
        return false;
        }
    });

    this.openButton.connect(new ToolButton.Clicked() {
        public void onClicked(ToolButton arg0) {
        openFile();
        }
    });

}

Another one that loads a file in our TextView:

private void openFile() {
    FileChooserDialog dlg = new FileChooserDialog("Open...", this.mainWindow, FileChooserAction.OPEN);
    FileFilter textFileFilter = new FileFilter("Text files");
    textFileFilter.addMimeType("text/plain");
    dlg.addFilter(textFileFilter);

    ResponseType response = dlg.run();
    dlg.hide();
    if(response.equals(ResponseType.OK)){
        String text = "";
        try{
        InputStreamReader reader = new InputStreamReader(new FileInputStream(dlg.getFilename()), "UTF-8");
        char[] buffer = new char[512];
        while(reader.read(buffer)!=-1){
            text = text + String.valueOf(buffer);
        }
        reader.close();
        }catch(IOException ioe){
        ioe.printStackTrace();
        text = "";
        }
        this.textBuffer.setText(text);
    }
}

And finally the constructor that uses all the above methods:

public MyGtkTextEditor(){
    Gtk.init(new String[0]);//This must be called before 
                        //anything else that is GTK related

    initComponents(this.getGladefilePath());
    connectWidgetsAndEvents();

    Gtk.main();//invokes the GTK main loop
}

Our class should now look like this:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package mygtktexteditor;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import org.gnome.gdk.Event;
import org.gnome.glade.Glade;
import org.gnome.glade.XML;
import org.gnome.gtk.FileChooserAction;
import org.gnome.gtk.FileChooserDialog;
import org.gnome.gtk.FileFilter;
import org.gnome.gtk.Gtk;
import org.gnome.gtk.ResponseType;
import org.gnome.gtk.TextBuffer;
import org.gnome.gtk.TextView;
import org.gnome.gtk.ToolButton;
import org.gnome.gtk.Widget;
import org.gnome.gtk.Window;

/**
 *
 * @author Georgios "cyberpython" Migdos <cyberpython@gmail.com>
 */
public class MyGtkTextEditor {

    private Window mainWindow;
    private ToolButton openButton;
    private TextView textView;
    private TextBuffer textBuffer;

    public MyGtkTextEditor(){

        Gtk.init(new String[0]);//This must be called before
                                //anything else that is GTK related

        initComponents(this.getGladefilePath());
        connectWidgetsAndEvents();

        Gtk.main();//invokes the GTK main loop
    }

    private void initComponents(String path) {
        try {
            XML gladeXML = Glade.parse(path, "window1");

            this.mainWindow = (Window) gladeXML.getWidget("window1");
            this.openButton = (ToolButton) gladeXML.getWidget("toolbutton2");
            this.textView = (TextView) gladeXML.getWidget("textview1");

            this.textBuffer = new TextBuffer();
            this.textView.setBuffer(this.textBuffer);

            this.mainWindow.showAll();
        } catch (FileNotFoundException fnfe) {
            fnfe.printStackTrace();
        }

    }

    private void connectWidgetsAndEvents() {

        this.mainWindow.connect(new Window.DeleteEvent() {
            public boolean onDeleteEvent(Widget source, Event event) {
                Gtk.mainQuit();
                return false;
            }
        });

        this.openButton.connect(new ToolButton.Clicked() {
            public void onClicked(ToolButton arg0) {
                openFile();
            }
        });

    }

    private void openFile() {
        FileChooserDialog dlg = new FileChooserDialog("Open...", this.mainWindow, FileChooserAction.OPEN);
        FileFilter textFileFilter = new FileFilter("Text files");
        textFileFilter.addMimeType("text/plain");
        dlg.addFilter(textFileFilter);

        ResponseType response = dlg.run();
        dlg.hide();
        if(response.equals(ResponseType.OK)){
            String text = "";
            try{
                InputStreamReader reader = new InputStreamReader(new FileInputStream(dlg.getFilename()), "UTF-8");
                char[] buffer = new char[512];
                while(reader.read(buffer)!=-1){
                    text = text + String.valueOf(buffer);
                }
                reader.close();
            }catch(IOException ioe){
                ioe.printStackTrace();
                text = "";
            }
            this.textBuffer.setText(text);
        }
    }

    private String getGladefilePath() {
        try {
            URI uri = this.getClass().getProtectionDomain().getCodeSource().getLocation().toURI();
            File f = new File(uri);
            String canonicalPath = f.getParentFile().getCanonicalPath();
            File f2 = new File(canonicalPath + File.separator + "glade" + File.separator + "main_window.glade");
            return f2.getCanonicalPath();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

Now, edit Main.java and create a MyGtkTextEditor object in the main method:

MyGtkTextEditor myTextEditor = new MyGtkTextEditor();

Finally, click on “Run” -> “Clean and Build Main Project” and then click “Run” -> “Run Main Project”. You should get something like this:

You can browse the Java-Gnome API documention here.

Now that you know how to work with GTK+ and Java you can implement the missing functionality for our application (New/Save, clipboard operations etc.). Or you can replace the TextView with a GtkSourceView and turn this into a code editor with syntax-highlighting.

Have fun!

Ο Chromium (όπως και ο Chrome) σε πολλές περιπτώσεις δεν χρησιμοποιούν το κατάλληλο χρώμα ώστε η tab bar να μοιάζει ως συνέχεια του πλαισίου του παραθύρου (όταν βέβαια έχουμε επιλέξει να γίνεται χρήση του GTK theme και των πλαισίων παραθύρων του συστήματος).

Για να το διορθώσουμε αυτό, πρέπει να επέμβουμε στο αρχείο .gtkrc του θέματος που χρησιμοποιούμε.

Το αρχείο αυτό βρίσκετε στο φάκελο gtk-2.0 μέσα σε ένα φάκελο με το όνομα του θέματος σε μία από τις τοποθεσίες /usr/share/themes ή ~/.themes (το ~/ είναι ο φάκελος του χρήστη σας). Π.χ. για το Hanso theme που έχω εγκαταστήσει μόνο για το δικό μου χρήστη βρίσκετε στο:

/home/cyberpython/.themes/Hanso/gtk-2.0/gtkrc

Σε αυτό το αρχείο (gtkrc) θα βρούμε μία γραμμή όπου δηλώνεται η μεταβλητή:

gtk_color_scheme

Εμείς θα προσθέσουμε δύο επιπλέον χρώματα που θα χρησιμοποιούνται για την tab bar, τα:

frame_color

inactive_frame_color

Τις τιμές που θα τους δώσουμε μπορούμε να τις βρούμε χρησιμοποιώντας ένα εργαλείο όπως το gcolor2 και κάνοντας κλικ στο πλαίσιο του παραθύρου. Η τιμή για το Hanso theme είναι:

#241E12

Οπότε προσθέτουμε στην τιμή της gtk_color_scheme (πριν το τελευταίο ” ) το:

\nframe_color:#241E12\ninactive_frame_color:#241E12

Εχθές είχα καλλιτεχνικές ανησυχίες και έτσι έχουμε ένα νέο GTK+ theme:

Clearlooks Bright Gummy:

και ένα νέο Metacity theme με 3 παραλλαγές:

GlossyTop:

The following program fetches an XML file from http://weather.yahooapis.com and displays the current weather information the file contains.

I wrote this program in order to use it in combination with conky. The result looks like this:

#!/usr/bin/env python3 

import sys
import urllib.request, urllib.error, urllib.parse
import xml.dom.minidom
from xml.dom.minidom import Node 

class YahooWeatherInfo: 

        def __init__(self, areaCode, units):
                self.areaCode = areaCode
                self.units = units
                self.city = ""
                self.region = ""
                self.country = ""
                self.temperatureUnit = ""
                self.distanceUnit = ""
                self.pressureUnit = ""
                self.speedUnit = ""
                self.temperature = ""
                self.windDirection = ""
                self.windSpeed = ""
                self.humidity = ""
                self.visibility = ""
                self.pressure = ""
                self.sunrise = ""
                self.sunset = ""
                self.forecasts = [] 

        def getWeatherInfo(self):
                try:
                        url = "http://weather.yahooapis.com/forecastrss?p="+self.areaCode+"&u="+self.units
                        xml_file = urllib.request.urlopen(url)
                        doc = xml.dom.minidom.parse(xml_file) 

                        #LOCATION:
                        for node in doc.getElementsByTagName("yweather:location"):
                                self.city = node.getAttribute("city")
                                self.region = node.getAttribute("region")
                                self.country = node.getAttribute("country")
                        #UNITS:
                        for node in doc.getElementsByTagName("yweather:units"):
                                self.temperatureUnit = node.getAttribute("temperature")
                                self.distanceUnit = node.getAttribute("distance")
                                self.pressureUnit = node.getAttribute("pressure")
                                self.speedUnit = node.getAttribute("speed")
                        #WIND:
                        for node in doc.getElementsByTagName("yweather:wind"):
                                self.temperature = node.getAttribute("chill")
                                self.windDirection = node.getAttribute("direction")
                                self.windSpeed = node.getAttribute("speed")
                        #ATMOSPHERE:
                        for node in doc.getElementsByTagName("yweather:atmosphere"):
                                self.humidity = node.getAttribute("humidity")
                                self.visibility = node.getAttribute("visibility")
                                self.pressure = node.getAttribute("pressure")
                        #ASTRONOMY:
                        for node in doc.getElementsByTagName("yweather:astronomy"):
                                self.sunrise = node.getAttribute("sunrise")
                                self.sunset = node.getAttribute("sunset")
                        #FORECAST (day, date, low, high, description):
                        self.forecasts = []
                        for node in doc.getElementsByTagName("yweather:forecast"):
                                self.forecasts.append([node.getAttribute("day"), node.getAttribute("date"), node.getAttribute("low"), node.getAttribute("high"), node.getAttribute("text")]) 

                except :
                        self.city = "-"
                        self.region = "-"
                        self.country = "-"
                        self.temperatureUnit = "-"
                        self.distanceUnit = "-"
                        self.pressureUnit = "-"
                        self.speedUnit = "-"
                        self.temperature = "-"
                        self.windDirection = "-"
                        self.windSpeed = "-"
                        self.humidity = "-"
                        self.visibility = "-"
                        self.pressure = "-"
                        self.sunrise = "-"
                        self.sunset = "-"
                        self.forecasts = [] 

class Main: 

        def __init__(self, areaCode, units):
                self.wi = YahooWeatherInfo(areaCode, units)
                self.wi.getWeatherInfo() 

        def getOutput(self, mask):
                m = mask
                m = m.replace('/c', self.wi.city)
                m = m.replace('/r', self.wi.region)
                m = m.replace('/o', self.wi.country)
                m = m.replace('/x', self.wi.temperatureUnit)
                m = m.replace('/b', self.wi.distanceUnit)
                m = m.replace('/n', self.wi.pressureUnit)
                m = m.replace('/m', self.wi.speedUnit)
                m = m.replace('/t', self.wi.temperature)
                m = m.replace('/d', self.wi.windDirection)
                m = m.replace('/s', self.wi.windSpeed)
                m = m.replace('/h', self.wi.humidity)
                m = m.replace('/v', self.wi.visibility)
                m = m.replace('/p', self.wi.pressure)
                m = m.replace('/a', self.wi.sunrise)
                m = m.replace('/z', self.wi.sunset)
                forecasts = ""
                for forecast in self.wi.forecasts:
                        forecasts += forecast[0]+", "+forecast[1]+" - low: "+forecast[2]+" - high: "+forecast[3]+" - Condition: "+forecast[4]+"\n"
                m = m.replace('/f', forecasts)
                return m 

def checkRuntimeArguments():
        if len(sys.argv)!=4:
                print("Wrong number of parameters.\nUsage is:\n\tweather.py areacode units mask\n\tmask can include:\n\t\t/c:\tcity\n\t\t/r:\tregion\n\t\t/o:\tcountry\n\t\t/x:\ttemperature unit\n\t\t/b:\tdistance unit\n\t\t/n:\tpressure unit\n\t\t/m:\tspeed unit\n\t\t/t:\ttemperature\n\t\t/d:\twind direction\n\t\t/s:\twind speed\n\t\t/h:\thumidity\n\t\t/v:\tvisibility\n\t\t/p:\tpressure\n\t\t/a:\tsunrise\n\t\t/z:\tsunset\n\t\t/f:\t1-day forecast\n\n\texample:\n\t\tweather.py GRXX0004 c \"/c,/o - temp: /t/x, vis: /v, hum: /h, pres: /p/n - sunrise: /a, sunset: /z\"\n\tresult:\n\t\tAthens,GR - temp: 21C, vis: 15, hum: 52, pres: 1021.8mb - sunrise: 7:16 am, sunset: 7:15 pm")
                exit(0) 

def checkUnits(units):
        if(units != "c")and(units!="f"):
                print("Wrong units type!\nPossible values are:\n\t\tc:\tCelsius\n\t\tf:\tFarenheit\n")
                return False 

checkRuntimeArguments() 

areaCode = sys.argv[1]
units = sys.argv[2]
checkUnits(units)
mask = sys.argv[3] 

m = Main(areaCode, units)
print(m.getOutput(mask))

Python’s standard library provides a great and simple way – via PasswordMgr and HTTPBasicAuthHandler – to provide credentials used for basic HTTP authentication, but (at least as far as I know) it can be used only for username-password pairs.

The problem is that sometimes – for example if you want to retrieve an xml file from gnome-look.org – you want to use an API key for authentication. To achieve that all we have to do is encode the API key with the Base64 algorith and then send it along with our HTTP request included in a basic authentication header (Note: For some reason the encoded string that I got using Python’s Base64 implementation included a line break that messed things up, so it might be wise to encode the API key by hand and then insert it to your code):

def download_file(url, API_KEY_BASE_64):
    req = urllib2.Request(url)
    req.add_header("Authorization", "Basic "+API_KEY_BASE_64)
    return urllib2.urlopen(req)

Of course you will have to import urllib2 (urllib in Python3).