When working on applications that use JavaScript you want to apply good practices like design patterns also on the client-side. Often times you’ll find yourself using the same piece of code over and over again but slightly changing parts of it. Sometimes you even want to have a centralized functionality you want to reuse across your application.

If your application makes AJAX calls to your server-side components jQuery’s AJAX implementation comes in handy. Usually you want to handle at least the successful and erroneous response of that call. Today’s web applications (like Gmail) based on a lot of AJAX calls display a “busy/loading” indicator like a spinner or some text.

JavaScript supports the Factory pattern (see the book “Pro JavaScript Design Patterns”) which lets you create an implementation with the new keyword. The nice thing about it is that you can even create multiple implementations that handle your HTTP calls differently. The methods are being added over the the class’s prototype object. Below you’ll find an implementation for making AJAX calls using jQuery. For each GET or POST call you pass in a callback variable. The callback variable defines how to handle the response.

ajax.js:

var AjaxHttpSender = function() {};

AjaxHttpSender.prototype.sendGet = function(url, callback) {
   $.ajax({
      url: url,
      type: 'GET',
      beforeSend: function() {
         onStartAjaxRequest();
      },
      error: function(XMLHttpRequest, textStatus, errorThrown) {
         callback.failure(XMLHttpRequest, textStatus, errorThrown);
      },
      success: function(data, textStatus) {
         callback.success(data, textStatus);
      },
      complete: function (XMLHttpRequest, textStatus) {
         onEndAjaxRequest();
      }
   });
}

AjaxHttpSender.prototype.sendPost = function(url, data, callback) {
   $.ajax({
      url: url,
      type: 'POST',
      data: data,
      beforeSend: function() {
         onStartAjaxRequest();
      },
      error: function(XMLHttpRequest, textStatus, errorThrown) {
         callback.failure(XMLHttpRequest, textStatus, errorThrown);
      },
      success: function(data, textStatus) {
         callback.success(data, textStatus);
      },
      complete: function (XMLHttpRequest, textStatus) {
         onEndAjaxRequest();
      }
   });
}

function onStartAjaxRequest() {
    // e.g. show spinner
}

function onEndAjaxRequest() {
    // e.g. hide spinner
}

Usage Example:

<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>
<script type="text/javascript" src="js/ajax.js"></script>
<script type="text/javascript">
   var callback = {
      success: function(data, textStatus) {
         $('#content').html(data);
      },
      failure: function(XMLHttpRequest, textStatus, errorThrown) {
         alert('Error making AJAX call: ' + XMLHttpRequest.statusText + ' (' + XMLHttpRequest.status + ')');
      }
   }

   function makeAjaxCall() {
      var ajaxHttpSender = new AjaxHttpSender();
      ajaxHttpSender.sendGet(url, callback);
   }
</script>

Hi

try this example to Validate FCKEditor Control using CustomValidator control

Your HTML Markup for FCKEditor:

<FCKeditorV2:FCKeditor ID="HTMLFCKeditor" runat="server" Height="400px" Width="100%">
</FCKeditorV2:FCKeditor>
<asp:CustomValidator ID="CustomValidator2" runat="server" ValidationGroup="Invitation"
ErrorMessage="Enter Message !" Display="Dynamic" ClientValidationFunction="ValidateFCKEditor"></asp:CustomValidator>

CustomValidator Javascript Function:

function ValidateFCKEditor(source, args)
{
    var fckEditorClientID = document.getElementById('<%=HTMLFCKeditor.ClientID%>');              
    args.IsValid = FCKeditorAPI.GetInstance(fckEditorClientID.id).GetXHTML(true) != "";      
}

Hope this helps

Good Luck.

Just before I Xmas I spent ages struggling with the “Ajax.Autocompleter is not a constructor” error while trying to add a script.aculo.us autocompleter to a textbox.  I’ve done them loads of times before and never had an issue so unsurprisingly this infuriated me!

I checked online and found suggestions to do with referencing prototype more than once, and not including the right bits of script.aculo.us (effects.js, I think it’s in).  But none of those were the case.

In the end I found the answer myself… I’d followed the generally good practice of placing all my javascript references and code at the bottom of my page (just before /body) which is how I always do things nowadays.  This works absolutely great when working with prototype as it means the page doesn’t have to wait for the library to load and things therefore aren’t unnecessarily delayed.  Now, I say it works great for prototype, it doesn’t however work for script.aculo.us, THIS HAS TO GO IN THE HEAD!

So, there we have it, if you hit this problem and you’re doing “the right thing” by including your javascript goodies at the bottom of your page, I’m afraid that won’t work here.  Move your JS references to your head and things work dandy again.  You can still do your actual javascript code before /body (which I would suggest you do), just include the references to prototype and scriptaculous in the head.

I hope this helps…. and saves some hair pulling.

:: :: :: :: :: :: :: :: :: :: :: :: :: :: :: ::

Web forms processing? Formspring offers a nifty service but its social side project needs a makeover; http://j.mp/7POZhX

Anyone have experiences in redesigning the HYIP monitor? I want to redesign my HYIP monitor to be like List4hyip.com or Libertyhyip.com. (Budget: $30-250, Jobs: Graphic Design, Javascript, PHP, SQL, Website Design)
Bid on this project

Anyone have experiences in redesigning the HYIP monitor? I want to redesign my HYIP monitor to be like List4hyip.com or Libertyhyip.com. (Budget: $30-250, Jobs: Graphic Design, Javascript, PHP, SQL, Website Design)
Bid on this project

Found a nice website tool that can used to encode or decode text strings as you like. I found this particularly useful for decrypting a SharePoint GUID, however it could be handy for turning encoded JavaScript URLs from complete gibberish into readable gibberish.

The URL is: http://meyerweb.com/eric/tools/dencoder/

This company is located in El Maadi, here

and that was the first company I’ve been in, that was internship, i lasted there for a month.

