//---------------------------------------------------------------------------
#include <vcl.h>
#include <Vcl.Imaging.pngimage.hpp>
#pragma hdrstop

#include "GlobalUnit.h"
#include "StyleItem.h"
#include "FavorTextureUnit.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

TPngImage *u_imgFold = NULL,
		*u_imgUnfold = NULL,
		*u_imgTrackOn = NULL,
		*u_imgTrackOff = NULL,
		*u_imgDelete = NULL,
		*u_imgDownload = NULL,
		*u_imgDownloading = NULL,
		*u_imgProg = NULL,
		*u_imgTexture = NULL,
		*u_imgVolume = NULL,
		*u_imgBrush = NULL,
		*u_imgCollect = NULL,
		*u_imgUnCollect = NULL,
		*u_imgScore = NULL,
		*u_imgSave = NULL,
		*u_imgImport = NULL,
		*u_imgUpload = NULL,
		*u_imgCharge = NULL;

COLORREF clrTextStyle = RGB(201, 214, 229), //Style文字
			clrTextHot = RGB( 225, 236, 255 ),	//高亮文字
			clrTextDirty = RGB( 226, 232, 187 ),
			clrTextDisable = RGB( 126, 131, 137 ),	//未下载文字
			clrTextLoading	= RGB( 105, 197, 235 ),	//正在下载
			clrBackground = RGB(47, 50, 57), //面板背景
			clrFocback = RGB( 67, 73, 80 ), //焦点背景
			clrSelback = RGB( 29, 31, 35 ); //选中背景

TStyleItem *g_pPreStyle = NULL,
		   *g_pUseStyle = NULL;

/////////////////////////////////////////////////////////////////////////////
// TCommonItem
__fastcall TCommonItem::TCommonItem()
{
	iType = 0;
	dwState = 0;
	iFocusCol = 0;

	aOptions = new System::Classes::TList();
	aItems = new System::Classes::TList();
	prev = next = up = NULL;
}

__fastcall TCommonItem::TCommonItem( char type, DWORD opts )
{
	iType = type;
	dwState = 0;
	iFocusCol = 0;

	aOptions = new System::Classes::TList();
	aItems = new System::Classes::TList();
	prev = next = up = NULL;

	if( opts!=0 ){
		for( int i=0; i<OPT_NUM; i++ ){
			if( opts & (1<<i) )
				aOptions->Add( (void*)(1<<i) );
		}
	}
}

__fastcall TCommonItem::~TCommonItem()
{
	ClearSubItems();

	delete aOptions;
	delete aItems;
}

void TCommonItem::ClearSubItems()
{
	for( int i=0; i<aItems->Count; i++ ){
		delete aItems->Items[i];
	}

	aItems->Clear();
}

void TCommonItem::RemoveSubItem( TCommonItem* pSub )
{
	if( pSub->prev )
		pSub->prev->next = pSub->next;
	if( pSub->next )
		pSub->next->prev = pSub->prev;

	aItems->Remove( pSub );
	delete pSub;
}

short __fastcall TCommonItem::GetColume( int X )
{
	return 0;
}

bool TCommonItem::IsUnfold()
{
	return dwState & STATE_UNFOLD;
}

bool TCommonItem::IsSelected()
{
	return dwState & STATE_SELECTED;
}
/*
void __fastcall TCommonItem::SetCollect( bool bSet )
{
	if( bSet )
		dwState |= STATE_COLLECTED;
	else
		dwState &= ~STATE_COLLECTED;
}
*/
void __fastcall TCommonItem::SetFocus( WORD iCol )
{
	iFocusCol = iCol;
}

void __fastcall TCommonItem::SetUnfold( bool bSet )
{
	if( bSet )
		dwState |= STATE_UNFOLD;
	else
		dwState &= ~STATE_UNFOLD;
}

void __fastcall TCommonItem::Select( bool bSet )
{
	if( bSet )
		dwState |= STATE_SELECTED;
	else
		dwState &= ~STATE_SELECTED;
}

void __fastcall TCommonItem::SetHover( bool bSet )
{
	if( bSet )
		dwState |= STATE_HOVER;
	else
		dwState &= ~STATE_HOVER;
}

DWORD TCommonItem::GetOption( int iCol )
{
	for( int i=0; i<OPT_COL_NUM; i++ ){
		if( iCol==(COL_OPT<<i) && aOptions->Count>i ){
			return (DWORD)aOptions->Items[i];
		}
	}

	return 0;
}

int TCommonItem::GetOnlineState()
{
	TStyleItem* pStyItem = GetStyleItem();

	if( pStyItem && pStyItem->pStyle ){
		if( pStyItem->pStyle->idLoc==0 )
			return pStyItem->pStyle->pOrigin->state;
		else if( pStyItem->pStyle->idLoc==1 ){
			if( iType==SEGTYPE_STYLE ){
				int iStyDlState = e_Downloaded;
				for( int i=0; i<aItems->Count; i++ ){
					TSegmentItem* pSeg = (TSegmentItem*)aItems->Items[i];
					int iState = pSeg->GetOnlineState();
					if( iState==e_UnDownload )
						return e_UnDownload;
					else if( iState==e_Downloading )
						iStyDlState = iState;
				}

				return iStyDlState;
			}
			else if( iType==SEGTYPE_TRACK ){
				TTrackItem* pTrk = (TTrackItem*)this;
				if( pTrk->pStyle->idLoc==0 )
					return pTrk->pStyle->pOrigin->state;
				else
					return e_Downloaded;
			}
			else{
				int iSegDlState = e_Downloaded;
				for( int i=0; i<aItems->Count; i++ ){
					TTrackItem* pTrk = (TTrackItem*)aItems->Items[i];
					int iState = pTrk->GetOnlineState();
					if( iState==e_UnDownload )
						return e_UnDownload;
					else if( iState==e_Downloading )
						iSegDlState = iState;
				}

				return iSegDlState;
			}
		}
	}

	return e_Downloaded;
}

