osd.h

Go to the documentation of this file.

/*
 * osd.h: Abstract On Screen Display layer
 *
 * See the main source file 'vdr.c' for copyright information and
 * how to reach the author.
 *
 * $Id: osd.h 5.4 2026/03/12 10:44:34 kls Exp $
 */
 
#ifndef __OSD_H
#define __OSD_H
 
#include <limits.h>
#include <stdio.h>
#include <stdint.h>
#include "config.h"
#include "font.h"
#include "thread.h"
#include "tools.h"
 
#define OSD_LEVEL_DEFAULT     0
#define OSD_LEVEL_SUBTITLES  10
 
#define MAXNUMCOLORS 256
#define ALPHA_TRANSPARENT  0x00
#define ALPHA_OPAQUE       0xFF
#define IS_OPAQUE(c)       ((c >> 24) == ALPHA_OPAQUE)
#define TEXT_ALIGN_BORDER  10 // fraction of the font height used for sizing border
 
enum {
                   //AARRGGBB
  clrTransparent = 0x00000000, // not drawn if used as background color in DrawText()
  clrTranslucent = 0x00000001, // always drawn, even as background color in DrawText()
  clrGray50      = 0x7F000000, // 50% gray
  clrBlack       = 0xFF000000,
  clrRed         = 0xFFFC1414,
  clrGreen       = 0xFF24FC24,
  clrYellow      = 0xFFFCC024,
  clrMagenta     = 0xFFB000FC,
  clrBlue        = 0xFF0000FC,
  clrCyan        = 0xFF00FCFC,
  clrWhite       = 0xFFFCFCFC,
  };
 
enum eOsdError { oeOk, // see also OsdErrorTexts in osd.c
                 oeTooManyAreas,
                 oeTooManyColors,
                 oeBppNotSupported,
                 oeAreasOverlap,
                 oeWrongAlignment,
                 oeOutOfMemory,
                 oeWrongAreaSize,
                 oeUnknown,
               };
 
typedef uint32_t tColor; // see also font.h
typedef uint8_t tIndex;
 
inline tColor ArgbToColor(uint8_t A, uint8_t R, uint8_t G, uint8_t B)
{
  return (tColor(A) << 24) | (tColor(R) << 16) | (tColor(G) << 8) | B;
}
 
inline tColor RgbToColor(uint8_t R, uint8_t G, uint8_t B)
{
  return (tColor(R) << 16) | (tColor(G) << 8) | B;
}
 
inline tColor RgbToColor(double R, double G, double B)
{
  return RgbToColor(uint8_t(0xFF * R), uint8_t(0xFF * G), uint8_t(0xFF * B));
}
 
tColor RgbShade(tColor Color, double Factor);
 
tColor HsvToColor(double H, double S, double V);
 
tColor AlphaBlend(tColor ColorFg, tColor ColorBg, uint8_t AlphaLayer = ALPHA_OPAQUE);
 
class cPalette {
private:
  tColor color[MAXNUMCOLORS];
  int bpp;
  int maxColors, numColors;
  bool modified;
  double antiAliasGranularity;
protected:
  typedef tIndex tIndexes[MAXNUMCOLORS];
public:
  cPalette(int Bpp = 8);
  virtual ~cPalette();
  void SetAntiAliasGranularity(uint FixedColors, uint BlendColors);
  int Bpp(void) const { return bpp; }
  void Reset(void);
  int Index(tColor Color);
  tColor Color(int Index) const { return Index < maxColors ? color[Index] : 0; }
  void SetBpp(int Bpp);
  void SetColor(int Index, tColor Color);
  const tColor *Colors(int &NumColors) const;
  void Take(const cPalette &Palette, tIndexes *Indexes = NULL, tColor ColorFg = 0, tColor ColorBg = 0);
  void Replace(const cPalette &Palette);
  tColor Blend(tColor ColorFg, tColor ColorBg, uint8_t Level) const;
  int ClosestColor(tColor Color, int MaxDiff = INT_MAX) const;
  };
 