it was a small company, we where 8 developers there during that time, but they’ve increased now.

it had relatively good projects and clients

the thing that made me very happy in the first week there, i wrote some AJAX code implementing the auto-complete like google’s

and implemented two algorithms i had just learned while ACMing in JAVA (edit distance, soundex)

the good thing there that i was holding a whole project by my own, in C#

i felt how was it to take care for some features that may not be of any importance for me, but is irritating that it doesn’t exist for the users

like “Esc” button to close the form, I NEVER USED “Esc” TO CLOSE A FORM !!!

and some other functions key plus the “Tab” navigation

and for the first time i needed the “decimal” data type to have accurate decimal point calculations.

the thing that i didn’t like there that my learning curve tended to stop rising.

after two weeks i was doing the same thing and applying what i know to develop in the project.

and at this time, i was more interested in knowledge rather than experience.

so i was thinking to go back home to Alex to study or start my ACM training, but ZIZO got me internship in Mentor Graphics with a whole new paradigm, Thanx ZOZZ !

ah, i forgot to say,

the greatest CON in that company that it was in Cairo,

and the best PRO that it’s manager is originally from Alexandria

Happy New Year to all our readers from Hogsmill. We’ve made a few resolutions for 2010, so do check back throughtout the year to see how we’re doing. Despite the recession, 2009 was a great year for us, so here’s hoping for something as good in 2010.

1. To get the ‘hush-hush’ site that we’re working on live so you can all see some great 2.0 functionality. I’d love to show everybody this, as we’re really proud of it, but it’s all under NDA at the mo’…
2. To release the Hogsmill Javascript and PHP libraries to the wider community. These are almost ready, but (predictably…) suffer from a lack of documentation. We’ll rectify that and release in 2010. Do Email us if you want to know when this is available.
3. To make the CMS-enabled version of Barge Walk available as a demo to demonstrate the latest in-line editing capabilities.
4. To keep this blog up-to-date

Editing a Sticky’s Contents

One of the first things that we’ll need to do is be able to edit the content of a sticky. We decided on using the jEditable component, as it seemed the easiest to integrate, and it was really high up on the google page. In this series of blog posts, I’m going to take a look at how we went about not only integrating the component, but also how we went about improving our design through shifting to a TDD approach and listening to what the tests were saying as they guided and influenced our design. Along the way, I learned some valuable lessons about bringing old habits from other language styles over without thinking about them. That comes later, though.

Link to the gist for all the code samples

Do I even know the javascripts?

It has been a long time since I wrote serious JavaScript; I think the last time I did what I would call an actual ‘JavaScript application’ was in 2002, or so. Sure, I’ve written a few things here and there. In fact, at the startup I worked at, I wrote a couple in-browser things that I was proud of at the time (looking back, naturally, I can see the parts that I’m not so proud of). But, all-in-all, most of what I do has been pretty non-dynamic. Back in 2002, I’m pretty sure I was only seeing the beginnings of JavaScript frameworks. There were some libraries coming out, but I seem to remember them being very focused on hiding the differences between DOM implementations. I wrote a couple things back then, but nothing incredibly crazy; I remember writing a client-side form validation library that was pretty damn sweet for the time.

So, both my JavaScript and JavaScript testing skills were a bit rusty. I’ve used this as an example before when talking about using the term ‘pragmatic’ to really be a cover over lack of skill: I never tested my JavaScript, not because I was pragmatic about testing, but because I flat-out didn’t have the skills needed to do it effectively. This was one of the reasons I was so excited to work on The Stickies Project: as I outlined initially, this application is going to be almost entirely JavaScript, so I will have a great opportunity to patch what I consider a significant hole in my skillset. After setting up BlueRidge, I began writing some examples for my code, but I found that, while I was writing tests, I wasn’t really doing TDD; I was writing some functions, trying to figure out how to get the desired behavior, while writing tests alongside them.

Figuring out the component

At first, I was just trying to get things working, figuring out how the component worked, so I wrote the following spike code:

function update_sticky_text(value, settings) {
  var stickie = $(this);
  console.log("value " + value + " settings " + settings + " this " ));
  var url = sticky_update_url_for(stickie);
  console.log("url " + url );
  // jQuery.post(url, {content : value, method : 'put'});
  return value;
}

function sticky_update_url_for(sticky_div){
  return sticky_div.attr('data-update-url');
}

Screw.Unit(function(){
  describe("getting information from sticky div", function(){
    it("can get the update url", function(){
      sticky_div = $("#sticky_23");
      sticky_div.attr('data-update-url', "/stickies/25");
      expect(sticky_update_url_for(sticky_div)).to(equal, "/stickies/25");
    });
  });
});

Hmmm… Reflection

Yeah, looks pretty bad. But, it was enough to learn the jEditable component, so I was pretty happy. However, I definitely had a few major problems with the code:

1. global functions
2. no sense of cohesion other than being in the same file for these two functions, even though the dependency was there
3. #sticky_update_url_for was not used anywhere else, only by #update_sticky_text
4. no test coverage for the #update_sticky_text function.

Learning from the spike

Now that I had finished the spike, it was time to actually write some code. I had identified some design problems with the resulting code, and I was curious to see how those problems would be resolved. Before moving on, though, we took a bit of time to learn some more about ScrewUnit. I had learned the expect(…).to(…) syntax, but wasn’t sure what the setup was for checking if methods are called. I’m tend to do collaboration-style tests, so it is important for me to be able to set expectations on method calls. I wasn’t ready to jump into using a mocking framework, so I decided to stick with the simplest way I knew how: replace the method with your own that sets a flag if it was called. Something like this should suffice:

Screw.Matchers['expect_called'] = function(obj, func_name, block){
  var got_called = false;
  obj[func_name] = function(x) { got_called = true; }
  block();
  this.expect_true(got_called);
};

// used like this
it("calls #parent_sticky", function(){
    expect_called(this, 'parent_sticky', function(){
    old_update_sticky_text("foo", null);
  });
});

