sweet, crone, smash

chico, ace, rois

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!

Na primeira parte deste tutorial você viu como montar o ambiente de desenvolvimento necessário para criar o glossário, e definimos um dialeto CSV para ser usado ao ler e gravar os arquivos com os termos do glossário. Nessa parte, você verá como fazer o programa ler e gravar esses arquivos CSV.

Antes de escrever o código, é necessário conhecer as funções reader e writer do módulo CSV. Como o próprio nome diz, reader serve para ler o CSV. Ela recebe um dialeto e um objeto iterável contendo strings (como uma lista ou um arquivo) e retorna outro objeto iterável, dessa vez com os campos do CSV já separados de acordo com o dialeto. Exemplo:

reader = csv.reader(arquivo, dialect="excel")

No nosso caso, usar uma lista com os campos (termo e significado) não faz muito sentido, pois um dicionário com os termos como chaves, e os significados como seus valores, cumpriria bem melhor o papel. Assim, na hora de pesquisar um significado, basta chamar:

dicionario[termo]

E na hora de gravar ou criar um novo termo, basta chamar:

dicionario[termo] = significado

Mais na frente faremos algumas modificações no dicionário do Python (a tipo dict) para adaptá-lo melhor às necessidades de um glossário, mas por enquanto só precisamos de uma função que receba o caminho do arquivo CSV e retorne um dicionário comum. Veja o código da função.

Repare que quando há uma exceção IOError ao abrir o arquivo, caso ele exista, é lançada uma exceção do tipo ArquivosError, que nada mais é do que uma classe de exceção vazia. Classe de exceção é uma classe que herda da classe base para todas as exceções no Python, a Exception. Pra que criar uma classe de exceção vazia? Para organizar nosso programa e dar um tratamento especial a esses erros na interface gráfica. Veja o código da classe  ArquivosError.

O próximo passo é criar a função que vai gravar os novos termos e as alterações que foram feitas no glossário do arquivo a partir do qual ele foi carregado. Para isso, utilizaremos a função writer que, assim como reader, recebe um arquivo e um dialeto retornando um objeto com os métodos write e writerows. Write escreve um registro por vez, e writerows recebe um iterável e escreve cada registro dentro dele no arquivo. Exemplo:

registro = ('C', 'Linguagem de programação.')
f = file('arquivo.csv', 'w')

writer = csv.writer(f, dialect='excel')
writer.write(registro)

registros = {'Flash':'Uma tecnologia para estragar sites.', 'Assembler':'Não é o nome de uma linguagem'}
writer.writerows(registros.items())

O que precisamos no nosso módulo de arquivos, é uma função que receba um dicionário com os dados a serem gravados no arquivo, e receba um caminho de arquivo para gravar esses dados. Lembra quando eu disse que vamos criar um dicionário personalizado? Um dos recursos do nosso dicionário é que ele armazenará no atributo path uma string com o caminho do arquivo de onde ele foi lido, assim a nossa função de gravar só precisa receber o glossário, ou seja, o nosso dicionário especial. Veja o código da função.

Note que nas duas funções eu usei o módulo codecs para abrir os arquivos, e usei a “constante” CODIFICACAO para informar a função open(), a codificação do arquivo. O módulo codecs é uma mão na roda na hora de mexer com arquivos de texto, porque ele evita diversos problemas de codificação. Ao ler um arquivo, ele usa a codificação informada para converter o conteúdo em Unicode (uma espécie de codificação universal), e ao gravar ele transforma as strings Unicode de volta em strings codificadas, de forma transparente. Eu � Unicode.

Você pode atribuir a CODIFICACAO o charset que quiser (eu gosto de usar sempre utf-8). Basta que ao salvar o CSV em outros programas (como editores de planilha), você tenha o cuidado de usar sempre a mesma codificação para evitar que o texto apareça todo zoado no glossário.

Com essa parte do tutorial finalizamos o nosso módulo de ler arquivos. Veja aqui o código completo, comentado e documentado do módulo. Na próxima parte do tutorial, faremos o nosso “model” e mostrarei como personalizar o dicionário do Python, incluindo o atributo path e otras cositas más.