TStyleItem* TCommonItem::GetStyleItem()
{
	if( iType==SEGTYPE_STYLE ){
		return (TStyleItem*)this;
	}
	else if( iType==SEGTYPE_TRACK ){
		return (TStyleItem*)up->up;
	}
	else{
		return (TStyleItem*)up;
	}
}

void TCommonItem::SetOnlineState( int iState )
{
	TStyleItem* pStyItem = GetStyleItem();

	if( pStyItem && pStyItem->pStyle ){
		if( pStyItem->pStyle->idLoc==0 )
			pStyItem->pStyle->pOrigin->state = iState;
		else if( pStyItem->pStyle->idLoc==1 && iType==SEGTYPE_TRACK ){
			TTrackItem* pTrk = (TTrackItem*)this;
			if( pTrk->pStyle->idLoc==0 )
				pTrk->pStyle->pOrigin->state = iState;
		}
	}
}

COLORREF TCommonItem::TextColor()
{
	return clrTextStyle;
}

void __fastcall TCommonItem::DrawItem( TCanvas* Canvas, TRect Rect, WORD iCol )
{
	int X, Y;

	if( iType!=SEGTYPE_STYLE ){
		Rect.Left += OPTION_WIDTH;

		if( iType==SEGTYPE_TRACK ){
			Rect.Left += OPTION_WIDTH;
		}
	}

	Canvas->Brush->Color = clrBackground;

	if( iCol==WORD(-1) ){
		//刷新左边
		TRect rtFresh( 0, Rect.Top, Rect.Left+OPTION_WIDTH, Rect.Bottom );
		Canvas->FillRect( rtFresh );
	}

	if( dwState & STATE_SELECTED ) //绘制选中背景
		Canvas->Brush->Color = clrSelback;
	else if( dwState & STATE_HOVER || iFocusCol>COL_FOLD )
		Canvas->Brush->Color = clrFocback;

	if( iCol & COL_FOLD ){
		TPngImage *pImg = NULL;
		if( aItems->Count>0 ){ //输出fold
			pImg = (dwState & STATE_UNFOLD) ? u_imgUnfold : u_imgFold;
		}
		else if( iType==SEGTYPE_TRACK ){ //输出mute
			pImg = IsMute() ? u_imgTrackOff : u_imgTrackOn;
		}

		if( pImg ){
			RECT rt;
			GetClipBox( Canvas->Handle, &rt );

			int w = pImg->Width/2,
				h = pImg->Height,
				l = ( iFocusCol==COL_FOLD ) ? w : 0;

			X = Rect.Left + (OPTION_WIDTH - w)/2;
			Y = Rect.Top + ( OPTION_HEIGHT - h) / 2;

			int x = X-rt.left,
				y = Y-rt.top,
				b = y+h;
			if( b > Rect.Bottom - rt.top )
				b = Rect.Bottom - rt.top;

			HRGN rgnClip = CreateRectRgn( x, y, x+w, b );

			SelectClipRgn( Canvas->Handle, rgnClip );
			Canvas->Draw( X-l, Y, pImg );
			SelectClipRgn( Canvas->Handle, NULL );
			DeleteObject(rgnClip);
		}
	}

	int iOnline = GetOnlineState();

	if( iCol >= COL_TEXT ){
		//输出文字
		if( iFocusCol>=COL_TEXT ){
			Canvas->Font->Color = clrTextHot;
		}
		else if( iOnline==e_UnDownload ){
			Canvas->Font->Color = clrTextDisable;
		}
		else if( iOnline==e_Downloading ){
			if( iType==SEGTYPE_STYLE )
				Canvas->Font->Color = clrTextLoading;
			else
				Canvas->Font->Color = clrTextDisable;
		}
		else{
			Canvas->Font->Color = TextColor();
		}

		String strText = GetCaption();

		Rect.Left += OPTION_WIDTH;
		Y = Rect.Top + ( OPTION_HEIGHT - Canvas->TextHeight(strText) )/2;

		//----处理字符过长------
		int nWidth = Rect.Width() - 4 - 8;
		if( iFocusCol > COL_FOLD || dwState & STATE_SELECTED )
			nWidth -= aOptions->Count*OPTION_WIDTH + 2;

		if( Canvas->TextWidth( strText )>nWidth ){
			UnicodeString strShorty = strText;
			while( Canvas->TextWidth( strShorty )>nWidth ){
					strShorty = strShorty.SubString( 1, strShorty.Length()-2 );
			}

			strText = strShorty;
			strText+="...";
		}
		//-----------
		Canvas->Brush->Style = bsSolid;
		Canvas->TextRect( Rect, Rect.Left+4, Y, strText );
	}

	for( int i=0; i<aOptions->Count; i++ ){
		DWORD iOpt = (DWORD)aOptions->Items[i];
		TPngImage* pImg = NULL;

		if( iOpt==OPT_DEL ){
			pImg = u_imgDelete;
		}
		else if( iOpt==OPT_DOWNLOAD ){
			if( iOnline==e_Downloading )
				pImg = u_imgDownloading;
			else
				pImg = u_imgDownload;
		}
		else if( iOpt==OPT_BRUSH )
			pImg = u_imgBrush;
		else if( iOpt==OPT_TEXTURE )
			pImg = u_imgTexture;
		else if( iOpt==OPT_FONTPROG )
			pImg = u_imgProg;
		else if( iOpt==OPT_VOL )
			pImg = u_imgVolume;
		else if( iOpt==OPT_COLLECT ){
			if( IsCollected() )
				pImg = u_imgCollect;
			else
				pImg = u_imgUnCollect;
		}
		else if( iOpt==OPT_SCORE )
			pImg = u_imgScore;
		else if( iOpt==OPT_SAVE )
			pImg = u_imgSave;
		else if( iOpt==OPT_IMPORT )
			pImg = u_imgImport;
		else if( iOpt==OPT_UPLOAD )
			pImg = u_imgUpload;
		else if( iOpt==OPT_CHARGE )
			pImg = u_imgCharge;

		if( iFocusCol>COL_FOLD  || (dwState & STATE_SELECTED) ){
			Rect.Right -= OPTION_WIDTH;

			if( pImg ){
				RECT rt;
				GetClipBox( Canvas->Handle, &rt );

				int w = pImg->Width/3,
					h = pImg->Height,
					l = ( iFocusCol==(1<<(i+2)) ) ? w : 0;

				X = Rect.Right + (OPTION_WIDTH - w)/2;
				Y = Rect.Top + ( OPTION_HEIGHT - h) / 2;

				int x = X-rt.left,
					y = Y-rt.top,
					b = y+h;
				if( b > Rect.Bottom - rt.top )
					b = Rect.Bottom - rt.top;

				HRGN rgnClip = CreateRectRgn( x, y, x+w, b );

				SelectClipRgn( Canvas->Handle, rgnClip );
				Canvas->Draw( X-l, Y, pImg );
				SelectClipRgn( Canvas->Handle, NULL );
				DeleteObject(rgnClip);
			}
		}
	}
}

