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.

Parę postów wcześniej opublikowałem gui do programu povray z paroma podstawowymi opcjami. Tak jakoś wyszło, że projekt powoli przeradza się w zaawansowany edytor.
Założenia:

• odbiegające od norm gui (wiekszość opcji po lewej stronie programu)
• kolorowanie składni
• możliwość dodawania gotowych obiektów do projektu
• 2 tryby widoku – samo gui do renderowania i edytor

Póki co tyle.  W co się to rozrośnie zobaczymy w swoim czasie.  Na razie zamieszczam 3 zrzuty ekranu:

<kbum> como eu poderia fazer uma barra de progresso que atualize
de acordo com a execuçao de determinado trecho do codigo?
<kbum> nosklo, conhece alguma soluçao pra esse caso?
<nosklo> kbum: a barra de progresso nao atualiza sozinha.
vc precisa atualiza-la.
<kbum> certo
<kbum> eu to pensando numa forma de "atualiza-la"
<kbum> pq se fosse um laço eu atualizaria facil facil
<kbum> mas sao metodos que estao executando
<epx> é, atualizar andamento sempre eh chato
<nosklo> kbum: tem um jeito de facilitar usando geradores
<nosklo> kbum: xo fazer um exemplo
<kbum> nosklo, desculpa, mas tenho que sair agora, agradeço pela ajuda,
mas tenho que ir, se nao perco carona pra voltar pra cidade!

Bom, foi feito um exemplo e aqui está:

Primeiro criei uma classe GlibYield. Ela simplesmente pega um iterável e agenda seu próximo passo usando glib.idle_add(). Criei três funções que servem de ganchos para subclasses desta classe.

A idéia aqui é que a função que está sendo monitorada será escrita com uma série de yields que a tornarão um gerador. Este gerador então será consumido a cada passo, e pode-se fazer qualquer coisa entre estes passos.

Na listagem abaixo, eu usei glib.timeout_add(1000, …) ao invés de glib.idle_add(…), para que demore mesmo um tempo entre cada passo. Ao usar em um caso real, troque pela linha glib.idle_add() comentada.

import pygtk
pygtk.require('2.0')
import gtk
import glib

class GlibYield(object):
    def __call__(self, iterable, *args, **kwds):
        obj = self.before_start(*args, **kwds)
        glib.timeout_add(1000, self.step, iter(iterable), obj)
#        glib.idle_add(self.step, iter(iterator), obj)

    def step(self, iterator, obj):
        try:
            data = next(iterator)
        except StopIteration:
            self.on_end(obj)
        else:
            obj = self.on_step(data, obj)
            glib.timeout_add(1000, self.step, iterator, obj)
#            glib.idle_add(self.step, iterator, obj)
        return False

    def before_start(self, *args, **kwds): pass
    def on_step(self, data, monitor_obj): pass
    def on_end(self, monitor_obj):  pass

Criei então uma subclasse de GlibYield que cria uma barra de progresso em um certo container (que você passa como parâmetro) e a atualiza com os valores que vem da função sendo executada:

class GtkProgressCreator(GlibYield):
    def __init__(self, container):
        self._container = container

    def before_start(self, title='Aguarde...'):
        pb = gtk.ProgressBar()
        if title:
            pb.set_text(title)
        self._container.pack_start(pb, True, True, 0) # TODO: incluir formas de customizar isso
        pb.show()
        return pb

    def on_step(self, data, pb):
        pb.set_fraction(data)
        return pb

    def on_end(self, pb):
        pb.destroy()

Aqui temos um exemplo da utilização da classe. O método calcula() é uma função geradora. Ao clicar no botão, ele é executado, criando um objeto gerador, que é passado para o GtkProgressCreator. Este então cria uma barra de progresso, e a atualiza toda vez que o gerador dá um yield, reagendando o próximo passo pela glib.