This is the easiest way to check if something was called, but, of course, it doesn’t reset the function at the end (I wrote that later), so it isn’t perfect. But, this allowed me to write isolation-based examples for my functions. With this in hand, I was equiped to write a full set of examples for what was going to be known as #old_update_sticky_text:

describe("#old_update_sticky_text", function(){

    before(function(){
      this.sticky_update_url_for = function(x) { return null; }
      this.parent_sticky = function(x) { return null; }
      this.update_sticky = function(x) { return null; }
    });

    it("returns the value passed in", function(){
      var value = old_update_sticky_text("foo", null);
      expect(value).to(equal, "foo");
    });

    it("calls #parent_sticky", function(){
      expect_called(this, 'parent_sticky', function(){
        old_update_sticky_text("foo", null);
      });
    });

    it("calls #sticky_update_url_for", function(){
      expect_called(this, 'sticky_update_url_for', function(){
        old_update_sticky_text("foo", null);
      });
    });

    it("calls #update_sticky", function(){
      expect_called(this, 'update_sticky', function(){
        old_update_sticky_text("foo", null);
      });
    });
});

So, I was pretty happy that I was able to write isolation tests, but I was still annoyed by the other problems, primarily what I considered to be the big problems of global functions and lack of a sense of cohesion. My experiences have led me to trust in TDD to guide me when I’m not 100% sure where to go. Let’s get going. I’ve comfortable enough with ScrewUnit now, so I thought I would just jump in head-first.

Let’s try some TDD

First example? How about this:

require("spec_helper.js");
rails_require('tsp');

Screw.Unit(function(){
  describe("TSP", function(){
    describe("#update_sticky_text_handler", function(){
      it("returns the value passed in", function(){
        var value = TSP.update_sticky_text_handler("new text", null);
        expect(value).to(equal, "new text");
      });
    });
  });
});

It felt somewhat reasonable. This is a handler across all the sticky object editable components, so hanging off a TSP (the stickies project) object feels like it will at least afford me a bit of cohesion while I figure out a better method.

Now to get it passing:

var TSP = {
  update_sticky_text_handler : function(value, settings){
                                 return value;
                               }
};

There, that made it passed, plus satisfied the first behavior that the jEditable component required: the handler returns the new value. In our case, we didn’t need anything fancy, so this was good enough. Of course, this didn’t do much, so we need to add the code that would interact with the back-end. The jEditable component executes the handler in the context of the inline editor div, so ‘this’ would be that div. The schema for a sticky was starting to look like:

<div class='sticky'>
  <div class='editable' id='sticky_23'></div>
</div>

Looking at this, and knowing that we were executing in the context of div.editable, it seemed naturally to have a 2-step process for updating the sticky:

1. construct some sort a sticky object from the div.editable
2. call #update_content on the sticky object

Reflecting on the work so far

• I felt really good with the way that things were progressing, especially how the spike led me to some conclusions about my code and drove me to learn ScrewUnit a bit more. The side-by-side testing on the spike gave me confidence with the toolset, so I was able to build some examples with the code there to base it on.
• By holding myself to a bit of isolation, I see that an abstraction has snuck in: ’sticky object.’ What is going to be? I don’t totally know at this point, but I do know that it is constructed from div.editable somehow and it has an #update_content method which, apparently, updates the content in the backend.
• Having a global TSP object feels a bit weird. It is going to be shared between everything, and that makes me uncomfortable. Of course, it is much better than just having free-floating functions out in the world. Not the spoil the surprise, but having a global object like this causes me a bit of pain and annoyance soon, so I end up getting rid of it. But, that is a story for the near future.

What is coming up in the next installment

I’ve got an idea of what needs to be done, so it is time to write the examples for the updating process and implement the code. Also, we’ll start writing more examples, learn the smoke framework, get annoyed with the smoke framework, realize that our annoyance is telling us something about our preconceptions, accept that our frustration has a lesson hidden in it, then listen to what the difficulties tell us about our design.

Ajax is one of the most important technology that is a part of web 2.0 applications. Unfortunately the Cross/Sub-domain communications through Ajax are not allowed in browsers due to the security restrictions imposed by them. There are few techniques through which a web developer can make Cross/Sub-domain Ajax calls. A method is using the browser’s Flash plug-in to make this communication possible. In this tutorial we are going to use the YUI framework to make Cross/Sub-domain Ajax calls.

Overview

The XMLHttpRequest object (also known as the XMLHTTP object in Microsoft Internet Explorer environment) is one of the most widely used JavaScript object in Web 2.0 applications. Through Ajax technology JavaScript can communicate with the server without loading the web page again and again. The communications between the browser and server will be done without interfering the front-end of the application. This particular feature revolutionized the web development arena like never before. Ajax has its own limitations, one of the most important limitation of Ajax is the difficulty for performing a Cross/Sub-domain communication.

Cross/Sub-Domain Communication in Ajax

Popular browsers has imposed certain security restrictions due to which JavaScript is unable to perform a Cross/Sub-Domain communication. A Cross/Sub-Domain can be considered as any of the following items:

• An independent external web server like Yahoo!
• A sub-domain in our web server is also considered as Cross Domain

The frustrating point from a web developer perspective is sub-domains can’t communicate with each other even if both domains resides in the same server.

Making Cross/Sub-Domain Communication in Ajax Possible

There are two popular methods through which Cross/Sub-Domain Ajax call can be possible:

• Server-side Proxy
• Using Flash

Server-side Proxy

This is the best method available without much drawbacks as this method completely relies on the capabilities of the Server-side language that uses the Web server for eg: PHP, C#, Java, Python, etc.

The proxy is nothing but a code snippet that communicates with the external server. In this method the Ajax call will be issued directly to the proxy not to the Cross/Sub-Domain resource. After receiving the request from the browser the proxy will in turn communicate with the Cross/Sub-Domain resource. Gather the result from the external server and serve the results to the browser.

