I am a longtime MS Windows programmer.  I worked with Visual Basic, and V.C++, when they were just started while ago and still using them now but I have MS Visual Studio .net installed and I write program using VB, VC++, C#, and others too.

Now I want to move all my programming development to Linux.  I also been using and playing with Linux for quite long time.  I have moved everything to Ubuntu, my laptop and desktops.  so I am all set using Lynx.  I also started to develop some programs using Mono that is the C# IDE on Linux.  I started writing some programs in C and C++ too.  I used GNU gcc, g++, and I edit with emacs.  then I found the other IDEs like:  Eclipse, Netbeans, Geany, Qt 4 Designer, Anjuta, and finally KDevelop4.

these are great tools for developing C or C++ programs, but, when I wanted to find a good IDE that I can use to develop GUI interfaces, I could not find any yet.  I either found a good IDE that I can design my GUI very well, but it fails to program side,  OR, I found a good IDE that I can connect between the GUI and the Code and it fails in compiling or does not have good tutorials.  I will talk about each in more details…

Before using or even studying about Anjuta , one must know what is IDE (Integrated desktop environment)

An integrated development environment (IDE) also known as integrated design environment or integrated debugging environment is a software application that provides comprehensive facilities to computer programmers for software development. An IDE normally consists of:

• a source code editor
• a compiler and/or an interpreter
• build automation tools
• a debuggerSo now as you have little idea about IDE you can read further about what anjuta is

Anjuta is an integrated development environment for the C and C++ computer programming languages, written for the GNOME project. It comes standard on base installation DVDs of major Linux distributions such as Ubuntu, openSuse, Fedora, and Mandriva (amongst others).

Anjuta features project management, application wizards, an interactive debugger built over gdb, and a powerful source code editor with source browsing, code completion and syntax highlighting.

Distributed under the GNU General Public License, Anjuta is free software.

The goal of Anjuta DevStudio is to provide a customizable and extensible IDE framework and at the same time provide the implementations of common development tools. libanjuta is the framework that realizes the Anjuta IDE plugin framework and Anjuta DevStudio realizes many of the common development plugins.

It integrates new programming tools including the Glade Interface Designer and the Devhelp API help browser.

For more information about this wonderful tool just google it….

]]> http://fl0rian.wordpress.com/2009/06/18/openembedded-and-anjuta/ Thu, 18 Jun 2009 23:38:44 +0000 Florian http://fl0rian.wordpress.com/2009/06/18/openembedded-and-anjuta/

I have always liked the idea to have an Anjuta plugin that simplifies the use of cross toolchains in order to develop for all sorts of mobile and embedded devices. Personally I do not rely on an IDE but I have worked with a lot of developers in the past who are not used to do application development with vi. The same applies to cross toolchains, but there are reasons why people compile natively or why tools like Scratchbox are developed.

Some time ago OpenedHand published an Anjuta plugin for Poky that almost fits these needs – apart from minor lacks and the fact that you can’t use it with an OpenEmbedded build tree because it relies on the Poky directory layout. It didn’t take me long to modify the Poky plugin to fit the needs for OpenEmbedded: I have added automatic detection of the toolchain host prefix and some functionality to deal with the (not 100% fixed) directory layout of OpenEmbedded. So what does it do?

• Select a toolchain or OpenEmbedded build directory to use
• Configure and build a project
• Deploying of binaries to a target device using rsync and ssh
• Some debug and remote device features from the original plugin I didn’t test so far

Anjuta OpenEmbedded SDK Plugin

It is easy to install (and build if necessary). I have created an initial website for it at KC Labs. You can find both source archive and binary packages for Ubuntu (9.04) and Debian Lenny. Once you have it installed it you should be able to design your GUI, fill it with functionality and deploy the application to a target device withouth leaving Anjuta.

Feedback is very welcome – if you have ideas about new features or what you would like to see for cross development please let me know!

Have a nice time…

PS: LinuxTag is approaching – visit the Embeded Area with projects like OpenEmbedded and Coreboot!

Bir önceki yazımda belirttiğim gibi, sizlere Anjuta isimli ide’yi tanıtacağım. Daha sonra, Anjuta’yı kurup basit bir merhaba dünya uygulaması yapacağız.

Anjuta, C ve C++ dilleri için geliştirilmiş güzel bir ide’dir. GNU/Linux üzerinde çalışan bir özgür yazılım projesidir. Anjuta, programcılara bir çok gelişmiş özellikler sunmaktadır. Proje yönetimi, uygulama sihirbazları ve hata ayıklayıcı bu özelliklerden bir kaçı. Ayrıca, kod renklendirme özelliği bulunan güçlü bir editor’e de sahip.

Anjuta Kurulumu:

