frodovdr
/
vdr-plugin-tvguide
mirror of https://projects.vdr-developer.org/git/vdr-plugin-tvguide.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Cosmetic change in osdmanager.*

This commit is contained in:
kamel5 2019-11-10 15:37:28 +01:00
parent d8663ff309
commit 93af9304c8
17 changed files with 231 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
channelgroup.c
View File

@ -47,7 +47,7 @@ void cChannelGroupGrid::SetGeometry(int start, int end) {
width = geoManager.channelGroupsWidth;
height = (end - start + 1) * geoManager.rowHeight;
}
pixmap = osdManager.requestPixmap(1, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(1, cRect(x, y, width, height));
}
void cChannelGroupGrid::Draw(void) {

10
channeljump.c
View File

@ -18,17 +18,17 @@ cChannelJump::cChannelJump(cChannelGroups *channelGroups, int lastValidChannel)
}
cChannelJump::~cChannelJump(void) {
osdManager.releasePixmap(pixmapBack);
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapBack);
osdManager.DestroyPixmap(pixmapText);
}
void cChannelJump::SetPixmaps(void) {
int x = (geoManager.osdWidth - geoManager.channelJumpWidth)/2;
int y = (geoManager.osdHeight - geoManager.channelJumpHeight)/2;
pixmapBack = osdManager.requestPixmap(4, cRect(x, y, geoManager.channelJumpWidth, geoManager.channelJumpHeight));
pixmap = osdManager.requestPixmap(5, cRect(x, y, geoManager.channelJumpWidth, geoManager.channelJumpHeight));
pixmapText = osdManager.requestPixmap(6, cRect(x, y, geoManager.channelJumpWidth, geoManager.channelJumpHeight));
pixmapBack = osdManager.CreatePixmap(4, cRect(x, y, geoManager.channelJumpWidth, geoManager.channelJumpHeight));
pixmap = osdManager.CreatePixmap(5, cRect(x, y, geoManager.channelJumpWidth, geoManager.channelJumpHeight));
pixmapText = osdManager.CreatePixmap(6, cRect(x, y, geoManager.channelJumpWidth, geoManager.channelJumpHeight));
}
void cChannelJump::Draw(void) {

4
detailview.c
View File

@ -149,14 +149,14 @@ eOSState cDetailView::ProcessKey(eKeys Key) {
bool scrolled = view->KeyUp();
if (scrolled) {
view->DrawScrollbar();
osdManager.flush();
osdManager.Flush();
}
break; }
case kDown: {
bool scrolled = view->KeyDown();
if (scrolled) {
view->DrawScrollbar();
osdManager.flush();
osdManager.Flush();
}
break; }
case kLeft:

12
dummygrid.c
View File

@ -34,10 +34,10 @@ void cDummyGrid::PositionPixmap() {
y0 += (StartTime() - column->Start())/60*geoManager.minutePixel;
}
if (!pixmap) {
pixmap = osdManager.requestPixmap(-1, cRect(x0, y0, geoManager.colWidth, viewportHeight));
pixmap = osdManager.CreatePixmap(-1, cRect(x0, y0, geoManager.colWidth, viewportHeight));
} else if (dirty) {
osdManager.releasePixmap(pixmap);
pixmap = osdManager.requestPixmap(-1, cRect(x0, y0, geoManager.colWidth, viewportHeight));
osdManager.DestroyPixmap(pixmap);
pixmap = osdManager.CreatePixmap(-1, cRect(x0, y0, geoManager.colWidth, viewportHeight));
} else {
pixmap->SetViewPort(cRect(x0, y0, geoManager.colWidth, viewportHeight));
}
@ -48,10 +48,10 @@ void cDummyGrid::PositionPixmap() {
x0 += (StartTime() - column->Start())/60*geoManager.minutePixel;
}
if (!pixmap) {
pixmap = osdManager.requestPixmap(-1, cRect(x0, y0, viewportHeight, geoManager.rowHeight));
pixmap = osdManager.CreatePixmap(-1, cRect(x0, y0, viewportHeight, geoManager.rowHeight));
} else if (dirty) {
osdManager.releasePixmap(pixmap);
pixmap = osdManager.requestPixmap(-1, cRect(x0, y0, viewportHeight, geoManager.rowHeight));
osdManager.DestroyPixmap(pixmap);
pixmap = osdManager.CreatePixmap(-1, cRect(x0, y0, viewportHeight, geoManager.rowHeight));
} else {
pixmap->SetViewPort(cRect(x0, y0, viewportHeight, geoManager.rowHeight));
}

4
epggrid.c
View File

@ -40,7 +40,7 @@ void cEpgGrid::PositionPixmap() {
y0 += (StartTime() - column->Start()) / 60 * geoManager.minutePixel;
}
if (!pixmap) {
pixmap = osdManager.requestPixmap(-1, cRect(x0, y0, geoManager.colWidth, viewportHeight),
pixmap = osdManager.CreatePixmap(-1, cRect(x0, y0, geoManager.colWidth, viewportHeight),
cRect(0, 0, geoManager.colWidth, Duration() / 60 * geoManager.minutePixel));
} else {
pixmap->SetViewPort(cRect(x0, y0, geoManager.colWidth, viewportHeight));
@ -52,7 +52,7 @@ void cEpgGrid::PositionPixmap() {
x0 += (StartTime() - column->Start()) / 60 * geoManager.minutePixel;
}
if (!pixmap) {
pixmap = osdManager.requestPixmap(-1, cRect(x0, y0, viewportHeight, geoManager.rowHeight),
pixmap = osdManager.CreatePixmap(-1, cRect(x0, y0, viewportHeight, geoManager.rowHeight),
cRect(0, 0, Duration() / 60 * geoManager.minutePixel, geoManager.rowHeight));
} else {
pixmap->SetViewPort(cRect(x0, y0, viewportHeight, geoManager.rowHeight ));

4
footer.c
View File

@ -8,7 +8,7 @@ cFooter::cFooter(cChannelGroups *channelGroups) {
currentGroup = -1;
buttonY = (geoManager.footerHeight - geoManager.buttonHeight)/2;
SetButtonPositions();
footer = osdManager.requestPixmap(2, cRect( 0,
footer = osdManager.CreatePixmap(2, cRect( 0,
geoManager.footerY,
geoManager.osdWidth,
geoManager.footerHeight),
@ -17,7 +17,7 @@ cFooter::cFooter(cChannelGroups *channelGroups) {
}
cFooter::~cFooter(void) {
osdManager.releasePixmap(footer);
osdManager.DestroyPixmap(footer);
}
void cFooter::drawRedButton() {

6
headergrid.c
View File

@ -8,7 +8,7 @@ cHeaderGrid::cHeaderGrid(void) : cGridElement(NULL) {
}
cHeaderGrid::~cHeaderGrid(void) {
osdManager.releasePixmap(pixmapLogo);
osdManager.DestroyPixmap(pixmapLogo);
}
void cHeaderGrid::createBackground(int num) {
@ -22,8 +22,8 @@ void cHeaderGrid::createBackground(int num) {
x = geoManager.channelGroupsWidth;
y = geoManager.statusHeaderHeight + geoManager.timeLineHeight + num*geoManager.rowHeight;
}
pixmap = osdManager.requestPixmap(1, cRect(x, y, geoManager.channelLogoWidth, geoManager.channelLogoHeight));
pixmapLogo = osdManager.requestPixmap(2, cRect(x, y, geoManager.channelLogoWidth, geoManager.channelLogoHeight));
pixmap = osdManager.CreatePixmap(1, cRect(x, y, geoManager.channelLogoWidth, geoManager.channelLogoHeight));
pixmapLogo = osdManager.CreatePixmap(2, cRect(x, y, geoManager.channelLogoWidth, geoManager.channelLogoHeight));
if ((!pixmap) || (!pixmapLogo)){
return;
}

36
osdmanager.c
View File

@ -2,9 +2,18 @@
#include "osdmanager.h"
cOsdManager::cOsdManager(void) {
osd = NULL;
}
bool cOsdManager::setOsd() {
void cOsdManager::Lock(void) {
mutex.Lock();
}
void cOsdManager::Unlock(void) {
mutex.Unlock();
}
bool cOsdManager::CreateOsd(void) {
osd = cOsdProvider::NewOsd(cOsd::OsdLeft(), cOsd::OsdTop());
if (osd) {
tArea Area = { 0, 0, cOsd::OsdWidth() - 1, cOsd::OsdHeight() - 1, 32 };
@ -15,7 +24,14 @@ bool cOsdManager::setOsd() {
return false;
}
void cOsdManager::setBackground() {
void cOsdManager::DeleteOsd(void) {
Lock();
delete osd;
osd = NULL;
Unlock();
}
void cOsdManager::SetBackground(void) {
if (config.displayStatusHeader && config.scaleVideo) {
int widthStatus = cOsd::OsdWidth() - geoManager.statusHeaderHeight * 16 / 9;
@ -27,12 +43,20 @@ void cOsdManager::setBackground() {
}
cPixmap *cOsdManager::requestPixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort) {
return osd->CreatePixmap(Layer, ViewPort, DrawPort);
cPixmap *cOsdManager::CreatePixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort) {
if (osd)
return osd->CreatePixmap(Layer, ViewPort, DrawPort);
return NULL;
}
void cOsdManager::releasePixmap(cPixmap *pixmap) {
if (!pixmap)
void cOsdManager::DestroyPixmap(cPixmap *pixmap) {
if (!osd || !pixmap)
return;
osd->DestroyPixmap(pixmap);
}
void cOsdManager::Flush(void) {
if (osd) {
osd->Flush();
}
}

31
osdmanager.h
View File

@ -4,20 +4,23 @@
#include <vdr/osd.h>
class cOsdManager {
private:
cOsd *osd;
public:
cOsdManager(void);
bool setOsd();
void setBackground();
void flush() {osd->Flush();};
cPixmap *requestPixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
void releasePixmap(cPixmap *pixmap);
void deleteOsd() {delete osd;};
int Width() { return osd->Width(); };
int Height() { return osd->Height(); };
int Top() { return osd->Top(); };
int Left() { return osd->Left(); };
private:
cOsd *osd;
cMutex mutex;
public:
cOsdManager(void);
void Lock(void);
void Unlock(void);
bool CreateOsd(void);
void DeleteOsd(void);
void SetBackground(void);
cPixmap *CreatePixmap(int Layer, const cRect &ViewPort, const cRect &DrawPort = cRect::Null);
void DestroyPixmap(cPixmap *pixmap);
void Flush(void);
int Width(void) { return osd->Width(); };
int Height(void) { return osd->Height(); };
int Top(void) { return osd->Top(); };
int Left(void) { return osd->Left(); };
};
#endif //__TVGUIDE_OSDMANAGER_H

14
recmenu.c
View File

@ -28,7 +28,7 @@ cRecMenu::~cRecMenu(void) {
if (footer)
delete footer;
if (pixmapScrollBar)
osdManager.releasePixmap(pixmapScrollBar);
osdManager.DestroyPixmap(pixmapScrollBar);
if (imgScrollBar)
delete imgScrollBar;
}
@ -81,15 +81,15 @@ bool cRecMenu::CalculateHeight(bool reDraw) {
void cRecMenu::CreatePixmap(void) {
if (pixmap)
osdManager.releasePixmap(pixmap);
pixmap = osdManager.requestPixmap(3, cRect(x, y, width, height));
osdManager.DestroyPixmap(pixmap);
pixmap = osdManager.CreatePixmap(3, cRect(x, y, width, height));
if (scrollable) {
int scrollBarX = x + width - scrollbarWidth - border;
int scrollBarY = y + border + headerHeight;
int scrollBarHeight = height - headerHeight - footerHeight - 2 * border;
if (pixmapScrollBar)
osdManager.releasePixmap(pixmapScrollBar);
pixmapScrollBar = osdManager.requestPixmap(4, cRect(scrollBarX, scrollBarY, scrollbarWidth, scrollBarHeight));
osdManager.DestroyPixmap(pixmapScrollBar);
pixmapScrollBar = osdManager.CreatePixmap(4, cRect(scrollBarX, scrollBarY, scrollbarWidth, scrollBarHeight));
} else
pixmapScrollBar = NULL;
}
@ -133,11 +133,11 @@ void cRecMenu::InitMenu(bool complete) {
numItems = 0;
if (scrollable) {
width -= scrollbarWidth + border;
osdManager.releasePixmap(pixmapScrollBar);
osdManager.DestroyPixmap(pixmapScrollBar);
pixmapScrollBar = NULL;
DELETENULL(imgScrollBar);
}
osdManager.releasePixmap(pixmap);
osdManager.DestroyPixmap(pixmap);
pixmap = NULL;
for (std::list<cRecMenuItem*>::iterator it = menuItems.begin(); it != menuItems.end(); it++) {
if (deleteMenuItems)

166
recmenuitem.c
View File

@ -30,7 +30,7 @@ void cRecMenuItem::SetGeometry(int x, int y, int width) {
void cRecMenuItem::SetPixmaps(void) {
if (!pixmap)
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
else
pixmap->SetViewPort(cRect(x, y, width, height));
}
@ -76,7 +76,7 @@ cRecMenuItemButton::cRecMenuItemButton(const char *text, eRecMenuState action, b
cRecMenuItemButton::~cRecMenuItemButton(void) {
if (pixmapText)
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapText);
}
int cRecMenuItemButton::GetWidth(void) {
@ -89,8 +89,8 @@ void cRecMenuItemButton::SetPixmaps(void) {
width = width / 2;
}
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapText->SetViewPort(cRect(x, y, width, height));
@ -158,8 +158,8 @@ void cRecMenuItemButtonYesNo::SetPixmaps(void) {
int noX = x + 52 * width / 100;
int yPixmaps = y + geoManager.borderRecMenus / 2;
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(yesX, yPixmaps, buttonWidth, height));
pixmapNo = new cStyledPixmap(osdManager.requestPixmap(4, cRect(noX, yPixmaps, buttonWidth, height)));
pixmap = osdManager.CreatePixmap(4, cRect(yesX, yPixmaps, buttonWidth, height));
pixmapNo = new cStyledPixmap(osdManager.CreatePixmap(4, cRect(noX, yPixmaps, buttonWidth, height)));
} else {
pixmap->SetViewPort(cRect(yesX, yPixmaps, buttonWidth, height));
pixmapNo->SetViewPort(cRect(noX, yPixmaps, buttonWidth, height));
@ -343,13 +343,13 @@ cRecMenuItemInt::cRecMenuItemInt(cString text,
cRecMenuItemInt::~cRecMenuItemInt(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
}
void cRecMenuItemInt::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(x, y, width, height));
@ -464,13 +464,13 @@ cRecMenuItemBool::cRecMenuItemBool(cString text,
cRecMenuItemBool::~cRecMenuItemBool(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
}
void cRecMenuItemBool::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(x, y, width, height));
@ -551,13 +551,13 @@ cRecMenuItemSelect::cRecMenuItemSelect(cString text,
cRecMenuItemSelect::~cRecMenuItemSelect(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
}
void cRecMenuItemSelect::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(x, y, width, height));
@ -659,13 +659,13 @@ cRecMenuItemSelectDirectory::cRecMenuItemSelectDirectory(cString text,
cRecMenuItemSelectDirectory::~cRecMenuItemSelectDirectory(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
}
void cRecMenuItemSelectDirectory::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(x, y, width, height));
@ -793,13 +793,13 @@ cRecMenuItemText::cRecMenuItemText(cString title,
cRecMenuItemText::~cRecMenuItemText(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
if (pixmapKeyboard)
delete pixmapKeyboard;
if (pixmapKeyboardHighlight)
osdManager.releasePixmap(pixmapKeyboardHighlight);
osdManager.DestroyPixmap(pixmapKeyboardHighlight);
if (pixmapKeyboardIcons)
osdManager.releasePixmap(pixmapKeyboardIcons);
osdManager.DestroyPixmap(pixmapKeyboardIcons);
delete[] valueUtf8;
delete[] allowedUtf8;
delete[] charMapUtf8;
@ -813,11 +813,11 @@ void cRecMenuItemText::SetPixmaps(void) {
int keyboardX = x + (100 - keyboardWidth)*width / 100;
int keyboardY = y + height;
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(xPixmapVal, yPixmapVal, widthPixmapVal, heightPixmapVal));
pixmapKeyboard = new cStyledPixmap(osdManager.requestPixmap(-1, cRect(keyboardX, keyboardY, keyboardWidth*width/100, keyboardHeight)));
pixmapKeyboardHighlight = osdManager.requestPixmap(-1, cRect(keyboardX, keyboardY, keyboardWidth*width/100, keyboardHeight));
pixmapKeyboardIcons = osdManager.requestPixmap(-1, cRect(keyboardX, keyboardY, keyboardWidth*width/100, keyboardHeight));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(xPixmapVal, yPixmapVal, widthPixmapVal, heightPixmapVal));
pixmapKeyboard = new cStyledPixmap(osdManager.CreatePixmap(-1, cRect(keyboardX, keyboardY, keyboardWidth*width/100, keyboardHeight)));
pixmapKeyboardHighlight = osdManager.CreatePixmap(-1, cRect(keyboardX, keyboardY, keyboardWidth*width/100, keyboardHeight));
pixmapKeyboardIcons = osdManager.CreatePixmap(-1, cRect(keyboardX, keyboardY, keyboardWidth*width/100, keyboardHeight));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(xPixmapVal, yPixmapVal, widthPixmapVal, heightPixmapVal));
@ -1350,13 +1350,13 @@ cRecMenuItemTime::cRecMenuItemTime(cString text,
cRecMenuItemTime::~cRecMenuItemTime(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
}
void cRecMenuItemTime::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(x, y, width, height));
@ -1489,13 +1489,13 @@ cRecMenuItemDay::cRecMenuItemDay(cString text,
cRecMenuItemDay::~cRecMenuItemDay(void) {
if (pixmapVal)
osdManager.releasePixmap(pixmapVal);
osdManager.DestroyPixmap(pixmapVal);
}
void cRecMenuItemDay::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapVal = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapVal->SetViewPort(cRect(x, y, width, height));
@ -1580,16 +1580,16 @@ cRecMenuItemTimer::cRecMenuItemTimer(const cTimer *timer,
cRecMenuItemTimer::~cRecMenuItemTimer(void) {
if (pixmapIcons)
osdManager.releasePixmap(pixmapIcons);
osdManager.DestroyPixmap(pixmapIcons);
if (pixmapStatus)
osdManager.releasePixmap(pixmapStatus);
osdManager.DestroyPixmap(pixmapStatus);
}
void cRecMenuItemTimer::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapStatus = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapStatus = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.CreatePixmap(6, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapStatus->SetViewPort(cRect(x, y, width, height));
@ -1765,13 +1765,13 @@ cRecMenuItemTimerConflictHeader::cRecMenuItemTimerConflictHeader(time_t conflict
cRecMenuItemTimerConflictHeader::~cRecMenuItemTimerConflictHeader(void) {
if (pixmapStatus)
osdManager.releasePixmap(pixmapStatus);
osdManager.DestroyPixmap(pixmapStatus);
}
void cRecMenuItemTimerConflictHeader::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapStatus = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapStatus = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapStatus->SetViewPort(cRect(x, y, width, height));
@ -1845,17 +1845,17 @@ cRecMenuItemEvent::cRecMenuItemEvent(const cEvent *event,
cRecMenuItemEvent::~cRecMenuItemEvent(void) {
if (pixmapIcons)
osdManager.releasePixmap(pixmapIcons);
osdManager.DestroyPixmap(pixmapIcons);
if (pixmapText)
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapText);
}
void cRecMenuItemEvent::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.requestPixmap(5, cRect(x, y, width - height / 2 - 10, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.CreatePixmap(5, cRect(x, y, width - height / 2 - 10, height));
pixmapText->Fill(clrTransparent);
pixmapIcons = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmapIcons = osdManager.CreatePixmap(6, cRect(x, y, width, height));
pixmapIcons->Fill(clrTransparent);
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
@ -1998,13 +1998,13 @@ cRecMenuItemChannelChooser::cRecMenuItemChannelChooser(cString text,
cRecMenuItemChannelChooser::~cRecMenuItemChannelChooser(void) {
if (pixmapChannel)
osdManager.releasePixmap(pixmapChannel);
osdManager.DestroyPixmap(pixmapChannel);
}
void cRecMenuItemChannelChooser::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapChannel = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapChannel = osdManager.CreatePixmap(5, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapChannel->SetViewPort(cRect(x, y, width, height));
@ -2151,16 +2151,16 @@ cRecMenuItemDayChooser::cRecMenuItemDayChooser(cString text,
cRecMenuItemDayChooser::~cRecMenuItemDayChooser(void) {
if (pixmapWeekdays)
osdManager.releasePixmap(pixmapWeekdays);
osdManager.DestroyPixmap(pixmapWeekdays);
if (pixmapWeekdaysSelect)
osdManager.releasePixmap(pixmapWeekdaysSelect);
osdManager.DestroyPixmap(pixmapWeekdaysSelect);
}
void cRecMenuItemDayChooser::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapWeekdays = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapWeekdaysSelect = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapWeekdays = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapWeekdaysSelect = osdManager.CreatePixmap(6, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapWeekdays->SetViewPort(cRect(x, y, width, height));
@ -2286,13 +2286,13 @@ cRecMenuItemRecording::cRecMenuItemRecording(const cRecording *recording, bool a
cRecMenuItemRecording::~cRecMenuItemRecording(void) {
if (pixmapText)
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapText);
}
void cRecMenuItemRecording::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapText->Fill(clrTransparent);
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
@ -2371,20 +2371,20 @@ cRecMenuItemTimelineHeader::cRecMenuItemTimelineHeader(time_t day, int numTimers
cRecMenuItemTimelineHeader::~cRecMenuItemTimelineHeader(void) {
if (pixmapTimeline)
osdManager.releasePixmap(pixmapTimeline);
osdManager.DestroyPixmap(pixmapTimeline);
if (pixmapTimerInfo)
osdManager.releasePixmap(pixmapTimerInfo);
osdManager.DestroyPixmap(pixmapTimerInfo);
if (pixmapTimerConflicts)
osdManager.releasePixmap(pixmapTimerConflicts);
osdManager.DestroyPixmap(pixmapTimerConflicts);
}
void cRecMenuItemTimelineHeader::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapTimeline = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapTimerInfo = osdManager.requestPixmap(6, cRect(x, y + 3 * font->Height() / 2, width, 2 * font->Height()));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapTimeline = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapTimerInfo = osdManager.CreatePixmap(6, cRect(x, y + 3 * font->Height() / 2, width, 2 * font->Height()));
if (conflicts.size() > 0) {
pixmapTimerConflicts = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmapTimerConflicts = osdManager.CreatePixmap(6, cRect(x, y, width, height));
}
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
@ -2560,17 +2560,17 @@ cRecMenuItemTimelineTimer::cRecMenuItemTimelineTimer(const cTimer *timer, time_t
cRecMenuItemTimelineTimer::~cRecMenuItemTimelineTimer(void) {
if (pixmapBack)
osdManager.releasePixmap(pixmapBack);
osdManager.DestroyPixmap(pixmapBack);
if (pixmapTimerConflicts)
osdManager.releasePixmap(pixmapTimerConflicts);
osdManager.DestroyPixmap(pixmapTimerConflicts);
}
void cRecMenuItemTimelineTimer::SetPixmaps(void) {
if (!pixmap) {
pixmapBack = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmap = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapBack = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(5, cRect(x, y, width, height));
if (conflicts.size() > 0) {
pixmapTimerConflicts = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmapTimerConflicts = osdManager.CreatePixmap(6, cRect(x, y, width, height));
}
} else {
pixmapBack->SetViewPort(cRect(x, y, width, height));
@ -2727,16 +2727,16 @@ cRecMenuItemSearchTimer::cRecMenuItemSearchTimer(cTVGuideSearchTimer timer,
cRecMenuItemSearchTimer::~cRecMenuItemSearchTimer(void) {
if (pixmapText)
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapText);
if (pixmapIcons)
osdManager.releasePixmap(pixmapIcons);
osdManager.DestroyPixmap(pixmapIcons);
}
void cRecMenuItemSearchTimer::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.CreatePixmap(6, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapText->SetViewPort(cRect(x, y, width, height));
@ -2854,16 +2854,16 @@ cRecMenuItemFavorite::cRecMenuItemFavorite(cTVGuideSearchTimer favorite,
cRecMenuItemFavorite::~cRecMenuItemFavorite(void) {
if (pixmapText)
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapText);
if (pixmapIcons)
osdManager.releasePixmap(pixmapIcons);
osdManager.DestroyPixmap(pixmapIcons);
}
void cRecMenuItemFavorite::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.CreatePixmap(6, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapText->SetViewPort(cRect(x, y, width, height));
@ -2929,16 +2929,16 @@ cRecMenuItemFavoriteStatic::cRecMenuItemFavoriteStatic(std::string text, eRecMen
cRecMenuItemFavoriteStatic::~cRecMenuItemFavoriteStatic(void) {
if (pixmapText)
osdManager.releasePixmap(pixmapText);
osdManager.DestroyPixmap(pixmapText);
if (pixmapIcons)
osdManager.releasePixmap(pixmapIcons);
osdManager.DestroyPixmap(pixmapIcons);
}
void cRecMenuItemFavoriteStatic::SetPixmaps(void) {
if (!pixmap) {
pixmap = osdManager.requestPixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.requestPixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.requestPixmap(6, cRect(x, y, width, height));
pixmap = osdManager.CreatePixmap(4, cRect(x, y, width, height));
pixmapText = osdManager.CreatePixmap(5, cRect(x, y, width, height));
pixmapIcons = osdManager.CreatePixmap(6, cRect(x, y, width, height));
} else {
pixmap->SetViewPort(cRect(x, y, width, height));
pixmapText->SetViewPort(cRect(x, y, width, height));

12
recmenuview.c
View File

@ -37,7 +37,7 @@ void cRecMenuView::Start(const cEvent *event) {
this->event = event;
activeMenu = new cRecMenuMain(recManager->EpgSearchAvailable(), recManager->CheckEventForTimer(event), SwitchTimers.EventInSwitchList(event));
activeMenu->Display();
osdManager.flush();
osdManager.Flush();
}
void cRecMenuView::StartFavorites(void) {
@ -49,7 +49,7 @@ void cRecMenuView::StartFavorites(void) {
recManager->GetFavorites(&favorites);
activeMenu = new cRecMenuFavorites(favorites);
activeMenu->Display();
osdManager.flush();
osdManager.Flush();
}
@ -70,7 +70,7 @@ void cRecMenuView::Close(void) {
void cRecMenuView::SetBackground(void) {
int backgroundWidth = geoManager.osdWidth;
int backgroundHeight = geoManager.osdHeight;
pixmapBackground = osdManager.requestPixmap(3, cRect(0, 0, backgroundWidth, backgroundHeight));
pixmapBackground = osdManager.CreatePixmap(3, cRect(0, 0, backgroundWidth, backgroundHeight));
pixmapBackground->Fill(theme.Color(clrRecMenuBackground));
if (config.scaleVideo) {
int tvHeight = geoManager.statusHeaderHeight;
@ -81,7 +81,7 @@ void cRecMenuView::SetBackground(void) {
}
void cRecMenuView::DeleteBackground(void) {
osdManager.releasePixmap(pixmapBackground);
osdManager.DestroyPixmap(pixmapBackground);
}
void cRecMenuView::DisplaySearchTimerList(void) {
@ -994,12 +994,12 @@ eOSState cRecMenuView::ProcessKey(eKeys Key) {
activeMenu->UpdateActiveMenuItem();
activeMenu->Show();
state = osContinue;
osdManager.flush();
osdManager.Flush();
}
return state;
}
state = StateMachine(nextState);
}
osdManager.flush();
osdManager.Flush();
return state;
}

10
statusheader.c
View File

@ -9,14 +9,14 @@ cStatusHeader::cStatusHeader(void) {
height = geoManager.statusHeaderHeight;
width = geoManager.headerContentWidth;
tvFrameWidth = geoManager.tvFrameWidth;
pixmap = osdManager.requestPixmap(1, cRect(0, 0, width, height));
pixmapText = osdManager.requestPixmap(2, cRect(0, 0, width, height));
pixmapTVFrame = osdManager.requestPixmap(1, cRect(width, 0, tvFrameWidth, height));
pixmap = osdManager.CreatePixmap(1, cRect(0, 0, width, height));
pixmapText = osdManager.CreatePixmap(2, cRect(0, 0, width, height));
pixmapTVFrame = osdManager.CreatePixmap(1, cRect(width, 0, tvFrameWidth, height));
}
cStatusHeader::~cStatusHeader(void) {
osdManager.releasePixmap(pixmapText);
osdManager.releasePixmap(pixmapTVFrame);
osdManager.DestroyPixmap(pixmapText);
osdManager.DestroyPixmap(pixmapTVFrame);
if (config.scaleVideo) {
cRect vidWin = cDevice::PrimaryDevice()->CanScaleVideo(cRect::Null);
cDevice::PrimaryDevice()->ScaleVideo(vidWin);

2
styledpixmap.c
View File

@ -12,7 +12,7 @@ cStyledPixmap::cStyledPixmap(cPixmap *pixmap) {
cStyledPixmap::~cStyledPixmap(void) {
if (pixmap)
osdManager.releasePixmap(pixmap);
osdManager.DestroyPixmap(pixmap);
}
void cStyledPixmap::setPixmap(cPixmap *pixmap) {

14
timeline.c
View File

@ -25,9 +25,9 @@ cTimeLine::cTimeLine(cTimeManager *timeManager) {
y12 = geoManager.statusHeaderHeight;
y22 = geoManager.timeLineHeight;
}
dateViewer = new cStyledPixmap(osdManager.requestPixmap(1, cRect(x11, y11, x21, y21)));
timeline = osdManager.requestPixmap(2, cRect(x12, y12, x22, y22));
clock = new cStyledPixmap(osdManager.requestPixmap(3, cRect(0,
dateViewer = new cStyledPixmap(osdManager.CreatePixmap(1, cRect(x11, y11, x21, y21)));
timeline = osdManager.CreatePixmap(2, cRect(x12, y12, x22, y22));
clock = new cStyledPixmap(osdManager.CreatePixmap(3, cRect(0,
geoManager.statusHeaderHeight,
geoManager.clockWidth,
geoManager.clockHeight)));
@ -36,8 +36,8 @@ cTimeLine::cTimeLine(cTimeManager *timeManager) {
cTimeLine::~cTimeLine(void) {
if (clock)
delete clock;
osdManager.releasePixmap(timeBase);
osdManager.releasePixmap(timeline);
osdManager.DestroyPixmap(timeBase);
osdManager.DestroyPixmap(timeline);
if (dateViewer)
delete dateViewer;
}
@ -205,7 +205,7 @@ void cTimeLine::DrawTimeIndicator(void) {
return;
}
int deltaTime = (time(0) - timeManager->GetStart()) / 60 * geoManager.minutePixel;
osdManager.releasePixmap(timeBase);
osdManager.DestroyPixmap(timeBase);
int x1, x2, y1, y2;
if (config.displayMode == eVertical) {
x1 = 0;
@ -218,7 +218,7 @@ void cTimeLine::DrawTimeIndicator(void) {
x2 = 4;
y2 = geoManager.timeLineHeight + config.channelRows * geoManager.rowHeight;
}
timeBase = osdManager.requestPixmap(3, cRect(x1, y1, x2, y2));
timeBase = osdManager.CreatePixmap(3, cRect(x1, y1, x2, y2));
timeBase->Fill(clrTransparent);
timeBase->DrawRectangle(cRect(0, 0, timeBase->ViewPort().Width(), timeBase->ViewPort().Height()), theme.Color(clrTimeBase));
}

42
tvguideosd.c
View File

@ -33,14 +33,12 @@ cTvGuideOsd::~cTvGuideOsd() {
delete recMenuView;
if (channelJumper)
delete channelJumper;
osdManager.deleteOsd();
osdManager.DeleteOsd();
}
void cTvGuideOsd::Show(void) {
int start = cTimeMs::Now();
bool ok = false;
ok = osdManager.setOsd();
if (ok) {
if (osdManager.CreateOsd()) {
bool themeChanged = config.LoadTheme();
config.SetStyle();
config.setDynamicValues();
@ -51,7 +49,7 @@ void cTvGuideOsd::Show(void) {
imgCache.Clear();
imgCache.CreateCache();
}
osdManager.setBackground();
osdManager.SetBackground();
timeManager = new cTimeManager();
timeManager->Now();
SwitchTimers.Load(AddDirectory(cPlugin::ConfigDirectory("epgsearch"), "epgsearchswitchtimers.conf"));
@ -125,10 +123,10 @@ void cTvGuideOsd::drawOsd() {
footer->drawYellowButton();
}
footer->drawBlueButton(false);
osdManager.flush();
osdManager.Flush();
readChannels(newStartChannel);
drawGridsChannelJump(offset);
osdManager.flush();
osdManager.Flush();
cPixmap::Unlock();
}
@ -289,7 +287,7 @@ void cTvGuideOsd::channelForward() {
if (activeGrid && (config.channelJumpMode == eGroupJump)) {
footer->UpdateGroupButtons(activeGrid->column->getChannel());
}
osdManager.flush();
osdManager.Flush();
}
void cTvGuideOsd::channelBack() {
@ -347,7 +345,7 @@ void cTvGuideOsd::channelBack() {
if (activeGrid && (config.channelJumpMode == eGroupJump)) {
footer->UpdateGroupButtons(activeGrid->column->getChannel());
}
osdManager.flush();
osdManager.Flush();
}
void cTvGuideOsd::timeForward() {
@ -367,7 +365,7 @@ void cTvGuideOsd::timeForward() {
if (!actionDone) {
ScrollForward();
}
osdManager.flush();
osdManager.Flush();
}
void cTvGuideOsd::ScrollForward() {
@ -406,7 +404,7 @@ void cTvGuideOsd::timeBack() {
if (!actionDone) {
ScrollBack();
}
osdManager.flush();
osdManager.Flush();
}
void cTvGuideOsd::ScrollBack() {
@ -518,7 +516,7 @@ void cTvGuideOsd::processKeyGreen() {
else
drawGridsChannelJump(currentCol);
}
osdManager.flush();
osdManager.Flush();
}
}
@ -568,7 +566,7 @@ void cTvGuideOsd::processKeyYellow() {
else
drawGridsChannelJump(currentCol);
}
osdManager.flush();
osdManager.Flush();
}
}
@ -619,9 +617,9 @@ void cTvGuideOsd::DetailedEPG() {
detailViewActive = true;
detailView = new cDetailView(activeGrid->GetEvent(), footer);
footer->SetDetailedViewMode();
osdManager.flush();
osdManager.Flush();
detailView->Start();
osdManager.flush();
osdManager.Flush();
}
}
@ -675,7 +673,7 @@ void cTvGuideOsd::TimeJump(int mode) {
timeLine->DrawDateViewer();
timeLine->DrawClock();
timeLine->DrawTimeline();
osdManager.flush();
osdManager.Flush();
}
int cTvGuideOsd::GetLastValidChannel(void) {
@ -689,7 +687,7 @@ void cTvGuideOsd::ChannelJump(int num) {
}
channelJumper->Set(num);
channelJumper->DrawText();
osdManager.flush();
osdManager.Flush();
}
void cTvGuideOsd::CheckTimeout(void) {
@ -714,7 +712,7 @@ void cTvGuideOsd::CheckTimeout(void) {
drawGridsChannelJump();
}
}
osdManager.flush();
osdManager.Flush();
}
}
@ -732,7 +730,7 @@ eOSState cTvGuideOsd::ProcessKey(eKeys Key) {
state = recMenuView->ProcessKey(Key);
if (state == osEnd) {
SetTimers();
osdManager.flush();
osdManager.Flush();
}
state = osContinue;
} else if (detailViewActive) {
@ -748,7 +746,7 @@ eOSState cTvGuideOsd::ProcessKey(eKeys Key) {
if ((config.blueKeyMode == eBlueKeySwitch) || (config.blueKeyMode == eBlueKeyFavorites)) {
state = ChannelSwitch(&alreadyUnlocked);
} else {
osdManager.flush();
osdManager.Flush();
state = osContinue;
}
} else if ((Key & ~k_Repeat) == kOk && (config.blueKeyMode == eBlueKeyEPG)) {
@ -762,7 +760,7 @@ eOSState cTvGuideOsd::ProcessKey(eKeys Key) {
delete detailView;
detailView = NULL;
detailViewActive = false;
osdManager.flush();
osdManager.Flush();
state = osContinue;
}
}
@ -787,7 +785,7 @@ eOSState cTvGuideOsd::ProcessKey(eKeys Key) {
default: break;
}
if (timeLine->DrawClock()) {
osdManager.flush();
osdManager.Flush();
}
}
if (!alreadyUnlocked) {

68
view.c
View File

@ -41,19 +41,19 @@ cView::cView(void) : cThread("View") {
cView::~cView(void) {
if (pixmapBackground)
osdManager.releasePixmap(pixmapBackground);
osdManager.DestroyPixmap(pixmapBackground);
if (pixmapHeader)
delete pixmapHeader;
if (pixmapHeaderLogo)
osdManager.releasePixmap(pixmapHeaderLogo);
osdManager.DestroyPixmap(pixmapHeaderLogo);
if (pixmapContent)
osdManager.releasePixmap(pixmapContent);
osdManager.DestroyPixmap(pixmapContent);
if (pixmapTabs)
osdManager.releasePixmap(pixmapTabs);
osdManager.DestroyPixmap(pixmapTabs);
if (pixmapScrollbar)
osdManager.releasePixmap(pixmapScrollbar);
osdManager.DestroyPixmap(pixmapScrollbar);
if (pixmapScrollbarBack)
osdManager.releasePixmap(pixmapScrollbarBack);
osdManager.DestroyPixmap(pixmapScrollbarBack);
if (imgScrollBar)
delete imgScrollBar;
}
@ -81,11 +81,11 @@ void cView::SetGeometry(void) {
void cView::DrawHeader(void) {
if (!pixmapHeader) {
pixmapHeader = new cStyledPixmap(osdManager.requestPixmap(5, cRect(0, 0, headerWidth, headerHeight)));
pixmapHeader = new cStyledPixmap(osdManager.CreatePixmap(5, cRect(0, 0, headerWidth, headerHeight)));
pixmapHeader->setColor(theme.Color(clrHeader), theme.Color(clrHeaderBlending));
}
if (!pixmapHeaderLogo) {
pixmapHeaderLogo = osdManager.requestPixmap(6, cRect(0, 0, width, headerHeight));
pixmapHeaderLogo = osdManager.CreatePixmap(6, cRect(0, 0, width, headerHeight));
}
pixmapHeader->Fill(clrTransparent);
pixmapHeaderLogo->Fill(clrTransparent);
@ -168,7 +168,7 @@ void cView::DrawHeader(void) {
void cView::DrawTabs(void) {
if (!pixmapTabs) {
pixmapTabs = osdManager.requestPixmap(4, cRect(0, y + headerHeight + contentHeight, width + scrollbarWidth, tabHeight));
pixmapTabs = osdManager.CreatePixmap(4, cRect(0, y + headerHeight + contentHeight, width + scrollbarWidth, tabHeight));
}
tColor bgColor = theme.Color(clrTabInactive);
pixmapTabs->Fill(clrTransparent);
@ -195,18 +195,18 @@ void cView::DrawTabs(void) {
void cView::ClearContent(void) {
if (pixmapContent && Running()) {
osdManager.releasePixmap(pixmapContent);
osdManager.DestroyPixmap(pixmapContent);
pixmapContent = NULL;
}
if (pixmapBackground && Running()) {
osdManager.releasePixmap(pixmapBackground);
osdManager.DestroyPixmap(pixmapBackground);
pixmapBackground = NULL;
}
}
void cView::CreateContent(int fullHeight) {
scrollable = false;
pixmapBackground = osdManager.requestPixmap(3, cRect(x, y + headerHeight, width + scrollbarWidth, contentHeight + tabHeight));
pixmapBackground = osdManager.CreatePixmap(3, cRect(x, y + headerHeight, width + scrollbarWidth, contentHeight + tabHeight));
pixmapBackground->Fill(theme.Color(clrBackground));
int drawPortHeight = contentHeight;
@ -214,7 +214,7 @@ void cView::CreateContent(int fullHeight) {
drawPortHeight = fullHeight;
scrollable = true;
}
pixmapContent = osdManager.requestPixmap(4, cRect(x, y + headerHeight, width, contentHeight), cRect(0, 0, width, drawPortHeight));
pixmapContent = osdManager.CreatePixmap(4, cRect(x, y + headerHeight, width, contentHeight), cRect(0, 0, width, drawPortHeight));
pixmapContent->Fill(clrTransparent);
}
@ -264,7 +264,7 @@ void cView::DrawFloatingContent(std::string *infoText, cTvMedia *img, cTvMedia *
pixmapContent->DrawText(cPoint(border, yText), wTextFull.GetLine(i), theme.Color(clrFont), clrTransparent, font);
yText += lineHeight;
}
osdManager.flush();
osdManager.Flush();
cImageLoader imgLoader;
if (imgLoader.LoadPoster(img->path.c_str(), imgWidth, imgHeight)) {
if (Running() && pixmapContent)
@ -272,7 +272,7 @@ void cView::DrawFloatingContent(std::string *infoText, cTvMedia *img, cTvMedia *
}
if (!img2)
return;
osdManager.flush();
osdManager.Flush();
if (imgLoader.LoadPoster(img2->path.c_str(), imgWidth2, imgHeight2)) {
if (Running() && pixmapContent)
pixmapContent->DrawImage(cPoint(width - imgWidth2 - border, imgHeight + 2 * border), imgLoader.GetImage());
@ -401,7 +401,7 @@ void cView::DrawActors(std::vector<cActor> *actors) {
}
actor++;
}
osdManager.flush();
osdManager.Flush();
x = 0;
y += thumbHeight + 2 * fontSmall->Height() + border + border/2;
}
@ -427,11 +427,11 @@ void cView::DrawScrollbar(void) {
return;
if (!pixmapScrollbar) {
pixmapScrollbar = osdManager.requestPixmap(6, cRect(width, y + headerHeight, scrollbarWidth, contentHeight));
pixmapScrollbar = osdManager.CreatePixmap(6, cRect(width, y + headerHeight, scrollbarWidth, contentHeight));
pixmapScrollbar->Fill(clrTransparent);
}
if (!pixmapScrollbarBack) {
pixmapScrollbarBack = osdManager.requestPixmap(5, cRect(width, y + headerHeight, scrollbarWidth, contentHeight));
pixmapScrollbarBack = osdManager.CreatePixmap(5, cRect(width, y + headerHeight, scrollbarWidth, contentHeight));
pixmapScrollbarBack->Fill(clrTransparent);
}
@ -587,7 +587,7 @@ void cEPGView::DrawImages(void) {
if (drawPic) {
pixmapContent->DrawImage(cPoint((width - imgWidth) / 2, yPic), imgLoader.GetImage());
yPic += imgHeight + border;
osdManager.flush();
osdManager.Flush();
}
}
}
@ -612,7 +612,7 @@ void cEPGView::Action(void) {
ClearContent();
if (!headerDrawn) {
DrawHeader();
osdManager.flush();
osdManager.Flush();
headerDrawn = true;
}
if (tabs.size() == 0) {
@ -632,7 +632,7 @@ void cEPGView::Action(void) {
break;
}
DrawScrollbar();
osdManager.flush();
osdManager.Flush();
}
/********************************************************************************************
@ -755,32 +755,32 @@ void cSeriesView::DrawImages(void) {
if (imgLoader.LoadPoster(series.banners[i].path.c_str(), series.banners[i].width, series.banners[i].height) && Running()) {
pixmapContent->DrawImage(cPoint((width - series.banners[i].width) / 2, yPic), imgLoader.GetImage());
yPic += series.banners[i].height + border;
osdManager.flush();
osdManager.Flush();
}
}
if (imgLoader.LoadPoster(series.fanarts[i].path.c_str(), fanartWidth, fanartHeight) && Running()) {
pixmapContent->DrawImage(cPoint((width - fanartWidth)/2, yPic), imgLoader.GetImage());
yPic += fanartHeight + border;
osdManager.flush();
osdManager.Flush();
}
}
if (numPosters >= 1) {
if (imgLoader.LoadPoster(series.posters[0].path.c_str(), posterWidth, posterHeight) && Running()) {
pixmapContent->DrawImage(cPoint(border, yPic), imgLoader.GetImage());
osdManager.flush();
osdManager.Flush();
yPic += posterHeight + border;
}
}
if (numPosters >= 2) {
if (imgLoader.LoadPoster(series.posters[1].path.c_str(), posterWidth, posterHeight) && Running()) {
pixmapContent->DrawImage(cPoint(2 * border + posterWidth, yPic - posterHeight - border), imgLoader.GetImage());
osdManager.flush();
osdManager.Flush();
}
}
if (numPosters == 3) {
if (imgLoader.LoadPoster(series.posters[2].path.c_str(), posterWidth, posterHeight) && Running()) {
pixmapContent->DrawImage(cPoint((width - posterWidth) / 2, yPic), imgLoader.GetImage());
osdManager.flush();
osdManager.Flush();
}
}
}
@ -814,7 +814,7 @@ void cSeriesView::Action(void) {
ClearContent();
if (!headerDrawn) {
DrawHeader();
osdManager.flush();
osdManager.Flush();
headerDrawn = true;
}
if (tabs.size() == 0) {
@ -856,7 +856,7 @@ void cSeriesView::Action(void) {
break;
}
DrawScrollbar();
osdManager.flush();
osdManager.Flush();
}
/********************************************************************************************
@ -982,28 +982,28 @@ void cMovieView::DrawImages(void) {
if (imgLoader.LoadPoster(movie.fanart.path.c_str(), fanartWidth, fanartHeight) && Running()) {
pixmapContent->DrawImage(cPoint((width - fanartWidth)/2, yPic), imgLoader.GetImage());
yPic += fanartHeight + border;
osdManager.flush();
osdManager.Flush();
}
}
if (movie.collectionFanart.width > 0 && movie.collectionFanart.height > 0 && movie.collectionFanart.path.size() > 0) {
if (imgLoader.LoadPoster(movie.collectionFanart.path.c_str(), collectionFanartWidth, collectionFanartHeight) && Running()) {
pixmapContent->DrawImage(cPoint((width - collectionFanartWidth)/2, yPic), imgLoader.GetImage());
yPic += collectionFanartHeight + border;
osdManager.flush();
osdManager.Flush();
}
}
if (movie.poster.width > 0 && movie.poster.height > 0 && movie.poster.path.size() > 0) {
if (imgLoader.LoadPoster(movie.poster.path.c_str(), movie.poster.width, movie.poster.height) && Running()) {
pixmapContent->DrawImage(cPoint((width - movie.poster.width) / 2, yPic), imgLoader.GetImage());
yPic += movie.poster.height + border;
osdManager.flush();
osdManager.Flush();
}
}
if (movie.collectionPoster.width > 0 && movie.collectionPoster.height > 0 && movie.collectionPoster.path.size() > 0) {
if (imgLoader.LoadPoster(movie.collectionPoster.path.c_str(), movie.collectionPoster.width, movie.collectionPoster.height) && Running()) {
pixmapContent->DrawImage(cPoint((width - movie.collectionPoster.width) / 2, yPic), imgLoader.GetImage());
yPic += movie.collectionPoster.height + border;
osdManager.flush();
osdManager.Flush();
}
}
}
@ -1028,7 +1028,7 @@ void cMovieView::Action(void) {
ClearContent();
if (!headerDrawn) {
DrawHeader();
osdManager.flush();
osdManager.Flush();
headerDrawn = true;
}
if (tabs.size() == 0) {
@ -1064,5 +1064,5 @@ void cMovieView::Action(void) {
break;
}
DrawScrollbar();
osdManager.flush();
osdManager.Flush();
}