Erstellen eines grundlegenden Media-Players

Aus RAD Studio
Wechseln zu: Navigation, Suche

Nach oben zu Tutorial: Audio-Video in FireMonkey

In diesem Tutorial wird gezeigt, wie ein grundlegender Media-Player mit TMediaPlayer und TMediaPlayerControl in FireMonkey erstellt wird. Der Media-Player enthält Standardfunktionen (Wiedergabe, Pause, Vorwärts und Zurück) und Funktionen zur Manipulation des gerade wiedergegebenen Mediums (Lautstärke und aktuelle Position). Mit diesem grundlegenden Media-Player können Sie eine Mediendateigruppe in ein Listenfeld (TListBox) laden und die Wiedergabe durch Doppelklicken auf ein Element in der Liste starten.

Formularentwurf

  1. Wählen Sie Datei > Neu > Geräteübergreifende Anwendung - Delphi > Leere Anwendung.
  2. Fügen Sie dem Formular eine TLayout-Komponente hinzu. Setzen Sie im Objektinspektor die Eigenschaft Align auf Left und die Eigenschaft Name auf MainLayout. Ändern Sie die Größe von MainLayout so, dass Videobilder angezeigt werden können.
  3. Fügen Sie MainLayout Folgendes hinzu:
    • Ein TLayout-Objekt. Geben Sie dem Objekt den Namen ControlPlayLayout, und richten Sie es am unteren Rand von MainLayout aus. Dieses Layout enthält alle Komponenten, die die Mediendatei steuern.
    • Ein TLayout-Objekt. Geben Sie dem Objekt den Namen TextLayout, und richten Sie es am oberen Rand von MainLayout aus. Dieses Layout enthält die Beschriftungen zum Anzeigen des Namens und der Länge des aktuell wiedergegebenen Mediums.
    • Ein TMediaPlayerControl-Objekt. Setzen Sie die Eigenschaft Align auf Client.
  4. Fügen Sie ControlPlayLayout Folgendes hinzu:
    • Fünf TButton-Objekte: Eins für jede Standardfunktion des Media-Players. Ändern Sie die Namen der Schaltflächen in PreviousButton, PlayButton, PauseButton, StopButton und NextButton.
    • Zwei TTrackBar-Objekte: Eins zum Steuern der Lautstärke und eins zum Steuern der aktuell wiedergegebenen Position. Ändern Sie die Namen der Schieberegler in VolumeTrackBar und PositionTrackBar. Richten Sie PositionTrackBar am oberen Rand von ControlPlayLayout aus.
    • Ein TCheckBox-Objekt. Nennen Sie dieses Objekt ShuffleCheckBox.
  5. Fügen Sie TextLayout zwei TLabel-Objekte hinzu: Eins zur Anzeige des Namens des aktuell wiedergegebenen Mediums und eins zur Anzeige der Gesamtlänge der aktuell wiedergegebenen Dateien in Minuten und Sekunden. Nennen Sie die beiden Beschriftungen NameLabel und DurationLabel. Legen Sie fest, dass DurationLabel rechts ausgerichtet wird, und setzen Sie die Eigenschaft AutoSize auf True. Setzen Sie die Eigenschaft Align von NameLabel auf Client, und legen Sie fest, dass der Text zentriert angezeigt wird, indem Sie die Eigenschaft TextSettings.HorzAlign auf Center setzen.
  6. Fügen Sie dem Formular ein weiteres TLayout-Objekt hinzu, setzen Sie dessen Eigenschaft Align auf Client, und benennen Sie es in PlayListLayout um.
  7. Fügen Sie PlayListLayout Folgendes hinzu:
    • Ein TLayout-Objekt zum Gruppieren der Schaltflächen, mit denen die Wiedergabeliste bearbeitet wird. Richten Sie das hinzugefügte Layout am unteren Rand des übergeordneten Objekts aus, und benennen Sie es in ControlPlayListLayout um.
    • Ein TListBox-Objekt. Geben Sie ihm den Namen PlayListBox, und setzen Sie dessen Eigenschaft Align auf Client.
  8. Fügen Sie PlayListLayout drei TButton-Objekte hinzu. Geben Sie den Schaltflächen die Namen LoadFileButton, ClearAllButton und ClearButton. Richten Sie alle drei Schaltflächen links von ihrem übergeordneten Objekt aus.
  9. Fügen Sie dem Formular folgende Objekte hinzu:
    Das Formular sollte wie folgt aussehen:
    Basic Media Player Form.png

