try

try

Download And Install Free Registry Cleaner

If you believe that good things can never come free, just think
again. With the free registry cleaner you are bound to think
differently. Especially, if you are using a Windows based PC a free
registry cleaner download is possible the most effective software that
you can get free of cost. If you are wondering, what a registry cleaner
is? Then let us start from the scratch that is the registry.



Registry is a typical feature of the Windows operating system. From
Windows 95, Microsoft introduced the registry in its flagship operating
system to store all the vital information about the hardware and
software configuration and system settings of the computer. Registry is
in a way an improved method of storing system information. In earlier
versions of Windows before Windows 95, the hardware and software
configurations were stored in the INI files those were stored in a
scattered way, making the system slower. With the Windows registry
these files are stored in specific location that made the system to
function faster. A free registry cleaner can keep the registry clean
and up to date for more effective and faster computing.



You must be wondering if registry entries are so useful then, why
should you clean them up? Actually registry keeps an entry of each and
every modification that you make to the system. Whether you install or
uninstall a program, change the hardware settings an entry is generated
in the registry file and it is stored for good until it is removed. As
all the entries, especially those are outdated, are not necessary to
run the system. Moreover, they clutter the registry and make the system
slower and prone to faults. With a free registry cleaner you can remove
these unnecessary entries to get better performance from your PC.



So, download a free registry cleaner and install the software. The free
registry cleaner software automatically scans the registry, cleans it
up, backs up the data for you to restore if you encounter any problem
after you have cleaned the registry. The registry cleaner can also
configure a startup organizer and remove embedded keys that are used by
malware like Trojan, virus, dialers and so on. Registry cleaner
software also eliminates the free spaces within the registry and traces
of programs that are never completely uninstalled. In short registry
cleaners are truly effective tool for safe and faster computing. So get
it now!

About the author:
Author
is admin and technical expert associated with development of computer
security and performance enhancing software like Registry Cleaner, Anti
Spyware, Window Cleaner, Anti Spam Filter. Visit: Home Page. Learn secrets for an efficient Registry Cleaner. Visit PCMantra informative Resource Center to read more about products.

Article Source: http://www.Free-Articles-Zone.com

Powered by ScribeFire.

Importance of Web application Development in India

Web application development has provided an efficient and effective
route to deal with foreign clients, aimed at purely gain in cost
cutting methods. Through the deployment of customized and specified web
applications, a diverse range of purpose can be served. Web
applications or computer programs help you to gain information, collect
data and to find out anything that you actually desire. The basic
purpose is to get the targeted knowledge and information within a short
time.



For example, if you are located in India and want to get connected with
people residing in other geographical destinations, you can easily do
that with a variety of web application services connected through the
internet with your preferred browser. The system of web application is
not only important for making clients or facilitating proper
communication with clients but also for making business relations
strengthen and workable. This personalized system gives you a chance to
hobnob with your existing clients and prospective clients to interact
you in free and trustable manner and co-ordinate each other to make
their relationship better and profitable. Business-to-Business
interactive is one of the main features of successful web applications.
With this customized service, you can identify the individual needs and
requirements of your clients and serve them better. To facilitate the
security in the business, companies are making private business
networks that work through the internet to give you excellent results.
This process is becoming increasingly popular with a lot of overseas
companies who outsource projects to each other.



In other words, web application development has boasted the growth of a
virtual business market that is working and growing like a real market.
Application developed on Web are generating better business strategies
and policies to smoothen the business working and initiating better
concepts to gain profitability and success for all. So, when you use
web application for your business purpose or your personal purpose, you
are actually transferring the data and inputs to make the system more
workable and gaining like never before.

Powered by ScribeFire.

How to Create Web2.0 Applications using AJAX and Clientside HTTP Requests

Web2.0 is a term coined to refer to web applications that run
without visible page refreshes. A normal website functions by
delivering pages of information, with links that allow a user to move
from page to page. A web 2.0 application, or AJAX application, runs on
a single web page, and uses clientside javascript to initiate and
process additional requests to the server. The additional requests run
in the background and are invisible to the user; the end result is that
the web application appears very similar to a normal computer program,
and the user can continue to manipulate the application and application
interface without having to wait for the additional requests sent to
the server to complete.



