Scripting-Hilfe: Nützliche Funktionen und Prozeduren

So nahe sich die mAirList-Skriptsprache an Delphi bzw. Turbo-Pascal orientiert, so ist man doch aufgeschmissen, wenn es um bestimmte mAirList-spezifische Operationen geht. Zwar gibt es diese sog. Hilfedatei, aber ohne Informatikstudium kommt man damit auch nicht wesentlich weiter, weil sich daraus die Struktur nur dem bereits Kundigen so recht erschließt. Als Nachschlagewerk, ob eine Anweisung überhaupt vorkommt, ist sie jedoch recht brauchbar.

Nachstehende Codebeispiele habe ich im Laufe der Zeit selber herausgefunden, und zwar überwiegend durch Recherche (!) in diesem Forum, daneben auch viel ausprobiert, und hin und wieder auch mal gefragt. Ist also kein Hexenwerk, jedoch zeitaufwendig. Weil die Leute jedoch heutzutage immer in Eile sind, habe ich die Funktionen bzw. Prozeduren im folgenden niedergeschrieben. Das meiste habe ich selber ausprobiert, ein paar Sachen noch dazuextrapoliert.

Achtung: Diese (unvollständige) Liste gilt für die jeweils neueste mAirList-Version. Ältere Versionen unterstützen nicht alle Funktionen/Prozeduren.

Bitte unbedingt auf die korrekte Deklaration der Variablen achten (unter var)! Insbesondere müssen die Werte der string-Variablen in 'einfache Anführungszeichen' gesetzt werden!



// Hier einige hilfreiche Tips und Tricks beim Programmieren von Skripten.
// Below some useful procedures and functions for Scripting are listed.


var
  State: boolean:
  Number: integer;
  Port: word;
  Name, Parameter: string;
  String1: AnsiString;
  Duration, Position: TTimeValue;
  Time, Date: TDateTime;
  Item: IPlaylistItem;
  StringList: TStringList;

  // Werte für Strings sind in einfache Anführungszeichen zu setzen:
  // String values are to be enclosed in apostrophes:
  //
  // Name := 'This is a string';

begin



// === Aktionen mit Playlistelementen/Operations on Playlist Items ===


// Pfad eines Elements herausfinden:
// Retrieve path of item:

  Name := IFilePlaylistItem(Item).GetFilename;


// ID eines Elements in der mAirListDB herausfinden:
// Retrieve mAirListDB-ID of an item:

  Name := Item.GetDatabaseID;


// Oberstes (= aktuelles) Element in der aktuellen Playlist herausfinden:
// Retrieve first (= current) item in current playlist:

  Item := CurrentPlaylist.GetItem(0);


// Zweites Element in der aktuellen Playlist herausfinden:
// Retrieve second item in current playlist:

  Item := CurrentPlaylist.GetItem(1); 

  // etc.


// Oberstes Element der zweiten Playlist herausfinden:
// Retrieve first item in second playlist:

  Item := Playlist(1).GetItem(0); 

  // etc.


// Gesamtzahl der Elemente in der aktuellen Playlist herausfinden:
// Retrieve total number of items in current playlist:

  Number := CurrentPlaylist.GetCount;


// Letztes Element der aktuellen Playliste herausfinden:
// Retrieve last item in current playlist:

  Item := CurrentPlaylist.GetItem(CurrentPlaylist.GetCount - 1);

  // (nullbasiert/zero-based!)


// Position eines Elements in der Playlist herausfinden:
// Retrieve position of item in Playlist:

  Number := CurrentPlaylist.IndexOf(Item); 

  // (nullbasiert/zero-based!)


// Titel des aktuellen Elements herausfinden:
// Retrieve title of current item:

  Name := CurrentPlaylist.GetItem(0).GetTitle;


// Nächstes Fixtime-Element suchen:
// Find next fixtime item:

  Item := CurrentPlaylist.GetNextFixedTimeItem;

  // (Achtung auf die Schreibweise "FixEDTime"!)
  // (Note diction "FixEDTime"!)


// Farbe eines Elements setzen:
// Set colour of item:

  Item.SetColor(<colour>);

  // … mit <colour> als hexadezimale Konstante: $00FF00.
  // … where <colour> ist the colour in hex: $00FF00.



// Punkt auf der Hüllkurve setzen:
// Set point in volume envelope:

  Item.GetVolumeEnvelope.AddPoint(Duration, Number, Name);


// Alle Hüllkurvenpunkte löschen:
// Clear points in volume envelope:

  Item.GetVolumeEnvelope.Clear;


// Zugriff auf aktuelle Playlist zum Bearbeiten sperren:
// Omit access to current playlist for editing:

  CurrentPlaylist.BeginRead;
    try
      { mach was/do something };
    finally
      CurrentPlaylist.EndRead;
    end;





// === Aktionen mit Playern/Operations on Players ===



