gfx.direct2d.disabled
layers.acceleration.disabled

Also, open the Add-on Manager (tools/add-ons/plugins) and disable all plugins that do not need to be enabled in your email client. Note that the plugins are a different thing than the extensions. I disabled them all in my TB.

Finally, restart Thunderbird.

This has worked for me. Thunderbird 6 now feels as responsive as TB3 was.

Related Articles

• Mozilla Thunderbird 3 is out!
• Be cautious with Notepad++
• Speed up Apache by including htaccess files into httpd.conf
• The new amateuristic release strategy of Firefox
• Use the Alternatives System to switch to a custom Firefox release

I think everyone who is interested in collaborative content should be happy about Creole. This is for the benefit of both the projects and their contributors because a standard wiki markup language promotes productivity. I think the language still needs more official additions, but I guess this is just a matter of time.

I got the impression that the Creole Project deserves more popularity, so I wrote this small post for all of you who might have never heard of it. It would be nice if you did the same!

Related Articles

• Zim – a Desktop Wiki
• Bot-Allow-Content and CC-Configurator plugin updates
• Tab Links extension for the Epiphany browser
• Forking Apache-licensed software on Github and Bitbucket
• Add-Meta-Tags WordPress Plugin

Two days ago, I decided to upgrade the program to the latest version and, during installation and without giving it much thought, I installed the application’s plugin system and a plugin called “Document Monitor” or something like that. This morning my system experienced another Notepad++ freeze, but this time a Virtual Machine, which run under VirtualBox, froze too. There was heavy disk I/O at that time. The virtual system was meant to be an RPM Build Server, so I re-deployed it just to be sure that everything was all right without risking any data loss during the freeze.

After that, I disabled Notepad++’s plugin system entirely and do not intend to use any of the plugins ever again. I continue to use the core editor, but I am also looking for alternatives. So far, PSpad (freeware) and TwistPad (commercial editor at a very reasonable price) are among the candidates. I mainly use a text editor for plain text and HTML documents, Python, PHP and BASH scripts. Any other suggestions are welcome and appreciated.

Related Articles

• Mozilla Thunderbird speed up
• Dictionary Lookups Anywhere
• Zim – a Desktop Wiki
• The Read-It-Later extension
• Break-Out-Of-Frames WordPress Plugin

Speaking about costs, I’d like to be more specific. Cost is not just about money. Cost can also be measured in terms of “time” and in terms of “effort“. Nothing is by default cheap or expensive. It depends on the task too. For example, suppose you have put all your old computer magazines in a cheap trash bag expecting it to hold long enough until you reach the trash bin across the street. The cheap bag will not hold the weight of all those magazines and you will most probably find yourself picking them up from the street like an idiot. Well, in this case, that cheap bag turned out to be very expensive in terms of time and effort. On the contrary, using expensive trash bags for lightweight garbage is idiotic too, as you spend your money on trash bags instead of buying yourself those extra megabytes of RAM your VPS requires. The same applies to computers and software. You have to use the right tool for a specific job to be cost-effective. There is no operating system that is good for everything.

I care about using cost-effective ways to do things. I didn’t used to, but I do care now. I am totally against saving, regardless of it being money, time or effort. I am in for spending, but spend wisely. Regarding computers, I have decided to use any operating system, office suite, development environment, programming language, multimedia software, server software to accomplish my tasks. Sometimes paying some money can save a lot of time and effort. Other times, investing some time and effort can save a lot of money. That’s how things work.

This post is not supposed to be lengthy and I will keep it that way. All the above, of course, do not change my views about open source, open standards and open access to information. I just wanted to say that I leave the operating system wars to you. I am out.

Related Articles

• Security Guides for Operating Systems by the NSA
• Checking on Windows Vista
• Why free should not always mean cost-free
• CentOS – Community ENTerprise Operating System
• A stolen bike

My primary desktop has been running GNU/Linux exclusively for 4+ years. During that time, I had the opportunity to use every FOSS graphical CD/DVD burning frontend that has ever been released, but I always ended to the good old command-line tools (mkisofs – now genisoimage-, dvd+rw-tools) to do the job.

Making an exception for K3B, I wouldn’t rate all other FOSS graphical CD/DVD burning frontends higher than “crapware“.

Of course, things would have been better if all those FOSS devs joined forces, had a plan and assembled a team of volunteer beta testers (I would have loved to participate). I am sure that the result would have been an awesome burning application. But, unfortunately, each of those selfish geniuses decided to torture the world by delivering his own version of crap to our desktop, dammit!

