rsence-pre 2.1.0.1.pre

data/docs/PluginBundleInfo.rdoc

@@ -0,0 +1,173 @@
+= Overview
+
+Each {file:PluginBundles plugin bundle} should contain an +info.yaml+ file.
+
+The main purpose of the +info.yaml+ file is to provide meta-information to the {RSence::PluginManager PluginManager} about the bundle.
+
+Using ruby notation, the defaults look like this:
+  @info = {
+    # The human-readable product name of the package
+    :title => bundle_name.to_s.capitalize,
+  
+    # The human-readable version of the package
+    :version => '0.0.0',
+  
+    # A brief description of the package (rdoc formatting supported)
+    :description => 'No Description',
+  
+    # A flag (when false) prevents the plugin from automatically reload when changed.
+    :reloadable => true,
+  
+    # Dependency, by default the system category (built-in plugins).
+    # A nil ( "~" in yaml ) value means no dependencies.
+    :depends_on     => :system,
+  
+    # Optional, name of category. The built-in plugins are :system
+    :category       => nil
+  }
+
+
+Using YAML notation, the same data would looks like this, if the name of the bundle in this example is "example_plugin":
+  !!!yaml
+  :title: Example_plugin
+  :version: 0.0.0
+  :description: 'No Description'
+  :reloadable: true
+  :depends_on: :system
+  :category: nil
+
+When defining your own, not all of the key-value pairs need to be entered, just the ones that are different from the defaults. In this example the +:version+, +:description+ and +:title+ are defined:
+  !!!yaml
+  :title: Example Plugin
+  :version: 1.0.0
+  :description: |
+    This plugin is an example showing how to define the info.yaml file.
+    Besides that, no functionality is defined.
+
+
+== Example 1: A set of plugins with dependency relationship
+
+In this example, we have an user interface bundle named 'myapp' that uses a an user database wrapper 'myapp_users' for a database connection provided by another plugin called 'myapp_db', which defines the category +:myapp_support+, which is a practical way of defining groups of dependencies. One could then add other supporting plugins to do specific tasks, when the requirements of the application grows.
+
+=== Files and directories of the example
+
+The "plugins" directory of a RSence environment containing only the three plugins of this example would look like:
+
+  !!!text
+  plugins/
+  |-- myapp
+  |   |-- gui
+  |   |   `-- main.yaml
+  |   |-- info.yaml
+  |   `-- main.rb
+  |-- myapp_db
+  |   |-- info.yaml
+  |   `-- main.rb
+  `-- myapp_users
+      |-- info.yaml
+      `-- main.rb
+
+=== A plugin bundle named 'myapp_db'
+
+The +info.yaml+ can also used to store settings. In this example, database connection parameters:
+  !!!yaml
+  :title: MyApp DB
+  :version: 0.1.3
+  :description:  This plugin provides connectivity to the FooBase database server.
+  :category: :myapp_support
+  :settings:
+    :host: '10.0.0.172'
+    :port: 12345
+    :database: example_database
+    :username: foobert
+    :password: n0ts0s3cr3t
+    :db_keys:
+      - abc123
+      - foobar
+      - 123456
+
+This information could then be read inside a plugin code like this:
+  
+  require 'foo_orm'
+  
+  # Provides connectivity to the FooBase user database using the FooBasePlugin
+  class FooBasePlugin < Plugin
+    
+    # Opens database connection after plugin is loaded
+    def open
+      @db = FooORM.new( database_connection_string )
+      super
+    end
+    
+    # Closes database connection before plugin is unloaded
+    def close
+      @db.disconnect
+      super
+    end
+    
+    # Returns database connection with very basic data access restriction
+    def db( db_key )
+      return nil unless @info[:settings][:db_keys].include?( db_key )
+      return @db
+    end
+    
+  private
+    
+    # Returns database connection string according to the settings.
+    # @return [String] FooBase connection string.
+    def database_connection_string
+      s = @info[:settings]
+      # Returns "foobase://foobert:n0ts0s3cr3t@10.0.0.172:12345/example_database" when using the default settings
+      "foobase://#{s[:username]}:#{s[:password]}@#{s[:host]}:#{s[:port]}/#{s[:database]}"
+    end
+    
+  end
+
+=== A plugin bundle named 'myapp_users'
+
+Here, the +info.yaml+ document depends on the +:myapp_db+ plugin defined above.
+  !!!yaml
+  :title: MyApp Users
+  :version: 0.0.1
+  :description:  This plugin provides an interface to access user information using FooBasePlugin
+  :depends_on: :myapp_db
+  :category: :myapp_support
+  :settings:
+    :db_key: foobar
+
+Code example:
+  
+  # Provides the user_name method to MyApp
+  class MyAppUsersPlugin < Plugin
+    
+    # Returns the user name that has the id provided by selecting it from the users table.
+    def user_name( user_id )
+      db_key = @info[:settings][:db_key]
+      db = @plugins.myapp_db.db( db_key )
+      unless db
+        warn "Invalid database key: #{db_key.inspect}"
+        return "[Database Error]"
+      end
+      user_info = db[:users].filter(:id => user_id).first
+      return "[Unknown User]" unless user_info
+      return user_info[:user_name]
+    end
+    
+  end
+
+=== A plugin bundle named 'myapp'
+Another plugin depending on the two plugins above may set it as a dependency if its +info.yaml+ is defined like this:
+  !!!yaml
+  :title: MyApp
+  :version: 0.2.0
+  :description: This application does fancy stuff using FooBasePlugin.
+  :depends_on: :myapp_support
+
+Defining the dependency like above ensures the 'foobase' plugin will be available when this code is run:
+  class MyAppPlugin < GUIPlugin
+    def gui_params( msg )
+      params = super
+      params[:greeting] = 'Welcome, ' + @plugins.myapp_users.user_name( msg.user_id )
+    end
+  end
+

data/docs/PluginBundles.rdoc

@@ -0,0 +1,96 @@
+
+= Overview
+Plugin bundles are the "building blocks" of RSence applications.
+A bundle is a directory that groups together the software code
+and its related resources.
+
+Plugin bundles are constructed of at least a directory and a ruby
+source file either named "main.rb" or the same name as the
+directory plus + ".rb".
+
+The main ruby file has to contain at least one class extended from one
+of the three types of plugins:
+- {RSence::Plugins::Plugin__ Plugin}, which is the simplest main logic plugin model.
+- {RSence::Plugins::GUIPlugin__ GUIPlugin}, which is an extended model of plugin with built-in user interface support.
+- {RSence::Plugins::Servlet__ Servlet}, which is a "traditional" request/response handler for GET/POST url's.
+
+== Example 1: A very simple plugin bundle structure
+  !!!plain
+  simple_plugin/
+  `-- main.rb
+
+=== Simplest possible contents of the "main.rb" as above
+  class SimplePlugin < Plugin
+  end
+
+A plugin like this just gets registered as a plugin named :simple_plugin when RSence finds it in one of its "plugins" directories. By default, one "plugins" directory is distributed as a part of RSence and contains some core services common to most applications. The other is the "plugins" directory inside your RSence project environment directory.
+
+To make the plugin do something useful, extend its model. To know more about that, just read the documentation about the model classes: {RSence::Plugins::Plugin__ Plugin}, {RSence::Plugins::GUIPlugin__ GUIPlugin}, {RSence::Plugins::Servlet__ Servlet}.
+
+=== Extending the simple plugin to say "Hello" to your web browser's javascript console.
+  class SimplePlugin < Plugin
+    def init_ui( msg )
+      msg.console( "Hello" )
+    end
+  end
+
+== Example 2: {file:ExampleGuiPlugin The "welcome" GUIPlugin bundle}
+This example is rather lengthy, so read it {file:ExampleGuiPlugin here}.
+
+
+= Plugin meta-information files
+
+These files are optional parts of a bundle, but are supported by the system. Most bundles will contain several other files as well, as defined by each bundle's software code.
+
+=== Supported by all bundle types, including {RSence::Plugins::Servlet__ Servlet}:
+- An {file:PluginBundleInfo info.yaml file}
+  - Defines the meta-information about the bundle, like its name, description, version, system requirements, dependencies etc.
+  - Each bundle *should* include an +info.yaml+ file.
+  - Any extra information, like default settings of the plugin itself can be stored here
+
+=== Supported by {RSence::Plugins::Plugin__ Plugin} and {RSence::Plugins::GUIPlugin__ GUIPlugin} bundles:
+- A {file:Values values.yaml file}
+  - Defines the default client-server {RSence::HValue HValue} objects to create for each user session.
+    - Contains what the default data is for each value.
+    - Defines if the data should be reset when the page is reloaded.
+    - Defines if the data should be the return-value of a plugin method.
+  - Binds the values to responder methods.
+    - Defines which plugins to bind
+      - The plugin defaults to the plugin bundle which defined the method
+    - Defines which methods to bind
+      - When the data of the value is changed by the client, the system calls the bound plugin methods to respond to and validate the data.
+
+=== Supported by {RSence::Plugins::GUIPlugin__ GUIPlugin} bundles:
+- A {file:JavascriptBundles client_pkgs.yaml file}
+  - Defines the packages of any extra javascript bundles and their themes, when contained in the bundle.
+    - The contents of the packages are loaded and built automatically by the built-in {ClientPkgPlugin +client_pkg+} plugin.
+- A {file:GUITreeYaml gui/main.yaml file}
+  - Instead of +main.yaml+, can optionally be named like +simple_plugin.yaml+ if the bundle name is +simple_plugin+
+  - Defines structure of the default user interface.
+  - Defines client-side {RSence::HValue value} bindings
+    - The values used must be defined, like using the {file:Values +values.yaml+} file
+  - May define other mappings, like localized strings and other static data.
+  - The system builds a user interface based on this file automatically when a RSence web page is loaded (and reloaded) by the user.
+
+= Values and data transfer
+The description is rather lengthy, so it's in its own document {file:Values HERE}.
+
+= Messages and sessions
+As a side effect of having the same instances of plugins serve the requests of all sessions, the request/response/session messaging is implemented as messaging objects. These objects contain or delegate all the necessary hooks required by the complete request/response cycle.
+
+The naming convention of the {RSence::Message Message} instance is +msg+ and it's given as the first parameter of methods using it directly.
+
+Use {RSence::Message#session_id +msg.session_id+} to identify the session's serial number and {RSence::Message#user_id +msg.user_id+} to identify the user's identity. Both are Numbers.
+
+Use the {RSence::Message#session +msg.session+} +Hash+ to store any persistent data associated with the user's session, preferably using the name of the plugin or its registered name as the primary key entry in the Hash. To do so automatically, just call the {RSence::Plugins::Plugin__#get_ses +get_ses+} method in your Plugin or GUIPlugin.
+
+The session data is persistent; it's stored in the session database by the main {RSence::SessionStorage SessionStorage} instance automatically, if a database connection string is properly configured.
+
+The +msg+  also provides access to the {RSence::Request +msg.request+} and {RSence::Response +msg.response+} objects directly, but don't mess around with them unless you know exactly what you are doing.
+
+Use the {RSence::PluginManager#method_missing +@plugins+} object to call other plugins, like this:
+  @plugins.plugin_name.method_name( param1, param2 )
+
+To append Javascript source code to be executed in the client, use the {RSence::Message#reply +msg.reply+} method. The {RSence::Message#console +msg.console+} method displays debugging messages in the browser's Javascript console.
+
+

data/docs/Values.rdoc

@@ -0,0 +1,163 @@
+= Overview
+The data exchange system exists to support bi-directional data synchronization between the browser and the plugin. The values are stored in the session as +HValue+ instances.
+
+Values support Hashes, Arrays, Strings, Numbers, Booleans and logically correct combinations of those. The data is automatically converted between ruby objects (server) and json objects (client). For dates and times, use Numbers as seconds since or before UTC epoch; (1970-01-01 00:00:00.0 equals 0.0) and convert accordingly for the representation intended.
+
+Each instance may be bound to plugin methods that are used as value change notification responders.
+
+When a method is bound to the value, the method is called as an event notification whenever the client has changed the value and synchronizes it to the server. The responders act as validators by default.
+
+Values may be bound in the client to instances of classes that implement the HValueResponder interface, like any derivate of HControl. See the client documentation for instructions about using them.
+
+To define a value responder method, it needs to respond to exactly two parameters: {RSence::Message +msg+} and {RSence::HValue +value+} (in that specific order). The method's return value must be either +true+ or +false+. When the method returns +false+, the change is discarded and the previously server-set value is sent back to the client.
+
+= Defining values
+The simplest and recommended way of defining the values is to define the value configuration file +values.yaml+ at the root level of your plugin bundle. The definition is then copied to each session automatically. Values created using +values.yaml+ files are accessible by their name in each user's session object.
+
+For instance, if a value has been defined as +:myvalue+, it's accessible in code like this:
+  ses = get_ses(msg) # gets the session object of the local plugin
+  my_value = ses[:myvalue] # reference to the value instance
+
+=== Syntax reference of the contents of a +values.yaml+ file:
+
+The name of the value, +:value_name+ in this case. It's a Hash key in the yaml syntax
+  !!!yaml
+   :value_name:
+
+Definitions of the value; all definitions are optional.
+
+The static value definition, a string "Foo" in this case. The default is +0+
+  !!!yaml
+     :value: Foo
+
+A plugin method to call to define the default value dynamically instead of the static value defined in +:value+
+  !!!yaml
+     :value_call:
+
+The name of the plugin where the responder method is found. It Defaults to the plugin where defined
+  !!!yaml
+       :plugin: plugin_name
+
+The name of the responder method. Mandatory item when defining a value call. In this case a method named +method_name+
+  !!!yaml
+       :method: method_name
+
+Optionally, list of parameters for the +:method+ in the order of defined. In this case, three parameters: 1, 'foo' and 3
+  !!!yaml
+       :args:
+         - 1
+         - foo
+         - 3
+
+If +:uses_msg+ is set to false, the {RSence::Message +msg+} won't be passed as the first parameter to the +:method+. It's +true+ by default.
+  !!!yaml
+       :uses_msg: false
+
+Restores the default, when the session is restored (page reload etc); defaults to +true+
+  !!!yaml
+     :restore_default: false
+
+List of value responder methods to bind.
+  !!!yaml
+     :responders:
+
+The name of the plugin and the method to bind. The plugin defaults to the plugin where defined. The responder methods always use the convention (+msg+, +value+) as their parameters.
+  !!!yaml
+       - :plugin: plugin_name
+         :method: method_name
+
+Another responder, this one using the same plugin where defined:
+  !!!yaml
+       - :method: another_method
+
+==== Example 1:
+A value defined using only the defaults by supplying an empty Hash: { value: 0, default restored, no responders or calls }
+  !!!yaml
+   :value_with_defaults: {}
+
+==== Example 2:
+This value defines a Number (123) and doesn't restore the default, when restoring the session.
+  !!!yaml
+   :one_two_three:
+     :value: 123
+     :restore_default: false
+
+==== Example 3:
+This value gets a random string and specifies a responder, that ensures it's unique, if changed in the client. (Such methods aren't predefined).
+  !!!yaml
+   :random_unique_string:
+     :value_call:
+       :method:   get_unique_random_string
+       :uses_msg: false
+     :responders:
+       - :method: ensure_unique_random_string
+
+
+= Using values in code
+
+=== Creating a HValue object in ruby and creates the client representation automatically.
+Sometimes dynamic value allocation is required. In these cases, use {RSence::HValue HValue} directly in the plugin's ruby code (or any library code that gets a +msg+).
+ a_test_value = HValue.new( msg, 'any_json_mappable_data' )
+
+=== A minimal value responder method is defined like this:
+  def my_value_responder( msg, my_value )
+    return true
+  end
+
+=== To access the content of the value, use the {RSence::HValue#data +value.data+} attribute.
+  def int_between_100_and_200( msg, value )
+    data = value.data.to_i
+    return ( data >= 100 and data <= 200 )
+  end
+
+=== To change the content of the value, use the {RSence::HValue#set +value.set+} method.
+  def int_between_100_and_200( msg, value )
+    data = value.data.to_i
+    value.set( msg, 100 ) if data < 100
+    value.set( msg, 200 ) if data > 200
+    return true
+  end
+
+=== Setting a HValue object in ruby.
+Doing the change in ruby sets the client-side accordingly too and causes all client-bound value responders to receive the same data. automatically. The data is synchronized server-client after all server responders have responded to all triggers by the last client-server synchronization, so only the lastly set data of a value is sent to the client.
+  a_test_value.set( msg, 'this_wont_be_on_the_client' )
+  a_test_value.set( msg, ['neither','will','this','be',[true]] )
+  a_test_value.set( msg, { 'and' => 'this', 'also' => 'stays', 'in' => 'the', 'server' => [1,2,3,4] )
+  a_test_value.set( msg, 'this is the last one, this gets through' )
+
+=== Binding a HValue responder in ruby. Causes the client-server synchronization to respond to all the bound methods.
+  class SomeTestPlugin < Plugin
+    def resp_one( msg, value )
+      puts "got data: #{value.data.inspect}"
+      return true
+    end
+    def resp_two( msg, value )
+      revert_to = "foo foo"
+      value.set( msg, revert_to )
+      puts "got the data too, but changed it to: #{value.data.inspect}"
+      return true
+    end
+    def define_responders( msg )
+      ...
+      # the @name is the name of the plugin bundle
+      a_test_value.bind( @name, :resp_one )
+      a_test_value.bind( @name, :resp_two )
+    end
+  end
+
+=== Referring to the value manually in the client, using the server
+This references the value by id in the client scope and binds it to a new instance of the +HTextArea+ component with its own dedicated app instance.
+  msg.reply( "COMM.Values.values[#{a_test_value.value_id.to_json}].bind( HTextArea.nu( [0,0,100,100], HApplication.nu() ) );" )
+
+=== Storing a reference to a variable in the session scope.
+Allows you to retrieve this session-specific object in any scope with access to the same session's +msg+, even in other requests (and server restarts, when a {RSence::SessionStorage SessionStorage} database connection is enabled).
+  get_ses(msg)[:the_test_name] = a_test_value
+
+=== Freeing a HValue responder, won't be used as a responder anymore
+  a_test_value.release( @name, :resp_two )
+
+=== Freeing all responders of a value
+  a_test_value.release_all
+
+=== Destructing a value, releases all bindings on both client and server and destructs the client representation too
+  a_test_value.die!( msg )

data/js/comm/autosync/autosync.js

@@ -0,0 +1,17 @@
+/*   RSence
+ *   Copyright 2009 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+// Starts the synchronization upon page load.
+LOAD(
+  function(){
+    COMM.urlResponder=COMM.URLResponder.nu();
+    COMM.Transporter.url=COMM.Transporter.HelloUrl;
+    COMM.Transporter.stop=false;
+    COMM.Transporter.sync();
+  }
+);

data/js/comm/comm.js

@@ -0,0 +1,203 @@
+/*   RSence
+ *   Copyright 2009 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+
+/*** = Description
+  ** XMLHttpRequest abstractor, and handler and utilities.
+  ** The only public method is +request+
+  ** The namespace also holds the following services:
+  **
+  ** Service Name::          Service Description
+  ** +COMM.Queue+::          Singleton, used for queuing tasks
+  **                         awaiting asynchronous requests to complete.
+  ** +COMM.Session+::        Session key secure hashing service.
+  ** +COMM.SessionWatcher+:: Polls server at regular intervals by reporting
+  **                         the client's local time.
+  ** +COMM.Transporter+::    Automated synchronization service, pulls server
+  **                         data, tasks etc. The main server interface.
+  ** +COMM.Values+::         Data value manager, handles synchronized data in
+  **                         both directions (server-client-server).
+  ** +COMM.JSLoader+::       Loads Javascript libraries asynchronously.
+  ** +COMM.JSONRenderer+::   Constructs nodes from JSON structures as GUI
+  **                         tree structures. Lowers the learning curve of GUI
+  **                         development, because Javascript knowledge is not
+  **                         required to define user interfaces.
+  **                         The main purpose is to ease the development of
+  **                         user interfaces by defining them as data on the
+  **                         server, converting the data to JSON GUI trees and
+  **                         letting the client handle the rest. The end result
+  **                         is the same as defining the structures in
+  **                         JavaScript code.
+  **
+***/
+var//RSence
+COMM = {
+  
+/** Displays an error alert, if the browser doesn't support XMLHttpRequests
+  **/
+  _FakeHttpRequest: function(){
+    alert("'ERROR: This web browser doesn't support XMLHttpRequest. Please upgrade; unable to continue.");
+  },
+  
+/** = Description
+  * Finds and calls the state responder method upon a readyState change to 4.
+  * - On readyStates other than 4 does nothing.
+  * - The default responder for a successful response code (between 200 to 299) is onSuccess.
+  * - The default responder for unsuccessful response codes is onFailure.
+  * - The responders are called with the request object as the parameter.
+  * - Custom response code handling is implemented as 'on' + status code,
+  *   eg. 'on404' for a 404 not found error.
+  **/
+  _stateChange: function(_this){
+    if(_this.X.readyState === 4){
+      var _status = _this.X.status,
+          _responderName = 'on'+_status,
+          _success = ((_status >= 200 && _status < 300) || (_status === 0));
+      _this[_responderName]?_this[_responderName](_this):_success?_this.onSuccess(_this):_this.onFailure(_this);
+    }
+  },
+  
+/** = Description
+  * Converts arrays to valid query strings.
+  *
+  * = Usage
+  * Returns 'productId=100&customerName=J-J%20Heinonen'
+  *   COMM._arrayToQueryString(['productId',100,'customerName','J-J Heinonen'])
+  *
+  **/
+  _arrayToQueryString: function(_params){
+    var i = 0,
+        _length = _params.length,
+        _queryString = '';
+    for(;i<_length;i++){
+      _queryString += encodeURIComponent(_params[i]);
+      _queryString += (i===_length-1)?'':(i%2===0)?'=':'&';
+    }
+    return _queryString;
+  },
+  
+/** = Description
+  * The main Request-handling object. Provides a general and fairly easy to use
+  * interface for making "Ajax" requests.
+  *
+  * = Parameters
+  * +_url+::        Full or relative url of the response handler
+  * +_options+::    An +Object+, see below for content:
+  *
+  *
+  * == Required properties for +_options+:
+  * +onSuccess+::   A function that is called on a successful response.
+  *                 Must accept one parameter: the request object.
+  * +onFailure+::   A function that is called on an unsuccessful response.
+  *                 Must accept one parameter: the request object.
+  *
+  * == Optional properties for +_options+:
+  * +method+::      The HTTP Request Method, usually 'POST' or 'GET', but will handle
+  *                 DAV and other extensions if the server supports them.
+  *                 Defaults to 'POST'.
+  * +async+::       Boolean; Uses asyncronous requests when true.
+  *                 Defaults to true.
+  * +params+::      Extra parameters to send, format: Array, see COMM._arrayToQueryString()
+  * +headers+::     Extra HTTP headers to send for POST requests, format: Hash.
+  * +body+::        The HTTP POST Body
+  * +username+::    Username for basic authentication
+  * +password+::    Password for basic authentication
+  * +contentType+:: The 'content-type' -header to send.
+  *                 Defaults to 'application/x-www-form-urlencoded'.
+  * +charset+::     The charset type to use. Defaults to 'UTF-8'.
+  *
+  * = Returns
+  * An +Object+ extended from the +_options+ given in the input.
+  *
+  **/
+  request: function(_url,_options){
+    var _comm = COMM,
+      
+        _this = _options?_options:{},
+      
+        _method = _options.method?_options.method.toUpperCase():'GET',
+        _async = (_options.async===undefined)?true:_options.async,
+        _params = _options.params?_options.params:[],
+        _headers = _options.headers?_options.headers:{},
+        _contentType = _options.contentType?_options.contentType:'application/x-www-form-urlencoded',
+        _charset = _options.charset?_options.charset:'UTF-8',
+        _username = _options.username?_options.username:null,
+        _password = _options.username?_options.password:null;
+    if(!_options.onFailure){
+      _this.onFailure = function(resp){console.log('No failure handler specified, response: ',resp);};
+    }
+    if(!_options.onSuccess){
+      _this.onSuccess = function(resp){console.log('No success handler specified, response: ',resp);};
+    }
+    if(!_options.on302){
+      /** Redirection handler **/
+      _this.on503 = function(_this){
+        var _retryAfter = parseInt(_this.X.getResponseHeader('Retry-After'),10)*1000,
+            _timeout = setTimeout(function(){COMM.request(_this.url,_this.options);},_retryAfter);
+      };
+    }
+    _this.url = _url;
+    _this.options = _options;
+    _this.X   = _comm._XMLHttpRequest();
+    if(_method === 'GET' && _params.length !== 0){
+      _url += ((_url.indexOf('?')!==-1)?'&':'?')+_comm._arrayToQueryString(_params);
+    }
+    if(!_async){
+      console.log("WARNING: Synchronous "+_method+" request to "+_url+", these will fail on the Symbian web browser.");
+    }
+    _this.X.open(
+      _method,
+      _url,
+      _async,
+      _username,
+      _password
+    );
+    _this.X.onreadystatechange = function(){
+      _comm._stateChange(_this);
+    };
+    if(_method === 'POST'){
+      _headers['Content-Type'] = _contentType + '; charset=' + _charset;
+      var _body = _options.body?_options.body:'';
+      for(var _header in _headers){
+        _this.X.setRequestHeader(_header,_headers[_header]);
+      }
+      _this.X.send(_body);
+    }
+    else if(_method === 'GET'){
+      _this.X.send(null);
+    }
+    if(!_async){
+      _comm._stateChange(_this);
+    }
+    return _this;
+  }
+};
+
+/** = Description
+  * Creates a new instance of the XMLHttpRequest
+  * object supported by the browser. Evaluated only once,
+  * after that does its things without any extra statements
+  *
+  **/
+if(window['XMLHttpRequest']!==undefined){
+  COMM._XMLHttpRequest = function(){
+    return new XMLHttpRequest();
+  };
+}
+else if(window.ActiveXObject){
+  COMM._XMLHttpRequest = function(){
+    return new ActiveXObject("Microsoft.XMLHTTP");
+  };
+}
+else {
+  COMM._XMLHttpRequest = function(){
+    console.log("No XMLHttpRequest object types known. Can't Communicate.");
+    return new COMM._FakeHttpRequst();
+  };
+}
+