eOSState cMenuLogMod::ProcessKey(eKeys Key)
{
eOSState state=cOsdMenu::ProcessKey(Key);
switch(state) {
case osUser9:
if(Interface->Confirm(tr("Really reset module to default?"))) {
cLogging::SetModuleDefault(LCLASS(m,0));
ScSetup.Store(false); state=osBack;
}
break;
case osContinue:
if(NORMALKEY(Key)==kLeft || NORMALKEY(Key)==kRight) {
cLogOptItem *item=dynamic_cast<cLogOptItem *>(Get(Current()));
if(item) {
int o=item->Option();
cLogging::SetModuleOption(LCLASS(m,1<<o),cfg[o]);
}
}
break;
case osUnknown:
if(Key==kOk) { Store(); state=osBack; }
break;
default:
break;
}
return state;
}
eOSState cMenuSetupSc::ProcessKey(eKeys Key)
{
eOSState state = cOsdMenu::ProcessKey(Key);
switch(state) {
case osUser4:
if(Feature.SmartCard()) {
cScInfoItem *ii=dynamic_cast<cScInfoItem *>(Get(Current()));
if(ii) return(AddSubMenu(new cMenuInfoCard(ii->Ident())));
}
state=osContinue;
break;
case osUser7:
state=osContinue;
if(Interface->Confirm(tr("Really flush ECM cache?"))) {
state=osEnd;
}
break;
case osUser8:
return AddSubMenu(new cMenuInfoSc);
case osUser6:
return AddSubMenu(new cMenuLogSys);
case osUser5:
return AddSubMenu(new cMenuSysOpts);
case osUser9:
state=osContinue;
if(!cGlobal::Active(true)) {
if(Interface->Confirm(tr("Really reload files?"))) {
Store();
cSoftCAM::Load(cfgdir);
state=osEnd;
}
}
else
Skins.Message(mtError,tr("Active! Can't reload files now"));
break;
case osContinue:
if(NORMALKEY(Key)==kUp || NORMALKEY(Key)==kDown) {
cOsdItem *item=Get(Current());
if(item) item->ProcessKey(kNone);
}
break;
case osUnknown:
if(Key==kOk) { Store(); state=osBack; }
break;
default:
break;
}
return state;
}
eOSState cMenuEditHexItem::ProcessKey(eKeys Key)
{
switch(NORMALKEY(Key)) {
case kUp:
case kDown:
if(isOn) SetButtons(false);
break;
default:
if(!isOn) SetButtons(true);
break;
}
eOSState state=cMenuEditItem::ProcessKey(Key);
if(state!=osUnknown) return state;
int newValue=*value;
bool IsRepeat=Key & k_Repeat;
Key=NORMALKEY(Key);
switch(Key) {
case kBlue:
abc=!abc; SetButtons(true);
break;
case kRed:
case kGreen:
case kYellow:
case k0 ... k9:
{
if(fresh) { newValue=0; fresh=false; }
int add;
if(Key>=kRed && Key<=kYellow) add=(abc ? 10:13)+(Key-kRed);
else add=(Key-k0);
newValue=newValue*16+add;
break;
}
case kLeft:
newValue=*value-1; fresh=true;
if(!IsRepeat && newValue<min) newValue=max;
break;
case kRight:
newValue=*value+1; fresh=true;
if(!IsRepeat && newValue>max) newValue=min;
break;
default:
if(*value<min) { *value=min; Set(); }
if(*value>max) { *value=max; Set(); }
return osUnknown;
}
if(newValue!=*value && (!fresh || min<=newValue) && newValue<=max) {
*value=newValue;
Set();
}
return osContinue;
}
eOSState cSatipEditSrcItem::ProcessKey(eKeys Key)
{
eOSState state = cMenuEditItem::ProcessKey(Key);
if (state == osUnknown) {
bool IsRepeat = Key & k_Repeat;
Key = NORMALKEY(Key);
if (Key == kLeft) { // TODO might want to increase the delta if repeated quickly?
if (source) {
if (source->Prev())
source = (cSource *)source->Prev();
else if (!IsRepeat)
source = Sources.Last();
*value = source->Code();
}
}
else if (Key == kRight) {
if (source) {
if (source->Next())
source = (cSource *)source->Next();
else if (!IsRepeat)
source = Sources.First();
}
else
source = Sources.First();
if (source)
*value = source->Code();
}
else
return state; // we don't call cMenuEditIntItem::ProcessKey(Key) here since we don't accept numerical input
Set();
state = osContinue;
}
return state;
}
eOSState cMenuEditIntItem::ProcessKey(eKeys Key)
{
eOSState state = cMenuEditItem::ProcessKey(Key);
if (state == osUnknown) {
int newValue = *value;
Key = NORMALKEY(Key);
switch (Key) {
case kNone: break;
case k0 ... k9:
if (fresh) {
newValue = 0;
fresh = false;
}
newValue = newValue * 10 + (Key - k0);
break;
case kLeft: // TODO might want to increase the delta if repeated quickly?
newValue = *value - 1;
fresh = true;
break;
case kRight:
newValue = *value + 1;
fresh = true;
break;
default:
if (*value < min) { *value = min; Set(); }
if (*value > max) { *value = max; Set(); }
return state;
}
if (newValue != *value && (!fresh || min <= newValue) && newValue <= max) {
*value = newValue;
Set();
}
state = osContinue;
}
eOSState cSatipMenuInfo::ProcessKey(eKeys keyP)
{
switch (int(keyP)) {
case kUp|k_Repeat:
case kUp:
case kDown|k_Repeat:
case kDown:
case kLeft|k_Repeat:
case kLeft:
case kRight|k_Repeat:
case kRight:
DisplayMenu()->Scroll(NORMALKEY(keyP) == kUp || NORMALKEY(keyP) == kLeft, NORMALKEY(keyP) == kLeft || NORMALKEY(keyP) == kRight);
cStatus::MsgOsdTextItem(NULL, NORMALKEY(keyP) == kUp || NORMALKEY(keyP) == kLeft);
return osContinue;
default: break;
}
eOSState state = cOsdMenu::ProcessKey(keyP);
if (state == osUnknown) {
switch (keyP) {
case kOk: return osBack;
case kRed: pageM = SATIP_DEVICE_INFO_GENERAL;
UpdateInfo();
break;
case kGreen: pageM = SATIP_DEVICE_INFO_PIDS;
UpdateInfo();
break;
case kYellow: pageM = SATIP_DEVICE_INFO_FILTERS;
UpdateInfo();
break;
case kBlue: SatipConfig.SetUseBytes(SatipConfig.GetUseBytes() ? 0 : 1);
UpdateInfo();
break;
default: if (timeoutM.TimedOut())
UpdateInfo();
state = osContinue;
break;
}
}
return state;
}
eOSState cMenuSysOpts::ProcessKey(eKeys Key)
{
eOSState state=cOsdMenu::ProcessKey(Key);
switch(state) {
case osContinue:
if(NORMALKEY(Key)==kUp || NORMALKEY(Key)==kDown) {
cOsdItem *item=Get(Current());
if(item) item->ProcessKey(kNone);
}
break;
case osUnknown:
if(Key==kOk) { ScSetup.Store(false); state=osBack; }
break;
default:
break;
}
return state;
}
eOSState cMenuSqueezeSetup::ProcessKey(eKeys Key)
{
eOSState state = cMenuSetupPage::ProcessKey(Key);
switch (state)
{
case osContinue:
{
if (NORMALKEY(Key) == kUp || NORMALKEY(Key) == kDown)
{
cOsdItem* item = Get(Current());
if (item)
item->ProcessKey(kNone);
}
break;
}
default: break;
}
return state;
}
eOSState cOsdInfoWindow::ProcessKey(eKeys key)
{
time_t curTime;
switch (key)
{
case k0:
if (m_Number == 0) {
m_Group = -1;
Hide();
return osUnknown;
}
case k1...k9:
if (m_Number >= 0) {
m_Number = m_Number * 10 + key - k0;
if (m_Number > 0) {
cChannel *channel = Channels.GetByNumber(m_Number);
m_Channel = channel;
m_WithInfo = false;
Show(false, (OsdPipSetup.ShowInfo==0));
// Lets see if there can be any useful further input:
int n = channel ? m_Number * 10 : 0;
while (channel && (channel = Channels.Next(channel)) != NULL) {
if (!channel->GroupSep()) {
if (n <= channel->Number() && channel->Number() <= n + 9) {
n = 0;
break;
}
if (channel->Number() > n)
n *= 10;
}
}
if (n > 0) {
// This channel is the only one that fits the input, so let's take it right away:
int number = m_Number;
m_Number = 0;
m_Group = -1;
m_WithInfo = true;
Channels.SwitchTo(number);
}
}
}
return osContinue;
case kLeft | k_Repeat:
case kLeft:
case kRight | k_Repeat:
case kRight:
m_WithInfo = false;
if (m_Group < 0) {
cChannel *channel = Channels.GetByNumber(cDevice::CurrentChannel());
if (channel)
m_Group = channel->Index();
}
if (m_Group >= 0) {
int SaveGroup = m_Group;
if (NORMALKEY(key) == kRight)
m_Group = Channels.GetNextGroup(m_Group);
else
m_Group = Channels.GetPrevGroup(m_Group < 1 ? 1 : m_Group);
if (m_Group < 0)
m_Group = SaveGroup;
cChannel *channel = Channels.Get(m_Group);
if (channel) {
m_Channel = channel;
Show(false, (OsdPipSetup.ShowInfo==0));
if (!channel->GroupSep())
m_Group = -1;
}
}
return osContinue;
case kUp | k_Repeat:
case kUp:
case kDown | k_Repeat:
case kDown:
//std::cout << "cOsdInfoWindow::ProcessKey, vor cDevice::SwitchChannel" << std::endl;
if (cDevice::SwitchChannel(NORMALKEY(key) == kUp ? 1 : -1));
SetChannel(Channels.GetByNumber(cDevice::CurrentChannel()), false);
//std::cout << "cOsdInfoWindow::ProcessKey, nach cDevice::SwitchChannel" << std::endl;
m_WithInfo = true;
m_Number = 0;
m_Group = -1;
Show(false, (OsdPipSetup.ShowInfo==0));
return osContinue;
//case kChanUp|k_Repeat:
//case kChanUp:
//case kChanDn|k_Repeat:
//case kChanDn:
// m_WithInfo = true;
// m_Number = 0;
// m_Group = -1;
// return osContinue;//osUnknown;
case kNone:
if (Shown()) {
time(&curTime);
if (m_Number && curTime - m_LastTime > DIRECTCHANNELTIMEOUT) {
if (Channels.GetByNumber(m_Number)) {
int number = m_Number;
m_Number = 0;
m_Group = -1;
//std::cout << "cOsdInfoWindow::ProcessKey, vor Channels.SwitchTo" << std::endl;
/* TB: only switch the channel if we are in live-view-mode, not when replaying recordings */
if(cDevice::PrimaryDevice()->Transferring()) {
Channels.SwitchTo(number);
}
} else {
m_Number = 0;
m_Group = -1;
m_Channel = NULL;
Show(false, (OsdPipSetup.ShowInfo==0));
m_Channel = Channels.Get(cDevice::CurrentChannel());
m_WithInfo = true;
return osContinue;
}
return osContinue;
}
}
break;
case kOk:
if (Shown()) {
if (m_Group >= 0) {
int group = m_Group;
m_Group = -1;
m_Number = 0;
Channels.SwitchTo(Channels.Get(Channels.GetNextNormal(group))->Number());
} else {
m_Group = -1;
m_Number = 0;
m_Channel = Channels.Get(cDevice::CurrentChannel());
m_WithInfo = true;
Hide();
}
return osContinue;
}
break;
default:
return osUnknown;
}
if (Shown()) {
time(&curTime);
if (curTime - m_LastTime >= INFOTIMEOUT) {
m_Group = -1;
m_Number = 0;
Hide();
}
return osContinue;
}
return osContinue;
}
eOSState cBrowserMenu::ProcessKey(eKeys Key)
{
eOSState state = osUnknown;
if(Key != kInfo)
{
state = userIf_->AnyKey(this, Key);
}
//RefreshIfDirty();
if(state == osUnknown /*&& !GetBrowserSubMenu()*/)
{
switch (NORMALKEY(Key))
{
case kOk:
state = userIf_->OkKey(this);
break;
case kBack:
state = userIf_->BackKey(this);
break;
case kRed:
state = userIf_->RedKey(this);
break;
case kGreen:
state = userIf_->GreenKey(this);
break;
case kYellow:
state = userIf_->YellowKey(this);
break;
case kBlue:
state = userIf_->BlueKey(this);
break;
case kInfo:
state = userIf_->InfoKey(this);
break;
case kPause:
case kPlay:
case kFastFwd:
case kFastRew:
{
Xinemediaplayer_handle_keys Keys;
Keys.Key = Key;
cPluginManager::CallFirstService("Xine handle keys", &Keys);
state = osContinue;
}
break;
case kStop:
cControl::Shutdown();
state = osContinue;
break;
default:
state = osContinue;
break;
}
}
if(userIfchanged_)
{
userIf_->EnterState(this, &search_, lastUserIf_);
userIfchanged_ = false;
lastUserIf_ = userIf_;
}
if(CurrentChanged())
{
userIf_->UpdateImage(this);
}
ClearVolume();
return state;
}
eOSState cMenuFavourites::ProcessKey(eKeys Key)
{
#if 1
/* exit key & yellow key goes to "previous" menu, ie. list of all fav. folders */
if (!HasSubMenu() && mode == eFavChannels && (NORMALKEY(Key) == kBack || NORMALKEY(Key) == kYellow)) {
mode = eFavFolders;
favouritesFilters.ClearFilters();
lastPosition = -1; // reset position of last selected item
Set();
return osContinue;
}
#endif
/* navigate folders with :
Left and Right keys : if 'cursor' is on first/last item on osd
OR
with Channel up/down (unconditional jump to prev/next fav. folder)
*/
if (!HasSubMenu() && mode == eFavChannels) {
bool isFirstItem = (Current() == 0);
bool isLastItem = (Current() == Count()-1);
if ( (kLeft == NORMALKEY(Key) && isFirstItem) || kChanDn == NORMALKEY(Key)) {
ShowPrevFolder();
return osContinue;
}
else if ( (kRight == NORMALKEY(Key) && isLastItem) || kChanUp == NORMALKEY(Key)) {
ShowNextFolder();
return osContinue;
}
}
eOSState state = cOsdMenu::ProcessKey(Key);
// refresh page
if (state == osRefreshPage) {
/* NOTE: call Set() before CloseSubMenu()
CloseSubMenu() calls RefreshCurrent() to redraw the current item
which might have just been deleted!
Therefore, redraw updated list and then call CloseSubMenu() */
Set();
CloseSubMenu();
state = osContinue;
} // refresh page
// show side note info if no submenu and key has been handled
if (!HasSubMenu() && state != osUnknown)
ShowSideNoteInfo();
cOsdChannelItem *currItem = dynamic_cast<cOsdChannelItem*> (Get(Current()));
if (state == osUnknown) {
switch (Key) {
case kOk:
/* switching to channel successful? change state to osEnd */
state = osContinue;
if (currItem && currItem->Channel()) {
if (mode == eFavFolders) {
// open fav folder
favouritesFilters.AddBouquetFilter(currItem->Channel()->Name(), true);
lastSelectedFolder = currItem->Channel()->Name();
//return AddSubMenu(new cMenuFavourites);
mode = eFavChannels;
lastPosition = -1; // reset position of last selected item
Set();
} else {
bool success = SwitchToFavChannel(currItem->Channel());
if (success) {
state = osEnd; // switched to channel so close menu
memoryOn = true;
SaveFilteredChannelList(true);
}
else
Skins.Message(mtError, tr("Switching to channel failed"));
} // else
} // if (currItem && currItem->Channel())
break;
case kBlue:
if (currItem && currItem->Channel())
return AddSubMenu(new cMenuFavouritesFunction(currItem->Channel()));
break;
default:
break;
} // switch
} // if state == osUnknown
if (state != osUnknown && !HasSubMenu() && currItem && mode == eFavChannels)
{
lastPosition = Current(); // update position of last selected fav. channel
}
// ignore color keys when this menu has submenus,
// else vdr opens Macrobinding for these keys
if (HasSubMenu() && state == osUnknown)
switch (NORMALKEY(Key))
{
case kRed:
case kGreen:
case kYellow:
case kBlue:
return osContinue;
default:
break;
}
// Handle color keys
if (state == osUnknown)
switch(Key) {
case kRed: // no filter, all channels
globalFilters.ClearFilters();
return AddSubMenu(new cMenuChannelList);
break;
case kGreen: // Sources
globalFilters.ClearFilters();
return AddSubMenu(new cMenuSourceList);
break;
case kBlue:
break; // blue is now function menu, ignore this key here
case kYellow: // reset Fav listing, show fav. folders list
if (mode != eFavFolders) {
favouritesFilters.ClearFilters();
mode = eFavFolders;
lastPosition = -1; // reset position of last selected item
Set();
}
state = osContinue;
break;
default:
break;
} // switch for colorkeys
return state;
}
eOSState cMenuXinelib::ProcessKey(eKeys Key)
{
/* Hot key support */
if (hotkey_state == hkInit && Key == kNone)
return osContinue;
if (hotkey_state == hkInit && Key == HOTKEY_START) {
hotkey_state = hkSeen;
return osContinue;
} else if (hotkey_state == hkSeen && Key != kNone) {
hotkey_state = hkNone;
return ProcessHotkey(Key);
}
hotkey_state = hkNone;
cOsdItem *item = Get(Current());
eOSState state = cMenuSetupPage::ProcessKey(Key);
if (HasSubMenu())
return state;
switch (state) {
case osUser1:
AddSubMenu(new cMenuBrowseFiles(m_Dev, ShowFiles));
return osUnknown;
case osUser2:
AddSubMenu(new cMenuBrowseFiles(m_Dev, ShowMusic));
return osUnknown;
case osUser3:
AddSubMenu(new cMenuBrowseFiles(m_Dev, ShowImages));
return osContinue;
case osUser4:
cPlayerFactory::Launch(m_Dev, "dvd:/");
return osEnd;
case osUser5:
AddSubMenu(new cMenuBluray(m_Dev, NULL));
return osContinue;
case osUser6:
cPlayerFactory::Launch(m_Dev, "cdda:/");
return osEnd;
case osUser7:
if (!xc.pending_menu_action) {
xc.pending_menu_action = new cEqualizer(m_Dev);
return osPlugin;
}
return osContinue;
default: ;
}
Key = NORMALKEY(Key);
if (Key == kLeft || Key == kRight || ISNUMBERKEY(Key)) {
if (item == audio_ctrl_compress)
m_Dev->ConfigurePostprocessing(xc.deinterlace_method, xc.audio_delay,
compression, xc.audio_equalizer,
xc.audio_surround, xc.speaker_type);
else if (item == ctrl_overscan)
m_Dev->ConfigureVideo(xc.hue, xc.saturation, xc.brightness, xc.sharpness,
xc.noise_reduction, xc.contrast, overscan,
xc.vo_aspect_ratio);
}
if (Key == kLeft || Key == kRight) {
if (item == ctrl_autocrop)
m_Dev->ConfigurePostprocessing("autocrop", autocrop?true:false,
xc.AutocropOptions());
else if (item == ctrl_novideo)
m_Dev->SetPlayMode(novideo ? pmAudioOnlyBlack : pmNone);
}
return state;
}
eOSState cMenuBouquetsList::ProcessKey(eKeys Key)
{
if (!HasSubMenu() && Key == kBack && (mode_ == 2)) //go back to standard mode
{
cChannel *currentbouquet = GetBouquet(Current());
if (currentbouquet && FilteredBouquetIsEmpty(currentbouquet))
{
for (cChannel * channel = currentbouquet; channel;
channel = (cChannel *) channel->Next())
{
if (channel->GroupSep() && !(FilteredBouquetIsEmpty(channel)))
{
currentbouquet = channel;
break;
}
}
}
mode_ = 1;
Setup(currentbouquet);
SetStatus(NULL);
return osContinue;
}
eOSState state = cOsdMenu::ProcessKey(NORMALKEY(Key));
//redraw
if (HadSubMenu_ && !HasSubMenu())
{
mode_ = 2;
Setup(newChannel_);
Options();
}
HadSubMenu_ = HasSubMenu();
switch (state)
{
case osUser1:
{ // add bouquet
cChannel *channel = Channels.Last();
if (channel)
{
cMenuBouquetItem *item = new cMenuBouquetItem(channel);
item->Set();
Add(item, true);
if (HasSubMenu())
return CloseSubMenu();
}
break;
}
case osBack:
if (mode_ == 2)
{
;
}
else
{
if (::Setup.UseBouquetList == 1 && !calledFromkChan)
return ViewChannels();
else
return osEnd;
}
default:
if (state == osUnknown)
{
switch (Key)
{
case kOk:
if (bouquetMarked >= 0)
{
SetStatus(NULL);
if (bouquetMarked != Current())
Move(bouquetMarked, Current());
bouquetMarked = -1;
}
else
return ViewChannels();
break;
default:
//if (showHelp) //if helpkeys were not shown,donot act on them
switch (Key)
{
case kRed:
if (mode_ == 2)
{
return NewBouquet();
}
else if (mode_ == 1)
{
return ViewChannels(); //back to Channels
}
break;;
case kGreen:
if (mode_ == 2)
{ // Move Bouquet
Mark();
break;
}
break;
case kYellow:
if (mode_ == 2)
{ // Delete Bouquet
return DeleteBouquet();
}
break;
case kBlue:
if (mode_ == 2)
{
return EditBouquet();
}
else if (mode_ == 1)
{
mode_ = 2;
Setup(GetBouquet(Current()));
return osContinue;
}
break;
/*case kGreater:
if (mode_ == 2)
{
newChannel_ = GetBouquet(Current());
return AddSubMenu(new cMenuChannels());
}
break;*/
default:
break;
} // switch
//else PRINTF("showHelp = %i\n", showHelp);
break;
}
}
}
return state;
}