class TestStep(object):
    def clicou(self, widget, data):
        print "Calculando..."
        # Executa a funcao no GtkProgressCreator
        self.pc(self.calcula(15, 14, 5))

    def calcula(self, n1, n2, n3):
        r = n1 + n2
        yield 0.25 #cada yield atualiza a barra de progresso e libera a GUI

        r = r * n3
        print 'Estamos na metade...'
        yield 0.5

        r = r / n1
        yield 0.75

        r = r ^ n2
        yield 1

        print 'RESULTADO ENCONTRADO: ', r

    def delete_event(self, widget, event, data=None):
        gtk.main_quit()
        return False

    def __init__(self):
        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_title("Teste de Step!")
        self.window.connect("delete_event", self.delete_event)
        self.window.set_border_width(10)
        self.box1 = gtk.VBox(False, 0)
        self.window.add(self.box1)
        self.button1 = gtk.Button("Calcular")
        self.button1.connect("clicked", self.clicou, 1)
        self.box1.pack_start(self.button1, True, True, 0)
        self.button1.show()
        self.box1.show()
        self.window.show()

        # Cria um progresscreator que criara barras de progresso em box1
        self.pc = GtkProgressCreator(self.box1)

def main():
    gtk.main()

if __name__ == "__main__":
    s = TestStep()
    main()

Existem alguns problemas com esta implementação – A principal é que ela não é boa com operações que duram muito tempo entre os yields, pois a GUI ficará travada nestes pontos. Nestes casos demorados, a operação geralmente depende de fatores externos – leitura de arquivos, acesso de rede – e aí o melhor seria utilizar as funções corretas da glib para eses casos (glib.io_add_watch). O gerador então poderia até injetar os resultados de cada chamada destas de volta na função através do http://docs.python.org/reference/expressions.html#generator.send ; Até pensei em escrever algo assim e atualizar depois o post.

Porém eu desisti. Porque melhor que tudo isso é usar twisted com um reactor GTK. Twisted possui deferreds – na verdade este código acima foi inspirado no http://twistedmatrix.com/documents/current/api/twisted.internet.defer.html#inlineCallbacks e é uma “versão pobre” deste esquema.

Mesmo assim foi divertido escrevê-la, e funciona! Veja como ficou ao clicar 4 vezes no botão rapidamente:

4 barras de progresso atualizadas independentemente

Za namową przyjaciela napisałem bardzo proste GUI do obsługi povraya. Przydaje się to szczególnie gdy nie chce się za każdym razem pisać długiego polecenia do zrenderowania kolejnego obrazka. Przy okazji nie zaśmieca się .bash_history

Póki co program:

• pozwala wybrać rozdzielczość
• pozwala ustawić jakość (0-9) oraz włączyć antialiasing
• zapamiętuje ostatnio wybrane parametry i plik
• otwiera wybrany plik w aplikacji medit.

GPov - gui dla povray

POBIERZ

Na razie tylko w języku polskim. W najbliższym czasie pewnie pojawi się wersja po angielsku.

Kto wie… może kiedyś pokuszę się na cały edytor do povray’a.

Yesterday I released GCounter 0.3 and today version 0.4 is out.

Changes:

• some bugs fixed
• add tray icon support
• whole app split as 2 .py files
• Reset default settings and Clear action history don’t need to restart app anymore.

You can download it from HERE.

And still – if you find some bugs or have a suggestion please mail to me.

Wbrew pozorom obługa ikony w tacce w pyGTK jest bardzo proste. Na sam początek wywołujemy samą ikonę, potem zajmiemy się jej atrybutami:

self.mojaikona = gtk.StatusIcon()

Teraz wypadałoby nadać ikonie jakiś wygląd. Myśle, że dwa najbardziej przydatne sposoby to:

self.mojaicona.set_from_stock(gtk.STOCK_FIND)

i

self.mojaikona.set_from_file(“/home/kuba/mojprogram/mojaikona.png”)

Myślę, że obie metody są wystarczająco zrozumiałe same w sobie. Aby ikona reagowała na kliknięcia wystarczy podpiąć sygnały:

self.mojaikona.connect(“activate”, activate)

self.mojaikona.connect(“popup_menu”, popup)

