Last Tuesday, we presented Mono Accessibility 2.1. We worked really hard on this release. Our main goals were, among other things, to improve our UI Automation Client API implementation, polish the interaction with at-spi2, better Moonlight accessibility and to handle custom and client-side providers. The great work made by all the contributors was the reason this release accomplished those goals.

What happened since last time?

Explaining this release is kind of hard if you are not involved in Mono Accessibility, and even more difficult if you’re not involved in Accessibility at all. However, if you’re familiar with Mono and .NET you are, also, aware of the possibility of developing .NET-based applications that run on both platforms with minor* changes or no changes at all. But, before the implementation of Mono Accessibility, there was something missing: all those applications were not accessible.

This meant two things. First Atk-based Assistive Technologies (ATs) were not able to access Windows Forms nor Silverlight applications. Second .NET-based ATs using UI Automation were not able to run on Mono. Making them useless for people requiring Accessibility to interact with software running Mono on Linux**.

After the implementation of Mono Accessibility, we have:

• UI Automation API Framework
• Bridge between UI Automation and ATK

This way ATs using either Accessibility Technology, Atk or UI Automation, will be able to interact with Gtk+, Windows Forms and Silverlight applications, with no changes at all.

This is what happened

In the following video: (if you are using a RSS reader click this link) gcalctool is launched and an application, using UI Automation Client API, interacts with it, clicking buttons “2″, “+”, “3″ and “=”.

Then UIA Explorer, a .NET- based application using UI Automation Client API, also interacts with gcalctool, if you pay attention you will notice that UIA Explorer also lists all other Gtk+ based applications, such as Nautilus and the GNOME Panel.

Finally Mozilla Firefox is executed (both Novell Moonlight with Accessibility Support and Novell Moonlight Accessibility Extensions plugins were installed prior running it) and an Atk-based Accessility Debugger, Accerciser, is launched to interact with the Moonlight application.

The source code used to test GCalctool is the following:

// gmcs -pkg:mono-uia gcalc.cs && mono gcalc.exe

using System;
using System.Linq;
using System.Windows.Automation;

namespace Mono.A11y.Examples {
	public class GCalc {
		public static void Main (string []args)
		{
			AndCondition cond
				= new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
				                                            ControlType.Window),
				                    new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Calculator"));
			var gcalc = AutomationElement.RootElement.FindFirst (TreeScope.Children, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Add"));
			var addButton = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Numeric 2"));
			var Button2 = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Numeric 3"));
			var Button3 = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Calculate result"));
			var calcButton = gcalc.FindFirst (TreeScope.Descendants, cond);

			cond = new AndCondition (new PropertyCondition (AutomationElementIdentifiers.ControlTypeProperty,
			                                                 ControlType.Button),
			                         new PropertyCondition (AutomationElementIdentifiers.NameProperty, "Calculate result"));
			var resultText = gcalc.FindFirst (TreeScope.Descendants, cond);

			// Clicking buttons
			InvokePattern addInvoke = (InvokePattern) addButton.GetCurrentPattern (InvokePattern.Pattern);
			InvokePattern Invoke2 = (InvokePattern) Button2.GetCurrentPattern (InvokePattern.Pattern);
			InvokePattern Invoke3 = (InvokePattern) Button3.GetCurrentPattern (InvokePattern.Pattern);
			InvokePattern calcInvoke = (InvokePattern) calcButton.GetCurrentPattern (InvokePattern.Pattern);

			System.Console.WriteLine ("Pressing \"2\"");
			System.Threading.Thread.Sleep (500);
			Invoke2.Invoke ();

			System.Console.WriteLine ("Pressing \"+\"");
			System.Threading.Thread.Sleep (500);
			addInvoke.Invoke ();

			System.Console.WriteLine ("Pressing \"3\"");
			System.Threading.Thread.Sleep (500);
			Invoke3.Invoke ();

			System.Console.WriteLine ("Pressing \"=\"");
			System.Threading.Thread.Sleep (500);
			calcInvoke.Invoke ();
		}
	}
}

Where do I get it?

If you installed Mono Accessibility 2.0 an option to upgrade should be available now, if not Mono Accessibility is available for a variety of Linux distributions, including:

• openSUSE 11.2 1-Click Install
• Ubuntu Karmic Koala Package Archive on Launchpad
• Fedora 12 openSUSE Build Service

Moonlight applications require the following extra steps:

