// プレイバー作成 5


var gPlaybarIdPrefix = "playbar_";
var gPlaybarClassName = "playbar";
var gFlashSoundPlayerId = "flashsoundplayer";

var gFlashLoaded = false;
var gPageLoaded = false;
var gLang = '';




Event.observe(window, 'load', onPageLoaded, false);

//---------------------------------------------------------------------------------------
/**
 * お気に入り削除のリンクを作成する
 */
function showFavoriteItemsDeleteLink() {
	var str = "";
	if(gLang == 'ja') {
		str = "お気に入りを全て削除する";
	}else{
		str = "remove all favorite items.";
	}
	
	//document.write("<p><a href='javascript:deleteFavoriteItems();'>" + str + "</a></p>");
	$('allclearlink').innerHTML = "<p>[ <a href='javascript:deleteFavoriteItems();'>" + str + "</a> ]</p>";
}


/**
 * お気に入りの削除リンクがクリックされたときの処理。
 * アラートを表示して、YES ならばflash にメッセージを送る。
 */
function deleteFavoriteItems() {
	var str ="";
	if(gLang == 'ja') {
		str = "お気に入りを全て削除します。\nよろしいですか？";
	}else{
		str = "The bookmarks will be deleted.  OK?";
	}
	
	var b = confirm(str);
	
	if(b) {
		// 削除する。
		EIManager.getInstance().deletefavoriteitems();
	}
	
}
/**
 * お気に入りが削除されたら flash から呼び出される関数。
 */
function favoriteItemesDeleted(){
	// alert("deleted");
	var str ="";
	if(gLang == 'ja') {
		str = "お気に入りは削除されました。";
	}else{
		str = "Your bookmarks have been deleted from your bookmarks.";
	}
	
	$('allclearlink').innerHTML = '';
	
	var rp = $('favoritesarea');
	rp.innerHTML = "<p><strong>" + str + "</strong></p>";
	y = rp.offsetTop;
	scrollTo(0,y); 
}



//---------------------------------------------------------------------------------------
/**
 * 再生履歴削除のリンクを作成する
 */
function showRecentlyPlayedItemsDeleteLink() {
	var str = "";
	if(gLang == 'ja') {
		str = "再生履歴を全て削除する";
	}else{
		str = "Clear recently played items.";
	}
	
	//document.write("<p><a href='javascript:deleteRecentlyPlayedItems();'>" + str + "</a></p>");
	$('allclearlink').innerHTML = "<p>[ <a href='javascript:deleteRecentlyPlayedItems();'>" + str + "</a> ]</p>";
}


/**
 * 再生履歴の削除リンクがクリックされたときの処理。
 * アラートを表示して、YES ならばflash にメッセージを送る。
 */
function deleteRecentlyPlayedItems() {
	var str ="";
	if(gLang == 'ja') {
		str = "再生履歴を全て削除します。\nよろしいですか？";
	}else{
		str = "Your recent plays will be deleted.  OK?";
	}
	
	var b = confirm(str);
	
	if(b) {
		// 削除する。
		EIManager.getInstance().deleterecentlyplayeditems();
	}
	
}
/**
 * 再生履歴が削除されたら flash から呼び出される関数。
 */
function recentlyPlayedItemesDeleted(){
	// alert("deleted");
	var str ="";
	if(gLang == 'ja') {
		str = "再生履歴は削除されました。";
	}else{
		str = "Your recent plays have been deleted.";
	}
	
	$('allclearlink').innerHTML = '';
	
	var rp = $('recentlyplayedarea');
	rp.innerHTML = "<p><strong>" + str + "</strong></p>";
	y = rp.offsetTop;
	scrollTo(0,y); 
}

//---------------------------------------------------------------------------------------

function fvAsFav(id)
{
	if(id.substr(0,4) == "THCD") return;
	
	var str = "";
	favid = 'fav_' + id;
	if(gLang == 'ja') {
		str += 'お気に入りから削除';
	}else{
		str += 'remove from favorites';
	}
	$(favid).innerHTML = '<a href="javascript:fvRemove(\'' + id +'\')" class="fav_in">' + str + '</a>';
}