Related Articles

• Verify a burned CD/DVD image on Linux
• Creating Screencasts under Linux
• How to annotate PDF files in Linux using Xournal
• Blanking a rewritable CD/DVD in GNOME
• Creative PC-CAM Series webcams in linux

#! /usr/bin/env bash
#
#  Send to Desktop - Create Symlink
#
#  Project: http://www.g-loaded.eu/2008/11/03/send-to-desktop-create-symlink/
#
#  Features:
#      - creates symlinks on the desktop pointing to each of the selected items
#        (files/directories).
#      - Supports paths containing spaces.
#      - Supports multi-selection (warns before creating multiple symlinks)
#
#  Requires:
#      - ln
#      - zenity
#
#  Installation:
#  1) Put the file in ~/.gnome2/nautilus-scripts/
#       cp "Send to Desktop - Create Symlink" ~/.gnome2/nautilus-scripts/
#  2) Set the 'executable' bit:
#       chmod -x ~/.gnome2/nautilus-scripts/"Send to Desktop - Create Symlink"
#  3) Access the script by right clicking and selecting the submenu 'scripts'
#
#  Copyright 2008 George Notaras <gnot [at] g-loaded.eu>, CodeTRAX.org
#
#  Licensed under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with the License.
#  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing, software
#  distributed under the License is distributed on an "AS IS" BASIS,
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#  See the License for the specific language governing permissions and
#  limitations under the License.
#
 
DESKTOP=~/Desktop
 