Implementierung

Die Implementierung kann in mehrere Schritte unterteilt werden:

  1. Zuordnen von Standardaktionen zu Standardsteuerelementen
  2. Erstellen und Bearbeiten der Wiedergabeliste
  3. Implementieren der grundlegenden Funktionen eines Media-Players
  4. Implementieren hilfreicher Methoden und Klassen
  5. Anpassen der aktuell wiedergegebenen Mediendatei

Zuordnen von Standardaktionen zu Standardsteuerelementen

Doppelklicken Sie auf TActionList, und führen in dem daraufhin geöffneten Aktionslisten-Editor Folgendes aus:

  1. Wählen Sie Neu > Neue Standardaktion.
  2. Wählen Sie unter Medienbibliothek folgende Aktionen aus:
    • TMediaPlayerStop
    • TMediaPlayerCurrentTime
    • TMediaPlayerVolume
  3. Klicken Sie auf OK, um der Aktionslistenkomponente diese Aktionen hinzuzufügen.

Konfigurieren Sie jetzt diese Aktionen über die Eigenschaft Action der folgenden Steuerelemente:

  • StopButton
  • PositionTrackBar
  • VolumeTrackBar

Erstellen und Bearbeiten der Wiedergabeliste

1. Doppelklicken Sie auf LoadFileButton, um der Schaltfläche OnClick-Ereignisbehandlungsroutinen zum Füllen der PlayListBox zuzuordnen. Wird LoadFileButton gedrückt, wird das Dialogfeld "Datei-öffnen" angezeigt. Wählen Sie eine oder mehrere Dateien aus, die der Liste hinzugefügt werden sollen, wenn im Dialogfeld "Datei-öffnen" die Schaltfläche OK gedrückt wird.
Delphi:
procedure TForm1.LoadFileButtonClick(Sender: TObject);
var
  Files: TStrings;
  I: integer;
  MediaEntry: TMediaEntry;
begin
  // Sets the Filter so only the supported files to be displayed
  OpenDialog1.Filter := TMediaCodecManager.GetFilterString;
  if (OpenDialog1.Execute) then
  begin
    Files := OpenDialog1.Files;
    for I := 0 to Files.Count - 1 do
    begin
      MediaEntry := TMediaEntry.Create(Files[I]);
      PlayListBox.Items.AddObject(extractFileName(Files[I]), MediaEntry);
    end;
  end;
end;
C++Builder:
void __fastcall TForm1::LoadFileButtonClick(TObject *Sender) {
  int i;
  TMedia *Media;
  TStrings *Files = new TStringList();

  // Sets the Filter so only the supported files to be displayed
  OpenDialog1->Filter = TMediaCodecManager::GetFilterString();

  if (OpenDialog1->Execute()) {
    Files = OpenDialog1->Files;
    for (i = 0; i < Files->Count; i++) {
      Media = TMediaCodecManager::CreateFromFile(Files->operator[](i));
      PlayListBox->Items->AddObject
      (ExtractFileName((UnicodeString)Files->operator[](i)), Media);
    }
  }
}
2. Doppelklicken Sie auf die Schaltflächen ClearAllButton und ClearButton, um ihnen OnClick-Ereignisbehandlungsroutinen zuzuordnen.
ClearAllButton ClearButton
Delphi:
procedure TForm1.ClearAllButtonClick(Sender: TObject);
var
  I: integer;
begin
  if (PlayListBox.Count > 0) then
  begin
    for I := 0 to PlayListBox.Count - 1 do
      PlayListBox.Items.Objects[I].Free;
    PlayListBox.Clear;
    PlayListBox.ItemIndex := -1;
    SetLength(Played, 0);
    CurrentPlayedIndex := -1;
    MediaPlayer1.Clear;
    NameLabel.Text := '';
    DurationLabel.Text := '';
  end;
end;
C++Builder:
void __fastcall TForm1::ClearAllButtonClick(TObject *Sender) {
  int i;
  if (PlayListBox->Count > 0) {
    for (i = 0; i < PlayListBox->Count; i++) {
      PlayListBox->Items->Objects[i]->Free();
    }

    PlayListBox->Clear();
    PlayListBox->ItemIndex = -1;
    Played.resize(0);
    CurrentPlayedIndex = -1;
    MediaPlayer1->Clear();
    NameLabel->Text = "";
    DurationLabel->Text = "";
  }
}
Delphi:
procedure TForm1.ClearButtonClick(Sender: TObject);
var
  I, J: integer;