• Install the updated xulrunner package from the above repositories. (Required until patch on bug #480317) gets approved.
• Install Novell Moonlight with Accessibility Support for 32 bit or 64 bit.
• Install Novell Moonlight Accessibility Extensions

Have fun and if you find any bug with this release, please file it. If you want to contribute or need specific assistance, please join our mailing list, or drop in #mono-a11y on irc.gimp.org.

* Of course this depends on what APIs you are using. If you want to know how compatible is your application try MoMA.
** Notice however, even though Mono is muti platform and UI Automation is included in both Mono and Silverlight, in order to allow other ATs running on other platforms, different than Linux, you will require to implement an specific bridge to talk to you OS Accessibility Layer.

Hackweek is an excellent opportunity to try something new. Hackweek V was not the exception. From June 7th to June 11th I joined a fantastic group of hackers to implement YaSTroid, our Android Front-end to WebYaST.

The week was fun. Learning new stuff, in this case Android, always helps me to see things different and somehow makes me appreciate other development platforms. Recalling Java was not that difficult. Honestly I thought Java had something new to offer to all developers, but it seems that Java hasn’t changed dramatically in years.

WebYaST and YaSTroid

WebYaST is an open source project which goal is to provide a web front-end for YaST functionality to enable remote 1:1 management. The interaction is basically like this (see the detailed diagram to get more information):

WebYaST and YaSTroid communicate using the REST API. If you have installed WebYaST you can access the documentation locally using:

http://localhost/restdoc

This website should show you a list of available methods and their arguments, if any, and examples showing you how to use them and the data returned. Pretty straightforward. Is also good idea to read the source code in case the documentation is missing. Everything is written in Ruby, so it should really simple to read.

Getting YaSTroid

Developing YaSTroid requires having Eclipse and Android installed. After that clone the repository. Make sure you are using Android 1.5 when defining your virtual device.

git clone git@gitorious.org:opensuse/yastroid.git

Result

Stephen and Scott recorded a video demoing the application using a real device, I recommend watching it full-screen to see all details:

If you can’t see the embedded video follow this link.

Usefull links

• YaSTroid by Stephen Shaw
• YaST – openSUSE

While reading The Ruby Programming Language I wrote a couple of notes about the language comparing it to C#. This is the first post of the series talking about those notes.

C# and Ruby share a similar syntax to compare equality in objects. Both use the operator equals (==) and, at least, one method to compare. Ruby uses equal? and eql?, C# uses Equals. Also, both support overriding the equals (==) operator to provide a different logic in case that’s required. The methods’ name are different but they work pretty much the same.

Understanding the difference between both languages is really simple. If you already know the difference between reference types and values types you are pretty much all set.

Ruby

Method equal?

Method used to test reference equality in two objects. For example:

#!/usr/bin/env ruby

a = 0
b = 0.0
c = b
d = e = 0

# "false" pointer c points to b, and b and a
# are different types.w
puts "c.equal?(a) #{c.equal?(a)}"
# "false" b and a are different types
puts "b.equal?(a) #{b.equal?(a)}"
# "true" Same type, same value.
puts "d.equal?(e) #{d.equal?(e)}"

Method eql?

Synonym of equal?, not strict type conversion. Notice Hash classes uses this method for creating the hash, so if two values are the same the hash method should return the same value.

#!/usr/bin/env ruby

a = 0
b = 0.0
c = b
d = e = 0

# "false" Pointer c points to b, and b and a are different types
puts "c.eql?(a) #{c.eql?(a)}"
# "false" Different types
puts "b.eql?(a) #{b.eql?(a)}"
# "true" Same type, same value.
puts "d.eql?(e) #{d.eql?(e)}"

Operator equals (==)

By default, in Object class, it’s a synonym of equal?. Tests reference equality.

#!/usr/bin/env ruby

a = 0
b = 0.0
c = b
d = e = 0

# "true" Even when pointer c points to b, and b and a
# are different types, the value is the same
puts "c == a #{c == a}"
# "true" Type is casted to allow comparing them
puts "b == a #{b == a}"
# "true" Same type, same value.
puts "d == e #{d == e}"

C#

Before explaining the equality options, notice one important difference between Ruby and C#.

First, Ruby is a dynamic typed language. When declaring variables there’s no meaning of variable type, all variables can be used to identify instances of different types depending on the situation. For example, we can define a variable x to act as a string, and then use the same variable x to act as an integer, this doesn’t mean we are converting the string to integer, this means we are using the same pointer (variable x) for two different types, string and integer, pointing to two different addresses in memory. For example:

#!/usr/bin/env ruby

a = "I'm string"
# Output: "a Value: 'I'm string' Class: 'String'"
puts "a Value: '#{a}' Class: '#{a.class}'"

# Output: "a Value: '10.0' Class: 'Float'"
a = 10.0
puts "a Value: '#{a}' Class: '#{a.class}'"

C# is a static typed language, all variables must indicate their type before instantiating an object. For example, when declaring a variable x of type string, you will be able to create an instance of string, only, there’s no way to “reuse” x as an integer in the same scope. Try to compile the following example, it will fail:

public class RubyAndCSharp {

	public static void Main (string []args) {
		string x = "I'm string";
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());

		x = 10.0; // It will fail here: "error CS0029: Cannot implicitly convert type `double' to `string'"
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());
	}
}