Pierwsze dotyczy kliknięcia lewym przyciskiem myszy, drugie prawym. Oczywiście dane funkcje należy zdefiniować w kodzie. Na przykład:

def self.activate(self,widget):

tu jakieś polecenia

i tyle

Teraz wystarczy ustawić widoczność ikony na True:

self.mojaikona.set_visible(True)

I po włączeniu programu mamy działającą ikone w Tray’u

Hi, I just release version 0.3 of my GCounter. App is using sudo for standard commands and pm-suspend for suspend option. You can also enter your own commands.

TO DO:
- multilanguage support (now – only english)
- tray icon
- more preferences (not only sudo etc)

You can download it from HERE.

Mês passado fiz um trabalho de equipe no curso técnico para a disciplina Inglês Técnico – III, que era escrever um glossário com termos relacionados a software, e outras equipes pesquisariam outros temas. Além disso era necessário desenvolver uma forma de visualizar os termos no computador, e o resultado foi este programinha em Python e Glade:

É bem simples, mas como muita gente que eu conheço tem curiosidade em relação ao Python e ao Glade este post será o primeiro mostrando passo-a-passo como fazer um programa parecido com o do meu trabalho. Parecido porque vou tentar melhorar o código do atual pra não passar vergonha aqui nas interwebs.

Se você está no Linux, basta instalar o Glade e provavelmente já terá tudo que precisa pra começar instalado aí. Quando muito falta instalar o PyGTK. Caso esteja no Windows, a coisa complica um pouco: você precisa baixar o interpretador Python, o GTK, o Glade (link para a versão sem GTK embutido), o PyGTK, PyGObject e o PyCairo e instalá-los (nessa ordem).

Dica: a instalação do GTK pelo arquivo do link é um porre, então instale o Geany, um IDE peso-leve, que fará essa tarefa por você e já serve para escrever os códigos que criaremos. Além de Python ele suporta várias outras linguagens, como Pascal, C, C++, Ruby, Java, C#, PHP, etc. Se correu tudo bem até aqui está pronto o seu ambiente de desenvolvimento.

Vamos para o código! O projeto usa como forma de armazenamento arquivos no formato CSV, permitindo assim abrir e editar o glossário como uma planilha do Excel ou do Calc. Felizmente o Python já traz na sua biblioteca padrão um módulo capaz de gerenciar a leitura e gravação desses arquivos. No entanto, estou repensando o código para que ele fique mais modular, de forma que você possa mudar essa característica sem ter de mexer no resto do código.

Apesar de existir uma especificação para o formato CSV é necessário apelar para auto-detecção ou definir o dialeto que será usado porque nem todos os programas usam os mesmo símbolos na hora de trabalhar com esses arquivos. Como auto-detecção é algo sujeito a falhas vamos definir o nosso próprio dialeto CSV. O que é feito na seguinte classe: (salve-a em um arquivo chamado “arquivos.py” que será o módulo de acesso aos arquivos do nosso programa)

Veja o código aqui. O WordPress estava bagunçando a indentação toda. =/

• “delimiter” é o caractere usado para separar os campos de um registro. No nosso caso os registros possuem dois campos: termo e descrição;
• “quotechar” é o caractere usado para aspas;
• “doublequote” quando verdadeiro (True) coloca dois quotechars seguidos caso no meio de um campo exista um quotechar, por exemplo: “aspas duplas são assim”", ficaria assim “aspas duplas são assim”"”;
• “skipinitialspace” quando verdadeiro determina que o parser deve ignorar espaços no começo dos campos;
• “lineterminator” diz qual o padrão usado para quebrar a linha, ou seja, indicar o fim do registro. O formato padrão de quebra de linha no *nix é “\n” mas se a IETF manda eu colocar o padrão do Windows eu coloco ;
• “quoting” indica o comportamento do módulo quanto ao uso das aspas. csv.QUOTE_ALL significa que todos os campos do registro devem estar entre aspas;
• Por fim, a última linha registra o dialeto que acabamos de criar para ser usado pelo módulo na interpretação e gravação do arquivo.