begin
  if PlayListBox.Count < 0 then
    Exit;
  PlayListBox.Items.Objects[PlayListBox.ItemIndex].Free;
  PlayListBox.Items.Delete(PlayListBox.ItemIndex);
  J := 0;
  // Makes sure that the deleted media is not on the Playlist
  while J < Length(Played) - 1 do
  begin
    if (Played[J] = PlayListBox.ItemIndex) then
    begin
      for I := J to Length(Played) - 1 do
        Played[I] := Played[I + 1];
      SetLength(Played, Length(Played) - 1);
    end;
    J := J + 1;
  end;
end;
C++Builder:
void __fastcall TForm1::ClearButtonClick(TObject *Sender) {
  unsigned int i, j;
  if (PlayListBox->Count < 0) {
    return;
  }

  PlayListBox->Items->Objects[PlayListBox->ItemIndex]->Free();
  PlayListBox->Items->Delete(PlayListBox->ItemIndex);
  j = 0;
  // Makes sure that the deleted media is not on the Playlist
  while (j < Played.size() - 1) {
    if (Played[j] == PlayListBox->ItemIndex) {
      for (i = j; i < Played.size(); i++) {
    Played[i] = Played[i + 1];
      }
      Played.resize(Played.size() - 1);
    }
    j += 1;
  }
}
3. Geben Sie alle der PlayListBox hinzugefügten Objekte frei, um zu vermeiden, dass nicht mehr verwendete Objekte im Speicher verbleiben. Beim Entfernen eines Elements aus der PlayListBox wird nur die Verknüpfung zwischen dem Listenfeldelement und dem zugeordneten Objekt freigegeben, und das Objekt verbleibt im Arbeitsspeicher.
Delphi:
procedure TForm1.FormDestroy(Sender: TObject);
var
  I: integer;
begin
  if (PlayListBox.Count > 0) then
    for I := 0 to PlayListBox.Count - 1 do
      PlayListBox.Items.Objects[I].Free;
end;
C++Builder:
void __fastcall TForm1::FormDestroy(TObject *Sender) {
  int i;
  if (PlayListBox->Count > 0) {
    for (i = 0; i < PlayListBox->Count; i++) {
      PlayListBox->Items->Objects[i]->Free();
    }
  }
}

Implementieren der grundlegenden Funktionen eines Media-Players

Drücken Sie PlayButton oder NextButton, oder doppelklicken Sie auf ein Element in der Wiedergabeliste, um den Player zu starten. Ordnen Sie der PlayListBox eine OnDblClick-Ereignisbehandlungsroutine zu. Doppelklicken Sie im ControlPlayLayout nacheinander auf alle Schaltflächen, um ihnen OnClick-Ereignisbehandlungsroutinen zuzuordnen und die grundlegenden Funktionen eines Media-Players zu implementieren.

PlayButton

PlayListBoxDblClick

Delphi:
procedure TForm1.PlayButtonClick(Sender: TObject);
begin
  if MediaPlayer1.Media <> nil then
  begin
    if (MediaPlayer1.State = TMediaState.Stopped) and
      (MediaPlayer1.CurrentTime < MediaPlayer1.Duration) then
    begin
      MediaPlayer1.Play;
      DisplayText(extractFileName(MediaPlayer1.FileName));
    end
    else
    begin
      MediaPlayer1.CurrentTime := 0;
    end;
  end
  else
  begin
    if (PlayListBox.Count = 0) then
      Exit;
    if (PlayListBox.ItemIndex = -1) then
      PlayListBox.ItemIndex := 0;
    FindAndPlay(PlayListBox.ItemIndex);
    if (ShuffleCheckBox.IsChecked) then
      AddToPlayedList(PlayListBox.ItemIndex);
  end;