/////////////////////////////////////////////////////////////////////////////
// TTrackItem
__fastcall TTrackItem::TTrackItem()
	: TCommonItem(SEGTYPE_TRACK, 0 )
{
	bOwnTrack = false;
	pTrack = NULL;
}

__fastcall TTrackItem::TTrackItem( TCommonItem* pUpItem, TPROSTYLE* info,
												char stype, char sno, char ch,
												char prog, char vol, DWORD opts )
	: TCommonItem( SEGTYPE_TRACK, opts )
{
	pStyle = info;
	up = pUpItem;
}

__fastcall TTrackItem::TTrackItem( TCommonItem* pUpItem, TPROSTYLE* info, TTrack* pTrk,
																DWORD opts, bool bOwn )
	: TCommonItem( SEGTYPE_TRACK, opts )
{
	up = pUpItem;
	pStyle = info;
	bOwnTrack = bOwn;
	pTrack = pTrk;
}

__fastcall TTrackItem::~TTrackItem()
{
	if( bOwnTrack && pTrack )
		delete pTrack;
}

void TTrackItem::SetMute( bool bSet )
{
	if( pTrack ){
		if( bSet )
			pTrack->nVol |= 0x80;
		else
			pTrack->nVol &= ~0x80;
	}
}

bool TTrackItem::IsCollected()
{
	return IsFavorTexture( pStyle->idLoc, pStyle->idStyle, GetSegType(),
									pTrack->iSegNo, pTrack->iChanNo );
}

void TTrackItem::StyleId2Str( String& strText )
{
	char strNo[20];
	if( pStyle->idLoc==0 ){
		sprintf( strNo, "[%d] ",  pStyle->idStyle );
	}
	else if( pStyle->idLoc==1 ){
		sprintf( strNo, "[S%d] ",  pStyle->idStyle );
	}
	else if( pStyle->idLoc==(UINT)-1 ){
		sprintf( strNo, "[T%d] ",  LOWORD(pStyle->idStyle) );
	}
	else{
		sprintf( strNo, "[L%d] ",  LOWORD(pStyle->idStyle) );
	}

	strText += strNo;
}

char TTrackItem::GetSegType()
{
	return ((TSegmentItem*)up)->iSegType;
}

char TTrackItem::GetSegNo()
{
	if( pTrack )
		return pTrack->iSegNo;
}

bool TTrackItem::IsMute()
{
	return pTrack ? pTrack->nVol < 0 : false;
}

void TTrackItem::AddStyleId( String& strText )
{
	TStyleItem* pStyItem = GetStyleItem();

	if( pStyItem->pStyle!=pStyle ){
		strText += " ";

		StyleId2Str( strText );
	}
}

String TTrackItem::GetCaption()
{
	String strText;

	if( pTrack->iBank!=0xFF || pTrack->iProg!=pTrack->iProgOrig
						|| (pTrack->nVolOrig & 0x7F) != (pTrack->nVol & 0x7F) ){
		strText += "* ";
	}

	if( (pTrack->iBank==0xFF || pTrack->iBank<0x80) && pTrack->iChanNo==9 )
		strText += "GM鼓";
	else
		strText += GetProgName( pTrack->iBank, pTrack->iChanNo, pTrack->iProg );

	AddStyleId( strText );

	return strText;
}

COLORREF TTrackItem::TextColor()
{
	if( pTrack->iBank!=0xFF ){
		return clrTextDirty;
	}

	return GetSegmentColor( GetSegType(), 0, false );
}

String TTrackItem::HintText()
{
	String strText = "织体：";

	StyleId2Str( strText );

	char strType_No[8];
	sprintf( strType_No, "%s - %d", NAME_SEG[GetSegType()], pTrack->iSegNo+1 );
	strText += strType_No;

	strText += "\n\n音源：";

	int iFont = pTrack->iBank==0xFF && !g_bExtFont ? g_idFont: pTrack->iBank;
	if( iFont==0xFF ){
		strText += "扩展音色库";
	}
	else if( iFont<0x80 ){
		FONTINFO* pFI = g_lstFonts[iFont];

		strText += pFI->strFontName;
	}
	else{
		VSTINFO* pFI = g_lstVSTi[iFont-0x80];
		strText += pFI->strVSTName;
	}

	strText += "\n";

	if( pTrack->iProg!=pTrack->iProgOrig )
		strText += "当前";
	strText += "乐器：";

	strText += GetProgName( pTrack->iBank, pTrack->iChanNo, pTrack->iProg );

	if( pTrack->iProg!=pTrack->iProgOrig ){
		strText += "\n原始乐器：";
		strText += GetProgName( 0xFF, pTrack->iChanNo, pTrack->iProgOrig );
	}
	strText += "\n\n";

	if( pTrack->nVol!=pTrack->nVolOrig )
		strText += "当前";
	strText += "音量：";

	if( pTrack->nVol<0 )
		strText += "静音";
	else
		strText += IntToStr( pTrack->nVol );

	if( pTrack->nVol!=pTrack->nVolOrig ){
		strText += "\n原始音量：";
		strText += IntToStr( pTrack->nVolOrig );
	}

	return strText;
}

