Version 1.7.17

- Updated the Estonian OSD texts (thanks to Arthur Konovalov).
- Fixed following symbolic links in RemoveFileOrDir() (cont'd) (thanks to
  Steffen Barszus).
- Changed the description of cDevice::GetSTC() to make it mandatory for devices
  that can replay.
- Removed the check for positive STC values from cDvbSubtitleConverter::Action().
- Added cString::operator=(const char *String) (suggested by Antti Seppälä).
- Some spelling fixes (thanks to Ville Skyttä).
- Passing package name and version to xgettext (thanks to Ville Skyttä).
- Made 'dist' target dependent on up to date *.po (thanks to Ville Skyttä).
- Added Language and fixed Language-Team header of *.po (thanks to Ville Skyttä).
- Updated the Lithuanian OSD texts (thanks to Valdemaras Pipiras).
- Fixed detecting frames on channels that broadcast with 50 or 60 fps.
  This avoids artifacts during fast forward/rewind when replaying recordings from such
  channels. To fix the index of existing recordings from such channels, just delete the
  'index' file of the recording and VDR will generate a new one the next time you play it.
  You should also change the line "F 25" to "F 50" in the 'info' file of that recording.
- Added support for "registration descriptor" to 'libsi' and using it in pat.c (thanks
  to Rolf Ahrenberg).
- Fixed unjustified log entries about changed channel pids (reported by Derek Kelly).
- Added an include of VDR's 'Make.global' to libsi's Makefile (thanks to Rolf
  Ahrenberg).
- Removed displaying the "contents" information from the "Classic VDR" and
  "ST:TNG Panels" skins, because it is often wrong and nothing but irritating.
- Added typecasts to avoid gcc 4.5 warnings in switch statements on eKeys
  variables where additional 'k_...' flags are used.
- Fixed inclusion of <stdarg.h> (thanks to Henning Heinold).
- Changed "frame duration" to "frame rate" in vdr.5 (reported by Tobias Grimm).
- Removing a cRemote from the Remotes list in case its initialization failed (thanks
  to Dominik Strasser).
- Added LDFLAGS to the linker calls in the Makefiles (thanks to Joerg Bornkessel and
  Paul Menzel).
- Now updating the 'frames per second' data in the list of recordings when a new
  recording is started that has a frame rate other than the default.
- The include path to the freetype2 header files is now retrieved via a call to
  'pkg-config --cflags freetype2' (suggested by Andreas Oberritter).
- The OSD now has full TrueColor support. There can be several "pixmaps" that can
  be overlayed with alpha blending. All existing skins should work out of the box
  with the TrueColor OSD - the only exception being cOsd::GetBitmap(). Since the
  TrueColor OSD doesn't use bitmaps, this function will return a dummy bitmap, which
  may not be what the plugin expects. As long as this bitmap is only used for setting
  the palette, there is no problem. However, any other operations on this bitmap will
  have no effect. See the description of the cPixmap functions in osd.h for details
  about the new functionalities.
  The "ST:TNG Panels" skin has been enhanced to automatically use the TrueColor OSD
  if available.
  The "osddemo" plugin has been extended to show some of the possibilities of the
  TrueColor OSD if it is run on a system that actually provides TrueColor support.
  Thanks to Reinhard Nissl for some valuable input, help with debugging, and an
  implementation of the AlphaBlend() function.
- Updated the Slovakian language texts (thanks to Milan Hrala).
- Added Serbian language texts (thanks to Milan Cvijanovic).
- Fixed reallocating memory in the "pictures" plugin (reported by Paul Menzel, with
  input from Oliver Endriss).
- Fixed reallocating memory in cTsToPes::PutTs() (suggested by Oliver Endriss).
- Now checking the result of all realloc() calls.
- Fixed setting up the 'Recordings' menu in case there are several recordings
  with exactly the same name (reported by Marcus Hilbrich).
- Setting the audio type of language descriptors to 0x00 in the PAT/PMT generator
  (thanks to Anssi Hannula).
- Changed the compiler optimization flag to -O3, which gives quite a performance
  boost in the AlphaBlend() function.
- While replaying, the editing marks are now updated every 10 seconds (based on a
  patch from Manuel Reimer).
- Now reducing the thread and I/O priority cCuttingThread::Action() to make the
  foreground process more responsive (suggested by Frank Neumann).
- Removed checking for minimum line length of 21 characters in the LIRC receiver code
  (reported by Gerald Dachs).
