//アップロード処理 (thank you ...oitake blog)
var a=new Object();
a.no=1;
a.add=function()
{
    if(this.no>=5)
    {
        return;
    }
    var src=document.getElementById('a_src');
    var cln=src.cloneNode(true);
    cln.id="a_cln_"+this.no;
    var dst=document.getElementById('a_dst');
    dst.appendChild(cln);
    this.no++;
};

//コピーボタン
    function fCopyDOM(){
        var taObj=document.getElementById("pass");
        var taObjCopy=document.getElementById("passCopy");
        taObjCopy.value=taObj.value;
    }

//表示・非表示切替
function setBtn(fObj) { fObj.disabled = true; }
function setTF(fObj,vType) { fObj.style.visibility = vType; } 


/*
 * jTPS - table sorting, pagination, and animated page scrolling
 *  version 0.4
 * Author: Jim Palmer
 * Released under MIT license.
 */
/*表示件数 ここから */
		$(document).ready(function () {
			$('#demoTable').jTPS( {perPages:[5,10,15,50,'ALL'],scrollStep:1,scrollDelay:30} );
			// bind mouseover for each tbody row and change cell (td) hover style
			$('#demoTable tbody tr:not(.stubCell)').bind('mouseover mouseout',
				function (e) {
					// hilight the row
					e.type == 'mouseover' ? $(this).children('td').addClass('hilightRow') : $(this).children('td').removeClass('hilightRow');
				}
			);
		});
