ALViC – Accessible Linux for Visually Challenged launched

ALViC- Accessible Linux for Visually Challenged was launched on 11th February, 2013 by Prof R. Chidambaram, Principal Scientific Adviser, Govt. of India & Shri J. Satyanarayana, Secretary, DeitY, Ministry of Comm. & I.T., Govt. of India during the CDAC Technology Conclave on 11th Feb, 2013 at Indian Habitat Centre, New Delhi. During the 2-days technology conclave, a number of technologies and products developed by CDAC under various thematic area were showcased.

ALViC is a complete desktop environment which provides a comprehensive solution for Visually Challenged users. This is a GNU/Linux distribution based on Ubuntu 10.04; and uses Orca 3.2.0 xdesktop screen reader as the main interaction mechanism for visually challenged users. They can use it out of the box because accessibility features suitable for fully blind as well as for partially blind users are enabled by default.

Main Features :

  • Free and open source desktop environment
  • Enhanced Orca with skim read, sentence navigation, list shortcut and structural navigation of text documents
  • PDF documents made accessible in Linux environment
  • Easy navigation and search facility on Desktop icon view
  • Accessible login for visually challenged users
  • Suitable desktop themes for partial blind
  • Other assistive tools like OCRFeeder, Audio book converter, Emerson DAISY reader, sound converter etc. useful for visually challenged users are also included.

This product has been released under the project ‘Enhancing Accessibility for FOSS Desktops’ at CDAC, Mumbai being carried out under NRCFOSS-Phase II. The research and development activities under this project are aimed at developing software-based assistive technologies/solutions for the differently-abled people.

Download:

ALViC can be downloaded from here.

Launch of ALViC can be watched here.

More details and documentation about ALViC can be accessed here.

New version of Anumaan – open source predictive text entry system from CDAC, Mumbai released

CDAC, Mumbai has announced the new release of open source predictive text entry system – Anumaan. This release includes new version of standalone flavour of Anumaan i.e. Anumaan-standalone-0.2. This version has been released as part of the activities of project “Enhancing Accessibility for FOSS Desktops” under NRCFOSS-Phase II being carried out at CDAC, Mumbai.

Anumaan gives predictions based on preceding text/words used by the user in his/her text and user can use these predictions, while composing text. By incorporating predictions, user can improve his/her rate of text entry to a great extent.

Anumaan is mainly intended to help persons with motor disabilities, specially ones facing problems in hand and finger movement. Such persons face difficulty in using regular input devices like keyboard for text entry related tasks. Anumaan can help such persons immensely in their text entry related tasks by way of predictions. However, It is equally useful for common users also and can support them in creating mails, letters, documents etc. in less time.

Salient features of current version include:

  • More user-friendly and simplified interface for easy interaction and navigation.
  • Re-oriented layout of text entry area and prediction display in order to reduce visual and cognitive overhead.
  • A single comprehensive prediction list combining predictions from all relevant grams for easy selection.
  • Keyboard support for selecting predictions from prediction list. It reduces time taken in selecting and committing predictions to text.
  • Larger text entry area compared to previous version for easy text entry.
  • Integrated context-sensitive help.
  • Re-oriented menu bar for easy access and navigation.

All these features are intended to improve user interaction and experience for motor disabled people.

Anumaan is developed on java platform and supports UTF-8, so it can effectively be run on any platform. Newly released version of Anumaan can be downloaded from http://www.cdacmumbai.in/anumaan.

Details about project “Enhancing Accessibility for FOSS Desktops” can be accessed at http://www.cdacmumbai.in/accessibility.

Feedback, bug reports or feature enhancement requests about the application can be sent to ossd[at]cdac[dot]in or predictanumaan[at]gmail[dot]com.

GNU/Linux distributions for Differently-abled people from CDAC, Mumbai

Centre for Development of Advanced Computing (CDAC), Mumbai has released beta versions of GNU/Linux distributions for Differently-abled people. These distributions are part of the activities being carried out under “Enhancing Accessibility for FOSS Desktops” project under NRCFOSS-Phase II at CDAC, Mumbai. There are three distributions specific to three different kinds of disabilities namely:

1. GNU/Linux distribution for Visually-challenged: This is a GNU/Linux distribution (beta version – 0.1.1) created specially for visually challenged users. Visually challenged users can use it out of the box because accessibility settings required by them are already enabled.

