skins.h

Go to the documentation of this file.

/*
 * skins.h: The optical appearance of the OSD
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: skins.h 5.13 2026/05/30 12:27:12 kls Exp $
 */
 
#ifndef __SKINS_H
#define __SKINS_H
 
#include "channels.h"
#include "epg.h"
#include "keys.h"
#include "osd.h"
#include "positioner.h"
#include "recording.h"
#include "themes.h"
#include "thread.h"
#include "timers.h"
#include "tools.h"
 
// Several member functions of the following classes are called with a pointer to
// an object from a global list (cTimer, cChannel, cRecording or cEvent). In these
// cases the core VDR code holds a lock on the respective list. While in general a
// plugin should only work with the objects and data that is explicitly given to it
// in the function call, the called function may itself set a read lock (not a write
// lock!) on this list, because read locks can be nested. It may also set read locks
// (not write locks!) on higher order lists.
// For instance, a function that is called with a cChannel may lock cRecordings and/or
// cSchedules (which contains cEvent objects), but not cTimers. If a plugin needs to
// set locks of its own (on mutexes defined inside the plugin code), it shall do so
// after setting any locks on VDR's global lists, and it shall always set these
// locks in the same sequence, to avoid deadlocks.
 
enum eMessageType { mtStatus = 0, mtInfo, mtWarning, mtError }; // will be used to calculate color offsets!
 
class cSkinDisplay {
private:
  static cSkinDisplay *current;
  int editableWidth; //XXX this is not nice, but how else could we know this value?
public:
  cSkinDisplay(void);
  virtual ~cSkinDisplay();
  static int AvgCharWidth(void) { return Setup.FontOsdSize * 4 / 6; }
  int EditableWidth(void) { return editableWidth; }
  void SetEditableWidth(int Width) { editableWidth = Width; }
  virtual void SetButtons(const char *Red, const char *Green = NULL, const char *Yellow = NULL, const char *Blue = NULL) {}
  virtual void SetMessage(eMessageType Type, const char *Text) {}
  virtual void Flush(void) {}
  static cSkinDisplay *Current(void) { return current; }
  };
 
class cSkinDisplayChannel : public cSkinDisplay {
private:
  const cPositioner *positioner;
public:
  cSkinDisplayChannel(void);
  virtual void SetChannel(const cChannel *Channel, int Number) = 0;
  virtual void SetEvents(const cEvent *Present, const cEvent *Following) = 0;
  virtual void SetMessage(eMessageType Type, const char *Text) override = 0;
  virtual void SetPositioner(const cPositioner *Positioner);
  /*TODO
  SetButtons
    Red    = Video options
    Green  = Info now
    Yellow = Info next
  */
  };
 
enum eMenuCategory {
  mcUndefined = -1,
  mcUnknown = 0,
  mcMain,
  mcSchedule,
  mcScheduleNow,
  mcScheduleNext,
  mcChannel,
  mcChannelEdit,
  mcTimer,
  mcTimerEdit,
  mcRecording,
  mcRecordingDel,
  mcRecordingInfo,
  mcRecordingEdit,
  mcPlugin,
  mcPluginSetup,
  mcSetup,
  mcSetupOsd,
  mcSetupEpg,
  mcSetupDvb,
  mcSetupLnb,
  mcSetupCam,
  mcSetupRecord,
  mcSetupReplay,
  mcSetupMisc,
  mcSetupPlugins,
  mcCommand,
  mcEvent,
  mcText,
  mcFolder,
  mcCam
  };
 
enum eMenuSortMode {
  msmUnknown = 0,
  msmNumber,
  msmName,
  msmTime,
  msmProvider
  };
 
enum eMenuOrientation {
  moVertical = 0,
  moHorizontal
  };
 
class cSkinDisplayMenu : public cSkinDisplay {
public:
  enum { MaxTabs = 6 };
private:
  eMenuCategory menuCategory;
  int tabs[MaxTabs];
protected:
  cTextScroller textScroller;
  int Tab(int n) { return (n >= 0 && n < MaxTabs) ? tabs[n] : 0; }
  const char *GetTabbedText(const char *s, int Tab);
public:
  cSkinDisplayMenu(void);
  eMenuCategory MenuCategory(void) const { return menuCategory; }
  virtual void SetMenuCategory(eMenuCategory MenuCategory);
  virtual void SetTabs(int Tab1, int Tab2 = 0, int Tab3 = 0, int Tab4 = 0, int Tab5 = 0);
  virtual void SetMenuSortMode(eMenuSortMode MenuSortMode) {}
  virtual eMenuOrientation MenuOrientation(void) { return moVertical; }
  virtual void Scroll(bool Up, bool Page);
  virtual int MaxItems(void) = 0;
  virtual void Clear(void) = 0;
  virtual void SetTitle(const char *Title) = 0;
  virtual void SetButtons(const char *Red, const char *Green = NULL, const char *Yellow = NULL, const char *Blue = NULL) override = 0;
  virtual void SetMessage(eMessageType Type, const char *Text) override = 0;
  virtual void SetItem(const char *Text, int Index, bool Current, bool Selectable) = 0;
  virtual bool SetItemEvent(const cEvent *Event, int Index, bool Current, bool Selectable, const cChannel *Channel, bool WithDate, eTimerMatch TimerMatch, bool TimerActive) { return false; }
  virtual bool SetItemEvent(const cEvent *Event, int Index, bool Current, bool Selectable, const cChannel *Channel, bool WithDate, eTimerMatch TimerMatch, const cTimer *Timer) {
       return SetItemEvent(Event, Index, Current, Selectable, Channel, WithDate, TimerMatch, Timer && Timer->HasFlags(tfActive)); }
  virtual bool SetItemTimer(const cTimer *Timer, int Index, bool Current, bool Selectable) { return false; }
  virtual bool SetItemChannel(const cChannel *Channel, int Index, bool Current, bool Selectable, bool WithProvider) { return false; }
  virtual bool SetItemRecording(const cRecording *Recording, int Index, bool Current, bool Selectable, int Level, int Total, int New) { return false; }
  virtual void SetScrollbar(int Total, int Offset);
  virtual void SetEvent(const cEvent *Event) = 0;
  virtual void SetRecording(const cRecording *Recording) = 0;
  virtual void SetText(const char *Text, bool FixedFont) = 0;
  //XXX ??? virtual void SetHelp(const char *Help) = 0;
  virtual int GetTextAreaWidth(void) const;
  virtual const cFont *GetTextAreaFont(bool FixedFont) const;
  };
 