After installing Karmic Koala, i’ve encountered a stupid problem in Eclipse which kept me from coding a few days, just because i couldn’t do click some buttons. After creating a new project, the Next button was not working if i was clicking on it, but navigating to it from the keyboard and then pressing space seemed to be the solution. I’ve discovered a bug, https://bugs.eclipse.org/bugs/show_bug.cgi?id=287307, and it seems that this will be changed for Eclipse 3.6, but for previous versions for Eclipse, just make sure you set environment variable GDK_NATIVE_WINDOWS=1

Example:

#!/bin/sh
export GDK_NATIVE_WINDOWS=1
`/media/part2/programming/eclipse/eclipse -vmargs -Xms128M -Xmx512M -XX:PermSize=128M -XX:MaxPermSize=512M &> /dev/null` &

Si actualizaste a Karmic y venias usando Eclipse, podrás darte cuenta que los botones no funcionan correctamente en esta aplicación. Bueno, la solución es muy sencilla, solo debemos abrir una consola y escribir lo siguiente:

sudo gedit /ruta_donde_instalaste_eclipse/MiEclipse

Ahí te debe abrir un archivo vacio, entonces copia y pega lo siguiente (modifica la ruta a eclipse tal y como lo hiciste en el paso anterior)

#!/bin/sh

export GDK_NATIVE_WINDOWS=1

/RUTA_DONDE_TIENES_ECLIPSE/eclipse

Guardas el archivo, y luego le das permisos de ejecución:

sudo chmod +x /ruta_donde_instalaste_eclipse/MiEclipse

Ahora modificas el lanzador de la aplicación, dirígete al Menú Aplicaciones, le das click derecho, selecciona la opción Editar los Menús, encontrarás esta pantalla

Menú de opciones del menú de Aplicaciones (que raro suena!!)

Selecciona Eclipse, y modifica el lanzador para que quede como esta imagen (obviamente la ruta de eclipse es distinta, modifícala según tu instalación)

Y listo!! Cuando abras Eclipse los botones ya deben funcionar.

Up The Irons!!

Fuente: Zdes (Gracias!!!)

These days, widget animation in linux is quite hot. I summarized several approaches.

GTK + Clutter

Basic idea behind this approach is adding GTK widget as an Clutter Actor on Clutter Scene. Animation and transparency is done by Clutter. It is by virtue of GTK client side window, off screen rendering, supported from 2.18.x.

• The return of Client side windows
• Animating GTK+, Clutter-Gtk, client-side-windows and demos
• Design experience and demos in GTK and Clutter

Pixmap based animation in GTK

Comparing to the GTK+Clutter approach, it animates redirected widget in main event loop using cairo.

• Discussion at GTK Dev Mailing list: [1], [2]
• Bugzilla: pixmap based animation, timeline
• Demo video clips: [1], [2]

PAF aka PAF Animation Framework

However above two approaches are specific to GTK, PAF is aiming to create a more general framework. It provides a interface to change GObject values with given time function.

• GNOME PAF Project page
• Blog post

QT Animation Framework

QT also provides implicit animation framework from QT 4.x. Here are some introductory materials.

• Blog post with video clip
• Nokia: [1], [2]

Other References

• Quick Study of Existing Animation Systems
• Apple’s CoreAnimation

Working with GTK# can be a  pain, which is also true with printing. The only good thing I can say on this is that for once GTK# isn’t far behind other toolkits such as WinForms and WPF. Just like all the other toolkits you have to draw everything.

The good news is that we don’t have to use GTK#. Mono has a project called webkit-sharp that makes rendering prints a dream compared to existing solutions. Bad news about it is that you have to compile it yourself on Ubuntu, since the the current libraries isn’t up to date (probably will be in 10.04, since Mono 2.6 should be out then).

I won’t cover compiling here though that’s for another post.

How to do the actual printing is actually so simple it’s silly. What you basically do is to create a WebView, feed it with the html and run the Print-method. Here’s an example:

using System;
using Gtk;
using WebKit;

class MainClass
{
     public static void Main(string[] args)
     {
         Application.Init();
         WebView v = new WebView();
         v.LoadHtmlString(@"<html><body><h1>Hello printer!</ht></body></html>", null);
         v.MainFrame.Print();
         Application.Run();
     }
}

Hope this will easy your job of printing next time you need to print something

kesp

gold

chico

