Free palm software for linux

Palm::Progect::Converter::Text is a Perl module to convert between Progect databases and Text files.

SYNOPSIS

my $converter = Palm::Progect::Converter->new(
format => Text,
# ... other args ...
);

$converter->load_records();

# ... do stuff with records

$converter->save_records();

This converts between Text files and Palm::Progect records and preferences.
The Text format used for import/export looks something like this:
[x] Level 1 Todo item
[10%] Child (progress)
. Child of Child (informational)

[80%] (31/12/2001) Progress item
[ ] Unticked action item
Here is a summary of the various types of records:
[ ] action type
[x] completed action type
< > action type with todo link
completed action type with todo link

[80%] progress type
[4/5] numeric type

. info type

[ ] [5] action type with priority
[ ] (15/7/2001) action type with date

[80%] [5] (15/7/2001) {category} progress type with priority and date and category

[80%] [5] (15/7/2001) {category} progress type with priority and date and category >

Funambol is open source mobile application server software that provides push email, address book and calendar (PIM) data synchronization, application provisioning, and device management for wireless devices and PCs, leveraging standard protocols. For users, this means BlackBerry-like capabilities on commodity handsets.
This project is also a software development platform for mobile applications. It provides client and server side Java APIs, and facilitates the development, deployment and management of any mobile project. Funambol is the de facto standard implementation of the Open Mobile Alliance Data Synchronization and Device Management protocols (OMA DS and DM, formerly known as SyncML).
Main features:
- Funambol Data Synchronization Server: a mobile application server providing synchronization services for wireless clients and PCs, including push email.
- Funambol Device Management: an OMA DM server to remotely manage mobile devices.
- Funambol Connectors: gateways to file systems, databases, email systems, and applications for two-way synchronization with existing data assets.
- Funambol Client Plug-ins: protocol extenders and clients for Outlook, Windows Mobile, BlackBerry, Palm and iPod so users can synchronize their email messages and PIM data (address book, calendar, tasks and notes) with the server.
- Funambol Software Development Kit: tools to develop sometimes-connected mobile applications on devices (in Java - J2SE and J2ME - and C++) and to add data sources to the server.
Enhancements:
- Major feature enhancements

Plans is a powerful and flexible Web calendar. Plans has features like recurring events, merged calendars, event icons, custom themes and templates, MS Outlook export, SQL or flat-file data storage, and browser-based management.
Main features:
Multiple Calendars
- One installation of plans can support many calendars.
- Calendars can share information with each other.
- Each calendar is managed independently (unique password, custom options, custom look & feel).
- Multiple calendars running on the same installation of plans can be "embedded" in completely different websites.
Recurring Events
- Plans uses a powerful and flexible recurring event model.
International Support
- Plans supports multiple languages.
- Weeks can start on days other than Sunday.
- Plans supports arbitrary date formats (mm/dd/yy, dd/mm/yy, etc.)
Database Support
- Plans can store data in flat files or an SQL database.
Sharp-looking
- Plans is the nicest-looking web calendar.
- Plans has several downloadable themes available.
- CSS-based layout makes it easy to match the colors & fonts with your website.
Open Source
- Plans is licensed under the GPL. You can freely modify the code for your needs. Many organizations have done so.
Extendable
- Plans architecture allows add-ons and standalone programs to re-use its framework.
- Plans can export events to other platforms, including MS Outlook and Palm.
Template-based design
- Plans uses HTML templates to allow easy customization of the look & feel.
- Each calendar can have its own custom template, even located on a different server.

Apollo is an open-source developer test skeleton toolkit for Web Start. Apollo lets you turbo-charge Web Start apps without Web Start to speed up your compile/run/test/debug/goof-off cycle avoiding the hassle of stuffing, signing, uploading or downloading your jars every time you rearrange a comma in your source code.

Apollo is not a replacement for Web Start (OpenJNLP, NetX or any other app launcher). Apollo is more like a test emulator (such as POSE - Palm OS Emulator) helping you to speed up your development between full-blown, time-consuming, irreplaceable, real Web Start workouts.

Apollo cant fake every Web Start bell and whistle (e.g. download on demand) but outshines Suns Web Start dumb dev pack stubs that merely let you compile your source. Apollo lets you popup your household browser and more without calling in the Web Start machinery.

Apollo consists of a jar that you can use to replace Suns javax.jnlpx stubs residing in jnlp.jar that only allow you to compile your code and that ship with Suns Web Start dev pack.

Apollo is a thin wrapper around Suns javax.jnlpx services. If your app runs under Web Start Apollo will automatically detect it and pass all runtime service calls (such as poping up a browser window) on to the Web Start engine. If your app, however, runs without Web Start Apollo will kick in and mimick Web Starts runtime services.

To use Apollo replace all javax.jnlpx imports with apollo. Example:

import javax.jnlpx.*; // Web Start only
import apollo.*; // Web Start plus Apollo-propelled stand-alone launching