2. GNU/Linux distribution for Physically-challenged: GNU/Linux for Physically Challenged-Beta-0.1.1′ is a special distribution for physically challenged people, so that they can easily access FOSS desktops.

3. GNU/Linux distribution for Cognitively-challenged: This GNU/Linux distribution has been developed to provide an accessible desktop environment to the cognitively challenged users.

These distributions and other related documentation can be downloaded from here.

Note: It is advisable to go through documentation first before installing/using the distribution. In case of error in any download and for feedback on distributions,  one can contact at ossd[at]cdac[dot]in.

GEM (GEstures with Mouse) – a mouse gesture based input mechanism from CDAC, Mumbai

CDAC, Mumbai has released beta-0.1 version of GEM (GEstures with Mouse). It is an open source input mechanism which uses gestures as input to the system. Gestures can be drawn using a mouse or some equivalent device like touch pad, joystick, pen tablet etc. Gestures can drawn either as single-part (continuous) or multi-part (discontinuous) as shown in screen shots below:

drawing a single-part gesture
Drawing a single-part gesture in input window
Drawing a multi-part gesture
Drawing a multi-part gesture in input window

This Input mechanism is intended for people suffering with different kinds of motor disabilities, who may face problems in using mouse and keyboard in conventional way. Hence, it provides them with an alternate and effective mechanism for using the system to perform various tasks such as navigation, executing commands & keyboard shortcuts, and launching applications etc. on Linux desktop.

More details about GEM can be accessed at http://www.cdacmumbai.in/accessibility.

GEM related URLs:

1. Accessibility Project Main page at CDAC, Mumbai website can be accessed at http://www.cdacmumbai.in/accessibility.

2. GEM can be download at http://www.cdacmumbai.in/projects/accessibility/gem-beta-0.1.tar.gz.

3. User documentation for GEM can be accessed at http://www.cdacmumbai.in/projects/accessibility/How-To-Use-GEM.pdf.

Feedbacks, bug reports or feature enhancement requests about the application can be sent to ossd[at]cdac[dot]in.

 

Using GNU Build System to create a distributable package

Background: Installing a software or package in Unix-like systems is quite different from that in Windows environment. Hence, whenever someone wants to install a new software or software in a Unix-like environment, question arises whether there is any standard for this. Typically, there are two methods of installing a software in Unix-like systems:

1. Installation by using a package manager.

2. Installation from source code.

However, as per GNU standard, users should follow the following method:

1. Packages normally come in the form of a tarball (archive of compressed files in .tar format).

2. Package should first be decompressed e.g. ….:~$tar -xzvf <tarball-of-package>

3. After decompressing, enter the decompressed directory.

4. In decompressed directory, locate and run configure script e.g. …:~$./configure.

5. Once, configure script is run successfully, then run make e.g. …:~$make. This will compile all necessary files for installing the package.

6. Once it completes, then run make install e.g. …:~$sudo make install

This is from user’s point of view. For a developer, the ultimate consideration is how to bundle the source code files and other relevant resources in a distributable package so that it can be run across various platforms. Following are some issues to be taken care of while packaging the system for a release as per GNU standards:

1. Naming and Versioning of the package.

2. Portability of system on a variety of platforms.

3. Configuration script configure with standard configurations options.

4. Makefile.inS required by configure script.

5. Conformity of Makefile and directory layout as per GNU standards.

6. Necessary documentation files and tests.

7. Bundling of the package into a tarball.

8. Licensing of the system.

However, this post is mainly about the use of GNU Build System in creating a distributable package..

Why GNU build system: Creating a configuration script and Makefiles from scratch is a tedious, time-consuming and error-prone task. Moreover, some users may be left unsatisfied due to unavailability of some desired features and at the same time, it may be needed to upgrade the overall setup to follow the changes to the GNU Coding Standards. This is where GNU build system fits in. It helps simplify the development of portable programs. It also simplifies the building of programs distributed as source code. Apart from it, any bug fixes and improvements can be made at one place. And, users don’t require any utilities of build system at their end.

Introduction to GNU build system: So, what do we mean by GNU build system? GNU Build System comprises:
1. autoconf: It is a tool for generating configuration script “configure”.
2. automake: It is a tool for generating makefile templates “Makfile.inS”.
3. libtool: It is a tool that helps creating the portable compiled libraries.
4. Some other auxilary tools:
    i. autoscan:
