script.aculo.usを読み解く

第13回dragdrop.js(後編)

今回のSortableクラスは、ulタグ要素を与えるだけで、中のliタグ要素に全自動でドラッグ&ドロップ機能を適切に割り当てて、並び替えできるリストに変身させてしまう機能を提供します。また、並び替えできるツリーという機能もあり、これはulタグ要素の中のulタグ要素といったツリー構造を扱うために、コードが複雑です。ツリー構造の走査には、再帰呼び出しが活躍します。

SortableObserver

ドラッグの開始、途中、終了という3種のフックをまとめたクラスです。将来的にはObserverクラスを作ろうと考えているのでしょうが、その必要性を計りかねているようです。

0576:var SortableObserver = Class.create({
0577:  initialize: function(element, observer) {
0578:    this.element   = $(element);
0579:    this.observer  = observer;
0580:    this.lastValue = Sortable.serialize(this.element);
0581:  },
0582:  

576~582行目のinitializeは、インスタンスの初期化をする関数です。引数にドラッグする要素のDOM idと、ドラッグの終了時に呼ぶフックをとります。

580行目で、lastValueプロパティには、serialize関数の結果が入ります。これは並び順を文字列に出力したものです。

0583:  onStart: function() {
0584:    this.lastValue = Sortable.serialize(this.element);
0585:  },
0586:  

583~586行目のonStart関数は、ドラッグの開始時に呼ばれるフックです。このときの並び順を保存しておきます。

0587:  onEnd: function() {
0588:    Sortable.unmark();
0589:    if(this.lastValue != Sortable.serialize(this.element))
0590:      this.observer(this.element)
0591:  }
0592:});
0593:

587~593行目のonEnd関数は、ドラッグの終了時に呼ばれるフックです。

588行目のunmark関数は、後述するように、マークを非表示にする関数です。

589行目で、ドラッグ開始時と比べて、並び順に変化があれば、observerフック(実体は734行目にあるように、options.onUpdateです)を呼びます。

Sortable