If you want more information about server-side proxy you can read a more detailed article about this in Yahoo Developer Network.

Using Flash

In a way Flash is similar to Ajax as it does not allow to gather data from external server. But there is a way to do this and this is the method that we are going to exploit to make the Cross/Sub-Domain Ajax call possible.

If we place a cross-domain policy file in the external server we can make this communication a reality. Personally I prefer to use this method to make the sub-domain communication and trusted Cross/Sub-Domain communication (the one between two of my websites) possible rather than making a call to an independent external server. As we need to place a cross-domain policy file in the external server this method may not be suitable for communicating with an independent external server without proper access to it. If you can place a cross-domain policy file in any server that allows the communication from your site to the external server then you can make the communication with any available server.

Cross-Domain Policy File

This is a normal XML file with some predefined markup in it. The most common location for a cross-domain policy file on a server is the root directory of a domain with the file name as crossdomain.xml. I have furnished a typical cross-domain policy file code below, which allows the Cross/Sub-Domain communication possible from client (the one who seeks resources).

<cross-domain-policy>
	<allow-access-from domain="*"/>
</cross-domain-policy>

If you do not want to allow any external server communicate with your server then you can use the following code, which allows communication from a specific server. In this case the external server which needs to be invoked will accept the communication only from yourdomain.com or www.yourdomain.com

<cross-domain-policy>
	<allow-access-from domain="yourdomain.com"/>
	<allow-access-from domain="www.yourdomain.com"/>
</cross-domain-policy>

If you are looking for more information about cross-domain policy file you can read it here.

The Tools We Use

• YUI2 Framework sources
• An empty Flash movie
• Cross-Domain Policy File

YUI2 Framework sources

YAhoo User Interface or YUI is one of the heavily feature oriented JavaScript framework developed by Yahoo!. The framework is well documented, comes with lots of examples, etc. We are going to use YUI’s Connection Manager

To include the YUI source insert the following code either in web page’s head or body section.

<script type="text/javascript" src="http://yui.yahooapis.com/2.8.0r4/build/yuiloader/yuiloader-min.js"></script> <!-- Serves directly from Yahoo!'s CDN -->
<script type="text/javascript">
	// Instantiate and configure YUI Loader:
	(function() {
			var loader = new YAHOO.util.YUILoader({
				base: "",
				require: ["connection","dom","event"],
				loadOptional: false,
				combine: true,
				filter: "MIN",
				allowRollup: true,
				onSuccess: function() {
					//You can place any code that needs to be executed after loading YUI source files here.
				}
			});
			// Load the files using the insert() method.
			loader.insert();
		})();
</script>

Empty Flash Movie

As this method uses Flash plugin of the user browser we need a flash movie to make this method work. Personally I uses a small empty flash movie for this purpose. This is because I don’t want to associate this method with any other special purpose flash movie that I use in my sites.

Cross-Domain Policy File

I have furnished the code of a generic cross-domain policy file below. You can use this code as a starting point and can change this in such a way that it suits your purpose.

<?xml version="1.0"?>
	<!DOCTYPE cross-domain-policy SYSTEM "http://www.adobe.com/xml/dtds/cross-domain-policy.dtd">
		<cross-domain-policy>
			<allow-access-from domain="yourdomain.com"/>
			<allow-access-from domain="www.yourdomain.com"/>
		</cross-domain-policy>

Copy the above code, save it in a file named crossdomain.xml. Replace yourdomain.com with your site’s correct domain name. As the last step place the saved crossdomain.xml file on the external web server’s root folder to which you want to make the communication from your site through Ajax. This is the most important step of in the whole process, without carrying out this step you’ll not be able to make this method work correctly.

Full Source Code

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
        <title>Cross-Domain Ajax Communication</title>
        <script type="text/javascript" src="http://yui.yahooapis.com/2.8.0r4/build/yuiloader/yuiloader-min.js">
        </script>
    </head>
    <body>
        <div id="container">
        </div>
		<form>
			<input type="button" name="btnLoad" id="btnLoad" value="Make Cross Domain Ajax Call">
		</form>
        <script type="text/javascript">
            var Global = {};
			Global.makeAjaxCall = function(paramObject){
				if(YAHOO.lang.isUndefined(paramObject.url) || YAHOO.lang.trim(paramObject.url) === ""){
					alert("Provide a url to proceed further");
					return false;
				}
				paramObject.method = paramObject.method||"GET";
				paramObject.cache = paramObject.cache||false
				if(paramObject.xdr === true && (!YAHOO.lang.isUndefined(paramObject.url) || YAHOO.lang.trim(paramObject.url) !== "")){
					YAHOO.util.Connect.transport(paramObject.flashFile);
					YAHOO.util.Connect.xdrReadyEvent.subscribe(function() {
						//This JS literal object is responsible for making the function calls after the Ajax call occur.
						var callback = {
							success:function(o){
								//The cross-domain Ajax call is success
								YAHOO.util.Dom.get("container").innerHTML = o.responseText; //After the cross-domain Ajax we insert the response from external server to one of the elements in the DOM
							},
							failure:function(o){
								//The cross-domain Ajax call is failure
								alert("Ajax call failed");
							},
							cache:paramObject.cache,
							xdr:true //This parameter will tell we are going to make a cross-domain Ajax call through flash plugin.
						};
						//The following function call will make the Ajax call and pass the callback object
						YAHOO.util.Connect.asyncRequest(paramObject.method, paramObject.url, callback);
					});
				}else{//Normal Ajax call will be handled by this section
					//This JS literal object is responsible for making the function calls after the Ajax call occur.
					var callback = {
						success:function(o){
							//The cross-domain Ajax call is success
							YAHOO.util.Dom.get("container").innerHTML = o.responseText; //You can place your code here that needs to be executed afer the successful Ajax call
						},
						failure:function(o){
							alert("Ajax call failed");
						},
						cache:paramObject.cache
					};
					//The following function call will make the Ajax call and pass the callback object
					YAHOO.util.Connect.asyncRequest(paramObject.method, paramObject.url, callback);
				}
			};
			/*The following function will load the YUI  modules: DOM, Event and Connection manager*/
            Global.loadYui = function(){
                var loader = new YAHOO.util.YUILoader({
                    base: "",
                    require: ["connection", "dom", "event"],
                    loadOptional: false,
                    combine: true,
                    filter: "MIN",
                    allowRollup: true,
                    onSuccess: function(){
                        //You can place any code that needs to be executed after loading YUI source files here.

						//After the YUI framework file loading we attach the event handler to the button available in the page.
						YAHOO.util.Event.on("btnLoad", "click", function(){
							Global.makeAjaxCall(Global.argumentsObject);
						});
                    }
                });
				//The following function call will insert the YUI modules in the page DOM
                loader.insert();
            };

			//A JS literal object that contains the arguments needs for the XDR communication
			Global.argumentsObject = {
				url: "http://www.theremoteserver.com/yourresourcefile.ext", //Replace this url with your own external server's url and resource name
				method:"GET", //By default GET
				cache:false, //Can be true or false
				xdr:true, //Should be true for XDR communications
				flashFile:"flash_file_path/flash_file_name.swf" //Please include the correct path of the flash movie that we are going to use to make this all possible.
			};

			Global.onLoad = function(){
				Global.loadYui(); //Include YUI source in to the DOM
			}

			YAHOO.util.Event.onDOMReady(Global.onLoad); //JS code execution will be started after loading the DOM except images completely.
        </script>
    </body>