Second, memory management. Both languages manage memory automatically: by default all memory is created and released automatically, there is no need to explicitly release or allocate memory, unless the programmer wants to do so. However, in C# there’s a “difference” between types. There are two type categories: Value Type and Reference Type. The difference, related to memory use, is the way they work and the addresses in memory they use. Declaring value types automatically allocates memory, declaring reference types declares a pointer and the memory is allocated when the object pointed by the variable is instantiated. The Value Types are allocated in the stack and the Reference Types are allocated in the heap.

This difference is really important. Comparing two instances of objects with different “category”, one value type and one reference type, does not work, it just fails. Is like comparing an apple to an orange. Is comparing a value stored in the stack to a value stored in the heap. We can’t compare them without writing any extra code.

And this extra code means using the base class object as the pointer for different types, because both types, value type and reference type, are subclasses of object, in one way or another. Let’s try to compile the following example:

public class RubyAndCSharp {

	public static void Main (string []args) {
		object x = "I'm string";
		// Output: "a Value: 'I'm string' Class: 'System.String'"
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());

		x = 10.0;
		// Output: "a Value: '10' Class: 'System.Double'"
		System.Console.WriteLine ("a Value: '{0}' Class: '{1}'", x, x.GetType ());
	}
}

After this short (or long?) explanation we are ready to see talk about the methods.

Method Object.Equals()

Is used to test reference equality in reference types and bitwise equality in value types. For example:

public class RubyAndCSharp {

	class MyClass {
		public string Name { get; set; }
		public override string ToString () { return Name; }
	}

	public static void Main (string []args) {
		// object.Equals in Reference Types uses address memory
		MyClass myClass0 = new MyClass () { Name = "test" };
		MyClass myClass1 = myClass0;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, object.Equals (myClass0, myClass1));

		// Let's try again. This will return false. myClass1 and myClass2 are different instances
		myClass1 = new MyClass () { Name = "test" };

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, object.Equals (myClass0, myClass1));

		// It doesn't matter myInt0 and myInt1 are different variables, equality will be true.
		int myInt0 = 1;
		int myInt1 = 1;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myInt0, myInt1, object.Equals (myInt0, myInt1));
	}
}

Operator equals (==)

Is, basically, a synonym of object.Equals, same rules apply.

public class RubyAndCSharp {

	class MyClass {
		public string Name { get; set; }
		public override string ToString () { return Name; }
	}

	public static void Main (string []args) {
		// == in Reference Types uses address memory
		MyClass myClass0 = new MyClass () { Name = "test" };
		MyClass myClass1 = myClass0;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, myClass0 == myClass1);

		// Let's try again. This will return false. myClass1 and myClass2 are different instances
		myClass1 = new MyClass () { Name = "test" };

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, myClass0 == myClass1);

		// It doesn't matter myInt0 and myInt1 are different variables
		int myInt0 = 1;
		int myInt1 = 1;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myInt0, myInt1, myInt0 == myInt1);
	}
}

Operator Object.ReferenceEquals()

Pretty straightforward, tests reference:

public class RubyAndCSharp {

	class MyClass {
		public string Name { get; set; }
		public override string ToString () { return Name; }
	}

	public static void Main (string []args) {
		// Object.ReferenceEquals in Reference Types uses address memory
		MyClass myClass0 = new MyClass () { Name = "test" };
		MyClass myClass1 = myClass0;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, System.Object.ReferenceEquals (myClass0, myClass1));

