Quando desenvolvendo aplicações móveis para o Android as vezes precisamos obter imagens do dispositivo para comparar com um alguma referencia no computador. Como tirar screenshots no Android? Usar uma aplicação para isso e então passar as imagens para o computador? Não, há um jeito mais fácil.

Juntamente com o Android SDK há uma ferramenta na pasta tools chamada ddms (Dalvik Debug Monitor Server). O ddms ainda está pouco integrado com o plugin ADT do Eclipse e também pouco documentado, mas é extremamente útil para várias tarefas como monitoras o heap de memória, threads, processos e, é claro, tirar screenshots.

Para utiliza-lo com todas suas funcionalidades lembre-se de desligar primeiro o Eclipse (porque no momento só pode ter um aplicativo conectado ao ADB), porém que para fins de captura de tela isso não é necessário. Selecione um dispositivo, vá no menu Devices → Screen Capture (Control-S). Pronto, você tem no computador uma captura da tela do dispositivo.

Today I was programming a toString method for a class widely used in a application, using the very useful String.format that provides a C’s like printf formatter.

@Override
public String toString() {
   return String.format("VO[a: %.1f, b: %.1f, c: %.1f]", a, b, a+b);
}

%.1f means a float with one digit precision after the dot separator. The code produces something like:

VO[a: 1.0, b: 2.0, c: 3.0]

The problem arises when running a JUnit test on this method wrote using a regular expression to extract the values from the String to test it correctness. We cannot assume that the dot will be always the separator for displaying a float value, in my locale pt_BR would be a comma. So the output would be:

VO[a: 1,0, b: 2,0, c: 3,0]

For a predictable output we can set a Locale for String.format:

Locale en = new Locale("en");
return String.format(en, "VO[a: %.1f, b: %.1f, c: %.1f]", a, b, a+b);

So it will always use the dot as common separator. Of course you should follow and respect the localization and internationalization efforts in others moments but in this toString case we are using it internally for debug and unitary testing so we can set a English default locale for safety reasons.

Inkscape is a Open Source vector graphics editor that works with SVG (Scalable Vector Graphics) format, Inkscape works with transparency, gradients, node editing, pattern fills, PNG export, and more. It also runs on Linux, Windows and OSX, those three are officially supported, but also runs in a broad list of Operational Systems. Is a software that I work daily and frequently is featured here in my blog.

You can download Inkscape or directly install it via some package system like Apt:

sudo apt-get install inskcape

But sometimes we need some special feature that is not available yet in the repositories or we want gain speed by having special binaries for our platforms or we want to help developing a new feature. In those cases we need to compile the software by ourself.

Those tips are valid for Ubuntu 8.04 but some part of them can be applied in others distributions. The Inkscape compiled here is the version 0.46+devel so newest versions can have compiling procedures slightly different.

Getting sources via APT.The easiest way to compile Inkscape on Ubuntu is

sudo su
apt-get build-dep inkscape
apt-get source inkscape
cd inkscape
./autogen.sh
./configure
make
make install

This will get a version of inkscape, compile it and install. If the first step doesn’t work well, you can try install all necessary packages by yourself using:

sudo apt-get install autotools-dev fakeroot dh-make build-essential autoconf automake intltool libglib2.0-dev libpng12-dev libgc-dev libfreetype6-dev liblcms1-dev libgtkmm-2.4-dev libxslt1-dev libboost-dev libpopt-dev libgsl0ldbl libgsl0-dev libgsl0-dbg libgnome-vfsmm-2.6-dev libssl-dev libmagick++9-dev libwpg-dev

Getting sources via SVN. The recipe I showed above will compile a stable version of Inkscape but not the last version of Inkscape. For that we need to grab the source directly from the Subversion repositories and so compile it.

At your home folder:

sudo apt-get install subversion
svn checkout https://inkscape.svn.sourceforge.net/svnroot/inkscape/inkscape/trunk inkscape

A alternative way to subversion is getting sources from here. Those are tarballs built every hour after someone change something in the development repositories. Download a tarball, and decompress it on your home folder.

Install all tools we need to compile Inkscape, this should fits:

sudo apt-get install autotools-dev fakeroot dh-make build-essential autoconf automake intltool libglib2.0-dev libpng12-dev libgc-dev libfreetype6-dev liblcms1-dev libgtkmm-2.4-dev libxslt1-dev libboost-dev libpopt-dev libgsl0ldbl libgsl0-dev libgsl0-dbg libgnome-vfsmm-2.6-dev libssl-dev libmagick++9-dev libwpg-dev

Enter in the directory with the Inkscape source and do:

./autogen.sh
mkdir build
cd build
../configure
make
sudo make install

In both cases, grabbing sources via svn or via apt, or can set the place where the software will be installed so it not cause conflicts with you already installed version of Inkscape. You can do that replacing the ./configure step with something like:

./configure –prefix=/home/yourname/inkscape

If you had some trouble in one of those steps, consider reading some of those other tutorials:

• http://www.inkscape.org/wiki/index.php/CompilingInkscape
• http://www.inkscape.org/wiki/index.php/CompilingUbuntu
• https://help.ubuntu.com/community/CompilingEasyHowTo

ps: thanks guys from the inkscape-devel@lists.sourceforge.net specially heathenx.

Netbeans have a modular architecture that permits plug and unplug functionalities easily using the Plugin Manager.

It’s also easy create new plugins using Netbeans itself.http://silveiraneto.net/wp-admin/media-upload.php?post_id=705&TB_iframe=true