Pra não tornar a leitura muito cansativa vou encerrar este artigo por aqui. Na próxima “aula” finalizaremos a parte que mexe com os arquivos e começaremos a desenhar a interface no Glade. Quaisquer dúvidas estou à disposição nos comentários. Até lá!

A new bugfix release for CrunchyFrog is out in the wild. There are not much visible changes, but a few bug fixes under the hood. One visible change is the option to give the SQL editor much more space by hiding all other UI elements in the main window. Here’s a screenshot:

SQL editor eating up all space

The second screenshot shows the new highlighting of errors in the editor. In this case there’s no table called “actor”. When the execution of a statement results in a SQL error, CrunchyFrog now tries to find the position of the error in the SQL editor, highlights the corresponding part in your SQL statement and moves the cursor to the right place. I found it very handy to have the cursor in place to correct the error and run the statement again without searching the error before.

ups... an error occurred

If you’re interested in the other, non-visible changes, please read the full list of changes or just go straight to the project page and give it a try

Thanks to everyone who contributed to this release by sending patches and submitting issues on the tracker!

I started a new project today called sxs (short for “side-by-side”). It’s another translation tool, this one designed to help me read things like newspaper articles. The basic premise is that it takes the source text, splits it into sentences, and then displays each sentence with its translation immediately below it.

Screenshot sxs in action

It’s largely functional now, with the glaring exception that it only translates to English. That’s on the hit-list, and it’s largely a matter of UI work.

My “sentence detection” algorithm is also pretty rudimentary, but I think I’ll finesse that as I use the program. It’s deficiencies haven’t really bothered me yet, so it may not get much more love.

You can get sxs here.

I’ve written some documentation about pygtkscintilla project (svn version)
The sourceforge page:
http://sourceforge.net/projects/pygtksci/

The documentation:
http://pygtksci.sourceforge.net

The wiki for bugs, status, other info:
https://sourceforge.net/apps/trac/pygtksci/wiki

I’ve packaged in a rough manner the gtkscintilla module,
follow the instruction in the trac wiki, if you have problem or want to tell me something, leave a comment!

How I wrapped scintilla

In this article I will tell you my journey wrapping pygtkscintilla, I think this could be useful to tell other people which mistakes I made and how I’ve solved them.

Know your enemy

To solve a problem you have to gather all possible information relate to this problem. Scintilla has a scary interface that have nothing to do with a well-formatted gtk-widget.

The interface is a very important thing. If you wanto to wrap scintilla you have to learn the basics of its usage.  Fortunately there was bait, an example  to test scintilla, it’s cast gold.

Here’s the code:

/* bait.c */
#include <gtk/gtk.h>

#include <Scintilla.h>
#include <SciLexer.h>
#define PLAT_GTK 1
#include <ScintillaWidget.h>

static int exit_app(GtkWidget*w, GdkEventAny*e, gpointer p) {
 gtk_main_quit();
 return w&#124;&#124;e&#124;&#124;p&#124;&#124;1;    // Avoid warnings
}

