Related Articles

• Creative Commons v3.0 Licenses Launched
• User management from the command line
• Using a CUPS printer from command line
• Creative PC-CAM 750 on Fedora 10
• Blanking a rewritable CD/DVD in GNOME

As mentioned previously, as soon as the device is plugged into the USB port, GNOME mounts its internal flash memory.

Looking at dmesg output as root:

# dmesg
usb 3-1: new full speed USB device using uhci_hcd and address 2
usb 3-1: configuration #1 chosen from 1 choice
usb 3-1: New USB device found, idVendor=041e, idProduct=4013
usb 3-1: New USB device strings: Mfr=1, Product=2, SerialNumber=0
usb 3-1: Product: Creative PC-CAM 750
usb 3-1: Manufacturer: ViewQuest Technologies INC.
Linux video capture interface: v2.00
gspca: main v2.2.0 registered
gspca: probing 041e:4013
gspca: probe ok
gspca: probing 041e:4013
usbcore: registered new interface driver sunplus
sunplus: registered
gspca: disconnect complete

As you can see, despite the fact that the webcam has been recognized by the gspca-sunplus driver, gspca loses control of the webcam. This happens because GNOME (gvfs) has mounted its memory. Obviously, the device cannot operate as a webcam while its internal memory is mounted.

To list the currently mounted block devices by gvfs run the following command as your currently logged in user:

$ gvfs-mount -l
Drive(0): CD-RW/DVD±RW Drive
Drive(1): Mass Storage Drive
...
...
Mount(0): Creative Technology, Ltd PC-Cam 750 -> gphoto2://[usb:003,002]/

So, there it is. The gphoto2 driver has been used to mount the device’s flash memory.
To unmount it run (as the currently logged in user):

$ gvfs-mount -u gphoto2://[usb:003,002]/

Replace the usb port reference according to your gvfs-mount -l output.

Alternatively, you can unmount all devices mounted by the gphoto2 driver with the following command:

$ gvfs-mount --unmount-scheme gphoto2

Now, the camera’s memory shouldn’t be listed in gvfs-mount -l output.

All you have to do now to get to webcam-mode is reload the gspca-sunplus module.

As root:

# /sbin/modprobe -vr gspca-sunplus
# /sbin/modprobe -v gspca-sunplus

Running dmesg we confirm that the gspca-sunplus module controls the device

# dmesg
...
...
Linux video capture interface: v2.00
gspca: main v2.2.0 registered
gspca: probing 041e:4013
gspca: probe ok
gspca: probing 041e:4013
usbcore: registered new interface driver sunplus
sunplus: registered

Also, the ls command shows that our v4l device has been created:

# ls -l /dev/video*
lrwxrwxrwx  1 root root     6 2008-12-08 15:49 /dev/video -> video0
crw-rw----+ 1 root root 81, 0 2008-12-08 15:49 /dev/video0

That’s it. As a user, run cheese and say hello to yourself!

This should work for all other digital-camera / web-camera combo devices as well, provided that you use the appropriate gspca driver as shown in the dmesg output.

Your feedback is welcome.

Related Articles

• Creative PC-CAM Series webcams in linux
• Access gvfs mounts from the command line
• A different approach…HAL
• Creative Commons v3.0 Licenses Launched
• Viceo Backend for SANE with libusb support

#! /bin/sh

if [ -f /var/lock/noshutdown.lock ] ; then
  logger -t shutdowndog shutdown prevented
  exit 1
fi

/sbin/shutdown "$@"

Then, I created the file that would act as a switch:

touch /var/lock/noshutdown.lock

Then, I initiated the shutdown procedure from the command line:

shutdown -h +0

There was no shutdown! It had worked!

Syslog confirmed that the check had taken place:

Nov 25 19:19:04 galeon shutdowndog: shutdown prevented

I rushed to try to shut down the system from GNOME’s shutdonw panel (Menu System -> Shut Down...), but, after pressing the relevant button, the system went down normally…