function fvAsNormal(id)
{
	if(id.substr(0,4) == "THCD") return;
	
	var str = "";
	favid = 'fav_' + id;
	if(gLang == 'ja') {
		str += 'お気に入りに追加';
	}else{
		str += 'add to favorites';
	}
	$(favid).innerHTML = '<a href="javascript:fvAdd(\'' + id +'\')" class="fav_non">' + str + '</a>';
}

function fvAdd(id)
{
	if(id.substr(0,4) == "THCD") return;
	
	if(EIManager.getInstance().addfavorites(id)) {
		//alert("added" + id);
		urchinTracker('/soundswf/'+id+'/fvAdded');
		fvAsFav(id);
	}
	
}

function fvRemove(id)
{
	if(id.substr(0,4) == "THCD") return;
	
	if(EIManager.getInstance().removefavorites(id)) {
		//alert("removed" + id);
		urchinTracker('/soundswf/'+id+'/fvRemoved');
		fvAsNormal(id);
	}
}

function fvCheck(id)
{
	if(EIManager.getInstance().isfavorite(id) == true) {
		fvAsFav(id);
	}else{
		fvAsNormal(id);
	}
}

/**
 * flash から呼ばれる関数（お気に入り)
 */
function setFavorites(o){
	var data = eval("("+o+")");
	
	if(data == null) return;
	
	//alert($('recentlyplayed').innerHTML);
		
	ids = data.ids.split(",");
	//console.log(data.ids);
	$('favoritesarea').innerHTML = '<table class="cmlist"><tbody>' + data.html + '</tbody></table>';//'<tbody>' + data.html + '</tbody>';


	
	var l = ids.length;
	
	for(i = 0; i < l; ++i) {
		id = ids[i];
		if(id.substr(0,2) == "TH") {
			PlayerManager.getInstance().addPlaybar(id, $('pb_' + id));
			fvCheck(id);
		}
	}
	
	nosoundids = data.nosoundids.split(",");
	var nl = nosoundids.length;
	for(i = 0; i < nl; ++i) {
		id = nosoundids[i];
		if(id.substr(0,2) == "TH") {
			fvCheck(id);
		}
	}
	
	if((l + nl) > 0) {
		showFavoriteItemsDeleteLink();
	}
}

/**
 * flash から呼ばれる関数(再生履歴)
 */
function setRecentlyPlayed(o){
	var data = eval("("+o+")");
	
	if(data == null) return;
	
	//alert($('recentlyplayed').innerHTML);

	ids = data.ids.split(",");
	//alert(data.ids);
	$('recentlyplayedarea').innerHTML = '<table class="cmlist"><tbody>' + data.html + '</tbody></table>';//'<tbody>' + data.html + '</tbody>';

	
	var l = ids.length;
	for(i = 0; i < l; ++i) {
		id = ids[i];
		if(id.substr(0,2) == "TH") {
			PlayerManager.getInstance().addPlaybar(id, $('pb_' + id));
			fvCheck(id);
		}
	}
	
	if(l > 0) {
		showRecentlyPlayedItemsDeleteLink();
	}
}

/**
 * playbar を初期化する
 */
function initPlaybars()
{	
	if(typeof(favoriteurl) == 'string') {
		EIManager.getInstance().getfavorites(favoriteurl);
		
	}else if(typeof(recentplayedurl) == 'string') {
		EIManager.getInstance().getrecentlyplayed(recentplayedurl);
		
	}else if(gPlaybars != null) {
		var l = gPlaybars.length;
		//$('debug').innerHTML += "<br/>initLatestcm /" + l + "/";
		for(i = 0; i < l; ++i) {
			id = gPlaybars[i][0];
			
			PlayerManager.getInstance().addPlaybar(id, gPlaybars[i][1]);
			fvCheck(id);
		}
		gPlaybars = [];
	}else{
		//$('debug').innerHTML += ".";
		setTimeout(initPlaybars(), 100);
	}
	
}

/**
 *  flash からExternalInterfaceのチェックに呼び出される関数
 */
function connectExternalInterface()
{
    EIManager.getInstance().initExternalInterface();

	//alert("connectExternalInterface");

    return true;
}