/////////////////////////////////////////////////////////////////////////////
// TSegmentItem
__fastcall TSegmentItem::TSegmentItem()
	: TCommonItem(SEGTYPE_SEGMENT, 0)
{
	iSegType = 0;
	iSegNo = 0;
	iInd = 0;
	volume = 0;
	nBars = 0;
	bAutoSpec = false;
	memset( aChanUsed, 0, sizeof(aChanUsed) );
}

__fastcall TSegmentItem::TSegmentItem( TCommonItem* pUpItem, char stype, char sno, DWORD opts,
												int bars, char ind, char vol, bool bSpec )
	: TCommonItem( SEGTYPE_SEGMENT, opts )
{
	up = pUpItem;
	iSegType = stype;
	iSegNo = sno;
	iInd = ind;
	volume = vol;
	nBars = bars;
	bAutoSpec = bSpec;
	memset( aChanUsed, 0, sizeof(aChanUsed) );
}

void TSegmentItem::ClearSubItems()
{
	TCommonItem::ClearSubItems();
	memset( aChanUsed, 0, sizeof(aChanUsed) );
}

TTrackItem* __fastcall TSegmentItem::AddTrack( TPROSTYLE* info, TTrack* pTrack, DWORD opts, bool bOwn, int iInd )
{
	if( !info && !(info = GetStyleInfo( pTrack->iStyleLoc, pTrack->iStyleId )))
		return NULL;

	TTrackItem *pItem = NULL;

	if( iInd>=0 ){
		pItem = new TTrackItem( this, info, pTrack, opts, bOwn );
		if( iSegType==SEGTYPE_VAR || iSegType==SEGTYPE_FILL )
			pItem->aOptions->Add((void*)OPT_BRUSH);

		if( aItems->Count==0 ){
        	aItems->Add( pItem );
		}
		else if( iInd<aItems->Count ){
			TCommonItem *pNext = (TCommonItem*)aItems->Items[iInd];
			if( pNext->prev )
				pNext->prev->next = pItem;
			pItem->prev = pNext->prev;
			pNext->prev = pItem;
			pItem->next = pNext;

			aItems->Insert( iInd, pItem );
		}
		else{
			TCommonItem *pLast = (TCommonItem*)aItems->Last();
			pLast->next = pItem;
			pItem->prev = pLast;

			aItems->Add( pItem );
		}
	}
	else{
		for( int i=0; i<aItems->Count; i++ ){
			TTrackItem* pTmp = (TTrackItem*)aItems->Items[i];

			if( pTrack->iChanNo==9 && pTmp->pTrack->iChanNo==9 ){
				pItem = pTmp;
				break;
			}
		}

		if( pItem ){
			pItem->pStyle = info;
			pTrack->iBank = pItem->pTrack->iBank;
			pTrack->iChanSpec = pItem->pTrack->iChanSpec;
			pTrack->iFile = pItem->pTrack->iFile;

			if( bOwn )
				delete pItem->pTrack;
			pItem->pTrack = pTrack;
		}
		else{
			pItem = new TTrackItem( this, info, pTrack, opts, bOwn );
			if( iSegType==SEGTYPE_VAR || iSegType==SEGTYPE_FILL )
				pItem->aOptions->Add((void*)OPT_BRUSH);

			char ch = pTrack->iChanNo,
				chSpec = pTrack->iChanSpec;
			if( ch==9 ){
				aChanUsed[9] = true;
			}
			else if( bAutoSpec ){
				if( !aChanUsed[chSpec] ){
					aChanUsed[chSpec] = true;
				}
				else if( ch!=9 ){
					for( int i=0; i<16; i++ ){
						if( !aChanUsed[i] ){
							pTrack->iChanSpec = i;
							aChanUsed[i] = true;
							break;
						}
					}
				}
			}

			bool bInserted = false;
			if( aItems->Count>0 ){
				if( ch==9 ){ //只能一个打击乐轨，且总在第一个
					TTrackItem *pFirst = (TTrackItem*)aItems->First();
					pItem->next = pFirst;
					pFirst->prev = pItem;

					aItems->Insert( 0, pItem );
					bInserted = true;
				}
				else{
					TCommonItem *pLast = (TCommonItem*)aItems->Last();

					pLast->next = pItem;
					pItem->prev = pLast;
				}
			}

			if( !bInserted )
				aItems->Add( pItem );
		}
	}

	return  pItem;
}

TTrackItem* __fastcall TSegmentItem::AddTrack( TPROSTYLE* info, char sno, char ch,
													char prog, char vol, DWORD opts )
{
	TTrack* pTrack = new TTrack;
	pTrack->iStyleLoc = info->idLoc;
	pTrack->iStyleId = info->idStyle;
	pTrack->iSegNo = sno;
	pTrack->iChanNo = pTrack->iChanSpec = ch;
	pTrack->iProg = pTrack->iProgOrig = prog;
	pTrack->nVol = pTrack->nVolOrig = vol;

	return AddTrack( info, pTrack, opts, true );
}