</html>

Dissect The Source

The code above code is a genric code which needs to be updated with your required details if you want to try this method. I have commented the source so that anyone can use it without any issues and can modify at their own will.

I have Placed the entire JavasScript code within a JavaScript literal object named Global to avoid cluttering the global namespace with our code. In other words we uses a custom namespace for our code, the entire functions, variables, etc will be within this namespace. This method organizes the code efficiently especially if you are dealing with large volume of code.

Everything starts with the following code.

YAHOO.util.Event.onDOMReady(Global.onLoad);

This code will invoke the function onLoad which is inside the Global JavaScript object literal after completing the page’s DOM loading. Please note that this will not wait for page’s images to load for executing the function. This is the method of YUI equivalent to jQuery’s $(document).ready() function.

Global.onLoad = function(){
	Global.loadYui(); //Include YUI source in to the DOM
};

This code will invoke the Global.loadYui function, which is responsible for loading YUI’s needed modules. You can load it via script tag but we are going to use JavaScript in anyway and thought of loading the framework files through JavaScript itself. One of the reason I’ve done like this is loading large script resources through script tags may take more time for completing the page loading. So what I’ve done was I’ve loaded the smallest module of YUI framework, which is YUI Loader utility using a script tag and loaded the rest of the framework resources through YUI Loader utility.

/*The following function will load the YUI  modules: <a href="http://developer.yahoo.com/yui/dom/" title="YUI Dom">Dom</a>, <a href="http://developer.yahoo.com/yui/event/" title="YUI Event">Event</a> and <a href="http://developer.yahoo.com/yui/connection/" title="YUI Connection Manager">Connection manager</a>*/
Global.loadYui = function () {
	var loader = new YAHOO.util.YUILoader({
		base: "",
		require: ["connection", "dom", "event"],
		loadOptional: false,
		combine: true,
		filter: "MIN",
		allowRollup: true,
		onSuccess: function () {
			//You can place any code that needs to be executed after loading YUI source files here.
			//After the YUI framework file loading we attach the event handler to the button available in the page.
			YAHOO.util.Event.on("btnLoad", "click", function () {
				Global.makeAjaxCall(Global.argumentsObject);
			});
		}
	});
	//The following function call will insert the YUI modules in the page DOM
	loader.insert();
};

The above code will perform three following things:

• It will load YUI modules Connection, Dom and Event
• After loading the YUI modules it will execute the onSuccss function
• An onclick event handler will be attached to a button element whose ID is btnLoad

You need to edit the following code snippet with your own details before proceeding further

Global.argumentsObject = {
	url: "http://www.theremoteserver.com/yourresourcefile.ext",	//Replace this url with your own external server's url (the one in which you've placed the policy file) and resource name
	method: "GET",			//By default GET
	cache: false,	//Can be true or false
	xdr: true,	//Should be true for XDR communications
	flashFile: "flash_file_path/flash_file_name.swf" //Please include the correct path of the flash movie that we are going to use to make this all possible.
};

Mostly you’ll need to change the first and the last properties of the Global.argumentsObject object literal with the correct details of yours. Make sure that you keep the xdr property value as true if you are intending Cross/Sub-Domain Ajax calls.

A click on the button will start the first stage of the Ajax call. This will invoke Global.makeAjaxCall function, which is responsible for making the Ajax call and handling the callbacks.

