Free nachocalendar 0.23 software for linux

NachoCalendar is intended to provide a fully customizable calendar component for Java. NachoCalendar has three components: DateField, MonthPanel, and CalendarPanel.
DateField
This component can be used instead of a JFormattedField, in fact it uses one. You can write directly the date in it or display the Calendar to navigate between months. It extends from JPanel so can be used in any Swing/AWT application.
The DateField can also be used withing a JTable.
DatePanel
This component is used to show a month permanently. You can add convenient Listeners to react to day changes. It extends from JPanel also.
CalendarPanel
This is the last (for now) component. It shows many months at once. They are synchronized, so they are always ordered and always only one date is selected. This component can be oriented horizontal or vertical. You can select the quantity of months to show. The position of the scrollbar and the year changer can be changed.
Enhancements:
- JTableCustomizer: fixed DateRendererDecorator constructor
- Added moon phase support (thanks to Leo Welsh)
- Added "eternal scroll" to CalendarPanel (thanks to Leo Welsh)
- Demos updated
- Lots of small fixes

Thesaurus is a Perl module that maintains lists of associated items.

SYNOPSIS

use Thesaurus;

my $th = Thesaurus->new( -files => [ file1, file2 ],
-ignore_case => 1 );

@words = $th->find(vegan);

%words = $th->find( Faye );

foreach $word ( @{ $words{Faye} } )
{
#something ...
}

$th->add_file( file1, file2 );

$th->add( [ tofu, mock duck ] );

$th->delete( meat, vivisection );

Thesaurus is a module that allows you to create lists of related things. It was created in order to facilitate searches of a database of Chinese names in Anglicized form. Because there are various schemes to create phonetic representations of Chinese words, the following can all represent the same Chinese character:

Woo
Wu
Ng

Thesaurus can be used for anything that fits into a scalar by using the new method with no parameters and then calling the add method to add data.
Thesaurus also acts as the parent class to several child classes which implement various forms of persistence for the data structure. This module can be used on its own to instantiate an object that lives for the life of its scope.

Coronet project is a library which implements an epoll and coroutine based library that allows for async operations over certain kinds of files. Any file that supports poll(2) and the O_NONBLOCK fcntl(2) flag can be hosted; this includes like sockets and pipes.

The coronet library uses the epoll support available in the 2.6 series of Linux kernels, and the libpcl library for coroutine support.

SYNOPSIS

#include < coronet.h >

int conet_init(void);
void conet_cleanup(void);
int conet_readsome(struct sk_conn *conn, void *buf, int n);
int conet_read(struct sk_conn *conn, void *buf, int n);
char *conet_readln(struct sk_conn *conn, int *lnsize);
int conet_write(struct sk_conn *conn, void const *buf, int n);
int conet_printf(struct sk_conn *conn, char const *fmt, ...);
struct sk_conn *conet_new_conn(int sfd, coroutine_t co);
void conet_close_conn(struct sk_conn *conn);
int conet_set_timeo(struct sk_conn *conn, int timeo);
int conet_mod_conn(struct sk_conn *conn, unsigned int events);
int conet_socket(int domain, int type, int protocol);
int conet_connect(struct sk_conn *conn, const struct sockaddr *serv_addr, socklen_t addrlen);
int conet_accept(struct sk_conn *conn, struct sockaddr *addr, int *addrlen);
struct sk_conn *conet_create_conn(int domain, int type, int protocol, coroutine_t co);
int conet_events_wait(int timeo);
int conet_events_dispatch(int evdmax);

CK-ERP is an accounting/ERP/CRM system that runs on top of eGroupWare.

CK-ERP project provides admin, contact management, customer relationship, customer self service, vendor relationship, ledger, bank reconciliation, inventory, service, AR, AP, SO, PO, quotation, POS for cashiers, POS for managers, HR, staff self service, and payroll functions.

Whats New in This Release:

1.Connector for MirrorMed
2.Connector for ClearHealth
3.Connector for OpenEMR
4.Connector for osCMax
5.Connector for XOOPS updated to provide group-module ACL control
6.locale-aware monetary figure printing
7.Improvement to sample cheque
8.Bug fixes to rectify,
- Error when searching for untranslated phrases (aTutor)
- Error when converting TIPs into translated phrases
- orphaned temp tables
- wrong official quotation (with tax) when bulk despatched
- error in ck-bank control report (suspense item total)
- error implementing ck-bank bulk update

RPCAP is a Remote Packet Capture system. It enables you to run a packet capture program (the server) on a target computer, which will sniff the network traffic on that system, and uplink the captured packets to another host (the client), where the captured packets can be processed, analysed and archived . The rpcap system thus consists of two separate processes, the server (or agent) which captures network traffic on a remote system, and a client, which receives and processes these packets. The server code is a standalone executable program which uses the libpcap packet capture library to capture network traffic. The client is actually a library called librpcap, which is linked to a user program and used on the client system in a manner identical to libpcap, to receive and process the packets which are captured.
The librpcap client library exposes a subset of the pcap API as defined in the pcap (3) manpage. The API is used in a manner identical to that of libpcap, so that any programs which do not use the libpcap functions not present in rpcap can directly link to rpcap in place of pcap. The API functions as a set of pcap-compatible wrapper functions over a Sun RPC interface to the remote server, which invoke the corresponding libpcap functionality on it.
At this time, rpcap has been built and tested only on Linux on Intel platforms. However, it should build on any UNIX like system that supports multithreading and has the RPC libraries and utilities available, so that it should be possible to build it on most systems. Please note however that there are a couple of bugs in the code (all my own!) that currently restrict it to little-endian systems. I will fix this ASAP.
Enhancements:
- New code release v.0.23 alpha
- added GNU autotools based build (autconf/ automake/ libtool)
- pcap_geterr rewritten
- pcap_compile fixed to accept null strings for tcpdump compatibility
- pointer issues with pcap_compile and pcap_open_live resolved
- made the code tcpdump compatible so that tcpdump now builds against librpcap
- added a port of tcpdump to rpcap