class cSkinDisplayReplay : public cSkinDisplay {
protected:
  const cMarks *marks;
  const cErrors *errors;
  class cProgressBar : public cBitmap {
  protected:
    int total;
    int Pos(int p) { return int(int64_t(p) * Width() / total); }
    void Mark(int x, bool Start, bool Current, tColor ColorMark, tColor ColorCurrent);
    void Error(int x, tColor ColorError);
  public:
    cProgressBar(int Width, int Height, int Current, int Total, const cMarks *Marks, tColor ColorSeen, tColor ColorRest, tColor ColorSelected, tColor ColorMark, tColor ColorCurrent); // for backwards compatibility
    cProgressBar(int Width, int Height, int Current, int Total, const cMarks *Marks, const cErrors *Errors, tColor ColorSeen, tColor ColorRest, tColor ColorSelected, tColor ColorMark, tColor ColorCurrent, tColor ColorError);
    };
public:
  cSkinDisplayReplay(void);
  virtual void SetMarks(const cMarks *Marks);
  virtual void SetErrors(const cErrors *Errors);
  virtual void SetRecording(const cRecording *Recording);
  virtual void SetTitle(const char *Title) = 0;
  virtual void SetMode(bool Play, bool Forward, int Speed) = 0;
  virtual void SetProgress(int Current, int Total) = 0;
  virtual void SetCurrent(const char *Current) = 0;
  virtual void SetTotal(const char *Total) = 0;
  virtual void SetJump(const char *Jump) = 0;
  virtual void SetMessage(eMessageType Type, const char *Text) override = 0;
  };
 
class cSkinDisplayVolume : public cSkinDisplay {
public:
  virtual void SetVolume(int Current, int Total, bool Mute) = 0;
  };
 
class cSkinDisplayTracks : public cSkinDisplay {
public:
  virtual void SetTrack(int Index, const char * const *Tracks) = 0;
  virtual void SetAudioChannel(int AudioChannel) = 0;
  };
 
class cSkinDisplayMessage : public cSkinDisplay {
public:
  virtual void SetMessage(eMessageType Type, const char *Text) override = 0;
  };
 
class cSkin : public cListObject {
private:
  char *name;
  cTheme *theme;
public:
  cSkin(const char *Name, cTheme *Theme = NULL);
  virtual ~cSkin() override;
  const char *Name(void) { return name; }
  cTheme *Theme(void) { return theme; }
  virtual const char *Description(void) = 0;
  virtual cSkinDisplayChannel *DisplayChannel(bool WithInfo) = 0;
  virtual cSkinDisplayMenu *DisplayMenu(void) = 0;
  virtual cSkinDisplayReplay *DisplayReplay(bool ModeOnly) = 0;
  virtual cSkinDisplayVolume *DisplayVolume(void) = 0;
  virtual cSkinDisplayTracks *DisplayTracks(const char *Title, int NumTracks, const char * const *Tracks) = 0;
  virtual cSkinDisplayMessage *DisplayMessage(void) = 0;
  };
 
class cSkins : public cList<cSkin> {
private:
  cSkin *current;
  cSkinDisplayMessage *displayMessage;
  cMutex queueMessageMutex;
public:
  cSkins(void);
  ~cSkins();
  bool SetCurrent(const char *Name = NULL);
  cSkin *Current(void) { return current; }
  bool IsOpen(void) { return cSkinDisplay::Current(); }
  eKeys Message(eMessageType Type, const char *s, int Seconds = 0);
  int QueueMessage(eMessageType Type, const char *s, int Seconds = 0, int Timeout = 0);
  void ProcessQueuedMessages(void);
  void Flush(void);
  virtual void Clear(void) override;
  };
 
extern cSkins Skins;
 
#endif //__SKINS_H