AJAX is an acronym that stands for Asynchronous Javascript and XML. The
interesting thing about AJAX is that the XML component is actually
unnecessary, or rather optional. The important component is
asynchronous javascript -- this is the meat of how web2.0 applications
work and the XML component is just one possible format for sending and
receiving the additional data requests to the server. However, since
this processing happens in the background and is invisible to the end
user, you can actually build a web2.0 application using any format for
the data requests that you wish.



The key to implementing an AJAX web2.0 application is in the XMLHTTP
Object. The XMLHTTP objects exists in many forms, both server-side and
client-side, and the purpose of it is to allow retrieval and processing
of external web pages from within the coding application. Since we are
trying to build a client-side web2.0 application, and since Javascript
is the most widely available scripting application for web browsers,
AJAX is the ideal implementation, and a good cross-browser Javascript
code for instantiating the XMLHTTP Object is as follows:



if (document.all) req=new ActiveXObject("Microsoft.XMLHTTP");

else req=new XMLHttpRequest();



When creating a web2.0 application, the idea is that whenever you would
normally send data to the server and receive a response in return by
submitting a form, or using a link to an external page, instead you
implement it by using the XMLHTTP object to send the request or form in
the background, and process the resulting data without causing the
browser to reload. The XMLHTTP Object allows you to send requests
synchronously or asynchronously, but since we are creating an AJAX
application you will use asynchronous mode in almost all cases. When
submitting form data, you can use either the GET or POST method, but in
this article I will show you how to use POST with the XMLHTTP Object as
that allows you the widest possible uses.



Once you instantiate the XMLHTTP object, there are four simple commands
to creating a web2.0 application. The "onreadystatechange" property is
used for asynchronous mode to define a function that is executed
whenever the state of the request changes (such as when it completes).
The "open" method creates the request and the "send" method send the
request. Also, the "setRequestHeader" method is used to specify the
format of the data that is being submitted. Here is some example code
that shows how a basic AJAX application would work:



if (document.all) req=new ActiveXObject("Microsoft.XMLHTTP");

else req=new XMLHttpRequest();

req.onreadystatechange=ajaxProcess;

req.open('POST','http://'+location.host+'/ajax.asp',true);

req.setRequestHeader('Content-Type','application/x-www-form-urlencoded');

req.send('p1='+escape(p1)+'&p2='+escape(p2));



In this example, "/ajax.asp" is the page that is being retrieved, and
"ajaxProcess()" is the function that is executed once the page is
retrieved. The variables "p1" and "p2" are sent to the page as form
data. You can of course send whatever data you wish according to what
you need to do; just make sure that the ajax.asp file processes them
correctly and returns the results. Define the ajaxProcess() function so
that it processes the returned results, and updates the user interface
to indicate that the request has been completed and updates the
appropriate variables and/or the user with the new data. If you would
like to see an AJAX web2.0 application in action, you can check out the
web2.0 RPG I created, Apocalypse, found at www.apocrpg.com .



Using these methods, you can in fact send whatever data you want to the
server and process the results, just as if you had used a normal HTTP
request. The difference is that when done normally, the end user has to
wait for each page to be loaded, which can be unacceptable if the user
is on dialup and there are a large number of actions to be performed
independently (multiple page reloads). By using AJAX in a web2.0
application, you can execute these actions in the background, and the
user never notices the delays as he is able to continue manipulating
your user interface while the page requests are processing in the
background, invisible.



This type of web application wasn't possible in the past, for two
reasons. Primarily, the XMLHTTP object wasn't available until recently,
and also Javascript was not widely supported by almost all browsers as
it is today. Now that background page requests are possible, it is
likely that in the future all web applications will be converted or
migrated to web2.0 / clientside AJAX applications. There are also
innumerable web applications that simply weren't possible or feasible
under the old model, that we will undoubtedly be see appearing in the
next few years, that could potentially be very successful. Your website
could be one of these, so get started!