end;
C++Builder:
void __fastcall TForm1::PlaybuttonClick(TObject *Sender) {
  if (MediaPlayer1->Media != NULL) {
    if ((MediaPlayer1->State == TMediaState::Stopped) &&
     (MediaPlayer1->CurrentTime < MediaPlayer1->Duration)) {
      MediaPlayer1->Play();
      DisplayText(ExtractFileName(MediaPlayer1->FileName));
    }
    else
      MediaPlayer1->CurrentTime = 0;
  }
  else {
    if (PlayListBox->Count == 0) {
      return;
    }
    if (PlayListBox->ItemIndex == -1) {
      PlayListBox->ItemIndex = 0;
    }
    FindAndPlay(PlayListBox->ItemIndex);
    if (ShuffleCheckBox->IsChecked) {
      AddToPlayedList(PlayListBox->ItemIndex);
    }
  }
}
Delphi:
procedure TForm1.PlayListBoxDblClick(Sender: TObject);
begin
  if (PlayListBox.Count < 0) then
    Exit;
  MediaPlayer1.Clear;
  MediaPlayer1.FileName:= TMediaEntry(
    PlayListBox.Items.Objects[PlayListBox.ItemIndex]).Path;
  if MediaPlayer1.Media <> nil then
  begin
    MediaPlayer1.Play;
    DisplayText(extractFileName(MediaPlayer1.FileName));
    AddToPlayedList(PlayListBox.Items.IndexOf
      (extractFileName(MediaPlayer1.FileName)));
  end;
end;
C++Builder:
void __fastcall TForm1::PlayListBoxDblClick(TObject *Sender) {
  if (PlayListBox->Count < 0) {
    return;
  }
  MediaPlayer1->Clear();
  MediaPlayer1->FileName = dynamic_cast<TMedia *>
      (PlayListBox->Items->Objects[PlayListBox->ItemIndex])->FileName;

  if (MediaPlayer1->Media != NULL) {
    MediaPlayer1->Play();
    DisplayText(ExtractFileName(MediaPlayer1->FileName));
    AddToPlayedList(PlayListBox->Items->IndexOf
        (ExtractFileName(MediaPlayer1->FileName)));
  }
}

PauseButton

NextButton

Delphi:
procedure TForm1.PauseButtonClick(Sender: TObject);
begin
  if MediaPlayer1.Media <> nil then
    MediaPlayer1.Stop;
end;
C++Builder:
void __fastcall TForm1::PauseButtonClick(TObject *Sender) {
  if (MediaPlayer1->Media != NULL) {
    MediaPlayer1->Stop();
  }
}
Delphi:
procedure TForm1.NextButtonClick(Sender: TObject);
begin
  if (PlayListBox.Count > 0) then
  begin
    PlayNext;
  end;
end;
C++Builder:
void __fastcall TForm1::NextButtonClick(TObject *Sender) {
  if (PlayListBox->Count > 0) {
    PlayNext();
  }
}

PreviousButton

Delphi:
procedure TForm1.PreviousButtonClick(Sender: TObject);
begin
  if ShuffleCheckBox.IsChecked then
  begin
    if (Length(Played) > 0) and (CurrentPlayedIndex > 0) then
    begin
      CurrentPlayedIndex := CurrentPlayedIndex - 1;
      FindAndPlay(Played[CurrentPlayedIndex]);
      PlayListBox.ItemIndex := Played[CurrentPlayedIndex];
    end;
  end
  else if (PlayListBox.ItemIndex > 0) then
  begin
    FindAndPlay(PlayListBox.ItemIndex - 1);
    PlayListBox.ItemIndex := PlayListBox.ItemIndex - 1;
  end;
end;
C++Builder:
void __fastcall TForm1::PreviousButtonClick(TObject *Sender) {
  if (ShuffleCheckBox->IsChecked) {
    if ((Played.size() > 0) && (CurrentPlayedIndex > 0)) {
      CurrentPlayedIndex = CurrentPlayedIndex - 1;
      FindAndPlay(Played[CurrentPlayedIndex]);
      PlayListBox->ItemIndex = Played[CurrentPlayedIndex];
    }
  }
  else
    if (PlayListBox->ItemIndex > 0) {
      FindAndPlay(PlayListBox->ItemIndex - 1);
      PlayListBox->ItemIndex = PlayListBox->ItemIndex - 1;
    }
}

Implementieren hilfreicher Methoden und Klassen

1. Fügen Sie der Klasse TForm1 die folgenden public-Member hinzu:
Delphi:
  public
    { Public declarations }
    Played: array of integer;
    CurrentPlayedIndex: integer;
    procedure AddToPlayedList(Index: integer);
    procedure DisplayText(str: string);
    procedure PlayNext();
    procedure FindAndPlay(Index: integer);
  end;

  TMediaEntry = class(TObject)
  public
    Path: String;
    constructor Create(FilePath: String);
  end;
