gui/haiku/haiku.cpp

   1 //
   2 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   3 //   Foundation, Inc.
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "gnashconfig.h"
  22 #endif
  23
  24 #include "RunResources.h"
  25
  26 #include <boost/format.hpp>
  27
  28 #include "gnash.h"
  29 #include "adipe.h"
  30 #include "haikusup.h"
  31
  32
  33 #include <interface/Font.h>
  34 #include <Application.h>
  35 #include <Alert.h>
  36 #include <Window.h>
  37 #include <Screen.h>
  38
  39 using namespace std;
  40
  41 #ifndef RENDERER_AGG
  42 #error Haiku gui requires AGG renderer
  43 #endif
  44
  45 namespace gnash
  46 {
  47
  48 const int32 GNASH_PULSE = 'GPLS';
  49 const int32 GNASH_SEND_PULSE = 'GSPL';
  50 const int32 GNASH_QUITTING = 'GQUI';
  51
  52
  53 class BeWin : public BWindow
  54 {
  55     HaikuGui *_gui;
  56     BRect _unfullscreen_frame;
  57     bool _fullscreen;
  58 public:
  59     BeWin(BRect frame, const char *title, HaikuGui *gui)
  60     : BWindow(frame, title, B_TITLED_WINDOW, 0), _gui(gui),
  61         _fullscreen(false)
  62     {
  63     }
  64
  65     bool QuitRequested()
  66     {
  67         be_app_messenger.SendMessage(B_QUIT_REQUESTED);
  68         BWindow::QuitRequested();
  69         return false;
  70     }
  71
  72     void FrameResized(float width, float height)
  73     {
  74         BMessage msg(GNASH_RESIZE);
  75         if (msg.AddFloat("w", width) != B_OK
  76             || msg.AddFloat("h", height) != B_OK)
  77             QQ(1);
  78         else
  79             be_app_messenger.SendMessage(&msg);
  80     }
  81
  82     void setFullscreenEtc()
  83     {
  84         QQ(8);
  85         if (_fullscreen == true)
  86             return;
  87         _fullscreen = true;
  88
  89         BScreen s(this);
  90         BRect r(s.Frame());
  91         _unfullscreen_frame = Frame();
  92         MoveTo(0,0);
  93         ResizeTo(r.Width(), r.Height());
  94     }
  95
  96     void ScreenChanged(BRect frame, color_space mode)
  97     {
  98         (void) mode;
  99
 100         QQ(8);
 101         if (_fullscreen == false)
 102             return;
 103         // XXX perform in beapp thread
 104         MoveTo(0,0);
 105         ResizeTo(frame.Width(), frame.Height());
 106     }
 107
 108     void unsetFullscreenEtc()
 109     {
 110         QQ(8);
 111         if (_fullscreen == false)
 112             return;
 113         _fullscreen = false;
 114         MoveTo(_unfullscreen_frame.left, _unfullscreen_frame.top);
 115         ResizeTo(_unfullscreen_frame.Width(), _unfullscreen_frame.Height());
 116     }
 117
 118
 119 };
 120
 121 class BeApp : public BApplication
 122 {
 123     HaikuGui *_gui;
 124     BWindow *_win;
 125     thread_id _pulse_tid;
 126     time_t _start_t;
 127     time_t _timeout;
 128     int32 _mouse_moves_this_pulse;
 129     int32 _mousemovedx, _mousemovedy;
 130 public:
 131     BeApp(HaikuGui *gui)
 132     : BApplication("application/gnash-player"),
 133         _gui(gui), _win(NULL),
 134         _pulse_tid(-1),
 135         _start_t(time(NULL)),
 136         _timeout(0),
 137         _mouse_moves_this_pulse(0),
 138         _mousemovedx(0), _mousemovedy(0)
 139     {
 140         _pulse_tid = spawn_thread(SendPulses, "Pulses", B_NORMAL_PRIORITY, this);
 141         if (_pulse_tid <= 0) {
 142             throw runtime_error(_("spawn_thread failed"));
 143         }
 144         if (B_OK != resume_thread(_pulse_tid)) {
 145             throw runtime_error(_("resume_thread failed"));
 146         }
 147
 148     }
 149
 150     static int32
 151     SendPulses(void *data)
 152     {
 153         BeApp *that =
 154             static_cast<BeApp*>(data);
 155         assert(that != NULL);
 156         int32 i = that->SendPulsesEtc();
 157         if (i != 0) {
 158             boost::format fmt(_("pulses thread returned %d"));
 159             fmt = fmt % i;
 160             log_error(fmt.str());
 161         }
 162         return i;
 163     }
 164
 165
 166     int32
 167     SendPulsesEtc()
 168     {
 169         BMessage m(GNASH_PULSE);
 170         int32 code;
 171         thread_id sender;
 172
 173         while (true)
 174         {
 175             if (B_OK != be_app_messenger.SendMessage(&m))
 176                 return -1;
 177
 178             unsigned int interval =
 179                 _gui->getInterval();
 180             if (interval == 0)
 181                interval = 15;
 182             // interval in miliseconds, 1000 * interval in microseconds
 183             usleep(1000 * interval);
 184
 185             do {
 186                 code = receive_data(&sender, NULL, 0);
 187             } while (code == B_INTERRUPTED);
 188             switch (code)
 189             {
 190                 case GNASH_SEND_PULSE:
 191                     break;
 192                 case GNASH_QUITTING:
 193                     return 0;
 194                 default:
 195                     return -1;
 196             };
 197         }
 198         return 0;
 199     }
 200
 201     void setTimeout(time_t timeout)
 202     {
 203         _timeout = timeout;
 204     }
 205
 206     virtual ~BeApp()
 207     {
 208         status_t st, exit_value;
 209         do {
 210             st = send_data(_pulse_tid, GNASH_QUITTING, NULL, 0);
 211         } while (st == B_INTERRUPTED);
 212         if (st == B_OK)
 213             wait_for_thread(_pulse_tid, &exit_value);
 214     }
 215
 216     bool QuitRequested()
 217     {
 218         BApplication::QuitRequested();
 219         return true;
 220     }
 221
 222     bool Timedout()
 223     {
 224         return _timeout && time(NULL) - _start_t > _timeout;
 225     }
 226
 227     void setFullscreenEtc()
 228     {
 229         assert(_win != NULL);
 230         static_cast<BeWin*>(_win)->setFullscreenEtc();
 231     }
 232
 233     void unsetFullscreenEtc()
 234     {
 235         assert(_win != NULL);
 236         static_cast<BeWin*>(_win)->unsetFullscreenEtc();
 237     }
 238
 239     void MessageReceived(BMessage *msg)
 240     {
 241         switch (msg->what)
 242         {
 243             case GNASH_PULSE:
 244                 if (_mouse_moves_this_pulse > 3)
 245                     _gui->notifyMouseMove(_mousemovedx, _mousemovedy);
 246                 _mouse_moves_this_pulse = 0;
 247                 _gui->GnashPulse();
 248                 if (B_OK != send_data(_pulse_tid, GNASH_SEND_PULSE, NULL, 0)) {
 249                     log_error(_("send_data failed"));
 250                     Quit();
 251                 }
 252                 break;
 253             case GNASH_RESIZE:
 254             {
 255                 float width, height;
 256                 if (msg->FindFloat("w", &width) != B_OK
 257                     || msg->FindFloat("h", &height) != B_OK)
 258                     QQ(1);
 259                 else
 260                     _gui->resize_view(width+1, height+1);
 261                 break;
 262             }
 263             case GNASH_HIDDEN:
 264             {
 265                 _gui->Hidden();
 266                 break;
 267             }
 268             case GNASH_SHOWN:
 269             {
 270                 _gui->Shown();
 271                 break;
 272             }
 273             case GNASH_SET_FULLSCREEN:
 274                 _gui->setFullscreenEtc();
 275                 break;
 276             case GNASH_UNSET_FULLSCREEN:
 277                 _gui->unsetFullscreenEtc();
 278                 break;
 279             case GNASH_MOUSE_CLICKED:
 280             {
 281                 bool pressed;
 282                 int32 mask;
 283                 if (B_OK != msg->FindBool("pressed", &pressed)
 284                     || B_OK != msg->FindInt32("mask", &mask))
 285                     QQ(1);
 286                 else
 287                     _gui->notifyMouseClick(pressed);
 288                 break;
 289             }
 290             case GNASH_MOUSE_MOVED:
 291             {
 292                 ++ _mouse_moves_this_pulse;
 293                 int32 x, y;
 294                 if (B_OK != msg->FindInt32("x", &x)
 295                     || B_OK != msg->FindInt32("y", &y))
 296                     QQ(1);
 297                 else
 298                 {
 299                     if (_mouse_moves_this_pulse > 3)
 300                     {
 301                         _mousemovedx = x;
 302                         _mousemovedy = y;
 303                     } else
 304                         _gui->notifyMouseMove(x, y);
 305                 }
 306                 break;
 307             }
 308             case GNASH_KEY_EVENT:
 309             {
 310                 int32 key, modifiers;
 311                 bool pressed;
 312                 if (B_OK != msg->FindInt32("key", &key)
 313                     || B_OK != msg->FindInt32("modifiers", &modifiers)
 314                     || B_OK != msg->FindBool("pressed", &pressed))
 315                     QQ(1);
 316                 else
 317                     _gui->notify_key_event(static_cast<gnash::key::code>(key), modifiers, pressed);
 318                 break;
 319             }
 320             default:
 321                 BApplication::MessageReceived(msg);
 322         };
 323     }
 324
 325     void
 326     ReadyToRun()
 327     {
 328     }
 329
 330     bool
 331     CreateWindow(int width, int height, int xPosition, int yPosition,
 332                 const char *title)
 333     {
 334         assert(_win == NULL);
 335         QQ(8);
 336         _win = new BeWin(BRect(xPosition, yPosition, xPosition+width-1, yPosition+height-1),
 337             title, _gui);
 338         _win->Show();
 339         return true;
 340     }
 341
 342     BWindow**
 343     GetWinAddr()
 344     {
 345         return &_win;
 346     }
 347 };
 348
 349
 350 HaikuGui::HaikuGui(unsigned long xid, float scale, bool loop, RunResources& r)
 351     : Gui(xid, scale, loop, r), _app(NULL),
 352       _glue(this, xid), _timeout(0)
 353 {
 354     QQ(8);
 355 }
 356
 357 HaikuGui::~HaikuGui()
 358 {
 359     GNASH_REPORT_FUNCTION;
 360
 361     delete _app;
 362 }
 363
 364 bool
 365 HaikuGui::init(int argc, char **argv[])
 366 {
 367     QQ(8);
 368     GNASH_REPORT_FUNCTION;
 369     _app = new BeApp(this);
 370
 371 //    if (_xid)
 372 //            log_error (_("Ignoring request to display in X11 window"));
 373
 374     char c;
 375     int origopterr = opterr;
 376
 377     optind = 0;
 378     opterr = 0;
 379
 380     while ((c = getopt(argc, *argv, "D:")) != -1) {
 381         if (c == 'D') {
 382             // Terminate if no filename is given.
 383             if (!optarg) {
 384                 std::cout <<
 385                     _("# FATAL:  No filename given with -D argument.") << std::endl;
 386                 return false;
 387             }
 388             _sharefilename = optarg;
 389         }
 390     }
 391
 392
 393     opterr = origopterr;
 394
 395     _glue.init(argc, argv, _app->GetWinAddr(), _sharefilename);
 396
 397     _renderer.reset(_glue.createRenderHandler(32));
 398     if ( ! _renderer ) return false;
 399
 400     return true;
 401 }
 402
 403 bool
 404 HaikuGui::createWindow(const char *title, int width, int height,
 405               int xPosition, int yPosition)
 406 {
 407     GNASH_REPORT_FUNCTION;
 408     if (xPosition == -1 && yPosition == -1)
 409     {
 410         xPosition = 200;
 411         yPosition = 200;
 412     }
 413     _width = width;
 414     _height = height;
 415
 416
 417
 418     if (_xid == 0)
 419     {
 420         bool b = _app->CreateWindow(width, height, xPosition, yPosition,
 421             title);
 422         if (b == false)
 423             return false;
 424     } else {
 425     }
 426     _glue.prepDrawingArea(_width, _height, 0/*sdl_flags*/);
 427     _glue.ViewNeeded();
 428     _runResources.setRenderer(_renderer);
 429
 430     return true;
 431 }
 432
 433 bool
 434 HaikuGui::run()
 435 {
 436     GNASH_REPORT_FUNCTION;
 437     _app->Run();
 438     return ! _app->Timedout();
 439 }
 440
 441 void
 442 HaikuGui::renderBuffer()
 443 {
 444     _glue.render();
 445 }
 446
 447 void
 448 HaikuGui::setInterval(unsigned int interval)
 449 {
 450     _interval = interval;
 451 }
 452
 453 void
 454 HaikuGui::setTimeout(unsigned int timeout)
 455 {
 456     _timeout = timeout;
 457     _app->setTimeout((timeout+999)/1000);
 458 }
 459
 460 void
 461 HaikuGui::error(const std::string &msg)
 462 {
 463     BAlert *alert =
 464         new BAlert("Error", msg.c_str(), "Dismiss", NULL, NULL,
 465                 B_WIDTH_AS_USUAL, B_OFFSET_SPACING, B_STOP_ALERT);
 466     alert->Go();
 467 }
 468
 469 bool
 470 HaikuGui::yesno(const std::string& question)
 471 {
 472     BAlert *alert =
 473         new BAlert("yes/no", question.c_str(), "Yes", "No", NULL,
 474                 B_WIDTH_AS_USUAL, B_EVEN_SPACING, B_WARNING_ALERT);
 475     int32 answer = alert->Go();
 476     return answer == 0;
 477 }
 478
 479 void
 480 HaikuGui::setInvalidatedRegions(const InvalidatedRanges& ranges)
 481 {
 482     _glue.setInvalidatedRegions(ranges);
 483 }
 484
 485 bool
 486 HaikuGui::createMenu()
 487 {
 488     GNASH_REPORT_FUNCTION;
 489     return false;
 490 }
 491
 492 bool
 493 HaikuGui::createMenuBar()
 494 {
 495     GNASH_REPORT_FUNCTION;
 496     return false;
 497 }
 498
 499 bool
 500 HaikuGui::setupEvents()
 501 {
 502     GNASH_REPORT_FUNCTION;
 503     return false;
 504 }
 505
 506 void
 507 HaikuGui::setFullscreen()
 508 {
 509     BMessage m(GNASH_SET_FULLSCREEN);
 510     be_app_messenger.SendMessage(&m);
 511 }
 512
 513 void
 514 HaikuGui::setFullscreenEtc()
 515 {
 516     //_glue.BlankScreen();
 517     if (_xid != 0)
 518     {
 519         bool b = _app->CreateWindow(_width, _height, 0, 0,
 520                 "Gnash");
 521         if (b == false)
 522         {
 523             return;
 524         }
 525         //_glue.prepDrawingArea(_width+5, _height, 0/*sdl_flags*/);
 526         //_glue.prepDrawingArea(_width, _height, 0/*sdl_flags*/);
 527         _glue.ViewNeeded();
 528     }
 529     _app->setFullscreenEtc();
 530 }
 531
 532 void
 533 HaikuGui::unsetFullscreen()
 534 {
 535     BMessage m(GNASH_UNSET_FULLSCREEN);
 536     be_app_messenger.SendMessage(&m);
 537 }
 538
 539 void
 540 HaikuGui::unsetFullscreenEtc()
 541 {
 542     //_glue.BlankScreen();
 543     _app->unsetFullscreenEtc();
 544     if (_xid != 0)
 545     {
 546         (*_app->GetWinAddr())->LockLooper();
 547         (*_app->GetWinAddr())->Quit();
 548         (*_app->GetWinAddr()) = NULL;
 549         _glue.ViewNoMore();
 550     }
 551     //std::cerr << _width << " " << _height << std::endl;
 552     //_glue.prepDrawingArea(_width, _height, 0/*sdl_flags*/);
 553 }
 554
 555 void HaikuGui::GnashPulse()
 556 {
 557     if (_app->Timedout())
 558     {
 559         _app->Quit();
 560         return ;
 561     }
 562
 563     Gui::advance_movie(this);
 564 }
 565
 566 unsigned int
 567 HaikuGui::getInterval()
 568 {
 569     return _interval;
 570 }
 571
 572 void
 573 HaikuGui::resize_view(int width, int height)
 574 {
 575     std::cerr << width << " " << height << std::endl;
 576     _glue.prepDrawingArea(width, height, 0);
 577     Gui::resize_view(width, height);
 578 }
 579
 580 void
 581 HaikuGui::Shown()
 582 {
 583     _glue.Shown();
 584 }
 585
 586 void
 587 HaikuGui::Hidden()
 588 {
 589     _glue.Hidden();
 590 }
 591
 592
 593
 594 };
 595