About the author:
===================================================

This article was written by Lucas Green,

a professional private web developer who lives off his internet income. To visit his website and learn more about

how he is creating multiple streams of passive income using the internet, please visit www.lucasgreen.com !

===================================================

Article Source: http://www.Free-Articles-Zone.com

Powered by ScribeFire.

What is Ajax?

We were getting a number of querries from our clients and friends, asking about what AJAX is?



With the development of Microsoft's Live, everyone is going crazy about
AJAX. So, we at Xaprio Solutions thaught of publishing this small
article about AJAX, which will help you guys understand it better.



Like DHTML, LAMP, or SPA, Ajax is not a technology in itself, but a
term that refers to the use of a group of technologies together. In
fact, derivative/composite technologies based substantially upon Ajax,
such as AFLAX, are already appearing. The Term AJAX refers to,
Asynchronous JavaScript and XML.



For a number of tasks, only small amounts of data need to be
transferred between the client and the server, allowing a number of
Ajax applications to perform almost as well as applications executed
natively on the user's machine. This has the effect that pages need
only be incrementally updated in the user's browser, rather than having
to be entirely refreshed.



"Every user's action that normally would generate an HTTP request takes
the form of a JavaScript call to the Ajax engine instead", wrote Jesse
James Garrett, in the essay that first defined the term. "Any response
to a user action that doesn't require a trip back to the server -- such
as simple data validation, editing data in memory, and even some
navigation -- the engine handles on its own. If the engine needs
something from the server in order to respond -- if it's submitting
data for processing, loading additional interface code, or retrieving
new data -- the engine makes those requests asynchronously, usually
using XML, without stalling a user's interaction with the application."



Traditional web applications essentially submit forms, completed by a
user, to a web server. The web server does some processing, and
responds by sending a new web page back. Because the server must send a
whole new page each time, applications run more slowly and awkwardly
than their native counterparts.



Ajax applications, on the other hand, can send requests to the web
server to retrieve only the data that is needed, and may use SOAP or
some other XML-based web services dialect. On the client, JavaScript
processes the web server's response, and may then modify the document's
content through the DOM to show the user that an action has been
completed. The result is a more responsive application, since the
amount of data interchanged between the web browser and web server is
vastly reduced. Web server processing time is also saved, since much of
it is done on the client.



The earliest form of asynchronous remote scripting, Microsoft's Remote
Scripting, was developed before XMLHttpRequest existed, and made use of
a dedicated Java applet. Thereafter, remote scripting was extended by
Netscape DevEdge at around 2001/2002 by use of an IFRAME instead of a
Java applet.

Powered by ScribeFire.

Simple J2EE Model View Controller Type II Framework

Executive Summary



Application presents content to users in numerous pages containing
various data. Also, the engineering team responsible for designing,
implementing, and maintaining the application is composed of
individuals with different skill sets.

One of the major concerns with the web applications is the separation
between the logics that deal with Presentation itself, the data to be
presented and the one that controls flow of logic. It is as an answer
to such concerns that the Model-View-Controller or MVC pattern was
designed.

This paper provides the solution to modularize the user interface
functionality of a Web application so that individual parts can be
easily modified, that is model view controller framework.



Introduction



The Model-View-Controller (MVC) pattern separates the modeling of the
domain, the presentation, and the actions based on user input into
three separate classes.

Model: The model manages the behavior and data of the application
domain, responds to requests for information about its state (usually
from the view), and responds to instructions to change state (usually
from the controller).

View: The view manages the display of information.

Controller: The controller interprets the mouse and keyboard inputs
from the user, informing the model and/or the view to change as
appropriate.

It is important to note that both the view and the controller depend on
the model. However, the model depends on neither the view nor the
controller. This is one the key benefits of the separation. This
separation allows the model to be built and tested independent of the
visual presentation. The separation between view and controller is
secondary in many rich-client applications, and, in fact, many user
interface frameworks implement the roles as one object. In Web
applications, on the other hand, the separation between view (the
browser) and controller (the server-side components handling the HTTP
request) is very well defined.

