understanding design pattern of a jquery gallery plugin

understanding design pattern of a jquery gallery plugin

hey guys i was just going through the code of a gallery plugin and i have been on this for a few hours now , basiclly the plugin has the following code structure , have a look :

  1. (function( $, undefined ) {

  3.     /*
  4.      * Gallery object.
  5.      */
  6.     $.Gallery               = function( options, element ) {    

  8.         this.$el    = $( element );
  9.         this._init( options );

  11.     };

  13.     $.Gallery.defaults      = {
  14.         current     : 0,    
  15.         autoplay    : false,
  16.         interval    : 2000      };

  18.     $.Gallery.prototype     = {
  19.         _init               : function( options ) {

  21.         },
  22.         _validate           : function() {

  24.         },
  25.         _layout             : function() {


  28.         },
  29.         _setItems           : function() {

  31.         },
  32.         _loadEvents         : function() {


  35.         },
  36.         _getCoordinates     : function( position ) {


  39.         },
  40.         _navigate           : function( dir ) {


  43.         },
  44.         _startSlideshow     : function() {


  47.         },
  48.         destroy             : function() {


  51.     };

  53.     var logError            = function( message ) {

  55.     };

  57.     $.fn.gallery            = function( options ) {


  60.         if ( typeof options === 'string' ) {            

  62.             this.each(function() {

  64.                 // do something 

  66.             });

  68.         } 
  69.         else {


  72.             this.each(function() {

  74.                 // do something

  76.             });

  78.         }

  80.         return this;

  82.     };

  84. })( jQuery );
now i have worked on a few jquery plugin earlier , but never come across such a plugin structure before , espically the below poniters are a bit weird , have a look :

1.  There is just one prototype used in the plugin ,

  1. $.Gallery.prototype = {

  3.   // all the functions are written here . 

  5. };
2.  using this pattern this always actually points to gallery(which is the main object ) and thus makes it easy to make calls to other functions in the prototype chain :

  1. $.Gallery.prototype    = {
  2.             _init               : function( options ) {
  3. // since this is actually pointing to gallery here , you can call _validate directly here , by just saying this.validate() }, _validate : function() {

  5.                 },

So i have a question here, what design patterns is this ? and what are its obvious advantages ?