enum eTextAlignment { taCenter  = 0x00,
                      taLeft    = 0x01,
                      taRight   = 0x02,
                      taTop     = 0x04,
                      taBottom  = 0x08,
                      taBorder  = 0x10, // keeps some distance from the left or right alignment edge
                      taDefault = taTop | taLeft
                    };
 
class cFont;
 
class cBitmap : public cPalette {
private:
  tIndex *bitmap;
  int x0, y0;
  int width, height;
  int dirtyX1, dirtyY1, dirtyX2, dirtyY2;
public:
  cBitmap(int Width, int Height, int Bpp, int X0 = 0, int Y0 = 0);
  cBitmap(const char *FileName);
  cBitmap(const char *const Xpm[]);
  virtual ~cBitmap() override;
  int X0(void) const { return x0; }
  int Y0(void) const { return y0; }
  int Width(void) const { return width; }
  int Height(void) const { return height; }
  void SetSize(int Width, int Height);
  void SetOffset(int X0, int Y0) { x0 = X0; y0 = Y0; }
  bool Contains(int x, int y) const;
  bool Covers(int x1, int y1, int x2, int y2) const;
  bool Intersects(int x1, int y1, int x2, int y2) const;
  bool Dirty(int &x1, int &y1, int &x2, int &y2);
  void Clean(void);
  bool LoadXpm(const char *FileName);
  bool SetXpm(const char *const Xpm[], bool IgnoreNone = false);
  void SetIndex(int x, int y, tIndex Index);
  void Fill(tIndex Index);
  void DrawPixel(int x, int y, tColor Color);
  void DrawBitmap(int x, int y, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool ReplacePalette = false, bool Overlay = false);
  void DrawText(int x, int y, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault);
  void DrawRectangle(int x1, int y1, int x2, int y2, tColor Color);
  void DrawEllipse(int x1, int y1, int x2, int y2, tColor Color, int Quadrants = 0);
  void DrawSlope(int x1, int y1, int x2, int y2, tColor Color, int Type);
  const tIndex *Data(int x, int y) const;
  tColor GetColor(int x, int y) const { return Color(*Data(x, y)); }
  void ReduceBpp(const cPalette &Palette);
  void ShrinkBpp(int NewBpp);
  cBitmap *Scaled(double FactorX, double FactorY, bool AntiAlias = false) const;
  };
 
struct tArea {
  int x1, y1, x2, y2;
  int bpp;
  int Width(void) const { return x2 - x1 + 1; }
  int Height(void) const { return y2 - y1 + 1; }
  bool Intersects(const tArea &Area) const { return !(x2 < Area.x1 || x1 > Area.x2 || y2 < Area.y1 || y1 > Area.y2); }
  };
 
class cPoint {
private:
  int x;
  int y;
public:
  cPoint(void) { x = y = 0; }
  cPoint(int X, int Y) { x = X; y = Y; }
  cPoint(const cPoint &Point) { x = Point.X(); y = Point.Y(); }
  bool operator==(const cPoint &Point) const { return x == Point.X() && y == Point.Y(); }
  bool operator!=(const cPoint &Point) const { return !(*this == Point); }
  cPoint operator-(void) const { return cPoint(-x, -y); }
  cPoint operator-(const cPoint &Point) const { return cPoint(x - Point.X(), y - Point.Y()); }
  int X(void) const { return x; }
  int Y(void) const { return y; }
  void SetX(int X) { x = X; }
  void SetY(int Y) { y = Y; }
  void Set(int X, int Y) { x = X; y = Y; }
  void Set(const cPoint &Point) { x = Point.X(); y = Point.Y(); }
  void Shift(int Dx, int Dy) { x += Dx; y += Dy; }
  void Shift(const cPoint &Dp) { x += Dp.X(); y += Dp.Y(); }
  cPoint Shifted(int Dx, int Dy) const { cPoint p(*this); p.Shift(Dx, Dy); return p; }
  cPoint Shifted(const cPoint &Dp) const { cPoint p(*this); p.Shift(Dp); return p; }
  };
 