It is used for generating intial input file for autoconf.
    ii. autoheader: It generates template header for “configure”.
    iii. aclocal: It generates a file named aclocal.m4.

Installation of GNU build system:
•     First check, if already installed in their most recent versions:
      •…:~$autoconf – -version
      •…:~$automake –version
      •…:~$libtool –version
•     If not installed, then to install (on any debian-like system):
      •…:~$apt-cache search <tool-name> – it searches for the package <tool-name> in available package list.
      •…:~$sudo apt-get install <tool-name> – it installs the package <tool-name>.

Using GNU Build System:
1. Basic requirements:
Basic requirements for using the GNU Build System are as follows:
i. Source and documentation files of the package.
ii. One “configure.ac” or “configure.in” as initial input file for autoconf.
iii. One “Makefile.am” for each directory in the package.

2. Source and Documentation files: These are the files containing source code and necessary documentation to be distributed in the package. Ex.: .c, .cpp files, README etc..

3. What is configure.ac? : It is initial input file for autoconf to generate configure script. It is also used by automake, while creating Makefile.amS. This file normally contains macros needed to test the system features required or used by the package.

4. Using autoscan: autoscan scans source files and creates configure.scan. After making some adjustments, if required, configure.scan can be renamed to configure.ac. Adjustments may be like adding some missing macros or changing the order of some macros etc..
5. Common macros: Following are the common macros normally used in “configure.ac”.
i.
AC_PREREQ: This macro specifies the minimum version of autoconf that can successfully compile a given configure.ac.
ii. AC_INIT: This macro initializes autoconf.
iii. AM_INIT_AUTOMAKE: It initializes automake.
iv. AC_PROG_CC: This macro determines a C compiler to use and sets output variable CC to its value.
v. AC_PROG_CXX: This macro determines a C++ compiler to use and sets output variable CXX to its value.
vi. AC_CONFIG_HEADER: It causes to create a config.h file gathering ‘#define’s defined by other macros in configure.ac.
vii. AC_CONFIG_FILES: It declares the list of files to be created from their *.in templates.
viii. AC_OUTPUT: It generates and runs config.status, which in turn creates the makefiles and any other files resulting from configuration.

6. Example configure.ac:
AC_PREREQ(2.61)
AC_INIT([hello], [0.1], [sagun@cdacmumbai.in])
AM_INIT_AUTOMAKE([-Wall -Werror])
AC_PROG_CC
AC_CONFIG_HEADER([config.h])
AC_CONFIG_FILES([
Makefile
src/Makefile
])
AC_OUTPUT

7. What is Makefile.am?: It is an initial input file for automake to generate Makefile.in. One Makefile.am is required for each directory in package including root directory. This file normally contains a list of variable (and rule) definitions required, when make is invoked.

8. Common Makefile targets: Following are common makefile targets.
i. make all: This target is used to build programs, libraries, documentation etc.
ii. make install: This target is used to install what needs to be installed, copying the files from the package’s tree to system-wide directories.
iii. make uninstall: This is opposite of “make install”. It erases the installed files.
iv. make clean: It erases from the build tree the files built by “make all”.
v. make distclean: It additionally erases anything ./configure created.
vi. make check: It is used to run the test suite, if any.
vii. make installcheck: It checks the installed programs or libraries, if supported.
viii. make dist: It recreate package-version.tar.gz from all the source files.

9. Common variables for Makefile.am: Following are some common varibales that can be used to create an initial Makefile.am.
i. bin_PROGRAMS: It specifies the <program> to be built and installed on …/bin directory.
ii. <program>_SOURCES: It lists one or more source files compiled to build the <program>.
iii. SUBDIRS: It lists all sub-directories to be built.
iv. dist_doc_DATA: It lists documentation files to be distributed and installed in ../doc directory.
v. <program>_DEPENDENCIES: It specifies dependencies, if any.
vi. <program>_<FLAGS>: Various compilation flags can be set.

vii. <program>_LDADD: It specifies extra objects and libraries to be added with <program>.
viii. <program>_LDFLAGS: It specifies extra linker flags for <program>.
10. An example Makefile.am:
      bin_PROGRAMS = hello
      hello_SOURCES = hello.c

