756 lines
27 KiB
C#
756 lines
27 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Text;
|
|
using System.Windows.Forms;
|
|
|
|
using Vocaluxe.Base;
|
|
using Vocaluxe.Lib.Draw;
|
|
using Vocaluxe.Lib.Song;
|
|
|
|
namespace Vocaluxe.Menu.SongMenu
|
|
{
|
|
class CSongMenuTileBoard : CSongMenuFramework
|
|
{
|
|
private SRectF _ScrollRect;
|
|
private List<CStatic> _Tiles;
|
|
private CStatic _CoverBig;
|
|
private CStatic _TextBG;
|
|
private CStatic _DuetIcon;
|
|
private CStatic _VideoIcon;
|
|
private CStatic _MedleyCalcIcon;
|
|
private CStatic _MedleyTagIcon;
|
|
|
|
private STexture _CoverBigTexture;
|
|
private STexture _CoverTexture;
|
|
|
|
private CText _Artist;
|
|
private CText _Title;
|
|
private CText _SongLength;
|
|
|
|
private int _NumW;
|
|
private int _NumH;
|
|
|
|
private float _SpaceW;
|
|
private float _SpaceH;
|
|
|
|
private int _TileW;
|
|
private int _TileH;
|
|
|
|
private int _Offset = 0;
|
|
private int _actualSelection = -1;
|
|
|
|
private bool _SmallView = false;
|
|
|
|
public override int GetActualSelection()
|
|
{
|
|
return _actualSelection;
|
|
}
|
|
|
|
public override void Init()
|
|
{
|
|
base.Init();
|
|
|
|
_Rect = _Theme.songMenuTileBoard.TileRect;
|
|
|
|
_NumW = _Theme.songMenuTileBoard.numW;
|
|
_NumH = _Theme.songMenuTileBoard.numH;
|
|
_SpaceW = _Theme.songMenuTileBoard.spaceW;
|
|
_SpaceH = _Theme.songMenuTileBoard.spaceH;
|
|
|
|
_PendingTime = 100L;
|
|
|
|
_TileW = (int)((_Theme.songMenuTileBoard.TileRect.W - _SpaceW * (_NumW - 1)) / _NumW);
|
|
_TileH = (int)((_Theme.songMenuTileBoard.TileRect.H - _SpaceH * (_NumH - 1)) / _NumH);
|
|
|
|
_CoverTexture = CTheme.GetSkinTexture(_Theme.CoverBackgroundName);
|
|
_CoverBigTexture = CTheme.GetSkinTexture(_Theme.CoverBigBackgroundName);
|
|
|
|
_Tiles = new List<CStatic>();
|
|
for (int i = 0; i < _NumH; i++)
|
|
{
|
|
for (int j = 0; j < _NumW; j++)
|
|
{
|
|
SRectF rect = new SRectF(_Theme.songMenuTileBoard.TileRect.X + j * (_TileW + _SpaceW),
|
|
_Theme.songMenuTileBoard.TileRect.Y + i * (_TileH + _SpaceH), _TileW, _TileH, _Rect.Z);
|
|
CStatic tile = new CStatic(_CoverTexture, Color, rect);
|
|
_Tiles.Add(tile);
|
|
}
|
|
}
|
|
|
|
_ScrollRect = new SRectF(0, 0, CSettings.iRenderW, CSettings.iRenderH, _Theme.songMenuTileBoard.TileRect.Z);
|
|
|
|
_PreviewSelected = -1;
|
|
_Offset = 0;
|
|
|
|
_CoverBig = _Theme.songMenuTileBoard.StaticCoverBig;
|
|
_TextBG = _Theme.songMenuTileBoard.StaticTextBG;
|
|
_DuetIcon = _Theme.songMenuTileBoard.StaticDuetIcon;
|
|
_VideoIcon = _Theme.songMenuTileBoard.StaticVideoIcon;
|
|
_MedleyCalcIcon = _Theme.songMenuTileBoard.StaticMedleyCalcIcon;
|
|
_MedleyTagIcon = _Theme.songMenuTileBoard.StaticMedleyTagIcon;
|
|
|
|
_Artist = _Theme.songMenuTileBoard.TextArtist;
|
|
_Title = _Theme.songMenuTileBoard.TextTitle;
|
|
_SongLength = _Theme.songMenuTileBoard.TextSongLength;
|
|
}
|
|
|
|
public override void OnShow()
|
|
{
|
|
if (CSongs.Tabs == EOffOn.TR_CONFIG_OFF && CSongs.NumCategories > 0 && CSongs.Category == -1)
|
|
{
|
|
EnterCategory(0);
|
|
}
|
|
_actualSelection = -1;
|
|
_Locked = -1;
|
|
_PreviewSelected = -1;
|
|
UpdateList(0);
|
|
//AfterCategoryChange();
|
|
SetSelectedSong(_ActSong);
|
|
AfterCategoryChange();
|
|
CSongs.UpdateRandomSongList();
|
|
|
|
int actcat = _PreviewSelected;
|
|
if ((CSongs.NumCategories > 0) && (actcat < 0))
|
|
{
|
|
_CoverBig.Texture = CSongs.Categories[0].CoverTextureSmall;
|
|
_Artist.Text = CSongs.Categories[0].Name;
|
|
_Title.Text = String.Empty;
|
|
_SongLength.Text = String.Empty;
|
|
_PreviewSelected = 0;
|
|
_Locked = 0;
|
|
_DuetIcon.Visible = false;
|
|
_VideoIcon.Visible = false;
|
|
_MedleyCalcIcon.Visible = false;
|
|
_MedleyTagIcon.Visible = false;
|
|
}
|
|
|
|
if (CSongs.NumVisibleSongs == 0 && CSongs.SearchFilter != String.Empty)
|
|
{
|
|
_CoverBig.Texture = _CoverBigTexture;
|
|
_Artist.Text = String.Empty;
|
|
_Title.Text = String.Empty;
|
|
_SongLength.Text = String.Empty;
|
|
_PreviewSelected = -1;
|
|
_Locked = -1;
|
|
_DuetIcon.Visible = false;
|
|
_VideoIcon.Visible = false;
|
|
_MedleyCalcIcon.Visible = false;
|
|
_MedleyTagIcon.Visible = false;
|
|
}
|
|
}
|
|
|
|
public override void HandleInput(ref KeyEvent KeyEvent)
|
|
{
|
|
base.HandleInput(ref KeyEvent);
|
|
|
|
if (KeyEvent.KeyPressed)
|
|
{
|
|
//
|
|
}
|
|
else
|
|
{
|
|
if (!(KeyEvent.Key == Keys.Left || KeyEvent.Key == Keys.Right || KeyEvent.Key == Keys.Up || KeyEvent.Key == Keys.Down ||
|
|
KeyEvent.Key == Keys.Escape || KeyEvent.Key == Keys.Back || KeyEvent.Key == Keys.Enter ||
|
|
KeyEvent.Key == Keys.PageDown || KeyEvent.Key == Keys.PageUp))
|
|
return;
|
|
|
|
bool sel = false;
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
if (tile.Selected)
|
|
{
|
|
sel = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ((_Locked == -1 || !sel) &&
|
|
KeyEvent.Key != Keys.Escape && KeyEvent.Key != Keys.Back && KeyEvent.Key != Keys.PageUp && KeyEvent.Key != Keys.PageDown)
|
|
{
|
|
if (_PreviewSelected > -1)
|
|
{
|
|
_Locked = _PreviewSelected;
|
|
}
|
|
else
|
|
{
|
|
_Locked = 0;
|
|
_actualSelection = 0;
|
|
_PreviewSelected = 0;
|
|
SetSelectedNow();
|
|
UpdateList(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (KeyEvent.Key)
|
|
{
|
|
case Keys.Enter:
|
|
if (CSongs.Category < 0)
|
|
{
|
|
EnterCategory(_PreviewSelected);
|
|
KeyEvent.Handled = true;
|
|
}
|
|
else if (_actualSelection > -1 && _PreviewSelected >= 0)
|
|
{
|
|
_Locked = _actualSelection;
|
|
}
|
|
break;
|
|
|
|
case Keys.Escape:
|
|
case Keys.Back:
|
|
if (CSongs.Category > -1 && CSongs.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
ShowCategories();
|
|
KeyEvent.Handled = true;
|
|
}
|
|
//else if (CSongs.Tabs == EOffOn.TR_CONFIG_OFF)
|
|
//{
|
|
// CGraphics.FadeTo(EScreens.ScreenMain);
|
|
//}
|
|
break;
|
|
|
|
case Keys.PageUp:
|
|
if (CSongs.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
PrevCategory();
|
|
}
|
|
break;
|
|
|
|
case Keys.PageDown:
|
|
if (CSongs.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
NextCategory();
|
|
}
|
|
break;
|
|
|
|
case Keys.Left:
|
|
if (_Locked > 0)
|
|
{
|
|
_Locked--;
|
|
if (CSongs.Category < 0 && _Locked < CSongs.NumCategories - _NumW ||
|
|
CSongs.Category >= 0 && _Locked < CSongs.NumVisibleSongs - _NumW)
|
|
UpdateList((_Locked / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
}
|
|
break;
|
|
|
|
case Keys.Right:
|
|
if (CSongs.Category < 0)
|
|
{
|
|
if (_Locked < CSongs.NumCategories - 1)
|
|
{
|
|
_Locked++;
|
|
if (_Locked < CSongs.NumCategories - _NumW)
|
|
UpdateList((_Locked / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (_Locked < CSongs.NumVisibleSongs - 1)
|
|
{
|
|
_Locked++;
|
|
if (_Locked < CSongs.NumVisibleSongs - _NumW)
|
|
UpdateList((_Locked / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
}
|
|
}
|
|
break;
|
|
|
|
case Keys.Up:
|
|
if (KeyEvent.ModSHIFT && CSongs.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
PrevCategory();
|
|
break;
|
|
}
|
|
|
|
if (_Locked > _NumW - 1)
|
|
{
|
|
_Locked -= _NumW;
|
|
UpdateList((_Locked / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
}
|
|
break;
|
|
|
|
case Keys.Down:
|
|
if (KeyEvent.ModSHIFT && CSongs.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
NextCategory();
|
|
break;
|
|
}
|
|
|
|
if (CSongs.Category < 0)
|
|
{
|
|
if (_Locked < CSongs.NumCategories - _NumW)
|
|
{
|
|
_Locked += _NumW;
|
|
if (_Locked < CSongs.NumCategories - _NumW)
|
|
UpdateList((_Locked / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (_Locked < CSongs.NumVisibleSongs - _NumW)
|
|
{
|
|
_Locked += _NumW;
|
|
if (_Locked < CSongs.NumVisibleSongs - _NumW)
|
|
UpdateList((_Locked / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
if (!KeyEvent.Handled)
|
|
{
|
|
_PreviewSelected = _Locked;
|
|
_actualSelection = _Locked;
|
|
|
|
for (int i = 0; i < _Tiles.Count; i++)
|
|
{
|
|
_Tiles[i].Selected = _Locked == i + _Offset;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void HandleMouse(ref MouseEvent MouseEvent)
|
|
{
|
|
base.HandleMouse(ref MouseEvent);
|
|
|
|
int i = 0;
|
|
bool sel = false;
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
if ((tile.Texture.index != _CoverTexture.index) && CHelper.IsInBounds(tile.Rect, MouseEvent) && !sel)
|
|
{
|
|
if (MouseEvent.LB || CSongs.Category == -1)
|
|
{
|
|
if (_PreviewSelected == i + _Offset)
|
|
_Locked = _PreviewSelected;
|
|
else
|
|
{
|
|
_PreviewSelected = i + _Offset;
|
|
_Locked = -1;
|
|
}
|
|
}
|
|
tile.Selected = true;
|
|
_actualSelection = i + _Offset;
|
|
sel = true;
|
|
}
|
|
else
|
|
{
|
|
tile.Selected = false;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (!sel)
|
|
_actualSelection = -1;
|
|
|
|
if ((MouseEvent.RB) && (CSongs.NumCategories > 0) && CSongs.Category >= 0 && CSongs.Tabs == EOffOn.TR_CONFIG_ON)
|
|
{
|
|
ShowCategories();
|
|
return;
|
|
}
|
|
else if (MouseEvent.RB && CSongs.Tabs == EOffOn.TR_CONFIG_OFF)
|
|
{
|
|
CGraphics.FadeTo(EScreens.ScreenMain);
|
|
}
|
|
else if (_PreviewSelected != -1 && MouseEvent.LB && CSongs.Category != -1)
|
|
{
|
|
if (CHelper.IsInBounds(_CoverBig.Rect, MouseEvent) || CHelper.IsInBounds(_TextBG.Rect, MouseEvent))
|
|
{
|
|
_Locked = _PreviewSelected;
|
|
}
|
|
}
|
|
else if ((MouseEvent.LB) && (CSongs.Category == -1))
|
|
{
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
if ((tile.Texture.index != _CoverTexture.index) && CHelper.IsInBounds(tile.Rect, MouseEvent))
|
|
{
|
|
EnterCategory(_PreviewSelected);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (MouseEvent.Wheel > 0)
|
|
{
|
|
if (CHelper.IsInBounds(_ScrollRect, MouseEvent))
|
|
{
|
|
if (CSongs.Category >= 0 && CSongs.NumVisibleSongs > _Offset + _NumW * MouseEvent.Wheel + _NumW * (_NumH - 1) ||
|
|
CSongs.Category < 0 && CSongs.NumCategories > _Offset + _NumW * MouseEvent.Wheel + _NumW * (_NumH - 1))
|
|
{
|
|
_Offset += _NumW * MouseEvent.Wheel;
|
|
UpdateList(_Offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (MouseEvent.Wheel < 0)
|
|
{
|
|
if (CHelper.IsInBounds(_ScrollRect, MouseEvent))
|
|
{
|
|
_Offset += _NumW * MouseEvent.Wheel;
|
|
if (_Offset < 0)
|
|
{
|
|
_Offset = 0;
|
|
}
|
|
UpdateList(_Offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Draw()
|
|
{
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
if (tile.Selected && _Active)
|
|
tile.Draw(1.2f, tile.Rect.Z - 0.1f, true, false);
|
|
else
|
|
{
|
|
if (tile.Texture.index != _CoverTexture.index)
|
|
tile.Draw(1f, tile.Rect.Z, true, false);
|
|
else
|
|
tile.Draw(1f, tile.Rect.Z, false, false);
|
|
}
|
|
}
|
|
|
|
if (CSongs.Category >= 0)
|
|
{
|
|
int actsong = _PreviewSelected;
|
|
if ((CSongs.NumVisibleSongs > actsong) && (actsong >= 0))
|
|
{
|
|
CSong song = CSongs.VisibleSongs[actsong];
|
|
|
|
_CoverBig.Texture = song.CoverTextureSmall;
|
|
_Artist.Text = song.Artist;
|
|
_Title.Text = song.Title;
|
|
_DuetIcon.Visible = song.IsDuet;
|
|
_VideoIcon.Visible = song.VideoFileName.Length > 0;
|
|
_MedleyCalcIcon.Visible = song.Medley.Source == EMedleySource.Calculated;
|
|
_MedleyTagIcon.Visible = song.Medley.Source == EMedleySource.Tag;
|
|
|
|
float Time = CSound.GetLength(_SongStream);
|
|
if (song.Finish != 0)
|
|
Time = song.Finish;
|
|
|
|
Time -= song.Start;
|
|
int min = (int)Math.Floor(Time / 60f);
|
|
int sec = (int)(Time - min * 60f);
|
|
_SongLength.Text = min.ToString("00") + ":" + sec.ToString("00");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int actcat = _PreviewSelected;
|
|
if ((CSongs.NumCategories > actcat) && (actcat >= 0))
|
|
{
|
|
_CoverBig.Texture = CSongs.Categories[actcat].CoverTextureSmall;
|
|
_Artist.Text = CSongs.Categories[actcat].Name;
|
|
|
|
int num = CSongs.NumSongsInCategory(actcat);
|
|
if (num != 1)
|
|
_Title.Text = CLanguage.Translate("TR_SCREENSONG_NUMSONGS").Replace("%v", num.ToString());
|
|
else
|
|
_Title.Text = CLanguage.Translate("TR_SCREENSONG_NUMSONG").Replace("%v", num.ToString());
|
|
|
|
_SongLength.Text = String.Empty;
|
|
_DuetIcon.Visible = false;
|
|
_VideoIcon.Visible = false;
|
|
_MedleyCalcIcon.Visible = false;
|
|
_MedleyTagIcon.Visible = false;
|
|
}
|
|
}
|
|
|
|
if (_vidtex.color.A < 1)
|
|
_CoverBig.Draw(1f, true);
|
|
_TextBG.Draw();
|
|
|
|
if (_vidtex.index != -1 && _Video != -1)
|
|
{
|
|
RectangleF bounds = new RectangleF(_CoverBig.Rect.X, _CoverBig.Rect.Y, _CoverBig.Rect.W, _CoverBig.Rect.H);
|
|
RectangleF rect = new RectangleF(0f, 0f, _vidtex.width, _vidtex.height);
|
|
CHelper.SetRect(bounds, ref rect, rect.Width / rect.Height, EAspect.Crop);
|
|
|
|
CDraw.DrawTexture(_vidtex, new SRectF(rect.X, rect.Y, rect.Width, rect.Height, _CoverBig.Rect.Z),
|
|
_vidtex.color, new SRectF(bounds.X, bounds.Y, bounds.Width, bounds.Height, 0f), false);
|
|
CDraw.DrawTextureReflection(_vidtex, new SRectF(rect.X, rect.Y, rect.Width, rect.Height, _CoverBig.Rect.Z),
|
|
_vidtex.color, new SRectF(bounds.X, bounds.Y, bounds.Width, bounds.Height, 0f), _CoverBig.ReflectionSpace, _CoverBig.ReflectionHeight);
|
|
}
|
|
|
|
|
|
|
|
_Artist.Draw();
|
|
_Title.Draw();
|
|
_SongLength.Draw();
|
|
_DuetIcon.Draw();
|
|
_VideoIcon.Draw();
|
|
_MedleyCalcIcon.Draw();
|
|
_MedleyTagIcon.Draw();
|
|
|
|
}
|
|
|
|
public override int GetSelectedSong()
|
|
{
|
|
return _Locked;
|
|
}
|
|
|
|
public override void SetSelectedSong(int VisibleSongNr)
|
|
{
|
|
base.SetSelectedSong(VisibleSongNr);
|
|
|
|
if (VisibleSongNr < 0)
|
|
return;
|
|
|
|
if (CSongs.NumVisibleSongs > VisibleSongNr)
|
|
{
|
|
bool sel = false;
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
if (tile.Selected)
|
|
{
|
|
sel = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (_Locked == -1 || !sel)
|
|
{
|
|
if (_PreviewSelected > -1)
|
|
{
|
|
_Locked = _PreviewSelected;
|
|
}
|
|
else
|
|
{
|
|
_Locked = 0;
|
|
_actualSelection = 0;
|
|
_PreviewSelected = 0;
|
|
SetSelectedNow();
|
|
UpdateList(0);
|
|
}
|
|
}
|
|
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
tile.Selected = false;
|
|
}
|
|
|
|
_PreviewSelected = VisibleSongNr;
|
|
SetSelectedNow();
|
|
_Locked = VisibleSongNr;
|
|
|
|
UpdateList((VisibleSongNr / _NumW) * _NumW - (_NumW * (_NumH - 2)));
|
|
|
|
_PreviewSelected = _Locked;
|
|
_actualSelection = _Locked;
|
|
|
|
for (int i = 0; i < _Tiles.Count; i++)
|
|
{
|
|
_Tiles[i].Selected = _Locked == i + _Offset;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
protected override void EnterCategory(int cat)
|
|
{
|
|
base.EnterCategory(cat);
|
|
|
|
_PreviewSelected = 0;
|
|
_Locked = -1;
|
|
_actualSelection = 0;
|
|
AfterCategoryChange();
|
|
}
|
|
|
|
protected override void ShowCategories()
|
|
{
|
|
base.ShowCategories();
|
|
|
|
_PreviewSelected = 0;
|
|
_Locked = -1;
|
|
_actualSelection = 0;
|
|
AfterCategoryChange();
|
|
}
|
|
|
|
private void NextCategory()
|
|
{
|
|
if (CSongs.Category > -1)
|
|
{
|
|
Reset();
|
|
CSongs.NextCategory();
|
|
EnterCategory(CSongs.Category);
|
|
_Locked = 0;
|
|
}
|
|
}
|
|
|
|
private void PrevCategory()
|
|
{
|
|
if (CSongs.Category > -1)
|
|
{
|
|
Reset();
|
|
CSongs.PrevCategory();
|
|
EnterCategory(CSongs.Category);
|
|
_Locked = 0;
|
|
}
|
|
}
|
|
|
|
private void AfterCategoryChange()
|
|
{
|
|
SetSelectedNow();
|
|
SelectSong(_PreviewSelected);
|
|
|
|
foreach (CStatic tile in _Tiles)
|
|
{
|
|
tile.Selected = false;
|
|
}
|
|
|
|
if (_actualSelection >= 0 && _actualSelection < _Tiles.Count)
|
|
_Tiles[_actualSelection].Selected = true;
|
|
|
|
if ((_LastKnownNumSongs == CSongs.NumVisibleSongs) && (_LastKnownCategory == CSongs.Category))
|
|
return;
|
|
|
|
_LastKnownCategory = CSongs.Category;
|
|
_LastKnownNumSongs = CSongs.NumVisibleSongs;
|
|
UpdateList(0);
|
|
CSongs.UpdateRandomSongList();
|
|
}
|
|
|
|
private void UpdateList(int offset)
|
|
{
|
|
if (CSongs.Category > -1)
|
|
{
|
|
if (offset >= (CSongs.NumVisibleSongs / _NumW) * _NumW - (_NumW * (_NumH - 1)))
|
|
offset = (CSongs.NumVisibleSongs / _NumW) * _NumW - (_NumW * (_NumH - 1));
|
|
}
|
|
else
|
|
{
|
|
if (offset >= (CSongs.NumCategories / _NumW) * _NumW - (_NumW * (_NumH - 1)))
|
|
offset = (CSongs.NumCategories / _NumW) * _NumW - (_NumW * (_NumH - 1));
|
|
}
|
|
|
|
if (offset < 0)
|
|
offset = 0;
|
|
|
|
for (int i = 0; i < _Tiles.Count; i++)
|
|
{
|
|
if (CSongs.Category >= 0)
|
|
{
|
|
if (CSongs.NumVisibleSongs > i + offset)
|
|
{
|
|
_Tiles[i].Texture = CSongs.VisibleSongs[i + offset].CoverTextureSmall;
|
|
_Tiles[i].Color = new SColorF(1f, 1f, 1f, 1f);
|
|
}
|
|
else
|
|
{
|
|
_Tiles[i].Texture = _CoverTexture;
|
|
_Tiles[i].Color = _Color;
|
|
}
|
|
}
|
|
|
|
if (CSongs.Category == -1)
|
|
{
|
|
if (CSongs.NumCategories > i + offset)
|
|
{
|
|
_Tiles[i].Texture = CSongs.Categories[i + offset].CoverTextureSmall;
|
|
_Tiles[i].Color = new SColorF(1f, 1f, 1f, 1f);
|
|
}
|
|
else
|
|
{
|
|
_Tiles[i].Texture = _CoverTexture;
|
|
_Tiles[i].Color = _Color;
|
|
}
|
|
}
|
|
}
|
|
_Offset = offset;
|
|
}
|
|
|
|
public override void SetSmallView(bool SmallView)
|
|
{
|
|
base.SetSmallView(SmallView);
|
|
|
|
_SmallView = SmallView;
|
|
|
|
if (_SmallView)
|
|
{
|
|
_NumH = _Theme.songMenuTileBoard.numHsmall;
|
|
_NumW = _Theme.songMenuTileBoard.numWsmall;
|
|
|
|
_TileW = (int)((_Theme.songMenuTileBoard.TileRectSmall.W - _SpaceW * (_NumW - 1)) / _NumW);
|
|
_TileH = (int)((_Theme.songMenuTileBoard.TileRectSmall.H - _SpaceH * (_NumH - 1)) / _NumH);
|
|
|
|
_CoverTexture = CTheme.GetSkinTexture(_Theme.CoverBackgroundName);
|
|
_CoverBigTexture = CTheme.GetSkinTexture(_Theme.CoverBigBackgroundName);
|
|
|
|
_Tiles = new List<CStatic>();
|
|
for (int i = 0; i < _NumH; i++)
|
|
{
|
|
for (int j = 0; j < _NumW; j++)
|
|
{
|
|
SRectF rect = new SRectF(_Theme.songMenuTileBoard.TileRectSmall.X + j * (_TileW + _SpaceW),
|
|
_Theme.songMenuTileBoard.TileRectSmall.Y + i * (_TileH + _SpaceH), _TileW, _TileH, _Rect.Z);
|
|
CStatic tile = new CStatic(_CoverTexture, Color, rect);
|
|
_Tiles.Add(tile);
|
|
}
|
|
}
|
|
|
|
_Rect = _Theme.songMenuTileBoard.TileRectSmall;
|
|
_ScrollRect = new SRectF(0, 0, CSettings.iRenderW, CSettings.iRenderH, _Theme.songMenuTileBoard.TileRectSmall.Z);
|
|
}
|
|
else
|
|
{
|
|
_NumH = _Theme.songMenuTileBoard.numH;
|
|
_NumW = _Theme.songMenuTileBoard.numW;
|
|
|
|
_TileW = (int)((_Theme.songMenuTileBoard.TileRect.W - _SpaceW * (_NumW - 1)) / _NumW);
|
|
_TileH = (int)((_Theme.songMenuTileBoard.TileRect.H - _SpaceH * (_NumH - 1)) / _NumH);
|
|
|
|
_CoverTexture = CTheme.GetSkinTexture(_Theme.CoverBackgroundName);
|
|
_CoverBigTexture = CTheme.GetSkinTexture(_Theme.CoverBigBackgroundName);
|
|
|
|
_Tiles = new List<CStatic>();
|
|
for (int i = 0; i < _NumH; i++)
|
|
{
|
|
for (int j = 0; j < _NumW; j++)
|
|
{
|
|
SRectF rect = new SRectF(_Theme.songMenuTileBoard.TileRect.X + j * (_TileW + _SpaceW),
|
|
_Theme.songMenuTileBoard.TileRect.Y + i * (_TileH + _SpaceH), _TileW, _TileH, _Rect.Z);
|
|
CStatic tile = new CStatic(_CoverTexture, Color, rect);
|
|
_Tiles.Add(tile);
|
|
}
|
|
}
|
|
|
|
_Rect = _Theme.songMenuTileBoard.TileRect;
|
|
_ScrollRect = new SRectF(0, 0, CSettings.iRenderW, CSettings.iRenderH, _Theme.songMenuTileBoard.TileRect.Z);
|
|
}
|
|
|
|
UpdateList(_Offset);
|
|
|
|
}
|
|
|
|
public override bool IsSmallView()
|
|
{
|
|
return _SmallView;
|
|
}
|
|
|
|
public override void LoadTextures()
|
|
{
|
|
base.LoadTextures();
|
|
|
|
_Theme.songMenuTileBoard.StaticCoverBig.ReloadTextures();
|
|
_Theme.songMenuTileBoard.StaticTextBG.ReloadTextures();
|
|
_Theme.songMenuTileBoard.StaticDuetIcon.ReloadTextures();
|
|
_Theme.songMenuTileBoard.StaticVideoIcon.ReloadTextures();
|
|
_Theme.songMenuTileBoard.StaticMedleyCalcIcon.ReloadTextures();
|
|
_Theme.songMenuTileBoard.StaticMedleyTagIcon.ReloadTextures();
|
|
|
|
_Theme.songMenuTileBoard.TextArtist.ReloadTextures();
|
|
_Theme.songMenuTileBoard.TextTitle.ReloadTextures();
|
|
_Theme.songMenuTileBoard.TextSongLength.ReloadTextures();
|
|
}
|
|
}
|
|
}
|