// Aktion abhänging vom Status eines Players starten:
// Initiate action according to player state:

  if CurrentPlaylist.GetPlayer(Number).GetState = psEmpty then
    { do something };

  // … wobei auch folgende Player Stati eingesetzt werden können:
  // … where following types of player states can also be used:
  // • psLoading,
  // • psLoaded,
  // • psPlaying,
  // • psFading,
  // • psEOF,
  // • psError,
  // • psPaused,
  // • psStopped,


// Anzahl der Player feststellen:
// Retrieve Number of players:

  Number := CurrentPlaylist.GetPlayerCount;


// Anzahl der Player setzen:
// Set Number of players:

  CurrentPlaylist.SetPlayerCount(Number);




// === Daten, Zeiten und Dauern/Dates, Times and Durations ===

  // (Dauern und Positionen sind immer in Sekunden angegeben.)
  // (Durations and positions always are indicated in seconds.)



// Uhrzeit(-wert) in Spieldauer umwandeln:
// Convert time value to duration:

  Duration := frac(Time) * 86400;


// Spieldauer in Uhrzeit(-wert) umwandeln:
// Convert duration to time value:

  Time := Duration / 86400;


// Position der Cue-in-Marke feststellen:
// Get position of cue-in marker of an item:

  Duration := Item.GetCuePosition(ptCueIn);

  // Für andere Marker folgende Bezeichnungen verwenden:
  // For different types use following denominations:
  // • ptFadeIn
  // • ptRamp1
  // • ptRamp2
  // • ptRamp3
  // • ptHookIn
  // • ptHookFade
  // • ptLoopIn
  // • ptLoopOut
  // • ptOutro
  // • ptStartNext
  // • ptFadeOut
  // • ptFadeEnd
  // • ptCueOut
  // • ptAnchor


// Cue-Marken setzen:
// Set cue positions:

  Item.SetCuePosition(ptCueIn, Position);

  // … oder entsprechende Marker wie oben.
  // … or respective cue positions as aforementioned.


// Gesamtlänge eines Elements herausfinden (Cue-Marken unberücksichtigt):
// Retrieve total duration of item (without respect to cue markers):

  Duration := Item.GetDuration;


// Tatsächliche Spieldauer eines Elements herausfinden (Cue-Marken berücksichtigt):
// Retrieve effective duration of item (with respect to cue markers):

  Duration := Item.GetAudibleDuration;


// Startzeit eines Elements herausfinden:
// Retrieve start time of item:

  Time := GetMetadata(CurrentPlaylist.IndexOf(Item)).GetStartTime(sttStarted);

  // … oder andere Startzeiten:
  // … or different start time types:
  // • sttCalculated
  // • sttReal
  // • sttSinceLastBreak
  // • sttExpected


// Aktuelles Datum und Uhrzeit bestimmen:
// Retrieve current date and time:

  Time := Instance.Now;


// Datum und Uhrzeit im mAirList-Universum bestimmen:
// Retrieve mAirlist-set date and time:

  Time := Instance.FakeNow;


// Nur das Datum erhalten:
// Retrieve date only:

  Date := trunc(Instance.FakeNow);


// Nur die Uhrzeit erhalten:
// Retrieve time only:

  Time := frac(Instance.FakeNow);



// === Spielereien mit der GUI/Playing around the GUI ===

  // 'BUTTON.NAME' sei der Name des Buttons bzw. statischen Textes,
  // "<HEXCOLOUR>" eine Farbe in Hex-Code, als z.B. #c0c0c0
  // (im Gegensatz zu Item.SetColor := $c0c0c0).
  // 'BUTTON.NAME' be the button's name (or that of static text),
  // "<HEXCOLOUR>" some colour in hex code, such as #c0c0c0
  // (contrary to Item.SetColor := $c0c0c0).


// Einen erweiterten Button in den "Ein"- bzw. "Aus"-Zustand versetzen:
// Put an extended button into "On" state (or "Off" respectively):

  ExecuteCommand('BUTTON.NAME ON');
  ExecuteCommand('BUTTON.NAME OFF');


// Einen erweiterten Button sperren bzw. entsperren:
// Disable/enable an extended button:

  ExecuteCommand('BUTTON.NAME DISABLE');
  ExecuteCommand('BUTTON.NAME ENABLE');

  // (Achtung: Gesperrte Buttons können auch durch ein Skript nicht
  //  eingeschaltet werden; immer vorher erst entsperren.)
  // (Note that disabled Buttons cannot be turned on, even by scripting;
  //  always enable them first.)


// Text eines Buttons oder statischen Textes in 'Caption' ändern:
// Change text in button or static text to 'Caption':

  ExecuteCommand('BUTTON.NAME TEXT Caption');


// Schriftfarbe eines statischen Textes mit dem Namen 'BUTTON.NAME' ändern:
// Change font colour of static text with name 'BUTTON.NAME':

  ExecuteCommand('BUTTON.NAME FONTCOLOR <HEXCOLOUR>');