		// Let's try again. This will return false. myClass1 and myClass2 are different instances
		myClass1 = new MyClass () { Name = "test" };

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myClass0, myClass1, System.Object.ReferenceEquals (myClass0, myClass1));

		// This will also return false.
		int myInt0 = 1;
		int myInt1 = 1;

		System.Console.WriteLine ("object.Equals('{0}','{1}') = {2}", myInt0, myInt1, System.Object.ReferenceEquals (myInt0, myInt1));
	}
}

Colophon

Sometimes you will have to use an object reference to refer to both types, value and reference, if you are planning to compare their value you have to use the static method object.Equals(a,b). Using the operator equals (==) will always return false, because of the boxing/unboxing:

public class RubyAndCSharp {

	public static void Main (string []args) {
		string str0 = "hola";
		string str1 = "hola";

		object obj0 = str0;
		object obj1 = str1;

		System.Console.WriteLine ("Equals: {0}, Using ==: {1}, object.Equals {2}",
		                          obj0.Equals (obj1), // True
		                          obj0 == obj1, // True
		                          object.Equals (obj0, obj1)); // True

		bool bool0 = true;
		bool bool1 = true;

		obj0 = bool0;
		obj1 = bool1;

		System.Console.WriteLine ("Equals: {0}, ==: {1}, object.Equals {2}",
		                          obj0.Equals (obj1), // True
		                          obj0 == obj1, // False
		                          object.Equals (obj0, obj1)); // True

	}
}

Updated 2010-03-17: Thanks to sukru for noticing the error in the examples.

Updated 2010-03-18: Fixed typos, thanks to yoeri and doza noticing them.

An important milestone happened on Friday, February 26: Mono Accessibility 2.0 was released. It’s important because all applications running on Moonlight 2.0, or greater, will be accessible from now on.

Accessibility?

If you are not familiar with this word, Accessibility, it might mean nothing to you and, probably, you will need a more formal definition:

“Accessibility is a general term used to describe the degree to which a product, device, service, or environment is accessible by as many people as possible. Accessibility can be viewed as the ability to access and possible benefit of some system or entity. Accessibility is often used to focus on people with disabilities and their right of access to entities, often through use of assistive technology.” Wikipedia

You have interacted with Accessibility in real life, even if this is your first time reading this word. Have you seen those tiny bumps on the floor when taking the subway? Wheelchairs ramps or the dots on elevator buttons? Have you heard that noise, like beeping, when crossing the street? Have you noticed the audio jack in some ATMs?

These are real life examples of Accessibility. Accessibility in software is similar, it’s basically the degree of interaction between your software and people with temporal or permanent disabilities. People who can only use the keyboard or the mouse, people with low vision, blind people or people with hearing disabilities. All of them will be able to interact and use your application only if it’s accessible. That’s why Accessibility is important.

Accessibility and Moonlight

Microsoft Silverlight is web application framework for building media experiences and rich interactive applications for the Web. Moonlight is an open source implementation of Silverlight. Besides providing a rich experience for the web, applications running on Moonlight are now available for people with disabilities, allowing them to interact and use these applications. The interaction between these new applications and existent Accessibility Technologies (ATs), such as screen readers, is the same. All existent ATs are reused, it’s like interacting with any other desktop application. ATs in GNOME should work right now without any change and, if any change is required, it will help to provide a better integration with this framework.

Implementation

Refer to Accessibility Architecture for a detailed explanation of the complete architecture.

In both Accessibility implementations, Silverlight and Moonlight, Microsoft UI Automation is used for interacting and exposing data of UI elements of the application. These data are used by ATs to access and manipulate those UI elements. Properties such as visibility, sensitivity or interaction, are exposed by Automation Peers (also known as Automation Providers), along with Automation Patterns to indicate the type of interaction in the control, for example: accepting selection or allowing clicking. There’s always a relation one to one, one Automation Peer and one Control. The properties are available to ATs through the information exposed by the UIA/Atk Bridge module. This module is loaded by the Moonlight application to interact with ATs. It keeps a tree of Atk objects to represent every UI Automation element in the Moonlight application.

The interaction between ATs and Moonlight applications is like this:

1. An AT requests information about the Moonlight control in Firefox.
2. Firefox asks Moonlight this information.
3. Moonlight uses the A11yHelper to load the UIA/Atk bridge module and returns the root accessible, it represents the control’s Automation Peer: WindowAutomationPeer.
4. From now on, new AutomationPeers will be mapped, one-to-one, to an Atk.Object. All data requested by an AT will be accessed through the associated Atk.Object, and this one will return information contained in the AutomationPeer.