if [ $# -lt 1 ] ; then
  zenity --error --text "At least one file or directory must be selected."
elif [ $# -gt 1 ] ; then
  zenity --question --text "Multiple items selected. Proceed?"
fi
 
if [ "$?" = 1 ] ; then
    exit 1
fi
 
for item in "$@"; do
    ln -s "$PWD/$item" "$DESKTOP/$(basename $item)"
done
 
exit 0

Save the code in a file. Assuming that you have saved it as “Send to Desktop – Create Symlink“, follow the instructions below in order to install and use it:

1 – Put the file in ~/.gnome2/nautilus-scripts/

cp "Send to Desktop - Create Symlink" ~/.gnome2/nautilus-scripts/

2 – Set the ‘executable‘ bit:

chmod +x ~/.gnome2/nautilus-scripts/"Send to Desktop - Create Symlink"

3 – Access the script by right clicking and selecting the submenu ‘scripts‘

Enjoy!

Related Articles

• Search for viruses from Nautilus
• Add files to Totem playing list from Nautilus
• How to create a single file of Sphinx based documentation
• Print to CUPS printer instances
• Tab Session Management extension for Epiphany

Related Articles

• Desktop now uses Fedora 9
• Send to Desktop – Create Symlink
• Creole – Standard Wiki Markup Language
• YUM-Priorities Configuration for a CentOS Desktop
• Dictionary Lookups Anywhere

1. Select some text with the mouse (easy :P)
2. Trigger a dictionary lookup for the selected text.
3. Get the word’s definitions in a browser window.

After some research on the web, I came up with a decent solution. I discovered that when some text is selected under X, it is temporarily stored in a location called “Primary Clipboard“. The text could be somehow retrieved from that location and could be sent to an online dictionary by pressing a specific keyboard combination. This is totally independent of the application which the text had been selected from. This method also makes dictionary lookups as easy and fast as it can get.

But, this was just in theory. I needed a way of retrieving the selected text from the primary clipboard programmatically. This was the most difficult part, as X or GTK programming is out of my league…

Fortunately, I was told that this exact functionality exists in the deskbar applet. The user can select some text, then press Alt-F3 and the deskbar applet displays a list of pre-defined places (epiphany smart bookmarks included) to search for the selected text, which also includes gnome-dictionary in order to look up the word on a dictionary server.

Using this deskbar applet’s functionality for the dictionary lookups could be the perfect solution. But, on the other hand, being able to specify different key combinations for different dictionaries and not having to pick a search location from the deskbar’s list would be more than perfect. Grepping into deskbar applet’s source code I soon found what I was looking for in the first place: that is the way to programmatically retrieve the selected text from the primary clipboard. Of course, I shamelessly stole that small piece of code :P

Provided that some text has been selected, its retrieval is possible with the following python snippet:

import gtk
clipboard = gtk.clipboard_get(selection = "PRIMARY")
text = clipboard.wait_for_text()
print text

The rest was easy. What was needed was a key combination to trigger the execution of the above script. Unfortunately, a custom command cannot be set in the gnome-keybinding-properties application. So, a workaround was needed even for that!! After some research, it turned out that one can set a custom command and assign a keyboard shortcut for it in GNOME’s window manager, metacity.

So, finally, it worked! Read on for detailed info…

How to set things up

First of all, create a small script:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
 
command = "epiphany -n http://en.wiktionary.org/wiki/%s"
#command = "epiphany -n http://dictionary.reference.com/search?q=%s"
 
import gtk
import os
from urllib import quote
 
clipboard = gtk.clipboard_get(selection = "PRIMARY")
text = clipboard.wait_for_text()
text = text.strip()
if text:
	text = quote(text)	# This is basically for multiword selections
	os.popen(command % text)

Save the script to a directory of your choice. The rest assumes that the script has been saved to:

/home/johndoe/bin/selectionlookup.py

What this does is to retrieve the selected text from the “primary clipboard” and execute the specified command. In this case, the command is actually a system call to the epiphany browser which is instructed to load a page with the possible definitions for the selected text. The English version of Wiktionary or Dictionary.com (whichever is uncommented) is used for the lookup. Note that multiword selections are supported by both the script above and the aforementioned online dictionaries.

Second of all, a global keyboard shortcut needs to be set in metacity for the reasons I explained previously.

First, the custom command needs to be set. Open the gconf-editor and browse to the key:

/apps/metacity/keybinding_commands/command_1

Of course use any command key you wish. Here command_1 is used. Set the following value:

python /home/johndoe/bin/selectionlookup.py

Then set up the keybinding for that command. Browse to the key:

/apps/metacity/global_keybindings/run_command_1

And set the combination (the following is an example):

<control><alt>g

Test it by selecting some text anywhere and by pressing Ctrl-Alt-g. A new tab will appear in the browser window with a page with the selected text’s definitions (if any).

Appendix I: Using a dictionary server

Instead of looking the selected text up on a web-based dictionary, you can retrieve definitions from a dictionary server. Adjust the script accordingly. For example:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
 
command = "echo 'DEFINE * \"%s\"' | nc dict.org 2628 | zenity --text-info --title='Dict Lookup' --width=500 --height=500"
 
import gtk
import os
 
clipboard = gtk.clipboard_get(selection = "PRIMARY")
text = clipboard.wait_for_text()
text = text.strip()
if text:
	os.popen(command % text)

The following happens when the keyboard shortcut is pressed:

1. The following dictionary protocol specific command: DEFINE * “selectedtext” is piped to netcat (see some netcat examples).
2. Netcat opens a connection to the dict.org dictionary server, sends the command and retrieves the results.
3. The results are piped to zenity and are displayed in an information textbox.

Obviously, in order to successfully run the above command you will need netcat (nc) and zenity.

Final Thoughts

A whole dictionary application can be built around the selected text that is stored at the primary clipboard. The above is the fastest and most effective way of retrieving word/phrase definitions from any possible dictionary. It is independent of the application from which the text is selected and no time is wasted in meaningless copy-pasting. If you know a better way of looking up words, please let me know.

Related Articles

• Epiphany Python Console – Open New Tab
• DictExpress
• Epiphany Browser Review
• Use Python to get the web page data in Epiphany
• Smart Bookmarks in Epiphany

Theory

Rapidshare uses cookie-based authentication. This means that every time you log into the service, a cookie containing information which identifies you as a registered user is stored in your browser’s cookie cache. Both wget and curl support saving and loading cookies, so before using them to download any files, you should save such a cookie. Having done this, then the only required action in order download from RapidShare is to load the cookie, so that wget or curl can use it to authenticate you on the RapidShare server. This is pretty much the same you would do with a graphical download manager. The difference now is that you do it on the command line.

Below you will find examples about how to perform these actions using both wget and curl.

IMPORTANT: Please note that in order to use these command-line utilities or any other download managers with RapidShare, you will have to check the Direct Downloads option in your account’s options page.

Save your RapidShare Premium Account Cookie

Saving your RapidShare cookie is a procedure that needs to be done once.

The login page is located at:

https://ssl.rapidshare.com/cgi-bin/premiumzone.cgi

The login form requires two fields: login and password. These are pretty self-explanatory.

In the following examples, the RapidShare username is shown as USERNAME and the password as PASSWORD.

Using wget

In order to save your cookie using wget, run the following:

wget \
    --save-cookies ~/.cookies/rapidshare \
    --post-data "login=USERNAME&password=PASSWORD" \
    -O - \
    https://ssl.rapidshare.com/cgi-bin/premiumzone.cgi \
    > /dev/null

–save-cookies : Saves the cookie to a file called rapidshare under the ~/.cookies directory (let’s assume that you store your cookies there)
–post-data : is the POST payload of the request. In other words it contains the data you would enter in the login form.
-O - : downloads the HTML data to the standard output. Since the above command is run only in order to obtain the cookie, this option prints the HTML data to stdout (Standard Output) and then discards it by redirecting stdout to /dev/null. If you don’t do this, wget will save the HTML data in a file called premiumzone.cgi in the current directory. This is just the Rapidshare HTML page, which is absolutely not needed.

Using curl

In order to save your cookie using curl, run the following:

curl \
    --cookie-jar ~/.cookies/rapidshare \
    --data "login=USERNAME&password=PASSWORD" \
    https://ssl.rapidshare.com/cgi-bin/premiumzone.cgi \
    > /dev/null

–cookie-jar : Saves the cookie to a file called rapidshare under the ~/.cookies directory (it has been assumed previously that cookies are stored there)
–data : contains the data you would enter in the login form.
Curl prints the downloaded page data to stdout by default. This is discarded by sending it to /dev/null.

Download files using your RapidShare Premium Account Cookie

Having saved your cookie, downloading files from RapidShare is as easy as telling wget/curl to load the cookie everytime you use them to download a file.

Downloading with wget

In order to download a file with wget, run the following:

wget -c --load-cookies ~/.cookies/rapidshare <URL>

-c : this is used in order to resume downloading of the file if it already exists in the current directory and is incomplete.
–load-cookies : loads your cookie.

Downloading with curl

In the same manner, in order to download a file with curl, run the following:

curl -L -O --cookie ~/.cookies/rapidshare <URL>

-L : Follows all redirections until the final destination page is found. This switch is almost always required as curl won’t follow redirects by default (read about how to check the server http headers with curl).
-O : By using this switch you instruct curl to save the downloaded data to a file in the current directory. The filename of the remote file is used. This switch is also required or else curl will print the data to stdout, which is something you won’t probably like.
–cookie : loads your Rapidshare account’s cookie.

Setting up a Download Server

Although most users would be satisfied with the above, I wouldn’t be surprised if you would want to go a bit further and try to setup a little service for your downloading pleasure. Here is a very primitive implementation of such a service. All you will need is standard command line tools.

This primitive server consists of the following:

1. A named pipe, called “dlbasket“. You will feed the server with URLs through this pipe. Another approach would be to use a listening TCP socket with NetCat.
2. A script, which, among others, contains the main server loop. This loop reads one URL at a time from dlbasket and starts a wget/curl process in order to download the file. If dlbasket is empty, the server should just stay there waiting.

So, in short, the service would be the following:

cat <> dlbasket | ( while ... done )

All credit for the “cat <> dlbasket |” magic goes to Zart, who kindly helped me out at the #fedora IRC channel.

So, let’s create that service. The following assume that a user named “downloader” exists in the system and the home directory is /var/lib/downloader/. Of course you can set this up as you like, but make sure you adjust the following commands and the script’s configuration options accordingly.

First, create the named pipe:

mkfifo -m 0700 /var/lib/downloader/dlbasket

If it does not exist, create a bin directory in the user’s home:

mkdir -p /var/lib/downloader/bin

Also, create a directory where the downloaded files will be saved:

mkdir -p /var/lib/downloader/downloads

The following is a quick and dirty script I wrote which actually implements the service. Save it as rsgetd.sh inside the user’s bin directory:

#! /usr/bin/env bash  
 
#  rsgetd.sh - Download Service
 
#  Version 0.3
 
#  Copyright (C) 2007 George Notaras (http://www.g-loaded.eu/)
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License version 2 as
#  published by the Free Software Foundation.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
 
# Special thanks to 'Zart' from the #fedora channel on FreeNode
 
# v0.3 - Oct 31 2009:
# - corrected error: "./bin/rsgetd.sh: line 37: [: argument expected"
 
# CONFIG START 
HOMEDIR="/var/lib/downloader"
DLBASKET="$HOMEDIR/dlbasket"
DLDIR="$HOMEDIR/downloads/"
LOGFILE="$HOMEDIR/.downloads_log"
CACHEFILE="$HOMEDIR/.downloads_cache"
LIMIT="25k"
WGETBIN="/usr/bin/wget"
# Rapidshare Login Cookie  
RSCOOKIE="$HOMEDIR/cookies/.rapidshare"
# CONFIG END
 
DATETIME="`date '+%Y-%m-%d %H:%M:%S'`"
 
cat <> $DLBASKET | (
        while read url ; do
                # First, check the cache if the file has been already downloaded
                if [ -f "$CACHEFILE" -a -n "$(grep -i $(basename $url) $CACHEFILE)" ] ; then
                       echo "$DATETIME File exists in cache. Already downloaded - Skipping: $url" >> $LOGFILE
                else
                        echo "$DATETIME Starting with rate $LIMIT/s: $url" >> $LOGFILE
                        if [ $(expr match "$url" '[rapidshare.com]') = 1 ] ; then
                                # If it is a Rapidshare.com link, load the RS cookie 
                                echo "RAPIDSHARE LINK"
                                $WGETBIN -c --limit-rate=$LIMIT --directory-prefix=$DLDIR --load-cookies $RSCOOKIE $url
                        else
                                $WGETBIN -c --limit-rate=$LIMIT --directory-prefix=$DLDIR $url
                        fi
                        echo "$DATETIME Finished: $url" >> $LOGFILE
                        echo $url >> $CACHEFILE
                fi
        done )
 
exit 0

As you might have already noticed, two extra files are created inside the home directory: .downloads_cache and .downloads_log. The first contains a list of all the urls that have been downloaded. Each new download is checked against this list, so that the particular URL is not processed if the file has already been downloaded. The latter file is a usual logfile stating the start and end times of each download. Feel free to adjust the script to your needs.

Here is some info about how you should start the service:

-1- You can simply start the script as a background process and then feed URLs to it. For example:

rsgetd.sh &
echo "<URL>" > /var/lib/downloader/dlbasket

-2- Use screen in order to run the script in the background but still be able to see its output by connecting to a screen session. Although this is not a screen howto, here is an example:

Create a new screen session and attach to it:

screen -S rs_downloads

While being in the session, run rsgetd.sh

rsgetd.sh

From another terminal feed the download basket (dlbasket) with urls:

echo "<URL>" > /var/lib/downloader/dlbasket
cat url_list.txt > /var/lib/downloader/dlbasket

Watch the files in the screen window as they are being downloaded.

Detach from the screen session by hitting the following:

Ctrl-a   d

Re-attach to the session by running:

screen -r

Note that you do not need to be attached to the screen session in order to add URLs.

Feeding the basket with URLs remotely

Assuming that a SSH server is running on the machine that runs rsgetd.sh, you can feed URLs to it by running the following from a remote machine:

ssh downloader@server.example.org cat \> /var/lib/downloader/dlbasket

Note that the > needs to be escaped so that it is considered as part of the command that will be executed on the remote server.

Now, feel free to add as many URLs as you like. After you hit the [Enter] key the url will be added to the download queue. When you are finished, just press Ctrl-D to end the URL submission.

Conclusion

This article provides all the information you need in order to use wget or curl to download files from your RapidShare Premium account. Also, information on how to set up a service that will assist you in order to commence downloads on your home server from a remote location has been covered.

The same information applies in all cases that wget and curl need to be used with websites that use cookie-based authentication.

Related Articles

• rsapiget downloads files using the new Rapidshare API
• Check Server HTTP Headers with CURL
• Mass download
• Partition images with Partimage and Partimaged
• Script for Apache Error Report

I’ve been experimenting with the Minimalist for the last days and all I can say is that this software Just Works™ … and I like it when software works! Actually, I liked it so much that I have devoted a significant amount of time in writing a program that acts as a bridge between the Minimalist’s mailing list archives and MHonArc. This program (a MHonArc wrapper actually), which also includes a set of resource files in order to heavily customize MHonArc’s HTML output (in an attempt to be like the popular Mailman web archives), is called BenzinArc (Benzin Archiver) and can be used both as a cron job and as a standalone application. BenzinArc is still work in progress. No code has been released yet. An overview of the HTML version of the CodeTRAX Mailing List Archives is available. Currently, only one read-only mailing list, codetrax-bugs, exists. This is a dedicated list to the bug reports of all projects hosted by CodeTRAX, but it is enough to serve as an example.

All this mailing-list-related stuff has kept me away from working on the 0.7.1 release of the TraxAuth Account System, but I assume all that was absolutely necessary. Although my free time will be very little in the upcoming weeks, I guess I will be able to release a new version of TraxAuth and the first public test release of BenzinArc.

Related Articles

• Organizing Mailing List messages with Evolution
• TraxAuth
• Next time, come prepared
• Add files to Totem playing list from Nautilus
• Smart Bookmarks in Epiphany