Global.makeAjaxCall = function (paramObject) {
	if (YAHOO.lang.isUndefined(paramObject.url) || YAHOO.lang.trim(paramObject.url) === "") {
		alert("Provide a url to proceed further");
		return false;
	}
	paramObject.method = paramObject.method || "GET";
	paramObject.cache = paramObject.cache || false
	if (paramObject.xdr === true && (!YAHOO.lang.isUndefined(paramObject.url) || YAHOO.lang.trim(paramObject.url) !== "")) {//Makes XDR Call
		YAHOO.util.Connect.transport(paramObject.flashFile);
		YAHOO.util.Connect.xdrReadyEvent.subscribe(function () {
			//This JS literal object is responsible for making the function calls after the Ajax call occur.
			var callback = {
				success: function (o) {
					//The cross-domain Ajax call is success this section will be executed
					YAHOO.util.Dom.get("container").innerHTML = o.responseText; //After the cross-domain Ajax we insert the response from external server to one of the elements in the DOM
				},
				failure: function (o) {
					//The cross-domain Ajax call is failure this section will be executed
					alert("Ajax call failed");
				},
				cache: paramObject.cache,
				xdr: true //This parameter will tell we are going to make a cross-domain Ajax call through flash plugin.
			};
			//The following function call will make the Ajax call and pass the callback object
			YAHOO.util.Connect.asyncRequest(paramObject.method, paramObject.url, callback);
		});
	} else { //Normal Ajax call will be handled by this section
		//This JS literal object is responsible for making the function calls after the Ajax call occur.
		var callback = {
			success: function (o) {
				//The cross-domain Ajax call is success
				YAHOO.util.Dom.get("container").innerHTML = o.responseText; //You can place your code here that needs to be executed afer the successful Ajax call
			},
			failure: function (o) {
				alert("Ajax call failed");
			},
			cache: paramObject.cache
		};
		//The following function call will make the Ajax call and pass the callback object
		YAHOO.util.Connect.asyncRequest(paramObject.method, paramObject.url, callback);
	}
};

The above function accepts a object literal as its parameter. We’ll use the earlier defined Global.argumentsObject for this purpose. The parameter should contain a url value for proceeding with this method.

By default the HTTP method used is GET. If you want POST then you’ll have to specify it in Global.argumentsObject object.

By default the Ajax call cache will be false. If you want it to be true then specify it in Global.argumentsObject object.

Make sure that the xdr property in Global.argumentsObject object is true for making the Cross/Sub-Domain Ajax calls to work

The basic functionality of the above mentioned code is it will make an XDR call to the mentioned server, which contains the cross-domain policy file that I have mentioned earlier. After gathering the response from the external server JS will insert the response in a div element whose id is “container”.

Before making the Cross/Sub-domain Ajax call we need to initialize the Flash transport that we use (the flash movie). The following code will do that

YAHOO.util.Connect.transport(paramObject.flashFile);

We can proceed further only after finishing the Flash transport initialization. In our case we’ve subscribed the xdrReadyEvent, which will be executed after initializing the Flash correctly. We’ve achieved that using the following code

YAHOO.util.Connect.xdrReadyEvent.subscribe(function () {
	//This JS literal object is responsible for making the function calls after the Ajax call occur.
	var callback = {
		success: function (o) {
			//The cross-domain Ajax call is success this section will be executed
			YAHOO.util.Dom.get("container").innerHTML = o.responseText; //After the cross-domain Ajax we insert the response from external server to one of the elements in the DOM
		},
		failure: function (o) {
			//The cross-domain Ajax call is failure this section will be executed
			alert("Ajax call failed");
		},
		cache: paramObject.cache,
		xdr: true //This parameter will tell we are going to make a cross-domain Ajax call through flash plugin.
	};
	//The following function call will make the Ajax call and pass the callback object
	YAHOO.util.Connect.asyncRequest(paramObject.method, paramObject.url, callback);
});

This code make sure that the Cross/Sub-Domain Ajax call will be made only after initializing the Flash transport, which is responsible for making the whole communication. The callback JavaScript object literal is an object passing the callbacks that needs to be executed after the Ajax call and also the required properties (cache and xdr) to YUI Connection Manager.

var callback = {
	success: function (o) {
		//The cross-domain Ajax call is success this section will be executed
		YAHOO.util.Dom.get("container").innerHTML = o.responseText; //After the cross-domain Ajax we insert the response from external server to one of the elements in the DOM
	},
	failure: function (o) {
		//The cross-domain Ajax call is failure this section will be executed
		alert("Ajax call failed");
	},
	cache: paramObject.cache,
	xdr: true //This parameter will tell we are going to make a cross-domain Ajax call through flash plugin.
};
YAHOO.util.Connect.asyncRequest(paramObject.method, paramObject.url, callback); //The Ajax calling code

The above JavaScript literal object will be passed to YUI’s Connection Manager’s asyncRequest function

The success function in the callback object literal will be execute if the Ajax call was a success and the Ajax object will be passed to the function from which the code can access the response either through using responseText or responseXML proerties.

YAHOO.util.Dom.get("container").innerHTML = o.responseText;

This code will just extract the response from the server and insert it in an HTML element whose ID is “container”

Summary

Web 2.0 uses Ajax technology extensively. Unfortuanately Ajax does not allow cross/sub-domain communications due to the security restrictions imposed by the browsers. This problem can be tackled either through a server-side proxy or through a method that uses the Flash plugin installed in the browsers (most of them). YUI’s Connection Manager provides a simple method for making this communication possible. This method is suitable for making any cross/sub-domain Ajax calls without much trouble.

อิอิ แบบว่าพึ่งศึกษา visual studio .net เหมือนกันยังไม่โปรหรอกนะครับ แต่ว่าเจอปัญหาบ่อย ๆ เลยอยากแนะนำคนที่เริ่มศึกษาเหมือนกันนะสำหรับคนที่โปรแล้วก็ถือว่าดูเด็กเล่านิทานแล้วกันกันครับ

หลาย ๆ ท่านคงเคยมีปัญหาใช้ Masterpage ใน visaul studio แล้วใช้ javascript ในหน้าที่ content ที่อ้างอิง Masterpage มีปัญหาใช้ไม่ได้ อ้างอิงไม่ถูก เป็นเพราะ หน้า content นั้นมีการปรับเปลี่ยน id ของ component ดังนั้นเวลาจะอ้างอิง เราเอา javascript  code ไปไว้ส่วน head ของหน้า Masterpage หรือแยกไฟล์ออกไปเป็น javascript ต่างหากก็สุดแล้วแต่