D is a high-level language derived from C and C++ but is not backwards-compatible with either. GDC is a frontend for D written for GCC.
Supported Systems:
GCC 3.3.x, 3.4.x, 4.0.x
Linux (tested on Red Hat 7.2, 8)
Mac OS X 10.3.x, 10.4.x
FreeBSD 5.2.1
Cygwin
MinGW
AIX (tested on 5.1)
Similar versions should work and other Unix platforms may work. Although the compiler will probably work on most 32-bit architectures, the D runtime library will still need to be updated to support them.
Enhancements:
- Support for 64-bit targets was added.
- Multilib support was added.
- DMD was updated to 1.007.
- Minor bugs were fixed.

Test::STDmaker is a Perl module to generate test scripts, demo scripts from a test description short hand.

SYNOPSIS

#######
# Procedural (subroutine) interface
#
use Test::STDmake qw(find_t_roots get_data perl_command);

@t_path = find_t_paths()
$date = get_date();
$myperl = perl_command();

#####
# Class interface
#
use Test::STDmaker

$std = new Test::STDmaker( @options ); # From File::Maker

$success = $std->check_db($std_pm);
@t_path = $std->find_t_paths()
$date = $std->get_date();
$myperl = $std->perl_command();

$std->tmake( @targets, %options );
$std->tmake( @targets );
$std->tmake( %options );

######
# Internal (Private) Methods
#
$success = $std->build($std_driver_class);
$success = $std->generate();
$success = $std->print($file_out);

The Test::STDmaker program module provides the following capabilities:
Automate Perl related programming needed to create a test script resulting in reduction of time and cost.

Translate a short hand Software Test Description (STD) file into a Perl test script that eventually makes use of the Test module.

Translate the sort hand STD data file into a Perl demo script that demonstrates the features of the the module under test.

Provide in the POD of a STD file information required by a Military/Federal Government Software Test Description (STD) document that may easily be index and accessed by automated Test software. ISO, British Military require most of the same information, US agencies such as the FAA. The difference is that ISO, British Military do not dictate detail format. US agencies such as FAA will generally tailor down the DOD required formats.

Thus, there is an extremely wide variation in the format of the same information among ISO certified comericial activities and militaries other than US. Once the information is in a POD, different translators may format nearly exactly as dictated by the end user, whether it is the US DOD, ISO certified commericial activity, British Military or whoever. By being able to provide the most demanding, which is usually US DOD, the capabilities are there for all the others.

The Test::STDmaker package relieves the designer and developer from the burden of filling out word processor boiler plate templates (whether run-off, Word, or vi), counting oks, providing documentation examples, tracing tests to test requirments, making sure it is in the proper corporate, ISO or military format, and other such extremely time consuming, boring, development support tasks. Instead the designers and developers need only to fill in a form using a test description short hand. The Test::STDmaker will take it from there and automatically and quickly generate the desired test scripts, demo scripts, and test description documents.

Look at the economics. It does not make economically sense to have expensive talent do this work. In does not even make economically sense to take a bright 16 year, at mimimum wage and have him manually count oks. Perl can count those oks much much cheaper and it is so easily to automated with Perl. And something like this were you are doing it year in and year out, the saving are enormous. To a program manager or contract officer, this is what programming and computers are all about, saving money and increasing productivity, not object oriented oriented programing, gotos or other such things.

The Test::STDmaker class package automates the generation of Software Test Descriptions (STD) Plain Old Documentation (POD), test scripts, demonstrations scripts and the execution of the generated test scripts and demonstration scripts. It will automatically insert the output from the demonstration script into the POD -headx Demonstration section of the file being tested.

Mac::Path::Util is a Perl module that can convert between darwin and Mac paths.

SYNOPSIS

use Mac::Path::Util;

my $path = Mac::Path::Util->new( "/Users/foo/file.txt" );
my $mac_path = $path->mac_path;

THIS IS ALPHA SOFTWARE. SOME THINGS ARE NOT FINISHED.

Convert between darwin (unix) and Mac file paths.

This is not as simple as changing the directory separator. The Mac path has the volume name in it, whereas the darwin path leaves off the startup volume name because it is mounted as /.

Mac::Path::Util can optionally use Mac::Carbon to determine the real startup volume name (off by default) if you have installed Mac::Carbon. You can use this module on other platforms too. Once the module has looked up the volume name, it caches it. If you want to reset the cache, use the clear_startup() method.

Colons ( ":" ) in the darwin path become / in the Mac path, and forward slashes in the Mac path become colons in the darwin path.

Mac paths do not have a leading directory separator for absolute paths.
Normally, Mac paths that end in a directory name have a trailing colon, but this module cannot necessarily verify that since you may want to convert paths.