Free international components unicode 3.6 software for linux

International Components for Unicode provides a Unicode implementation, with functions for formatting numbers, dates, times, and currencies (according to locale conventions, transliteration, and parsing text in those formats).
It provides flexible patterns for formatting messages, where the pattern determines the order of the variable parts of the messages, and the format for each of those variables. These patterns can be stored in resource files for translation to different languages. Included are more than 100 codepage converters for interaction with non-unicode systems.
Main features:
- Text: Unicode text handling, full character properties and character set conversions (500+ code pages)
- Analysis: Unicode regular expressions; full Unicode sets; character, word and line boundaries
- Comparison: language sensitive collation and searching
- Transformations: normalization, upper/lowercase, script transliterations (50+ pairs)
- Locales: comprehensive data (230+) & resource bundle architecture
- Complex Text Layout: Arabic, Hebrew, Indic and Thai
- Formatting and Parsing: multi-calendar and time zone,dates, times, numbers, currencies, messages
Enhancements:
- This is a major release, with new features, new APIs, and many bugfixes in data and code.
- ICU uses and supports Unicode 5.0, which is the latest major release of Unicode.
- CU uses and supports data from Common Locale Data Repository (CLDR) 1.4, which includes many improvements in quality and quantity of data.
- A charset detection framework was added, which provides heuristics for detecting the charset for unlabeled sequences of bytes.
- Other performance and feature enhancements were added.

Simple components for Ada library 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 library 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.
As a special exception, if other files instantiate generics from this unit, or you link this unit with other files to produce an executable, this unit does not by itself cause the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the executable file might be covered by the GNU Public License.
Enhancements:
- Functions Is_In were added for doubly-linked webs and lists. GPS project files were added for GNAT users.

UJAC provides a collection of JAVA components which may be useful in some projects.
Each component is designed for easy use, easy integration into existing projects, extensibility and last but not least efficiency.
Enhancements:
Chart Module:
- Moved common types into the interface org.ujac.util.UjacTypes.
Form Module:
- Fixed handling of default values.
Print Module:
- At < insert-document > tag: Fixed offset handling.
- At tags < background-image > & < watermark >: Removed code that forces the existance of a page for the background image.
Utils Module:
- Added interface UjacTypes, which defines common types, used inside the UJAC project.
- Added class UjacTypeHelper, which provides methods to convert data type IDs to Strings and vice versa.
- Moved class XmlUtils into sub package org.ujac.util.xml
SimplePatternMatcher:
- Fixed handling of empty patterns (always matches).
Table:
- Moved common types into the interface org.ujac.util.UjacTypes.
TemplateInterpreter:
- Fixed handling of underscores that are not part of statements.
- Added class BaseObjectSerializer, which provides basic code to easily read/write Objects from/to XML.
Web Module:
- Added support for PageTiles to ActionContext.
- Added < tile > tag which includes PageTiles into JSPs.
- Added class WebFormSerializer, which reads/writes WebForm definitions from/to XML.
- Added support for dynamic form registration from XML definitions.
- Fixed bugs in form field value handling.
- Fixed bugs in form field rendering.

POE::Component::IRC is a fully event-driven IRC client module.

SYNOPSIS

# A simple Rot13 encryption bot

use strict;
use warnings;
use POE qw(Component::IRC);

my $nickname = Flibble . $$;
my $ircname = Flibble the Sailor Bot;
my $ircserver = irc.blahblahblah.irc;
my $port = 6667;