Today I tried to use Eclipse with Pydev to create a HelloWorld GTK application, but it was not that easy I’ve thought it would be. With the following lines I want to describe my encountered problem and how to solve it. After installing pydev you have to add the python interpreter manually. Go to Window->Preferences->Pydev->Interpreter Python and add e.g. /usr/bin/python2.6 Now the plugin will automatically detect some directories to add to the PYTHONPATH and you can run your first HelloWorld application:

import gtk
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.connect("destroy", gtk.main_quit)
window.show()
gtk.main()

It shouldn’t be a problem to run this application with “Run As->Python Run” and you will see a simple GTK window. But the problem is, that code completion for gtk doesn’t work because pydev can’t find the imported gtk package.

To solve this problem, add /var/lib/python-support/python2.6/gtk-2.0 and /var/lib/python-support/python2.6/ to your PYTHONPATH and gtk, gobject, pango and atk to your “Forced Builtins”.

(The picture doesn’t show “atk”, but it should also be added to the list.) If the problem is still present, remove the python interpreter and add it again. Now the code completion for GTK should work.

For the past couple of days, I have been struggling with my eyesight on a 12 inch monitor with Ubuntu Karmic. It has not helped that, for some reason or other, I have been working frequently on a Windows 7 machine. As much as I hate to admit it – Win7 beats the pants off Karmic with its eye candy and usability.

These days I am building a Linux NAS box using ZFS-FUSE on a Hardy Box and I keep running into unfixed driver regressions like this one for a Davicom Ethernet Card. I personally believe that for Lucid Lynx, all that Ubuntu should work on is getting driver support cleaned up.

However, one thing I would like to see is resolution independence (Ubuntu’s blueprint) – which is where my eyesight and the 12 inch desktop comes in. In essence what it means is that the operating system resizes it’s UI – fonts, icons, windows – at any hardware resolution to match the physical size that you are comfortable with. This does away with the problem that at higher screen resolution, fonts look smaller (because at higher resolution the pixels themselves take up lesser space). Win7 included this feature after a lot of brainstorming.

And of course, the question of high quality icons for Linux – there have been quite a few ideas submitted to Ubuntu about this – most of which rely on Scalable Vector Graphics for this. While being theoretically sound – there is a huge performance hit by using scalable graphics, rather than bitmaps for icons. OSX – which has arguably the sweetest eye candy – does not use vector graphics for its icons.

The key to this is its ICNS format – which has a set of images at varying resolutions for icons. Interestingly, GTK has had support for Apple .icns for a long time now. A very interesting discussion on the impact of resolution-independence on icons is quite lively to read.

I would be all in favor of using the Apple ICNS format as the standard supported format in Linux. Except for not-invented-here, what’s not to like ? The format itself may demand support of scaling and resolution independent technologies to be included in GTK – which I think is a good thing, rather than mutating the icon format to support the state of GTK as it is now.

One gets access to a big market of designers who create high quality icon sets for MacOS (may more out there than for Gnome) and readily available toolchains (including for Gimp)

Take a look here and tell you dont want these …. and then let’s talk.

Há uns dias atrás mostrei como escrever um programinha pra gerar senha aleatória com python, bom resolvi montar uma interface gráfica pra ele usando gtk+glade+python o script que gera a senha é basicamente o mesmo que mostrei em outro post..
bom galera espero que gostem, na verdade vi vários desses na net e resolvi tbm codificar o meu
há ia me esquecendo a tela que desenhei no glade é super simples tem um caixa de texto que dei o nome de senha
um label que ira mostrar o resultado que dei o nome de resultado
e tem tbm 3 botoes,
um pra gerar a senha, outro com about só pra fazer uso das caixas de mensagens e tem tbm um botão pra sair do programa, qq duvida a respeito das telas me avisem, vou ver se coloca elas aqui tbm

#! /usr/bin/python
# -*- coding: iso-8859-1 -*-

# Criado em: "03/11/2009"
# Autor: MRSantos mrsantos@viaconnect.com.br
#
# A espera não é uma esperaça vazia,
# possui a certeza interior de alcançar seu objetivo...

try:
	import gtk
except:
	print "Modulo python-gtk2 nao encontrado: sudo apt-get install python-gtk2"

