Free ajax requests software for linux

PITA::XML::Request is a request for the testing of a software package.

SYNOPSIS

# Create a request specification
my $dist = PITA::XML::Request->new(
scheme => perl5,
distname => PITA-XML,

# The package to test
file => PITA::XML::File->new(
filename => Foo-Bar-0.01.tar.gz,
digest => MD5.0123456789ABCDEF0123456789ABCDEF,
),

# Optional fields for repository-based requests
authority => cpan,
authpath => /id/A/AD/ADAMK/Foo-Bar-0.01.tar.gz,
);

PITA::XML::Request is an object for holding information about a request for a distribution to be tested. It is created most often as part of the parsing of a PITA::XML XML file.

It holds the testing scheme, name of the distribition, file information, and authority information (if the distribution was sourced from a repository such as CPAN)

AJAX Image Dump System or AIDS for short, is a image dump system written in PHP and Javascript using MYSQL databases, with AJAX functionality using the jquery library and the MOD_REWRITE Apache module to shorten down URL-addresses. The system also uses the XTemplate.
Enhancements:
- Fixed the bug causing the second image uploaded to fail, and send the user to the upload.php page.
- See https://sourceforge.net/tracker/index.php?func=detail&aid=1735653&group_id=198562&atid=965971 for more info regarding this bug.
- Got more of the system onto the xtemplatephp-system and added support for multiple languages, translation will begin shortly.
- Better support for adding other languages will come in one of the next releases. (See langNO.php for the current running language).
- Changed the link for the pictures after a uploading to point to the right page (removed .jpg at the end of the link).

RAJAX is an approach to remove the repetitive code that coders need to add for simple AJAX applications. RAJAXs main goal is to create a library that at runtime will generate a proxy JavaScript class to a server side Java class allowing the web programmer to invoke remote methods in the local JavaScript object.
The project is composed by an network abstraction layer and other sub components such as a Model-View-Controller Framework totally based in AJAX and JavaScript. Since this the project is quite dynamic other components will be added from research experiences or user requests.
Installation:
- Note: Requires Java Runtime Environment (JRE) 1.5 or higher. Requires a Servlet 2.4 compatible container, Tomcat 5.5.x/6.x recomended.
- Add rajaxlib.jar to your webapp WEB-INF/lib.
- Add js/* to your webapp web/js.
- Alternatively grab the sample webapp from the repository and start from it.
Enhancements:
- A Servlet dispatcher was added, so there is no need to declare each bean as a servlet in web.xml.
- RAJAX objects are POJOs and can be tested with JUnit without running a container.
- Nimble MVC now uses the concept of the Observer pattern for event attaching and detaching.
- The code for the XSLT processor on the server side when the browser cannot handle the action locally was started.

Ajaxdo is a Ajax persistent Data Objects framwork.
Ajax Data Objects (ajaxdo) provides an easy database persistency framework for JavaScript objects. Ajaxdo enables runtime loading, saving, deleting, and listing of JavaScript objects stored on the server database.
Using Ajaxdo can dramatically reduce server side code and make a Web 2.0 application port easily from one server-side programming language to another.
Enhancements:
- This release adds a fully functional Java server-side implementation in addition to the pre-existing PHP server-side implementation.
- Ajaxdo enabled applications can now work in a JSP/JDBC environment and port easily from PHP to Java and vice versa.

PAJAX project is a framework that facilitates the creation of remote PHP objects in JavaScript.
You might have heard of AJAX by now. I first saw the term coined in this article by adaptive path and is short for Asynchronous JavaScript + XML. This technique came into the spotlight with Google Suggest and Google Maps.
It relies on a little known JavaScript object named XMLHttpRequest. This object allows for synchronous and asynchronous HTTP request to be performed from within a browser via JavaScript.
Wanting to play with this, I deiced to create a framework that would allow simple PHP objects to be made remotable in JavaScript, using XMLHttpRequest.
Introducing JSON
AJAX technique usually implies using XML as a data exchange format. While suitable as a format to marshal parameters back and forth, there is another format that is much more suitable for JavaScript. JSON (JavaScript Object Notation) is an alternate markup format that can be used to describe structured text data. It is based on the internal format used to store JavaScript Objects.
Object Request Broker pattern
CORBA and RMI are two well known instances of the ORB (Object Request Broker) pattern. In this pattern, objects in a distributed environment need to call methods of remote objects. For remote call to work, many details must be just right. This pattern covers the aspect of building an infrastructure that hides all the complexity from the caller standpoint.
Enhancements:
- Fixes a remote code injection vulnerability.

myAJAX is an AJAX Javascript OOP implementation.
Object myAJAX
PARAMETERS
url = pages URL
urlParameters = pages parameters
method = HEAD, GET or POST with a defaul value of GET
refreshInterval = sets the execution of AJAX request periodically for values not zero; it is expressed in msec.
onProgressFunction = function called on interactive mode
onReadyFunction = function called when servers response is constants.serverStatus.OK
onErrorFunction = function called when servers response is other than constants.serverStatus.OK
InnerHtmlId = is the ID of an html element who will be populated with the text response
PROPERTIES
same as PARAMETRS
METHODS
namedInstance(instanceName) = create and/or just return specified instance name
urlEncode(urlParameters) = encode URL parameters
sendRequest() = performs AJAX request
abortRequest() = aborts AJAX request
onProgressFunction(new String(responseText), new Number(myContentLength));
onReadyFunction(Array(ResponseHeaders) | new myXML() | new String(responseText));
onErrorFunction(new String(statusText),new Number(status));
Object myXML
PARAMETERS
xmlDoc = XML object returned by responseXML
PROPERTIES
same as PARAMETRS
METHODS
rootNodeName = returns root nodes name of the XML document
rootNodeObject = returns root node object of the XML document
nodeObject(nodeName, index=0 | nodeObj) = returns node object of the XML document
nodeValue(nodeName,index=0 | nodeObj) = returns nodes value
nodeAttribute=function(nodeName, index, attribute | nodeObj, attribute) = returns nodes attribute
nodesByTagName(tagName) = returns a list of nodes with specified tag name
Object cookie
PARAMETERS
name = cookies name
PROPERTIES
none
METHODS
set(value, days) = sets cookies value
get() = get cookies value
delete() = delete cookie
Enhancements:
- Adding dragging facility for HTML elements - see `myAJAX.draggable` function.
- Redefine `myXML` object definition into `myAJAX.XML` and `XMLHttp` object definition into `myAJAX.XMLHttp`, while keeping backward compatibility.
- Adding `$getPosition` method for `HTMLElement`.
- Adding `$scroll` and `$getMousePosition` methods for `window`.
- Redesign of `$captureEvent` and `$releaseEvent` methods for `HTMLElement`.
- Renaming `$style` `HTMLElement`s method into `$getStyle`.
- Renaming `$opacity` `HTMLElement`s method into `$setOpacity`.

Saja is a lightweight AJAX scripting engine for PHP with secured function calls. Saja is designed for the speedy creation of simple, intuitive, and maintainable AJAX applications, without the need to write any JavaScript.