To spare you from learning yet another API set Apollo reuses all runtime service class and method names. The only exception is Apollos ServiceManager class that adds type-safe methods to lookup pre-defined runtime services (e.g. lookupBasicService()) avoiding unexpected runtime errors and reducing source code bloat. Example:

import javax.jnlp.*
...
BasicService bs = (BasicService) ServiceManager.lookup( "javax.jnlp.BasicService" );
bs.showDocument( new URL( "http://vamphq.com/times" ) );

becomes

import apollo.*;
...
BasicService bs = ServiceManager.lookupBasicService();
bs.showDocument( new URL( "http://vamphq.com/times" ) );

or

import apollo.*;
...
ServiceManager.lookupBasicService().showDocument( new URL( "http://vamphq.com/times" ) );

Apollo lets you configure the codebase or the online/offline status of your app if you want to run it without Web Start but still use BasicService.getCodeBase() or Basic.isOffline().

By default BasicService.isOffline() returns false (meaning your app is online). If you want to change the setting you can pass the property apollo.offline=true to your app. As an alternative you can also add apollo.properties to your classpath or bundle it with your apps jar in the root directory. Inside the apollo.properties file add the apollo.offline property to match your desired setting. Note, that all apollo properties only work if your app runs without Web Start.

By default BasicService.getCodeBase() uses the working directory returned by the system property user.dir. To use a different codebase pass the property apollo.codebase=your_url_here to your app. As an alternative you can also add the apollo.codebase property to the apollo.properties file in your apps root directory where Apollo picks it up if you run your app without Web Start.

Pilot-QOF converts Palm databases to queriable objects. A Palm database record is an instance of the object, called an Entity.
Objects are collated to form one data source, called books, that can contain any number of different objects - depending on the application running QOF. Pilot-QOF writes selected palm data to QSF XML offline storage and running SQL-type queries on the live data or XML file.
Pilot-QOF currently supports the four main applications (Expenses, Contacts, Calendar and ToDo) and work is now progressing to support other free software Palm databases like PCash and FreeCoins.
Liberate your Palm data to use in any number of other applications and scripts.
QOF provides a set of C language utilities for performing generic structured complex queries on a set of data held by a set of C/C++ objects. This framework allows programmers to add query support to their applications without having to hook into a SQL Database.
QOF provides the framework, the new QOF XML backend (QSF) provides the off-line storage and a format for a data stream between different applications, including converting QOF objects.
QOF frees the data from the application, allowing queries, data mining, abstraction and data interchange without having to recompile the original application, let alone program the filters. Central to QOF are the ideas of databases and objects.
A Palm database is an object in QOF. A Palm database record is an instance of the object, called an Entity. QOF then collates all supported objects to form one data source that can be queried. QOF allows the programmer to easily find all other instances of any one type, just by having one instance of that type.
Objects are collected in books and a book can contain any number of different objects - depending on the application running QOF. The book is the central data source within QOF and a book can be queried or written out to XML using the QOF Serialisation Format: QSF.
In real terms, QOF will be running as a framework around the libpisock library from pilot-link so the offline storage, (QSF XML), will be written by pilot-qof. Pilot-link itself does not directly support users who cross timezones with their Palm - it may be wise that users are reminded that if timezone issues are important to their DateBook or Expenses data, the user should take the sensible precaution of changing the Palm Preferences to use the same timezone as the computer running pilot-qof.
Once in QOF, all dates and times are UTC so the QSF XML files can be freely exchanged across timezones without complication.
Pilot-QOF is free software relased under the GPL license.
Enhancements:
- Ensure all help output is available for translation.

Hastymail is yet another webmail IMAP client written in PHP. Hastymail is designed for speed, simplicity, RFC compatibility and security.
Our goal is to create a simple interface with powerful but easy to use options that make managing your IMAP account effective and fast. Hastymail is NOT groupware. We are focused on being a functional and fast webmail client.
Main features:
- Hastymail provides an attractive interface and modest feature set with very few browser requirements. By default Hastymail does NOT use HTML frames, Javascript, or cookies.
- All Hastymail needs from PHP is session support, but additional functionality can be used or internal functions replaced with configuration options
- Hastymail works across HTTPS transparently and if using PHP 4.3+ with openssl support can connect to IMAP, LDAP, and SMTP servers using TLS/SSL.
- Hastymail combines CSS for themes and templates for layout giving sites an easy way to customize the interface. As of 1.5 Hastymail has 3 template sets and many themes.
- Lots of site-wide options can be tweaked to make Hastymail work with your environment.
- Hastymail is 100% PHP5 compatible
All browsers from IE6 to Lynx to Dillo are supported. Currently we have been testing Hastymail with:
- Mozilla, (current versions, many platforms)
- Internet explorer, 5.0, 5.5, 6.0
- Netscape 4.x,7
- Galeon (current versions)
- Firefox (current versions)
- Dillo 0.6.6 - current
- Lynx 2.8.4 and up
- Blazer on Palm OS
- WebPro3 on Palm OS
- Several others like Opera, Skipstone, Links...