summaryrefslogtreecommitdiff
path: root/skins.h
diff options
context:
space:
mode:
authorKlaus Schmidinger <vdr@tvdr.de>2004-05-16 10:35:36 +0200
committerKlaus Schmidinger <vdr@tvdr.de>2004-05-16 10:35:36 +0200
commit5d99df7b7760c4a2b497c737a15b609008f6d56d (patch)
treea342f2f7465a73fe2bd63848d87566af8d646dd3 /skins.h
parent7aab06d8b1c6de59d06756d44c631984acd299b3 (diff)
downloadvdr-5d99df7b7760c4a2b497c737a15b609008f6d56d.tar.gz
vdr-5d99df7b7760c4a2b497c737a15b609008f6d56d.tar.bz2
Implemented 'skins' and 'themes'
Diffstat (limited to 'skins.h')
-rw-r--r--skins.h297
1 files changed, 297 insertions, 0 deletions
diff --git a/skins.h b/skins.h
new file mode 100644
index 00000000..412810f2
--- /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