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;
}