TTrackItem* __fastcall TSegmentItem::AddTrack( TPROSTYLE* info, char sn, char tn,
															DWORD opts, bool bAddLocal )
{
	TTrackItem *pItem = NULL;
	char st = iSegType;

	if( info->idLoc==0 ){
		TSTYLEORIGIN* pOrigin = info->pOrigin;
		if( pOrigin->detail.tracks[st][sn][tn].no>=0 ){

			pItem = AddTrack( info, sn,
							pOrigin->detail.tracks[st][sn][tn].no,
							pOrigin->detail.tracks[st][sn][tn].prog,
							pOrigin->detail.tracks[st][sn][tn].vol,
							opts );
		}
	}
	else if( info->idLoc==1 ){
		TSTYLESHARE* pShare = info->pShare;
		TSHARETRACKREF& trkRef = pShare->trkRef[st][sn][tn];
		UINT idStyle = trkRef.idStyle;

		TPROSTYLE* pTrkInfo = NULL;

		if( idStyle>0 )
			pTrkInfo = GetStyleInfo( 0, idStyle );

		if( pTrkInfo ){
			int osn = trkRef.segNo;
			char chan = trkRef.chan,
				prog = trkRef.prog,
				vol = trkRef.vol;// & 0x7F;

			if( pTrkInfo!=info ){
				for( int t=0; t<16; t++ ){
					if( pTrkInfo->pOrigin->detail.tracks[st][osn][t].no==chan ){
						prog = pTrkInfo->pOrigin->detail.tracks[st][osn][t].prog;
						vol = pTrkInfo->pOrigin->detail.tracks[st][osn][t].vol;
						break;
					}
				}
			}

			pItem = AddTrack( pTrkInfo, osn, chan, prog, vol, opts );
			pItem->pTrack->iProg = trkRef.prog;
			pItem->pTrack->nVol = trkRef.vol;
		}
	}
	else{
		TSTYLELOCAL* pLocal = info->pLocal;
		TTRACKREF& trkRef = pLocal->trkRef[st][sn][tn];
		UINT idLoc = trkRef.idLoc,
			idStyle = trkRef.idStyle;

		TPROSTYLE* pTrkInfo = NULL;
		if( idStyle>0 && ( bAddLocal || idLoc==0 ) ){
			pTrkInfo = GetStyleInfo( idLoc, idStyle );
		}

		if( pTrkInfo ){
			int osn = trkRef.segNo;
			char chan = trkRef.chan,
				prog = trkRef.prog,
				vol = trkRef.vol;// & 0x7F;

			if( pTrkInfo!=info ){
				for( int t=0; t<16; t++ ){
					if( pTrkInfo->idLoc==0 ){
						if( pTrkInfo->pOrigin->detail.tracks[st][osn][t].no==chan ){
							prog = pTrkInfo->pOrigin->detail.tracks[st][osn][t].prog;
							vol = pTrkInfo->pOrigin->detail.tracks[st][osn][t].vol;
							break;
						}
					}
					else{
						int nSegNum = info->pLocal->nSegNum[st];
						int iStart = ( st<SEGTYPE_INTRO || sn<4 ) ? 0 : 4,
							iEnd = iStart + ( iStart==0 ? ( nSegNum & 0x0F ) : ( nSegNum>>4 ));

						bool bFind = false;
						for( int i=iStart; !bFind && i<iEnd; i++ ){
							for( int j=0; j<16; j++ ){
								if( pTrkInfo->pLocal->trkRef[st][i][j].idLoc==idLoc
											&& pTrkInfo->pLocal->trkRef[st][i][j].idStyle==idStyle
											&& pTrkInfo->pLocal->trkRef[st][i][j].segNo==osn
											&& pTrkInfo->pLocal->trkRef[st][i][j].chan==chan ){
									prog = pTrkInfo->pLocal->trkRef[st][i][j].prog;
									vol = pTrkInfo->pLocal->trkRef[st][i][j].vol;

									bFind = true;
									break;
								}
								else if( pTrkInfo->pLocal->trkRef[st][i][j].idLoc==0
											&& pTrkInfo->pLocal->trkRef[st][i][j].idStyle==0 ){
									break;
								}
							}
						}
					}
				}
			}

			pItem = AddTrack( pTrkInfo, osn, chan, prog, vol, opts );
			pItem->pTrack->iProg = trkRef.prog;
			pItem->pTrack->nVol = trkRef.vol;
		}
	}

	return pItem;
}
/*
TTrackItem* __fastcall TSegmentItem::AddTrack( TPROSTYLE* info, char st, char sn, char tn,
														DWORD opts, bool bAddLocal )
{
	TTrackItem *pItem = NULL;

	if( info->idLoc==0 ){
		TSTYLEORIGIN* pOrigin = info->pOrigin;
		if( pOrigin->detail.tracks[st][sn][tn].no>=0 ){
			pItem = AddTrack( info, st, sn,
							pOrigin->detail.tracks[st][sn][tn].no,
							pOrigin->detail.tracks[st][sn][tn].no,
							pOrigin->detail.tracks[st][sn][tn].prog,
							pOrigin->detail.tracks[st][sn][tn].vol,
							opts );
		}
	}
	else if( info->idLoc==1 ){
		TSTYLESHARE* pShare = info->pShare;
		TSHARETRACKREF& trkRef = pShare->trkRef[st][sn][tn];
		UINT idStyle = trkRef.idStyle;

		TPROSTYLE* pTrkInfo = NULL;

		if( idStyle>0 )
			pTrkInfo = GetStyleInfo( 0, idStyle );

		if( pTrkInfo ){
			int osn = trkRef.segNo;
			char chan = trkRef.chan,
				prog = trkRef.prog,
				vol = trkRef.vol;// & 0x7F;

			if( pTrkInfo!=info ){
				for( int t=0; t<16; t++ ){
					if( pTrkInfo->pOrigin->detail.tracks[st][osn][t].no==chan ){
						prog = pTrkInfo->pOrigin->detail.tracks[st][osn][t].prog;
						vol = pTrkInfo->pOrigin->detail.tracks[st][osn][t].vol;
						break;
					}
				}
			}

			pItem = AddTrack( pTrkInfo, st, osn, chan, chan, prog, vol, opts );
			pItem->progCurr = trkRef.prog;
			pItem->volCurr = trkRef.vol;
		}
	}
	else{
		TSTYLELOCAL* pLocal = info->pLocal;
		TTRACKREF& trkRef = pLocal->trkRef[st][sn][tn];
		UINT idLoc = trkRef.idLoc,
			idStyle = trkRef.idStyle;

		TPROSTYLE* pTrkInfo = NULL;
		if( idStyle>0 && ( bAddLocal || idLoc==0 ) ){
			pTrkInfo = GetStyleInfo( idLoc, idStyle );
		}

		if( pTrkInfo ){
			int osn = trkRef.segNo;
			char chan = trkRef.chan,
				prog = trkRef.prog,
				vol = trkRef.vol;// & 0x7F;

			if( pTrkInfo!=info ){
				for( int t=0; t<16; t++ ){
					if( pTrkInfo->idLoc==0 ){
						if( pTrkInfo->pOrigin->detail.tracks[st][osn][t].no==chan ){
							prog = pTrkInfo->pOrigin->detail.tracks[st][osn][t].prog;
							vol = pTrkInfo->pOrigin->detail.tracks[st][osn][t].vol;
							break;
						}
					}
					else{
						int nSegNum = info->pLocal->nSegNum[st];
						int iStart = ( st<SEGTYPE_INTRO || sn<4 ) ? 0 : 4,
							iEnd = iStart + ( iStart==0 ? ( nSegNum & 0x0F ) : ( nSegNum>>4 ));

						bool bFind = false;
						for( int i=iStart; !bFind && i<iEnd; i++ ){
							for( int j=0; j<16; j++ ){
								if( pTrkInfo->pLocal->trkRef[st][i][j].idLoc==idLoc
											&& pTrkInfo->pLocal->trkRef[st][i][j].idStyle==idStyle
											&& pTrkInfo->pLocal->trkRef[st][i][j].segNo==osn
											&& pTrkInfo->pLocal->trkRef[st][i][j].chan==chan ){
									prog = pTrkInfo->pLocal->trkRef[st][i][j].prog;
									vol = pTrkInfo->pLocal->trkRef[st][i][j].vol;

									bFind = true;
									break;
								}
								else if( pTrkInfo->pLocal->trkRef[st][i][j].idLoc==0
											&& pTrkInfo->pLocal->trkRef[st][i][j].idStyle==0 ){
									break;
								}
							}
						}
					}
				}
			}

			pItem = AddTrack( pTrkInfo, st, osn, chan, chan, prog, vol, opts );
			pItem->progCurr = trkRef.prog;
			pItem->volCurr = trkRef.vol;
		}
	}

	return pItem;
}
*/
void TSegmentItem::DeleteTrack( TCommonItem* pItem )
{
	if( ((TTrackItem*)pItem)->pTrack->iChanNo==9 )
		aChanUsed[9] = false;
	else if( bAutoSpec )
		aChanUsed[((TTrackItem*)pItem)->pTrack->iChanSpec] = false;

	aItems->Remove( pItem );
	delete pItem;
}