// Hintergrundfarbe eines statischen Textes mit dem Namen 'BUTTON.NAME' ändern:
// Change background colour of static text with name 'BUTTON.NAME':

  ExecuteCommand('BUTTON.NAME BACKGROUNDCOLOR <HEXCOLOUR>');

  // (Diese gehen nur bei statischem Text. Die Farben [erweiterter] Buttons
  //  müssen in deren Konfiguration festgelegt werden.)
  // (Note that these apply to static text only. The colours of [extended]
  //  buttons are to be defined via configuration.)




// === Mehr so systemorientiertes Zeug/System-related stuff ===


// Schauen, ob Automation an ist:
// Retrieve state of automatation:

  State := CurrentPlaybackControl.GetAutomation;


// Automation ein- oder ausschalten:
// Switch automatation on or off:

  CurrentPlaybackControl.SetAutomation(State);


// Einen Remote-Befehl ausführen:
// Execute a remote command:

  ExecuteCommand(Name);


// Daten für andere Skripte zugänglich machen:
// Set data being able to be accessed bay other scripts:

  SetRuntimeData(Name, Parameter);

  // … mit "Name" als Namen der Variable und "Parameter" deren Inhalt.
  // … where "Name" ist the name of the variable, "Parameter" is the data itself.


// Runtime-Data abrufen:
// Retrieve runtime data:

  Parameter := GetRuntimeData(Name);


// Eine Textdatei erzeugen, Zeilen hinzufügen und speichern.
// Create a text file, add lines to and save it.

  try
    StringList := TStringList.Create;
    StringList.Add(Name);
    // etc. …
    StringList.SaveToFile('C:\path\to\file.txt');
  finally
    StringList.Free;


// Einen MS-DOS-Kommandozeilenbefehl ausführen:
// Execute an MS-DOS command:

  ShellExecute(Name, Parameter);


// Einen MS-DOS-Kommandozeilenbefehl unsichtbar ausführen:
// Execute an MS-DOS command invisibly:

  ShellExecuteHidden(Name, Parameter);


// Einen TCP-String senden:
// Send a TCP string to client:

  TCPSendString(Server, Port, String1);

  // (nicht getestet/untested)


// Einen UDP-String senden:
// Send a UDP string:

  UDPSendString(Server, Port, String1);

  // (nicht getestet/untested)


// Etwas ins System-Log schreiben:
// Write something to system log:

  SystemLog(Name);


// Eine Textnachricht zeigen:
// Show text message:

  ShowMessage(Name);


end;

begin
end.


Keine Gewähr für Fehler. (Kaputtmachen kann man aber nichts.)

2 Likes

Leider kann man den Elementtyp mit der Abfrage Item.GetItemType nicht direkt verwerten, siehe hier. Allen, die so etwas trotzdem brauchen, sei hier eine Funktion dafür an die Hand gelegt, etwas eleganter als im obigen Beispiel:

function ItemType(Item: IPlaylistItem): string;
begin
  case Ord(Item.GetItemType) of
    0: Result := 'Unknown';
    1: Result := 'Music';
    2: Result := 'Voice';
    3: Result := 'News';
    5: Result := 'Traffic';
    6: Result := 'Advertising';
    7: Result := 'Package';
    8: Result := 'Jingle';
    9: Result := 'Sound';
    10: Result := 'Trailer';
    11: Result := 'Promo';
    12: Result := 'Sponsorship';
    13: Result := 'Sweeper';
    14: Result := 'Drop';
    15: Result := 'StationID';
    16: Result := 'Bed';
    17: Result := 'Instrumental';
    18: Result := 'Show';
    19: Result := 'Stream';
    20: Result := 'Container';
    21: Result := 'Playlist';
    22: Result := 'Command';
    23: Result := 'CartwallPage';
    24: Result := 'Break';
    25: Result := 'Dummy';
    26: Result := 'Silence';
    27: Result := 'Error';
    28: Result := 'Other';
    29: Result := 'Custom1';
    30: Result := 'Custom2';
    31: Result := 'Custom3';
  else
    Result := 'NULL';
  end;
end;


Mit der Abfrage
var
  Element: string;
  Item: IPlaylistItem;

begin
  Element := ItemType(Item);
end.

läßt sich der Elementtyp direkt als String ausgeben.

Ergänzte Grüße

TSD

Metadaten eines Relayed-Streams in ein Textfile loggen (geht nämlich nicht mit der normalen Logfunktion):

Log metadata of a relayed stream into a text file (built-in logger doesn’t apply to this):

// Called when metadata is received from a (relayed) stream
procedure OnItemMetadata(Item: IPlaylistItem; Metadata: string);
var
  sl: IStrings;
begin
  sl := Factory.CreateStrings;
  sl.Add(Metadata);
  sl.SaveToFile('C:\sometextfile.txt');
end;

© @Torben

Gespeicherte Grüße

TSD