The solution provided in this paper is used very simple servlet and JSP
and plain java objects, using this framework very easily any real time
applications can be developed. By following this simple framework most
of the complex MVC frameworks can be understood.

Model View Controller Types

MVC Type-I: In this type of implementation, the View and the Controller
exist as one entity -- the View-Controller. In terms of implementation,
in the Page Centric approach the Controller logic is implemented within
the View i.e. with J2EE, it is JSP. All the tasks of the Controller,
such as extracting HTTP request parameters, call the business logic
(implemented in JavaBeans, if not directly in the JSP), and handling of
the HTTP session is embedded within JSP using scriptlets and JSP action
tags.



MVC Type-II: The problem with Type-I is its lack of maintainability.
With Controller logic embedded within the JSP using scriptlets, the
code can get out of hand very easily. So to overcome the problems of
maintainability and reusability, the Controller logic can be moved into
a servlet and the JSP can be used for what it is meant to be -- the
View component. Hence, by embedding Controller logic within a servlet,
the MVC Type-II Design Pattern can be implemented.



The major difference between MVC Type-I and Type-II is where the
Controller logic is embedded in JSP in Type-I and in Type-II its moved
to servlet.



MVC Type-II Framework



In this frame work, Model is a plain old java object, view is a JSP
which will render the page using the model , these two are application
dependent and this framework has a centralized controller is a servlet,
which will populate the model and invokes a method from the action
class.

Below is the source of the controller.



SimpleController.java



package simple;



import java.io.IOException;

import java.lang.reflect.Method;



import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;



public class SimpleController extends HttpServlet {



private ActionBeanMapping mapping;



public void doGet(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {

try {

String strJsp = null;

String strURI = request.getRequestURI();

int startIndex = strURI.lastIndexOf("/");

int endIndex=strURI.lastIndexOf(".do");

String strAction =

strURI.substring(startIndex+1, endIndex);

this.populateBean(request, strAction);

SimpleHandler handler =

(SimpleHandler)mapping.getActionInstance(strAction);

strJsp = handler.process(request, response);

request.getRequestDispatcher(strJsp).forward(request, response);

} catch (Exception e) {

e.printStackTrace();

request.getRequestDispatcher("/error.jsp").forward(request, response);

}

}





public void doPost(HttpServletRequest request,

HttpServletResponse response)

throws ServletException, IOException {

this.doGet(request, response);

}



public void init() throws ServletException {

String strFile = this.getServletContext().getRealPath("/")+

this.getServletConfig().getInitParameter("actionmappings");

System.out.println("MAPPING FILE PATH::"+strFile);

try {

mapping = new ActionBeanMapping(strFile);

} catch (IOException e) {

e.printStackTrace();

}

}

private void populateBean(HttpServletRequest request, String strAction)

{

Object obj;

try {

obj = mapping.getBeanInstance(strAction);

Method methods[] = obj.getClass().getMethods();

for(int i=0; i0){

strValue = arrayValue[0];

}

try {

method.invoke(obj, strValue);

} catch (Exception e) {

e.printStackTrace();

}

}

}

request.setAttribute(SimpleHandler.BEAN, obj);

} catch (Exception e) {

e.printStackTrace();

}

}

}





The servlet’s init method is used to initialize the action and bean mappings.



public void init() throws ServletException {

String strFile = this.getServletContext().getRealPath("/")+

this.getServletConfig().getInitParameter("actionmappings");

System.out.println("MAPPING FILE PATH::"+strFile);

try {

mapping = new ActionBeanMapping(strFile);

} catch (IOException e) {

e.printStackTrace();

}

}

Mapping file path is taken from the servlet config, and initialized the ActionBeanMapping helper class.



ActionBeanMapping.java:



package simple;



import java.io.FileInputStream;

import java.io.IOException;

import java.util.Properties;