class cSize {
private:
  int width;
  int height;
public:
  cSize(void) { width = height = 0; }
  cSize(int Width, int Height) { width = Width; height = Height; }
  cSize(const cSize &Size) { width = Size.Width(); height = Size.Height(); }
  bool operator==(const cSize &Size) const { return width == Size.Width() && height == Size.Height(); }
  bool operator!=(const cSize &Size) const { return !(*this == Size); }
  bool operator<(const cSize &Size) const { return width < Size.Width() && height < Size.Height(); }
  int Width(void) const { return width; }
  int Height(void) const { return height; }
  void SetWidth(int Width) { width = Width; }
  void SetHeight(int Height) { height = Height; }
  void Set(int Width, int Height) { width = Width; height = Height; }
  void Set(const cSize &Size) { width = Size.Width(); height = Size.Height(); }
  bool Contains(const cPoint &Point) const { return 0 <= Point.X() && 0 <= Point.Y() && Point.X() < width && Point.Y() < height; }
  void Grow(int Dw, int Dh) { width += 2 * Dw; height += 2 * Dh; }
  cSize Grown(int Dw, int Dh) const { cSize s(*this); s.Grow(Dw, Dh); return s; }
  };
 
class cRect {
private:
  cPoint point;
  cSize size;
public:
  static const cRect Null;
  cRect(void): point(0, 0), size(0, 0) {}
  cRect(int X, int Y, int Width, int Height): point(X, Y), size(Width, Height) {}
  cRect(const cPoint &Point, const cSize &Size): point(Point), size(Size) {}
  cRect(const cSize &Size): point(0, 0), size(Size) {}
  cRect(const cRect &Rect): point(Rect.Point()), size(Rect.Size()) {}
  bool operator==(const cRect &Rect) const { return point == Rect.Point() && size == Rect.Size(); }
  bool operator!=(const cRect &Rect) const { return !(*this == Rect); }
  int X(void) const { return point.X(); }
  int Y(void) const { return point.Y(); }
  int Width(void) const { return size.Width(); }
  int Height(void) const { return size.Height(); }
  int Left(void) const { return X(); }
  int Top(void) const { return Y(); }
  int Right(void) const { return X() + Width() - 1; }
  int Bottom(void) const { return Y() + Height() - 1; }
  const cPoint &Point(void) const { return point; }
  const cSize &Size(void) const { return size; }
  void Set(int X, int Y, int Width, int Height) { point.Set(X, Y); size.Set(Width, Height); }
  void Set(cPoint Point, cSize Size) { point.Set(Point); size.Set(Size); }
  void SetPoint(int X, int Y) { point.Set(X, Y); }
  void SetPoint(const cPoint &Point) { point.Set(Point); }
  void SetSize(int Width, int Height) { size.Set(Width, Height); }
  void SetSize(const cSize &Size) { size.Set(Size); }
  void SetX(int X) { point.SetX(X); }
  void SetY(int Y) { point.SetY(Y); }
  void SetWidth(int Width) { size.SetWidth(Width); }
  void SetHeight(int Height) { size.SetHeight(Height); }
  void SetLeft(int Left) { SetWidth(Width() + X() - Left); SetX(Left); }
  void SetTop(int Top) { SetHeight(Height() + Y() - Top); SetY(Top); }
  void SetRight(int Right) { SetWidth(Right - X() + 1); }
  void SetBottom(int Bottom) { SetHeight(Bottom - Y() + 1); }
  void Shift(int Dx, int Dy) { point.Shift(Dx, Dy); }
  void Shift(const cPoint &Dp) { point.Shift(Dp); }
  cRect Shifted(int Dx, int Dy) const { cRect r(*this); r.Shift(Dx, Dy); return r; }
  cRect Shifted(const cPoint &Dp) const { cRect r(*this); r.Shift(Dp); return r; }
  void Grow(int Dx, int Dy);
  cRect Grown(int Dw, int Dh) const { cRect r(*this); r.Grow(Dw, Dh); return r; }
  bool Contains(const cPoint &Point) const;
  bool Contains(const cRect &Rect) const;
  bool Intersects(const cRect &Rect) const;
  cRect Intersected(const cRect &Rect) const;
  void Combine(const cRect &Rect);
  cRect Combined(const cRect &Rect) const { cRect r(*this); r.Combine(Rect); return r; }
  void Combine(const cPoint &Point);
  cRect Combined(const cPoint &Point) const { cRect r(*this); r.Combine(Point); return r; }
  bool IsEmpty(void) const { return Width() <= 0 || Height() <= 0; }
  };
 
