Version 1.3.7vdr-1.3.7

- Fixed a memory leak in thread handling when using NPTL (thanks to Jon Burgess).
- Fixed handling Setup.RecordDolbyDigital, which was broken since version 1.1.6.
- Fixed handling text lengths for itemized EPG texts (thanks to Marcel Wiesweg).
- Fixed the help for LSTE and LSTR (was broken in 1.3.6).
- Improved iso8859-7 fonts (thanks to Dimitrios Dimitrakos).
- Added some 3-letter language codes (thanks to Marcus Mönnig).
- Added language code handling to the subtitling descriptor in 'libsi' (thanks to
  Pekka Virtanen).
- Moved several menu item classes from menu.c to menuitems.[hc] to make them
  available for plugins.
- The epg2html.pl script now handles '|' in description texts.
- The new setup option "OSD/Use small font" can be used to control the use of
  the small font (see MANUAL for details).
- Swapped osd.[hc] and osdbase.[hc] to have the virtual OSD base class named cOsd.
  Plugins may need to adjust their #include statements.
- Colors are now given as AARRGGBB instead of AABBGGRR. The values are mapped to
  the driver's (wrong) sequence in dvbosd.c (this should really be fixed in the
  driver, together with the endian problem).
- The new OSD setup parameters "Left" and "Top" can be used to define the top left
  corner of the OSD.
- The OSD size parameters are now in pixel (as opposed to formerly characters).
  When reading a 'setup.conf' file from an older version of VDR, the OSDwidth
  and OSDheight values will be converted to pixel automatically.
- The OSD is now fully device independent. See the comments in VDR/osd.h and the
  description in PLUGINS.html for information on how a plugin can implement an OSD
  display on arbitrary hardware.
- The OSD (actually its cBitmap class) can now handle XPM files. There are several
  XPM files in the VDR/symbols directory which can be used by skins (some of these
  have been taken from the "elchi" patch). See VDR/skinsttng.c for examples on how
  to use these.
- Due to the changes in the OSD handling the DEBUG_OSD option for a textual OSD
  has been dropped. There will be a plugin that implements a skin with this
  functionality later.
- The entire OSD display can now be implemented via "skins". See VDR/skins.[hc],
  VDR/skinclassic.[hc], VDR/skinsttng.[hc] and PLUGINS.html for information on how
  a plugin can implement its own skin. By default VDR comes with a "Classic" skin
  that implements the OSD display known from previous versions, and the new skin
  named "ST:TNG Panels", which is also the default skin now. The actual skin can
  be selected through "Setup/OSD/Skin".
- The colors used in a skin can now be configured using "themes". See PLUGINS.html
  for information on how a skin can make use of themes, and man vdr(5) for the
  structure of a theme file. The actual theme to use can be selected through
  "Setup/OSD/Theme".
- Added Croatian language texts (thanks to Drazen Dupor).
  NOTE: there is apparently a problem with the newly introduced iso8859-2 font,
  because as soon as Setup/OSD/Language is set to Croatian (currently the last one
  in the list) everything freezes and the vdr processes have to be killed with -9
  and the driver needs to be reloaded. Maybe somebody else can find out what's
  going wrong here...
- Added missing NULL checks when accessing sectionHandler in device.c (thanks to
  Pekka Virtanen).
- Fixed setting the time from the DVB data stream (thanks to Helmut Auer for
  pointing out a frequency/transponder handling mixup). This now also takes the
  actual source (sat, cable etc.) into account. Please go into "Setup/EPG" and
  set the "Set system time" and "Use time from transponder" parameters accordingly
  (this is necessary even if you have already set them before!).

1 files changed, 297 insertions, 0 deletions