It was obvious that GNOME had not used my override, but another mechanism to power-off the system instead. Since I use the GNOME menu to shutdown/reboot/suspend the system, I spent a couple of hours trying to find what was going on in GNOME and finally discovered the file /usr/bin/gnome-power-cmd.sh:

#!/bin/sh
# Copyright (C) 2007 Richard Hughes 
#
# Licensed under the GNU General Public License Version 2
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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.

#$1 = method name
execute_dbus_method ()
{
        dbus-send --session --dest=org.freedesktop.PowerManagement              \
                  --type=method_call --print-reply --reply-timeout=2000 \
                  /org/freedesktop/PowerManagement                      \
                  org.freedesktop.PowerManagement.$1
        if [ $? -eq 0 ]; then
                echo "Failed"
        fi
}

if [ "$1" = "suspend" ]; then
        echo "Suspending"
        execute_dbus_method "Suspend"
elif [ "$1" = "hibernate" ]; then
        echo "Hibernating"
        execute_dbus_method "Hibernate"
elif [ "$1" = "reboot" ]; then
        echo "Rebooting"
        execute_dbus_method "Reboot"
elif [ "$1" = "shutdown" ]; then
        echo "Shutting down"
        execute_dbus_method "Shutdown"
elif [ "$1" = "" ]; then
        echo "command required: suspend, shutdown, hibernate or reboot"
else
        echo "command '$1' not recognised, only suspend, shutdown, hibernate or reboot are valid"
        exit 1
fi

So, GNOME makes the appropriate calls for power-related events through D-bus. I initially thought that GNOME used /usr/bin/gnome-power-cmd.sh whenever the shutdown/reboot/suspend button was pressed, so I modified it so to check for my switch (/var/lock/noshutdown.lock) and then proceed accordingly. It did not work out…

I had already spent much time on this, so I decided to quit. But, it is crucial for me to make this thing work and I will probably investigate it a bit more and report back at some later time.

Related Articles

• delayed-shutdown initscript
• Using setenforce to switch SELinux mode wisely
• Use the Alternatives System to switch to a custom Firefox release
• Screenshot of a menu under GNOME: ROUND 2
• Print a Man Page

*/1 * * * * root /usr/bin/notify-send "lala" "test message"

No notification appears on the desktop, no matter how long I wait. After doing some research it turns out that notify-send cannot automatically send notifications to all users that run a desktop session. It can only send notifications only to one user at a time provided that the user’s D-Bus session address is available to notify-send.

So, I decided to set the cron job to send a notification to my own user account by providing notify-send with my DBUS_SESSION_BUS_ADDRESS.

The following is a method a system user (or any user except me) would use to retrieve my DBUS_SESSION_BUS_ADDRESS address. These steps are actually taken from this GNOME-Hack, which is supposed to send notifications from a cronjob.

In order to retrieve this address, my gnome-session’s PID number is needed.

$ ps axu | grep gnome-session | grep -v grep
gnot      2602  0.0  1.3  33432  7064 ?        Ssl  16:56   0:00 /usr/bin/gnome-session

The needed PID number is 2602. The D-BUS session’s address exists as an environment variable (DBUS_SESSION_BUS_ADDRESS) of that process (2602). This can be retrieved with the following:

$ grep -z DBUS_SESSION_BUS_ADDRESS /proc/2602/environ
DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-vKzOHyaDdi,guid=f45436454463d8df2f8d265447405220

Notice that the PID number has been used in the /proc/2602/environ path.

Adding this information to the initial cronjob one would expect that the notification would appear on the desktop.

*/1 * * * * root DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-vKzOHyaDdi,guid=f45436454463d8df2f8d265447405220 /usr/bin/notify-send "lala" "test message"

Unfortunately, it didn’t. I also retrieved my desktop session’s display number and added it to the cron job.