C++Builder:
public:   // User declarations
  std::vector<int> Played;
  unsigned int CurrentPlayedIndex;
  void __fastcall AddToPlayedList(int index);
  void __fastcall DisplayText(String s);
  void __fastcall PlayNext();
  void __fastcall FindAndPlay(int index);
};

class TMediaEntry : public TObject
{
public:
  TMediaEntry(UnicodeString FilePath);
  UnicodeString Path;
};
2. Im Array Played werden die Indizes der aus der PlayListBox wiedergegebenen Mediendateien gespeichert, wenn der Media-Player im Modus Shuffle (ShuffleChekBox ist aktiviert) ausgeführt wird. Wiedergegebene Medien werden gespeichert, damit das nächste oder das vorhergehende wiedergegebene Medium abgerufen werden kann. CurrentPlayedIndex enthält den Index des aktuell aus Played wiedergegebenen Mediums. Mit der Methode AddToPlayedList wird der Played-Liste ein bestimmtes Medium hinzugefügt.
Delphi:
procedure TForm1.AddToPlayedList(Index: integer);
var
  Len: integer;
begin
  Len := Length(Played);
  SetLength(Played, Len + 1);
  Played[Len] := Index;
  CurrentPlayedIndex := Len;
  PlayListBox.ItemIndex := index;
end;
C++Builder:
void __fastcall TForm1::AddToPlayedList(int index) {
  int len;

  len = Played.size();
  Played.resize(len + 1);
  Played[len] = index;
  CurrentPlayedIndex = len;
  PlayListBox->ItemIndex = index;
}
3. Mit der Methode FindAndPlay wird anhand des Index in PlayListBox das Medium gesucht, das wiedergegeben werden soll, und mit der Methode PlayNext wird der Index des Mediums abgerufen, das wiedergegeben werden soll, und dann wird FindAndPlay zur Wiedergabe des Mediums mit dem berechneten Index aufgerufen.
FindAndPlay PlayNext
Delphi:
procedure TForm1.FindAndPlay(Index: integer);
begin
  MediaPlayer1.Clear;
  PositionTrackBar.Value := PositionTrackBar.Min;
  if Index >= PlayListBox.Items.Count then
    Index := 0;
  MediaPlayer1.FileName := TMediaEntry(PlayListBox.Items.Objects[Index]).Path;
  if MediaPlayer1.Media <> nil then
  begin
    MediaPlayer1.Play;
    DisplayText(extractFileName(MediaPlayer1.FileName));
  end;
end;
C++Builder:
void __fastcall TForm1::FindAndPlay(int index) {
  MediaPlayer1->Clear();
  PositionTrackBar->Value = PositionTrackBar->Min;
  MediaPlayer1->FileName = dynamic_cast<TMedia*>
          (PlayListBox->Items->Objects[index])->FileName;
  if (MediaPlayer1->Media != NULL) {
    MediaPlayer1->Play();
    DisplayText(ExtractFileName(MediaPlayer1->FileName));
  }
}
Delphi:
procedure TForm1.PlayNext();
var
  Index: integer;
begin
  if (ShuffleCheckBox.IsChecked) then
  begin
    if (CurrentPlayedIndex < Length(Played) - 1) then
    begin
      CurrentPlayedIndex := CurrentPlayedIndex + 1;
      FindAndPlay(Played[CurrentPlayedIndex]);
    end
    else
    begin
      Index := Random(PlayListBox.Count - 1);
      FindAndPlay(Index);
      AddToPlayedList(Index);
    end;
    PlayListBox.ItemIndex := Played[CurrentPlayedIndex];
  end
  else
  begin
    FindAndPlay(PlayListBox.ItemIndex + 1);
    PlayListBox.ItemIndex := PlayListBox.ItemIndex + 1;
  end;
end;
C++Builder:
void __fastcall TForm1::PlayNext() {
  unsigned int index;

  if (ShuffleCheckBox->IsChecked) {
    if (CurrentPlayedIndex < Played.size() - 1) {
      CurrentPlayedIndex = CurrentPlayedIndex + 1;
      FindAndPlay(Played[CurrentPlayedIndex]);
    }
    else {
      index = Random(PlayListBox->Count - 1);
      FindAndPlay(index);
      AddToPlayedList(index);
    }
    PlayListBox->ItemIndex = Played[CurrentPlayedIndex];
  }
  else {
    FindAndPlay(PlayListBox->ItemIndex + 1);
    PlayListBox->ItemIndex = PlayListBox->ItemIndex + 1;
  }
}
4. Die Methode DisplayText zeigt den Namen und die Länge (in Minuten und Sekunden) des aktuell wiedergegebenen Mediums an.
Delphi:
procedure TForm1.DisplayText(str: string);
var
  DurationMin, DurationSec: integer;