1º Step: A new module.

Create a New Project clicking in File → New Project.

Figure 1. Creating a new project

In Categories select Netbeans Module and in Projects select Module.

Figure 2. Creating a new module.

Click in Next.

In the next screen you can choose your module name, like HelloYou. Leave the rest with the default values.

Figure 3. Naming the module.

Now you have to set up the package base name, something like org.yourorg.helloyou.

Figure 4. Package name.

Now you have an empty module, but we need some action.

2º Step: Some action.

Right click in your source package and click in New → Action.

Figure 5. Adding some action.

Now we’ll fill another wizard. The first screen is about Action Type. Leave all with the default values (the Always Enabled option) and click Next.

Figure 6. Filling the Action Type.

In the GUI Registration screen we can set where we want our action appears as an menu item. We chose Menu file and select Global Toolbar Button. In Toolbar select Build and in Position select Profile Main Project…- HERE. Click Next.

Figure 7. GUI Registration.

Now we will set up the screen Name, Icon and Location. In Class Name we choose HelloAction. Display Name is how the class will appear in the menu, so we can spaces. You should select an icon in dimensions of 16×16. In the same directory you can put to an icon in 24×24. If your 16×16 icon is named ball.png your 24×24 icon should be ball24.png. Doesn’t matter where is this icon, it’ll be automatically copied to the module directory. Now click Finish.

Figure 8. Name, Icon and Location.

I used an smile icon from the Pidgin Project.

After clicked in Finish your project will look like that:

Figure 9. Empty action.

At this point we can already test our module! For doing that right click in HelloYou (puzzle icon) and select Install/Reload in Target Platform. This will open a new instance of Netbeans with your module installed!

Figure 10. Install/Reload in target platform.

If everything goes alright you will see your icon in the toolbar.

Figure 11. Look! We got an plugin!

But if you click in the smile nothing happens. We have defined no action at all.

3º Step: Creating dependencies.

A module can have dependencies from others modules. When you try to install it, Netbeans will ask about install their modules dependencies. Is much like an Linux package system.

We can see and set up the dependencies in our module properties screen. You can right click HelloYou and go in Properties. Another way to do the same is going in File → “HelloYou” Properties.

Figure 12. File → “HelloYou” Properties.

In the Project Properties screen select Libraries in the left side, Categories. There are listed the Java, Netbeans and all Module Dependencies of your module. By default you’ll see Utilities API module dependence.

Figure 13. Module Dependences.

Click in the button Add (that one near the module dependencies). You’ll see the Add Module Dependency screen where are listed all Netbeans modules.

Figure 14. Add Modules Dependency

We want add an dependency for the Dialogs API. Type “dialogs” in the filter text field.

Figure 15. Dialogs API.

Select the module Dialogs API and click OK. Now our module have two dependencies: Utilities API and Dialogs API.

Figure 16. Dialogs API and Utilities API.

Now for the first time, let’s right some code.

In HelloAction.java file there’s a class HelloAction that extends CallableSystemAction (an abstract class). In the method performAction() there’s nothing but:

//TODO implement action body

We will rewrite the performAction method:

public void performAction() {
   String msg = "Hello Netbeans World!";
   int msgType = NotifyDescriptor.INFORMATION_MESSAGE;
   NotifyDescriptor d = new NotifyDescriptor.Message(msg, msgType);
   DialogDisplayer.getDefault().notify(d);
}

You will see some warnings (cannot find symbol). Just fix the imports (Ctrl+Shift+I). To test your module, do it again: HelloYou → Install/Reload in Target Platform. A new instance of Netbeans will open and you’ll see our smile face button again. When you click it, Netbeans will show an dialog.

Figure 17. Hello Netbeans World.

Let’s do more. Let’s talk with the user using NotifyDescriptor.InputLine. Will create an input line dialog, get the user name (if he clicks in Ok) and display a message to him.

public void performAction() {
    NotifyDescriptor.InputLine question;
    question = new NotifyDescriptor.InputLine("Name:",
        "What's your name?",
        NotifyDescriptor.OK_CANCEL_OPTION,
        NotifyDescriptor.QUESTION_MESSAGE);
 
    if (DialogDisplayer.getDefault().notify(question) == NotifyDescriptor.OK_OPTION) {
         String msg = "Hello "+question.getInputText()+"!";
         int msgType = NotifyDescriptor.INFORMATION_MESSAGE;
         NotifyDescriptor d = new NotifyDescriptor.Message(msg, msgType);
         DialogDisplayer.getDefault().notify(d);
     }
}

Again, HelloYou → Install/Reload in Target Platform.

After the new Netbeans instance opens, click in our smile face.

That’s it. You made your Netbeans plugin!

Learn more about Netbeans Module Development:

• Introduction to NetBeans Module Development Tutorial – A tutorial I based to make this one.
• NetBeans Modules and Rich-Client Applications Learning Trail – All resources you need to learn more about Netbeans Platform. Lot’s of tutorials.
• Netbeans Plugin Portal – You can download and also make a NBM file to share your plugins with the community.
• Rich Client Programming: Plugging into the NetBeans Platform – Tim Boudreau, Jaroslav Tulach and Geertjan Wielenga wrote the best book about Netbeans platform. I’m reading it.
• Netbeans Developer FAQ – An big FAQ for person writing NetBeans extension modules (plug-ins), or applications based on the NetBeans platform.

added in 02.27.08: now this tutorial is also available in the Netbeans Wiki.