public class ActionBeanMapping {

private Properties prop = new Properties();



public ActionBeanMapping(String propFile) throws IOException {

this.prop.load(new FileInputStream(propFile));

}

public Object getActionInstance(String action)throws Exception {

String strClass = prop.getProperty("action."+action.trim());

if(strClass == null)

throw new NullPointerException("Null action::"+action);

return Class.forName(strClass).newInstance();

}



public Object getBeanInstance(String action)throws Exception {

String strClass = prop.getProperty("bean."+action);

if(strClass == null) throw

new NullPointerException("Null bean::"+action);

return Class.forName(strClass).newInstance();

}

}



This class reads the properties file and provides two methods to
instantiate the Action and Bean classes using java reflection for the
specified user action.

The GET and POST methods of the request calls the following code in controller.

try {

String strJsp = null;

String strURI = request.getRequestURI();

int startIndex = strURI.lastIndexOf("/");

int endIndex=strURI.lastIndexOf(".do");

String strAction =

strURI.substring(startIndex+1, endIndex);

this.populateBean(request, strAction);

SimpleHandler handler =

(SimpleHandler)mapping.getActionInstance(strAction);

strJsp = handler.process(request, response);

request.getRequestDispatcher(strJsp).forward(request, response);

} catch (Exception e) {

e.printStackTrace();

request.getRequestDispatcher("/error.jsp").forward(request, response);

}



This piece of code gets the user action from the URI and instantiates
the bean and action class and populates the model and invokes the
method on an action class. All the actions classes in the application
should implement the interface SimpleHandler. If any error occurs this
controller forwards to a generalized error page.



SimpleHandler.java:



package simple;



import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;



public interface SimpleHandler {

public static final String BEAN = "simple.BEAN";



public String process(HttpServletRequest request, HttpServletResponse response) throws Exception;



}



All the action classes in the application should implement the process method.



Population of model data from the request object is done by the following controller method.



private void populateBean(HttpServletRequest request, String strAction)

{

Object obj;

try {

obj = mapping.getBeanInstance(strAction);

Method methods[] = obj.getClass().getMethods();

for(int i=0; i0){

strValue = arrayValue[0];

}

try {

method.invoke(obj, strValue);

} catch (Exception e) {

e.printStackTrace();

}

}

}

request.setAttribute(SimpleHandler.BEAN, obj);

} catch (Exception e) {

e.printStackTrace();

}

}



This method populates the model data and binds the model to request object, this model is accessed by the action class and JSP.



error.jsp



[%@ page language="java" pageEncoding="ISO-8859-1"%]

[html]

[head]

[title]Error page[/title]

[/head]

[body]

[font color="#ff0000"][b]Error occured while processing request.[/b][/font]

[/body]

[/html]



The web configuration is defined below, it’s a simple configuration file for controller.



web.xml:



[?xml version="1.0" encoding="UTF-8"?]