class cImage {
private:
  cSize size;
  tColor *data;
public:
  cImage(void);
  cImage(const cImage &Image);
  cImage(const cSize &Size, const tColor *Data = NULL);
  virtual ~cImage();
  const cSize &Size(void) const { return size; }
  int Width(void) const { return size.Width(); }
  int Height(void) const { return size.Height(); }
  const tColor *Data(void) const { return data; }
  tColor GetPixel(const cPoint &Point) const { return data[size.Width() * Point.Y() + Point.X()]; }
  void SetPixel(const cPoint &Point, tColor Color) { data[size.Width() * Point.Y() + Point.X()] = Color; }
  void Clear(void);
  void Fill(tColor Color);
  cImage *Scaled(double FactorX, double FactorY, bool AntiAlias = false) const;
  };
 
#define MAXPIXMAPLAYERS    8
 
class cPixmap {
  friend class cOsd;
  friend class cPixmapMutexLock;
private:
  static cMutex mutex;
  int layer;
  int alpha;
  bool tile;
  cRect viewPort;
  cRect drawPort;
  cRect dirtyViewPort;
  cRect dirtyDrawPort;
protected:
  virtual ~cPixmap() {}
  void MarkViewPortDirty(const cRect &Rect);
  void MarkViewPortDirty(const cPoint &Point);
  void MarkDrawPortDirty(const cRect &Rect);
  void MarkDrawPortDirty(const cPoint &Point);
  void SetClean(void);
  virtual void DrawPixmap(const cPixmap *Pixmap, const cRect &Dirty);
public:
  cPixmap(void);
  cPixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
  static void Lock(void) { mutex.Lock(); }
  static void Unlock(void) { mutex.Unlock(); }
  int Layer(void) const { return layer; }
  int Alpha(void) const { return alpha; }
  bool Tile(void) const { return tile; }
  const cRect &ViewPort(void) const { return viewPort; }
  const cRect &DrawPort(void) const { return drawPort; }
  const cRect &DirtyViewPort(void) const { return dirtyViewPort; }
  const cRect &DirtyDrawPort(void) const { return dirtyDrawPort; }
  virtual void SetLayer(int Layer);
  virtual void SetAlpha(int Alpha);
  virtual void SetTile(bool Tile);
  virtual void SetViewPort(const cRect &Rect);
  virtual void SetDrawPortPoint(const cPoint &Point, bool Dirty = true);
  virtual void Clear(void) = 0;
  virtual void Fill(tColor Color) = 0;
  virtual void DrawImage(const cPoint &Point, const cImage &Image) = 0;
  virtual void DrawImage(const cPoint &Point, int ImageHandle) = 0;
  virtual void DrawScaledImage(const cPoint &Point, const cImage &Image, double FactorX, double FactorY, bool AntiAlias = false) {};
  virtual void DrawScaledImage(const cPoint &Point, int ImageHandle, double FactorX, double FactorY, bool AntiAlias = false) {};
  virtual void DrawPixel(const cPoint &Point, tColor Color) = 0;
  virtual void DrawBlendedPixel(const cPoint &Point, tColor Color, uint8_t AlphaLayer = ALPHA_OPAQUE) { DrawPixel(Point, Color); }
  virtual void DrawBitmap(const cPoint &Point, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool Overlay = false) = 0;
  virtual void DrawText(const cPoint &Point, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault) = 0;
  virtual void DrawRectangle(const cRect &Rect, tColor Color) = 0;
  virtual void DrawEllipse(const cRect &Rect, tColor Color, int Quadrants = 0) = 0;
  virtual void DrawSlope(const cRect &Rect, tColor Color, int Type) = 0;
  virtual void Render(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) = 0;
  virtual void Copy(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) = 0;
  virtual void Scroll(const cPoint &Dest, const cRect &Source = cRect::Null) = 0;
  virtual void Pan(const cPoint &Dest, const cRect &Source = cRect::Null) = 0;
  };
 