*/1 * * * * root DISPLAY=:0.0 DBUS_SESSION_BUS_ADDRESS=unix:abstract=/tmp/dbus-vKzOHyaDdi,guid=f45436454463d8df2f8d265447405220 /usr/bin/notify-send "lala" "test message"

Unfortunately, nothing happened.

It seems that not only notify-send can send a notification to only one desktop session owner at a time, but also it is that desktop session owner who must issue the notify-send command. So, as long as most system services drop privileges and run as processes of non-privileged system users, they cannot send notifications to desktop users.

This is probably because of one or more of the following reasons:

1. either D-Bus is incomplete when it comes to message exchanging between non-privileged users
2. or there is some kind of security mechanism that prevents the above from happening. Unfortunately, I haven’t found any information about such a mechanism.
3. or I miss something way too important
4. or I make a mistake in one of the steps

If I miss anything, please let me know.

Related Articles

• Towards the resolution of the issues with libnotify
• Email Notifications from a Linux System
• The kind of RPM dependencies I dislike
• User management from the command line
• Lock out a user after N failed login attempts

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
• Taking a screenshot of a menu under GNOME
• Zim – a Desktop Wiki
• Use Python to get the web page data in Epiphany

1. The official extensions that are marked as safe by the packagers and, generally, by all the folks that make decisions for each distribution. These extensions are finally available to the end users through the extensions panel.
2. The official extensions that are not mature enough to appear in Epiphany’s extension panel. This means that there is a great issue with this group of extensions. If an end user does not check the official extensions package sources or the Epiphany project’s webpage, it is absolutely impossible even to know about the existence of these “imature” extensions.
3. The third party extensions, which are mainly distributed by their developers.

All these restrictions do a good job protecting the end user from using buggy code, but this situation, not only narrows the end user’s freedom of choice, but also leads new Epiphany users, who are not aware of the situation, to make the false assumption that it is way too difficult to extend this browser’s functionality to suit their needs. The Firefox phenomenon has shown the importance of the high availability of software that extends the browser’s functionality.

My suggestion to packagers is: enable all official extensions (except for the examples maybe) in the epiphany-extensions package. The end users have the right to choose to use imature code.

NOTE: Those users who wish to recompile the extensions package, please read here.

Another thing that requires much thought is how well this epiphany-extensions package concept will work when the number of the available extensions increases. It will give both the end users and the developers a hard time. Furthermore, this concept promotes the distribution of 3rd party extensions by many different locations on the web, which is absolutely unacceptable when it comes to security. I mean this is a web browser, not a calculator!

I hope the folks at the Epiphany project give a higher priority to the organization of the extension distribution system in a more effective way.

Related Articles

• A Note About The Epiphany Extensions on Fedora
• Featured Epiphany Plugins
• Tab Session Management extension for Epiphany
• Epiphany Python Console – Documentation
• Tab Links extension for the Epiphany browser

-1- Eject the medium, set your “removable media preferences” in a way so that CDs do not get mounted automatically, and then load the medium into the drive again and continue on with blanking it.

-2- Use su or sudo to unmount the medium. Although this is the most common solution to such issues, I think that root access should not be required in order to accomplish everyday tasks of such simplicity.

-3- The third way involves using the utility gnome-mount. I found out about this today, while, from the nautilus interface, I was unable to directly unmount the volume as a user without ejecting it. The syntax is very simple. Assuming that /dev/hdc is your writer, then issue the following command as a user:

$ gnome-mount --unmount -d /dev/hdc

The volume gets unmounted, but the CD still remains loaded into the drive. If there is another way to perform this task through a graphical interface, I’d appreciate it if you dropped me a line.

-4- Yes, there is always an extra option :) Use brasero (ex bonfire). This is yet another desktop CD/DVD burning application, but it is smart enough to unmount the written rewritable medium before trying to blank it! And it is good when applications are a bit smart ;)