0594:var Sortable = {
0595:  SERIALIZE_RULE: /^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
0596:  
0597:  sortables: { },
0598:  

595行目で、SERIALIZE_RULEは、この正規表現に一致するDOM idを持ったアイテム要素だけを処理の対象にします。この正規表現から分かるように、アイテム要素のDOM idは"名称_アイテムID"の形になっている必要があります。

597行目のsortablesは、このクラスのインスタンスを保持するハッシュテーブルです。キーにインスタンスのコンテナ要素のDOM idを、値にそのoptionsをとります。

0599:  _findRootElement: function(element) {
0600:    while (element.tagName.toUpperCase() != "BODY") {  
0601:      if(element.id && Sortable.sortables[element.id]) return element;
0602:      element = element.parentNode;
0603:    }
0604:  },
0605:

599~605行目の_findRootElementは、引数の要素のDOM階層を上にたどって、特に、並び替えリストのコンテナになっている親要素を求める関数です。

0606:  options: function(element) {
0607:    element = Sortable._findRootElement($(element));
0608:    if(!element) return;
0609:    return Sortable.sortables[element.id];
0610:  },
0611:  

606~611行目のoptionsは、引数の要素に上述の_findRootElement関数を使って、そのコンテナになっている親要素のoptionsを返す関数です。

0612:  destroy: function(element){
0613:    var s = Sortable.options(element);
0614:    
0615:    if(s) {
0616:      Draggables.removeObserver(s.element);
0617:      s.droppables.each(function(d){ Droppables.remove(d) });
0618:      s.draggables.invoke('destroy');
0619:      
0620:      delete Sortable.sortables[s.element.id];
0621:    }
0622:  },
0623:

612~623行目のdestroyは、引数の要素に上述のoptions関数を使って、そのコンテナになっている親要素から並び替えリストの機能を取り除く関数です。

616行目で、DraggablesクラスのremoveObserver関数でフックを外します。

617行目で、その並び替えリストを構成するDroppablesクラスのインスタンスたちを、それぞれremove関数で削除します。ここで618行目のようにinvoke('remove')を使えないのは、同名の関数であるPrototype.jsのElement.removeが優先して呼ばれてしまうからです。

618行目で、その並び替えリストを構成するDraggablesクラスのインスタンスたちにinvokeメソッドを使って、それぞれdestroy関数で削除します。

620行目で、sortablesハッシュテーブルからこのインスタンスを削除します。

0624:  create: function(element) {
0625:    element = $(element);
0626:    var options = Object.extend({ 
0627:      element:     element,
0628:      tag:         'li',       // assumes li children, override with tag: 'tagname'
0629:      dropOnEmpty: false,
0630:      tree:        false,
0631:      treeTag:     'ul',
0632:      overlap:     'vertical', // one of 'vertical', 'horizontal'
0633:      constraint:  'vertical', // one of 'vertical', 'horizontal', false
0634:      containment: element,    // also takes array of elements (or id's); or false
0635:      handle:      false,      // or a CSS class
0636:      only:        false,
0637:      delay:       0,
0638:      hoverclass:  null,
0639:      ghosting:    false,
0640:      quiet:       false, 
0641:      scroll:      false,
0642:      scrollSensitivity: 20,
0643:      scrollSpeed: 15,
0644:      format:      this.SERIALIZE_RULE,
0645:      
0646:      // these take arrays of elements or ids and can be 
0647:      // used for better initialization performance
0648:      elements:    false,
0649:      handles:     false,
0650:      
0651:      onChange:    Prototype.emptyFunction,
0652:      onUpdate:    Prototype.emptyFunction
0653:    }, arguments[1] || { });
0654:

624~740行目のcreate関数は、引数の要素に、全自動でドラッグ&ドロップ機能を適切に割り当てて、並び替えできるリストを作る関数です。

まずは前半部分、624~654行目を扱います。これはオプションを処理します。このクラスに特有なオプションは以下だけで、残りはDraggablesクラスとDroppablesクラスのためのものです。

tag
デフォルトは'li'です。並び替えリストのアイテムにする要素のタグ名です。
dropOnEmpty
デフォルトはfalseです。trueにすると、並び替えリストのコンテナ自身がドロップ可能要素になるので、アイテムがひとつもないときでもドラッグを受け入れられるようになります。
tree
デフォルトはfalseです。trueにすると、並び替えツリーを作ります。並び替えツリーでは、treeTagの要素でできたツリー構造を並び替えることができます。
treeTag
デフォルトは'ul'です。並び替えツリーで、ツリー構造を表現する要素のタグ名です。
only
デフォルトはfalseです。CSSクラスかその配列を指定します。受けつける要素を、containmentでの制限以上に絞るためのオプションで、それらのクラスのいずれかを持つ要素しか受けつけないようになります(containmentオプションは、前回解説したように、Droppablesクラスのオプションで、要素のDOM idか、DOM idの配列を指定し、その子要素のドロップだけを受けつけるように制限するオプションです⁠⁠。
format
アイテムのDOM id(通常は"名称_アイテムID"の形式)から、名称の部分とアイテムIDの部分の値を取り出すための正規表現です。
elements
デフォルトでは、並び替えリストにする要素を全自動で計算するようになっていますが、このオプションに、そのような要素のDOM idの配列を人間の手で記述して渡してやることで処理時間を短縮できます。
handles
デフォルトでは、並び替えリストのアイテムのハンドル(把手)にする要素を全自動で計算するようになっていますが、このオプションに、そのような要素のDOM idの配列を人間の手で記述して渡してやることで、処理時間を短縮できます。
onChange
ドラッグに伴ってリストの並び順が変わった瞬間に呼ばれるフックです。また、ドラッグ中の要素が別の並び替えリストに出て行ったときも、このフックが呼ばれます。引数にドラッグ中の要素をとります。
onUpdate
ドラッグ終了時にリストの並び順が変わっていたときに呼ばれるフックです。引数に並び替えリストのコンテナをとります。このフックの呼び出し元のSortableObserver.onEndにあるように、このフックの動作はSortable.serializeの結果に依存しているので、アイテムのDOM idが適切な形式になっているか、くれぐれも注意してください。
0655:    // clear any old sortable with same element
0656:    this.destroy(element);
0657:
0658:    // build options for the draggables
0659:    var options_for_draggable = {
0660:      revert:      true,
0661:      quiet:       options.quiet,
0662:      scroll:      options.scroll,
0663:      scrollSpeed: options.scrollSpeed,
0664:      scrollSensitivity: options.scrollSensitivity,
0665:      delay:       options.delay,
0666:      ghosting:    options.ghosting,
0667:      constraint:  options.constraint,
0668:      handle:      options.handle };
0669:
0670:    if(options.starteffect)
0671:      options_for_draggable.starteffect = options.starteffect;
0672:
0673:    if(options.reverteffect)
0674:      options_for_draggable.reverteffect = options.reverteffect;
0675:    else
0676:      if(options.ghosting) options_for_draggable.reverteffect = function(element) {
0677:        element.style.top  = 0;
0678:        element.style.left = 0;
0679:      };
0680:
0681:    if(options.endeffect)
0682:      options_for_draggable.endeffect = options.endeffect;
0683:
0684:    if(options.zindex)
0685:      options_for_draggable.zindex = options.zindex;
0686:
0687:    // build options for the droppables  
0688:    var options_for_droppable = {
0689:      overlap:     options.overlap,
0690:      containment: options.containment,
0691:      tree:        options.tree,
0692:      hoverclass:  options.hoverclass,
0693:      onHover:     Sortable.onHover
0694:    }
0695:    
0696:    var options_for_tree = {
0697:      onHover:      Sortable.onEmptyHover,
0698:      overlap:      options.overlap,
0699:      containment:  options.containment,
0700:      hoverclass:   options.hoverclass
0701:    }
0702:
0703:    // fix for gecko engine
0704:    Element.cleanWhitespace(element); 
0705:
0706:    options.draggables = [];
0707:    options.droppables = [];
0708:
0709:    // drop on empty handling
0710:    if(options.dropOnEmpty || options.tree) {
0711:      Droppables.add(element, options_for_tree);
0712:      options.droppables.push(element);
0713:    }
0714:
0715:    (options.elements || this.findElements(element, options) || []).each( function(e,i) {
0716:      var handle = options.handles ? $(options.handles[i]) :
0717:        (options.handle ? $(e).select('.' + options.handle)[0] : e); 
0718:      options.draggables.push(
0719:        new Draggable(e, Object.extend(options_for_draggable, { handle: handle })));
0720:      Droppables.add(e, options_for_droppable);
0721:      if(options.tree) e.treeNode = element;
0722:      options.droppables.push(e);      
0723:    });
0724:    
0725:    if(options.tree) {
0726:      (Sortable.findTreeElements(element, options) || []).each( function(e) {
0727:        Droppables.add(e, options_for_tree);
0728:        e.treeNode = element;
0729:        options.droppables.push(e);
0730:      });
0731:    }
0732:
0733:    // keep reference
0734:    this.sortables[element.id] = options;
0735:
0736:    // for onupdate
0737:    Draggables.addObserver(new SortableObserver(element, options.onUpdate));
0738:
0739:  },
0740:

次に、create関数の後半部分、655~740行目を解説します。

656行目で、この要素を含む並び替えリストがあれば、それを破棄します。

658~702行目で、Droppables、Draggablesクラスのためにオプションを割り振ります。これらのオプションの意味は前回を参照してください。

706行目のoptions.draggablesは、この並び替えリストを構成するドラッグ可能要素を保持する配列です。

707行目のoptions.droppablesは、この並び替えリストを構成するドロップ可能要素を保持する配列です。

710行目で、options.dropOnEmptyがtrueか、あるいはoptions.treeがtrueならば、このコンテナ自身をドロップ可能要素にします。

715~732行目が、コンテナ内部の要素に適切にドラッグ&ドロップ機能を加えて、並び替えリストを構築する処理です。

715行目で、後述のfindElements関数で、コンテナ内部で並び替えリストのアイテムになるべき要素たちを求めます。ただし前述のとおり、options.elementsにそれを記述してやることで、この関数の呼び出しを省略できるようになっています。

716行目で、アイテムのなかに、ハンドル(把手)になるべき要素があれば取り出します。

718行目で、アイテムをドラッグ可能要素にします。

720行目で、アイテムをドロップ可能要素にします。並び替えリストというと、アイテムをドラッグだけできれば良さそうな気もしますが、ドラッグ中のアイテムが"挿入位置のアイテムを押しのける"ように見える動作は、実際は、ドロップ可能要素が"上空のドラッグ中のアイテムを避ける"ことで実現されているので、ドロップ可能にしておく必要があります。

721行目で、options.treeがtrueならば、アイテムのツリー構造上の親ノードをこのコンテナにします。

725行目で、options.treeがtrueならば、後述のfindTreeElements関数で、コンテナ内部で並び替えツリーのツリー構造になる要素たちを求め、eachメソッドで727~729行目の処理を行います。

727行目で、これらの要素をドロップ可能にします。これでツリーのドラッグを受け入れられるようになります。

729行目で、これらの要素のツリー構造上の親ノードをこのコンテナにします。

734行目で、sortablesハッシュテーブルに、このコンテナを追加します。

737行目で、このコンテナ全体のフックを追加します。

0741:  // return all suitable-for-sortable elements in a guaranteed order
0742:  findElements: function(element, options) {
0743:    return Element.findChildren(
0744:      element, options.only, options.tree ? true : false, options.tag);
0745:  },
0746:  

741~746行目のfindElementsは、並び替えリストが含むアイテム要素を列挙する関数です。内部的には、後述のElement.findChildren関数を使っています。有り体にいえば、引数の要素以下のDOMツリーをたどって、'li'タグ要素を列挙する関数です。

0747:  findTreeElements: function(element, options) {
0748:    return Element.findChildren(
0749:      element, options.only, options.tree ? true : false, options.treeTag);
0750:  },
0751:

747~751行目のfindTreeElementsは、並び替えツリーに含まれるツリー要素を列挙する関数です。内部的には、後述のElement.findChildren関数を使っています。有り体にいえば、引数の要素以下のDOMツリーをたどって、'ul'タグ要素を列挙する関数です。

0752:  onHover: function(element, dropon, overlap) {
0753:    if(Element.isParent(dropon, element)) return;
0754:
0755:    if(overlap > .33 && overlap < .66 && Sortable.options(dropon).tree) {
0756:      return;
0757:    } else if(overlap>0.5) {
0758:      Sortable.mark(dropon, 'before');
0759:      if(dropon.previousSibling != element) {
0760:        var oldParentNode = element.parentNode;
0761:        element.style.visibility = "hidden"; // fix gecko rendering
0762:        dropon.parentNode.insertBefore(element, dropon);
0763:        if(dropon.parentNode!=oldParentNode) 
0764:          Sortable.options(oldParentNode).onChange(element);
0765:        Sortable.options(dropon.parentNode).onChange(element);
0766:      }
0767:    } else {
0768:      Sortable.mark(dropon, 'after');
0769:      var nextElement = dropon.nextSibling || null;
0770:      if(nextElement != element) {
0771:        var oldParentNode = element.parentNode;
0772:        element.style.visibility = "hidden"; // fix gecko rendering
0773:        dropon.parentNode.insertBefore(element, nextElement);
0774:        if(dropon.parentNode!=oldParentNode) 
0775:          Sortable.options(oldParentNode).onChange(element);
0776:        Sortable.options(dropon.parentNode).onChange(element);
0777:      }
0778:    }
0779:  },
0780:  

752~780行目のonHoverは、引数に、ドラッグ中の要素、そのドラッグが上空にきているドロップ可能要素、それらの要素の重なり具合をとります。これは、ドラッグ中のアイテムが"挿入位置のアイテムを押しのける"ように見える動作を行う関数です。この動作は実際は、ドロップ可能要素が"上空のドラッグ中のアイテムを避ける"ことで実現されています。ここで問題になるのは、前に避けるか、後に避けるかということです。要素の重なり具合からそれを判断します。

753行目で、Element.isParentは後述しますが、つまり、もしドロップ先の要素が、ドラッグ中の要素の子孫に含まれていたら、何も処理しないということです。

755行目で、overlapの値が(0.33~0.66)の範囲にあり、ドロップ先のoptions.treeがtrueならば、何も処理しません。つまり、だいたい中央に重なっていて、かつドロップ先が並び替えツリーならば、避ける動作をしないということです。

757~766行目が、重なりのズレが"前側"のときの処理です。このときは、挿入位置はドロップ先要素の直前になります。

758行目で、後述のmark関数で、マーカーの位置を、ドロップ先要素の"前側"にします。

以下で、ドロップ先要素のDOMに挿入して、"挿入位置のアイテムを押しのける"動作をします。

759行目で、既にDOMに挿入してあるなら、何もしません。

760行目で、並び替えリスト間のアイテムの移動を検知するため、親ノードを記憶しておきます。

761行目で、"押しのける"ことでスペースが空いたように見えるのは、見えない要素がそこに挿入されるからです。

762行目で、ドロップ先要素のDOM位置の直前に挿入します。

763行目で、並び替えリスト間のアイテムの移動があったら、出どころの並び替えリストのonChangeフックを呼びます。

765行目で、ドロップ先の並び替えリストのonChangeフックを呼びます。

以降は、重なりのズレが"後側"のときの処理です。ほぼ同様なので解説は省略します。

0781:  onEmptyHover: function(element, dropon, overlap) {
0782:    var oldParentNode = element.parentNode;
0783:    var droponOptions = Sortable.options(dropon);
0784:        
0785:    if(!Element.isParent(dropon, element)) {
0786:      var index;
0787:      
0788:      var children = Sortable.findElements(dropon, {tag: droponOptions.tag, only: droponOptions.only});
0789:      var child = null;
0790:            
0791:      if(children) {
0792:        var offset = Element.offsetSize(dropon, droponOptions.overlap) * (1.0 - overlap);
0793:        
0794:        for (index = 0; index < children.length; index += 1) {
0795:          if (offset - Element.offsetSize (children[index], droponOptions.overlap) >= 0) {
0796:            offset -= Element.offsetSize (children[index], droponOptions.overlap);
0797:          } else if (offset - (Element.offsetSize (children[index], droponOptions.overlap) / 2) >= 0) {
0798:            child = index + 1 < children.length ? children[index + 1] : null;
0799:            break;
0800:          } else {
0801:            child = children[index];
0802:            break;
0803:          }
0804:        }
0805:      }
0806:      
0807:      dropon.insertBefore(element, child);
0808:      
0809:      Sortable.options(oldParentNode).onChange(element);
0810:      droponOptions.onChange(element);
0811:    }
0812:  },
0813:

781~813行目のonEmptyHoverは、ドラッグ中のアイテムをドロップ先の並び替えツリーのDOMに追加する関数です。それらの重なり具合と、要素ごとの位置関係を加味して、より自然な操作感を実現しています。引数に、ドラッグ中のアイテム、ドロップ先の並び替えツリー、それらの重なり具合、を取ります。

785行目で、Element.isParentは後述しますが、つまり、もしドロップ先の要素が、ドラッグ中の要素の子孫に含まれていたら、何も処理しないということです。

788行目で、findElements関数で、ドロップ先の並び替えツリーのアイテムを全て列挙します。

791~806行目で、それらのアイテムの位置関係から、ドラッグ中の要素を挿入するのにふさわしい位置にあるアイテムを求めます。

807行目で、ふさわしい位置にあるアイテムの直前にドラッグ中の要素を挿入します。

809行目で、ドラッグ中のアイテムが属していた並び替えツリーのonChangeフックを呼びます。

810行目で、ドロップ先の並び替えツリーのonChangeフックを呼びます。

0814:  unmark: function() {
0815:    if(Sortable._marker) Sortable._marker.hide();
0816:  },
0817:

814~817行目のunmarkは、マーカーを非表示にする関数です。

0818:  mark: function(dropon, position) {
0819:    // mark on ghosting only
0820:    var sortable = Sortable.options(dropon.parentNode);
0821:    if(sortable && !sortable.ghosting) return; 
0822:
0823:    if(!Sortable._marker) {
0824:      Sortable._marker = 
0825:        ($('dropmarker') || Element.extend(document.createElement('DIV'))).
0826:          hide().addClassName('dropmarker').setStyle({position:'absolute'});
0827:      document.getElementsByTagName("body").item(0).appendChild(Sortable._marker);
0828:    }    
0829:    var offsets = Position.cumulativeOffset(dropon);
0830:    Sortable._marker.setStyle({left: offsets[0]+'px', top: offsets[1] + 'px'});
0831:    
0832:    if(position=='after')
0833:      if(sortable.overlap == 'horizontal') 
0834:        Sortable._marker.setStyle({left: (offsets[0]+dropon.clientWidth) + 'px'});
0835:      else
0836:        Sortable._marker.setStyle({top: (offsets[1]+dropon.clientHeight) + 'px'});
0837:    
0838:    Sortable._marker.show();
0839:  },
0840:  

818~840行目のmarkは、マーカーを適切な位置に表示する関数です。引数にドロップ先の要素と、表示位置('before'か'after')をとります。

821行目で、コメントにもあるように、マーカーを表示するのは、ドロップ先の並び替えリストのoptions.ghostingが有効なときだけです。

823行目で、マーカーとなるべき要素が用意されていなかった場合は、即席にdiv要素を作り、表示を隠し、クラス名に'dropmarker'を加え、positionプロパティを'absolute'にします。

827行目で、そのdiv要素をbodyのすぐ下に追加します。

829行目で、Position.cumulativeOffsetで、ドロップ先の要素の位置を取得します。

830行目で、マーカーの位置は、表示位置が'before'ならば、ドロップ先の要素の直前の位置です。

832行目で、表示位置が'after'ならば、ドロップ先の要素の直後の位置です。ドロップ先の要素の幅、あるいは高さ分を補正します。

838行目で、マーカーを表示します。

0841:  _tree: function(element, options, parent) {
0842:    var children = Sortable.findElements(element, options) || [];
0843:  
0844:    for (var i = 0; i < children.length; ++i) {
0845:      var match = children[i].id.match(options.format);
0846:
0847:      if (!match) continue;
0848:      
0849:      var child = {
0850:        id: encodeURIComponent(match ? match[1] : null),
0851:        element: element,
0852:        parent: parent,
0853:        children: [],
0854:        position: parent.children.length,
0855:        container: $(children[i]).down(options.treeTag)
0856:      }
0857:      
0858:      /* Get the element containing the children and recurse over it */
0859:      if (child.container)
0860:        this._tree(child.container, options, child)
0861:      
0862:      parent.children.push (child);
0863:    }
0864:
0865:    return parent; 
0866:  },
0867:

841~867行目の_treeは、並び替えツリーのツリー構造を再帰的にたどり、すべてのアイテムを列挙した配列を返す関数です。引数に並び替えツリーのコンテナと、そのoptionsと、ツリー構造の親になっているアイテムをとります。この関数はserialize関数によって、すべてのアイテムの並び順を文字列に直すために使われます。

842行目で、findElements関数で、このコンテナが含むアイテムを取りだします。コンテナが含むコンテナのアイテムなどは取り出されないことに注意してください。

845行目で、取りだしたアイテムのDOM idがoptions.formatの形式(デフォルトでは"名称_アイテムID"の形式)に一致するか確かめます。

849~856行目で、アイテムの情報を作ります。

850行目のidは、アイテムのDOM idのアイテムIDの部分です。

851行目のelementは、このコンテナ自身です。

852行目のparentは、入れ子構造の親になっているアイテムです。

853行目のchildrenは、このコンテナに含まれる子アイテムのリストです。

854行目のpositionは、このコンテナが親にとって何番めの子かを表します。

855行目のcontainerは、このコンテナが含む、子のコンテナです。

859行目で、このコンテナに子のコンテナがあれば、それを再帰的にたどります。

862行目で、ツリー構造の親のアイテムのchildrenにこのアイテムを追加します。

865行目で、ツリー構造の親を返します。

0868:  tree: function(element) {
0869:    element = $(element);
0870:    var sortableOptions = this.options(element);
0871:    var options = Object.extend({
0872:      tag: sortableOptions.tag,
0873:      treeTag: sortableOptions.treeTag,
0874:      only: sortableOptions.only,
0875:      name: element.id,
0876:      format: sortableOptions.format
0877:    }, arguments[1] || { });
0878:    
0879:    var root = {
0880:      id: null,
0881:      parent: null,
0882:      children: [],
0883:      container: element,
0884:      position: 0
0885:    }
0886:    
0887:    return Sortable._tree(element, options, root);
0888:  },
0889:

868~889行目のtreeは、上述の_tree関数を再帰的に呼び出す起点となる関数です。引数に起点となる並び替えツリーのコンテナをとります。2番めの引数にそのオプションをとることができます。

879行目で、ツリー構造の根として、rootアイテムを作ります。

887行目で、上述の_tree関数を呼び出します。

0890:  /* Construct a [i] index for a particular node */
0891:  _constructIndex: function(node) {
0892:    var index = '';
0893:    do {
0894:      if (node.id) index = '[' + node.position + ']' + index;
0895:    } while ((node = node.parent) != null);
0896:    return index;
0897:  },
0898:

890~898行目の_constructIndexは、引数にtree関数がつくるアイテム情報をとり、そのツリー構造をrootアイテムに向かってたどりながら、それらのpositionの情報からアイテムのツリー構造上のインデックスを表現した"[i][j]..."という文字列を作って返す関数です。

0899:  sequence: function(element) {
0900:    element = $(element);
0901:    var options = Object.extend(this.options(element), arguments[1] || { });
0902:    
0903:    return $(this.findElements(element, options) || []).map( function(item) {
0904:      return item.id.match(options.format) ? item.id.match(options.format)[1] : '';
0905:    });
0906:  },
0907:

899~907行目のsequenceは、並び替えリストのコンテナを引数にとり、その並び順をアイテムIDの配列の形で返す関数です。2番めの引数に並び替えリストのオプションを取ることができます。

903行目で、findElementsでこのコンテナが含むアイテムを求めます。

904行目で、各アイテムのDOM id(デフォルトでは"名称_アイテムID"の形式)からアイテムIDを取り出します。

0908:  setSequence: function(element, new_sequence) {
0909:    element = $(element);
0910:    var options = Object.extend(this.options(element), arguments[2] || { });
0911:    
0912:    var nodeMap = { };
0913:    this.findElements(element, options).each( function(n) {
0914:        if (n.id.match(options.format))
0915:            nodeMap[n.id.match(options.format)[1]] = [n, n.parentNode];
0916:        n.parentNode.removeChild(n);
0917:    });
0918:   
0919:    new_sequence.each(function(ident) {
0920:      var n = nodeMap[ident];
0921:      if (n) {
0922:        n[1].appendChild(n[0]);
0923:        delete nodeMap[ident];
0924:      }
0925:    });
0926:  },
0927:  

908~927行目のsetSequenceは、並び替えリストのアイテムの順番を、並び順を記述したアイテムIDの配列のとおりにする関数です。引数に並び替えリストのコンテナと、並び順を記述したアイテムIDの配列をとります。3番目の引数に並び替えリストのオプションを取ることができます。

913行目で、findElementsでこのコンテナが含むアイテムを求めます。

914行目で、各アイテムのDOM id(デフォルトでは"名称_アイテムID"の形式)からアイテムIDを取り出します。

915行目で、nodeMapのハッシュテーブルに、キーをそのアイテムID、値を[アイテムの要素、アイテムの親要素]として追加します。

916行目で、アイテムのDOMの親子関係を切り離します。次でもう一度繋ぐことで、並び替えができます。

919行目で、並び順を記述したアイテムIDの配列にeachメソッドを使い、以下の処理で、アイテムのDOMの親子関係を再び繋ぎます。

920行目で、nodeMapハッシュテーブルから値を取り出すと、それが順序の互換関係になります。

922行目で、アイテムのDOMの親子関係を再び繋ぎます。

923行目で、一応、nodeMapから使用済みのアイテムを削除しておきます。

0928:  serialize: function(element) {
0929:    element = $(element);
0930:    var options = Object.extend(Sortable.options(element), arguments[1] || { });
0931:    var name = encodeURIComponent(
0932:      (arguments[1] && arguments[1].name) ? arguments[1].name : element.id);
0933:    
0934:    if (options.tree) {
0935:      return Sortable.tree(element, arguments[1]).children.map( function (item) {
0936:        return [name + Sortable._constructIndex(item) + "[id]=" + 
0937:                encodeURIComponent(item.id)].concat(item.children.map(arguments.callee));
0938:      }).flatten().join('&');
0939:    } else {
0940:      return Sortable.sequence(element, arguments[1]).map( function(item) {
0941:        return name + "[]=" + encodeURIComponent(item);
0942:      }).join('&');
0943:    }
0944:  }
0945:}
0946:

928~946行目のserializeは、現在の並び順を、Ajaxで送信するのに便利なクエリパラメータの形で出力する関数です。引数に並び替えリストのコンテナをとります。2番めの引数にそのオプションを取ることができます。

931行目で、変数nameにコンテナ名を設定します。デフォルトではコンテナのDOM idですが、オプションで指定することもできます。

934行目で、並び替えツリーであれば、上述のtree関数でアイテムの入れ子構造を計算します。rootアイテムのchildrenにmapメソッドをかけて、まずは入れ子の最初の段を処理します。

936行目で、コンテナ名やインデックスやアイテムIDを文字列結合します。さらにアイテムのchildren、つまりツリー構造の次の段に向かって、arguments.callee、すなわちこのserialize関数を、再帰的に適用します。

938行目で、配列の入れ子構造をflattenメソッドでつぶして、クエリパラメータとして&を区切り文字にして結合します。

939行目で、ツリーでなく、並び替えリストであれば、sequence関数の結果を整形するだけなので難しくありません。

0947:// Returns true if child is contained within element
0948:Element.isParent = function(child, element) {
0949:  if (!child.parentNode || child == element) return false;
0950:  if (child.parentNode == element) return true;
0951:  return Element.isParent(child.parentNode, element);
0952:}
0953:

947~953行目のElement.isParentは、引数に要素child、要素elementをとり、childがelementに含まれるかどうかを返します。

951行目で、再帰的にchild.parentNodeをたどって調べます。

0954:Element.findChildren = function(element, only, recursive, tagName) {   
0955:  if(!element.hasChildNodes()) return null;
0956:  tagName = tagName.toUpperCase();
0957:  if(only) only = [only].flatten();
0958:  var elements = [];
0959:  $A(element.childNodes).each( function(e) {
0960:    if(e.tagName && e.tagName.toUpperCase()==tagName &&
0961:      (!only || (Element.classNames(e).detect(function(v) { return only.include(v) }))))
0962:        elements.push(e);
0963:    if(recursive) {
0964:      var grandchildren = Element.findChildren(e, only, recursive, tagName);
0965:      if(grandchildren) elements.push(grandchildren);
0966:    }
0967:  });
0968:
0969:  return (elements.length>0 ? elements.flatten() : []);
0970:}
0971:

954~971行目のElement.findChildrenは、要素のDOMを下にたどって、指定のタグ名をもつ要素をすべて列挙する関数です。引数に、起点になる要素、CSSクラスの文字列(あるいはその配列⁠⁠、再帰的にたどるかどうかのフラグ、探すタグ名をとります。

955行目で、起点となる要素に子ノードがなければnullを返します。

957行目で、onlyの値をCSSクラスの文字列の配列に統一するため、一度配列にしてからflattenメソッドを使います。

959行目で、子ノードをたどります。

960行目で、指定のタグ名に一致し、かつ、onlyのCSSクラスを持つノードを、elements配列に追加します。

963行目で、再帰的にたどるならば、子ノードの子ノードを同様に調べます。

965行目で、孫の結果をelements配列に追加します。

969行目で、elements配列の入れ子構造をflattenメソッドでつぶして返します。

0972:Element.offsetSize = function (element, type) {
0973:  return element['offset' + ((type=='vertical' || type=='height') ? 'Height' : 'Width')];
0974:}

972~974行目のElement.offsetSizeは、要素のoffsetHeightかoffsetWidthを返す関数です。引数に要素と、どちらを返すかの指定をとります。

973行目で、指定が'vertical'か'height'なら要素のoffsetHeightを返し、それ以外ならoffsetWidthを返します。

dragdrop.jsの解説は以上です。

おわりに

これで、script.aculo.usのコードを全て解説しました。このライブラリの4000行を越えるコードを読み解くにあたって、Javascriptの動的性が非常に役立ったことが印象的でした。Firebugでたくさんの情報を実行中に取り出せること、トップレベルから関数単位に呼び出してテストできることで、多くの疑問を解決できました。

また、このscript.aculo.usのコード自体も、一貫性のあるクラス設計と、関数単位のボトムアップな実装のおかげで、大変読みやすいものでした。さらに、プロジェクト全体としても、アジャイル開発プロセスに基づいて徹底的なテストが記述されていることや、SubversionやGitによるソースコード管理、Tracによるバグ管理などが整備されていることで、大いに助かりました。

最後に、本連載の草稿を一緒に読み、種々の誤り等を指摘してくれた名古屋大学大学院情報科学研究科修士1年結縁研究室の水野洋樹氏連載執筆のあいだお世話になった技術評論社株式会社の高橋和道氏に深謝いたします。

おすすめ記事

記事・ニュース一覧