- Updated the Romanian OSD texts (thanks to Lucian Muresan).
- Now storing the original display size when handling DVB subtitles (thanks to
  Reinhard Nissl).
- The original display size of subtitles is now used to scale them properly when
  displaying them on an HD OSD.

4 files changed, 380 insertions, 6 deletions

diff --git a/PLUGINS/src/osddemo/HISTORY b/PLUGINS/src/osddemo/HISTORY
index 4217cb1..1270fbf 100644
--- a/PLUGINS/src/osddemo/HISTORY
+++ b/PLUGINS/src/osddemo/HISTORY
@@ -21,3 +21,7 @@ VDR Plugin 'osddemo' Revision History
 2008-04-13: Version 0.1.3
 
 - Fixed setting the OSD level (thanks to Wolfgang Rohdewald).
+
+2011-02-20: Version 0.2.0
+
+- Added support for TrueColor OSD.
diff --git a/PLUGINS/src/osddemo/Makefile b/PLUGINS/src/osddemo/Makefile
index d9ed4c5..d93d802 100644
--- a/PLUGINS/src/osddemo/Makefile
+++ b/PLUGINS/src/osddemo/Makefile
@@ -1,7 +1,7 @@
 #
 # Makefile for a Video Disk Recorder plugin
 #
-# $Id: Makefile 2.1 2010/02/06 14:50:03 kls Exp $
+# $Id: Makefile 2.3 2011/02/27 10:05:01 kls Exp $
 
 # The official name of this plugin.
 # This name will be used in the '-P...' option of VDR to load the plugin.
@@ -16,7 +16,7 @@ VERSION = $(shell grep 'static const char \*VERSION *=' $(PLUGIN).c | awk '{ pri
 ### The C++ compiler and options:
 
 CXX      ?= g++
-CXXFLAGS ?= -g -O2 -Wall -Woverloaded-virtual -Wno-parentheses
+CXXFLAGS ?= -g -O3 -Wall -Woverloaded-virtual -Wno-parentheses
 
 ### The directory environment:
 
@@ -72,7 +72,7 @@ $(DEPFILE): Makefile
 ### Targets:
 
 libvdr-$(PLUGIN).so: $(OBJS)
-	$(CXX) $(CXXFLAGS) -shared $(OBJS) -o $@
+	$(CXX) $(CXXFLAGS) $(LDFLAGS) -shared $(OBJS) -o $@
 	@cp --remove-destination $@ $(LIBDIR)/$@.$(APIVERSION)
 
 dist: clean
diff --git a/PLUGINS/src/osddemo/README b/PLUGINS/src/osddemo/README
index 50d36d8..90ae295 100644
--- a/PLUGINS/src/osddemo/README
+++ b/PLUGINS/src/osddemo/README
@@ -19,4 +19,11 @@ Demonstration of how a plugin can have its very own OSD setup.
 It's a very primitive game that opens a small window in which the
 user can draw lines with the Up, Down, Left and Right buttons.
 The color buttons are used to switch color.
+
+On a VDR system with TrueColor support it displays some of the
+possibilities available with the TrueColor OSD. Once the "Animation"
+pixmap is displayed, it can be moved around with the Up, Down, Left
+and Right buttons. The Red button turns off the "Tiled Pixmaps"
+display, and the Green button toggles the color display.
+
 Press Ok to close the window.
diff --git a/PLUGINS/src/osddemo/osddemo.c b/PLUGINS/src/osddemo/osddemo.c
index 2a9e09a..2e6a33b 100644
--- a/PLUGINS/src/osddemo/osddemo.c
+++ b/PLUGINS/src/osddemo/osddemo.c
@@ -3,12 +3,13 @@
  *
  * See the README file for copyright information and how to reach the author.
  *
- * $Id: osddemo.c 2.1 2008/04/13 12:59:57 kls Exp $
+ * $Id: osddemo.c 2.3 2011/02/26 12:08:13 kls Exp $
  */
 
+#include <vdr/osd.h>
 #include <vdr/plugin.h>
 
-static const char *VERSION        = "0.1.3";
+static const char *VERSION        = "0.2.0";
 static const char *DESCRIPTION    = "Demo of arbitrary OSD setup";
 static const char *MAINMENUENTRY  = "Osd Demo";
 
@@ -22,7 +23,7 @@ private:
   tColor color;
 public:
   cLineGame(void);
-  ~cLineGame();
+  virtual ~cLineGame();
   virtual void Show(void);
   virtual eOSState ProcessKey(eKeys Key);
   };
