Using the Wuala API .net wrapper for quick in-folder search

An interesting question that came up to me was how to implement a quick, efficient in-folder search engine with the .net wrapper. Of course, by it’s nature this isn’t a given feature and because you’d have to enumerate through all the subfolders.

But the question tips of another aspect: LINQ in combination with the wrapper.

As the entire assembly is written with extendability in mind, let me say: Yes, you can easily use LINQ with the wrapper:

var allfiles = WualaFile.GetFileList(
"http://wuala.com/Creative+Commons/Chaos+Computer+Club/Chaosradio+Express", true, false);

var files = allfiles.Items
            .Where(f => f.Name.Contains("09"))
            .OrderBy(f => f.Url);

foreach(var file in files)
{
   Console.WriteLine(""{0}"", file.Name);
}

Console.ReadKey();

If you want to build an in-folder search that also cares about subfolders though, recursively get the files from the folders, add them to a global index, run LINQ queries over it and export the Url of the result files back in. Easy as that.

Wrapper Release

Gee. I didn’t get around to post this but the stable wrapper v. 0.0.1.0 has been released onto Wuala.

Changes include the latest adjustments to the API (doesn’t include the changes to the thumbnail method, as this came later) and a little cleanup/documentation in the sourcecode itself.

I think it’s a nice, easy-going wrapper to work with that doesn’t make a big deal out of every little event (as a matter of fact, it doesn’t throw any exceptions whatsoever $me thinks).

Since there isn’t much demand for fast-paced development and I’m kind of absorbed into FarCry 2 at the moment, I probably won’t bother working on the Wuala Browser Sample (the application that should succeed ToyBox at one point) for a while — that doesn’t mean I won’t play around with it, though.

Wrapper for Wuala’s API

As many Wuala users have probably noticed, there is an official group for the upcoming Wuala API available. Yes, the documentation for the alpha API is out and I’ve been busy implementing the specs into an easy-to-use .net assembly for the last two days.

Basically I’ve all the calls plugged in and wired together, all that’s left before a first public test version (watch the group, people!) is to clean up some ugly sections and start basic documentation on how to work with the calls and classes, although the included ToyBox application should show this.

So, when will there be a public download and will the sourcecode for the assembly be freely available? A first public version is to be expected to hit the Wuala API group in the middle of the week, I’d prefer to release earlier but I want to make sure I have a somewhat solid base for further improvements. The sourcecode will be made available later on, the people from Caleido’s staff already do have access to it though.

A basic set of features:

  • Complete implementation of the current Wuala API.
  • Uses basic datatypes and generics only
  • Full proxy support
  • Many function overloads (yet more to come!)

Some things that won’t make the cut for the first test version:

  • Better integration/naming of the properties to be more .net like
  • A somewhat more dynamic way of implementing certain calls

I hope that this work will encourage people to play and experiment more with Wuala and it’s capabilities, even though the current API is somewhat limited.

Update: I released a binary version of the DLL as well as the sourcecode for ToyBox into the Wuala API group. Feel free to test it and give me your feedback either directly via the group or by comment πŸ™‚ .

Nemo

Can’t really tell how I’ve managed to overlook this great program πŸ™‚ .

Nemo is a file manager without… well… it’s more like a calendar actually… but with files. Hard to explain but very fitting to keep track of my incredible heap of data. I’ll keep an eye on this project as it is not only written in C# (Mono) but also utilizes the capabilities of Xesam. That makes 2 great reasons to love it already πŸ™‚ .

Temporarily register fonts using a normal User account

As you may know Windows is quite stiff sometimes. You can’t add additional font directories like you’d do on Unix. Another stiffy problem is that Windows requires an elevated account for operations like installing/removing fonts from the system. That’s quite troublesome at times.

This is exactly when my little tool jumps in. With RegisterFont you can add a number of fonts to your font cache without using an elevated user account. The downside is that all the changes persist only ’till the next reboot; Windows will rebuild it’s cache and the changes will be lost.

Anyway, the archive contains a binary as well as the C# sourcecode to this small utility. Use it like that:

RegisterFont.exe add font1.ttf font2.ttf font3.ttf … font1000.ttf

Easy, huh? If you don’t want to add fonts but remove them, substitute the “add” parameter with “rem” and you’ll be set. I didn’t bother to link up to the MSDN entries explaining the API, this is just a quick and dirty tool I wrote because we were in need of a quick solution to a problem πŸ™‚ .

Update 2010-08-27: dcpurton wrote a tool in C to accomplish the same goal but without the .net dependencies. Best of all: Sourcecode is also available πŸ™‚ .

Winforms in Mono

I hope I don’t have to emphatize how much of a Mono fanboy I am at this point πŸ™‚ . Today I had one of these “Wow” moments Microsoft wanted me to give with Vista (they failed miserably, btw) when I did some poking at Winforms in Mono and were able to run my fairly sophisticated installation program example I wrote a while back unmodified on Linux (and it basically worked out of the box):

I was especially impressed by the fact that the program was aware the user level it was running in. I started it with sudo and got the result you can see above, program reports “elevated” status. Now this is very cool, more so because this was originally written for Windows Vista! One thing I’d love to implement, just for the sake of completing a nice installer demo, is awareness of what operating system the installer is being launched on/what features are available in the CLR it is running in. Also some smaller things like getting rid of improper path delimiters and casing where files should go depending on the system. Wycked.

Monodevelop no longer broken

Yeah, I don’t really know what’s different now. A fresh checkout from trunk, a quick compile and Monodevelop is back in action. It is actually the first version I’m using in a long time, I’ll try to get a little more into Mono and Gtk# now as Qyoto still seems to be a little in the future for everyday use across different platforms.

So, as a little test of some of the Mono namespaces I’ve built a quick and dirty (I really mean it!) program that writes a user-selectable number of feeds from Liferea’s liferea.db back into XML files (RSS2):

If there’s any interest I’ll polish the code to be less prone to errors and post the sources.

By the way: Weekend, yay.