This keyboard is designed to enable simple input in all European
languages which use Latin-script, and in most Latin-script languages
from the rest of the world.
The keyboard is written in KMN Keyboard Language by the KMN language
developer, Tavultesoft (http://www.tavultesoft.com). The keyboard
uses punctuation and letter keys in sequence to access diacritic and
other letters.
This port installs the keyboard so that it can be used through SCIM or
IBus KMFL IMEngine (textproc/scim-kmfl-imengine, textproc/ibus-kmfl).
It currently covers 120 languages including: Afrikaans, Albanian,
Balearic, Basque, Breton, Catalan, Croatian, Czech, Danish, Dutch,
Esperanto, Estonian, Faroese, Finnish, French, Gaelic, Galician,
German, Hungarian, Icelandic, Inuktitut, Italian, Kashubian, Ladin,
Latvian, Lithuanian, Maltese, Norwegian, Nynorsk, Polish, Portugese,
Romansch, Saami, Serbian, Slovak, Slovenian, Sorbian, Spanish,
Swedish, Tagalog, Turkish, Valencian, Vlaams, Walloon, Welsh and Zulu.
The keyboard is distributed under the terms of 3-clause BSD-licence.
KMFL aims to bring Tavultesoft Keyman functionality to *nix operating
systems. KMFL is being jointly developed by SIL International
(http://www.sil.org) and Tavultesoft (http://www.tavultesoft.com).
This is compiler for keyboard sources written in Keyman keyboard
language (.kmn files). Resulting binaries (.kmfl) can be used with
SCIM KMFL IMEngine (textproc/scim-kmfl-imengine).
The powerful KMN keyboard language supports contextual deadkeys,
pre- and post-processing of keystrokes, rules grouping, 'storing'
of character classes for use in similar rules, custom and Unicode
character constants, SIL Ethnologue language codes, etc.
Official Tavultesoft repository contains keyboards that cover more
than 220 languages. Significant number of them are open source.
Ported keyboards are textproc/scim-kmfl-*.
Often, XML messages and schemas are created by automatic tools. These
tools may provide very nice user interfaces, but tend to produce
horrible XML. If you have to read these ugly products, you are in for
pain. The purpose of this module (and the script "xmlrewrite" which is
part of this distribution) is to be able to rewrite XML messages and
Schema's into something maintainable.
The main difference between this module and other beautifiers is that
the clean-up is based on schema rules. For instance, it is permitted
to remove blanks around and inside integers, but not in strings.
Beautifiers which do not look into the schema have only limited
possibilities for cleanup, or may accidentally change the message
content.
SCIM Input-Pad is an on-screen input pad that can be used to input symbols
and key events very easily. It works with the SCIM input method platform.
SCIM Input-Pad comes with predefined files for common symbols, some special
keyboard events (such as dead keys and composing keys), punctuation technical
and graphics signs (including Braille alphabet), and many languages: Arabian,
Armenian, Balinese, Bengali, Buginese, Buhid, Cham, Chinese, Devanagari,
Ethiopic, Georgian, Gujarati, Gurmukhi, Hanunoo, Hebrew, Japanese, Kannada,
Kaya Li, Khmer, Korean, Lao, Lepcha, Limbu, Malayalam, Mongolian, Myanmar,
New Tai Lue, Ol Chiki, Oriya, Rejang, Russian (with all Cyrillic languages),
Saurashtra, Sinhala, Sundanese, Syloti Nagri, Tagalog, Tai Le, Tamil, Telugu,
Thai and Tibetian. It also provides an easy access to all Latin-based scripts.
Ding-libs provides utility functions to manipulate filesystem pathnames
(libpath_utils), a hash table which dynamically resizes to achieve
optimal storage and access time properties (libdhash), a data type to
collect data in a hierarchical structure for easy iteration and
serialization (libcollection), a dynamically growing, reference-counted
array (libref_array), and a library to process configuration files in
initialization format (INI) into a library collection data structure
(libini_config).
This module is a subclass of Test::Harness::Straps.
It uses callbacks in the straps object to construct a deep structure,
with all the data known about a test run accessible within.
It's purpose is to ease the processing of test data, for the purpose of
generating reports, or something like that.
The niche it fills is creating a way to access test run data, both from
a serialized and a real source, and to ease the querying of this data.
Schemas extend the notion of interfaces to detailed descriptions of Attributes
(but not methods). Every schema is an interface and specifies the public fields
of an object. A field roughly corresponds to an attribute of a Python object.
But a Field provides space for at least a title and a description. It can also
constrain its value and provide a validation method. Besides you can optionally
specify characteristics such as its value being read-only or not required.
The spreadsheet calculator sc is based on rectangular tables much like
a financial spreadsheet. When invoked it presents you with a table
organized as rows and columns of cells. If invoked without a file
argument, the table is initially empty. Each cell may have associated
with it a numeric value, a label string, and/or an expression (formula)
which evaluates to a numeric value or label string, often based on other
cell values.
The Ini file manager consists of a package, Config, which can read or write
informations from various configuration files known as "ini" files because
they have often the ".ini" extension. They are text files which look like
the following:
; Comment line
[Section 1]
a_string = abcd # a comment here...
a_number = +123.456 ; another comment
[Section 2]
a_string = efgh
For more examples in this format, just search files with the .ini extension
on a Windows-based computer.
The Extensible Messaging and Presence Protocol (XMPP) is an IETF standard
that provides a complete cross protocol messaging solution. The problem
with current IM solutions is that they are all proprietary and cannot
talk to each other. XMPP seeks to get rid of those barriers.
Net::XMPP is a collection of Perl modules that provide a Perl Developer
access to the XMPP protocol. Using OOP modules we provide a clean
interface to writing anything from a full client to a simple protocol
tester.