If you are curious you can checkout the sources to see the final implementation:

• Moonlight: important bits located in class/System.Windows/System.Windows.Automation.Peers/ and class/System.Windows/Mono/A11yHelper.cs.
• Moonlight UIA/Atk Bridge: implementation located in MoonAtkBridge/.

How do I install it?

Before installing, make sure Assistive Technologies is enabled, then add the Mono UIA repository (see Downloading) and follow the instructions (taken from Installing):

1. Install the updated xulrunner package from the above repositories. (This is required until Firefox 3.7 because of bug #480317)
2. Install Novell Moonlight with Accessibility Support for 32 bit or 64 bit.
3. Install Novell Moonlight Accessibility Extensions
4. Restart Firefox
5. Enjoy!

Useful links

• Accessibility. Windows Developer Center
• Silverlight: Accessibility Overview
• GNOME Accessibility
• Mono Accessibility 2.0 unleashed!

Yes! Your favorite task management application is back. Tasque v0.1.9 was released today!. New features include:

• Support for Mono >= 2.6
• Customizable color highlighting in tasks.
• Hiveminder improvements
• New translations
• And more!

See the announce email to get more information.

Get it while it’s hot!

Screenshots?

More here!

Where to get?

• Main Downloads page
• Sources
• Mac OS X binaries
• MS Windows binaries

More information?

• Wiki
• FAQs

By Claire L. Evans / CC BY-ND 2.0

This is an updated version of Multiple Parallel Mono Environments.

What is Pulque?

Pulque is a collection of applications written in Ruby and Bash scripting to maintain parallel development environments.

Why does Pulque exist?

Three reasons:

1. I need to keep multiple versions installed of the same software,
2. I need to know what Version Control System is used by the software, and the most important
3. I want to keep myself sane.

At work, I have to interact with different open source projects, most of them use Subversion and Git, but some others use Bazaar and Mercurial. Keeping track of the current parallel development environment and the VCS used by the software is exhausting.

You spend time focusing on something that shouldn’t be that important:

• Managing your parallel environments and,
• Keeping track of the VCS used by the software

Is easy to get confused when interacting with the repository, for example, executing svn update when the software is stored in a git repository. Is silly, but it happens. Unless you are using an IDE that support Multiple Parallel Development Environments you will need the terminal to configure and build your projects.

Pulque helps you maintaining parallel development environments by:

• Printing in the bash prompt the name of the parallel development environment and the type of the VCS, this information is updated depending on the working directory,
• Defining aliases to the default commands used to configure and build the software project, to always prefix your projects using your parallel environment, and
• Showing a failure or success alert when the command finishes.

Installing and using Pulque

Follow the instructions in INSTALL, or if you are using openSUSE 11.2:

Click here to drink Pulque!

Don’t forget to add the function pswitch to your .bashrc. Bash will autocomplete your environment name when using TAB TAB.

function pswitch {
  source /usr/bin/__pswitch $1
}

Read the USING file to understand how to use Pulque in the daily basis. If you find something weird or interesting please create an issue to fix it.

Colophon

According to Wikipedia: “Pulque, or octli, is a milk-colored, somewhat viscous alcoholic beverage made from the fermented sap of the maguey plant, and is a traditional native beverage of Mexico.“

A couple of days ago I finished reading: The Ruby Programming Language, book written by David Flanagan and Yukihiro Matsumoto. If I have to say anything about the book and, the language, of course, is: I am impressed. The syntax is pretty for writing and simple for reading. Its simplicity makes you understand the code, is like visualizing the goal of the program in your mind by reading it, not running it. It is like reading a well written letter. You just understand.

I must say, when I was reading the book, at the beginning. I did not feel comfortable with the weird, at that time, syntax. Method decorations such as “!” and “?”, and the support for methods aliases made no sense. Actually I thought I was wasting my time by trying to learn the language. I was wrong.

When I learned C++ several years ago, I did not have reference to object orientation or any object-oriented programming language. Learning it was difficult, but, at the same time, easy. Difficult because I did not know the paradigm, easy because it was my first time learning that kind of syntax. After learning C++ I decided to learn Java and after that, I decided to learn C#.

And I learned them all the same way. I “translated” the syntax. Translated it from the “new language” to the “old language”. I did learn them all. And I thought, for long time, that the rule was: “Learn all the languages the same way: by translation”. I was wrong. Again.

Learning a new programming language, in my opinion, is better when you do not translate the new language. Similar to learn to speak a new language. In both cases, you have to think in the language. I decided to think in the new language. To do it that way. The Ruby way. The results were amazing. Were so amazing that inspired me to write a project in Ruby. I wanted to try out the syntax, the platform and the community. To see if the language was that good as I thought.

After trying it out. No disappointments at all. Actually is interesting that C# and Ruby share a lot of things, syntactically speaking. Both of them are pretty languages. Probably they do not share goals. However, I’m sure they share one goal: to make the life of the software developer easier. And, to a software developer, a programming language, and everything around it, that makes your life easier is what matters the most.

I decided to try something different this Hackweek to learn a programming language and get involved into another exciting software libre project. There were too many options, too many good projects to work on. I selected gwibber because of three reasons:

1. gwibber supports several microblogging services, including my favorites: Twitter and Facebook.
2. gwibber is written in Python.
3. gwibber doesn’t integrate with other gnome applications, for example Cheese or Nautilus.

So… what’s the new cool feature?

Something I like to call “Sharing Services”. What’s a sharing service? A sharing service is a service using an online provider to share data, easier impossible. For example: Images would be shared using Twitpic, Videos would use yfrog, Files would use Drop.io and Plaint Text files would use Pastebin (this is configurable, in case you were wondering) I’m sure you got the idea.

Technical approach

The implementation is based on the following UML class diagram:

The idea is simple, subclass Provider and override share method and you are pretty much all set. I already implemented 3 services: twitpic to share images, yfrog to share images and video, and pastebin.ca to share plain text files. My plans include to implement the following providers:

Plain text

• Pastebin.cz
• OpenPaste

Video

• Vimeo
• Twitvid

Files

• Drop.io

To allow communication between gnome/gtk/dbus-based applications I added a new dbus method: share(filename,message), that way you can “share” your file using a message, you don’t need to explicitly tell the provider+service to use, gwibber will use the filename’s mime-type to get the valid provider and the configured service, convenient isn’t it?

Where to get it?

I branched trunk to implement this feature, you can read launchpad to get more information, basically you need to:

bzr branch lp:~mario-carrion/gwibber/gwibber-services

and execute:

./bin/gwibber

I also included a patch for cheese, I’m using gnome-2-26 branch, in case you want to share your videos and images on gwibber using cheese.

Cool video

Known bugs and issues

I’m aware of several bugs, for example: web timeouts, invalid responses and random deadlocks, so take it easy, remember: this is a preview, be happy. Also I need to think about multiple instances and implementing a real HTTP handler instead of using the MultiPartForm class, will decide it later.

OpenSUSE 11.1 Users: you may need to install python-related dependencies. OpenSUSE 11.1-64, if you want to use the nautilus extension, you will need create a symbolic link in /usr/lib/ for libpython2.6.so. I’m going to report the packing bug as soon as possible.

BTW, you can always follow me on twitter: @mariocarrion in case you want to recommend me a new provider.

If you are a Mono developer, either you develop Mono or you use Mono for development, I’m sure you already have your Parallel Mono Environment set up and you are happy using it. Keeping a parallel environment is necessary because that way you don’t break your default Mono installation or an specific mono application, so you can keep using the latest version of whatever you need, however sometimes you need more than one parallel environment, usually because you are working on different versions, for example mono-2-6, mono-head and mono-package; in the Accessibility Team we are always working on different Mono versions jumping from one version to another, so we need to keep multiple parallel environments, and we don’t want to compile everything every time over and over. One way to accomplish multiple parallel environments is to keep n copies of mono-dev-env (something like mono-dev-env-2-6 or mono-dev-env-trunk); but since I like to keep everything in one place and use the same procedure to set up my environments, I updated the default environment file to something like this (you can always get an updated version from: here):

#!/bin/bash
#
# Based on http://www.mono-project.com/Parallel_Mono_Environments , with the
# following modifications:
#
# - Aliases for make:
#   - mk = make
#   - mki = make install
#   - mku = make uninstall
#   - mkuci = make uninstall, clean, autogen and install
#   - mkc = make clean
#   - mkdc = make dist-clean
#   - autogenmono = autogen.sh with prefix, you also add your arguments
#   - configuremono = configure with prefix, you also add your arguments
#   - bootstrapmono = bootstrap with prefix, you also add your arguments
# - Success/Failure messages raised depending on executed command.
#
# You will need to add the following alias into your .bashrc:
#
# function exportmono {
#   source ~/path/to/mono-dev $1
# }
#
# so you can use:
# - "exportmono trunk"
# - "exportmono 2.4"
# - "exportmono whatever"
# to use multiple parallel environments, when no argument is used "trunk"
# is set by default.
#
#
# You can also use "lcustom" to load custom scripts, for example
# if you need to define environment variables instead of adding those here
# you will write a custom-var.sh and will use:
#
# "lcustom ~/custom-var.sh"

# Use this variable to add local enviroment paths
# (i.e. to include a custom executable script)
EXTRA_PATH=$HOME/Documents/Repository/uia2atk/tools

# Colors, based on http://wiki.archlinux.org/index.php/Color_Bash_Prompt
NO_COLOR='\e[0m'
# regular colors
BLACK='\e[0;30m'
RED='\e[0;31m'
GREEN='\e[0;32m'
YELLOW='\e[0;33m'
BLUE='\e[0;34m'
MAGENTA='\e[0;35m'
CYAN='\e[0;36m'
WHITE='\e[0;37m'
# emphasized (bolded) colors
EBLACK='\e[1;30m'
ERED='\e[1;31m'
EGREEN='\e[1;32m'
EYELLOW='\e[1;33m'
EBLUE='\e[1;34m'
EMAGENTA='\e[1;35m'
ECYAN='\e[1;36m'
EWHITE='\e[1;37m'
# underlined colors
UBLACK='\e[4;30m'
URED='\e[4;31m'
UGREEN='\e[4;32m'
UYELLOW='\e[4;33m'
UBLUE='\e[4;34m'
UMAGENTA='\e[4;35m'
UCYAN='\e[4;36m'
UWHITE='\e[4;37m'
# background colors
BBLACK='\e[40m'
BRED='\e[41m'
BGREEN='\e[42m'
BYELLOW='\e[43m'
BBLUE='\e[44m'
BMAGENTA='\e[45m'
BCYAN='\e[46m'
BWHITE='\e[47m'

# We are going to load CUSTOM FILES
#
# Basically the idea is to split multiple development paths or variables
# into different files, that way we can keep this file as clean as possible.
# This magic function tries to load those files.

function lcustom {
  if test x"$1" = x; then
  	echo -e "${RED}>>${NO_COLOR} Nothing to do, no arguments provided."
  else
  	source $1 && echo -e "${RED}>>${NO_COLOR} Loaded: '$1'" || echo -e "${RED}>>${NO_COLOR} Not loaded"
  fi
}

MONO_REV=$1
if test x"$MONO_REV" = x; then
	MONO_REV="trunk"
fi

HOME_ROOT=$HOME/.root-dev/$MONO_REV
MONO_PREFIX=$HOME_ROOT
GNOME_PREFIX=$HOME_ROOT

if [ -d $HOME_ROOT ]; then
  echo -e "${RED}>>${NO_COLOR} Using environment: ${RED}$MONO_REV"
else
  mkdir -p $HOME_ROOT && echo -e "${RED}>>${NO_COLOR} Using environment (for the first time): ${RED}$MONO_REV" || echo -e "${RED}>>${NO_COLOR} Unable to create local path."
fi

# configure-related functions
function autogenmono {
  ./autogen.sh --prefix=$MONO_PREFIX $* && mynotify "autogenmono" || mynotify 1 "autogenmono"
}
function configuremono {
  ./configure --prefix=$MONO_PREFIX $* && mynotify "configuremono" || mynotify 1 "configuremono"
}
function bootstrapmono {
  if test x"$1" = x; then
    echo -e "${RED}>>${NO_COLOR} Use bootstrapmono bootstrap-file"
    echo -e "${RED}>>${NO_COLOR} For example: bootstrapmono bootstrap-2.12"
  else
    ./$1 --prefix=$MONO_PREFIX $2 && mynotify "bootstrapmono" || mynotify 1 "bootstrapmono"
  fi
}

# make-related functions
function mkuci {
  make uninstall && make clean && autogenmono $* && make install && mynotify "mkuci" || mynotify 1 "mkuci"
}
function mk {
  make $* && mynotify "mk" || mynotify 1 "mk"
}
function mki {
  make install $* && mynotify "mki" || mynotify 1 "mki"
}
function mku {
  make uninstall && mynotify "mku" || mynotify 1 "mku"
}
function mkc {
  make clean && mynotify "mkc" || mynotify 1 "mkc"
}
function mkdc {
  make dist-clean && mynotify "mkdc" || mynotify 1 "mkdc"
}

function mynotify {
  MSG_CONTENT=$1
  MSG_URGENCY="normal"
  MSG_RESULT="done"

  echo $1 | grep "[^0-9]" > /dev/null 2>&1
  # Is first argument a numeric value?
  if [ "$?" -ne "0" ]; then
    if [ "$1" -eq "1" ]; then
      MSG_CONTENT=$2
      MSG_URGENCY="critical"
      MSG_RESULT="failed"
    fi
  fi

  notify-send -t 2500 -u $MSG_URGENCY "$MSG_CONTENT $MSG_RESULT: '`basename $PWD`'"
}

export DYLD_LIBRARY_PATH=$MONO_PREFIX/lib:$DYLD_LIBRARY_PATH
export LD_LIBRARY_PATH=$MONO_PREFIX/lib:$LD_LIBRARY_PATH
export C_INCLUDE_PATH=$MONO_PREFIX/include:$GNOME_PREFIX/include
export ACLOCAL_PATH=$MONO_PREFIX/share/aclocal
export PKG_CONFIG_PATH=$MONO_PREFIX/lib/pkgconfig:$GNOME_PREFIX/lib/pkgconfig
export MANPATH=$MONO_PREFIX/share/man:$MANPATH
# a11y support
export GTK_MODULES=gail:atk-bridge

PATH=$EXTRA_PATH:$PATH
PATH=$MONO_PREFIX/bin:$PATH
PS1="$WHITE@mono-dev$NO_COLOR:$RED$MONO_REV$NO_COLOR:\w-> "

To use this script you will need to define an alias in your .bashrc:


function exportmono {
source ~/path/to/mono-dev $1
}


You can use this alias: exportmono 2.4 if you are planning to define a 2.4 environment, or exportmono trunk, or whatever; there are more aliases that I like to use, for example, autogenmono, mk or mki, the nice about these aliases is that they also use notify-send to send a message when the command is completed, so you can work on something else while compiling, installing, cleaning or configuring. Also the bash prompt is using colors to identify what is the current parallel environment, in this case I’m using mono-2-4 and the environment name is 2.4.

This environment should work on any recent bash version, if not let me know.

I’ve been using this tablet for about 4 months with OpenSUSE 11.1, I’m happy: performance, design and hardware support are good for me, however there are few complaints about it:

Hardware

• Keys are small. Are not small as keys in netbooks, but you get tired if you spent more that 6 hours hacking.
• Temperature. This is really painful, the hard-disk gets really warm and you can’t touch the bottom if you are using doing hard work.
• Noise. Same as temperature, using the DVD is somehow annoying, unless you are wearing headphones you don’t notice the noise. When using the hard-disk, for example, compiling or searching, happens the same.

Recently noticed that HP released HP TouchSmart tx2z, this is similar to TX2500z, however the big differences include more memory (up to 8gb) and multi-touch support. Hopefully my complains are already fixed in this newest hardware.

Software

Installing OpenSUSE 11.1 in super easy, so installing won’t let you down, however you will need extra tunning if you want to support all hardware, in particular sound, wireless and video:

radeonhd, open driver

1.2.3 is installed by default, this version doesn’t support Screen Rotation nor 3D Acceleration, according to 1.2.4 releasing notes Screen Rotation is now supported however xrandr doesn’t report any rotation information. If you want to upgrade add the following repository and upgrade:
http://download.opensuse.org/repositories/X11:/Drivers:/Video/openSUSE_11.1/.

fglrx, proprietary driver

I recommend to generate the rpm and use zypper to install the generated file, if you are running 64bit you will need to recreate the symbolic link because seems the fglrx driver is using 32 paths instead of 64, according to documentation Screen Rotation is also supported, but not enabled by default, so execute as root:
aticonfig --set-pcs-str="DDX,EnableRandr12,TRUE"
to enable it, notice this command doesn’t change /etc/X11/xorg.conf, it works however sometimes rotating the screen will lead to a black screen.

Verdict

I like it, is smaller and lighter that my previous laptop, however the temperature is really really annoying.