[web-app version="2.4"

xmlns="http://java.sun.com/xml/ns/j2ee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee

http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"]

[servlet]

[description]Simple J2EE Controller[/description]

[display-name]Simple J2EE Controller[/display-name]

[servlet-name]SimpleController[/servlet-name]

[servlet-class]simple.SimpleController[/servlet-class]

[init-param]

[param-name]actionmappings[/param-name]

[param-value]WEB-INF/actionmappings.properties[/param-value]

[/init-param]

[load-on-startup]1[/load-on-startup]

[/servlet]



[servlet-mapping]

[servlet-name]SimpleController[/servlet-name]

[url-pattern]*.do[/url-pattern]

[/servlet-mapping]

[welcome-file-list]

[welcome-file]index.jsp[/welcome-file]

[/welcome-file-list]

[/web-app]



The controller servlet is invoked for all the urls which will ends with
.do, this servlet loads on server startup, and defines the action
mappings file path.





Sample Application using the Framework



Providing sample application to registration to store name, email and phone.

index.jsp:

[%@ page language="java" pageEncoding="ISO-8859-1"%]

[html]

[head]

[title]Home page[/title]

[/head]



[body]

[form method="post" action="register.do"]

[table width="200" border="0" align="center"]

[tr]

[td colspan=2 align="center"][strong]User Data[/strong] [/td][/tr]

[tr]

[td]Name[/td]

[td][input type="text" name="name"][/td][/tr]

[tr]

[td align="left"]Email[/td]

[td][input type="text" name="email"][/td][/tr]

[tr]

[td align="center"] Phone[/td]

[td][input type="text" name="phone"][/td][/tr]



[tr]

[td colspan="2" align="center"] [input type="submit" value="Submit" name="Submit"][/td][/tr]

[/table]

[/form]

[/body]

[/html]



This is a JSP page to enter the data by the user to store in the
system. When user clicks the Submit button on the page data is posted
to the action register.

Bean and Action mappings are entered into the mappings file.

actionmappings.properties

action.register=simple.RegistrationHandler

bean.register=simple.User

all the user actions from the view should present in this properties file.

When user submits the data to controller it populates the data to the following model.

User.java:

package simple;



public class User {

private String name;

private String email;

private String phone;

public String getEmail() {

return email;

}

public void setEmail(String email) {

this.email = email;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getPhone() {

return phone;

}

public void setPhone(String phone) {

this.phone = phone;

}

}

Following action is called when data is submitted.

package simple;



import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;



public class RegistrationHandler implements SimpleHandler {

public String process(HttpServletRequest request,

HttpServletResponse response) throws Exception {

User user = (User)request.getAttribute(SimpleHandler.BEAN);

return "/success.jsp";

}

}

This action class gets the bean from the request; this bean can be
saved in the system, after successful processing it returns the
success.jsp to controller to forward to this view.

success.jsp:

[%@ page language="java" import="simple.*" pageEncoding="ISO-8859-1"%]

[%

User user = (User) request.getAttribute(SimpleHandler.BEAN);

%]

[html]

[head]

[title]Success page[/title]

[/head]

[body]

[table width="200" border="0" align="center"]

[tr]

[td colspan=2 align="center"][strong]User Data Successfully Saved[/strong] [/td][/tr]

[tr]

[td]Name[/td]

[td][%= user.getName() %][/td][/tr]

[tr]

[td align="left"]Email[/td]

[td][%= user.getEmail() %][/td][/tr]

[tr]

[td align="center"] Phone[/td]

[td][%= user.getPhone() %][/td][/tr]

[tr]

[td colspan="2" align="center"] [input type="button" va



About the author:
Madhusudan Pagadala is working as a Senior Software



Engineer at NetZero,UnitedOnline, Inc., located in



WoodlandHills,California,USA. He has 9+ years experience in Web



Technologies like J2EE, HTML, and JavaScript. He pursued Master



of Technology in AeroSpace Engineering from the prestigious



college IIT, Kharagpur-India.

Powered by ScribeFire.

New version RTF TO XML Converter is now available.

On October, 2006 Novosoft Product Department has announced a new release of RTF TO XML Converter.

The RTF TO XML Converter is a powerful and easy-to-use program that
allows to convert RTF documents into Word, PDF, HTML, XSL FO. RTF to
XML converter provides you with flexibility and speed. You will
appreciate how easy you can convert RTF documents into XML format file
with one button click.

Features of RTF to HTML Converter:

Page formatting support (margins; page size; headers and footers;page
(section) breaks of all types; watermarks (document background);
footnotes; paragraph pagination)

Text formatting support (font: family,size, style and weight;
superscript and subscript; font and background color; paragraph: line
spacing , alignment and margins; lists of all formats)

Tabs support (the rendering is applied for calculating true position of
text with tabs; multiple tabs of the “center” or “left” type)

Miscellaneous (full implementation of tables; high quality of
conversion RTF files; high speed of converting documents; height of
table rows and vertical alignment of text in table cells; last page
number field; pictures of any graphic format; picture conversion
plug-ins; support of non-grouped textboxes; multilingual support; links
and hyperlinks; track changes support; free upgrades )

Visit http://www.rtf-to-xml.com to read more about RTF TO XML Converter features and download new release.

Powered by ScribeFire.