Some characteristics of GNU Build System: Following are the some characteristics of GNU Build System:
1. VPATH Builds:
When source tree and build tree are different, such builds are called VPATH builds.
2. Cross-compilation: When a program is built on one platform and run on another platform is called cross-compilation.
3. Renaming: GNU build system allows to automatically rename executables etc. before installation.
4. Dependency tracking: GNU build system allows to track dependencies automatically.
5. Nested packages: Autoconfiscated packages can be nested to arbitrary depth.

Applying tools of GNU Build System to create the package: Following steps need to be performed for creating a package.
1. Ensure all necessary source, documentation and Makefiel.amS files have been created.
2. Run autoscan to create prelimanary configure.scan e.g. ..:~/<pkg-dir>$autoscan
3. If required, edit configure.scan to update package-name, version, invocation to AM_INIT_AUTOMAKE macro etc. and rename it to configure.ac.
4. Run aclocal to create aclocal.m4. This file contains macro definitions not part of standard autoconf macro e.g. ..:~/<pkg-dir>$aclocal.
5. Run autoheader to create config.h.in. This file is a template header for configure e.g ..:~/<pkg-dir>$autoheader.
6. Run autoconf to create configure from configure.ac and aclocal.m4 e.g. ..:~/<pkg-dir>$autoconf.
7. Run automake to create Makefile.inS from Makefile.amS e.g. ..:~/<pkg-dir>$automake.
8. Run configure to create Makefiles from Makefile.inS, config.h from config.h.in and perform various checks about the environment e.g. ..:~/<pkg-dir>$./configure.
9. Now run make to build the system e.g. ..:~/<pkg-dir>$make.
10. If make executes successfully, run make distcheck to create the package for distribution as a tarballe.g. ..:~/<pkg-dir>$make distcheck.
11. Run make install to install the package e.g. ..:~/<pkg-dir>$sudo make install.
12. Run make uninstall to uninstall the package e.g. ..:~/<pkg-dir>$sudo make uninstall.

Conclusion:
From User’s point of view:
It provides a standard procedure for installation. This procedure consists of only a small set of commands.
From Developer’s point of view: Creating portable distributions becomes easy. Updations or improvements, if any, can be done at one place.

Reference urls:
http://autotoolset.sourceforge.net/tutorial.html

http://www.gnu.org/software/automake/manual/automake.html

http://sources.redhat.com/autobook/

http://www.gnu.org/software/hello/manual/autoconf/autoscan-Invocation.html#autoscan-Invocation

http://www.lrde.epita.fr/~adl/autotools.html

http://en.wikipedia.org/wiki/GNU_build_system

http://www.dwheeler.com/essays/releasing-floss-software.html

http://www.dwheeler.com/essays/releasing-floss-software.html

http://www.gnu.org/software/hello/manual/autoconf/Autoconf-Macro-Index.html

http://www.devshed.com/c/a/Administration/Linux-Administration-Installing-Software/9/

http://www.control-escape.com/linux/lx-swinstall.html

http://www.unixguide.net/linux/faq/05.02.shtml

http://www.gnu.org/software/libtool/

Indianizing with Rupantar- An OpenOffice.org extension from CDAC, Mumbai

In a diverse country like India, localisation of information in the respective languages of the people works as a way of empowerment for the people. And, open source provides the necessary technical platform for delivering that information at some reasonable cost. CDAC Mumbai has long been involved in developing tools/technologies in the area of localisation and open source. These include Xlit, Matra, SuTra, Anumaan. New tool to join this list is Rupantar.

Rupantar is an extention for OpenOffice.org developed by the KBCS division of CDAC Mumbai. This extension works as a utility to write in Devnagri script, hence allows a user to type in Hindi and Marathi language. It uses the Rupantar scheme, also developed by CDAC Mumbai, to convert from Roman to Devnagri. More details about downloading and installing the extension can be accessed at http://extensions.services.openoffice.org/project/rupantar.

Related blog posts:

http://matra2.blogspot.com/2010/03/rupanatar-openoffice-writer-extension.html

http://blogs.siliconindia.com/light/Writing_in_HindiMarathi_Indianising_information_and_softwares-bid-cs2Li6d193012540.html

For feedback about the extension mailto:prakash@cdacmumbai.in.