diff --git a/skins.h b/skins.h
new file mode 100644
index 0000000..412810f
--- /dev/null
+++ b/skins.h
@@ -0,0 +1,297 @@
+/*
+ * 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 1.1 2004/05/16 09:40:18 kls Exp $
+ */
+
+#ifndef __SKINS_H
+#define __SKINS_H
+
+#include "channels.h"
+#include "epg.h"
+#include "keys.h"
+#include "osd.h"
+#include "recording.h"
+#include "themes.h"
+#include "tools.h"
+
+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();
+  int EditableWidth(void) { return editableWidth; }
+  void SetEditableWidth(int Width) { editableWidth = Width; }
+       ///< If an item is set through a call to cSkinDisplayMenu::SetItem(), this
+       ///< function shall be called to set the width of the rightmost tab separated
+       ///< field. This information will be used for editable items.
+  virtual void SetButtons(const char *Red, const char *Green = NULL, const char *Yellow = NULL, const char *Blue = NULL) {}
+       ///< Sets the color buttons to the given strings, provided this cSkinDisplay
+       ///< actually has a color button display.
+  virtual void SetMessage(eMessageType Type, const char *Text) {}
+       ///< Sets a one line message Text, with the given Type. Type can be used
+       ///< to determine, e.g., the colors for displaying the Text.
+  virtual void Flush(void) {}
+       ///< Actually draws the OSD display to the output device.
+  static cSkinDisplay *Current(void) { return current; }
+       ///< Returns the currently active cSkinDisplay.
+  };
+
+class cSkinDisplayChannel : public cSkinDisplay {
+       ///< This class is used to display the current channel, together with
+       ///< the present and following EPG even. How and to what extent this
+       ///< is done is totally up to the derived class.
+public:
+  virtual void SetChannel(const cChannel *Channel, int Number) = 0;
+       ///< Sets the current channel to Channel. If Number is not 0, the
+       ///< user is in the process of entering a channel number, which must
+       ///< be displayed accordingly.
+  virtual void SetEvents(const cEvent *Present, const cEvent *Following) = 0;
+       ///< Sets the Present and Following EPG events. It either of these
+       ///< is not available, NULL will be given.
+  /*TODO
+  SetButtons
+    Red    = Video options
+    Green  = Info now
+    Yellow = Info next
+    Blue   = Audio options
+  AudioOptions
+  VideoOptions
+  */
+  };
+
+class cSkinDisplayMenu : public cSkinDisplay {
+       ///< This class implements the general purpose menu display, which is
+       ///< used throughout the program to display information and let the
+       ///< user interact with items.
+       ///< A menu consists of the following fields, each of which is explicitly
+       ///< set by calls to the member functions below:
+       ///< - Title: a single line of text, indicating what this menu displays
+       ///< - Color buttons: the red, green, yellow and blue buttons, used for
+       ///<   various functions
+       ///< - Message: a one line message, indicating a Status, Info, Warning,
+       ///<   or Error condition
+       ///< - Central area: the main central area of the menu, used to display
+       ///<   one of the following:
+       ///<   - Items: a list of single line items, of which the user may be
+       ///<     able to select one
+       ///<   - Event: the full information about one EPG event
+       ///<   - Text: a multi line, scrollable text
+public:
+  enum { MaxTabs = 6 };
+private:
+  int tabs[MaxTabs];
+protected:
+  cTextScroller textScroller;
+  int Tab(int n) { return (n >= 0 && n < MaxTabs) ? tabs[n] : 0; }
+       ///< Returns the offset of the given tab from the left border of the
+       ///< item display area. The value returned is in pixel.//XXX ncurses???
+  const char *GetTabbedText(const char *s, int Tab);
+       ///< Returns the that part of the given string, that follows the given
+       ///< Tab (where 0 indicates the beginning of the string). If no such
+       ///< part can be found, NULL will be returned.
+public:
+  cSkinDisplayMenu(void);
+  virtual void SetTabs(int Tab1, int Tab2 = 0, int Tab3 = 0, int Tab4 = 0, int Tab5 = 0);
+       ///< Sets the tab columns to the given values, which are the number of
+       ///< characters in each column.//XXX ncurses???
+  virtual void Scroll(bool Up, bool Page);
+       ///< If this menu contains a text area that can be scrolled, this function
+       ///< will be called to actually scroll the text. Up indicates whether the
+       ///< text shall be scrolled up or down, and Page is true if it shall be
+       ///< scrolled by a full page, rather than a single line. An object of the
+       ///< cTextScroller class can be used to implement the scrolling text area.
+  virtual int MaxItems(void) = 0;
+       ///< Returns the maximum number of items the menu can display.
+  virtual void Clear(void) = 0;
+       ///< Clears the entire central area of the menu.
+  virtual void SetTitle(const char *Title) = 0;
+       ///< Sets the title of this menu to Title.
+  virtual void SetButtons(const char *Red, const char *Green = NULL, const char *Yellow = NULL, const char *Blue = NULL) = 0;
+       ///< Sets the color buttons to the given strings. If any of the values is
+       ///< NULL, any previous text must be removed from the related button.
+  virtual void SetMessage(eMessageType Type, const char *Text) = 0;
+       ///< Sets a one line message Text, with the given Type. Type can be used
+       ///< to determine, e.g., the colors for displaying the Text.
+       ///< If Text is NULL, any previously displayed message must be removed, and
+       ///< any previous contents overwritten by the message must be restored.
+  virtual void SetItem(const char *Text, int Index, bool Current, bool Selectable) = 0;
+       ///< Sets the item at the given Index to Text. Index is between 0 and the
+       ///< value returned by MaxItems(), minus one. Text may contain tab characters ('\t'),
+       ///< which shall be used to separate the text into several columns, according to the
+       ///< values set by a prior call to SetTabs(). If Current is true, this item shall
+       ///< be drawn in a way indicating to the user that it is the currently selected
+       ///< one. Selectable can be used to display items differently that can't be
+       ///< selected by the user.
+       ///< Whenever the current status is moved from one item to another,
+       ///< this function will be first called for the old current item
+       ///< with Current set to false, and then for the new current item
+       ///< with Current set to true.
+  /*TODO
+  virtual void SetItem(const cEvent *Event, int Index, bool Current, bool Selectable, bool NowNext???, bool Schedule???);
+  virtual void SetItem(const cTimer *Timer, int Index, bool Current, bool Selectable);
+  virtual void SetItem(const cChannel *Channel, int Index, bool Current, bool Selectable);
+  virtual void SetItem(const cRecording *Recording, int Index, bool Current, bool Selectable);
+  --> false: call SetItem(text)
+  */
+  virtual void SetEvent(const cEvent *Event) = 0;
+       ///< Sets the Event that shall be displayed, using the entire central area
+       ///< of the menu. The Event's 'description' shall be displayed using a
+       ///< cTextScroller, and the Scroll() function will be called to drive scrolling
+       ///< that text if necessary.
+  virtual void SetRecording(const cRecording *Recording) = 0;
+       ///< Sets the Recording that shall be displayed, using the entire central area
+       ///< of the menu. The Recording's 'summary' shall be displayed using a
+       ///< cTextScroller, and the Scroll() function will be called to drive scrolling
+       ///< that text if necessary.
+  virtual void SetText(const char *Text, bool FixedFont) = 0;
+       ///< Sets the Text that shall be displayed, using the entire central area
+       ///< of the menu. The Text shall be displayed using a cTextScroller, and
+       ///< the Scroll() function will be called to drive scrolling that text if
+       ///< necessary.
+  //XXX ??? virtual void SetHelp(const char *Help) = 0;
+  };
+
+class cSkinDisplayReplay : public cSkinDisplay {
+       ///< This class implements the progress display used during replay of
+       ///< a recording.
+protected:
+  const cMarks *marks;
+  class cProgressBar : public cBitmap {
+  protected:
+    int total;
+    int Pos(int p) { return p * Width() / total; }
+    void Mark(int x, bool Start, bool Current, tColor ColorMark, tColor ColorCurrent);
+  public:
+    cProgressBar(int Width, int Height, int Current, int Total, const cMarks *Marks, tColor ColorSeen, tColor ColorRest, tColor ColorSelected, tColor ColorMark, tColor ColorCurrent);
+    };
+public:
+  cSkinDisplayReplay(void);
+  virtual void SetMarks(const cMarks *Marks);
+       ///< Sets the editing marks to Marks, which shall be used to display the
+       ///< progress bar through a cProgressBar object.
+  virtual void SetTitle(const char *Title) = 0;
+       ///< Sets the title of the recording.
+  virtual void SetMode(bool Play, bool Forward, int Speed) = 0;
+       ///< Sets the current replay mode, which can be used to display some
+       ///< indicator, showing the user whether we are currently in normal
+       ///< play mode, fast forward etc.
+  virtual void SetProgress(int Current, int Total) = 0;
+       ///< This function will be called whenever the position in of the total
+       ///< length of the recording has changed. A cProgressBar shall then be
+       ///< used to display a progress indicator.
+  virtual void SetCurrent(const char *Current) = 0;
+       ///< Sets the current position within the recording, as a user readable
+       ///< string if the form "h:mm:ss.ff". The ".ff" part, indicating the
+       ///< frame number, is optional and the actual implementation needs to
+       ///< take care that it is erased from the display when a Current string
+       ///< _with_ ".ff" is followed by one without it.
+  virtual void SetTotal(const char *Total) = 0;
+       ///< Sets the total length of the recording, as a user readable 
+       ///< string if the form "h:mm:ss".
+  virtual void SetJump(const char *Jump) = 0;
+       ///< Sets the prompt that allows the user to enter a jump point.
+       ///< Jump is a string of the form "Jump: mm:ss". The actual implementation
+       ///< needs to be able to handle variations in the length of this
+       ///< string, which will occur when the user enters an actual value.
+       ///< If Jump is NULL, the jump prompt shall be removed from the display.
+  };
+
+class cSkinDisplayVolume : public cSkinDisplay {
+       ///< This class implements the volume/mute display.
+public:
+  virtual void SetVolume(int Current, int Total, bool Mute) = 0;
+       ///< Sets the volume to the given Current value, which is in the range
+       ///< 0...Total. If Mute is true, audio is currently muted and a "mute"
+       ///< indicator shall be displayed.
+  };
+
+class cSkinDisplayMessage : public cSkinDisplay {
+       ///< This class implements a simple message display.
+public:
+  virtual void SetMessage(eMessageType Type, const char *Text) = 0;
+       ///< Sets the message to Text. Type can be used to decide how to display
+       ///< the message, for instance in which colors.
+  };
+
+class cSkin : public cListObject {
+private:
+  char *name;
+  cTheme *theme;
+public:
+  cSkin(const char *Name, cTheme *Theme = NULL);
+       ///< Creates a new skin class, with the given Name and Theme.
+       ///< Name will be used to identify this skin in the 'setup.conf'
+       ///< file, and is normally not seen by the user. It should
+       ///< consist of only lowercase letters and digits.
+       ///< Theme must be a static object that survives the entire lifetime
+       ///< of this skin.
+       ///< The constructor of a derived class shall not set up any data
+       ///< structures yet, because whether or not this skin will actually
+       ///< be used is not yet known at this point. All actual work shall
+       ///< be done in the pure functions below.
+       ///< A cSkin object must be created on the heap and shall not be
+       ///< explicitly deleted.
+  virtual ~cSkin();
+  const char *Name(void) { return name; }
+  cTheme *Theme(void) { return theme; }
+  virtual const char *Description(void) = 0;
+       ///< Returns a user visible, single line description of this skin,
+       ///< which may consist of arbitrary text and can, if the skin
+       ///< implementation wishes to do so, be internationalized.
+       ///< The actual text shouldn't be too long, so that it can be
+       ///< fully displayed in the Setup/OSD menu.
+  virtual cSkinDisplayChannel *DisplayChannel(bool WithInfo) = 0;
+       ///< Creates and returns a new object for displaying the current
+       ///< channel. WithInfo indicates whether it shall display only
+       ///< the basic channel data, or also information about the present
+       ///< and following EPG event.
+       ///< The caller must delete the object after use.
+  virtual cSkinDisplayMenu *DisplayMenu(void) = 0;
+       ///< Creates and returns a new object for displaying a menu.
+       ///< The caller must delete the object after use.
+  virtual cSkinDisplayReplay *DisplayReplay(bool ModeOnly) = 0;
+       ///< Creates and returns a new object for displaying replay progress.
+       ///< ModeOnly indicates whether this should be a full featured replay
+       ///< display, or just a replay mode indicator.
+       ///< The caller must delete the object after use.
+  virtual cSkinDisplayVolume *DisplayVolume(void) = 0;
+       ///< Creates and returns a new object for displaying the current volume.
+       ///< The caller must delete the object after use.
+  virtual cSkinDisplayMessage *DisplayMessage(void) = 0;
+       ///< Creates and returns a new object for displaying a message.
+       ///< The caller must delete the object after use.
+  };
+
+class cSkins : public cList<cSkin> {
+private:
+  cSkin *current;
+  cSkinDisplayMessage *displayMessage;
+public:
+  cSkins(void);
+  ~cSkins();
+  bool SetCurrent(const char *Name = NULL);
+       ///< Sets the current skin to the one indicated by name.
+       ///< If no such skin can be found, the first one will be used.
+  cSkin *Current(void) { return current; }
+       ///< Returns a pointer to the current skin.
+  bool IsOpen(void) { return cSkinDisplay::Current(); }
+       ///< Returns true if there is currently a skin display object active.
+  eKeys Message(eMessageType Type, const char *s, int Seconds = 0);
+       ///< Displays the given message, either through a currently visible
+       ///< display object that is capable of doing so, or by creating a
+       ///< temporary cSkinDisplayMessage object.
+  void Flush(void);
+       ///< Flushes the currently active cSkinDisplay, if any.
+  };
+
+extern cSkins Skins;
+
+#endif //__SKINS_H