@@ -73,6 +74,366 @@ eOSState cLineGame::ProcessKey(eKeys Key)
   return state;
 }
 
+// --- cTrueColorDemo --------------------------------------------------------
+
+class cTrueColorDemo : public cOsdObject, public cThread {
+private:
+  cOsd *osd;
+  cPoint cursor;
+  cRect cursorLimits;
+  bool clockwise;
+  cPixmap *destroyablePixmap;
+  cPixmap *toggleablePixmap;
+  virtual void Action(void);
+  cPixmap *CreateTextPixmap(const char *s, int Line, int Layer, tColor ColorFg, tColor ColorBg, const cFont *Font = NULL);
+public:
+  cTrueColorDemo(void);
+  virtual ~cTrueColorDemo();
+  virtual void Show(void);
+  virtual eOSState ProcessKey(eKeys Key);
+  };
+
+cTrueColorDemo::cTrueColorDemo(void)
+{
+  osd = NULL;
+  clockwise = true;
+  destroyablePixmap = NULL;
+  toggleablePixmap = NULL;
+}
+
+cTrueColorDemo::~cTrueColorDemo()
+{
+  delete osd;
+}
+
+cPixmap *cTrueColorDemo::CreateTextPixmap(const char *s, int Line, int Layer, tColor ColorFg, tColor ColorBg, const cFont *Font)
+{
+  if (!Font)
+     Font = cFont::GetFont(fontOsd);
+  const int h = Font->Height(s);
+  int w = Font->Width(s);
+  cPixmap *Pixmap = osd->CreatePixmap(Layer, cRect((osd->Width() - w) / 2, Line, w, h));
+  if (Pixmap) {
+     Pixmap->Clear();
+     Pixmap->SetAlpha(0);
+     Pixmap->DrawText(cPoint(0, 0), s, ColorFg, ColorBg, Font);
+     }
+  return Pixmap;
+}
+
+void cTrueColorDemo::Action(void)
+{
+  cPixmap *FadeInPixmap = NULL;
+  cPixmap *FadeOutPixmap = NULL;
+  cPixmap *MovePixmap = NULL;
+  cPixmap *NextPixmap = NULL;
+  cPixmap *TilePixmap = NULL;
+  cPixmap *ScrollPixmap = NULL;
+  cPixmap *AnimPixmap = NULL;
+  int FrameTime = 40; // ms
+  int FadeTime = 1000; // ms
+  int MoveTime = 4000; // ms
+  int TileTime = 6000; // ms
+  int ScrollWaitTime = 1000; // ms
+  int ScrollLineTime = 200; // ms
+  int ScrollTotalTime = 8000; // ms
+  uint64_t Start = 0;
+  uint64_t ScrollStartTime = 0;
+  int ScrollLineNumber = 0;
+  cPoint MoveStart, MoveEnd;
+  cPoint TileStart, TileEnd;
+  cPoint ScrollStart, ScrollEnd;
+  int Line = osd->Height() / 20;
+  int StartLine = Line;
+  cPoint OldCursor;
+  int State = 0;
+  while (Running()) {
+        cPixmap::Lock();
+        bool Animated = false;
+        uint64_t Now = cTimeMs::Now();
+        if (FadeInPixmap) {
+           double t = min(double(Now - Start) / FadeTime, 1.0);
+           int Alpha = t * ALPHA_OPAQUE;
+           FadeInPixmap->SetAlpha(Alpha);
+           if (t >= 1)
+              FadeInPixmap = NULL;
+           Animated = true;
+           }
+        if (FadeOutPixmap) {
+           double t = min(double(Now - Start) / FadeTime, 1.0);
+           int Alpha = ALPHA_OPAQUE - t * ALPHA_OPAQUE;
+           FadeOutPixmap->SetAlpha(Alpha);
+           if (t >= 1)
+              FadeOutPixmap = NULL;
+           Animated = true;
+           }
+        if (MovePixmap) {
+           double t = min(double(Now - Start) / MoveTime, 1.0);
+           int x = MoveStart.X() + t * (MoveEnd.X() - MoveStart.X());
+           int y = MoveStart.Y() + t * (MoveEnd.Y() - MoveStart.Y());
+           cRect r = MovePixmap->ViewPort();
+           r.SetPoint(x, y);
+           MovePixmap->SetViewPort(r);
+           if (t >= 1)
+              MovePixmap = NULL;
+           Animated = true;
+           }
+        if (TilePixmap) {
+           double t = min(double(Now - Start) / TileTime, 1.0);
+           int x = TileStart.X() + t * (TileEnd.X() - TileStart.X());
+           int y = TileStart.Y() + t * (TileEnd.Y() - TileStart.Y());
+           TilePixmap->SetDrawPortPoint(cPoint(x, y));
+           if (t >= 1) {
+              destroyablePixmap = TilePixmap;
+              TilePixmap = NULL;
+              }
+           Animated = true;
+           }
+        if (ScrollPixmap) {
+           if (int(Now - Start) > ScrollWaitTime) {
+              if (ScrollStartTime) {
+                 double t = min(double(Now - ScrollStartTime) / ScrollLineTime, 1.0);
+                 int x = ScrollStart.X() + t * (ScrollEnd.X() - ScrollStart.X());
+                 int y = ScrollStart.Y() + t * (ScrollEnd.Y() - ScrollStart.Y());
+                 ScrollPixmap->SetDrawPortPoint(cPoint(x, y));
+                 if (t >= 1) {
+                    if (int(Now - Start) < ScrollTotalTime) {
+                       cRect r = ScrollPixmap->DrawPort();
+                       r.SetPoint(-r.X(), -r.Y());
+                       ScrollPixmap->Pan(cPoint(0, 0), r);
+                       const cFont *Font = cFont::GetFont(fontOsd);
+                       cString s = cString::sprintf("Line %d", ++ScrollLineNumber);
+                       ScrollPixmap->DrawRectangle(cRect(0, ScrollPixmap->ViewPort().Height(), ScrollPixmap->DrawPort().Width(), ScrollPixmap->DrawPort().Height()), clrTransparent);
+                       ScrollPixmap->DrawText(cPoint(0, ScrollPixmap->ViewPort().Height()), s, clrYellow, clrTransparent, Font);
+                       ScrollStartTime = Now;
+                       }
+                    else {
+                       FadeOutPixmap = ScrollPixmap;
+                       ScrollPixmap = NULL;
+                       Start = cTimeMs::Now();
+                       }
+                    }
+                 }
+              else
+                 ScrollStartTime = Now;
+              }
+           Animated = true;
+           }
+        if (AnimPixmap) {
+           int d = AnimPixmap->ViewPort().Height();
+           if (clockwise)
+              d = -d;
+           cPoint p = AnimPixmap->DrawPort().Point().Shifted(0, d);
+           if (clockwise && p.Y() <= -AnimPixmap->DrawPort().Height())
+              p.SetY(0);
+           else if (!clockwise && p.Y() > 0)
+              p.SetY(-(AnimPixmap->DrawPort().Height() - AnimPixmap->ViewPort().Height()));
+           AnimPixmap->SetDrawPortPoint(p);
+           }
+        if (!Animated) {
+           switch (State) {
+             case 0: {
+                       if (cFont *Font = cFont::CreateFont(DefaultFontOsd, osd->Height() / 10)) {
+                          FadeInPixmap = CreateTextPixmap("VDR", Line, 1, clrYellow, clrTransparent, Font);
+                          if (FadeInPixmap)
+                             Line += FadeInPixmap->DrawPort().Height();
+                          delete Font;
+                          Start = cTimeMs::Now();
+                          }
+                       State++;
+                     }
+                     break;
+             case 1: { 
+                       FadeInPixmap = CreateTextPixmap("Video Disk Recorder", Line, 3, clrYellow, clrTransparent);
+                       if (FadeInPixmap)
+                          Line += FadeInPixmap->DrawPort().Height();
+                       Start = cTimeMs::Now();
+                       State++;
+                     }
+                     break;
+             case 2: {
+                       FadeInPixmap = CreateTextPixmap("True Color OSD Demo", Line, 1, clrYellow, clrTransparent);
+                       if (FadeInPixmap)
+                          Line += FadeInPixmap->DrawPort().Height();
+                       Start = cTimeMs::Now();
+                       State++;
+                     }
+                     break;
+             case 3: {
+                       if (cFont *Font = cFont::CreateFont(DefaultFontOsd, osd->Height() / 10)) {
+                          NextPixmap = CreateTextPixmap("Millions of colors", Line, 1, clrYellow, clrTransparent, Font);
+                          if (NextPixmap) {
+                             FadeInPixmap = NextPixmap;
+                             }
+                          Start = cTimeMs::Now();
+                          StartLine = Line;
+                          Line += NextPixmap->DrawPort().Height();
+                          }
+                       State++;
+                     }
+                     break;
+             case 4: {
+                       Line += osd->Height() / 10;
+                       int w = osd->Width() / 2;
+                       int h = osd->Height() - Line - osd->Height() / 10;
+                       cImage Image(cSize(w, h));
+                       for (int y = 0; y < h; y++) {
+                           for (int x = 0; x < w; x++)
+                               Image.SetPixel(cPoint(x, y), HsvToColor(360 * double(x) / w, 1 - double(y) / h, 1) | 0xDF000000);
+                           }
+                       if (cPixmap *Pixmap = osd->CreatePixmap(2, cRect((osd->Width() - w) / 2, Line, w, h))) {
+                          Pixmap->DrawImage(cPoint(0, 0), Image);
+                          toggleablePixmap = Pixmap;
+                          }
+                       State++;
+                     }
+                     break;
+             case 5: {
+                       if (NextPixmap) {
+                          MovePixmap = NextPixmap;
+                          MoveStart = MovePixmap->ViewPort().Point();
+                          MoveEnd.Set(osd->Width() - MovePixmap->ViewPort().Width(), osd->Height() - MovePixmap->ViewPort().Height());
+                          Start = cTimeMs::Now();
+                          }
+                       State++;
+                     }
+                     break;
+             case 6: {
+                       TilePixmap = CreateTextPixmap("Tiled Pixmaps", StartLine, 1, clrRed, clrWhite);
+                       if (TilePixmap) {
+                          TilePixmap->SetViewPort(TilePixmap->ViewPort().Grown(TilePixmap->DrawPort().Width(), TilePixmap->DrawPort().Height()));
+                          TilePixmap->SetAlpha(200);
+                          TilePixmap->SetTile(true);
+                          TileStart = TilePixmap->DrawPort().Point();
+                          TileEnd = TileStart.Shifted(TilePixmap->ViewPort().Width(), TilePixmap->ViewPort().Height());
+                          MovePixmap = TilePixmap;
+                          MoveStart = MovePixmap->ViewPort().Point();
+                          MoveEnd.Set(10, osd->Height() - MovePixmap->ViewPort().Height() - 10);
+                          Start = cTimeMs::Now();
+                          }
+                       State++;
+                     }
+                     break;
+             case 7: {
+                       const cFont *Font = cFont::GetFont(fontOsd);
+                       const char *Text = "Scrolling Pixmaps";
+                       int w = Font->Width(Text);
+                       int h = Font->Height();
+                       if (cPixmap *Pixmap = osd->CreatePixmap(2, cRect((osd->Width() - w) / 2, StartLine, w, 2 * h), cRect(0, 0, w, 3 * h))) {
+                          Pixmap->Clear();
+                          Pixmap->DrawText(cPoint(0, 0), Text, clrYellow, clrTransparent, Font);
+                          cString s = cString::sprintf("Line %d", ++ScrollLineNumber);
+                          Pixmap->DrawText(cPoint(0, Pixmap->ViewPort().Height()), s, clrYellow, clrTransparent, Font);
+                          ScrollPixmap = Pixmap;
+                          ScrollStart.Set(0, 0);
+                          ScrollEnd.Set(0, -h);
+                          Start = cTimeMs::Now();
+                          }
+                       State++;
+                     }
+                     break;
+             case 8: {
+                       const cFont *Font = cFont::GetFont(fontSml);
+                       const char *Text = "Animation";
+                       const int Size = Font->Width(Text) + 10;
+                       const int NumDots = 12;
+                       const int AnimFrames = NumDots;
+                       // Temporarily using pixmap layer 0 to have the text alpha blended:
+                       AnimPixmap = osd->CreatePixmap(0, cRect((osd->Width() - Size) / 2, StartLine, Size, Size), cRect(0, 0, Size, Size * AnimFrames));
+                       if (AnimPixmap) {
+                          AnimPixmap->SetAlpha(0);
+                          AnimPixmap->Clear();
+                          const int Diameter = Size / 5;
+                          int xc = Size / 2 - Diameter / 2;
+                          for (int Frame = 0; Frame < AnimFrames; Frame++) {
+                              AnimPixmap->DrawEllipse(cRect(0, Frame * Size, Size, Size), 0xDDFFFFFF);
+                              int yc = Frame * Size + Size / 2 - Diameter / 2;
+                              int Color = 0xFF;
+                              int Delta = Color / NumDots / 3;
+                              for (int a = 0; a < NumDots; a++) {
+                                  double t = 2 * M_PI * (Frame + a) / NumDots;
+                                  int x = xc + ((Size - Diameter) / 2 - 5) * cos(t);
+                                  int y = yc + ((Size - Diameter) / 2 - 5) * sin(t);
+                                  AnimPixmap->DrawEllipse(cRect(x, y, Diameter, Diameter), ArgbToColor(0xFF, Color, Color, Color));
+                                  Color -= Delta;
+                                  }
+                              AnimPixmap->DrawText(cPoint(0, Frame * Size), Text, clrBlack, clrTransparent, cFont::GetFont(fontSml), Size, Size, taCenter);
+                              }
+                          AnimPixmap->SetLayer(3); // now setting the actual pixmap layer
+                          FadeInPixmap = AnimPixmap;
+                          LOCK_THREAD;
+                          OldCursor = cursor = AnimPixmap->ViewPort().Point();
+                          cursorLimits.Set(0, 0, osd->Width(), osd->Height());
+                          cursorLimits.SetRight(cursorLimits.Right() - Size);
+                          cursorLimits.SetBottom(cursorLimits.Bottom() - Size);
+                          cursorLimits.Grow(-10, -10);
+                          Start = cTimeMs::Now();
+                          }
+                       State++;
+                     }
+                     break;
+             case 9: {
+                       LOCK_THREAD;
+                       if (cursor != OldCursor) {
+                          MovePixmap = AnimPixmap;
+                          MoveStart = MovePixmap->ViewPort().Point();
+                          MoveEnd = OldCursor = cursor;
+                          MoveTime = 500;
+                          Start = cTimeMs::Now();
+                          }
+                     }
+                     break;
+             }
+           }
+        osd->Flush();
+        cPixmap::Unlock();
+        int Delta = cTimeMs::Now() - Now;
+        if (Delta < FrameTime)
+           cCondWait::SleepMs(FrameTime - Delta);
+        }
+}
+
+void cTrueColorDemo::Show(void)
+{
+  osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop(), 50);
+  if (osd) {
+     tArea Area = { 0, 0, cOsd::OsdWidth() - 1, cOsd::OsdHeight() - 1,  32 };
+     if (osd->SetAreas(&Area, 1) == oeOk) {
+        osd->DrawRectangle(0, 0, osd->Width() -1 , osd->Height() - 1, clrGray50);
+        osd->Flush();
+        Start();
+        }
+     }
+}
+
+eOSState cTrueColorDemo::ProcessKey(eKeys Key)
+{
+  eOSState state = cOsdObject::ProcessKey(Key);
+  if (state == osUnknown) {
+     LOCK_PIXMAPS;
+     LOCK_THREAD;
+     const int d = 80;
+     switch (Key & ~k_Repeat) {
+       case kUp:     cursor.SetY(max(cursorLimits.Top(),    cursor.Y() - d)); clockwise = false; break;
+       case kDown:   cursor.SetY(min(cursorLimits.Bottom(), cursor.Y() + d)); clockwise = true; break;
+       case kLeft:   cursor.SetX(max(cursorLimits.Left(),   cursor.X() - d)); clockwise = false; break;
+       case kRight:  cursor.SetX(min(cursorLimits.Right(),  cursor.X() + d)); clockwise = true; break;
+       case kRed:    if (destroyablePixmap) {
+                        osd->DestroyPixmap(destroyablePixmap);
+                        destroyablePixmap = NULL;
+                        }
+                     break;
+       case kGreen:  if (toggleablePixmap)
+                        toggleablePixmap->SetLayer(-toggleablePixmap->Layer());
+                     break;
+       case kOk:     return osEnd;
+       default: return state;
+       }
+     state = osContinue;
+     }
+  return state;
+}
+
 // --- cPluginOsddemo --------------------------------------------------------
 
 class cPluginOsddemo : public cPlugin {
@@ -131,6 +492,8 @@ void cPluginOsddemo::Housekeeping(void)
 cOsdObject *cPluginOsddemo::MainMenuAction(void)
 {
   // Perform the action when selected from the main VDR menu.
+  if (cOsdProvider::SupportsTrueColor())
+     return new cTrueColorDemo;
   return new cLineGame;
 }