Related Articles

• Packet Writing on CDRW and DVDRW media
• Creative PC-CAM 750 on Fedora 10
• Turning off window animations in GNOME
• GNOME 2.12 is out, but…
• Screenshot of a menu under GNOME: ROUND 2

How to create a smart (dynamic) bookmark

This is quite easy. Assume that you need to create a smart bookmark that searches the archives of your favourite mailing list.

All you need to do is perform a search on that list for a distinctive sequence of characters. For example I searched the LGU list for the term AAAAAA:

AAAAAA site:http://lists.hellug.gr/pipermail/linux-greek-users/

Or better, you may want to use Google’s advanced search feature.

Now, all you have to do is bookmark (Ctrl-D) the results page, but before actually saving the bookmark, you should substitute the AAAAAA sequence with %s. (that’s two characters % and s)

%s will be substituted with the requested search terms every time the smart bookmark is used.

Now, your bookmark is a smart one and you may finally press the “Add” button to save it. All you have to do is type the search terms on the browser’s address bar and choose your smart bookmark from the bottom of the dropdown list that appears below the address bar.

Another cool thing you can do with a smart bookmark is to open the bookmarks editor (Ctrl-B), right click on your smart bookmark and select the “Show on Toolbar” option. A textbox should appear in your bookmarks bar, so you can search this resource quickly.

Finally, if you use the Deskbar applet, then you should know that this tool recognizes your saved smart bookmarks and lets you assign a shortcut to each one of them. For example, one could assign the “lgu” string to the aforementioned search on the mailing list archives. So now a search on the mailing list can be performed right from the desktop (deskbar applet) with the following:

lgu kernel

This will search the mailing list for all entries that contain the term kernel.

Smart bookmarks are a neat feature. I use this very frequently. This post was written for those who have overlooked this really useful feature.

Related Articles

• Epiphany Browser Review
• Dictionary Lookups Anywhere
• Organizing Mailing List messages with Evolution
• Descramble Passwords from gftp Bookmarks using Python
• Featured Epiphany Plugins

Although YouTube’s video resolution is not suitable for this type of videos, it was enough to convince me that something does not function as expected on my machine. But, first of all, a few remarks about the video:

1. After issuing the import command, the cursor does not turn into a cross. Usually, the cursor change indicates a change of mode. But I guess this is not of significant importance.
2. This is definitely not the GNOME desktop environment. It is fluxbox (or I have been badly misled), but, sincerely, I have no problem at all with this…

I tried to take a screenshot of a menu under fluxbox. After issuing import, to my relief I could switch applications with Alt-Tab, but, when I tried to trigger a menu with Alt-F, for example, the menu, although triggered, it was not visible. How can anyone take a screenshot of an invisible menu?

I use Fedora Core 6 with almost the latest updates. I would be very glad to know what I am missing here…

Related Articles

• Taking a screenshot of a menu under GNOME
• Blanking a rewritable CD/DVD in GNOME
• Turning off window animations in GNOME
• GNOME 2.12 is out, but…
• GNOME 2.14, Rawhide, SUSE and more…

The Postscript output can be piped to lpr for printing in a CUPS printer. The following example prints the iptables manual page to the HP690C printer:

$ man -t iptables | lpr -P HP690C

Alternatively, the output can be saved to a postscript file:

$ man -t iptables > iptables.ps

More on using a CUPS printer from the CLI can be found here.

Those who have the Yelp GNOME application installed, can take advantage of its internal man page parser and HTML converter. For example, in order to display the iptables man page in Yelp, launch it like the following:

$ yelp man:iptables

From there, you can use the GNOME print dialog to print the iptables manual.

I tend to prefer the quality of the man page when it has been printed through Yelp.

Related Articles

• Print to CUPS printer instances
• Using a CUPS printer from command line
• Write A Man Page
• pdf2email CUPS Backend
• Use Python to get the web page data in Epiphany