my @channels = ( #Blah, #Foo, #Bar );

# We create a new PoCo-IRC object and component.
my $irc = POE::Component::IRC->spawn(
nick => $nickname,
server => $ircserver,
port => $port,
ircname => $ircname,
) or die "Oh noooo! $!";

POE::Session->create(
package_states => [
main => [ qw(_default _start irc_001 irc_public) ],
],
heap => { irc => $irc },
);

$poe_kernel->run();
exit 0;

sub _start {
my ($kernel,$heap) = @_[KERNEL,HEAP];

# We get the session ID of the component from the object
# and register and connect to the specified server.
my $irc_session = $heap->{irc}->session_id();
$kernel->post( $irc_session => register => all );
$kernel->post( $irc_session => connect => { } );
undef;
}

sub irc_001 {
my ($kernel,$sender) = @_[KERNEL,SENDER];

# Get the components object at any time by accessing the heap of
# the SENDER
my $poco_object = $sender->get_heap();
print "Connected to ", $poco_object->server_name(), "n";

# In any irc_* events SENDER will be the PoCo-IRC session
$kernel->post( $sender => join => $_ ) for @channels;
undef;
}

sub irc_public {
my ($kernel,$sender,$who,$where,$what) = @_[KERNEL,SENDER,ARG0,ARG1,ARG2];
my $nick = ( split /!/, $who )[0];
my $channel = $where->[0];

if ( my ($rot13) = $what =~ /^rot13 (.+)/ ) {
$rot13 =~ tr[a-zA-Z][n-za-mN-ZA-M];
$kernel->post( $sender => privmsg => $channel => "$nick: $rot13" );
}
undef;
}

# We registered for all events, this will produce some debug info.
sub _default {
my ($event, $args) = @_[ARG0 .. $#_];
my @output = ( "$event: " );

foreach my $arg ( @$args ) {
if ( ref($arg) eq ARRAY ) {
push( @output, "[" . join(" ,", @$arg ) . "]" );
} else {
push ( @output, "$arg" );
}
}
print STDOUT join , @output, "n";
return 0;
}

POE::Component::IRC is a POE component (whod have guessed?) which acts as an easily controllable IRC client for your other POE components and sessions. You create an IRC component and tell it what events your session cares about and where to connect to, and it sends back interesting IRC events when they happen. You make the client do things by sending it events. Thats all there is to it. Cool, no?

[Note that using this module requires some familiarity with the details of the IRC protocol. Id advise you to read up on the gory details of RFC 1459 before you get started. Keep the list of server numeric codes handy while you program. Needless to say, youll also need a good working knowledge of POE, or this document will be of very little use to you.]
The POE::Component::IRC distribution has a docs/ folder with a collection of salient documentation including the pertinent RFCs.

POE::Component::IRC consists of a POE::Session that manages the IRC connection and dispatches irc_ prefixed events to interested sessions and an object that can be used to access additional information using methods.

Sessions register their interest in receiving irc_ events by sending register to the component. One would usually do this in your _start handler. Your session will continue to receive events until you unregister. The component will continue to stay around until you tell it not to with shutdown.

The SYNOPSIS demonstrates a fairly basic bot.

Swing has lot of components built-in but still some are missing. L2FProd.com Common Components project provides the developer community with these missing components, components inspired (copied?!) from modern user interfaces.
Editing properties
This is the main job of the PropertySheet component, it puts together a list of properties and their editors. Each property is given a name, a type, a description.It also supports JavaBeans through BeanInfos and PropertyDescriptors.
Building task oriented applications
Lot of recent applications bring contextual item lists from which you can pick tasks related to the current selection or context. The JTaskPane and JTaskPaneGroup deliver this feature to java applications.
Organizing the option dialog
Even if this is not the primary goal of the JButtonBar, this is where you often find it. It is a bar made of buttons [sic], you have seen it in Mozilla Firebird, IntelliJ.
Build the nextgen e-mail client
the JOutlookBar (seen in...Outlook) stacks components together and allows only one of the stack to be visible at a given time. The component extends the JTabbedPane, no surprise regarding its API
Selecting fonts and directories
Surprisingly Swing has no font chooser and using the original JFileChooser to select a directory is kind of not so user friendly...well, you know how it works. JFontChooser and JDirectoryChooser address these two issues.
Enhancements:
- A change in 6.9 broke the look and feel of several custom components: these components would use only the default "basic" look, instead of the one associated with the currently installed Swing look and feel.
- This update is recommended for all users who upgraded to 6.9.

Midgard Components Framework (also called MidCOM) is an advanced component architecture which extends the Midgard Web content management framework. It provides mechanisms for building a Web site using components without much need for writing code to glue all this together.
The administration site gets built automatically by using those components. Goodies like a caching engine and subrequests make site building even easier.
Enhancements:
- Full multilingual content support, performance enhancements, and support for Midgard builds that have the legacy API disabled were added.

PoJoe Component Libraries project is a set of Java POJO components, originally developed for OSMQ. Developers have found these components useful in building robust enterprise applications.
Of note are: a FIFO queue that utilizes memory until a size threshold is reached, paging overflow elements to a disk cache; a dynamic discovery mechanism for locating remote processes by name over an IP network, eliminating the need to identify a remote service with a specific host computer; and a set of peer-to-peer async message components that support n concurrent message publishers for each named subscriber.
Enhancements:
- Minor enhancements and bugfixes, and changing the license from GNU Lesser to Apache 2.0.

rxvt-unicode is a clone of the well known terminal emulator rxvt, modified to store text in Unicode (either UCS-2 or UCS-4) and to use locale-correct input and output. rxvt-unicode also supports mixing multiple fonts at the same time, including Xft fonts.
Main features:
- Stores text in Unicode (either UCS-2 or UCS-4).
- Uses locale-correct input, output and width: as long as your system supports the locale, rxvt-unicode will display correctly.
- Daemon mode: one daemon can open multiple windows on multiple displays, which improves memory usage and startup time considerably.
- Crash-free. At least I try, but rxvt-unicode certainly crashes much less often than rxvt and its many clones, and reproducible bugs get fixed immediately.
- Completely flicker-free.
- Full combining character support (unlike xterm :).
- Multiple fonts supported at the same time: No need to choose between nice japanese and ugly latin, or no japanese and nice latin characters.
- Supports Xft and core fonts in any combination.
- Can easily be embedded into other applications.
- All documentation accessible through manpages.
- Locale-independent XIM support.
- Many small improvements, such as improved and correct terminfo, improved secondary screen modes, italic and bold font support, tinting and shading.
Version restrictions:
- Complex script support, such as arabic or tibetian - more info is needed. (use mlterm)
- Left-To-Right rendering - more info is needed. (use mlterm)
- Tabs (although a supplied perl script implements a tabbed shell). (use mrxvt)
- IIIMF (Intranet/Internet Input Method Framework) support. (use scim)
Enhancements:
- This release optionally takes advantage of libafterimage for much improved image format and transparency support: transparency is now officially supported.
- Some new options are available: "skipScroll" hides fast scrolling text, "urgentOnBell" sets urgent hints to use an ASCII bell, and the "iso14755_52" resource controls the keycap insert mode.
- Portability has been enhanced, and many minor bugs have been fixed.