Linux kullanmaya yeni başladığımdan, gerek kurulumunun basitliği, gerek forum desteği, gerekse de paket genişliği sebebiyle Ubuntu dağıtımını kullanıyorum. Eğer siz de yeniyseniz kesinlikle tavsiye ederim. Ubuntu üzerinde anjuta kurmak gayet basit. Komut satırını açın ve “sudo apt-get install anjuta” yazıp enter’a basın. Gerisini apt-get halledecektir : ) Eğer kullandığınız linux dağıtımında bu paket hazır değilse buradan ilgili dosyayı indirip kaynak koddan kurulum yapabilirsiniz.

Yeni Bir Proje Oluşturmak:

Yeni proje oluşturmak için, Anjuta’yı açın ve menüden Dosya > Yeni > Proje seçeneğini seçin. İlk pencereyi geçtikten sonra, karşınıza aşağıdaki gibi bir pencere gelecek:

C dilinde basit bir uygulama yapacağımız için, sihirbazda C sekmesini seçip Genel (Minik) isimli şablona tıklıyoruz ve ileri tuşuna basıyoruz. Şimdiki pencerede ise, projenin adına HelloWorld yazıp ileri tuşuna tıklayalım. Şimdi karşımıza, projeyi hangi klasörde saklayacağımızı soran bir pencere çıkacak:

Burada, hedef kısmında, önceden oluşturduğum HWorld isimli boş bir klasörü seçtim. Siz de bu şekilde bir klasör açıp seçin. Şimdi ileri tuşuna, ve sonra uygula tuşuna tıkladığımızda projemiz oluşmuş olacak.

İlk (Merhaba Dünya) Uygulamamız:

Proje oluştuktan sonra, karşınıza gelen ekranın sol tarafında projeye ait dosyaları göreceksiniz. Aşağıda da gösterildiği gibi, bu dosyaların içinden main.c isimli dosyaya çift tıklayın:

Evet, şimdi buraya dünyaya merhaba diyen kodumuzu yazabiliriz. Sağ taraftaki editor’e basitçe;

#include<stdio.h>
int main() {
printf("Merhaba Dunya ! \n");
return(0);
}

yazıyoruz ve kaydet’e basıyoruz.

Şimdi sıra geldi, kodumuzu derlemeye. Bunun için menüden İnşa Et (Build) > İnşe Et (Build) seçeneğini seçin ya da F11′e basın. Derleme işlemi tamamlandığında, sol tarafta helloworld isimli dosyayı göreceksiniz. Aşağıda gösterildiği gibi, bu dosyaya çift tıklayın ve karşınıza çıkan pencerede tamam’a basın. Eveeet.. Şimdi yazdığımız küçük programın çalıştığını görebilirsiniz:

Bu yazıda sizlere, basitçe Anjuta’yı tanıtmaya çalıştım. İleride, valgrind eklentisini kullanarak, bellek tüketimini takip eden bir uygulama ile karşınızda olacağım.

1. Bluefish

Es un editor HTML, diseñado para ahorrar algunas tareas a los webmasters con experiencia. Además es uno de los IDEs más populares disponibles para el desarrollo web.. Incluye un editor de múltiples archivos, múltiples barras de herramientas, menús configurables, ventanas de previsualización, soporte para SSI, PHP y validación HTML entre otros. Es ligero y puede abrir hasta 3.500 documentos a la vez

Una de las características más apreciadas de Bluefish es “Quickba”, una barra de herramientas definidas por el usuario que le permite añadir botones haciendo clic derecho y seleccionando “
“añadir rápido”. Allí se puede agregar todo el código HTML a esta barra de herramientas rápidas.

2: Anjuta

Es un entorno de desarrollo para C/C++ que en la actualidad está bastante avanzado. También es un servicio gratuito, de código abierto para el IDE de C y C + + lenguas.
Usa GTK+/GNOME, con lo que se integra perfectamente en este entorno. Es fácil de instalar y ofrece características tales como la gestión de proyectos, un depurador interactivo y un poderoso editor de código fuente (con fuente de la navegación, de código, y el resaltado de sintaxis). El equipo de Anjuta desarrolló este potente IDE de fácil utilización, para satisfacer todas las necesidades de programación en C y C + +. Tiene una interfaz de usuario potente y flexible.

3. Glade

Glade es un RAD (desarrollo rápido de aplicaciones), creador de interfaces gráficas que usa GTK+ para el escritorio GNOME. Guarda los proyectos en XML y puede generar código C para este meta-formato. Adicionalmente. el meta-formato puede ser convertido a otros lenguajes gracias a módulos. Por ejemplo glade– puede generar código C++. Indispensable para desarrolladores de aplicaciones GTK. Incluye una serie de módulos de interfaz, tales como cuadros de texto, etiquetas de diálogo, entradas numéricas, casillas de verificación y menús para el desarrollo de interfaces más rápida. Los diseños de interfaz se archivan en formato XML. Eso permite que los diseños sean fácilmente conectados con herramientas externas. Además es simple de instalar.

4. GCC