หลังจากนั้นลอง รันหน้า content แล้ว view code  เพื่อดู id ที่แท้จริงก่อนการอ้างอิง หรือจะดูจาก Control.ClientID.ToString() ที่ .Net จะได้เป็นค่า id ที่ .Net เจนเป็น html แล้วส่งค่านี้เข้าไปใน javascript ก็ได้ครับจึงจะสามารถใช้ javascript ที่อยู่หน้า Masterpage ได้เช่น ปรกติเราเซต id = “lbltext” แต่เมื่อผ่านหน้า content ค่า id จะเปลี่ยนไปเช่น id=”clt00_content0_lbltex” ซึ่งเป็น id ที่ javascirpt จาก Masterpage จะอ้างอิงได้ถูกต้อง เป็นต้น



Today I was reading around in a forum when I came across a post of someone claiming to be a web developer.  What struck me as odd was that the person making the claim was looking for a freelance developer to help him with his website.  That is not the part that struck me as odd,  he then stated that he did not know JavaScript, Flash, PHP, or any server side language.  How I took this was that the kid knew HTML and that was all.  Yes, it is true that knowing HTML or xHTML is definitely one of the most important parts of web development it is by no means the be all end all of web development.

I know that it may seem harsh, but to tell you the truth it is actually quite insulting to hear someone that only knows how to mark up a document call himself a web developer.  The developer part of the name insinuates that he knows how to program.  HTML is not programming, it is just structuring  a page to look a certain way.  All of the functionality that we have come so accustomed to is actually the result of a programmer using some sort of client side or server side scripting language like JavaScript, PHP, or ASP.NET.  The difference might sound quite subtle, but in reality it is like night and day.  My point is this,  if you truly want to call yourself a web developer, and not just a web designer, don’t stop on HTML.  There is so much more to the world of programming, and web development then just marking up a document.  Study hard, read a lot, code a lot, always seek to keep learning and then you can be a true developer.

Até a pouco tempo eu estava usando como ferramenta gratuíta para edição WEB o APTANA. Que na versão 1.5 tinha bom suporte a PHP e Javascript. Todavia da versão 2.0 pra diante, o pessoal do APTANA abandonou o suporte nativo a PHP. Só percebi depois de desinstalar a versão 1.5 e instalar a 2.0.

Temporariamente retomei a utilização do Dreamweaver 8 (não é gratuíto) e que apesar de ser uma versão desatualizada, continua com algumas opções mais completas que os editores gratuítos que temos à disposição.

Mas retomei minha busca por editores gratuítos, e fiquei surpreso com o Netbeans 6.8 customizado para PHP. Pra começar… o tamanho do arquivo de Download: 25MB contra os 135MB do Aptana 2.0. Eu disse míseros 25 Megalhões de Bytes! Veja com seus próprios olhos no site de Download: http://netbeans.org/downloads/index.html (na opção de download Netbeans para PHP).

De cara deu pra perceber que também não é tão pesado para abrir o programa, instalei-o em um note Intel Dualcore 1.8Ghz com 2GB de RAM e Windows Vista.  Para ser mais preciso… não abre tão rápido quanto o bloco de notas hahaha mas também perde para o Dreamweaver 8.

Recursos encontrados:

Interface em Português
(dispensa comentários)

Search e replace em todo o projeto

Este é um recurso que me era muito útil no Dreamweaver, mas que não estava disponível no Aptana. Necessário quando vc quer modificar o nome de uma variável, função ou método que vc criou, e está sendo chamada em diversos arquivos. Talvez vc nem lembre todos os locais que será necessário modificar. Nesta hora a ferramenta detona.

Sugestão para comandos PHP e Javascript, incluíndo detalhes sobre as funções

Este recurso é encontrado tanto no Dreamweaver quanto no Aptana. E o Netbens faz bonito.

O mesmo vale para Javascript, HTML e CSS.

Localiza os métodos e atributos da Classe em que vc está trabalhando
Já trabalhei com java, e meu ambiente de trabalho era justamente o Netbeans. Apreciava o recurso oferecido por ele, em que dentro de uma classe vc pode digitar “this.” e ele suge os métodos e atributos disponíveis na classe.  Tal recurso está inteiramente disponível na versão do ambiente Netbeans para PHP.

Perceba na figura acima, que ao selecionar um dos métodos de minha classe, ele apresenta inclusive a documentação do método. Claro… vc precisa seguir o padrão de documentação PHP, e informar antes de cada método seu propósito e parâmetros, como no exemplo abaixo:

Suporte a TAGs HTML

Vc pode escrever código HTML tranquilamente, que ele oferece sujestão para nomes das TAGs e também para os atributos. Se vc escrever a tag body como esta:  <body style=”color: red “></body>    pode localizar a propriedade style, e nos valores para o atributo, virão também automaticamente as sugstões de comandos CSS, como color e após selecionar este colocando dois pontos “:” será apresentada uma modesta lista de cores. Achei pobre a lista de cores neste caso, mas funciona amigavelmente.

Suporte avançado a CSS

Não utilizei o recurso ainda por tempo suficiente para afirmar que seja excelente, ou apontar possíveis defeitos. Porém percebi que possui recursos interessantes. Quando um arquivo “.css” é aberto, um painel é apresentado com ferramentas para manutenção dos parâmetros do CSS.

Mais detalhes na figura abaixo:

Dá pra notar que ele mostra inclusive um exemplo de texto com a formatação a direita. Neste quesito o APTANA era o mais pobre… oferecia como grande recurso uma cubo de 216 cores para ajudar na escolha das cores para atributos CSS.

Pontos Negativos

1) Falta uma interface WYSIWYG para delinear interfaces HTML.  Aliás quanto a este recurso, dos programas que experimentei só o Dreamwever oferece algo realmente satisfatório. Sei que para o bom desenvolvedor, aquele que conhece os recursos de HTML e CSS, até não faz muita falta. Mas acho interessante por exemplo para preparar rapidamente uma página estática em HTML com textos e figuras. Principalmente para copiar com a formatação um texto que vc copia do Writer Open Office, ou no Office Word. Facilita também para colar uma lista de valores no HTML, pois com WYSIWYG é rapidinho e intuitivo preencher uma tabela.