begin
  NameLabel.Text := str;
  DurationMin := MediaPlayer1.Duration div 10000 div 60000;
  DurationSec := MediaPlayer1.Duration div 10000 mod 60000 div 1000;
  DurationLabel.Text := IntToStr(DurationMin) + ':' + IntToStr(DurationSec);
end;
C++Builder:
void __fastcall TForm1::DisplayText(String s) {
  int DurationMin, DurationSec;
  NameLabel->Text = s;
  DurationMin = MediaPlayer1->Duration / 10000 / 60000;
  DurationSec = MediaPlayer1->Duration / 10000 % 60000 / 1000;
  DurationLabel->Text = IntToStr(DurationMin) + ':' + IntToStr(DurationSec);
}
5. TMediaEntry kapselt den absoluten Pfad einer Mediendatei aus der Wiedergabeliste, da TListBox das Speichern einer Instanz einer Unterklasse von TObject mit jedem Eintrag des Listenfelds ermöglicht. Definieren Sie den Konstruktor wie folgt:
Delphi:
constructor TMediaEntry.Create(FilePath: String);
begin
  Path := FilePath;
end;
C++Builder:
TMediaPlayer::TMediaPlayer(UnicodeString FilePath)
: Path(FilePath)
{
}

Anpassen der aktuell wiedergegebenen Mediendatei

1. Nächste Mediendatei abspielen

Damit der Media-Player das nächste Medium beim Ende des aktuell abgespielten Mediums wiedergibt, verwenden Sie TTimer mit einem bestimmten Intervall.

Doppelklicken Sie auf die TTimer-Komponente, um ihr OnTimer-Ereignisbehandlungsroutinen zuzuordnen.

Delphi:
procedure TForm1.Timer1Timer(Sender: TObject);
begin
  // When the current media ends the player starts playing
  // the next media in playlist
  if (MediaPlayer1.State = TMediaState.Playing) and
    (MediaPlayer1.CurrentTime = MediaPlayer1.Duration) then
    PlayNext;
end;
C++Builder:
void __fastcall TForm1::Timer1Timer(TObject *Sender) {
  PositionTrackBar->Tag = 1;
  PositionTrackBar->Value = MediaPlayer1->CurrentTime;
  PositionTrackBar->Tag = 0;
  // When the current media ends the player starts playing
  // the next media in playlist
  if ((MediaPlayer1->State == TMediaState::Playing) &&
        (MediaPlayer1->CurrentTime == MediaPlayer1->Duration)) {
    PlayNext();
  }
}
2. Zufallswiedergabe an/aus

Wenn ShuffleCheckBox nicht aktiviert ist, dann wird jeweils das nächste Medium in der PlayListBox wiedergegeben. Wenn dieses Kontrollkästchen aktiviert ist, dann wird das nächste wiederzugebende Medium zufällig aus der PlayListBox ermittelt. Wenn sich der Media-Player nicht im Zufallswiedergabemodus befindet, wird der Played-Vektor nicht benötigt, weil die Reihenfolge der in PlayListBox entspricht.

Delphi:
procedure TForm1.ShuffleCheckBoxChange(Sender: TObject);
begin
  If (not ShuffleCheckBox.IsChecked) then
  begin
    SetLength(Played, 0);
    CurrentPlayedIndex := -1;
  end;
end;
C++Builder:
void __fastcall TForm1::ShuffleCheckBoxChange(TObject *Sender) {
  if (!ShuffleCheckBox->IsChecked) {
    Played.resize(0);
    CurrentPlayedIndex = -1;
  }
}

Ausführen der Anwendung

1. Drücken Sie F9, um das Projekt auszuführen.
2. Laden Sie Dateien in die PlayListBox, indem Sie die Schaltfläche LoadFileButton drücken.
3. Starten Sie die Wiedergabe eines Mediums durch Drücken von PlayButton oder NextButton oder durch Doppelklicken auf ein Element in der PlayListBox.

Zurück

Siehe auch