GCC es un compilador GNU que funcione para C, C + +, Objective C, Fortran, Java, y Ada. Es una herramienta de línea de comandos pero es muy potente. Muchos han IDEs no son más que herramientas de interfaces para GCC. GCC es en realidad un conjunto de herramientas. Los más utilizados son los compiladores de C y C + + código.

¿Cómo funciona una herramienta de compilación para diferentes idiomas? Simple: Para C, invocar el “gcc” para el mando y el C + +, invocar la “g + +” comando. Dos compiladores de la misma caja de herramientas. Y g + + es un compilador, no sólo un preprocesador. Se basará código objeto desde el código fuente sin necesidad de utilizar un intermediario a la primera construcción de código C de C + +. Esto crea mejor código objeto y le da una mejor información de depuración.

Las siglas GCC significaban GNU C Compiler (Compilador C GNU). En la actualidad, al admitir una colección de compiladores la siglas, han pasado a significar GNU Compiler Collection (Colección de compiladores GNU).

GCC suministra al usuario muchas herramientas de comprobación de errores, integra una eficiente herramienta de depuración y dispone de muchas opciones de optimización de código, basándose en el microprocesador de destino u optimizaciones sobre la compilación de código inteligente.

Otras características importantes a resaltar son: soporte del procesador de Intel Itanium, integración del compilador de Java GCJ, eliminación del codigo muerto utilizando la representación SSA , preprocesador C integrado en los compiladores C, C++ y Objective C; permiso para renombrar el registro, emisión del codigo Assembler x86 utilizando el estilo de sintaxis Intel
Potentes optimizaciones en las llamadas a subrutinas (CALL) optimizando los accesos al STACK (pila del procesador).

5. Kdevelop

El proyecto KDevelop fue iniciado en 1998 para diseñar un entorno de desarrollo integrado, fácil de usar, para C/C++ en Unix. Desde entonces está disponible públicamente bajo licencia GPL, y soporta KDE/Qt, GNOME, C y C++. Es un IDE (Integrated Development Environment, Entorno integrado de desarrollo) para programar en C y C++ en Linux, que utiliza las librerías Qt (trolltech.com, las del escritorio KDE). Está integrado con QtDesigner, el diseñador de interfaces gráficas de Trolltech.
Para utilizar Kdevelop necesita un sistema operativo X11 KDE

Un buen detalle es que la ventana de salida del compilador es coloreada, lo que resulta más fácil ver al instante la diferencia entre los errores, advertencias y mensajes.

6. GDB

Se trata de un programa de depuración para C, C++, Java, Modula-2 y otros muchos lenguajes. Puede ejecutar en GNU/Linux, BSD y la mayoría de los sistemas operativos propietarios. Lo utilizan los desarrolladores de * NIX (y muchos desarrolladores de Windows). Es el depurador GNU. Esta herramienta se emite desde la línea de comandos y le dará una respuesta inmediata de los desarrolladores dentro de otro programa mientras se ejecuta.

¿Qué se puede hacer?  Entre otros, iniciar la aplicación especificando argumentos, interruptores, o de entrada que afectan a su comportamiento; examinar lo que ha ocurrido cuando la aplicación se detiene y realizar cambios en el programa del usuario para ponerlo a prueba sobre la marcha.

7. KompoZer

Editor HTML, del tipo WYSIWYG (Lo Que Ves Es Lo Que Obtienes), es decir, todo aquello que hagas en el editor luego se verá en la página web cuando la publiques.

Se basa en Nvu. Cuenta con el motor Gecko de Mozilla. Incorpora interesantes herramientas de depuración de código, gestión de estilos CSS, validador de HTML, consola Javascript y subida automática a al servidor FTP del usuario.

Aunque está pensado para quienes no dominan lenguaje HTML pero quieren tener su propio espacio en Internet, cuenta también con la opción de editar el código HTML manualmente.

8. Eclipse

Potente y completa plataforma de programación, desarrollo y compilación de elementos tan variados como sitios web, programas en C++, aplicaciones Java, hasta clientes BitTorrent. Es un entorno de desarrollo integrado (IDE), que cuenta con todas las herramientas y funciones necesarias para el trabajo, recogidas además en una atractiva interfaz que lo hace fácil y agradable de usar.

Cuenta con un editor de texto donde ver el contenido del fichero en el que el usuario trabaja. También una lista de tareas y otros módulos similares. Si bien las funciones de Eclipse son más bien de carácter general, los elementos del programa se pueden ampliar y mejorar mediante el uso de plug-ins.

Los últimos cambios de esta herramienta de desarrollo incluyen: nueva interfaz de actualizaciones, nueva pestaña de marcadores, nueva pestaña con avisos de errores y alertas, búsqueda de texto mejorada, mejora en la gestión de proyectos, importar y exportar configuraciones de lanzamiento de aplicaciones y asistente de contenidos renovado. Para su uso es necesario contar con Java Runtime Environment, ya que este multilenguaje está escrito en Java.