/**
 *  flash の準備が整ったときに呼び出される関数
 */
function flashStandby()
{
    if(EIManager.getInstance().canUseFlash() == true) {
    	gFlashLoaded = true;
		checkMaterials();
    }else{
        setTimeout(flashStandby(), 10);
    }
}


/**
 * ページの読み込みが完了したときに呼び出される関数
 */
function onPageLoaded() {
	gPageLoaded = true;
	checkMaterials();
}

/**
 * flash, html の準備が整ったときに呼び出される関数
 */
function checkMaterials() {
	if(gFlashLoaded == true && gPageLoaded == true) {
		initPlaybars();
	}
}


/**
 *  flash を初期化する
 */
function initializeFlash(lang)
{
	gLang = lang;
    var divId = "flashcontent";
    var parent = document.getElementsByTagName("body")[0];
    
    var e = document.createElement('div');
    e.id = divId;
    parent.appendChild(e);
    if(lang == "en"){
		e.innerHTML = '<p>This web site requires the latest version of <a href="http://www.adobe.com/go/getflashplayer" target="_blank">Flash Player</a>.</p>';
	}else{
    	e.innerHTML = '<p>視聴するには最新の <a href="http://www.adobe.com/go/getflashplayer" target="_blank">Flash Player</a> が必要です。</p>';
	}
	
    var so = new SWFObject(gFspFilename, gFlashSoundPlayerId, "1", "1", "8", "#ffffff");
    so.addParam("allowScriptAccess", "sameDomain"); // ローカルでテストする場合は always, サイト上では sameDomainにする
    
    so.write(divId);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
/**
 * サウンドのロードに失敗したときに呼び出される関数
 *
 *  @o.id           サウンドID
 *  @o.errorCode    "URLNotFound" または "LoadNeverCompleted"
 *  @o.httpStatus   サーバーから返された HTTP ステータスコード。使えない場合は0
 */
function onLoadError(o){
    return true;
}

/**
 * サウンドのロード中に呼び出される関数
 *
 *  @o.id           サウンドID
 *  @o.bytesLoaded  ロード済みのサイズ
 *  @o.bytesTotal   ファイル全体のサイズ
 */
function onLoadProgress(o){
    PlayerManager.getInstance().onLoadProgress(o);
    
    return true;
}


/**
 * サウンドが再生中に呼び出される関数
 *
 *  @o.id           サウンドID
 *  @o.position     現在の再生位置
 *  @o.duration     サウンド全体のの長さ
 */
function onSoundPlaying(o){
    PlayerManager.getInstance().onSoundPlaying(o);
    
    return true;
}

/**
 * サウンドの再生が終了したときに呼び出される関数
 *
 * @o.id           サウンドID
 */
function onSoundComplete(o){
    PlayerManager.getInstance().onSoundComplete(o);
    
    return true;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
EIManager = Class.create(); // !! singleton で使う
EIManager.prototype = {
    /**
     * 初期化
     */
    initialize : function() {
        this.availableExternalInterface = null;
    },
    
    /**
     * ExternalInterface を初期化する
     */
    initExternalInterface : function() {
        if($(gFlashSoundPlayerId).init == null) {
            setTimeout(this.initExternalInterface(), 250);
        }else if($(gFlashSoundPlayerId).init() != true) {
            setTimeout(this.initExternalInterface(), 250);
        }else{
            this.availableExternalInterface = true;
        }        
    },
    
    
    /**
     * 再生させる
     */
    play : function(sid) {
        $(gFlashSoundPlayerId).playsound(sid);
    },
    
    /**
     * 一時停止させる
     */
    pause : function(sid) {
        $(gFlashSoundPlayerId).pausesound(sid);
    },
    
    /**
     * 停止させる
     */
    stop : function(sid) {
        $(gFlashSoundPlayerId).stopsound(sid);
    },
    
    /**
     * 再生位置を変更する
     */
    seek : function(sid, pos) {
        $(gFlashSoundPlayerId).seeksound(sid, pos);
    },
    
    /**
     * flash が使えるかどうかを返す
     */
    canUseFlash : function() {
        return this.availableExternalInterface;
    },
    /**
     * 最近再生された曲一覧を返す
     */
    getrecentlyplayed : function(url) {
    	$(gFlashSoundPlayerId).getrecentlyplayed(url);
    },
    /**
     * お気に入りに入っていたらtrueを返す
     */
    isfavorite : function(sid){
    	return $(gFlashSoundPlayerId).isfavorite(sid);
    },
    /**
     * お気に入りに追加する
     */
    addfavorites : function(sid){
    	return $(gFlashSoundPlayerId).addfavorites(sid);
    },
    /**
     * お気に入りから削除する
     */
    removefavorites : function(sid){
    	return $(gFlashSoundPlayerId).removefavorites(sid);
    },
    /**
     * 最近再生された曲一覧を返す
     */
    getfavorites : function(url) {
    	$(gFlashSoundPlayerId).getfavorites(url);
    },
    deleterecentlyplayeditems : function() {
    	//console.log("EIManager delete;")
    	$(gFlashSoundPlayerId).deleterecentlyplayeditems();
    },
    deletefavoriteitems : function() {
    	// console.log("EIManager delete favorites;")
    	$(gFlashSoundPlayerId).deletefavoriteitems();
    }
};

// singleton
(function(){
    var eim = new EIManager();
    EIManager.prototype.initialize = null;
    EIManager.getInstance = function() {
        return eim;
    };
})(); // (function end


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
PlayerManager = Class.create(); // !! singleton で使う
PlayerManager.prototype = {
    /**
     * 初期化
     */
    initialize : function() {
    },
    
    /**
     * playbar を作成する
     */
    addPlaybar : function(sid, parent) {
        if(this.playbars == null) {
            this.playbars = {};
        }
        
        var elementId = gPlaybarIdPrefix + sid;
        var e = this.createPlaybarElement(elementId);
        
        parent.appendChild(e);
        
        this.playbars[sid] = new Playbar(sid, elementId);
    },
    
    /**
     * playbar 用の要素を作成する
     */
    createPlaybarElement : function(elementId) {
        var e = document.createElement('div');
        
        e.id = elementId;
        e.className = gPlaybarClassName;
        
        return e;
    },
    
    /**
     * 再生させる
     */
    play : function(sid) {
        this.resetPreviousPlaybar(sid);
        
        EIManager.getInstance().play(sid);
        this.playingSoundId = sid;
        
        urchinTracker('/soundswf/'+sid+'/play');
    },
    
    /**
     * 一時停止させる
     */
    pause : function(sid) {
        EIManager.getInstance().pause(sid);
        this.resetPreviousPlaybar(sid);
    },
    
    /**
     * 停止させる
     */
    stop : function(sid) {
        EIManager.getInstance().stop(sid);
    },
    
    /**
     * 再生位置を変更する
     */
    seek : function(sid, pos) {
        EIManager.getInstance().seek(sid, pos);
    },
    
    
    /**
     * サウンドが再生中に呼び出される関数
     *
     *  @o.id           サウンドID
     *  @o.position     現在の再生位置
     *  @o.duration     サウンド全体のの長さ
     */
    onSoundPlaying : function(o) {
        var per = o.position / o.duration;
        this.playbars[o.id].setSeekbarKnobPosition(per);
    },
    
    /**
     * サウンドのロード中に呼び出される関数
     *
     *  @o.id           サウンドID
     *  @o.bytesLoaded  ロード済みのサイズ
     *  @o.bytesTotal   ファイル全体のサイズ
     */
    onLoadProgress : function(o) {
        var per = o.bytesLoaded/o.bytesTotal;
        var txt = o.bytesLoaded + " / " + o.bytesTotal;
    
        this.playbars[o.id].setProgression(per, txt);
    },
    
    /**
     * サウンドの再生が終了したときに呼び出される関数
     *
     * @o.id           サウンドID
     */
    onSoundComplete : function (o){
    	urchinTracker('/soundswf/'+[o.id]+'/complete');
        this.playbars[o.id].setNormalState();
    },
    
    /**
     * 曲が変更されたら前の曲のプレイバーを初期化する
     */    
    resetPreviousPlaybar : function(sid) {
        if(this.playingSoundId == null) {
            this.playingSoundId = sid;
        }else if (this.playingSoundId != sid){
            this.playbars[this.playingSoundId].setNormalState();
        }
    }
};

// singleton
(function(){
    var pm = new PlayerManager();
    PlayerManager.prototype.initialize = null;
    PlayerManager.getInstance = function() {
        return pm;
    };
})(); // (function end



//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Playbar = Class.create();
Playbar.prototype = {
    /**
     * 初期化
     */
    initialize : function(sid, id){
        this.sid = sid;
        
		
		var str = '<div class="play_normal" title="play">[play]</div>';
		str += '<div class="pause_hidden" title="pause">[pause]</div>';
		str += '<div class="stop_nonactive" title="stop">[stop]</div>';
		str += '<div class="progressbar_bg"><div class="progressbar_fg"></div><p class="progressbar_text"></p></div>';
		str += '<div class="seekbar_bg"><div class="seekbar_knob"></div></div>';
		
		$(id).innerHTML = str;
		
		
        this.state = null;
        

        this.play = new PlaybarButton($(id), "play_normal", "play", "[play]", {title:"play"});
        this.pause = new PlaybarButton($(id), "pause_hidden",  "pause", "[pause]", {title:"pause"});
        this.stop = new PlaybarButton($(id), "stop_nonactive", "stop", "[stop]", {title:"stop"});
		

        this.progressbar = new PlaybarProgressbar($(id), "progressbar_bg", "progressbar_fg", "progressbar_text");
        this.seekbar = new PlaybarSeekbar($(id), "seekbar_bg", "seekbar_knob");


        // イベントの初期化
        this.eventClick = this.changeState.bindAsEventListener(this);
        
        this.eventSlide = this.onSeekbarSlide.bindAsEventListener(this);
        this.eventSeeked = this.changePlayPosition.bindAsEventListener(this);

        this.buttonElements = {};
        this.chechElements();
    
        

        this.seekbar.options.onSlide = this.eventSlide;
        this.seekbar.options.onChange = this.eventSeeked;

        this.seekbar.hide();

    },
    
    
    
    /**
     * プログレスバーの値を変更する
     * @per     0～1の値
     * @txt     同時に表示するテキスト情報
     */
    setProgression : function(per, txt){
        this.progressbar.setBar(per, txt);
        
        if(per >= 1) {
            this.progressbar.destroy();
            delete this.progressbar;
            this.seekbar.show();
        }
    },
    
    /**
     * シークバーのノブの位置を設定する
     */
    setSeekbarKnobPosition : function(per) {
        this.seekbar.setValue(per+1);
    },
    
    /**
     * ボタンのdiv 要素が作成されるまで待つ
     */
    chechElements : function() {

        if(this.play.getElement() &&
           this.pause.getElement() &&
           this.stop.getElement()){
            
            this.initButtonElements();
            
            
        }else{
            // 取得できなかったときのための保険
            setTimeout(this.initEvents(), 100);
        }
    },
    
    /**
     * ボタンのイベント処理を初期化する
     */
    initButtonElements : function() {
        this.buttonElements.play = this.play.getElement();
        this.buttonElements.stop = this.stop.getElement();
        this.buttonElements.pause = this.pause.getElement();
        
		
        for(str in this.buttonElements) {
            Event.observe(this.buttonElements[str], "click", this.eventClick);
        }
		
        this.setNormalState();
    },
    
    /**
     * シークバーの変更が終了したときに呼び出される関数
     */
    changePlayPosition : function(value) {
        if(this.state == "pausing") {
            var pos = Number(value)-1;     //range:$R(1,2) のため。
            //$("debug").innerHTML = pos;
            PlayerManager.getInstance().seek(this.sid, pos);
        }
    },
    
    /**
     * シークバーの値が変更されたときに呼び出される関数
     */
    onSeekbarSlide : function() {
        this.setPausingState();
    },
    
    /**
     * ボタンがクリックされたときに呼び出される関数
     */
    changeState : function(e) {
        var target = (e.srcElement) ? e.srcElement : e.target;  // IE -- srcElement | FF -- target
        var className = target.className;
        
        //alert(className);
        switch(className){
        case this.play.getClassName():
            //alert("play button clicked");
            
            this.setPlayingState();
            break;
            
        case this.pause.getClassName():
            //alert("pause button clicked");
            
            this.setPausingState();
            break;  
            
        case this.stop.getClassName():
            //alert("stop button clicked");
            
            this.setNormalState();
            break;     
        }

    },
    
    /**
     * 通常状態にする
     */
    setNormalState : function() {
        if(this.state != "normal") {

            
			this.state = "normal";
            
            
			if(this.isFirstTimesetNormalState == undefined) {
				this.isFirstTimesetNormalState = true;
			}else{
				PlayerManager.getInstance().stop(this.sid);
			}

            
			this.play.setState("normal");
            this.pause.setState("hidden");
            this.stop.setState("nonactive");
            
            if(this.seekbar != null) {
                this.seekbar.setValue(1);
            }

        }
    },
    
    /**
     * 再生中にする
     */
    setPlayingState : function() {
        if(this.state != "playing") {
            this.state = "playing";
            
            //alert("setPlayingState");
            PlayerManager.getInstance().play(this.sid);
            
            this.play.setState("hidden");
            this.pause.setState("normal");
            this.stop.setState("normal");
        }
    },
    
    /**
     * 一時停止中にする
     */
    setPausingState : function() {
        if(this.state != "pausing") {
            this.state = "pausing";
            
            //alert("setPlayingState");
            PlayerManager.getInstance().pause(this.sid);
            
            this.play.setState("normal");
            this.pause.setState("hidden");
            this.stop.setState("normal");
        }
    }
};

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
PlaybarSeekbar = Class.create();
Object.extend(PlaybarSeekbar.prototype, Control.Slider.prototype);
Object.extend(PlaybarSeekbar.prototype, {
    /**
     * 初期化
     */
    initialize : function(parentNode, bgClassName, knobClassName) {
        this.parentNode = parentNode;
        
		
        this.bgClassName = bgClassName;
        this.knobClassName = knobClassName;
        
		this.bg = cssQuery("div." + bgClassName, $(this.parentNode))[0];
		this.knob = cssQuery("div." + knobClassName, $(this.parentNode))[0];
        //this.initElement();
        
		
        this.getBackgroundWidth();

    },
    
    /**
     * 要素を初期化する
     */
/*
	initElement : function() {
        this.bg = document.createElement('div');
        this.knob = document.createElement('div');
        
        this.bg.className = this.bgClassName;
        this.knob.className = this.knobClassName;
        
        
        
        this.bg.appendChild(this.knob);
        this.parentNode.appendChild(this.bg);
    },
*/
    /**
     * 背景の幅を取得する。
     */
    getBackgroundWidth : function() {
        this.barWidth = this.bg.offsetWidth;
        if(this.barWidth){
            this.initSlider();

            
        }else{
            setTimeout(this.getBackgroundWidth(), 100);
        }
    },
    
    /**
     * 非表示にする
     */
    hide : function() {
        this.bg.style.visibility = "hidden";
    },
    /**
     * 表示させる
     */
    show : function() {
        this.bg.style.visibility = "visible";
    },
    
    /**
     * スライダーとして初期化する
     */
    initSlider : function() {
        var options = {range: $R(1,2)}; // $R(0,1) だと、0のときに undefined が返る
        var args = [this.knob, this.bg, options];
        Control.Slider.prototype.initialize.apply(this, args);
        
    }
}); //Object.extend(Control.PlaybarSeekbar.prototype -- end

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

PlaybarProgressbar = Class.create();
PlaybarProgressbar.prototype = {
    /**
     * 初期化
     */
    initialize : function(parentNode, bgClassName, fgClassName, textClassName) {
        this.parentNode = parentNode;
        
        this.bgClassName = bgClassName;
        this.fgClassName = fgClassName;
        this.textClassName = textClassName;
        
        //this.initElement();
        
		this.bg = cssQuery("div." + bgClassName, $(this.parentNode))[0];
		this.fg = cssQuery("div." + fgClassName, $(this.parentNode))[0];
		this.text = cssQuery("p." + textClassName, $(this.parentNode))[0];
		
		
        this.getBackgroundWidth();
    },
    
    /**
     * 要素を初期化する
     */
/*
	initElement : function() {
        this.bg = document.createElement('div');
        this.fg = document.createElement('div');        
        this.text = document.createElement('p');
        
        this.bg.className = this.bgClassName;
        this.fg.className = this.fgClassName;
        this.text.className = this.textClassName;
        
        
        
        //this.bg.appendChild(this.fg);
        this.parentNode.appendChild(this.bg);
    },
*/
    /**
     * 背景の幅を取得する。
     */
    getBackgroundWidth : function() {
        this.barWidth = this.bg.offsetWidth;
        if(this.barWidth){
			// console.log("progress bar getBackgroundWidth " + this.barWidth);
            //alert(this.barWidth);
            this.fg.style.width = '0';
            
        }else{
            setTimeout(this.getBackgroundWidth(), 100);
        }
    },
    
    /**
     * プログレスバーの表示比率を設定する
     */
    setBar : function(per, text) {
        var w = Number(this.barWidth) * per;
        this.fg.style.width = Math.floor(w) + 'px';
        this.text.innerHTML = text;
    },
    
    /**
     * 破棄する
     */
    destroy : function() {
        this.bg.removeChild(this.fg);
        this.bg.removeChild(this.text);
        this.parentNode.removeChild(this.bg);
    }
};



//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

PlaybarButton = Class.create();
PlaybarButton.prototype = {
    /**
     * 初期化
     */
    initialize : function(parentNode, currentClassName, baseClassName, text, attr) {
        this.parentNode = parentNode;
        this.state = "";
        this.baseClassName = baseClassName;
        this.text=  text;
        
        this.isObserving = false;
        
        this.div = cssQuery("div." + currentClassName, $(this.parentNode))[0];
        
        //this.initElement();
        //this.initAttributes(attr);
        
        // イベントの初期化
        this.eventMouseOver = this.setOverState.bindAsEventListener(this);
        this.eventMouseOut = this.setNormalState.bindAsEventListener(this);
        
    },
    
    /**
     * 要素を初期化する
     */
/*    initElement : function() {
        this.div = document.createElement('div');
        this.div.innerHTML = this.text;
        this.parentNode.appendChild(this.div);
    },
*/

    /**
     * 属性を追加する
     * @attr {属性名: 値, 属性名: 値, ...}
     */
/*
	initAttributes : function(attr){
        for(a in attr){
            this.div[a] = attr[a];
        }
    },
*/    
    /**
     * ロールオーバーでスワップさせるかどうかを決める
     */
    activateButton : function(b){
        if(b == true){
            if(this.isObserving == false) {
                Event.observe(this.div, "mouseover", this.eventMouseOver);
                Event.observe(this.div, "mouseout", this.eventMouseOut);
                this.isObserving = true;
            }
        }else{
            if(this.isObserving == true) {
                Event.stopObserving(this.div, "mouseover", this.eventMouseOver);
                Event.stopObserving(this.div, "mouseout", this.eventMouseOut);
                this.isObserving = false;
            }
        }
    },
    
    
    /**
     * 状態を変更する
     */
    setState : function(s) {
        if(this.state == "" || this.state != s){
            var newClassName = this.baseClassName + "_" + s;
            
            if(this.state == ""){
                this.div.className = newClassName;
            }else{
                var oldClassName = this.baseClassName + "_" + this.state;
                this.div.className = this.div.className.replace(oldClassName, newClassName);
            }
			
            this.state = s;
            
            switch(this.state) {
                case "normal":
                    this.activateButton(true);
                    break;
                case "hidden":
                case "nonactive":
                    this.activateButton(false);
                    break;
            }
        }
    },
    
    
    /**
     * "over" 状態にする
     */
    setOverState : function() {
        this.setState("over");
    },
    
    /**
     *
     */
    setNormalState : function() {
        this.setState("normal");
    },
    
    /**
     * 要素を返す
     */
    getElement : function(){
        return this.div;
    },
    
    getClassName : function() {
        return this.baseClassName + "_" + this.state;
    }

};




//----
//Event.observe(window, 'load', init, false);