int main(int argc, char **argv) {
 GtkWidget *app;
 GtkWidget *editor;
 ScintillaObject *sci;

 gtk_init(&argc, &argv);
 app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 editor = scintilla_new();
 sci = SCINTILLA(editor);

 gtk_container_add(GTK_CONTAINER(app), editor);
 gtk_signal_connect(GTK_OBJECT(app), "delete_event",
 GTK_SIGNAL_FUNC(exit_app), 0);

 scintilla_set_id(sci, 0);
 gtk_widget_set_usize(editor, 500, 300);

#define SSM(m, w, l) scintilla_send_message(sci, m, w, l)

 SSM(SCI_STYLECLEARALL, 0, 0);

And this is the Makefile associated:

##### Makefile #####
# Make file for bait on Linux or compatible OS
# Released to the public domain 2000 by Neil Hodgson neilh@scintilla.org
# This makefile tested with GCC 3.2 and GNOME 2.0

.SUFFIXES: .c .o .h .a

INCLUDEDIRS=-I../scintilla/include
CXXFLAGS= -DGTK -DSCI_LEXER -W -Wall -fPIC
LEXEROBJS=$(wildcard ../scintilla/gtk/Lex*.o)

all: bait

.c.o:
 gcc `pkg-config --cflags gtk+-2.0` $(INCLUDEDIRS) $(CXXFLAGS) -c $< -o $@
bait: bait.o $(LEXEROBJS) ../scintilla/bin/scintilla.a
 gcc `pkg-config --libs gtk+-2.0 gthread-2.0` -lstdc++ -DGTK $^ -o $@
clean:
 rm -rf bait *.o

I noticed:

1. How to initialize a scintilla editor
2. How to interact with it. It uses just the SSM macro:  scintilla_send_message function.
3. With the Makefile associated, how to compile and run it.

Once I’ve done this,  I needed a good interface to respond codegen (utility used to wrap gtk widgets, explained in the wrapping tutorial).

It’s time to start wrapping

There was 2 possibilities:

1. Write myself the widget in C.
2. Search the web for someone that have already done this.

I’m really lazy, I searched a lot on the web and I’ve found some alternatives:

• The geany editor: there was some files that wrapped the scintilla interface in a more convenient manner, however it wasn’t well-formatted because they don’t use intensively the C/GObject system.
• The anjuta editor:  They use a well formatted editor widget that wraps scintilla but there were interdependencies related to anjuta.
• The most natural GtkScintilla: someone have done this work long time ago, after some days I noticed that it was a very good starting point.

note: I discovered all this things browsing in the project files, reading headers and source files ( I felt like a true hacker).

I haven’t modified the gtkscintilla.h header and I generated definition files. Next I wrote a simple override file and the initialization module (if you don’t understand this first read the wrapping tutorial).

With no problem I generated the wrapper, cool! (pygtk team have done a great work with codegen, I’m sad they didn’t write any documentation)

Now comes the hard part…

Compiling

Welcome in the hell. Scintilla is distribuited as a static library, scintilla.a but the python module I needed was a shared library. I browsed in a sea of pain, errors, errors and errors, my module wouldn’t compile.

The problem is that you can’t link a static library to a shared library, the compiler tell you that you have to recompile your files with the -fPIC option. I ignored what the compiler told me, and I tried a lot of  dirty ways to make it work, without success…

After about 4 days of depression I was sorry with the wisdom of gcc compiler and I was gone in the scintilla/gtk directory to modify the makefile that compiles the scintilla stuff.

In the original makefile there was the compilation command without the -fPIC option and the command “ar” to make a static library.

The compilation commands:

.cxx.o:
 $(CC) $(CONFIGFLAGS) $(CXXFLAGS) -c $<
.c.o:
 $(CCOMP) $(CONFIGFLAGS) $(CXXFLAGS) -w -c $<

Becomes:

 .cxx.o:
 $(CC) $(CONFIGFLAGS) $(CXXFLAGS) -fPIC -c $<
 .c.o:
 $(CCOMP) $(CONFIGFLAGS) $(CXXFLAGS) -fPIC -w -c $<

And I modified the creation of the library from static (compressed with ar) to shared (compiled with gcc -shared)

Before:

COMPLIB= ../bin/scintilla.a
AR= ar
// other things //

$(COMPLIB): DocumentAccessor.o WindowAccessor.o KeyWords.o StyleContext.o \
 CharClassify.o Decoration.o Document.o PerLine.o CallTip.o \
 ScintillaBase.o ContractionState.o Editor.o ExternalLexer.o PropSet.o PlatGTK.o \
 KeyMap.o LineMarker.o PositionCache.o ScintillaGTK.o CellBuffer.o ViewStyle.o \
 RESearch.o RunStyles.o Style.o Indicator.o AutoComplete.o UniConversion.o XPM.o \
 $(MARSHALLER) $(LEXOBJS)
 $(AR) rc $@ $^

After:

COMPLIB= ../bin/scintilla.so # MODIFIED
AR= ar
// other things //

$(COMPLIB): DocumentAccessor.o WindowAccessor.o KeyWords.o StyleContext.o \
 CharClassify.o Decoration.o Document.o PerLine.o CallTip.o \
 ScintillaBase.o ContractionState.o Editor.o ExternalLexer.o PropSet.o PlatGTK.o \
 KeyMap.o LineMarker.o PositionCache.o ScintillaGTK.o CellBuffer.o ViewStyle.o \
 RESearch.o RunStyles.o Style.o Indicator.o AutoComplete.o UniConversion.o XPM.o \
 $(MARSHALLER) $(LEXOBJS)
 gcc -shared -o $@ $^ # MODIFIED

After recompiling scintilla I obtained my shared library scintilla.so !!! After this I clearly compiled and linked (reference the basics tutorial) my python module and run it without (too much) problems!

I post the pygtkscintilla makefile that compiled and linked the python module:

DEFS=`pkg-config --variable=defsdir pygtk-2.0`
CFLAGS=-I/usr/include/python2.6 `pkg-config --cflags gtk+-2.0 pygtk-2.0 gthread-2.0`  -I. -I..
CXXFLAGS=-DGTK2  
LDFLAGS=`pkg-config --libs gtk+-2.0 pygtk-2.0 pygobject-2.0 gthread-2.0`
LEXEROBJS=$(wildcard ~/workspace/pygtkscintilla/scintilla/gtk/Lex*.o)

all: gtkscintilla-wrap.c gtkscintilla-module.o gtkscintilla.o gtkscintilla.so

gtkscintilla-wrap.c: gtkscintilla.defs gtkscintilla.override
 python /usr/share/pygobject/2.0/codegen/codegen.py \
 --override gtkscintilla.override \
 --prefix gtkscintilla gtkscintilla.defs > $@

# Here's the magic!
gtkscintilla.so: gtkscintilla-wrap.o gtkscintilla.o  gtkscintilla-module.o
 gcc -shared  $(LDFLAGS) -L~/workspace/pygtkscintilla/scintilla/bin -lscintilla  $^ -o $@

gtkscintilla-wrap.o: gtkscintilla-wrap.c
 gcc $(CFLAGS) -fPIC -c $^ -o $@
gtkscintilla.o: gtkscintilla.c
 gcc $(CFLAGS) -fPIC -c $^ -o $@
gtkscintilla-module.o: gtkscintilla-module.c
 gcc  $(CFLAGS) -fPIC -c   $^ -o $@

clean:
 rm -f gtkscintilla.so gtkscintilla-wrap.c gtkscintilla.o gtkscintilla-module.o

Ok I’ve finished telling my story. I hope that my errors can help you!

Just why?

Scintilla is a the powerful text editor widget.  I’s used by a lot of applications, it’s something like this:

Scintilla is for GTK+ but this f*** widget doesn’t follow standards from GTK+/GObject.

In the actual state of things there isn’t a good pygtk IDE/editor written in pygtk (there’s pida but uses embedded editors  like vim and emacs), and I think the reason is that there isn’t a scintilla wrapper. To make a comparison with pyqt there’s the fairly complete eric.

The code source editor for pygtk  is pygtksourceview but this widget hasn’t the code-completion feature and the code folding feauture that in my opinion are fundamental. These features will be implented in near(?) future and I will use it, but I (maybe we) need a powerful editor now.

I want to wrap scintilla for pygtk, it was wrapped sometime ago by Roberto Cavada but it’s outdated  and his mail isn’t reachable.

The current state of things

• found GtkScintilla widget, a well-formatted GObject scintilla distribution. It’s outdated but it’s a good starting point to write another GObject to wrap.
• I generate the wrapper  (cfr Wrapping Gobject) for GtkScintilla but I can’t compile it … frustrating.
• In next days I will test a little the scintilla distribution to focus the design and to learn to compile all the things… I need.

There’s a lot of work to do, it’s very hard, every help is accepted (everyone can partecipate, also without experience. Just tell me in comments or via e-mail).

Wish me good luck!