9. Make

Es una utilidad para determinar qué piezas más específicas de un programa necesita ser recompilado. Se construye un binario a partir de unas fuentes y un makefile usando un compilador como gcc. Una vez que determina qué bits deben ser recompilados, emite los comandos necesarios para completar la acción. Con Make podemos llevar a cabo una de las cosas más interesantes de Linux: personalizar y armar la arquitectura que aloje nuestro sistema. Así se obtiene más rendimiento al crear los programas optimizados para donde van a ser alojados.

10. Quanta Plus

Magnífico editor HTML ideal para usuarios Linux en entorno KDE, que posee todo lo que un editor HTML puede albergar, en cuanto a opciones se refiere, y además lo combina con una interfaz gráfica y de usuario que hacen mucho más sencillo el manejo del programa en cuestión.

Ofrece un excelente navegador de directorios, que facilita el acceso de una manera fácil e intuitiva a los archivos HTML y gráficos alojados en el disco rígido, carpetas compartidas, periféricos o directamente en Internet. Cuenta también con un completo panel de previsualización y un ágil editor coloreado de tags.

Se puede destacar también, la posibilidad de editar varios ficheros simultáneamente, a la vez que se utiliza el panel inferior para ir visualizando gráficos y los asistentes para la creación de tablas o documentos en blanco.

Dato negativo: no incluye una librería de la librería PHP de BlueFish, pero no se ve agravado gracias a la agilidad que aporta el panel de previsualización.

Los requisitos mínimos para su uso son: KDE 3.5 y QT 3.3.2.

I’ve installed my Ubuntu desktop, ATi driver, got Anjuta, got OpenGL libraries, wrote my first linux program (output dummy text to console – eh, not really the first, but I did write the last one long quite time ago).

In one word: I’m ready to rock!

I made a promise last week to come out with Vimjuta 0.2 over the previous weekend. I hate to say I broke the promise, the best I could come up with was a 0.1.1-ish “release” (it’s on SVN), fixing a very irritating and troublesome reference issue. I spent around 14 straight hours fixing that single issue, chasing my ref counts through Anjuta and fixing several inconsistencies along the way. I couldn’t find the time to fix the problems with the debugger and to re-implement some of the interfaces (mainly the search interfaces, which vim honestly has better functionality in). My new goal is to cut out about an hour every day of this week and work through the weekend (during which I am going home, away from the hectic campus life), and try and come up with a 0.2 release in time for Diwali (huge Indian festival). Wish me luck!

In other matters, I have finally made a small webpage for Vimjuta, hosted on my webserver at: http://arun.chagantys.org/projects/vimjuta/.

TARGET AUDIENCE:HIGH SCHOOL & UNDER GRADUATE COLLEGE STUDENTS

Well in undergraduate college courses we all are taught to write programs in C/C++ etc we all are very happy and enthusiastic about it but little do we know about the stark realities of real word programming !!
the TURBO C++ IDE used in most colleges and homes by students is though easy ( if i may call it so ) to learn doesn’t teach us good project management skills. I know that project management skill like code reuse , splitting the code into many files etc can be done even in this IDE but the point is that it doesn’t enforce it !!

So let me point out a few popular IDEs

(i will not feature CODE::BLOCKS as i myself have not used it fellow developers are welcome to leave comments about the use of CODE::BLOCKS IDE)

that are available to students using linux

( i am a staunch supporter of linux )

1.GEANY

it is a very simple IDE and IDEAL for beginners if you are using UBUNTU you’ll most probably find it in the repositories.

NOTE: it does not have a debugger built in.And has very elementary project management features.

to compile a sample C code

/*————hello world.c————–*/

#include <stdio.h>

int main()

{

printf(“Hello, World !!\n”);

return(0);

}

/*——————————-*/

step 1.click on File->New

step 2.replace all the text with the code given above.

step 3.save the file

step 4.click Build->compile (it should not give any errors)

step 5.click Build->build (it should not give any errors)

step 6.click Build->execute.

Voila !! there you have your output.

Note: incase you are using math.h header file

goto build->set includes & arguments

and change the compile entry to gcc -Wall -c -lm “%f”

and build entry to gcc -Wall -lm “%f”

2.Anjuta

It is a very mature and stable and useful and …. IDE ideal for many practical uses but for now i will explain only how to write and compile a sample C code

1.click on File->New->project

2.forward

3.Project Type select “Generic” under the C tab.

4.give a relevant project name (***without spaces***) and forward

5.destination :select the path of an empty folder.

6.Apply

7.in the files sidebar select “src”->”main.c”

8.you are by default given a sample hello world program

9.click on Build->compile

10.Build->build

11.Build->execute program.

you should be able to see the “Hello world” output in a seperate window

NOTE:in case you are using the math.h header file