char TSegmentItem::GetIndType()
{
	char type = iSegType;

	if( ((TStyleItem*)up)->nBars>0 && type==SEGTYPE_FILL )
		type = SEGTYPE_VAR;

	return type;
}

String TSegmentItem::GetCaption()
{
	String strText;

	if( ((TStyleItem*)up)->nBars>0 ){
		if( iSegType<=SEGTYPE_FILL ){
			strText += "旋律";
			strText += String("-") + (int)(iInd+1);
			strText += " ";
			strText += g_strSegment[iSegType];
		}
		else{
			if( iSegType==SEGTYPE_INTRO ){
				int index = iInd;
				if( ((TCommonItem*)up->aItems->First())->GetSegType()!=SEGTYPE_INTRO )
					index++;

				if( index==0 ){
					strText += "前奏";
				}
				else{
					strText += "间奏";
					strText += String("-") + index;
				}
			}
			else{
				strText += "尾奏";
			}
		}
	}
	else{
		strText += g_strSegment[iSegType];
		strText += String("-") + (int)(iInd+1);
	}

	if( iSegType>=SEGTYPE_INTRO ){
		if( iSegNo<4 )
			strText += " 大调" ;
		else
			strText += " 小调" ;
	}

	if( nBars>0 ){
		char strNum[20];
		sprintf( strNum, " (%d小节)", nBars );
		strText += strNum;
	}

	return strText;
}

COLORREF TSegmentItem::TextColor()
{
	int ty = GetSegType(),
		iNo = g_iSegColorMode==0 ? GetSegNo() : aItems->Count;
	bool bInc = g_iSegColorMode==0 ? true
						: iNo>0 && ((TTrackItem*)aItems->Items[0])->pTrack->iChanNo==9;

	return GetSegmentColor( ty, iNo, bInc );
}

/////////////////////////////////////////////////////////////////////////////
// TStyleItem
__fastcall TStyleItem::TStyleItem()
	: TCommonItem(SEGTYPE_STYLE, 0)
{
	pStyle = NULL;
	nBars = 0;
//	nVarNum = nFillNum = nIntroMajNum = nIntroMinNum = nEndingMajNum = nEndingMinNum = 0;
	memset( nSegNum, 0, sizeof(int)*4 );
}

__fastcall TStyleItem::TStyleItem( TPROSTYLE* info, DWORD opts )
	: TCommonItem( SEGTYPE_STYLE, opts )
{
	pStyle = info;
	nBars = 0;
	memset( nSegNum, 0, sizeof(int)*4 );
//	idLoc = info->idLoc;
//	idStyle = info->idStyle;
}

bool TStyleItem::IsCollected()
{
	return IsCollectedStyle( pStyle->idLoc, pStyle->idStyle );
}