2) [Ponto de vista Pessoal] Não oferece suporte nato a bibliotecas javascript mais conhecidas como Jquery e Dojo. Seria interessande em meio a um código JavaScript digitar “dojo.” e ele oferecer as opções da API Dojo. Talvez até haja uma forma de acrescentar um plugin de terceiros ou coisa parecida, investiguei superficialmente e não tive um resultados satisfatórios. Neste ponto o APTANA faz bonito e o Dreamweaver 8 também é isento.

Conclusão

Temos aí um editor WEB para PHP, HTML, JAVASCRIPT e CSS  de ótimo nível entre os da categoria FREEWARE, fácil de instalar, arquivo de Download relativamente pequeno, bons recursos. Vale a pena testar!

Grande Abraço

Sortable Table

http://www.pengoworks.com/workshop/jquery/tablesorter/

http://docs.jquery.com/Tutorials:Getting_Started_with_jQuery#Sort_me:_Using_the_tablesorter_plugin

Sorting Issue for Digits explained – http://stackoverflow.com/questions/302749/jquery-tablesorter-problem

Collapsible Table

http://www.exforsys.com/tutorials/jquery/jquery-collapsing-and-expanding-table-rows.html

http://csscreator.com/node/30150

A few months ago I was writing a post on the Pheromone Lab entitled “The Death of the Mobile Website”. The basic point of it was, as the landscape of web-ready devices become less segregated between “Desktop”, “Smartphones” and “Mobile”, and as we advance towards a more continuous ecosystem, we need to learn to design flexible interfaces that can adapt to a wide range of size, resolution, capabilities and modes of use.

A few weeks ago, Apple, a leader in sales of mobile devices, apparently started contacting selected developers with one message: stop assuming that you are building applications for 320×480px screens.

Score one for flexible design.

So, how can one create applications that would feel and work great in the current fragmented market of web devices? I’ve had, for a long time now, a hunch that web standard technologies such as HTML and CSS had the answer. HTML and CSS were made to meet this challenge, to build interfaces that scale, to cascade differently according to the media. The new CSS3 Media Queries pushes this capability quite far already, and I have been looking forward to experimenting more with it.

I was surprised, however, by a very interesting new trend: HTML+CSS+JS are being used not as the final UI layer for web applications, but instead as a programming language to be compiled into other languages (such as objectiveC, Java etc.) and the deployed, with native UI look and feel, onto a variety of devices.

This is the strategy currently followed by Nitobi’s PhoneGap and Appcelerator’s Titanium, both of which allow development using the basic Web technologies and JavaScript API, and package the result into “native apps” for iPhone, Android (and blackberry).

This could be a very exciting development for web standards as base layers for everything on the web… including applications that have very little to do with the Web paradigm. And for designers and developers, this could be the solution to the conundrum of flexible design and multi-platform development.

Score two for flexible design.

This article is dedicated to shedding light on those questions I have had in my programming experience that I just never found a clear answer for on the web; that I had to take the hints that I found from Google and go playing around for myself until I found a solution. Hopefully someone will benefit from my hours of trial and error.

Javascript and Master Pages

This is a subject that causes a lot of confusion. Many times when I am searching for a reason why my code is not working, I forget to add to my search the keywords “master page”. I forget that I am even using a master page and that it could ultimately be the source of my problem. The main reason beginning programmers are confronted with problems when incorporating javascript in their code is that javascript’s language is client side, and .net is server side, which is what we are used to.

What does this mean? Well, when we use a client side script, we have to call the controls we are using by the ID’s they are given after the page has rendered in the browser. In master pages, rendered code has different control names than what you are used to seeing. They are given new identities so that they can be identified within a master page which may or may not have identically named controls in its code.

How to overcome? Anytime you use Javascript to reference an asp.net control, you must reference its full control name post-browser rendering. There are many ways to do this that you can find on the web, but the easiest way uses no extra code at all. Simply build your page up to the point where you want to add javascript. Before you do, either debug your page, or preview it in the browser and when you target control is visible, choose view->source from the browser’s menu. Here you will see the rendered code for your entire page. Search through the code for your control and notice its ID name, it should be similar to ctl00_ContentPlaceHolder1_yourcontrolname . When you need to reference the form that your control resides within, it will always be aspnetform.

Master pages with Javascript pop up calendar pickers

As mentioned above, most .NET/Javascript woes are caused by their control ID’s being referenced incorrectly. This problem is often highlighted when programmers try to incorporate pop up calendar pickers in their code. Please see the paragraphs ahead of this section for instructions to find your text field’s control name to reference in your window.open code.

Top 5 jQuery Based Gallery / Slideshow Plugin

1) s3Slider
DEMO
WEBSITE

2) Galleriffic

Galleriffic is a jQuery plugin that provides a rich, post-back free experience optimized to handle high volumes of photos while conserving bandwidth. I am not so great at spelling, and it was much later that I realized that the more appropriate spellings would be Gallerific or Gallerrific, but is too late now for a name change, so Galleriffic remains.

DEMO
WEBSITE

3)Slider Gallery

This shows a demonstration of a slider widget from the jQuery UI library used to create the same effect used on Apple’s web site.

DEMO
WEBSITE

4) AJAX Image Gallery

You can drag the Slideflow using your mouse, or click anywhere in the stack to jump there. Click inside the frame in order to enable mouse wheel and arrow key navigation! Or better yet,

DEMO
WEBSITE

5)Polaroid Gallery v.1.01

Polaroid Gallery is a free, opensource flash gallery developed by myself, Christopher Einarsrud, in the year of 2006.
I was originally going to use this for my online portfolio, but I ended up going for something completely different.
I thought that it might come in handy for someone else, so I decided to release it here. After all, I did put some work into it and it would be a pity to see it all go to waste

DEMO
WEBSITE