try:
	import gtk.glade
except:
	print "Modulo python-glade2 nao encontrado: sudo apt-get install python-glade2"

import os
from random import choice

class gera_senha(object):

	def __init__(self):

		os.system("clear")
		dir = ''
		file = 'gera_senha.glade'
		path = "%s%s" % (dir, file)
		self.interface = gtk.glade.XML(path)
		self.interface.signal_autoconnect(self)

		self.janela = self.interface.get_widget("janela")
		self.janela.set_title("Gerador de senhas by mrsantos")
		self.janela.connect("destroy", gtk.main_quit)

		self.tamanho = self.interface.get_widget("tamanho")
		self.tamanho.set_text("10")

		self.resultado = self.interface.get_widget("resultado")

	def mensagem(self, texto, janela=None):
		dialogo= gtk.MessageDialog(janela, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, texto)
		dialogo.set_markup(texto)
		dialogo.run()
		dialogo.destroy()

	def gera_senha(self):
		tamanho = None
		caracters = '0123456789abcdefghijlmnopqrstuwvxz'
		try:
			tamanho = int(self.tamanho.get_text())
		except:
			tamanho = 10

		passwd = ''
		for char in range(tamanho):
			passwd += choice(caracters)

		return passwd

	def on_sair_clicked(self, widget):
		gtk.main_quit()

	def on_about_clicked(self, widget):
		texto = "%s" % (15000, 'blue', "By mrsantos")
		self.mensagem(texto)

	def on_gera_clicked(self, widget):
		passwd = self.gera_senha()
		self.resultado.set_label("%s" % \
		(15000, 'orange', passwd))

	def main(self):
		self.janela.show_all()
		gtk.main()

if __name__ == '__main__':
	gs = gera_senha()
	gs.main()

imagem da tela feita no glade

imagem do aplicativo pronto

É isso ai galera, espero que gostem, abraços

Marcio

I’m writing a gvim clone in Vala, and wanted auto-indentation for my ‘open new line’ function. So I looked around, and hey, all I have to do is set_auto_indent (true);. But wait, that’s using SourceView, and I’ve been using TextView! For a minute I panicked, thinking I would have to rewrite everything, but no, I pretty much just have to change
view = new TextView ();
to
view = new SourceView ();
and I’m good to go.

Well, not quite – auto-indentation is triggered on keypress, so instead of inserting a newline with:
buffer.insert_at_cursor ("\n", 1);
I have to emit a keypress signal:
Event open = new Event (EventType.KEY_PRESS);
open.key.keyval = 65293;//enter
Signal.emit_by_name (view, "key-press-event", open);

This is what I end up with:

using Gtk;
using Gdk;

public class TextEditor : Gtk.Window {

	public SourceView view;
	public TextBuffer buffer;

	public TextEditor () {
		this.set_default_size (400, 300);
		this.view = new SourceView ();
		view.set_auto_indent (true);
		this.buffer = this.view.buffer;
		buffer.text = "\toh hai";

		var scroll = new ScrolledWindow (null, null);
		scroll.set_policy (PolicyType.AUTOMATIC, PolicyType.AUTOMATIC);
		scroll.add (this.view);
		add (scroll);

		key_snooper_install (snoop_callback, null);
	}

	public int snoop_callback () {
		var event = get_current_event ();
		var key = event.key;
		if (event.type == EventType.KEY_PRESS) {
			switch (key.keyval) {
				case 111://o
					var offset = buffer.cursor_position;
					TextIter iter;
					buffer.get_iter_at_offset (out iter, offset);
					if (!iter.ends_line ())
						iter.forward_to_line_end ();
					buffer.place_cursor (iter);
					Event open = new Event (EventType.KEY_PRESS);
					open.key.keyval = 65293;//enter
					Signal.emit_by_name (view, "key-press-event", open);
					break;
				default:
					stdout.printf("%u %s\n", key.keyval, key.str);
					break;
			}
		}
		return 1;
	}

	public static int main (string[] args) {
		Gtk.init (ref args);

		var window = new TextEditor ();
		window.destroy.connect (Gtk.main_quit);
		window.show_all ();
		window.present ();

		Gtk.main ();
		return 0;
	}
}

This gives lots of warnings that I’m not sure what to do with, but it works.