/*表示件数 ここまで */


 (function($) {

    // apply table controls + setup initial jTPS namespace within jQuery
    $.fn.jTPS = function ( opt ) {

        $(this).data('tableSettings', $.extend({
            perPages:           [5, 6, 10, 20, 50, 'ALL'],              // the "show per page" selection
            perPageText:        'page:',                       // text that appears before perPages links
            perPageDelim:       '<span style="color:#ccc;">|</span>',   // text or dom node that deliminates each perPage link
            perPageSeperator:   '..',                                   // text or dom node that deliminates split in select page links
            scrollDelay:        30,                                     // delay (in ms) between steps in anim. - IE has trouble showing animation with < 30ms delay
            scrollStep:         1,                                      // how many tr's are scrolled per step in the animated vertical pagination scrolling
            fixedLayout:        true                                    // autoset the width/height on each cell and set table-layout to fixed after auto layout
        }, opt));
       
        // generic pass-through object + other initial variables
        var pT = $(this), page = page || 1, perPages = $(this).data('tableSettings').perPages, perPage = perPage || perPages[0],
            rowCount = $('tbody tr', this).length;

        // append jTPS class "stamp"
        $(this).addClass('jTPS');
       
        // setup the fixed table-layout so that the animation doesn't bounce around - faux grid for table
        if ( $(this).data('tableSettings').fixedLayout ) {
            // "fix" the table layout and individual cell width & height settings
            if ( $(this).css('table-layout') != 'fixed' ) {
                // find max tbody td cell height
                var maxCellHeight = 0;

                // set width style on the TH headers (rely on jQuery with computed styles support)
                $('thead th', this).each(function () { $(this).css('width', $(this).width()); });

                // ensure browser-formated widths for each column in the thead and tbody
                var tbodyCh = $('tbody', this)[0].childNodes, tmpp = 0;
                // loop through tbody children and find the Nth <TR>
                for ( var tbi=0, tbcl=tbodyCh.length; tbi < tbcl; tbi++ )
                    if ( tbodyCh[ tbi ].nodeName == 'TR' )
                        maxCellHeight = Math.max( maxCellHeight, tbodyCh[ tbi ].offsetHeight );

                // now set the height attribute and/or style to the first TD cell (not the row)
                for ( var tbi=0, tbcl=tbodyCh.length; tbi < tbcl; tbi++ )
                    if ( tbodyCh[ tbi ].nodeName == 'TR' )
                        for ( var tdi=0, trCh=tbodyCh[ tbi ].childNodes, tdcl=trCh.length; tdi < tdcl; tdi++ )
                            if ( trCh[ tdi ].nodeName == 'TD' ) {
                                trCh[ tdi ].style.height = maxCellHeight + 'px';
                                tdi = tdcl;
                            }

                // now set the table layout to fixed
                $(this).css('table-layout','fixed');
            }
        }

        // remove all stub rows
        $('.stubCell', this).remove();

        // add the stub rows
        var stubCount=0, cols = $('tbody tr:first td', this).length,
            stubs = ( perPage - ( $('tbody tr', this).length % perPage ) ),
            stubHeight = $('tbody tr:first td:first', this).css('height');
        for ( ; stubCount < stubs && stubs != perPage; stubCount++ )
            $('tbody tr:last', this).after( '<tr class="stubCell"><td colspan="' + cols + '" style="height: ' + stubHeight + ';">&nbsp;</td></tr>' );

        // paginate the result
        if ( rowCount > perPage )
            $('tbody tr:gt(' + (perPage - 1) + ')', this).addClass('hideTR');

        // bind sort functionality to theader onClick
        $('thead th[sort]', this).each(
            function (tdInd) {
                $(this).addClass('sortableHeader').unbind('click').bind('click',
                    function () {
                        var desc = $(pT).find('thead th:eq(' + tdInd + ')').hasClass('sortAsc') ? true : false;
                        // sort the rows
                        sort( pT, tdInd, desc );
                        // show first perPages rows
                        var page = parseInt( $(pT).find('.hilightPageSelector:first').html() ) || 1;
                        $(pT).find('tbody tr').removeClass('hideTR').filter(':gt(' + ( ( perPage - 1 ) * page ) + ')').addClass('hideTR');
                        $(pT).find('tbody tr:lt(' + ( ( perPage - 1 ) * ( page - 1 ) ) + ')').addClass('hideTR');
                        // scroll to first page
                        $(pT).find('.pageSelector:first').click();
                        // hilight the sorted column header
                        $(pT).find('thead .sortDesc, thead .sortAsc').removeClass('sortDesc').removeClass('sortAsc');
                        $(pT).find('thead th:eq(' + tdInd + ')').addClass( desc ? 'sortDesc' : 'sortAsc' );
                        // hilight the sorted column
                        $(pT).find('tbody').find('td.sortedColumn').removeClass('sortedColumn');
                        $(pT).find('tbody tr:not(.stubCell)').each( function () { $(this).find('td:eq(' + tdInd + ')').addClass('sortedColumn'); } );
                        clearSelection();
                    }
                );
            }
        );

        // add perPage selection link + delim dom node
        $('tfoot .selectPerPage', this).empty();
        var pageSel = perPages.length;
        while ( pageSel-- )
            $('tfoot .selectPerPage', this).prepend( ( (pageSel > 0) ? $(this).data('tableSettings').perPageDelim : '' ) +
                '<span class="perPageSelector">' + perPages[pageSel] + '</span>' );

        // now draw the page selectors
        drawPageSelectors( this, page || 1 );

        // prepend the instructions and attach select hover and click events
        $('tfoot .selectPerPage', this).prepend( $(this).data('tableSettings').perPageText ).find('.perPageSelector').each(
            function () {
                if ( ( parseInt($(this).html()) || rowCount ) == perPage )
                    $(this).addClass('perPageSelected');
                $(this).bind('mouseover mouseout',
                    function (e) {
                        e.type == 'mouseover' ? $(this).addClass('perPageHilight') : $(this).removeClass('perPageHilight');
                    }
                );
                $(this).bind('click',
                    function () {
                        // set the new number of pages
                        perPage = parseInt( $(this).html() ) || rowCount;
                        if ( perPage > rowCount ) perPage = rowCount;
                        // remove all stub rows
                        $('.stubCell', this).remove();
                        // redraw stub rows
                        var stubCount=0, cols = $(pT).find('tbody tr:first td').length,
                            stubs = ( perPage - ( $(pT).find('tbody tr').length % perPage ) ),
                            stubHeight = $(pT).find('tbody tr:first td:first').css('height');
                        for ( ; stubCount < stubs && stubs != perPage; stubCount++ )
                            $(pT).find('tbody tr:last').after( '<tr class="stubCell"><td colspan="' + cols + '" style="height: ' + stubHeight + ';">&nbsp;</td></tr>' );
                        // set new visible rows
                        $(pT).find('tbody tr').removeClass('hideTR').filter(':gt(' + ( ( perPage - 1 ) * page ) + ')').addClass('hideTR');
                        $(pT).find('tbody tr:lt(' + ( ( perPage - 1 ) * ( page - 1 ) ) + ')').addClass('hideTR');
                        // back to the first page
                        $(pT).find('.pageSelector:first').click();
                        $(this).siblings('.perPageSelected').removeClass('perPageSelected');
                        $(this).addClass('perPageSelected');
                        // redraw the pagination
                        drawPageSelectors( pT, 1 );
                        // update status bar
                        var cPos = $('tbody tr:not(.hideTR):first', pT).prevAll().length,
                            ePos = $('tbody tr:not(.hideTR):not(.stubCell)', pT).length;
                        $('tfoot .status', pT).html( 'Showing ' + ( cPos + 1 ) + ' - ' + ( cPos + ePos ) + ' of ' + rowCount + '' );
                        clearSelection();
                    }
                );
            }
        );
       
        // show the correct paging status
        var cPos = $('tbody tr:not(.hideTR):first', this).prevAll().length, ePos = $('tbody tr:not(.hideTR)', this).length;
        $('tfoot .status', this).html( 'showing ' + ( cPos + 1 ) + ' - ' + ( cPos + ePos ) + ' of ' + rowCount );

        // clear selected text function
        function clearSelection () {
            if ( document.selection && typeof(document.selection.empty) != 'undefined' )
                document.selection.empty();
            else if ( typeof(window.getSelection) === 'function' && typeof(window.getSelection().removeAllRanges) === 'function' )
                window.getSelection().removeAllRanges();
        }

        // render the pagination functionality
        function drawPageSelectors ( target, page ) {

            // add pagination links
            $('tfoot .pagination', target).empty();
            var pages = (perPage >= rowCount) ? 0 : Math.ceil( rowCount / perPage ), totalPages = pages;
            while ( pages-- )
                $('tfoot .pagination', target).prepend( '<div class="pageSelector">' + ( pages + 1 ) + '</div>' );
       
            var pageCount = $('tfoot .pageSelector', target).length;
            $('tfoot .pageSelector.hidePageSelector', target).removeClass('hidePageSelector');
            $('tfoot .pageSelector.hilightPageSelector', target).removeClass('hilightPageSelector');
            $('tfoot .pageSelectorSeperator', target).remove();
            $('tfoot .pageSelector:lt(' + ( ( page > ( pageCount - 4 ) ) ? ( pageCount - 5 ) : ( page - 2 ) ) + '):not(:first)', target).addClass('hidePageSelector')
                .eq(0).after( '<div class="pageSelectorSeperator">' + $(target).data('tableSettings').perPageSeperator + '</div>' );
            $('tfoot .pageSelector:gt(' + ( ( page < 4 ) ? 4 : page ) + '):not(:last)', target).addClass('hidePageSelector')
                .eq(0).after( '<div class="pageSelectorSeperator">' + $(target).data('tableSettings').perPageSeperator + '</div>' );
            $('tfoot .pageSelector:eq(' + ( page - 1 ) + ')', target).addClass('hilightPageSelector');

            // remove the pager title if no pages necessary
            if ( perPage >= rowCount )
                $('tfoot .paginationTitle', target).css('display','none');
            else
                $('tfoot .paginationTitle', target).css('display','');
           
            // bind the pagination onclick
            $('tfoot .pagination .pageSelector', target).each(
                function () {
                    $(this).bind('click',
                        function () {

                            // if double clicked - stop animation and jump to selected page - this appears to be a tripple click in IE7
                            if ( $(this).hasClass('hilightPageSelector') ) {
                                if ( $(this).parent().queue().length > 0 ) {
                                    // really stop all animations and create new queue
                                    $(this).parent().stop().queue( "fx", [] ).stop();
                                    // set the user directly on the correct page without animation
                                    var beginPos = ( ( parseInt( $(this).html() ) - 1 ) * perPage ), endPos = beginPos + perPage;
                                    $('tbody tr', pT).removeClass('hideTR').addClass('hideTR');
                                    $('tbody tr:gt(' + (beginPos - 2) + '):lt(' + ( perPage ) + ')', pT).andSelf().removeClass('hideTR');
                                    // update status bar
                                    var cPos = $('tbody tr:not(.hideTR):first', pT).prevAll().length,
                                        ePos = $('tbody tr:not(.hideTR):not(.stubCell)', pT).length;
                                    $('tfoot .status', pT).html( 'Showing ' + ( cPos + 1 ) + ' - ' + ( cPos + ePos ) + ' of ' + rowCount + '' );
                                }
                                clearSelection();
                                return false;
                            }

                            // hilight the specific page button
                            $(this).parent().find('.hilightPageSelector').removeClass('hilightPageSelector');
                            $(this).addClass('hilightPageSelector');

                            // really stop all animations
                            $(this).parent().stop().queue( "fx", [] ).stop().dequeue();

                            // setup the pagination variables
                            var beginPos = $('tbody tr:not(.hideTR):first', pT).prevAll().length,
                                endPos = ( ( parseInt( $(this).html() ) - 1 ) * perPage );
                            if ( endPos > rowCount )
                                endPos = (rowCount - 1);
                            // set the steps to be exponential for all the page scroll difference - i.e. faster for more pages to scroll
                            var sStep = $(pT).data('tableSettings').scrollStep * Math.ceil( Math.abs( ( endPos - beginPos ) / perPage ) );
                            if ( sStep > perPage ) sStep = perPage;
                            var steps = Math.ceil( Math.abs( beginPos - endPos ) / sStep );

                            // start scrolling
                            while ( steps-- ) {
                                $(this).parent().animate({'opacity':1}, $(pT).data('tableSettings').scrollDelay,
                                    function () {
                                        // reset the scrollStep for the remaining items
                                        if ( $(this).queue("fx").length == 0 )
                                            sStep = ( Math.abs( beginPos - endPos ) % sStep ) || sStep;
                                        /* scoll up */
                                        if ( beginPos > endPos ) {
                                            $('tbody tr:not(.hideTR):first', pT).prevAll(':lt(' + sStep + ')').removeClass('hideTR');
                                            if ( $('tbody tr:not(.hideTR)', pT).length > perPage )
                                                $('tbody tr:not(.hideTR):last', pT).prevAll(':lt(' + ( sStep - 1 ) + ')').andSelf().addClass('hideTR');
                                            // if scrolling up from less rows than perPage - compensate if < perPage
                                            var currRows =  $('tbody tr:not(.hideTR)', pT).length;
                                            if ( currRows < perPage )
                                                $('tbody tr:not(.hideTR):last', pT).nextAll(':lt(' + ( perPage - currRows ) + ')').removeClass('hideTR');
                                        /* scroll down */
                                        } else {
                                            var endPoint = $('tbody tr:not(.hideTR):last', pT);
                                            $('tbody tr:not(.hideTR):lt(' + sStep + ')', pT).addClass('hideTR');
                                            $(endPoint).nextAll(':lt(' + sStep + ')').removeClass('hideTR');
                                        }
                                        // update status bar
                                        var cPos = $('tbody tr:not(.hideTR):first', pT).prevAll().length,
                                            ePos = $('tbody tr:not(.hideTR):not(.stubCell)', pT).length;
                                        $('tfoot .status', pT).html( 'Showing ' + ( cPos + 1 ) + ' - ' + ( cPos + ePos ) + ' of ' + rowCount + '' );
                                    }
                                );
                            }

                            // redraw the pagination
                            drawPageSelectors( pT, parseInt( $(this).html() ) );

                        }
                    );
                }
            );
           
        };

        /* sort function */
        function sort ( target, tdIndex, desc ) {

            var sorted = $('thead th:eq(' + tdIndex + ')', target).hasClass('sortAsc') ||
                $('thead th:eq(' + tdIndex + ')', target).hasClass('sortDesc') || false,
                nullChar = String.fromCharCode(0), re = /([-]{0,1}[0-9.]{1,})/g,
                rows = $('tbody tr:not(.stubCell)', target).get(), procRow = [];

            $(rows).each(
                function(key, val) {
                    // setup temp-scope variables for comparison evauluation
                    var x = ( $('td:eq(' + tdIndex + ')', val).html() || '' ).toString().toLowerCase() || '',
                        xN = x.replace(re, nullChar + '$1' + nullChar).split(nullChar),
                        tD = (new Date(x)).getTime(), xNl = xN.length;
                    if ( tD )
                        procRow.push( tD + ',' + (procRow.length) );
                    else {
                        var dS = [];
                        for (var i=0; i < xNl; i++)
                            dS.push( (new Date( xN[ i ] )).getTime() || parseFloat( xN[ i ] ) || xN[ i ] );
                        procRow.push( dS.join(',') + ',' + (procRow.length) );
                    }
                }
            );

            if ( !sorted ) {
                // use the quick sort algorithm
                quickSort( procRow, 0, (rows.length - 1) );
                // properly position order of sort
                if ( !desc )
                    procRow.reverse();
            }

            // now re-order the parent tbody based off the quick sorted tbody map
            $('tbody:first', target).before('<tbody></tbody>');
            var nr = procRow.length, tf = $('tbody:first', target)[0];
            // move the row from old tbody to new tbody in order of new tbody with replaceWith to retain original tbody row positioning
            if ( sorted )
                while ( nr-- )
                    tf.appendChild( rows[ nr ] );
            else
                while ( nr-- )
                    tf.appendChild( rows[ parseInt( procRow[ nr ].split(',').pop() ) ] );
            // remove the old table
            $('tbody:last', target).remove();
            // redraw stub rows
            var stubCount=0, cols = $('tbody tr:first td', target).length,
                stubs = ( perPage - ( $('tbody tr', target).length % perPage ) ),
                stubHeight = $('tbody tr:first td:first', target).css('height');
            for ( ; stubCount < stubs && stubs != perPage; stubCount++ )
                $('tbody tr:last', target).after( '<tr class="stubCell"><td colspan="' + cols + '" style="height: ' + stubHeight + ';">&nbsp;</td></tr>' );

        }

        /* Quick Sort algorithm - instantiation of Michael Lamont's Quick Sort pseudocode from http://linux.wku.edu/~lamonml/algor/sort/quick.html */
        function quickSort ( numbers, left, right ) {
            var l_hold = left, r_hold = right, pivot = numbers[left];
            // natural sort comparison "operator overload"
            var chCompare = function ( a, b ) {
                var ca = a.split(',').slice( 0, ( a.length - 1 ) ),
                    cb = b.split(',').slice( 0, ( a.length - 1 ) );
                for ( var cLoc=0, nMin = Math.min( ca.length, cb.length ), nMax = Math.max( ca.length, cb.length ); cLoc < nMax; cLoc++ ) {
                    if ( ( parseFloat( ca[ cLoc ] ) || ca[ cLoc ] ) < ( parseFloat( cb[ cLoc ] ) || cb[ cLoc ] ) )
                        return -1;
                    if ( ( parseFloat( ca[ cLoc ] ) || ca[ cLoc ] ) > ( parseFloat( cb[ cLoc ] ) || cb[ cLoc ] ) )
                        return 1;
                    if ( cLoc > nMin && cLoc <= nMax )
                        return 0;
                }
                return 0;
            }
            while (left < right) {
                while ( ( chCompare( numbers[right], pivot ) >= 0 ) && ( left < right ) )
                    right--;
                if (left != right) {
                    numbers[left] = numbers[right];
                    left++;
                }
                while ( ( chCompare( numbers[left], pivot ) <= 0 ) && ( left < right ) )
                    left++;
                if (left != right) {
                    numbers[right] = numbers[left];
                    right--;
                }
            }
            numbers[left] = pivot;
            pivot = left;
            left = l_hold;
            right = r_hold;
            if (left < pivot)
                quickSort( numbers, left, ( pivot - 1 ) );
            if (right > pivot)
                quickSort( numbers, ( pivot + 1 ), right );
        };

        // chainable
        return this;
    };

})(jQuery);