mirror of
https://github.com/vdr-projects/vdr.git
synced 2025-03-01 10:50:46 +00:00
5619c0602b
- 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.
1240 lines
48 KiB
C
1240 lines
48 KiB
C
/*
|
|
* skinsttng.c: A VDR skin with ST:TNG Panels
|
|
*
|
|
* See the main source file 'vdr.c' for copyright information and
|
|
* how to reach the author.
|
|
*
|
|
* $Id: skinsttng.c 2.7 2011/02/20 13:02:49 kls Exp $
|
|
*/
|
|
|
|
// Star Trek: The Next Generation® is a registered trademark of Paramount Pictures
|
|
// registered in the United States Patent and Trademark Office.
|
|
// No infringement intended.
|
|
|
|
#include "skinsttng.h"
|
|
#include "font.h"
|
|
#include "osd.h"
|
|
#include "menu.h"
|
|
#include "themes.h"
|
|
|
|
#include "symbols/arrowdown.xpm"
|
|
#include "symbols/arrowup.xpm"
|
|
#include "symbols/audio.xpm"
|
|
#include "symbols/audioleft.xpm"
|
|
#include "symbols/audioright.xpm"
|
|
#include "symbols/audiostereo.xpm"
|
|
#include "symbols/dolbydigital.xpm"
|
|
#include "symbols/encrypted.xpm"
|
|
#include "symbols/ffwd.xpm"
|
|
#include "symbols/ffwd1.xpm"
|
|
#include "symbols/ffwd2.xpm"
|
|
#include "symbols/ffwd3.xpm"
|
|
#include "symbols/frew.xpm"
|
|
#include "symbols/frew1.xpm"
|
|
#include "symbols/frew2.xpm"
|
|
#include "symbols/frew3.xpm"
|
|
#include "symbols/mute.xpm"
|
|
#include "symbols/pause.xpm"
|
|
#include "symbols/play.xpm"
|
|
#include "symbols/radio.xpm"
|
|
#include "symbols/recording.xpm"
|
|
#include "symbols/sfwd.xpm"
|
|
#include "symbols/sfwd1.xpm"
|
|
#include "symbols/sfwd2.xpm"
|
|
#include "symbols/sfwd3.xpm"
|
|
#include "symbols/srew.xpm"
|
|
#include "symbols/srew1.xpm"
|
|
#include "symbols/srew2.xpm"
|
|
#include "symbols/srew3.xpm"
|
|
#include "symbols/teletext.xpm"
|
|
#include "symbols/volume.xpm"
|
|
|
|
#define Roundness (Setup.FontOsdSize / 2)
|
|
#define Gap (Setup.FontOsdSize / 5)
|
|
#define ScrollWidth (Setup.FontOsdSize / 4)
|
|
#define TextFrame (Setup.FontOsdSize / 10)
|
|
#define TextSpacing (Setup.FontOsdSize / 4)
|
|
#define SymbolSpacing (Setup.FontOsdSize / 4)
|
|
|
|
static cTheme Theme;
|
|
|
|
THEME_CLR(Theme, clrBackground, clrGray50);
|
|
THEME_CLR(Theme, clrButtonRedFg, clrWhite);
|
|
THEME_CLR(Theme, clrButtonRedBg, clrRed);
|
|
THEME_CLR(Theme, clrButtonGreenFg, clrBlack);
|
|
THEME_CLR(Theme, clrButtonGreenBg, clrGreen);
|
|
THEME_CLR(Theme, clrButtonYellowFg, clrBlack);
|
|
THEME_CLR(Theme, clrButtonYellowBg, clrYellow);
|
|
THEME_CLR(Theme, clrButtonBlueFg, clrWhite);
|
|
THEME_CLR(Theme, clrButtonBlueBg, clrBlue);
|
|
THEME_CLR(Theme, clrMessageFrame, clrYellow);
|
|
THEME_CLR(Theme, clrMessageStatusFg, clrBlack);
|
|
THEME_CLR(Theme, clrMessageStatusBg, clrCyan);
|
|
THEME_CLR(Theme, clrMessageInfoFg, clrBlack);
|
|
THEME_CLR(Theme, clrMessageInfoBg, clrGreen);
|
|
THEME_CLR(Theme, clrMessageWarningFg, clrBlack);
|
|
THEME_CLR(Theme, clrMessageWarningBg, clrYellow);
|
|
THEME_CLR(Theme, clrMessageErrorFg, clrWhite);
|
|
THEME_CLR(Theme, clrMessageErrorBg, clrRed);
|
|
THEME_CLR(Theme, clrVolumeFrame, clrYellow);
|
|
THEME_CLR(Theme, clrVolumeSymbol, clrBlack);
|
|
THEME_CLR(Theme, clrVolumeBarUpper, 0xFFBC8024);
|
|
THEME_CLR(Theme, clrVolumeBarLower, 0xFF248024);
|
|
THEME_CLR(Theme, clrChannelFrame, clrYellow);
|
|
THEME_CLR(Theme, clrChannelName, clrBlack);
|
|
THEME_CLR(Theme, clrChannelDate, clrBlack);
|
|
THEME_CLR(Theme, clrChannelSymbolOn, clrBlack);
|
|
THEME_CLR(Theme, clrChannelSymbolOff, 0xFFBC8024);
|
|
THEME_CLR(Theme, clrChannelSymbolRecFg, clrWhite);
|
|
THEME_CLR(Theme, clrChannelSymbolRecBg, clrRed);
|
|
THEME_CLR(Theme, clrChannelEpgTime, clrBlack);
|
|
THEME_CLR(Theme, clrChannelEpgTitle, clrCyan);
|
|
THEME_CLR(Theme, clrChannelEpgShortText, clrYellow);
|
|
THEME_CLR(Theme, clrChannelTimebarSeen, clrYellow);
|
|
THEME_CLR(Theme, clrChannelTimebarRest, clrGray50);
|
|
THEME_CLR(Theme, clrMenuFrame, clrYellow);
|
|
THEME_CLR(Theme, clrMenuTitle, clrBlack);
|
|
THEME_CLR(Theme, clrMenuDate, clrBlack);
|
|
THEME_CLR(Theme, clrMenuItemCurrentFg, clrBlack);
|
|
THEME_CLR(Theme, clrMenuItemCurrentBg, clrYellow);
|
|
THEME_CLR(Theme, clrMenuItemSelectable, clrYellow);
|
|
THEME_CLR(Theme, clrMenuItemNonSelectable, clrCyan);
|
|
THEME_CLR(Theme, clrMenuEventTime, clrYellow);
|
|
THEME_CLR(Theme, clrMenuEventVps, clrBlack);
|
|
THEME_CLR(Theme, clrMenuEventTitle, clrCyan);
|
|
THEME_CLR(Theme, clrMenuEventShortText, clrYellow);
|
|
THEME_CLR(Theme, clrMenuEventDescription, clrCyan);
|
|
THEME_CLR(Theme, clrMenuScrollbarTotal, clrYellow);
|
|
THEME_CLR(Theme, clrMenuScrollbarShown, clrCyan);
|
|
THEME_CLR(Theme, clrMenuScrollbarArrow, clrBlack);
|
|
THEME_CLR(Theme, clrMenuText, clrCyan);
|
|
THEME_CLR(Theme, clrReplayFrame, clrYellow);
|
|
THEME_CLR(Theme, clrReplayTitle, clrBlack);
|
|
THEME_CLR(Theme, clrReplayMode, clrBlack);
|
|
THEME_CLR(Theme, clrReplayCurrent, clrBlack);
|
|
THEME_CLR(Theme, clrReplayTotal, clrBlack);
|
|
THEME_CLR(Theme, clrReplayJump, clrBlack);
|
|
THEME_CLR(Theme, clrReplayProgressSeen, clrGreen);
|
|
THEME_CLR(Theme, clrReplayProgressRest, clrWhite);
|
|
THEME_CLR(Theme, clrReplayProgressSelected, clrRed);
|
|
THEME_CLR(Theme, clrReplayProgressMark, clrBlack);
|
|
THEME_CLR(Theme, clrReplayProgressCurrent, clrRed);
|
|
|
|
// --- cSkinSTTNGDisplayChannel ----------------------------------------------
|
|
|
|
class cSkinSTTNGDisplayChannel : public cSkinDisplayChannel {
|
|
private:
|
|
cOsd *osd;
|
|
int x0, x1, x2, x3, x4, x5, x6, x7;
|
|
int y0, y1, y2, y3, y4, y5, y6, y7;
|
|
bool withInfo;
|
|
int lineHeight;
|
|
tColor frameColor;
|
|
bool message;
|
|
const cEvent *present;
|
|
cString lastDate;
|
|
int lastSeen;
|
|
tTrackId lastTrackId;
|
|
static cBitmap bmTeletext, bmRadio, bmAudio, bmDolbyDigital, bmEncrypted, bmRecording;
|
|
public:
|
|
cSkinSTTNGDisplayChannel(bool WithInfo);
|
|
virtual ~cSkinSTTNGDisplayChannel();
|
|
virtual void SetChannel(const cChannel *Channel, int Number);
|
|
virtual void SetEvents(const cEvent *Present, const cEvent *Following);
|
|
virtual void SetMessage(eMessageType Type, const char *Text);
|
|
virtual void Flush(void);
|
|
};
|
|
|
|
cBitmap cSkinSTTNGDisplayChannel::bmTeletext(teletext_xpm);
|
|
cBitmap cSkinSTTNGDisplayChannel::bmRadio(radio_xpm);
|
|
cBitmap cSkinSTTNGDisplayChannel::bmAudio(audio_xpm);
|
|
cBitmap cSkinSTTNGDisplayChannel::bmDolbyDigital(dolbydigital_xpm);
|
|
cBitmap cSkinSTTNGDisplayChannel::bmEncrypted(encrypted_xpm);
|
|
cBitmap cSkinSTTNGDisplayChannel::bmRecording(recording_xpm);
|
|
|
|
cSkinSTTNGDisplayChannel::cSkinSTTNGDisplayChannel(bool WithInfo)
|
|
{
|
|
present = NULL;
|
|
lastSeen = -1;
|
|
memset(&lastTrackId, 0, sizeof(lastTrackId));
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
withInfo = WithInfo;
|
|
lineHeight = font->Height();
|
|
frameColor = Theme.Color(clrChannelFrame);
|
|
message = false;
|
|
if (withInfo) {
|
|
x0 = 0;
|
|
x1 = x0 + font->Width("00:00") + 2 * TextFrame;
|
|
x2 = x1 + Roundness;
|
|
x3 = x2 + Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x5 = x6 - lineHeight / 2;
|
|
x4 = x5 - Gap;
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
y2 = y1 + Roundness;
|
|
y3 = y2 + Gap;
|
|
y4 = y3 + 4 * lineHeight;
|
|
y5 = y4 + Gap;
|
|
y6 = y5 + Roundness;
|
|
y7 = y6 + cFont::GetFont(fontSml)->Height();
|
|
int yt = (y0 + y1) / 2;
|
|
int yb = (y6 + y7) / 2;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop() + (Setup.ChannelInfoPos ? 0 : cOsd::OsdHeight() - y7));
|
|
tArea Areas[] = { { 0, 0, x7 - 1, y7 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { 0, 0, x7 - 1, y7 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { 0, 0, x7 - 1, y7 - 1, 4 } }; // 16 colors
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y7 - 1, Theme.Color(clrBackground));
|
|
osd->DrawRectangle(x0, y0, x1 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawRectangle(x0, y6, x1 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, y0, x7 - 1, yt - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, yb, x7 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 2);
|
|
osd->DrawRectangle(x1, y0, x4 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
osd->DrawRectangle(x0, y1, x1 - 1, y2 - 1, frameColor);
|
|
osd->DrawEllipse (x1, y1, x2 - 1, y2 - 1, frameColor, -2);
|
|
osd->DrawRectangle(x0, y3, x1 - 1, y4 - 1, frameColor);
|
|
osd->DrawRectangle(x0, y5, x1 - 1, y6 - 1, frameColor);
|
|
osd->DrawEllipse (x1, y5, x2 - 1, y6 - 1, frameColor, -3);
|
|
osd->DrawEllipse (x0, y6, x1 - 1, y7 - 1, frameColor, 3);
|
|
osd->DrawRectangle(x1, y6, x4 - 1, y7 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y6, x6 - 1, y7 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y6, x7 - 1, y7 - 1, frameColor, 5);
|
|
}
|
|
else {
|
|
x0 = 0;
|
|
x1 = lineHeight / 2;
|
|
x2 = lineHeight;
|
|
x3 = x2 + Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x5 = x6 - lineHeight / 2;
|
|
x4 = x5 - Gap;
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop() + (Setup.ChannelInfoPos ? 0 : cOsd::OsdHeight() - y1));
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 4 } }; // 16 colors
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 7);
|
|
osd->DrawRectangle(x1, y0, x2 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
}
|
|
}
|
|
|
|
cSkinSTTNGDisplayChannel::~cSkinSTTNGDisplayChannel()
|
|
{
|
|
delete osd;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayChannel::SetChannel(const cChannel *Channel, int Number)
|
|
{
|
|
osd->DrawRectangle(x3, y0, x4 - 1, y1 - 1, frameColor);
|
|
int x = x4 - SymbolSpacing;
|
|
if (Channel && !Channel->GroupSep()) {
|
|
bool rec = cRecordControls::Active();
|
|
x -= bmRecording.Width() + SymbolSpacing;
|
|
osd->DrawBitmap(x, y0 + (y1 - y0 - bmRecording.Height()) / 2, bmRecording, Theme.Color(rec ? clrChannelSymbolRecFg : clrChannelSymbolOff), rec ? Theme.Color(clrChannelSymbolRecBg) : frameColor);
|
|
x -= bmEncrypted.Width() + SymbolSpacing;
|
|
osd->DrawBitmap(x, y0 + (y1 - y0 - bmEncrypted.Height()) / 2, bmEncrypted, Theme.Color(Channel->Ca() ? clrChannelSymbolOn : clrChannelSymbolOff), frameColor);
|
|
x -= bmDolbyDigital.Width() + SymbolSpacing;
|
|
osd->DrawBitmap(x, y0 + (y1 - y0 - bmDolbyDigital.Height()) / 2, bmDolbyDigital, Theme.Color(Channel->Dpid(0) ? clrChannelSymbolOn : clrChannelSymbolOff), frameColor);
|
|
x -= bmAudio.Width() + SymbolSpacing;
|
|
osd->DrawBitmap(x, y0 + (y1 - y0 - bmAudio.Height()) / 2, bmAudio, Theme.Color(Channel->Apid(1) ? clrChannelSymbolOn : clrChannelSymbolOff), frameColor);
|
|
if (Channel->Vpid()) {
|
|
x -= bmTeletext.Width() + SymbolSpacing;
|
|
osd->DrawBitmap(x, y0 + (y1 - y0 - bmTeletext.Height()) / 2, bmTeletext, Theme.Color(Channel->Tpid() ? clrChannelSymbolOn : clrChannelSymbolOff), frameColor);
|
|
}
|
|
else if (Channel->Apid(0)) {
|
|
x -= bmRadio.Width() + SymbolSpacing;
|
|
osd->DrawBitmap(x, y0 + (y1 - y0 - bmRadio.Height()) / 2, bmRadio, Theme.Color(clrChannelSymbolOn), frameColor);
|
|
}
|
|
}
|
|
osd->DrawText(x3 + TextFrame, y0, ChannelString(Channel, Number), Theme.Color(clrChannelName), frameColor, cFont::GetFont(fontOsd), x - x3 - TextFrame);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayChannel::SetEvents(const cEvent *Present, const cEvent *Following)
|
|
{
|
|
if (!withInfo)
|
|
return;
|
|
if (present != Present)
|
|
lastSeen = -1;
|
|
present = Present;
|
|
osd->DrawRectangle(x0, y3, x1 - 1, y4 - 1, frameColor);
|
|
osd->DrawRectangle(x3, y3, x7 - 1, y4 - 1, Theme.Color(clrBackground));
|
|
for (int i = 0; i < 2; i++) {
|
|
const cEvent *e = !i ? Present : Following;
|
|
if (e) {
|
|
osd->DrawText(x0 + TextFrame, y3 + 2 * i * lineHeight, e->GetTimeString(), Theme.Color(clrChannelEpgTime), frameColor, cFont::GetFont(fontOsd));
|
|
osd->DrawText(x3 + TextFrame, y3 + 2 * i * lineHeight, e->Title(), Theme.Color(clrChannelEpgTitle), Theme.Color(clrBackground), cFont::GetFont(fontOsd), x4 - x3 - TextFrame);
|
|
osd->DrawText(x3 + TextFrame, y3 + (2 * i + 1) * lineHeight, e->ShortText(), Theme.Color(clrChannelEpgShortText), Theme.Color(clrBackground), cFont::GetFont(fontSml), x4 - x3 - TextFrame);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayChannel::SetMessage(eMessageType Type, const char *Text)
|
|
{
|
|
const cFont *font = cFont::GetFont(withInfo ? fontSml : fontOsd);
|
|
if (Text) {
|
|
int yt = withInfo ? y6 : y0;
|
|
int yb = withInfo ? y7 : y1;
|
|
osd->SaveRegion(x2, yt, x4 - 1, yb - 1);
|
|
if (withInfo)
|
|
osd->DrawRectangle(x2, yt, x3 - 1, yb - 1, Theme.Color(clrBackground));
|
|
osd->DrawText(x3, yt, Text, Theme.Color(clrMessageStatusFg + 2 * Type), Theme.Color(clrMessageStatusBg + 2 * Type), font, x4 - x3, 0, taCenter);
|
|
message = true;
|
|
}
|
|
else {
|
|
osd->RestoreRegion();
|
|
message = false;
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayChannel::Flush(void)
|
|
{
|
|
if (withInfo) {
|
|
if (!message) {
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
cString date = DayDateTime();
|
|
int w = font->Width(date);
|
|
if (!*lastDate || strcmp(date, lastDate)) {
|
|
osd->DrawText(x4 - w - TextFrame, y7 - font->Height(), date, Theme.Color(clrChannelDate), frameColor, font, w);
|
|
lastDate = date;
|
|
}
|
|
cDevice *Device = cDevice::PrimaryDevice();
|
|
const tTrackId *Track = Device->GetTrack(Device->GetCurrentAudioTrack());
|
|
if (!Track && *lastTrackId.description || Track && strcmp(lastTrackId.description, Track->description)) {
|
|
osd->DrawText(x3 + TextFrame, y6, Track ? Track->description : "", Theme.Color(clrChannelName), frameColor, font, x4 - x3 - w - 2 * TextFrame);
|
|
strn0cpy(lastTrackId.description, Track ? Track->description : "", sizeof(lastTrackId.description));
|
|
}
|
|
}
|
|
|
|
int seen = 0;
|
|
if (present) {
|
|
time_t t = time(NULL);
|
|
if (t > present->StartTime())
|
|
seen = min(y4 - y3 - 1, int((y4 - y3) * double(t - present->StartTime()) / present->Duration()));
|
|
}
|
|
if (seen != lastSeen) {
|
|
osd->DrawRectangle(x1 + Gap, y3, x1 + Gap + ScrollWidth - 1, y4 - 1, Theme.Color(clrChannelTimebarRest));
|
|
if (seen)
|
|
osd->DrawRectangle(x1 + Gap, y3, x1 + Gap + ScrollWidth - 1, y3 + seen, Theme.Color(clrChannelTimebarSeen));
|
|
lastSeen = seen;
|
|
}
|
|
}
|
|
osd->Flush();
|
|
}
|
|
|
|
// --- cSkinSTTNGDisplayMenu -------------------------------------------------
|
|
|
|
class cSkinSTTNGDisplayMenu : public cSkinDisplayMenu {
|
|
private:
|
|
cOsd *osd;
|
|
int x0, x1, x2, x3, x4, x5, x6, x7;
|
|
int y0, y1, y2, y3, y4, y5, y6, y7;
|
|
int lineHeight;
|
|
tColor frameColor;
|
|
int currentIndex;
|
|
bool message;
|
|
cString lastDate;
|
|
void DrawScrollbar(int Total, int Offset, int Shown, int Top, int Height, bool CanScrollUp, bool CanScrollDown);
|
|
void SetTextScrollbar(void);
|
|
public:
|
|
cSkinSTTNGDisplayMenu(void);
|
|
virtual ~cSkinSTTNGDisplayMenu();
|
|
virtual void Scroll(bool Up, bool Page);
|
|
virtual int MaxItems(void);
|
|
virtual void Clear(void);
|
|
virtual void SetTitle(const char *Title);
|
|
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 SetItem(const char *Text, int Index, bool Current, bool Selectable);
|
|
virtual void SetScrollbar(int Total, int Offset);
|
|
virtual void SetEvent(const cEvent *Event);
|
|
virtual void SetRecording(const cRecording *Recording);
|
|
virtual void SetText(const char *Text, bool FixedFont);
|
|
virtual int GetTextAreaWidth(void) const;
|
|
virtual const cFont *GetTextAreaFont(bool FixedFont) const;
|
|
virtual void Flush(void);
|
|
};
|
|
|
|
cSkinSTTNGDisplayMenu::cSkinSTTNGDisplayMenu(void)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
lineHeight = font->Height();
|
|
frameColor = Theme.Color(clrMenuFrame);
|
|
currentIndex = -1;
|
|
message = false;
|
|
x0 = 0;
|
|
x1 = lineHeight / 2;
|
|
x3 = (x1 + Roundness + Gap + 7) & ~0x07; // must be multiple of 8
|
|
x2 = x3 - Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x4 = (x6 - lineHeight / 2 - Gap) & ~0x07; // must be multiple of 8
|
|
x5 = x4 + Gap;
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
y2 = y1 + Roundness;
|
|
y3 = y2 + Gap;
|
|
y7 = cOsd::OsdHeight();
|
|
y6 = y7 - cFont::GetFont(fontSml)->Height();
|
|
y5 = y6 - Roundness;
|
|
y4 = y5 - Gap;
|
|
int yt = (y0 + y1) / 2;
|
|
int yb = (y6 + y7) / 2;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop());
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y7 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y7 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y7 - 1, 4 } }; // 16 colors
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y3 - 1, 2 }, // 2..16 colors
|
|
{ x0, y3, x3 - 1, y4 - 1, 1 },
|
|
{ x3, y3, x4 - 1, y4 - 1, 2 },
|
|
{ x4, y3, x7 - 1, y4 - 1, 2 },
|
|
{ x0, y4, x7 - 1, y7 - 1, 4 }
|
|
};
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y7 - 1, Theme.Color(clrBackground));
|
|
osd->DrawRectangle(x0, y0, x1 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawRectangle(x0, y6, x1 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, y0, x7 - 1, yt - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, yb, x7 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 2);
|
|
osd->DrawRectangle(x1, y0, x2 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x3, y0, x4 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
osd->DrawRectangle(x0, y1, x1 - 1, y6 - 1, frameColor);
|
|
osd->DrawEllipse (x1, y1, x2 - 1, y2 - 1, frameColor, -2);
|
|
osd->DrawEllipse (x1, y5, x2 - 1, y6 - 1, frameColor, -3);
|
|
osd->DrawEllipse (x0, y6, x1 - 1, y7 - 1, frameColor, 3);
|
|
osd->DrawRectangle(x1, y6, x2 - 1, y7 - 1, frameColor);
|
|
osd->DrawRectangle(x3, y6, x4 - 1, y7 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y6, x6 - 1, y7 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y6, x7 - 1, y7 - 1, frameColor, 5);
|
|
}
|
|
|
|
cSkinSTTNGDisplayMenu::~cSkinSTTNGDisplayMenu()
|
|
{
|
|
delete osd;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::DrawScrollbar(int Total, int Offset, int Shown, int Top, int Height, bool CanScrollUp, bool CanScrollDown)
|
|
{
|
|
if (Total > 0 && Total > Shown) {
|
|
int h = lineHeight;
|
|
int yt = Top;
|
|
int yb = yt + Height;
|
|
int st = yt + h + Gap;
|
|
int sb = yb - h - Gap;
|
|
int th = max(int((sb - st) * double(Shown) / Total + 0.5), ScrollWidth);
|
|
int tt = min(int(st + (sb - st) * double(Offset) / Total + 0.5), sb - th);
|
|
int tb = min(tt + th, sb);
|
|
osd->DrawRectangle(x5, st, x5 + ScrollWidth - 1, sb - 1, Theme.Color(clrMenuScrollbarTotal));
|
|
osd->DrawRectangle(x5, tt, x5 + ScrollWidth - 1, tb - 1, Theme.Color(clrMenuScrollbarShown));
|
|
osd->DrawRectangle(x5, yt, x6 - 1, yt + h - 1, frameColor);
|
|
osd->DrawEllipse (x6, yt, x7 - 1, yt + h - 1, frameColor, 5);
|
|
osd->DrawRectangle(x5, yb - h, x6 - 1, yb - 1, frameColor);
|
|
osd->DrawEllipse (x6, yb - h, x7 - 1, yb - 1, frameColor, 5);
|
|
if (CanScrollUp) {
|
|
cBitmap bm(arrowup_xpm);
|
|
osd->DrawBitmap(x5 + (x7 - x5 - bm.Width()) / 2 - 2, yt + (h - bm.Height()) / 2, bm, Theme.Color(clrMenuScrollbarArrow), frameColor);
|
|
}
|
|
if (CanScrollDown) {
|
|
cBitmap bm(arrowdown_xpm);
|
|
osd->DrawBitmap(x5 + (x7 - x5 - bm.Width()) / 2 - 2, yb - h + (h - bm.Height()) / 2, bm, Theme.Color(clrMenuScrollbarArrow), frameColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetTextScrollbar(void)
|
|
{
|
|
if (textScroller.CanScroll())
|
|
DrawScrollbar(textScroller.Total(), textScroller.Offset(), textScroller.Shown(), textScroller.Top(), textScroller.Height(), textScroller.CanScrollUp(), textScroller.CanScrollDown());
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::Scroll(bool Up, bool Page)
|
|
{
|
|
cSkinDisplayMenu::Scroll(Up, Page);
|
|
SetTextScrollbar();
|
|
}
|
|
|
|
int cSkinSTTNGDisplayMenu::MaxItems(void)
|
|
{
|
|
return (y4 - y3 - 2 * Roundness) / lineHeight;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::Clear(void)
|
|
{
|
|
textScroller.Reset();
|
|
osd->DrawRectangle(x1, y3, x7 - 1, y4 - 1, Theme.Color(clrBackground));
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetTitle(const char *Title)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
const char *VDR = " VDR";
|
|
int w = font->Width(VDR);
|
|
osd->DrawText(x3 + TextSpacing, y0, Title, Theme.Color(clrMenuTitle), frameColor, font, x4 - w - x3 - TextSpacing);
|
|
osd->DrawText(x4 - w, y0, VDR, frameColor, clrBlack, font, w, lineHeight);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetButtons(const char *Red, const char *Green, const char *Yellow, const char *Blue)
|
|
{
|
|
cString date = DayDateTime();
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int d = 2 * Gap;
|
|
int d2 = d / 2;
|
|
int t4 = x4 - font->Width(date) - TextFrame;
|
|
int w = t4 - x3;
|
|
int t0 = x3 + d2;
|
|
int t1 = x3 + w / 4;
|
|
int t2 = x3 + w / 2;
|
|
int t3 = t4 - w / 4;
|
|
osd->DrawRectangle(t0 + d2, y6, t1 - d2, y7 - 1, clrBlack);
|
|
osd->DrawRectangle(t1 + d2, y6, t2 - d2, y7 - 1, clrBlack);
|
|
osd->DrawRectangle(t2 + d2, y6, t3 - d2, y7 - 1, clrBlack);
|
|
osd->DrawRectangle(t3 + d2, y6, t4 - d2, y7 - 1, clrBlack);
|
|
osd->DrawText(t0 + d, y6, Red, Theme.Color(clrButtonRedFg), Theme.Color(clrButtonRedBg), font, t1 - t0 - 2 * d, 0, taCenter);
|
|
osd->DrawText(t1 + d, y6, Green, Theme.Color(clrButtonGreenFg), Theme.Color(clrButtonGreenBg), font, t2 - t1 - 2 * d, 0, taCenter);
|
|
osd->DrawText(t2 + d, y6, Yellow, Theme.Color(clrButtonYellowFg), Theme.Color(clrButtonYellowBg), font, t3 - t2 - 2 * d, 0, taCenter);
|
|
osd->DrawText(t3 + d, y6, Blue, Theme.Color(clrButtonBlueFg), Theme.Color(clrButtonBlueBg), font, t4 - t3 - 2 * d, 0, taCenter);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetMessage(eMessageType Type, const char *Text)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
if (Text) {
|
|
osd->SaveRegion(x3, y6, x4 - 1, y7 - 1);
|
|
osd->DrawText(x3, y6, Text, Theme.Color(clrMessageStatusFg + 2 * Type), Theme.Color(clrMessageStatusBg + 2 * Type), font, x4 - x3, 0, taCenter);
|
|
message = true;
|
|
}
|
|
else {
|
|
osd->RestoreRegion();
|
|
message = false;
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetItem(const char *Text, int Index, bool Current, bool Selectable)
|
|
{
|
|
int y = y3 + Roundness + Index * lineHeight;
|
|
tColor ColorFg, ColorBg;
|
|
if (Current) {
|
|
ColorFg = Theme.Color(clrMenuItemCurrentFg);
|
|
ColorBg = Theme.Color(clrMenuItemCurrentBg);
|
|
osd->DrawEllipse (x1, y - Roundness, x2 - 1, y - 1, frameColor, -3);
|
|
osd->DrawRectangle(x1, y, x2 - 1, y + lineHeight - 1, frameColor);
|
|
osd->DrawEllipse (x1, y + lineHeight, x2 - 1, y + lineHeight + Roundness - 1, frameColor, -2);
|
|
osd->DrawRectangle(x3, y, x4 - 1, y + lineHeight - 1, ColorBg);
|
|
currentIndex = Index;
|
|
}
|
|
else {
|
|
ColorFg = Theme.Color(Selectable ? clrMenuItemSelectable : clrMenuItemNonSelectable);
|
|
ColorBg = Theme.Color(clrBackground);
|
|
if (currentIndex == Index) {
|
|
osd->DrawRectangle(x1, y - Roundness, x2 - 1, y + lineHeight + Roundness - 1, Theme.Color(clrBackground));
|
|
osd->DrawRectangle(x3, y, x4 - 1, y + lineHeight - 1, Theme.Color(clrBackground));
|
|
}
|
|
}
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
for (int i = 0; i < MaxTabs; i++) {
|
|
const char *s = GetTabbedText(Text, i);
|
|
if (s) {
|
|
int xt = x3 + TextSpacing + Tab(i);
|
|
osd->DrawText(xt, y, s, ColorFg, ColorBg, font, x4 - xt);
|
|
}
|
|
if (!Tab(i + 1))
|
|
break;
|
|
}
|
|
SetEditableWidth(x4 - x3 - TextSpacing - Tab(1));
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetScrollbar(int Total, int Offset)
|
|
{
|
|
DrawScrollbar(Total, Offset, MaxItems(), y3 + Roundness, MaxItems() * lineHeight, Offset > 0, Offset + MaxItems() < Total);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetEvent(const cEvent *Event)
|
|
{
|
|
if (!Event)
|
|
return;
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
int xl = x3 + TextSpacing;
|
|
int y = y3;
|
|
cTextScroller ts;
|
|
char t[32];
|
|
snprintf(t, sizeof(t), "%s %s - %s", *Event->GetDateString(), *Event->GetTimeString(), *Event->GetEndTimeString());
|
|
ts.Set(osd, xl, y, x4 - xl, y4 - y, t, font, Theme.Color(clrMenuEventTime), Theme.Color(clrBackground));
|
|
if (Event->Vps() && Event->Vps() != Event->StartTime()) {
|
|
cString buffer = cString::sprintf(" VPS: %s ", *Event->GetVpsString());
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int w = font->Width(buffer);
|
|
osd->DrawText(x4 - w, y, buffer, Theme.Color(clrMenuEventVps), frameColor, font, w);
|
|
int yb = y + font->Height();
|
|
osd->DrawRectangle(x5, y, x6 - 1, yb - 1, frameColor);
|
|
osd->DrawEllipse (x6, y, x7 - 1, yb - 1, frameColor, 5);
|
|
}
|
|
y += ts.Height();
|
|
if (Event->ParentalRating()) {
|
|
cString buffer = cString::sprintf(" %s ", *Event->GetParentalRatingString());
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int w = font->Width(buffer);
|
|
osd->DrawText(x4 - w, y, buffer, Theme.Color(clrMenuEventVps), frameColor, font, w);
|
|
int yb = y + font->Height();
|
|
osd->DrawRectangle(x5, y, x6 - 1, yb - 1, frameColor);
|
|
osd->DrawEllipse (x6, y, x7 - 1, yb - 1, frameColor, 5);
|
|
}
|
|
y += font->Height();
|
|
ts.Set(osd, xl, y, x4 - xl, y4 - y, Event->Title(), font, Theme.Color(clrMenuEventTitle), Theme.Color(clrBackground));
|
|
y += ts.Height();
|
|
if (!isempty(Event->ShortText())) {
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
ts.Set(osd, xl, y, x4 - xl, y4 - y, Event->ShortText(), font, Theme.Color(clrMenuEventShortText), Theme.Color(clrBackground));
|
|
y += ts.Height();
|
|
}
|
|
y += font->Height();
|
|
if (!isempty(Event->Description())) {
|
|
int yt = y;
|
|
int yb = y4 - Roundness;
|
|
textScroller.Set(osd, xl, yt, x4 - xl, yb - yt, Event->Description(), font, Theme.Color(clrMenuEventDescription), Theme.Color(clrBackground));
|
|
yb = yt + textScroller.Height();
|
|
osd->DrawEllipse (x1, yt - Roundness, x2, yt, frameColor, -3);
|
|
osd->DrawRectangle(x1, yt, x2, yb, frameColor);
|
|
osd->DrawEllipse (x1, yb, x2, yb + Roundness, frameColor, -2);
|
|
SetTextScrollbar();
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetRecording(const cRecording *Recording)
|
|
{
|
|
if (!Recording)
|
|
return;
|
|
const cRecordingInfo *Info = Recording->Info();
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
int xl = x3 + TextSpacing;
|
|
int y = y3;
|
|
cTextScroller ts;
|
|
char t[32];
|
|
snprintf(t, sizeof(t), "%s %s", *DateString(Recording->start), *TimeString(Recording->start));
|
|
ts.Set(osd, xl, y, x4 - xl, y4 - y, t, font, Theme.Color(clrMenuEventTime), Theme.Color(clrBackground));
|
|
y += ts.Height();
|
|
if (Info->GetEvent()->ParentalRating()) {
|
|
cString buffer = cString::sprintf(" %s ", *Info->GetEvent()->GetParentalRatingString());
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int w = font->Width(buffer);
|
|
osd->DrawText(x4 - w, y, buffer, Theme.Color(clrMenuEventVps), frameColor, font, w);
|
|
int yb = y + font->Height();
|
|
osd->DrawRectangle(x5, y, x6 - 1, yb - 1, frameColor);
|
|
osd->DrawEllipse (x6, y, x7 - 1, yb - 1, frameColor, 5);
|
|
}
|
|
y += font->Height();
|
|
const char *Title = Info->Title();
|
|
if (isempty(Title))
|
|
Title = Recording->Name();
|
|
ts.Set(osd, xl, y, x4 - xl, y4 - y, Title, font, Theme.Color(clrMenuEventTitle), Theme.Color(clrBackground));
|
|
y += ts.Height();
|
|
if (!isempty(Info->ShortText())) {
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
ts.Set(osd, xl, y, x4 - xl, y4 - y, Info->ShortText(), font, Theme.Color(clrMenuEventShortText), Theme.Color(clrBackground));
|
|
y += ts.Height();
|
|
}
|
|
y += font->Height();
|
|
if (!isempty(Info->Description())) {
|
|
int yt = y;
|
|
int yb = y4 - Roundness;
|
|
textScroller.Set(osd, xl, yt, x4 - xl, yb - yt, Info->Description(), font, Theme.Color(clrMenuEventDescription), Theme.Color(clrBackground));
|
|
yb = yt + textScroller.Height();
|
|
osd->DrawEllipse (x1, yt - Roundness, x2, yt, frameColor, -3);
|
|
osd->DrawRectangle(x1, yt, x2, yb, frameColor);
|
|
osd->DrawEllipse (x1, yb, x2, yb + Roundness, frameColor, -2);
|
|
SetTextScrollbar();
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::SetText(const char *Text, bool FixedFont)
|
|
{
|
|
textScroller.Set(osd, x3, y3, GetTextAreaWidth(), y4 - y3, Text, GetTextAreaFont(FixedFont), Theme.Color(clrMenuText), Theme.Color(clrBackground));
|
|
SetTextScrollbar();
|
|
}
|
|
|
|
int cSkinSTTNGDisplayMenu::GetTextAreaWidth(void) const
|
|
{
|
|
return x4 - x3;
|
|
}
|
|
|
|
const cFont *cSkinSTTNGDisplayMenu::GetTextAreaFont(bool FixedFont) const
|
|
{
|
|
const cFont *font = cFont::GetFont(FixedFont ? fontFix : fontOsd);
|
|
//XXX -> make a way to let the text define which font to use
|
|
return font;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMenu::Flush(void)
|
|
{
|
|
if (!message) {
|
|
cString date = DayDateTime();
|
|
if (!*lastDate || strcmp(date, lastDate)) {
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int w = font->Width(date);
|
|
osd->DrawText(x4 - w - TextFrame, y7 - font->Height(), date, Theme.Color(clrMenuDate), frameColor, font, w);
|
|
lastDate = date;
|
|
}
|
|
}
|
|
osd->Flush();
|
|
}
|
|
|
|
// --- cSkinSTTNGDisplayReplay -----------------------------------------------
|
|
|
|
class cSkinSTTNGDisplayReplay : public cSkinDisplayReplay {
|
|
private:
|
|
cOsd *osd;
|
|
int x0, x1, x2, x3, x4, x5, x6, x7;
|
|
int y0, y1, y2, y3, y4, y5, y6, y7;
|
|
tColor frameColor;
|
|
int lastCurrentWidth;
|
|
public:
|
|
cSkinSTTNGDisplayReplay(bool ModeOnly);
|
|
virtual ~cSkinSTTNGDisplayReplay();
|
|
virtual void SetTitle(const char *Title);
|
|
virtual void SetMode(bool Play, bool Forward, int Speed);
|
|
virtual void SetProgress(int Current, int Total);
|
|
virtual void SetCurrent(const char *Current);
|
|
virtual void SetTotal(const char *Total);
|
|
virtual void SetJump(const char *Jump);
|
|
virtual void SetMessage(eMessageType Type, const char *Text);
|
|
virtual void Flush(void);
|
|
};
|
|
|
|
#define SymbolWidth 30
|
|
#define SymbolHeight 30
|
|
|
|
cSkinSTTNGDisplayReplay::cSkinSTTNGDisplayReplay(bool ModeOnly)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int lineHeight = font->Height();
|
|
frameColor = Theme.Color(clrReplayFrame);
|
|
lastCurrentWidth = 0;
|
|
cBitmap bm(play_xpm);
|
|
x0 = 0;
|
|
x1 = max(SymbolWidth, bm.Width());
|
|
x2 = x1 + Roundness;
|
|
x3 = x2 + Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x5 = x6 - lineHeight / 2;
|
|
x4 = x5 - Gap;
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
y2 = y1 + Roundness;
|
|
y3 = y2 + Gap;
|
|
y4 = y3 + max(SymbolHeight, bm.Height());
|
|
y5 = y4 + Gap;
|
|
y6 = y5 + Roundness;
|
|
y7 = y6 + font->Height();
|
|
int yt = (y0 + y1) / 2;
|
|
int yb = (y6 + y7) / 2;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop() + cOsd::OsdHeight() - y7);
|
|
tArea Areas[] = { { 0, 0, x7 - 1, y7 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { 0, 0, x7 - 1, y7 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { 0, 0, x7 - 1, y7 - 1, 4 } }; // 16 colors
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y7 - 1, ModeOnly ? clrTransparent : Theme.Color(clrBackground));
|
|
if (!ModeOnly) {
|
|
osd->DrawRectangle(x0, y0, x1 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawRectangle(x0, y6, x1 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, y0, x7 - 1, yt - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, yb, x7 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 2);
|
|
osd->DrawRectangle(x1, y0, x4 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
osd->DrawRectangle(x0, y1, x1 - 1, y2 - 1, frameColor);
|
|
osd->DrawEllipse (x1, y1, x2 - 1, y2 - 1, frameColor, -2);
|
|
}
|
|
osd->DrawRectangle(x0, y3, x1 - 1, y4 - 1, frameColor);
|
|
if (!ModeOnly) {
|
|
osd->DrawRectangle(x0, y5, x1 - 1, y6 - 1, frameColor);
|
|
osd->DrawEllipse (x1, y5, x2 - 1, y6 - 1, frameColor, -3);
|
|
osd->DrawEllipse (x0, y6, x1 - 1, y7 - 1, frameColor, 3);
|
|
osd->DrawRectangle(x1, y6, x4 - 1, y7 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y6, x6 - 1, y7 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y6, x7 - 1, y7 - 1, frameColor, 5);
|
|
}
|
|
}
|
|
|
|
cSkinSTTNGDisplayReplay::~cSkinSTTNGDisplayReplay()
|
|
{
|
|
delete osd;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::SetTitle(const char *Title)
|
|
{
|
|
osd->DrawText(x3 + TextSpacing, y0, Title, Theme.Color(clrReplayTitle), frameColor, cFont::GetFont(fontSml), x4 - x3 - TextSpacing);
|
|
}
|
|
|
|
static const char *const *ReplaySymbols[2][2][5] = {
|
|
{ { pause_xpm, srew_xpm, srew1_xpm, srew2_xpm, srew3_xpm },
|
|
{ pause_xpm, sfwd_xpm, sfwd1_xpm, sfwd2_xpm, sfwd3_xpm }, },
|
|
{ { play_xpm, frew_xpm, frew1_xpm, frew2_xpm, frew3_xpm },
|
|
{ play_xpm, ffwd_xpm, ffwd1_xpm, ffwd2_xpm, ffwd3_xpm } }
|
|
};
|
|
|
|
void cSkinSTTNGDisplayReplay::SetMode(bool Play, bool Forward, int Speed)
|
|
{
|
|
if (Speed < -1)
|
|
Speed = -1;
|
|
if (Speed > 3)
|
|
Speed = 3;
|
|
cBitmap bm(ReplaySymbols[Play][Forward][Speed + 1]);
|
|
osd->DrawBitmap(x0 + (x1 - x0 - bm.Width()) / 2, y3 + (y4 - y3 - bm.Height()) / 2, bm, Theme.Color(clrReplayMode), frameColor);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::SetProgress(int Current, int Total)
|
|
{
|
|
cProgressBar pb(x4 - x3, y4 - y3, Current, Total, marks, Theme.Color(clrReplayProgressSeen), Theme.Color(clrReplayProgressRest), Theme.Color(clrReplayProgressSelected), Theme.Color(clrReplayProgressMark), Theme.Color(clrReplayProgressCurrent));
|
|
osd->DrawBitmap(x3, y3, pb);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::SetCurrent(const char *Current)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int w = font->Width(Current);
|
|
osd->DrawText(x3, y6, Current, Theme.Color(clrReplayCurrent), frameColor, font, lastCurrentWidth > w ? lastCurrentWidth : w);
|
|
lastCurrentWidth = w;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::SetTotal(const char *Total)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
int w = font->Width(Total);
|
|
osd->DrawText(x4 - w - TextSpacing, y6, Total, Theme.Color(clrReplayTotal), frameColor, font, w);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::SetJump(const char *Jump)
|
|
{
|
|
osd->DrawText(x0 + (x4 - x0) / 4, y6, Jump, Theme.Color(clrReplayJump), frameColor, cFont::GetFont(fontSml), (x4 - x3) / 2, 0, taCenter);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::SetMessage(eMessageType Type, const char *Text)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontSml);
|
|
if (Text) {
|
|
osd->SaveRegion(x2, y6, x4 - 1, y7 - 1);
|
|
osd->DrawRectangle(x2, y6, x3 - 1, y7 - 1, Theme.Color(clrBackground));
|
|
osd->DrawText(x3, y6, Text, Theme.Color(clrMessageStatusFg + 2 * Type), Theme.Color(clrMessageStatusBg + 2 * Type), font, x4 - x3, 0, taCenter);
|
|
}
|
|
else
|
|
osd->RestoreRegion();
|
|
}
|
|
|
|
void cSkinSTTNGDisplayReplay::Flush(void)
|
|
{
|
|
osd->Flush();
|
|
}
|
|
|
|
// --- cSkinSTTNGDisplayVolume -----------------------------------------------
|
|
|
|
class cSkinSTTNGDisplayVolume : public cSkinDisplayVolume {
|
|
private:
|
|
cOsd *osd;
|
|
int x0, x1, x2, x3, x4, x5, x6, x7;
|
|
int y0, y1;
|
|
tColor frameColor;
|
|
int mute;
|
|
public:
|
|
cSkinSTTNGDisplayVolume(void);
|
|
virtual ~cSkinSTTNGDisplayVolume();
|
|
virtual void SetVolume(int Current, int Total, bool Mute);
|
|
virtual void Flush(void);
|
|
};
|
|
|
|
cSkinSTTNGDisplayVolume::cSkinSTTNGDisplayVolume(void)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
int lineHeight = font->Height();
|
|
frameColor = Theme.Color(clrVolumeFrame);
|
|
mute = -1;
|
|
x0 = 0;
|
|
x1 = lineHeight / 2;
|
|
x2 = lineHeight;
|
|
x3 = x2 + Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x5 = x6 - lineHeight / 2;
|
|
x4 = x5 - Gap;
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop() + cOsd::OsdHeight() - y1);
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 4 } }; // 16 colors
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 7);
|
|
osd->DrawRectangle(x1, y0, x2 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x3, y0, x4 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
}
|
|
|
|
cSkinSTTNGDisplayVolume::~cSkinSTTNGDisplayVolume()
|
|
{
|
|
delete osd;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayVolume::SetVolume(int Current, int Total, bool Mute)
|
|
{
|
|
int xl = x3 + TextSpacing;
|
|
int xr = x4 - TextSpacing;
|
|
int yt = y0 + TextFrame;
|
|
int yb = y1 - TextFrame;
|
|
if (mute != Mute) {
|
|
osd->DrawRectangle(x3, y0, x4 - 1, y1 - 1, frameColor);
|
|
mute = Mute;
|
|
}
|
|
cBitmap bm(Mute ? mute_xpm : volume_xpm);
|
|
osd->DrawBitmap(xl, y0 + (y1 - y0 - bm.Height()) / 2, bm, Theme.Color(clrVolumeSymbol), frameColor);
|
|
if (!Mute) {
|
|
xl += bm.Width() + TextSpacing;
|
|
int w = (y1 - y0) / 3;
|
|
int d = TextFrame;
|
|
int n = (xr - xl + d) / (w + d);
|
|
int x = xr - n * (w + d);
|
|
tColor Color = Theme.Color(clrVolumeBarLower);
|
|
for (int i = 0; i < n; i++) {
|
|
if (Total * i >= Current * n)
|
|
Color = Theme.Color(clrVolumeBarUpper);
|
|
osd->DrawRectangle(x, yt, x + w - 1, yb - 1, Color);
|
|
x += w + d;
|
|
}
|
|
}
|
|
}
|
|
|
|
void cSkinSTTNGDisplayVolume::Flush(void)
|
|
{
|
|
osd->Flush();
|
|
}
|
|
|
|
// --- cSkinSTTNGDisplayTracks -----------------------------------------------
|
|
|
|
class cSkinSTTNGDisplayTracks : public cSkinDisplayTracks {
|
|
private:
|
|
cOsd *osd;
|
|
int x0, x1, x2, x3, x4, x5, x6, x7;
|
|
int y0, y1, y2, y3, y4, y5, y6, y7;
|
|
int lineHeight;
|
|
tColor frameColor;
|
|
int currentIndex;
|
|
static cBitmap bmAudioLeft, bmAudioRight, bmAudioStereo;
|
|
void SetItem(const char *Text, int Index, bool Current);
|
|
public:
|
|
cSkinSTTNGDisplayTracks(const char *Title, int NumTracks, const char * const *Tracks);
|
|
virtual ~cSkinSTTNGDisplayTracks();
|
|
virtual void SetTrack(int Index, const char * const *Tracks);
|
|
virtual void SetAudioChannel(int AudioChannel);
|
|
virtual void Flush(void);
|
|
};
|
|
|
|
cBitmap cSkinSTTNGDisplayTracks::bmAudioLeft(audioleft_xpm);
|
|
cBitmap cSkinSTTNGDisplayTracks::bmAudioRight(audioright_xpm);
|
|
cBitmap cSkinSTTNGDisplayTracks::bmAudioStereo(audiostereo_xpm);
|
|
|
|
cSkinSTTNGDisplayTracks::cSkinSTTNGDisplayTracks(const char *Title, int NumTracks, const char * const *Tracks)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
lineHeight = font->Height();
|
|
frameColor = Theme.Color(clrMenuFrame);
|
|
currentIndex = -1;
|
|
int ItemsWidth = font->Width(Title);
|
|
for (int i = 0; i < NumTracks; i++)
|
|
ItemsWidth = max(ItemsWidth, font->Width(Tracks[i]));
|
|
ItemsWidth += 2 * TextSpacing;
|
|
x0 = 0;
|
|
x1 = lineHeight / 2;
|
|
x3 = (x1 + Roundness + Gap + 7) & ~0x07; // must be multiple of 8
|
|
x2 = x3 - Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x4 = (x6 - lineHeight / 2 - Gap) & ~0x07; // must be multiple of 8
|
|
x5 = x4 + Gap;
|
|
int d = x4 - x3;
|
|
if (d > ItemsWidth) {
|
|
d = (d - ItemsWidth) & ~0x07; // must be multiple of 8
|
|
x4 -= d;
|
|
x5 -= d;
|
|
x6 -= d;
|
|
x7 -= d;
|
|
}
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
y2 = y1 + Roundness;
|
|
y3 = y2 + Gap;
|
|
// limit to cOsd::OsdHeight()? - what if height is too big???
|
|
y4 = y3 + NumTracks * lineHeight + 2 * Roundness;
|
|
y5 = y4 + Gap;
|
|
y6 = y5 + Roundness;
|
|
y7 = y6 + cFont::GetFont(fontSml)->Height();
|
|
int yt = (y0 + y1) / 2;
|
|
int yb = (y6 + y7) / 2;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop() + cOsd::OsdHeight() - y7);
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y7 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y7 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y7 - 1, 4 } }; // 16 colors
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y3 - 1, 2 }, // 2..16 colors
|
|
{ x0, y3, x3 - 1, y4 - 1, 1 },
|
|
{ x3, y3, x4 - 1, y4 - 1, 2 },
|
|
{ x4, y3, x7 - 1, y4 - 1, 2 },
|
|
{ x0, y4, x7 - 1, y7 - 1, 4 }
|
|
};
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y7 - 1, Theme.Color(clrBackground));
|
|
osd->DrawRectangle(x0, y0, x1 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawRectangle(x0, y6, x1 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, y0, x7 - 1, yt - 1, clrTransparent);
|
|
osd->DrawRectangle(x6, yb, x7 - 1, y7 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 2);
|
|
osd->DrawRectangle(x1, y0, x2 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x3, y0, x4 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
osd->DrawRectangle(x0, y1, x1 - 1, y6 - 1, frameColor);
|
|
osd->DrawEllipse (x1, y1, x2 - 1, y2 - 1, frameColor, -2);
|
|
osd->DrawEllipse (x1, y5, x2 - 1, y6 - 1, frameColor, -3);
|
|
osd->DrawEllipse (x0, y6, x1 - 1, y7 - 1, frameColor, 3);
|
|
osd->DrawRectangle(x1, y6, x2 - 1, y7 - 1, frameColor);
|
|
osd->DrawRectangle(x3, y6, x4 - 1, y7 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y6, x6 - 1, y7 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y6, x7 - 1, y7 - 1, frameColor, 5);
|
|
osd->DrawText(x3 + TextSpacing, y0, Title, Theme.Color(clrMenuTitle), frameColor, font, x4 - x3 - TextSpacing);
|
|
for (int i = 0; i < NumTracks; i++)
|
|
SetItem(Tracks[i], i, false);
|
|
}
|
|
|
|
cSkinSTTNGDisplayTracks::~cSkinSTTNGDisplayTracks()
|
|
{
|
|
delete osd;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayTracks::SetItem(const char *Text, int Index, bool Current)
|
|
{
|
|
int y = y3 + Roundness + Index * lineHeight;
|
|
tColor ColorFg, ColorBg;
|
|
if (Current) {
|
|
ColorFg = Theme.Color(clrMenuItemCurrentFg);
|
|
ColorBg = Theme.Color(clrMenuItemCurrentBg);
|
|
osd->DrawEllipse (x1, y - Roundness, x2 - 1, y - 1, frameColor, -3);
|
|
osd->DrawRectangle(x1, y, x2 - 1, y + lineHeight - 1, frameColor);
|
|
osd->DrawEllipse (x1, y + lineHeight, x2 - 1, y + lineHeight + Roundness - 1, frameColor, -2);
|
|
osd->DrawRectangle(x3, y, x4 - 1, y + lineHeight - 1, ColorBg);
|
|
currentIndex = Index;
|
|
}
|
|
else {
|
|
ColorFg = Theme.Color(clrMenuItemSelectable);
|
|
ColorBg = Theme.Color(clrBackground);
|
|
if (currentIndex == Index) {
|
|
osd->DrawRectangle(x1, y - Roundness, x2 - 1, y + lineHeight + Roundness - 1, Theme.Color(clrBackground));
|
|
osd->DrawRectangle(x3, y, x4 - 1, y + lineHeight - 1, Theme.Color(clrBackground));
|
|
}
|
|
}
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
int xt = x3 + TextSpacing;
|
|
osd->DrawText(xt, y, Text, ColorFg, ColorBg, font, x4 - xt);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayTracks::SetTrack(int Index, const char * const *Tracks)
|
|
{
|
|
if (currentIndex >= 0)
|
|
SetItem(Tracks[currentIndex], currentIndex, false);
|
|
SetItem(Tracks[Index], Index, true);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayTracks::SetAudioChannel(int AudioChannel)
|
|
{
|
|
cBitmap *bm = NULL;
|
|
switch (AudioChannel) {
|
|
case 0: bm = &bmAudioStereo; break;
|
|
case 1: bm = &bmAudioLeft; break;
|
|
case 2: bm = &bmAudioRight; break;
|
|
default: ;
|
|
}
|
|
if (bm)
|
|
osd->DrawBitmap(x3 + TextSpacing, y6 + (y7 - y6 - bm->Height()) / 2, *bm, Theme.Color(clrChannelSymbolOn), frameColor);
|
|
else
|
|
osd->DrawRectangle(x3, y6, x4 - 1, y7 - 1, frameColor);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayTracks::Flush(void)
|
|
{
|
|
osd->Flush();
|
|
}
|
|
|
|
// --- cSkinSTTNGDisplayMessage ----------------------------------------------
|
|
|
|
class cSkinSTTNGDisplayMessage : public cSkinDisplayMessage {
|
|
private:
|
|
cOsd *osd;
|
|
int x0, x1, x2, x3, x4, x5, x6, x7;
|
|
int y0, y1;
|
|
public:
|
|
cSkinSTTNGDisplayMessage(void);
|
|
virtual ~cSkinSTTNGDisplayMessage();
|
|
virtual void SetMessage(eMessageType Type, const char *Text);
|
|
virtual void Flush(void);
|
|
};
|
|
|
|
cSkinSTTNGDisplayMessage::cSkinSTTNGDisplayMessage(void)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
int lineHeight = font->Height();
|
|
tColor frameColor = Theme.Color(clrMessageFrame);
|
|
x0 = 0;
|
|
x1 = lineHeight / 2;
|
|
x2 = lineHeight;
|
|
x3 = x2 + Gap;
|
|
x7 = cOsd::OsdWidth();
|
|
x6 = x7 - lineHeight / 2;
|
|
x5 = x6 - lineHeight / 2;
|
|
x4 = x5 - Gap;
|
|
y0 = 0;
|
|
y1 = lineHeight;
|
|
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop() + cOsd::OsdHeight() - y1);
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 32 } }; // TrueColor
|
|
if (osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 8 } }; // 256 colors
|
|
if (Setup.AntiAlias && osd->CanHandleAreas(Areas, sizeof(Areas) / sizeof(tArea)) == oeOk)
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
else {
|
|
tArea Areas[] = { { x0, y0, x7 - 1, y1 - 1, 2 } }; // 4 colors
|
|
osd->SetAreas(Areas, sizeof(Areas) / sizeof(tArea));
|
|
}
|
|
}
|
|
osd->DrawRectangle(x0, y0, x7 - 1, y1 - 1, clrTransparent);
|
|
osd->DrawEllipse (x0, y0, x1 - 1, y1 - 1, frameColor, 7);
|
|
osd->DrawRectangle(x1, y0, x2 - 1, y1 - 1, frameColor);
|
|
osd->DrawRectangle(x5, y0, x6 - 1, y1 - 1, frameColor);
|
|
osd->DrawEllipse (x6, y0, x7 - 1, y1 - 1, frameColor, 5);
|
|
}
|
|
|
|
cSkinSTTNGDisplayMessage::~cSkinSTTNGDisplayMessage()
|
|
{
|
|
delete osd;
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMessage::SetMessage(eMessageType Type, const char *Text)
|
|
{
|
|
const cFont *font = cFont::GetFont(fontOsd);
|
|
osd->DrawText(x3, y0, Text, Theme.Color(clrMessageStatusFg + 2 * Type), Theme.Color(clrMessageStatusBg + 2 * Type), font, x4 - x3, 0, taCenter);
|
|
}
|
|
|
|
void cSkinSTTNGDisplayMessage::Flush(void)
|
|
{
|
|
osd->Flush();
|
|
}
|
|
|
|
// --- cSkinSTTNG ------------------------------------------------------------
|
|
|
|
cSkinSTTNG::cSkinSTTNG(void)
|
|
:cSkin("sttng", &::Theme)//XXX naming problem???
|
|
{
|
|
}
|
|
|
|
const char *cSkinSTTNG::Description(void)
|
|
{
|
|
return tr("ST:TNG Panels");
|
|
}
|
|
|
|
cSkinDisplayChannel *cSkinSTTNG::DisplayChannel(bool WithInfo)
|
|
{
|
|
return new cSkinSTTNGDisplayChannel(WithInfo);
|
|
}
|
|
|
|
cSkinDisplayMenu *cSkinSTTNG::DisplayMenu(void)
|
|
{
|
|
return new cSkinSTTNGDisplayMenu;
|
|
}
|
|
|
|
cSkinDisplayReplay *cSkinSTTNG::DisplayReplay(bool ModeOnly)
|
|
{
|
|
return new cSkinSTTNGDisplayReplay(ModeOnly);
|
|
}
|
|
|
|
cSkinDisplayVolume *cSkinSTTNG::DisplayVolume(void)
|
|
{
|
|
return new cSkinSTTNGDisplayVolume;
|
|
}
|
|
|
|
cSkinDisplayTracks *cSkinSTTNG::DisplayTracks(const char *Title, int NumTracks, const char * const *Tracks)
|
|
{
|
|
return new cSkinSTTNGDisplayTracks(Title, NumTracks, Tracks);
|
|
}
|
|
|
|
cSkinDisplayMessage *cSkinSTTNG::DisplayMessage(void)
|
|
{
|
|
return new cSkinSTTNGDisplayMessage;
|
|
}
|