TSegmentItem* __fastcall TStyleItem::AddSegment( char stype, char sno, DWORD opts,
													int bars, char ind, char vol, bool bAutoSpec )
{
	int index = ind;
	if( ind<0 )
		index = sno;//nSegNum[stype];

	TSegmentItem *pItem = new TSegmentItem( this, stype, sno, opts, bars, index, vol, bAutoSpec );

	bool bInserted = false;
	if( aItems->Count>0 ){
		if( ind<0 ){
			ind = 0;
			for( int i=0; i<=stype; i++ ){
				ind += nSegNum[i];
			}
		}

		if( bars==0 && ind>=0 && aItems->Count>ind ){
			TCommonItem *pNext = (TCommonItem*)aItems->Items[ind];

			if( pNext->prev ){
				pItem->prev = pNext->prev;
				pNext->prev->next = pItem;
			}

			pItem->next = pNext;
			pNext->prev = pItem;

			aItems->Insert( ind, pItem );
			bInserted = true;
		}
		else{
			TCommonItem* pLast = (TCommonItem*)aItems->Last();
			pLast->next = pItem;
			pItem->prev = pLast;
		}
	}

	if( !bInserted ){
		aItems->Add( pItem );
	}

	nSegNum[stype]++;
	nBars += bars;

	return pItem;
}

void TStyleItem::InsertSegment( int ind, TSegmentItem* pItem, int bars )
{
	if( ind<0 || ind > aItems->Count )
		ind = aItems->Count;

	if( aItems->Count > ind ){
		TCommonItem *pNext = (TCommonItem*)aItems->Items[ind];

		if( pNext->prev ){
			pItem->prev = pNext->prev;
			pNext->prev->next = pItem;
		}

		pItem->next = pNext;
		pNext->prev = pItem;

		aItems->Insert( ind, pItem );
	}
	else{
		if( aItems->Count>0 ){
			TCommonItem* pLast = (TCommonItem*)aItems->Last();
			pLast->next = pItem;
			pItem->prev = pLast;
		}
		aItems->Add( pItem );
	}

//	pItem->iInd = ind;

	nSegNum[pItem->iSegType]++;
	nBars += bars;
}

void TStyleItem::DeleteSegment( TCommonItem* pSeg )
{
	nSegNum[pSeg->GetSegType()]--;

	if( pSeg->next ){
		int stype = ((TSegmentItem*)pSeg)->GetIndType();
		TSegmentItem* pNext = (TSegmentItem*)pSeg->next;
		while( pNext ){
			if( pNext->GetIndType()==stype )
				pNext->iInd--;

			pNext = (TSegmentItem*)pNext->next;
		}
	}

	aItems->Remove( pSeg );
	delete pSeg;
}

void TStyleItem::SetDownload()
{
	if( pStyle ){
		if( pStyle->idLoc==0 ){
//			pStyle->pOrigin->state = e_Downloaded;
			for( int i=0; i<aOptions->Count; i++ ){
				DWORD iOpt = (DWORD)aOptions->Items[i];
				if( iOpt==OPT_DOWNLOAD ){
					aOptions->Items[i] = (void*)OPT_COLLECT;
					break;
				}
			}
		}
		else if( pStyle->idLoc==1 ){
			bool bFull = true;
			for( int i=0; i<aItems->Count; i++ ){
				TSegmentItem* pSeg = (TSegmentItem*)aItems->Items[i];
				for( int j=0; j<pSeg->aItems->Count; j++ ){
					TTrackItem* pTrk = (TTrackItem*)pSeg->aItems->Items[j];
					if( pTrk->pStyle->idLoc==0 && pTrk->pStyle->pOrigin->state!=e_Downloaded ){
						bFull = false;
						break;
					}
				}

				if( !bFull )
					break;
			}

			if( bFull ){
				for( int i=0; i<aOptions->Count; i++ ){
					DWORD iOpt = (DWORD)aOptions->Items[i];
					if( iOpt==OPT_DOWNLOAD ){
						aOptions->Items[i] = (void*)OPT_COLLECT;
						break;
					}
				}
			}
		}
	}
}

void TStyleItem::SetImport()
{
	bool bSet = false;
	for( int i=0; i<4; i++ ){
		if( nSegNum[i]<8 ){
			bSet = true;
			break;
		}
	}

	int iImport = -1;
	for( int i=0; i<aOptions->Count; i++ ){
		DWORD iOpt = (DWORD)aOptions->Items[i];
		if( iOpt==OPT_IMPORT ){
			iImport = i;
			break;
		}
	}

	if( iImport<0 && bSet ){
		aOptions->Add((void*)OPT_IMPORT);
	}
	else if( iImport>=0 && !bSet ){
		aOptions->Delete( iImport );
	}
}

void TStyleItem::SetCharge( bool bSet )
{
	int iCharge = -1;
	for( int i=0; i<aOptions->Count; i++ ){
		DWORD iOpt = (DWORD)aOptions->Items[i];
		if( iOpt==OPT_CHARGE ){
			iCharge = i;
			break;
		}
	}

	if( iCharge<0 && bSet ){
		aOptions->Add((void*)OPT_CHARGE);
	}
	else if( iCharge>=0 && !bSet ){
		aOptions->Delete( iCharge );
	}
}

void TStyleItem::AddStyleId( String& strText )
{
	char strNo[20] = "";

	if( pStyle ){
		if( pStyle->idLoc==0 ){
			if( pStyle->idStyle>0 ){
				sprintf( strNo, "[%d] ", pStyle->idStyle );
			}
			else{
				strNo[0] = '\0';
			}
		}
		else if( pStyle->idLoc==1 ){
			sprintf( strNo, "[S%d] ", pStyle->idStyle );
		}
		else if( pStyle->idLoc!=(UINT)-1 ){
			sprintf( strNo, "[L%d] ", LOWORD(pStyle->idStyle) );
		}
	}

	strText += strNo;
}