in files sidebar select “src”->MakeFile

in that replace the entry on the 86th line

“CPP = gcc -E” with “CPP = gcc -E -lm”

and save the makefile you may need to change the g++

entries if you are using c++ to code.

I am leaving KDEVELOP and NETBEANS for you to practice on.

incase this article of mine has been of any use to you please leave a message.

(you could help me monitarily by taking a survey by clicking the add snippet at the bottom right

when you make an account i will be credited with 1.25USD)

regards and Best of Luck

kunal ghosh

(kunalghosh)

I have been doing some pondering on the best way of alerting users that they have put in invalid data. Typically the method used it to have a message box pop up showing the error but this can get annoying when there is multiple entries that could have invalid data entered.

First off I was thinking of sticking with the message box approach but customize it a bit to show all the areas the user has messed up at once so that they don’t have to click through multiple message boxes. (Inspired by Deluge)

Or in the case where the user has “technically” inputted everything ok but there is something they may not have meant to do they would still have the ability to continue.

This works but it could caues the user to have to do a lot of clicking back, fixing errors, clicking back, fixing errors, etc until it is all resolved. This is where I was thinking it would be nice if the user never had to click a button to know what all was incorrect.

So I thought inline status images could be very helpful.

This way right away the user knows that they inputted an invalid bug, are reminded that they forgot the different author field and know that they have a valid log message.

Then the user could mouse of the image to get what the warning or error is.

One thing I am unsure about is whether or not to prevent the user from having the ability of clicking the OK button until they inputted the correct fields or let the user continue but pop up the typical message box also.

Before I started putting this inline checking into too much of my code I wanted to see if anyone had any suggestions or comments on this.

I will be at the airport and looking for an apartment for some of this week so I will make sure and respond to anyones comments as soon as I can.

Also I think I finally figured out how to allow annonymous comments (atleast I hope).

Thanks in advance for any advice.

Will

Vimjuta 0.1 “Take me to your leader” has released. Hurrah!

Download Here

Features:

• Tags / Symbols Viewer
• Debugger Support
• Stability!

Known Bugs:

• You can’t run more than 1 session at a given time. This is because I’ve been using a DBus session bus instead of creating a peer-to-peer connection. In case the program doesn’t work, kill any ghost gvim processes you have running.

Missing Features:

• AutoComplete: AutoComplete should *technically* work, but I haven’t been able to get it it to work even with the existing editors.
• Search / Selections : The current implementation is a bit buggy, so I’ve commented out the support. At any rate, vim’s search is infinitely better.

Boring Screencast (Redoux!):

I finally managed to get a screencast. I’m still not sure what the problem was, but it isn’t recurrent, so I’m scared. It looks like I have some bugs to fix, sigh. The video shows a Symbol Browser (actually the plugin is called the Symbol Database. It’s some new and awesome SVN dope) and debugging working. At some point in the video, the program counter disappears. I don’t know why this is, but I have found that Anjuta makes a lot of duplicated Mark/Unmark calls which do sometimes overlap. The bug will be fixed shortly.

Installation Instructions:
Unfortunately, the installation process for Vimjuta is a bit of a pain. Until Anjuta releases 2.6 (which will feature James’ Git Plugin), my patches will not be included upstream.

You can always grab the latest version from SVN, and the release is r50. I’ve also hosted a tarball. To use the plugin, you need to have anjuta-svn (which you should get anyway due to sheer awesomeness). Copy the editor-multiple.diff and accels.diff to anjuta/, patch anjuta. Build, and install anjuta, and finally, build and install anjuta-gvim/. Further instructions can be found in the INSTALL folder.

The plugin on first run will install some configuration files at .config/anjuta/gvim/, namely, anjuta.vimrc (to make vim usable), and a “locked_keys” file which contains some keybindings that should never be remapped by anjuta (for example <C-n> or <C-w>).