class cPixmapMutexLock : public cMutexLock {
public:
  cPixmapMutexLock(void): cMutexLock(&cPixmap::mutex) {}
  };
 
#define LOCK_PIXMAPS cPixmapMutexLock PixmapMutexLock
 
// cPixmapMemory is an implementation of cPixmap that uses an array of tColor
// values to store the pixmap.
 
class cPixmapMemory : public cPixmap {
private:
  tColor *data;
  bool panning;
public:
  cPixmapMemory(void);
  cPixmapMemory(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
  virtual ~cPixmapMemory() override;
  const uint8_t *Data(void) { return (uint8_t *)data; }
  virtual void Clear(void) override;
  virtual void Fill(tColor Color) override;
  virtual void DrawImage(const cPoint &Point, const cImage &Image) override;
  virtual void DrawImage(const cPoint &Point, int ImageHandle) override;
  virtual void DrawScaledImage(const cPoint &Point, const cImage &Image, double FactorX, double FactorY, bool AntiAlias = false) override;
  virtual void DrawScaledImage(const cPoint &Point, int ImageHandle, double FactorX, double FactorY, bool AntiAlias = false) override;
  virtual void DrawPixel(const cPoint &Point, tColor Color) override;
  virtual void DrawBlendedPixel(const cPoint &Point, tColor Color, uint8_t AlphaLayer = ALPHA_OPAQUE) override;
  virtual void DrawBitmap(const cPoint &Point, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool Overlay = false) override;
  virtual void DrawText(const cPoint &Point, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault) override;
  virtual void DrawRectangle(const cRect &Rect, tColor Color) override;
  virtual void DrawEllipse(const cRect &Rect, tColor Color, int Quadrants = 0) override;
  virtual void DrawSlope(const cRect &Rect, tColor Color, int Type) override;
  virtual void Render(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) override;
  virtual void Copy(const cPixmap *Pixmap, const cRect &Source, const cPoint &Dest) override;
  virtual void Scroll(const cPoint &Dest, const cRect &Source = cRect::Null) override;
  virtual void Pan(const cPoint &Dest, const cRect &Source = cRect::Null) override;
  };
 
#define MAXOSDAREAS 16

 
class cOsd {
  friend class cOsdProvider;
private:
  static int osdLeft, osdTop, osdWidth, osdHeight;
  static cVector<cOsd *> Osds;
  static cSize maxPixmapSize;
  static cMutex mutex;
  bool isTrueColor;
  cBitmap *savedBitmap;
  cBitmap *bitmaps[MAXOSDAREAS];
  int numBitmaps;
  cPixmapMemory *savedPixmap;
  cVector<cPixmap *> pixmaps;
  int left, top, width, height;
  uint level;
  bool active;
protected:
  cOsd(int Left, int Top, uint Level);
  bool Active(void) { return active; }
  virtual void SetActive(bool On) { active = On; }
  cPixmap *AddPixmap(cPixmap *Pixmap);
  cPixmap *RenderPixmaps(void);
  cBitmap *GetBitmap(int Area);
public:
  virtual ~cOsd();
  static int OsdLeft(void) { return osdLeft ? osdLeft : Setup.OSDLeft; }
  static int OsdTop(void) { return osdTop ? osdTop : Setup.OSDTop; }
  static int OsdWidth(void) { return osdWidth ? osdWidth : Setup.OSDWidth; }
  static int OsdHeight(void) { return osdHeight ? osdHeight : Setup.OSDHeight; }
  static void SetOsdPosition(int Left, int Top, int Width, int Height);
  static int IsOpen(void) { return Osds.Size() && Osds[0]->level == OSD_LEVEL_DEFAULT; }
  bool IsTrueColor(void) const { return isTrueColor; }
  int Left(void) { return left; }
  int Top(void) { return top; }
  int Width(void) { return width; }
  int Height(void) { return height; }
  void SetAntiAliasGranularity(uint FixedColors, uint BlendColors);
  virtual const cSize &MaxPixmapSize(void) const;
  virtual cPixmap *CreatePixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
  virtual void DestroyPixmap(cPixmap *Pixmap);
  virtual void DrawImage(const cPoint &Point, const cImage &Image);
  virtual void DrawImage(const cPoint &Point, int ImageHandle);
  virtual void DrawScaledImage(const cPoint &Point, const cImage &Image, double FactorX, double FactorY, bool AntiAlias = false);
  virtual void DrawScaledImage(const cPoint &Point, int ImageHandle, double FactorX, double FactorY, bool AntiAlias = false);
  virtual eOsdError CanHandleAreas(const tArea *Areas, int NumAreas);
  virtual eOsdError SetAreas(const tArea *Areas, int NumAreas);
  virtual void SaveRegion(int x1, int y1, int x2, int y2);
  virtual void RestoreRegion(void);
  virtual eOsdError SetPalette(const cPalette &Palette, int Area);
  virtual void DrawPixel(int x, int y, tColor Color);
  virtual void DrawBitmap(int x, int y, const cBitmap &Bitmap, tColor ColorFg = 0, tColor ColorBg = 0, bool ReplacePalette = false, bool Overlay = false);
  virtual void DrawScaledBitmap(int x, int y, const cBitmap &Bitmap, double FactorX, double FactorY, bool AntiAlias = false);
  virtual void DrawText(int x, int y, const char *s, tColor ColorFg, tColor ColorBg, const cFont *Font, int Width = 0, int Height = 0, int Alignment = taDefault);
  virtual void DrawRectangle(int x1, int y1, int x2, int y2, tColor Color);
  virtual void DrawEllipse(int x1, int y1, int x2, int y2, tColor Color, int Quadrants = 0);
  virtual void DrawSlope(int x1, int y1, int x2, int y2, tColor Color, int Type);
  virtual void Flush(void);
  };
 
#define MAXOSDIMAGES 64
 
class cOsdProvider {
  friend class cPixmapMemory;
private:
  static cOsdProvider *osdProvider;
  static int oldWidth;
  static int oldHeight;
  static double oldAspect;
  static cImage *images[MAXOSDIMAGES];
  static int osdState;
protected:
  virtual cOsd *CreateOsd(int Left, int Top, uint Level) = 0;
  virtual bool ProvidesTrueColor(void) { return false; }
  virtual int StoreImageData(const cImage &Image);
  virtual void DropImageData(int ImageHandle);
  static const cImage *GetImageData(int ImageHandle);
public:
  cOsdProvider(void);
      //XXX maybe parameter to make this one "sticky"??? (frame-buffer etc.)
  virtual ~cOsdProvider();
  static cOsd *NewOsd(int Left, int Top, uint Level = OSD_LEVEL_DEFAULT);
  static void UpdateOsdSize(bool Force = false);
  static bool OsdSizeChanged(int &State);
  static bool SupportsTrueColor(void);
  static int StoreImage(const cImage &Image);
  static void DropImage(int ImageHandle);
  static void Shutdown(void);
  };
 
class cTextScroller {
private:
  cOsd *osd;
  int left, top, width, height;
  const cFont *font;
  tColor colorFg, colorBg;
  int offset, shown;
  cTextWrapper textWrapper;
  void DrawText(void);
public:
  cTextScroller(void);
  cTextScroller(cOsd *Osd, int Left, int Top, int Width, int Height, const char *Text, const cFont *Font, tColor ColorFg, tColor ColorBg);
  void Set(cOsd *Osd, int Left, int Top, int Width, int Height, const char *Text, const cFont *Font, tColor ColorFg, tColor ColorBg);
  void Reset(void);
  int Left(void) { return left; }
  int Top(void) { return top; }
  int Width(void) { return width; }
  int Height(void) { return height; }
  int Total(void) { return textWrapper.Lines(); }
  int Offset(void) { return offset; }
  int Shown(void) { return shown; }
  bool CanScroll(void) { return CanScrollUp() || CanScrollDown(); }
  bool CanScrollUp(void) { return offset > 0; }
  bool CanScrollDown(void) { return offset + shown < Total(); }
  void Scroll(bool Up, bool Page);
  };
 
#endif //__OSD_H