vvideolivetv.cc

   1 /*
   2     Copyright 2007-2008 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP.  If not, see <https://www.gnu.org/licenses/>.
  18 */
  19
  20 #include <sstream>
  21
  22 #include "vchannellist.h"
  23 #include "video.h"
  24 #include "audio.h"
  25 #include "playerlive.h"
  26 #include "playervideolive.h"
  27 #include "playerradiolive.h"
  28 #include "channel.h"
  29 #include "boxstack.h"
  30 #include "colour.h"
  31 #include "osd.h"
  32 #include "command.h"
  33 #include "i18n.h"
  34 #include "wtextbox.h"
  35 #include "input.h"
  36 #include "inputman.h"
  37 #include "vaudioselector.h"
  38 #include "colour.h"
  39 #include "event.h"
  40 #include "vepg.h"
  41 #include "bitmap.h"
  42 #include "log.h"
  43 #include "vteletextview.h"
  44 #include "vepgsummary.h"
  45 #include "vepglistadvanced.h"
  46 #include "staticartwork.h"
  47 #include "demuxer.h"
  48 #include "messagequeue.h"
  49
  50 #include "vvideolivetv.h"
  51
  52
  53 VVideoLiveTV::VVideoLiveTV(ChannelList* tchanList, ULONG initialChannelNumber, VChannelList* tvchannelList)
  54 {
  55   vdr = VDR::getInstance();
  56   boxstack = BoxStack::getInstance();
  57   video = Video::getInstance();
  58
  59   vas = NULL;
  60
  61   chanList = tchanList;
  62   vchannelList = tvchannelList;
  63   numberWidth = VDR::getInstance()->getChannelNumberWidth();
  64
  65   currentChannelIndex = 0;
  66   previousChannelIndex = 0;
  67   osdChannelIndex = 0;
  68   keying = 0;
  69   preBuffering = 0;
  70
  71   playing = false;
  72
  73   // Convert channel number to index
  74   for(UINT i = 0; i < chanList->size(); i++)
  75   {
  76     if ((*chanList)[i]->number == initialChannelNumber)
  77     {
  78       currentChannelIndex = i;
  79       osdChannelIndex = i;
  80       break;
  81     }
  82   }
  83
  84   eventList = NULL;
  85
  86   videoMode = video->getMode();
  87
  88   if ((*chanList)[currentChannelIndex]->type == VDR::VIDEO)
  89   {
  90     streamType = VDR::VIDEO;
  91     player = new PlayerVideoLive(Command::getInstance(), this, this, chanList);
  92   }
  93   else
  94   {
  95     streamType = VDR::RADIO;
  96     player = new PlayerRadioLive(Command::getInstance(), this, chanList);
  97   }
  98   player->init();
  99
 100   setSize(video->getScreenWidth(), video->getScreenHeight());
 101   createBuffer();
 102   DrawStyle transparent(0, 0, 0, 0);
 103   setBackgroundColour(transparent);
 104
 105   OsdVector* osdv = dynamic_cast<OsdVector*>(Osd::getInstance());
 106   if (osdv)
 107   {
 108     osdv->updateBackgroundColor(DrawStyle::BLACK);
 109   }
 110
 111   // This variable is set to true if the user pressed OK to bring the OSD on screen
 112   // This is only used on old remotes to stop up/down buttons being used for osd-epg scrolling
 113   okTriggeredOSD = false;
 114
 115   TVMediaInfo info;
 116   info.setChannelLogo(initialChannelNumber);
 117
 118   if (osdv && streamType == VDR::RADIO) {
 119           radioChannelLogo.setPosition(video->getScreenWidth()/4,video->getScreenHeight()/4);
 120           radioChannelLogo.setSize(video->getScreenWidth()/2,video->getScreenHeight()/2);
 121           radioChannelLogo.setVisible(true);
 122           radioChannelLogo.setTVMedia(info, WTVMedia::ZoomVertical);
 123           add(&radioChannelLogo);
 124   }
 125
 126   osdposterbanner.setPosition(20,20);
 127   //osdposterbanner.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 128   osdposterbanner.setSize(video->getScreenWidth()*4/10,video->getScreenHeight()*4/10);
 129   osdposterbanner.setVisible(false);
 130   add(&osdposterbanner);
 131
 132   osd.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 133   osd.setPosition(0, video->getScreenHeight() - 150);
 134   osd.setSize(video->getScreenWidth(), 150);
 135   osd.setVisible(false);
 136   add(&osd);
 137
 138   int channellogomove=0;
 139   int boxdiff=166;
 140   if (osdv)
 141   {
 142     //osdChannelLogo.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 143     osdChannelLogo.setPosition(30,5);
 144     osdChannelLogo.setSize(60,60);
 145     osdChannelLogo.setTVMedia(info, WTVMedia::ZoomVertical);
 146     osd.add(&osdChannelLogo);
 147     channellogomove = 30-5;
 148     boxdiff = 145;
 149   }
 150
 151   //clock.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 152   clock.setPosition(osd.getWidth() - 100, 4);
 153   clock.setSize(90, 30);
 154   osd.add(&clock);
 155
 156   //osdChanNum.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 157   osdChanNum.setPosition(60 + channellogomove, 4);
 158   osdChanNum.setSize((numberWidth * 10) + 22, getFontHeight() + 5); // 10 px = width of number chars in font
 159   osd.add(&osdChanNum);
 160
 161   //osdChanName.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 162   osdChanName.setPosition(osdChanNum.getX2() + 10, 4);
 163   osdChanName.setSize(300, 30);
 164   osd.add(&osdChanName);
 165
 166   boxRed.setBackgroundColour(DrawStyle::RED);
 167   boxRed.setPosition(54+0*boxdiff, 104);
 168   boxRed.setSize(18, 16);
 169   osd.add(&boxRed);
 170
 171   boxGreen.setBackgroundColour(DrawStyle::GREEN);
 172   boxGreen.setPosition(54+1*boxdiff, 104);
 173   boxGreen.setSize(18, 16);
 174   osd.add(&boxGreen);
 175
 176   boxYellow.setBackgroundColour(DrawStyle::YELLOW);
 177   boxYellow.setPosition(54+2*boxdiff, 104);
 178   boxYellow.setSize(18, 16);
 179   osd.add(&boxYellow);
 180
 181   boxBlue.setBackgroundColour(DrawStyle::BLUE);
 182   boxBlue.setPosition(54+3*boxdiff, 104);
 183   boxBlue.setSize(18, 16);
 184   osd.add(&boxBlue);
 185
 186   //textRed.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 187   textRed.setPosition(boxRed.getX2(), 98);
 188   textRed.setSize(boxGreen.getX() - boxRed.getX2(), 30);
 189   textRed.setText(tr("Summary"));
 190   osd.add(&textRed);
 191
 192   if (streamType == VDR::VIDEO)
 193   {
 194     //textGreen.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 195     textGreen.setPosition(boxGreen.getX2(), 98);
 196     textGreen.setSize(boxYellow.getX() - boxGreen.getX2(), 30);
 197     textGreen.setText(tr("Audio"));
 198     osd.add(&textGreen);
 199   }
 200
 201   //textYellow.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 202   textYellow.setPosition(boxYellow.getX2(), 98);
 203   textYellow.setSize(boxBlue.getX() - boxYellow.getX2(), 30);
 204   textYellow.setText(tr("Teletext"));
 205   osd.add(&textYellow);
 206
 207   //textBlue.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 208   textBlue.setPosition(boxBlue.getX2(), 98);
 209   textBlue.setSize(osd.getX2() - boxBlue.getX2(), 30);
 210   textBlue.setText(tr("EPG"));
 211   osd.add(&textBlue);
 212
 213   //sl.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 214   sl.setPosition(90, 36);
 215   sl.setSize(480, 58);
 216   osd.add(&sl);
 217
 218   bufferBar.setPosition(osd.getWidth() - 90, 70);
 219   bufferBar.setSize(40, 20);
 220   bufferBar.setVisible(true);
 221   osd.add(&bufferBar);
 222
 223   if (!osdv)
 224   {
 225     sAspectRatio.setPosition(osd.getWidth() - 90, 40);
 226     sAspectRatio.nextColour = DrawStyle::LIVETVSYMBOLS;
 227     sAspectRatio.setVisible(false);
 228     osd.add(&sAspectRatio);
 229
 230     sAudioChannels.setPosition(osd.getWidth() - 130, 40);
 231     sAudioChannels.nextColour = DrawStyle::LIVETVSYMBOLS;
 232     sAudioChannels.setVisible(false);
 233     osd.add(&sAudioChannels);
 234   }
 235
 236   if (osdv)
 237   {
 238     TVMediaInfo ninfo;
 239     ninfo.setStaticArtwork(sa_txtoff);
 240     txtlogo.setPosition(54+4*boxdiff,104);
 241     txtlogo.setSize(22,20);
 242     txtlogo.setTVMedia(ninfo, WTVMedia::ZoomVertical);
 243     osd.add(&txtlogo);
 244
 245     ninfo.setStaticArtwork(sa_dolbyoff);
 246     dolbylogo.setPosition(54+4*boxdiff+15,104);
 247     dolbylogo.setSize(22,20);
 248     dolbylogo.setTVMedia(ninfo, WTVMedia::ZoomVertical);
 249     osd.add(&dolbylogo);
 250
 251     ninfo.setStaticArtwork(sa_sd576i);
 252     reslogo.setPosition(54+4*boxdiff+30,104);
 253     reslogo.setSize(22,20);
 254     reslogo.setTVMedia(ninfo, WTVMedia::ZoomVertical);
 255     osd.add(&reslogo);
 256
 257     reslogo.setVisible(false);
 258     dolbylogo.setVisible(false);
 259     txtlogo.setVisible(false);
 260   }
 261
 262   //textUnavailable.setBackgroundColour(DrawStyle::OSDBACKGROUND);
 263   textUnavailable.setPosition(60, 30);
 264   textUnavailable.setSize(osd.getWidth() - 120, 30);
 265   textUnavailable.setText(tr("Channel Unavailable"));
 266   textUnavailable.setVisible(false);
 267   add(&textUnavailable);
 268
 269   vdisplay.mode = Fullscreen;
 270   vdisplay.fallbackMode = Fullscreen;
 271   vdisplay.x = 0;
 272   vdisplay.y = 0;
 273   vdisplay.width = 0;
 274   vdisplay.height = 0;
 275 }
 276
 277 void VVideoLiveTV::preDelete()
 278 {
 279   if (playing) stop();
 280 }
 281
 282 VVideoLiveTV::~VVideoLiveTV()
 283 {
 284   delete player;
 285   video->setDefaultAspect();
 286   delData();
 287   OsdVector* osdv = dynamic_cast<OsdVector*>(Osd::getInstance());
 288   if (osdv)
 289   {
 290     osdv->updateBackgroundColor(DrawStyle::WALLPAPER);
 291   }
 292 }
 293
 294 void VVideoLiveTV::delData()
 295 {
 296   if (eventList)
 297   {
 298     int eventListSize = eventList->size();
 299     for(int i = 0; i < eventListSize; i++)
 300     {
 301       delete (*eventList)[i];
 302     }
 303     eventList->clear();
 304     delete eventList;
 305   }
 306 }
 307
 308 int VVideoLiveTV::handleCommand(int command)
 309 {
 310   switch(command)
 311   {
 312     case Input::BACK:
 313     {
 314       if (osd.getVisible() && !textUnavailable.getVisible())
 315       {
 316         clearScreen();
 317         return 2;
 318       }
 319       // else drop through to stop
 320     }
 321     FALLTHROUGH
 322     case Input::STOP:
 323     {
 324       stop();
 325       vchannelList->highlightChannel((*chanList)[currentChannelIndex]);
 326       return 4;
 327     }
 328
 329     // navigate EPG, bring it onscreen if it's not there
 330     case Input::UP:
 331     {
 332       if (InputMan::getInstance()->mayHaveFewButtons())
 333       {
 334         if (okTriggeredOSD) doUpDown(false);
 335         else doChanUpDown(UP);
 336       }
 337       else
 338       {
 339         doUpDown(false);
 340       }
 341       return 2;
 342     }
 343     case Input::DOWN:
 344     {
 345       if (InputMan::getInstance()->mayHaveFewButtons())
 346       {
 347         if (okTriggeredOSD) doUpDown(true);
 348         else doChanUpDown(DOWN);
 349       }
 350       else
 351       {
 352         doUpDown(true);
 353       }
 354       return 2;
 355     }
 356     case Input::LEFT:
 357     {
 358       doLeftRight(false);
 359       return 2;
 360     }
 361     case Input::RIGHT:
 362     {
 363       doLeftRight(true);
 364       return 2;
 365     }
 366     case Input::CHANNELUP:
 367     {
 368       doChanUpDown(UP);
 369       return 2;
 370     }
 371     case Input::CHANNELDOWN:
 372     {
 373       doChanUpDown(DOWN);
 374       return 2;
 375     }
 376     case Input::PREVCHANNEL:
 377     {
 378       channelChange(PREVIOUS, 0);
 379       osdChannelIndex = currentChannelIndex;
 380       displayOSD(true);
 381       return 2;
 382     }
 383     case Input::OK:
 384     {
 385       doOK();
 386       return 2;
 387     }
 388     case Input::RED:
 389     case Input::MENU:
 390     {
 391       doSummary();
 392       return 2;
 393     }
 394     case Input::FULL:
 395     case Input::TV:
 396     {
 397       toggleChopSides();
 398       return 2;
 399     }
 400
 401     case Input::ZERO:
 402     case Input::ONE:
 403     case Input::TWO:
 404     case Input::THREE:
 405     case Input::FOUR:
 406     case Input::FIVE:
 407     case Input::SIX:
 408     case Input::SEVEN:
 409     case Input::EIGHT:
 410     case Input::NINE:
 411     {
 412       // key in channel number
 413       doKey(command);
 414       return 2;
 415     }
 416
 417     case Input::GREEN:
 418     {
 419       if (streamType == VDR::VIDEO) doAudioSelector();
 420       return 2;
 421     }
 422     case Input::YELLOW:
 423     {
 424       if (streamType ==VDR::VIDEO)
 425       {
 426         doTeletext(); //TODO: Add a selector for subtitles or teletext
 427       }
 428       return 2;
 429     }
 430     case Input::GUIDE:
 431     case Input::BLUE:
 432     {
 433       doEPG();
 434       return 2;
 435     }
 436     case Input::RECORD:
 437       if (streamType == VDR::VIDEO)
 438         (static_cast<PlayerVideoLive*>(player))->toggleSubtitles();
 439       return 2;
 440   }
 441
 442   return 1;
 443 }
 444
 445 void VVideoLiveTV::go()
 446 {
 447   playing = true;
 448   draw();
 449   boxstack->update(this);
 450
 451   setClock();
 452   displayOSD(true);
 453
 454   player->go(currentChannelIndex);
 455 }
 456
 457 void VVideoLiveTV::stop()
 458 {
 459   Timers::getInstance()->cancelTimer(this, 1);
 460   Timers::getInstance()->cancelTimer(this, 2);
 461   player->stop();
 462   playing = false;
 463 }
 464
 465 void VVideoLiveTV::doLeftRight(bool right)
 466 {
 467   if (osd.getVisible())
 468   {
 469     if (right) osdChannelIndex = upChannel(osdChannelIndex);
 470     else       osdChannelIndex = downChannel(osdChannelIndex);
 471   }
 472   else
 473   {
 474     osdChannelIndex = currentChannelIndex;
 475   }
 476   displayOSD(true);
 477 }
 478
 479 void VVideoLiveTV::doUpDown(bool /* down */)
 480 {
 481   if (osd.getVisible())
 482   {
 483     sl.draw();
 484
 485     displayOSD(false);
 486   }
 487   else
 488   {
 489     displayOSD(true);
 490   }
 491 }
 492
 493 void VVideoLiveTV::doChanUpDown(int which)
 494 {
 495   channelChange(OFFSET, which);
 496   osdChannelIndex = currentChannelIndex;
 497   displayOSD(true);
 498 }
 499
 500 void VVideoLiveTV::doOK()
 501 {
 502   if (osd.getVisible())
 503   {
 504     if (keying)
 505     {
 506       UINT newChannel = 0;
 507       for(int i = keying - 1; i >= 0; i--) newChannel += keyingInput[i] * (ULONG)pow(10., i);
 508
 509       channelChange(NUMBER, newChannel);
 510       osdChannelIndex = currentChannelIndex;
 511       displayOSD(true);
 512     }
 513     else if (osdChannelIndex == currentChannelIndex)
 514     {
 515       clearScreen();
 516     }
 517     else
 518     {
 519       channelChange(INDEX, osdChannelIndex);
 520       displayOSD(true);
 521     }
 522   }
 523   else
 524   {
 525     osdChannelIndex = currentChannelIndex;
 526     displayOSD(true);
 527     okTriggeredOSD = true;
 528   }
 529 }
 530
 531 void VVideoLiveTV::doSummary()
 532 {
 533   displayOSD(false);
 534   Channel* currentChannel = (*chanList)[osdChannelIndex];
 535   eventList = VDR::getInstance()->getChannelSchedule(currentChannel->number);
 536   if (!eventList)
 537   {
 538       return;
 539   }
 540   sort(eventList->begin(), eventList->end(), EventSorter());
 541
 542   if (eventList->size() < 1) return;
 543   Event* event = (*eventList)[0];
 544   event->loadinfos(currentChannel->number);
 545
 546   VEpgSummary* vr = new VEpgSummary(event,currentChannel);
 547   vr->draw();
 548   boxstack->add(vr);
 549   boxstack->update(vr);
 550 }
 551
 552 void VVideoLiveTV::doKey(int command)
 553 {
 554   if (!osd.getVisible()) // First key. prep the data
 555   {
 556     setNowNextData();
 557     updatePosterBanner();
 558     keying = 0;
 559   }
 560
 561   int i;
 562   for (i = keying - 1; i >= 0; i--) keyingInput[i+1] = keyingInput[i];
 563   keyingInput[0] = command;
 564   keying++;
 565
 566   char* keyingString = new char[numberWidth + 1];
 567   for (i = 0; i < numberWidth; i++) keyingString[i] = '_';
 568   keyingString[numberWidth] = '\0';
 569
 570   for (i = 0; i < keying; i++) keyingString[i] = keyingInput[keying - 1 - i] + 48;
 571
 572   if (keying == numberWidth)
 573   {
 574     UINT newChannel = 0;
 575     for(i = keying - 1; i >= 0; i--) newChannel += keyingInput[i] * (ULONG)pow(10., i);
 576
 577     channelChange(NUMBER, newChannel);
 578     osdChannelIndex = currentChannelIndex;
 579     Timers::getInstance()->cancelTimer(this, 1); // cancel the timer to react to keying input,
 580     displayOSD(true); // this will put one back if required
 581   }
 582   else
 583   {
 584     osdChanNum.setText(keyingString);
 585
 586     if (!osd.getVisible())
 587     {
 588       osd.setVisible(true);
 589       draw();
 590     }
 591     else
 592     {
 593       osdChanNum.draw();
 594     }
 595     boxstack->update(this, osd.getRegion());
 596     Timers::getInstance()->setTimerD(this, 1, 3);  // 3s for keying input
 597   }
 598   delete[] keyingString;
 599 }
 600
 601 void VVideoLiveTV::doTeletext(bool subtitlemode)
 602 {
 603   if (streamType != VDR::VIDEO) return;
 604
 605   PlayerVideoLive* playervl = static_cast<PlayerVideoLive*>(player);
 606
 607   playervl->tellSubtitlesOSDVisible(true);
 608   bool exists = true;
 609
 610   // Cancel keying
 611   if (keying)
 612   {
 613     keying = 0;
 614     // and reset the display - this is a copy from setNowNextData
 615     char formatChanNum[20];
 616     SNPRINTF(formatChanNum, 19, "%0*lu", numberWidth, (*chanList)[osdChannelIndex]->number);
 617     osdChanNum.setText(formatChanNum);
 618     osdChanName.setText((*chanList)[osdChannelIndex]->name);
 619   }
 620   playervl->tellSubtitlesOSDVisible(true);
 621   if (osd.getVisible()) clearScreen();
 622   // Draw the teletxt
 623   VTeletextView* vtxv = playervl->getTeletextDecoder()->getTeletxtView();
 624   if (vtxv == NULL)
 625   {
 626     vtxv = new VTeletextView(playervl->getTeletextDecoder(), this, playervl);
 627     playervl->getTeletextDecoder()->registerTeletextView(vtxv);
 628     exists=false;
 629   }
 630
 631   vtxv->setSubtitleMode(subtitlemode);
 632   vtxv->draw();
 633   draw();
 634
 635   if (!exists)
 636   {
 637     BoxStack::getInstance()->add(vtxv);
 638   }
 639
 640   BoxStack::getInstance()->update(this);
 641   BoxStack::getInstance()->update(vtxv);
 642 }
 643
 644 void VVideoLiveTV::doAudioSelector()
 645 {
 646   // Only called if streamtype == VDR::VIDEO
 647   PlayerVideoLive* playervl = static_cast<PlayerVideoLive*>(player);
 648
 649   // If the osd is already visisble there might be a timer for it
 650   Timers::getInstance()->cancelTimer(this, 1);
 651   //This causes a deadlock with the timertrhread itself is locked
 652
 653   // Cancel keying
 654   if (keying)
 655   {
 656     keying = 0;
 657     // and reset the display - this is a copy from setNowNextData
 658     char formatChanNum[20];
 659     SNPRINTF(formatChanNum, 19, "%0*lu", numberWidth, (*chanList)[osdChannelIndex]->number);
 660     osdChanNum.setText(formatChanNum);
 661     osdChanName.setText((*chanList)[osdChannelIndex]->name);
 662   }
 663   int subtitleChannel = playervl->getCurrentSubtitleChannel();
 664   int subtitleType = 0x10;
 665   if (!playervl->isSubtitlesOn())
 666   {
 667     if (playervl->getTeletextDecoder()->getTeletxtView() &&
 668         playervl->getTeletextDecoder()->getTeletxtView()->isInSubtitleMode())
 669     {
 670       subtitleChannel = playervl->getTeletextDecoder()->getPage();
 671       subtitleType = 0x11;
 672     }
 673     else
 674     {
 675       subtitleType = 0xFF; //turnedOff
 676       subtitleChannel = 0;
 677     }
 678   }
 679
 680   // Draw the selector
 681   vas = new VAudioSelector(this, (*chanList)[currentChannelIndex], playervl->getCurrentAudioChannel(),
 682       subtitleType,subtitleChannel,NULL);
 683
 684   vas->setBackgroundColour(DrawStyle::OSDBACKGROUND);
 685   vas->setPosition(0, osd.getScreenY() - vas->getHeight());
 686   vas->draw();
 687
 688   // make vas != null and displayOSD will not set a timer or do any boxstack update
 689   if (osd.getVisible()) displayOSD(false);
 690   else displayOSD(true);
 691   draw();
 692
 693   BoxStack::getInstance()->add(vas);
 694   BoxStack::getInstance()->update(this);
 695   BoxStack::getInstance()->update(vas);
 696 }
 697
 698 void VVideoLiveTV::doEPG()
 699 {
 700   if (osd.getVisible()) clearScreen();
 701
 702   if (!Command::getInstance()->isAdvMenus())
 703   {
 704     VEpg* vepg = new VEpg(this, currentChannelIndex, chanList);
 705     vepg->draw();
 706     boxstack->add(vepg);
 707     boxstack->update(vepg);
 708   }
 709   else
 710   {
 711     Channel* currentChannel = (*chanList)[osdChannelIndex];
 712     VEpgListAdvanced  *vepg= new VEpgListAdvanced(this, chanList, currentChannel->number);
 713     vepg->draw();
 714     boxstack->add(vepg);
 715     boxstack->update(vepg);
 716   }
 717 }
 718
 719 void VVideoLiveTV::setNowNextData()
 720 {
 721   delData();
 722
 723   Channel* currentChannel = (*chanList)[osdChannelIndex];
 724
 725   char formatChanNum[20];
 726   SNPRINTF(formatChanNum, 19, "%0*lu", numberWidth, currentChannel->number);
 727   osdChanNum.setText(formatChanNum);
 728   osdChanName.setText(currentChannel->name);
 729
 730   eventList = VDR::getInstance()->getChannelSchedule(currentChannel->number);
 731
 732   if (!eventList)
 733   {
 734     sl.setText(tr("No channel data available"));
 735   }
 736   else
 737   {
 738     sort(eventList->begin(), eventList->end(), EventSorter());
 739
 740     char tempString[300];
 741     struct tm btime;
 742     Event* event;
 743     int eventListSize = eventList->size();
 744     std::stringstream ss;
 745     for(int i = 0; i < eventListSize; i++)
 746     {
 747       event = (*eventList)[i];
 748
 749       time_t etime = event->time;
 750       LOCALTIME_R(&etime, &btime);
 751       // FIXME convert following to std::strftime
 752 #ifndef _MSC_VER
 753       strftime(tempString, 299, "%0H:%0M ", &btime);
 754 #else
 755       strftime(tempString, 299, "%H:%M ", &btime);
 756 #endif
 757       ss << tempString << " " << event->title << "\n";
 758     }
 759     sl.setText(ss.str().c_str());
 760   }
 761 }
 762
 763
 764
 765 void VVideoLiveTV::displayOSD(bool newNowNextData)
 766 {
 767   PlayerVideoLive* playerlivetv = dynamic_cast<PlayerVideoLive*>(player);
 768   if (playerlivetv) playerlivetv->tellSubtitlesOSDVisible(true);
 769   osd.setVisible(true);
 770   if (newNowNextData)
 771   {
 772     setNowNextData();
 773     updatePosterBanner();
 774     keying = 0;
 775   }
 776   osd.draw();
 777   if (osdposterbanner.getVisible()) osdposterbanner.draw();
 778
 779
 780   Region  toupdate;
 781
 782   toupdate=*osd.getRegion();
 783
 784
 785   if (osdposterbanner.getVisible())
 786   {
 787     boxstack->update(this);
 788   }
 789   else
 790   {
 791     boxstack->update(this, &toupdate);
 792   }
 793
 794   bool setTimer = true;
 795   if (vas) setTimer = false;
 796   if (textUnavailable.getVisible()) setTimer = false;
 797
 798   if (setTimer) Timers::getInstance()->setTimerD(this, 1, 4);
 799 }
 800
 801 void VVideoLiveTV::clearScreen()
 802 {
 803   Timers::getInstance()->cancelTimer(this, 1);
 804
 805   textUnavailable.setVisible(false);
 806   osd.setVisible(false);
 807   osdposterbanner.setVisible(false);
 808
 809   okTriggeredOSD = false;
 810
 811   draw();
 812   boxstack->update(this);
 813
 814   PlayerVideoLive* playerlivetv = dynamic_cast<PlayerVideoLive*>(player);
 815   if (playerlivetv) playerlivetv->tellSubtitlesOSDVisible(false);
 816 }
 817
 818 void VVideoLiveTV::showUnavailable()
 819 {
 820   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Show unavailable called");
 821   textUnavailable.setVisible(true);
 822   textUnavailable.draw();
 823
 824   if (!osd.getVisible()) displayOSD(true);
 825
 826   boxstack->update(this, textUnavailable.getRegion());
 827 }
 828
 829 void VVideoLiveTV::setClock()
 830 {
 831   char timeString[20];
 832   time_t t;
 833   time(&t);
 834   struct tm tms;
 835   LOCALTIME_R(&t, &tms);
 836   strftime(timeString, 19, "%H:%M", &tms);
 837   clock.setText(timeString);
 838
 839   time_t dt = 60 - (t % 60);  // seconds to the next minute
 840   if (dt == 0) dt = 60; // advance a whole minute if necessary
 841   dt += t;  // get a time_t value for it rather than using duration
 842   // (so it will occur at the actual second and not second and a half)
 843
 844   Timers::getInstance()->setTimerT(this, 2, dt);
 845 }
 846
 847 void VVideoLiveTV::timercall(int ref)
 848 {
 849   if (ref == 1)
 850   {
 851     if (keying)
 852     {
 853       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 key start.");
 854       UINT newChannel = 0;
 855       for(int i = keying - 1; i >= 0; i--) newChannel += keyingInput[i] * (ULONG)pow(10., i);
 856
 857       Message* m = new Message();
 858       m->message = Message::CHANNEL_CHANGE;
 859       m->to = this;
 860       m->parameter = newChannel;
 861       m->tag = 1; // signal to call displayOSD();
 862       MessageQueue::getInstance()->postMessage(m);
 863       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 key end.");
 864     }
 865     else
 866     {
 867       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 not key start.");
 868       // We have received a timer, we are not keying. If still prebuffering, don't remove the bar
 869       if (preBuffering < 100)
 870       {
 871         Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Still prebuffering, not removing osd...");
 872         Timers::getInstance()->setTimerD(this, 1, 2); // reset timer for another 2s
 873         return;
 874       }
 875       bool osdpbvisible=osdposterbanner.getVisible();
 876       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 notkey 1.");
 877       osd.setVisible(false);
 878       osdposterbanner.setVisible(false);
 879       okTriggeredOSD = false;
 880       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 notkey 2.");
 881       draw();
 882       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 notkey 4.");
 883       if (osdpbvisible) boxstack->update(this);
 884       else  boxstack->update(this, osd.getRegion());
 885
 886       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 notkey 3.");
 887       PlayerVideoLive* playerlivetv = dynamic_cast<PlayerVideoLive*>(player);
 888       if (playerlivetv) playerlivetv->tellSubtitlesOSDVisible(false);
 889       Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 1 notkey end.");
 890     }
 891   }
 892   else if (ref == 2)
 893   {
 894     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 2  start.");
 895     setClock();
 896     if (osd.getVisible())
 897     {
 898       clock.draw();
 899       boxstack->update(this, osd.getRegion());
 900     }
 901     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Timer Call 2 end.");
 902   }
 903 }
 904
 905 bool VVideoLiveTV::channelChange(UCHAR changeType, UINT newData)
 906 {
 907   UINT newChannel = 0;
 908   if (streamType == VDR::VIDEO)
 909   {
 910     VTeletextView* vtxt = static_cast<PlayerVideoLive*>(player)->getTeletextDecoder()->getTeletxtView();
 911     if (vtxt)
 912     {
 913       BoxStack::getInstance()->remove(vtxt);
 914     }
 915   }
 916   if (changeType == INDEX)
 917   {
 918     newChannel = newData;
 919   }
 920   else if (changeType == NUMBER)
 921   {
 922     UINT i;
 923     for(i = 0; i < chanList->size(); i++)
 924     {
 925       if ((*chanList)[i]->number == newData)
 926       {
 927         newChannel = i;
 928         break;
 929       }
 930     }
 931
 932     if (i == chanList->size())
 933     {
 934       // no such channel
 935       return false;
 936     }
 937   }
 938   else if (changeType == OFFSET)
 939   {
 940     if (newData == UP) newChannel = upChannel(currentChannelIndex);
 941     else newChannel = downChannel(currentChannelIndex);
 942   }
 943   else if (changeType == PREVIOUS)
 944   {
 945     newChannel = previousChannelIndex;
 946   }
 947   else
 948   {
 949     return false; // bad input
 950   }
 951
 952   if (newChannel == currentChannelIndex) return true;
 953
 954   previousChannelIndex = currentChannelIndex;
 955   currentChannelIndex = newChannel;
 956
 957   preBuffering = 0;
 958
 959   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Set player to channel %u", currentChannelIndex);
 960   player->setChannel(currentChannelIndex);
 961   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Done Set player to channel %u", currentChannelIndex);
 962
 963   // Blank out the symbols
 964   OsdVector *osdv=dynamic_cast<OsdVector*>(Osd::getInstance());
 965
 966   bufferBar.setPercent(0);
 967
 968   if (!osdv)
 969   {
 970     sAudioChannels.setVisible(false);
 971     sAspectRatio.setVisible(false);
 972   }
 973   else
 974   {
 975     reslogo.setVisible(false);
 976     dolbylogo.setVisible(false);
 977     txtlogo.setVisible(false);
 978   }
 979
 980   // Remove other stuff
 981   if (textUnavailable.getVisible())
 982   {
 983     textUnavailable.setVisible(false);
 984   }
 985
 986   if (osdv)
 987   {
 988     TVMediaInfo info;
 989     Channel* currentChannel = (*chanList)[currentChannelIndex];
 990     if (currentChannel)
 991     {
 992       info.setChannelLogo(currentChannel->number);
 993       if (streamType == VDR::RADIO)
 994       {
 995         radioChannelLogo.setTVMedia(info, WTVMedia::ZoomVertical);
 996         radioChannelLogo.setVisible(true);
 997       }
 998       osdChannelLogo.setTVMedia(info, WTVMedia::ZoomVertical);
 999     }
1000   }
1001
1002   draw();
1003   BoxStack::getInstance()->update(this);
1004
1005   return true;
1006 }
1007
1008 void VVideoLiveTV::processMessage(Message* m)
1009 {
1010   if (m->message == Message::MOUSE_LBDOWN)
1011   {
1012     //check if press is outside this view! then simulate cancel
1013     int x = (m->parameter >> 16) - osd.getScreenX();
1014     int y = (m->parameter & 0xFFFF) - osd.getScreenY();
1015     if (osd.getVisible())
1016     {
1017         if ((boxRed.getX()<=x) && (boxRed.getX()+(int)boxRed.getWidth()>=x ) &&
1018             (boxRed.getY()<=y) && (boxRed.getY()+(int)boxRed.getHeight()>=y ))
1019         {
1020           BoxStack::getInstance()->handleCommand(Input::RED);
1021         }
1022         else if ((boxGreen.getX()<=x) && (boxGreen.getX()+(int)boxGreen.getWidth()>=x ) &&
1023                  (boxGreen.getY()<=y) && (boxGreen.getY()+(int)boxGreen.getHeight()>=y))
1024         {
1025           BoxStack::getInstance()->handleCommand(Input::GREEN);
1026         }
1027         else if ((boxYellow.getX()<=x) && (boxYellow.getX()+(int)boxYellow.getWidth()>=x ) &&
1028                  (boxYellow.getY()<=y) && (boxYellow.getY()+(int)boxYellow.getHeight()>=y )){
1029           BoxStack::getInstance()->handleCommand(Input::YELLOW);
1030         }
1031         else if ((boxBlue.getX()<=x) && (boxBlue.getX()+(int)boxBlue.getWidth()>=x ) &&
1032                  (boxBlue.getY()<=y) && (boxBlue.getY()+(int)boxBlue.getHeight()>=y ))
1033         {
1034           BoxStack::getInstance()->handleCommand(Input::BLUE);
1035         }
1036         else
1037         {
1038           BoxStack::getInstance()->handleCommand(Input::OK); //simulate rok press
1039         }
1040     }
1041     else
1042     {
1043       BoxStack::getInstance()->handleCommand(Input::OK); //simulate rok press
1044     }
1045   }
1046   else if (m->message == Message::CHANNEL_CHANGE)
1047   {
1048     channelChange(NUMBER, m->parameter);
1049     osdChannelIndex = currentChannelIndex;
1050     if (m->tag == 1) displayOSD(true);
1051   }
1052   else if (m->message == Message::CHILD_CLOSE)
1053   {
1054     if (m->from == vas)
1055     {
1056       vas = NULL;
1057       displayOSD(false);
1058     }
1059   }
1060   else if (m->message == Message::AUDIO_CHANGE_CHANNEL)
1061   {
1062     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Received change audio channel to %x", m->parameter);
1063     player->setAudioChannel((m->parameter & 0xFFFF), (m->parameter & 0xFF0000) >> 16, (m->parameter & 0xFF000000) >> 24);
1064   }
1065   else if (m->message == Message::SUBTITLE_CHANGE_CHANNEL)
1066   {
1067     if (streamType != VDR::VIDEO) return;
1068
1069     PlayerVideoLive* playervl = static_cast<PlayerVideoLive*>(player);
1070
1071     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Received change subtitle channel to %x", m->parameter);
1072     int type = (m->parameter & 0xFF0000) >> 16;
1073     switch (type)
1074     {
1075       case 0x10:
1076       {
1077         //dvbsubtitle
1078         playervl->setSubtitleChannel((m->parameter & 0xFFFF));
1079         playervl->turnSubtitlesOn(true);
1080         VTeletextView* vtxt = playervl->getTeletextDecoder()->getTeletxtView();
1081         if (vtxt && vtxt->isInSubtitleMode())
1082         {
1083           BoxStack::getInstance()->remove(vtxt);
1084         }
1085         break;
1086       }
1087       case 0xFF:
1088       {
1089         //nosubtitles
1090         playervl->turnSubtitlesOn(false);
1091         VTeletextView* vtxt = playervl->getTeletextDecoder()->getTeletxtView();
1092         if (vtxt && vtxt->isInSubtitleMode())
1093         {
1094           BoxStack::getInstance()->remove(vtxt);
1095         }
1096         break;
1097       }
1098       case 0x11:
1099       {
1100         //videotext
1101         playervl->turnSubtitlesOn(false);
1102         doTeletext(true);
1103         playervl->getTeletextDecoder()->setPage((m->parameter & 0xFFFF));
1104         break;
1105       }
1106     }
1107
1108     if (vas)
1109     {
1110       BoxStack::getInstance()->update(vas);
1111       //BoxStack::getInstance()->update(&osd); //eveil error
1112     }
1113     BoxStack::getInstance()->update(this, osd.getRegion());
1114   }
1115   else if (m->message == Message::PLAYER_EVENT)
1116   {
1117     switch (m->parameter)
1118     {
1119       case PlayerVideoLive::CONNECTION_LOST: // connection lost detected
1120       {
1121         Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Received connection lost from player");
1122         Command::getInstance()->connectionLost();
1123         break;
1124       }
1125
1126       case PlayerVideoLive::STREAM_END:
1127       {
1128         // Message comes from playerlivetv through master mutex, so can do anything here
1129         showUnavailable();
1130         break;
1131       }
1132
1133       case PlayerVideoLive::ASPECT43:
1134       {
1135         OsdVector* osdv=dynamic_cast<OsdVector*>(Osd::getInstance());
1136         if (osdv)
1137         {
1138           osdv->updateBackgroundColor(DrawStyle::BLACK);
1139         }
1140
1141         sAspectRatio.nextSymbol = WSymbol::VIDEOASPECT43;
1142         sAspectRatio.setVisible(true);
1143
1144         if (osd.getVisible()) // don't wake up the whole osd just for a aspect change
1145         {
1146           osd.draw();
1147           BoxStack::getInstance()->update(this, osd.getRegion());
1148         }
1149
1150         break;
1151       }
1152       case PlayerVideoLive::ASPECT169:
1153       {
1154         sAspectRatio.nextSymbol = WSymbol::VIDEOASPECT169;
1155         sAspectRatio.setVisible(true);
1156
1157         OsdVector* osdv=dynamic_cast<OsdVector*>(Osd::getInstance());
1158         if (osdv)
1159         {
1160           osdv->updateBackgroundColor(DrawStyle::BLACK);
1161         }
1162
1163
1164         if (osd.getVisible()) // don't wake up the whole osd just for a aspect change
1165         {
1166           osd.draw();
1167           BoxStack::getInstance()->update(this, osd.getRegion());
1168         }
1169
1170         break;
1171       }
1172       case PlayerVideoLive::PREBUFFERING:
1173       {
1174         preBuffering = m->tag;
1175         Log::getInstance()->log("VVideoRec", Log::DEBUG, "Prebuffering - %u", preBuffering);
1176         bufferBar.setPercent(preBuffering);
1177
1178         if (osd.getVisible())
1179         {
1180           bufferBar.setVisible(true);
1181           bufferBar.draw();
1182           Region r;
1183           bufferBar.getRootBoxRegion(&r);                       ///////// FIXME !!!
1184           BoxStack::getInstance()->update(this, &r);
1185
1186           if (preBuffering == 100)
1187           {
1188             doAudioChannelSymbol();
1189           }
1190         }
1191       }
1192     }
1193   }
1194 }
1195
1196 void VVideoLiveTV::doAudioChannelSymbol()
1197 {
1198   OsdVector *osdv=dynamic_cast<OsdVector*>(Osd::getInstance());
1199   // get the doobery
1200   Channel* currentChannel = (*chanList)[osdChannelIndex];
1201
1202   bool multiAudio = false;
1203   if (Audio::getInstance()->supportsAc3()) {
1204           if ((currentChannel->numDPids+currentChannel->numAPids) > 1) multiAudio = true;
1205   }
1206   if (currentChannel->numAPids > 1) multiAudio = true;
1207
1208   // draw the doobery
1209   if (!osdv) {
1210           if (multiAudio) sAudioChannels.nextSymbol = WSymbol::MULTIAUDIO;
1211           else            sAudioChannels.nextSymbol = WSymbol::SINGLEAUDIO;
1212           sAudioChannels.setVisible(true);
1213   }
1214   if (osdv)
1215   {
1216           dolbylogo.setVisible(true);
1217           txtlogo.setVisible(true);
1218           TVMediaInfo info;
1219           if (currentChannel->tpid!=0) info.setStaticArtwork(sa_txton);
1220           else info.setStaticArtwork(sa_txtoff);
1221           txtlogo.setTVMedia(info, WTVMedia::ZoomVertical);
1222
1223
1224           if (Audio::getInstance()->supportsAc3() && currentChannel->numDPids>1)
1225                   info.setStaticArtwork(sa_dolbyon);
1226           else info.setStaticArtwork(sa_dolbyoff);
1227           dolbylogo.setTVMedia(info, WTVMedia::ZoomVertical);
1228
1229          Demuxer* demux=Demuxer::getInstance();
1230          if (demux) {
1231                  int vertical_size=demux->getVerticalSize();
1232                  Log::getInstance()->log("VVideoRec", Log::DEBUG, "TVMedia vertical size %d", vertical_size);
1233                  reslogo.setVisible(true);
1234                  switch (vertical_size) {
1235                  case 576:
1236                          info.setStaticArtwork(sa_sd576i);
1237                          reslogo.setTVMedia(info, WTVMedia::ZoomVertical);break;
1238                  case 720:
1239                          info.setStaticArtwork(sa_hd720p);
1240                          reslogo.setTVMedia(info, WTVMedia::ZoomVertical);break;
1241                  case 1080:
1242                          info.setStaticArtwork(sa_hd1080i);
1243                          reslogo.setTVMedia(info, WTVMedia::ZoomVertical);break;
1244                  default: // we assume sd
1245                          reslogo.setVisible(false);
1246                  };
1247
1248          } else {
1249                  reslogo.setVisible(false);
1250          }
1251
1252
1253   }
1254
1255   if (osd.getVisible())
1256   {
1257     sAudioChannels.draw();
1258     Region r;
1259     sAudioChannels.getRootBoxRegion(&r);                       ///////// FIXME !!!
1260     // Fix this n'all.
1261     r.w = 32;
1262     r.h = 16;
1263     BoxStack::getInstance()->update(this, &r);
1264   }
1265 }
1266
1267 UINT VVideoLiveTV::upChannel(UINT index)
1268 {
1269   if (index == (chanList->size() - 1)) // at the end
1270     return 0; // so go to start
1271   else
1272     return index + 1;
1273 }
1274
1275 UINT VVideoLiveTV::downChannel(UINT index)
1276 {
1277   if (index == 0) // at the start
1278     return chanList->size() - 1; // so go to end
1279   else
1280     return index - 1;
1281 }
1282
1283 void VVideoLiveTV::toggleChopSides()
1284 {
1285   if (video->getTVsize() == Video::ASPECT16X9) return; // Means nothing for 16:9 TVs
1286
1287   if (videoMode == Video::NORMAL)
1288   {
1289     videoMode = Video::LETTERBOX;
1290     video->setMode(Video::LETTERBOX);
1291   }
1292   else
1293   {
1294     videoMode = Video::NORMAL;
1295     video->setMode(Video::NORMAL);
1296   }
1297 }
1298
1299 void VVideoLiveTV::updatePosterBanner()
1300 {
1301         OsdVector *osdv=dynamic_cast<OsdVector*>(Osd::getInstance());
1302         if (!osdv) {
1303                 osdposterbanner.setVisible(false);
1304                 return;
1305         }
1306         Event* toShow = NULL;
1307         if (eventList && eventList->size()) {
1308                 toShow = (*eventList)[0];
1309                 Channel* currentChannel = (*chanList)[osdChannelIndex];
1310                 toShow->loadinfos(currentChannel->number);
1311         }
1312
1313         if (toShow)
1314         {
1315                 TVMedia poster;
1316                 poster.height=0;
1317                 bool posterscale=true;
1318                 if (toShow->movieInfo) {
1319                         poster=toShow->movieInfo->poster;
1320                 }
1321                 if (toShow->seriesInfo) {
1322                         if (toShow->seriesInfo->banners.size()) {
1323                                 poster=toShow->seriesInfo->banners[0];
1324                                 posterscale=false;
1325                         } else if (toShow->seriesInfo->seasonposter.height) {
1326                                 poster=toShow->seriesInfo->seasonposter;
1327                         } else if (toShow->seriesInfo->posters.size()) {
1328                                 poster=toShow->seriesInfo->posters[0];
1329                         }
1330                 }
1331                 if (poster.height) {
1332                         osdposterbanner.setTVMedia(poster.info, posterscale ? WTVMedia::ZoomVertical : WTVMedia::ZoomHorizontal);
1333                         osdposterbanner.setVisible(true);
1334                 } else {
1335                         osdposterbanner.setVisible(false);
1336                 }
1337         } else {
1338                 osdposterbanner.setVisible(false);
1339         }
1340
1341 }
1342
1343
1344 void VVideoLiveTV::drawOSDBitmap(UINT posX, UINT posY, const Bitmap& bm, const DisplayRegion& region)
1345 {
1346   drawBitmap(posX, posY, bm,region);
1347   Region r;
1348   r.x = posX; r.y = posY; r.w = bm.getWidth(); r.h = bm.getHeight();
1349   boxstack->update(this, &r);
1350 }
1351
1352 void VVideoLiveTV::clearOSD()
1353 {
1354   rectangle(area, DrawStyle(0,0,0,0));
1355   boxstack->update(this, &area);
1356 }
1357
1358 void VVideoLiveTV::clearOSDArea(UINT posX, UINT posY, UINT width, UINT height, const DisplayRegion& region)
1359 {
1360   Region r;
1361   r.x = posX+region.windowx; r.y = posY+region.windowy; r.w = width; r.h = height;
1362   //now convert to our display
1363   float scalex=720.f/((float) (region.framewidth+1));
1364   float scaley=576.f/((float) (region.frameheight+1));
1365   r.x = (UINT)floor(scalex*((float)r.x));
1366   r.y = (UINT)floor(scaley*((float)r.y));
1367   r.w = (UINT)(ceil(scalex*((float)r.w))+1.f);
1368   r.h = (UINT)(ceil(scaley*((float)r.h))+1.f);
1369   rectangle(r, DrawStyle(0,0,0,0));
1370   boxstack->update(this, &r);
1371 }