String TStyleItem::GetCaption()
{
	String strText;

	AddStyleId( strText );

	if( pStyle ){
		if( pStyle->idLoc==0 )
			strText += UTF8ToMBCS(pStyle->pOrigin->detail.strStyleName).c_str();
		else if( pStyle->idLoc==1 )
			strText += UTF8ToMBCS(pStyle->pShare->strStyleName).c_str();
		else if( pStyle->idLoc!=(UINT)-1 )
			strText += UTF8ToMBCS(pStyle->pLocal->strStyleName).c_str();
		else
			strText += "未知风格";
	}
	else{
		if( this==g_pPreStyle )
			strText += "新建自定义风格";
		else if( this==g_pUseStyle )
			strText += "无";
	}

	if( nBars>0 ){
		char strNum[20];
		sprintf( strNum, " (%d段 %d小节)", aItems->Count, nBars );
		strText += strNum;
	}

	return strText;
}

String TStyleItem::HintText()
{
	String HintStr;

	if( !pStyle ){
		HintStr = "新建自定义风格\n";
	}
	else if( pStyle->idLoc==0 ){
		TSTYLEORIGIN* pOrig = pStyle->pOrigin;
		HintStr = "发布风格\n\n";
		HintStr += "名称：";
		HintStr += UTF8ToMBCS(pOrig->detail.strStyleName).c_str();

		HintStr += "\n作者：";
		HintStr += UTF8ToMBCS(pOrig->detail.strAuthor).c_str();

		HintStr += "\n简介：";
		HintStr += UTF8ToMBCS(pOrig->detail.strDescription).c_str();

		HintStr += "\n类型：";
		String strType;
		for( int i=0; i<4; i++ ){
			int type = pOrig->detail.type[i];

			if( type<0 )
				break;
			else{
				if( type<24 ){
					strType += (String)LSZ_STYLTYPES[type] + " ";
				}
			}
		}
		if (strType == L"") {
			strType = L"未知类型";
		}
		HintStr += strType;

		char buf[20];
		HintStr += "\n原速：";
		sprintf( buf, "%d", pOrig->detail.iTempo );
		HintStr += buf;

		HintStr += "\n价格：";
		if( pOrig->cost==0 )
			strcpy( buf, "免费" );
		else
			sprintf(buf, "%d个唱作音符", pOrig->cost);
		HintStr += buf;

		int score10 =  (int)(pOrig->score/10.0 + 0.5);
		sprintf( buf, "%.1f", score10 / 10.0 );

		HintStr += "\n评分：";
		HintStr += buf;

		HintStr += "\n状态：";
		if( pOrig->state==e_UnDownload )
			HintStr += "未下载";
		else if( pOrig->state==e_Downloading )
			HintStr += "正在下载";
		else
			HintStr += "已下载";
	}
	else if( pStyle->idLoc==1 ){
		TSTYLESHARE* pShare = pStyle->pShare;
		HintStr = "分享风格\n\n";
		HintStr += "名称：";
		HintStr += UTF8ToMBCS(pShare->strStyleName).c_str();

		HintStr += "\n作者：";
		HintStr += UTF8ToMBCS(pShare->strAuthor).c_str();

		HintStr += "\n简介：";
		HintStr += UTF8ToMBCS(pShare->strDescription).c_str();

		HintStr += "\n类型：";
		String strType;
		for( int i=0; i<2; i++ ){
			int type = pShare->type[i];

			if( type<0 )
				break;
			else{
				if( type<24 ){
					strType += (String)LSZ_STYLTYPES[type] + " ";
				}
			}
		}
		if (strType == L"") {
			strType = L"未知类型";
		}
		HintStr += strType;

		char buf[20];
		HintStr += "\n原速：";
		sprintf( buf, "%d", pShare->iTempo );
		HintStr += buf;

		int score10 =  (int)(pShare->score/10.0 + 0.5);
		sprintf( buf, "%.1f", score10 / 10.0 );

		HintStr += "\n评分：";
		HintStr += buf;
	}
	else if( pStyle->pLocal ){
		TSTYLELOCAL* pLocal = pStyle->pLocal;
		HintStr = "本地风格\n\n";
		HintStr += "名称：";
		HintStr += UTF8ToMBCS(pLocal->strStyleName).c_str();

		char buf[20];
		HintStr += "\n原速：";
		sprintf( buf, "%d", pLocal->iTempo );
		HintStr += buf;
	}

	return HintStr;
}
/////////////////////////////////////////////////////////////////////////

String GetProgName( BYTE iBank, BYTE iChan, BYTE iProg )
{
	String strText;

	if( iBank!=0xFF && iBank>=0x80 ){
		VSTINFO* pVst = g_lstVSTi[iBank-0x80];

		bool bSet = false;
		for( int i=0; i<pVst->aPlugins.size(); i++ ){
			if( iChan==pVst->aPlugins[i]->id ){
				return pVst->aPlugins[i]->name;
			}
		}

		if( !bSet ){
			strText += "ch " + IntToStr( iChan+1 ) + ": ";
			strText += pVst->strVSTName;
		}
	}
	else{
		FONTINFO* pFI = NULL;
		if( iBank==0xFF ){
			if( g_bExtFont ){
				if(iChan==9)
					pFI = g_lstCZFonts[16];
				else
					pFI = g_lstCZFonts[iProg/16];
			}
			else
				pFI = g_lstFonts[g_idFont];
		}
		else
			pFI = g_lstFonts[iBank];

		int num = iChan==9 ? pFI->nDrumCount : pFI->nInstCount;
		FONTPRESET* pSet = ( iChan==9 ? pFI->aDrums : pFI->aInsts );
		char** strInst = NULL;

		if( iChan==9 ){
			for( int i=0; i<num; i++) {
				if( pSet[i].id==iProg ){
					return pSet[i].text;
				}
			}
		}
		else{
			if( iBank==0xFF || g_bExtFontUsable && iBank<16
							|| !strcmp( pFI->strFontName, g_strDefaultSoundSet )
							|| !strcmp( pFI->strFontName, "Pop default" ) )
				strInst = GM_INSTRUMENT;

			if( strInst )
				return strInst[iProg];
			else{
				for( int i=0; i<num; i++ ){
					if( pSet[i].id==iProg ){
						return pSet[i].text;
					}
				}
			}
		}
	}

	return strText;
}