Also, to have any fun with the plugin (or vim in general), install the awesome MiniBufExplorer (VimScript #159:
http://vim.sourceforge.net/scripts/script.php?script_id=159).

Ramblings:
The past couple of weeks have been crazy. From closing bugs just minutes before the GSoC India meet, to being pulled into doing a ton of work for our college’s Golden Jubliee year, and finally fending off people who want me to do their bidding. But it’s there. Vim has assimilated Anjuta, and it’s only due time before Vim takes over the rest of the world.

I pushed out the “offical” release at approximately 11:59 p.m on Friday, which qualifies this release as an “Independence Day” special, and makes me an inch closer to James Bond. There have been so many changes between the last time I blogged about it and now, I hardly know where to begin.

Currently, the keybindings for vim and anjuta mush into each other a lot. The problem is that I need some Anjuta keybindings (like debugger support), and vim keybindings basically take the whole keyboard. A slightly hackish solution I’ve come up with was to unload all of anjuta’s accelerators, and then load another set especially for “Vimjuta”, and lock some special keys like <C-n> or <C-w> which was previously getting overwritten. This solution works by and large, but it’s an unstable solution, as other plugins can overwrite the key-mappings.

Another problem I faced previously was updating the embedded Vim window. From what I managed to gather, GtkSockets don’t emit signals, nor can you invalidate their rectangles. So when I moved the cursor remotely using DBus, it would not update on the screen, until I sent it some form of event (generally by scrolling the mouse). The vim –remote functions seemed to work, and I deduce the reason being that it updates a “window property” (part of the X11 ICCCM protocol). At this point, I’d like to thank Guido Von Rossum for Python, and Ali Ashafar for PIDA. I managed to find out how to set Vim’s properties properly. Now the symbol database and browser work properly.I have noticed how ready vim is for an IDE. It has over the years accumulated an quite a few IDE specific features, like inserting marks (useful for debugger support), remote file editing, etc. This of course made my life much easier. I also realized that I was wasting a lot of time on really unnecessary gui-fications of vim features (like search) instead of features like Debugger Support that vimmr’s really need. All I had to do was keep track of my debugger marks, and that was enough to bring Debugger support.

I hope that everyone likes the plugin, and I’d love to hear feedback.

https://launchpad.net/anjuta-bazaar/trunk/v0.2.0

This release adds a new experimental revision range selector that allows you to select a revision range from dates and tags as opposed to just revisions. For example Revno1 to March 2008. Or Revno 8 to v0.1.0 (tag). Along with the range selector this release also adds diff support and some bug fixes and UI improvements.

This article if for the people who loves, needs or work in the programming business, some time ago exists a new cool text editor and literally: “focuses on creating
an easy to use interface and features that aid in code development” (Editra site).

For many time i have use vim or drpython for coding and trying -recently- with eclipse and anjuta for the search of a new application which brings me more power, those 2 last apps are very good but have a high load and consumes a lot of resources. Editra is really easy and has a lot of features not included in many text editors, including: memos, version control system (git, bazaar, cvs, svn), auto-complete, auto-suggestion, etc.

Take a look and you will see a great tool for our work, don’t be regret. Soon i will post some small tutorial for plug-in programming for this application, which -by the way- is fully written in python and wxwidgets.

Biasanya, saya menggunakan Dreamweaver di Windows untuk mengerjakan kode-kode client/server side. Ada beberapa hal vital bagi saya pribadi yang ada di Dreamweaver, yaitu code completion, site/project manager, intellisense, dll yang rasanya susah ditemukan di software IDE (Integrated Development Environment) lainnya. Tapi beberapa hari yang lalu Windows yang saya gunakan terserang virus yang memakan hampir 80% resource prosesor dan RAM yang berakhir dengan melambatnya kinerja Windows.

Ini memaksa (bukan terpaksa, sih) saya untuk pindah ke Ubuntu Gutsy (Linux) tersayang (saya punya 2 OS) untuk mengerjakan kode-kode tersebut. IDE yang saya miliki cukup banyak, tapi hampir tidak ada yang memenuhi kebutuhan.

Yang pertama adalah Gedit. Eits tunggu dulu, Gedit yang saya punya bukan lagi Gedit polos bawaan Ubuntu. Gedit yang saya miliki sudah termodifikasi disana-sini dengan themes dan komponen-komponen tambahan, diantaranya adalah: file browser, symbol browser, class browser, color picker, custom theme, dll. Tapi ada beberapa kekurangan seperti tidak adanya intellisense dsb. Dengan sangat terpaksa saya singkirkan Gedit dan mencari IDE lain.

Gedit yang telah dimodifikasi

Pilihan kedua adalah mengemulasikan Dreamweaver di platform Linux, biasanya ini bisa menggunakan emulator seperti Wine atau CrossOver, sayangnya kedua emulator tersebut tidak pernah berhasil menjalankan Dreamweaver di Ubuntu saya. Terpaksa emulator juga harus disingkirkan dan mencari IDE lain.
Pilihan ketiga adalah BlueFish editor. Ini IDE yang cukup komplit, tapi perlu kerja ekstra untuk mendapatkan fitur-fitur yang diincar seperti code completion, intellisense, auto tooltip, dll. Parahnya, secara default BlueFish tidak mendeteksi jenis dokumen untuk kemudian ditampilkan dalam format syntax highlighting yang sesuai. Dan banyak lagi nilai minus yang saya temukan di BlueFish, terpaksa IDE ini juga disingkirkan.

Pilihan selanjutnya adalah Anjuta IDE. Software ini memang cukup komplit, tapi tetap perlu kerja ekstra keras untuk menambahkan komponen dan fitur yang diinginkan. IDE ini juga terpaksa tidak masuk nominasi.

IDE selanjutnya adalah QuantaPlus. IDE ini sudah cukup lengkap dengan dengan berbagai fitur didalamnya, bahkan bisa dibilang menyaingi Dreamweaver dalam beberapa hal. Tapi sayangnya aplikasi ini menggunakan KDE sebagai environmentnya, sementara saya sendiri adalah pemakai setia GNOME, meskipun QuantaPlus tetap bisa berjalan diatas GNOME, tapi theme dan styles-nya masih inherit dari KDE. Saya terpaksa mencari IDE yang lain.

Yang terakhir dan baru dapat, adalah Komodo Edit. IDE ini cukup komplit memenuhi kebutuhan saya seperti project manager, code completion, syntax highlighting yang sangat lengkap, intellisense, code folding, auto tooltip, dan banyak lagi. Software ini juga cukup ringan dan menggunakan GNOME sebagai environmentnya. Adapun nilai minus yang saya temukan sejauh ini adalah:
1. Tidak ada color picker. Bagi saya color picker adalah utility vital ketika kita sedang mengedit file stylesheet seperti CSS.
2. Tidak ada “designer mode”, sehingga kita tidak bisa melihat live-preview dari sebuah file HTML layaknya pada Dreamweaver. (Ini bukan nilai minus karena saya bukan desainer :p)

Screenshot Komodo Edit

Sejauh ini, Komodo Edit-lah yang jadi pilihan saya untuk mengerjakan kode-kode client/server side seperti .js, .php, dll. Software yang free, light, komplit dan sampai sekarang masih terus dikembangkan. Salah satu nilai plus juga adalah software ini yang paling “mirip” environmentnya dengan Dreamweaver jika dibanding dengan software-software lain yang sudah saya sebut diatas (ini pendapat pribadi), jadi rasanya lebih nyaman aja.

Pastinya masih banyak lagi software IDE lainnya yang tersebar di Internet, seperti Zend Studio, dll. Lain waktu akan saya sempatkan lagi melakukan tes perbandingan software-software tersebut

https://launchpad.net/anjuta-bazaar/trunk/v0.1.0/

This is the initial anjuta-bazaar release. The release comes with lots of bugs and missing features. It is meant as a public preview of the project. Any feedback is greatly appreciated. There is a couple requirements needed that the configure file will not correctly alert you on.

• Python 2.5 (default path)
• bzr-xmloutput (bzr branch lp:bzr-xmloutput)

I closed some big bad bugs yesterday, and managed to get a whole workflow (open a bunch of files, edit, save, close) working without any glitchy-ness. Most of the time. And while I’m no where near the quality required to ship this plugin, it feels great all the same.

A phenomenally boring Youtube screencast:

There’s a very apparent bug in the video; it doesn’t change pages when the option is document is chosen from the Documents menu. I’ve already fixed it.

If you liked this plugin, well, unfortunately you’ll have to wait a while. There is a considerable amount of code required to be reviewed and there’s bound to be a lot of back and forth activity between Johannes and me. Hopefully, we can start the review process once Johannes gets back from GUADEC. If you absolutely can’t wait, I do have the patches required for the anjuta svn tree in my svn repo. The instructions are in the INSTALL file.

Getting this to work was quite a hassle because of the odd quirks of some Vim plugins. While a vanilla vim works fine (so far…), a vanilla vim is boring (not to mention not worth using). The objective of this project is to give you all the power of Vim + all the power of Anjuta, with as few compromises as possible.

One of the more frustrating issues I faced was with a plugin called MiniBufExploerer. MiniBufExplorer is a fantastic plugin that lets you look at all open documents at once, and at cycle through them with ease. I’d ideally like to package this with the Vim plugin, but I have to discuss those issues with Johannes first.

For some crazy reason, MiniBufExplorer (MBE) when opened with a single file gets into a position where the contents of the file are displayed with MBE’s buffer number. So lets say I have a file foo.c open (as buffer 2), and MBE occupies buffer 3. foo.c is a normal file (it’s ‘buftype’ is empty), but MBE has a buftype of ‘nofile’. Now if I open another file bar.c (now MBE is displayed) and close it (MBE goes away), it opens foo.c as MBE, i.e. it’s buffer no. is 3 and buftype is ‘nofile’. Utter nonsense. The only work around I found for this was to set the MBE option: g:MiniBufExplorerMoreThanOne=1, which always keeps the MBE open.

I’m really worried with what other plugins might do. Making this plugin robust looks like a very daunting task. Any tips?

P.S. The glade file shown is the Maemo version of Dasher. The only reason I opened it was that it was in my recent documents list.

I’ve been making some progress on my Anjuta-Vim Integration project, infact, I even have screenshots [1]. But that’s very deceptive, notice the (null) ((null)) on the window title. Essentially, I’ve written an AnjutaPlugin that implements the necessary interfaces to “open files”. Currently all my interface implementation functions are returning NULL’s or 0’s (which can cause unpredictable segfaults and  memdumps), and that brings me to the real challenge of my GSoC project.


Talking to Vim / Containing Vim
The biggest problem with embedding Vim as an alternate editor is, as my mentor (not officially, but he’s helped me a lot), Sebastien Granjoux (seb) told me (vimzard):

<vimzard> …especially since i would like vim to send commands to anjuta (like debug, make,etc.)
<seb> I think you don’t need that vim send make or debug command to anjuta.
<seb> The other editor plugins don’t do such thing.
…
<seb> Yes, I have understood but again other editor don’t do it like this. They cannot open a file by themselves.

The other editors being Scintilla and GtkSourceview, both of which are widgets Vim is an full fledged application (Scintilla is just a simple application with a Scintilla widget). There is no libvim, there is no VimWidget (though I wish there was). Vim comes chock full of features, and it’s hard to make sure they don’t mash around existing frameworks. Incidently, I’m also going to have problems with the fact that a single Vim instance opens multiple buffers…

I shudder to think about the issues Emacs would give me (besides pinky injuries).

Back to the problem at hand, I can’t implement those interfaces until I talk to Vim. Unfortunately, Vim does not have DBus bindings, nor does it emit any signals, which makes it hard to deal with.  And this has led me to a very special juncture in my (arguably short) life as a coder.

Hackery Invariance Point: The total hackery of a project is invariant across possible solutions

Point in case,

Problem: Getting Vim and Anjuta talking to each other. Anjuta must issue commands to Vim, vim must reply, and send signals to Anjuta.

Solution #1: Vim –remote[2] : Vim supports a commandline feature that allows you to send queries/commands to a running vim session (which acts like server). This gives you complete freedom to send Vim any key commands you would like to, as well as request for the values of certain expressions.

E.g.:

$> gvim –server-name GVIM;
$> vim –server-name GVIM –remote-send iabcd;
Will first enter insert mode (i), and enter ‘abcd’ into the buffer opened by the
first command.

$> gvim –server-name GVIM –remote-expr “&tabstop”;
Will get the value of the setting “tabstop” of the current vim buffer.

Hackery: You would have to spawn a vim process (albeit a lighter version) every time you wanted to ask it something. And the entire thing is implemented using X11’s window properties, which sounds hacky at first glance (but I found out that it’s normal)[3]. And that solves just half the problem, of talking from Anjuta to Vim.

To send back signals, unfortunatlely, Vim uses a pseudo terminal, where it sends all its stdout output. Therefore, I can’t simply listen on the pipe from which I spawned vim in Anjuta [4]. I couldn’t find a single way to cajol (g)vim to send output to the stdout, neither through command line options, nor through options. Every 1/2 hour, I’d find  some more documentation, but in the end it came to no avail. If anyone has a clue how to do this, please please tell me.

Grand Hackery Masterpiece

To work around this, I was thinking of creating a pipe (thanks to seb), and I’d run :!echo “anjuta:foo_bar” > pipe_no (runs the command in a terminal), and listen on the pipe using GIO.

Solution #1.5: Implement that same X11 code myself, to save myself all the spawning. The rest of it is the same.

Hackery: I’d have to reimplement the code (but with a reduction factor of using of using GDK and Glib), and do all that grand hackery nonsense.

Solution #2: The Netbeans Protocal. A gross misnomer, the netbeans protocol is a manner of communication to a Vim instance using sockets. Yes, this is IPC using sockets. It is sad that in an age of DBus I must choose between pipes and sockets for IPC… The netbeans system looks a bit hacky through and through, but it’s worked successfully for a number of projects already. How can I most pompously say that it’s useless for Anjuta? Well, more than half of the functions under IAnjutaEditor and IAnjutaDocument interfaces that I must implement can’t be done using this very limited protocol. There are a handful of functions that are exposed, and another handful of functions that “are yet to be implemented”. Oddly, vim does not extend the same flexibility it did with the vim –remote through the sockets interface, which is a pity.

Hackery: The whole sockets interface itself. And the loops I’d have to go through to implement 1/10th of the required interface functions.

Solution #3: Spend a week or two and implement DBus bindings for Vim. This has been proposed by someone else as well[5], but I doubt I have the time to take out a week on this. DBus would solve everyone’s problems though.

Hackery: The  thread mentioned [5] says that the main loop is very much obfuscated, and unfriendly to DBus. Besides, touching the Vim source guarantees hackery.

I personally favour (1.5), despite it’s hackery.

Any suggestions / advice ?

References
[1] Screenshots of the VimPlugin
[2] vim –remote
[3 This is part of the X11 ICCCM (Inter Client Communications Convention
Manual). The key function is XChangeProperty. This is wrapped by GDK as well.
[4] The implemenation of my plugin works by plugging in a GVim instance into a
GtkSocket. Vim is extremely friendly here, as it has a command line option
‘–socketid’ which creates GtkPlug using the socket id.
[5] A thread on the Vim ML’s, proposing a DBus interface.