void FxMixerView::deleteUnusedChannels() { TrackContainer::TrackList tracks; tracks += Engine::getSong()->tracks(); tracks += Engine::getBBTrackContainer()->tracks(); // go through all FX Channels for(int i = m_fxChannelViews.size()-1; i > 0; --i) { // check if an instrument references to the current channel bool empty=true; for( Track* t : tracks ) { if( t->type() == Track::InstrumentTrack ) { InstrumentTrack* inst = dynamic_cast<InstrumentTrack *>( t ); if( i == inst->effectChannelModel()->value(0) ) { empty=false; break; } } } FxChannel * ch = Engine::fxMixer()->effectChannel( i ); // delete channel if no references found if( empty && ch->m_receives.isEmpty() ) { deleteChannel( i ); } } }
void FxMixerView::keyPressEvent(QKeyEvent * e) { switch(e->key()) { case Qt::Key_Delete: deleteChannel(m_currentFxLine->channelIndex()); break; case Qt::Key_Left: if( e->modifiers() & Qt::AltModifier ) { moveChannelLeft( m_currentFxLine->channelIndex() ); } else { // select channel to the left setCurrentFxLine( m_currentFxLine->channelIndex()-1 ); } break; case Qt::Key_Right: if( e->modifiers() & Qt::AltModifier ) { moveChannelRight( m_currentFxLine->channelIndex() ); } else { // select channel to the right setCurrentFxLine( m_currentFxLine->channelIndex()+1 ); } break; } }
void FxMixer::clear() { while( m_fxChannels.size() > 1 ) { deleteChannel(1); } clearChannel(0); }
bool Chat::removeUserFromChannel(Player* player, uint16_t channelId) { ChatChannel* channel = getChannel(player, channelId); if(!channel || !channel->removeUser(player)) return false; if(channel->getOwner() == player->getGUID()) deleteChannel(player, channelId); return true; }
bool Chat::removeUserFromChannel(const Player& player, uint16_t channelId) { ChatChannel* channel = getChannel(player, channelId); if (!channel || !channel->removeUser(player)) { return false; } if (channel->getOwner() == player.getGUID()) { deleteChannel(player, channelId); } return true; }
ServerGroupDialog::ServerGroupDialog(const QString& title, QWidget *parent) : KDialog(parent) { setCaption(title); setButtons(Ok|Cancel); m_id = -1; m_identitiesNeedsUpdate = false; m_editedServer = false; m_mainWidget = new Ui::ServerGroupDialogUI(); m_mainWidget->setupUi(mainWidget()); mainWidget()->layout()->setMargin(0); m_mainWidget->serverWidget->layout()->setMargin(0); m_mainWidget->channelWidget->layout()->setMargin(0); connect(m_mainWidget->m_editIdentityButton, SIGNAL(clicked()), this, SLOT(editIdentity())); IdentityList identities = Preferences::identityList(); for (IdentityList::ConstIterator it = identities.constBegin(); it != identities.constEnd(); ++it) m_mainWidget->m_identityCBox->addItem((*it)->getName()); m_mainWidget->m_removeServerButton->setIcon(KIcon("list-remove")); m_mainWidget->m_upServerBtn->setIcon(KIcon("arrow-up")); m_mainWidget->m_downServerBtn->setIcon(KIcon("arrow-down")); connect(m_mainWidget->m_addServerButton, SIGNAL(clicked()), this, SLOT(addServer())); connect(m_mainWidget->m_changeServerButton, SIGNAL(clicked()), this, SLOT(editServer())); connect(m_mainWidget->m_removeServerButton, SIGNAL(clicked()), this, SLOT(deleteServer())); connect(m_mainWidget->m_serverLBox, SIGNAL(itemSelectionChanged()), this, SLOT(updateServerArrows())); connect(m_mainWidget->m_upServerBtn, SIGNAL(clicked()), this, SLOT(moveServerUp())); connect(m_mainWidget->m_downServerBtn, SIGNAL(clicked()), this, SLOT(moveServerDown())); m_mainWidget->m_removeChannelButton->setIcon(KIcon("list-remove")); m_mainWidget->m_upChannelBtn->setIcon(KIcon("arrow-up")); m_mainWidget->m_downChannelBtn->setIcon(KIcon("arrow-down")); connect(m_mainWidget->m_addChannelButton, SIGNAL(clicked()), this, SLOT(addChannel())); connect(m_mainWidget->m_changeChannelButton, SIGNAL(clicked()), this, SLOT(editChannel())); connect(m_mainWidget->m_removeChannelButton, SIGNAL(clicked()), this, SLOT(deleteChannel())); connect(m_mainWidget->m_channelLBox, SIGNAL(itemSelectionChanged()), this, SLOT(updateChannelArrows())); connect(m_mainWidget->m_upChannelBtn, SIGNAL(clicked()), this, SLOT(moveChannelUp())); connect(m_mainWidget->m_downChannelBtn, SIGNAL(clicked()), this, SLOT(moveChannelDown())); setButtonGuiItem(Ok, KGuiItem(i18n("&OK"), "dialog-ok", i18n("Change network information"))); setButtonGuiItem(Cancel, KGuiItem(i18n("&Cancel"), "dialog-cancel", i18n("Discards all changes made"))); m_mainWidget->m_nameEdit->setFocus(); setInitialSize(QSize(320, 400)); }
void Chat::removeUserFromAllChannels(Player* player) { ChannelList list = getChannelList(player); while(list.size()){ ChatChannel *channel = list.front(); list.pop_front(); channel->removeUser(player); if(channel->getOwner() == player->getGUID()) deleteChannel(player, channel->getId()); } }
void Channel::resetChannel(bool deleteatend, bool removed) { chanClient *user; char *nick; std::list<chanClient *>::iterator it = user_list.begin(); while(it != user_list.end()) { user = *it; user->client->getUserInfo(&nick,NULL,NULL,NULL); if(user->invisible) { invisibleSend(":SERVER!SERVER@* KICK %s %s :Channel %s",getName(),nick,removed==true?"Removed":"Reset"); } else { sendToChan(":SERVER!SERVER@* KICK %s %s :Channel %s",getName(),nick,removed==true?"Removed":"Reset"); } this->removeUser(user->client,false,NULL,false); it = user_list.begin(); } if(deleteatend) { deleteChannel(this); } }
void Channel::removeUser(Client *user, bool sendpart, char *reason, bool closeChan) { std::list<chanClient *>::iterator it = user_list.begin(); char *nullreason = "\0"; if(reason == NULL) { reason = nullreason; } char *unick; user->getUserInfo(&unick,NULL,NULL,NULL); sendToAllWithMode((int)EUserMode_ShowJoins,":SERVER!SERVER@* NOTICE :%s has parted %s",unick,getName()); while(it != user_list.end()) { chanClient *c=(chanClient *)*it; if(c->client == user) { if(sendpart) { if(this->auditorium != 2) { if(this->auditorium == 1) { if(c->voice || c->halfop || c->op || c->owner) sendMessage(c->invisible,false,user,"PART %s :%s",getName(),reason); } else { sendMessage(c->invisible,false,user,"PART %s :%s",getName(),reason); } } else { user->messageSend(user,"PART %s :%s",getName(),reason); } } customKey *key; std::list<customKey *>::iterator it2 = c->userKeys->begin(); while(it2 != c->userKeys->end()) { key = *it2; free((void *)key); it2++; } delete c->userKeys; free(c); user_list.erase(it); break; } it++; } if(getNumUsers(true) < 1 && !stayopen && closeChan) { deleteChannel(this); } }
void Chat::removeUserFromAllChannels(Player* player) { if(!player || player->isRemoved()) return; for(NormalChannelMap::iterator it = m_normalChannels.begin(); it != m_normalChannels.end(); ++it) it->second->removeUser(player); for(PartyChannelMap::iterator it = m_partyChannels.begin(); it != m_partyChannels.end(); ++it) it->second->removeUser(player); for(GuildChannelMap::iterator it = m_guildChannels.begin(); it != m_guildChannels.end(); ++it) it->second->removeUser(player); for(PrivateChannelMap::iterator it = m_privateChannels.begin(); it != m_privateChannels.end(); ++it) { it->second->removeUser(player); if(it->second->getOwner() == player->getGUID()) deleteChannel(player, it->second->getId()); } }
void Chat::removeUserFromAllChannels(const Player& player) { for (auto& it : normalChannels) { it.second.removeUser(player); } for (const auto& it : partyChannels) { it.second->removeUser(player); } for (const auto& it : guildChannels) { it.second->removeUser(player); } for (const auto& it : privateChannels) { PrivateChatChannel* channel = it.second; channel->removeUser(player); if (channel->getOwner() == player.getGUID()) { deleteChannel(player, channel->getId()); } } }
void Chat::removeUserFromAllChannels(Player* player) { ChannelList list = getChannelList(player); while(!list.empty()){ ChatChannel *channel = list.front(); list.pop_front(); channel->removeUser(player); g_gameOnLeaveChannel(player, channel); if(channel->getOwner() == player->getGUID()) deleteChannel(player, channel->getId()); } for(NormalChannelMap::iterator it = m_normalChannels.begin(); it != m_normalChannels.end(); ++it){ it->second->removeUser(player); } for(GuildChannelMap::iterator it = m_guildChannels.begin(); it != m_guildChannels.end(); ++it){ it->second->removeUser(player); } }
void Chat::removeUserFromAllChannels(Player* player) { for (NormalChannelMap::iterator it = m_normalChannels.begin(), end = m_normalChannels.end(); it != end; ++it) { it->second->removeUser(player); } for (PartyChannelMap::iterator it = m_partyChannels.begin(), end = m_partyChannels.end(); it != end; ++it) { it->second->removeUser(player); } for (GuildChannelMap::iterator it = m_guildChannels.begin(), end = m_guildChannels.end(); it != end; ++it) { it->second->removeUser(player); } for (PrivateChannelMap::iterator it = m_privateChannels.begin(), end = m_privateChannels.end(); it != end; ++it) { PrivateChatChannel* channel = it->second; channel->removeUser(player); if (channel->getOwner() == player->getGUID()) { deleteChannel(player, channel->getId()); } } }
bool Chat::removeUserFromChannel(Player* player, const uint16_t& channelId) { ChatChannel* channel = getChannel(player, channelId); if (!channel) { return false; } if (channel->removeUser(player)) { if (channel->getOwner() == player->getGUID()) { deleteChannel(player, channelId); } return true; } else { return false; } }
SIGNAL(storeSettings(PortSettingsPointer,int)), channel_factory, SLOT(storeSettings(PortSettingsPointer,int)) ); connect( ui->channelList, SIGNAL(currentTextChanged(QString)), this, SLOT(channelPortChanged(QString)) ); connect( ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(scrollData(int))); connect( ui->label, SIGNAL(newSize(QSize)), this, SLOT(labelResized()) ); connect( ui->addChannel, SIGNAL(clicked()), this, SLOT(addChannel()) ); connect( ui->deleteChannel, SIGNAL(clicked()), this, SLOT(deleteChannel())); connect( ui->channelEnable, SIGNAL(toggled(bool)), this, SLOT(toggleChannel())); connect( ui->channelSetColor, SIGNAL(clicked()), this, SLOT(setChannelColor()) ); connect( ui->snifferStart, SIGNAL(clicked()), this, SLOT(startSniffingButt()) ); connect( ui->retrStart, SIGNAL(clicked()), this, SLOT(startRetranslatingButt()) ); connect( ui->parserEditDummy, SIGNAL(gotFocus()), this, SLOT(dummyParseLineEditClicked()) ); connect( ui->showPreprocessedButt,SIGNAL(clicked()), this, SLOT(showPreprocessed()) ); connect( ui->parserSetButt, SIGNAL(clicked()), this, SLOT(setParser()) ); connect( ui->parserSetReparseButt,SIGNAL(clicked()), this, SLOT(setParserAndReparse()) ); connect( ui->hideParseEditButt, SIGNAL(clicked()), this, SLOT(parseEditorClosed()) ); connect( &sorter, SIGNAL(gotByte(timestamped_data)), &data_holder, SLOT(receiveByte(timestamped_data)) );
int processChannelControlMessage( INOUT SESSION_INFO *sessionInfoPtr, INOUT STREAM *stream ) { SSH_INFO *sshInfo = sessionInfoPtr->sessionSSH; const long prevChannelNo = \ getCurrentChannelNo( sessionInfoPtr, CHANNEL_READ ); long channelNo; int status; assert( isWritePtr( sessionInfoPtr, sizeof( SESSION_INFO ) ) ); assert( isWritePtr( stream, sizeof( STREAM ) ) ); /* See what we've got. SSH has a whole pile of no-op equivalents that we have to handle as well as the obvious no-ops. We can also get global and channel requests for assorted reasons and a constant stream of window adjusts to implement the SSH performance handbrake */ switch( sshInfo->packetType ) { case SSH2_MSG_GLOBAL_REQUEST: status = processChannelRequest( sessionInfoPtr, stream, CRYPT_UNUSED ); if( cryptStatusError( status ) && status != OK_SPECIAL ) return( status ); return( OK_SPECIAL ); case SSH2_MSG_CHANNEL_OPEN: /* Process the channel-open request. In theory we could immediately reject any attempts by the server to open a channel to the client at this point, but unfortunately we have to process a considerable portion of the channel-open request in order to use the information in it to send a request-denied response back to the server */ status = processChannelOpen( sessionInfoPtr, stream ); if( cryptStatusError( status ) ) return( status ); /* Tell the caller that they have to process the new channel information before they can continue */ return( CRYPT_ENVELOPE_RESOURCE ); case SSH2_MSG_IGNORE: case SSH2_MSG_DEBUG: /* Nothing to see here, move along, move along: byte SSH2_MSG_IGNORE string data byte SSH2_MSG_DEBUG boolean always_display string message string language_tag */ return( OK_SPECIAL ); case SSH2_MSG_DISCONNECT: /* This only really seems to be used during the handshake phase, once a channel is open it (and the session as a whole) is disconnected with a channel EOF/close, but we handle it here anyway just in case */ return( getDisconnectInfo( sessionInfoPtr, stream ) ); #ifdef KPYM_HACK case SSH2_MSG_KEXDH_INIT/*SSH2_MSG_KEXDH_GEX_REQUEST_OLD*/: case SSH2_MSG_KEXDH_GEX_INIT: case SSH2_MSG_KEXDH_GEX_REQUEST_NEW: case SSH2_MSG_KEXINIT: case SSH2_MSG_NEWKEYS: { int status = ke_DH_ROUTER(sessionInfoPtr, stream, sshInfo->packetType); if( status == CRYPT_OK )return( OK_SPECIAL ); else return status; } #else case SSH2_MSG_KEXINIT: #endif /* The SSH spec is extremely vague about the sequencing of operations during a rehandshake. Unlike SSL there's no real indication of what happens to the connection-layer transfers while a transport-layer rehandshake is in progress. Also unlike SSL we can't refuse a rehandshake by ignoring the request, so once we've fallen we can't get up any more. This is most obvious with ssh.com's server, which starting with version 2.3.0 would do a rehandshake every hour (for a basic encrypted telnet session, while a high-volume IPsec link can run for hours before it feels the need to do this). To make things even messier, neither side can block for too long waiting for the rehandshake to complete before sending new data because the lack of WINDOW_ADJUSTs (in an implementation that sends these with almost every packet, as most do) will screw up flow control and lead to deadlock. This problem got so bad that as of 2.4.0 the ssh.com implementation would detect OpenSSH (the other main implementation at the time) and disable the rehandshake when it was talking to it, but it may not do this for other implementations. To avoid falling into this hole, or at least to fail obviously when the two sides can't agree on how to handle the layering mismatch problem, we report a rehandshake request as an error. Trying to handle it properly results in hard-to- diagnose errors (it depends on what the layers are doing at the time of the problem), typically some bad-packet error when the other side tries to interpret a connection-layer packet as part of the rehandshake, or when the two sides disagree on when to switch keys and one of the two decrypts with the wrong keys and gets a garbled packet type */ retExt( CRYPT_ERROR_BADDATA, ( CRYPT_ERROR_BADDATA, SESSION_ERRINFO, "Unexpected KEXINIT request received" ) ); case SSH2_MSG_CHANNEL_DATA: case SSH2_MSG_CHANNEL_EXTENDED_DATA: case SSH2_MSG_CHANNEL_REQUEST: case SSH2_MSG_CHANNEL_WINDOW_ADJUST: case SSH2_MSG_CHANNEL_EOF: case SSH2_MSG_CHANNEL_CLOSE: /* All channel-specific messages end up here */ channelNo = readUint32( stream ); if( cryptStatusError( channelNo ) ) { /* We can't send an error response to a channel request at this point both because we haven't got to the response- required flag yet and because SSH doesn't provide a mechanism for returning an error response without an accompanying channel number. The best that we can do is to quietly ignore the packet */ retExt( CRYPT_ERROR_BADDATA, ( CRYPT_ERROR_BADDATA, SESSION_ERRINFO, "Invalid channel number in channel-specific packet " "type %d", sshInfo->packetType ) ); } if( channelNo != getCurrentChannelNo( sessionInfoPtr, \ CHANNEL_READ ) ) { /* It's a request on something other than the current channel, try and select the new channel */ status = selectChannel( sessionInfoPtr, channelNo, CHANNEL_READ ); if( cryptStatusError( status ) ) { /* As before for error handling */ retExt( CRYPT_ERROR_BADDATA, ( CRYPT_ERROR_BADDATA, SESSION_ERRINFO, "Invalid channel number %lX in " "channel-specific packet type %d, current " "channel is %lX", channelNo, sshInfo->packetType, prevChannelNo ) ); } } break; default: { BYTE buffer[ 16 + 8 ]; int length; /* We got something unexpected, throw an exception in the debug version and let the caller know the details */ DEBUG_DIAG(( "Unexpected control packet %d", sshInfo->packetType )); assert( DEBUG_WARN ); status = length = sread( stream, buffer, 8 ); if( cryptStatusError( status ) || length < 8 ) { /* There's not enough data present to dump the start of the packet, provide a more generic response */ retExt( CRYPT_ERROR_BADDATA, ( CRYPT_ERROR_BADDATA, SESSION_ERRINFO, "Unexpected control packet type %d received", sshInfo->packetType ) ); } retExt( CRYPT_ERROR_BADDATA, ( CRYPT_ERROR_BADDATA, SESSION_ERRINFO, "Unexpected control packet type %d received, " "beginning %02X %02X %02X %02X %02X %02X %02X %02X", sshInfo->packetType, buffer[ 0 ], buffer[ 1 ], buffer[ 2 ], buffer[ 3 ], buffer[ 4 ], buffer[ 5 ], buffer[ 6 ], buffer[ 7 ] ) ); } } /* From here on we're processing a channel-specific message that applies to the currently selected channel */ switch( sshInfo->packetType ) { case SSH2_MSG_CHANNEL_DATA: case SSH2_MSG_CHANNEL_EXTENDED_DATA: { int length; /* Get the payload length and make sure that it's (approximately) valid, more exact checking has already been done by the caller so we don't need to return extended error information as this is just a backup check */ status = length = readUint32( stream ); if( cryptStatusError( status ) || \ length < 0 || length > sessionInfoPtr->receiveBufSize ) return( CRYPT_ERROR_BADDATA ); /* These are messages that consume window space, adjust the data window and communicate changes to the other side if necessary */ status = handleWindowAdjust( sessionInfoPtr, channelNo, length ); if( cryptStatusError( status ) ) return( status ); /* If it's a standard data packet, we're done */ if( sshInfo->packetType == SSH2_MSG_CHANNEL_DATA ) return( CRYPT_OK ); /* The extended data message is used for out-of-band data sent over a channel, specifically output sent to stderr from a shell command. What to do with this is somewhat uncertain, the only possible action that we could take apart from just ignoring it is to convert it back to in-band data. However, something running a shell command may not expect to get anything returned in this manner (see the comment for the port-forwarding channel open in the client-side channel-open code for more on this) so for now we just ignore it and assume that the user will rely on results sent as in-band data. This should be fairly safe since this message type seems to be rarely (if ever) used, so apps will function without it */ return( OK_SPECIAL ); } case SSH2_MSG_CHANNEL_REQUEST: status = processChannelRequest( sessionInfoPtr, stream, prevChannelNo ); if( cryptStatusError( status ) && status != OK_SPECIAL ) return( status ); return( OK_SPECIAL ); case SSH2_MSG_CHANNEL_WINDOW_ADJUST: /* Another noop-equivalent (but a very performance-affecting one) */ return( OK_SPECIAL ); case SSH2_MSG_CHANNEL_EOF: /* According to the SSH docs the EOF packet is mostly a courtesy notification, however many implementations seem to use a channel EOF in place of a close before sending a disconnect message */ #ifdef KPYM_HACK #else return( OK_SPECIAL ); #endif case SSH2_MSG_CHANNEL_CLOSE: /* The peer has closed their side of the channel, if our side isn't already closed (in other words if this message isn't a response to a close that we sent), close our side as well */ if( getChannelStatusByChannelNo( sessionInfoPtr, channelNo ) == CHANNEL_BOTH ) { #ifdef KPYM_HACK status = sendChannelClose( sessionInfoPtr, channelNo, CHANNEL_BOTH, TRUE ); /* We've already closed our side of the channel, delete it */ status = deleteChannel( sessionInfoPtr, channelNo, CHANNEL_BOTH, TRUE ); #else status = sendChannelClose( sessionInfoPtr, channelNo, CHANNEL_BOTH, TRUE ); #endif } else { /* We've already closed our side of the channel, delete it */ status = deleteChannel( sessionInfoPtr, channelNo, CHANNEL_BOTH, TRUE ); } /* If this wasn't the last channel, we're done */ if( status != OK_SPECIAL ) return( OK_SPECIAL ); /* We've closed the last channel, indicate that the overall connection is now closed. This behaviour isn't mentioned in the spec but it seems to be the standard way of handling things, particularly for the most common case where channel == session */ sessionInfoPtr->flags |= SESSION_SENDCLOSED; retExt( CRYPT_ERROR_COMPLETE, ( CRYPT_ERROR_COMPLETE, SESSION_ERRINFO, "Remote system closed last remaining SSH channel" ) ); } retIntError(); }
IN const long channelNo, IN_ENUM( CHANNEL ) const CHANNEL_TYPE channelType, const BOOLEAN closeLastChannel ) { BOOLEAN lastChannel = FALSE; int status; assert( isWritePtr( sessionInfoPtr, sizeof( SESSION_INFO ) ) ); REQUIRES( channelNo >= 0 && channelNo <= LONG_MAX ); REQUIRES( channelType > CHANNEL_NONE && channelType < CHANNEL_LAST ); /* Delete the channel. If we've deleted the last active channel deleteChannel() will return OK_SPECIAL to let us know that there are no more channels left to close */ status = deleteChannel( sessionInfoPtr, channelNo, channelType, closeLastChannel ); if( cryptStatusError( status ) ) { if( status != OK_SPECIAL ) return( status ); /* We're closing the last remaining channel */ lastChannel = TRUE; } /* Prepare the channel-close notification: byte SSH2_MSG_CHANNEL_CLOSE uint32 channel_no */ status = enqueueResponse( sessionInfoPtr, SSH2_MSG_CHANNEL_CLOSE, 1, channelNo, CRYPT_UNUSED, CRYPT_UNUSED,
int CBEChannelWidget::exec(CMenuTarget* parent, const std::string &/*actionKey*/) { neutrino_msg_t msg; neutrino_msg_data_t data; int res = menu_return::RETURN_REPAINT; if (parent) parent->hide(); width = w_max ( (frameBuffer->getScreenWidth() / 20 * 17), (frameBuffer->getScreenWidth() / 20 )); height = h_max ( (frameBuffer->getScreenHeight() / 20 * 16), (frameBuffer->getScreenHeight() / 20)); listmaxshow = (height - theight)/fheight; height = theight + listmaxshow*fheight; // recalc height // info height info_height = g_Font[SNeutrinoSettings::FONT_TYPE_CHANNELLIST_DESCR]->getHeight() + 10; // coordinate x = frameBuffer->getScreenX() + (frameBuffer->getScreenWidth() - (width + ConnectLineBox_Width)) / 2 + ConnectLineBox_Width; y = frameBuffer->getScreenY() + (frameBuffer->getScreenHeight() - height -ButtonHeight - 2 - info_height) / 2; Channels = mode == CZapitClient::MODE_TV ? &(g_bouquetManager->Bouquets[bouquet]->tvChannels) : &(g_bouquetManager->Bouquets[bouquet]->radioChannels); paintHead(); paint(); paintFoot(); frameBuffer->blit(); channelsChanged = false; unsigned long long timeoutEnd = CRCInput::calcTimeoutEnd(g_settings.timing[SNeutrinoSettings::TIMING_EPG]); bool loop = true; while (loop) { g_RCInput->getMsgAbsoluteTimeout( &msg, &data, &timeoutEnd ); if ( msg <= CRCInput::RC_MaxRC ) timeoutEnd = CRCInput::calcTimeoutEnd(g_settings.timing[SNeutrinoSettings::TIMING_EPG]); if ((msg == CRCInput::RC_timeout) || (msg == (neutrino_msg_t)g_settings.key_channelList_cancel)) { if (state == beDefault) { loop = false; } else if (state == beMoving) { cancelMoveChannel(); } } else if (msg==CRCInput::RC_up || msg==(neutrino_msg_t)g_settings.key_channelList_pageup) { if (!(Channels->empty())) { int step = 0; int prev_selected = selected; step = (msg == (neutrino_msg_t)g_settings.key_channelList_pageup) ? listmaxshow : 1; // browse or step 1 selected -= step; if((prev_selected-step) < 0) // because of uint { selected = Channels->size() - 1; } if (state == beDefault) { paintItem(prev_selected - liststart); unsigned int oldliststart = liststart; liststart = (selected/listmaxshow)*listmaxshow; if(oldliststart!=liststart) { paint(); } else { paintItem(selected - liststart); } } else if (state == beMoving) { internalMoveChannel(prev_selected, selected); } } } else if (msg == CRCInput::RC_down || msg == (neutrino_msg_t)g_settings.key_channelList_pagedown) { unsigned int step = 0; int prev_selected = selected; step = (msg == (neutrino_msg_t)g_settings.key_channelList_pagedown) ? listmaxshow : 1; // browse or step 1 selected += step; if(selected >= Channels->size()) { if (((Channels->size() / listmaxshow) + 1)*listmaxshow == Channels->size() + listmaxshow) // last page has full entries selected = 0; else selected = ((step == listmaxshow) && (selected < (((Channels->size() / listmaxshow) + 1)*listmaxshow))) ? (Channels->size() - 1) : 0; } if (state == beDefault) { paintItem(prev_selected - liststart); unsigned int oldliststart = liststart; liststart = (selected/listmaxshow)*listmaxshow; if(oldliststart!=liststart) { paint(); } else { paintItem(selected - liststart); } } else if (state == beMoving) { internalMoveChannel(prev_selected, selected); } } else if(msg == CRCInput::RC_red) { if (state == beDefault) deleteChannel(); } else if(msg == CRCInput::RC_green) { if (state == beDefault) addChannel(); } else if(msg == CRCInput::RC_blue) { if (state == beDefault) { if (mode == CZapitClient::MODE_TV) mode = CZapitClient::MODE_RADIO; else mode = CZapitClient::MODE_TV; Channels = mode == CZapitClient::MODE_TV ? &(g_bouquetManager->Bouquets[bouquet]->tvChannels) : &(g_bouquetManager->Bouquets[bouquet]->radioChannels); selected = 0; paint(); } } else if(msg == CRCInput::RC_yellow) { liststart = (selected/listmaxshow)*listmaxshow; if (state == beDefault) beginMoveChannel(); paintItem(selected - liststart); } else if(msg == CRCInput::RC_ok) { if (state == beDefault) { if (selected < Channels->size()) /* Channels.size() might be 0 */ g_Zapit->zapTo_serviceID((*Channels)[selected]->channel_id); } else if (state == beMoving) { finishMoveChannel(); } } else if( CRCInput::isNumeric(msg) ) { if (state == beDefault) { //kein pushback - wenn man versehentlich wo draufkommt is die edit-arbeit umsonst //selected = oldselected; //g_RCInput->postMsg( msg, data ); //loop=false; } else if (state == beMoving) { cancelMoveChannel(); } } else { CNeutrinoApp::getInstance()->handleMsg( msg, data ); } frameBuffer->blit(); } hide(); return res; }