src/frontends/qt4/QWorkArea.C

   1 /**
   2  * \file QWorkArea.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author John Levon
   7  * \author Abdelrazak Younes
   8  *
   9  * Full author contact details are available in file CREDITS.
  10  */
  11
  12 #include <config.h>
  13
  14 #include <boost/current_function.hpp>
  15
  16 #include "QWorkArea.h"
  17 #include "QLPainter.h"
  18 #include "QLyXKeySym.h"
  19
  20 #include "lcolorcache.h"
  21 #include "qt_helpers.h"
  22
  23 #include "debug.h"
  24 #include "funcrequest.h"
  25 #include "LColor.h"
  26 #include "support/os.h"
  27
  28 #include <QApplication>
  29 #include <QClipboard>
  30 #include <QLayout>
  31 #include <QMainWindow>
  32 #include <Q3UriDrag>
  33 #include <QDragEnterEvent>
  34 #include <QPixmap>
  35 #include <QPainter>
  36 #include <QScrollBar>
  37
  38 #include <boost/bind.hpp>
  39
  40 ///////////////////////////////////////////////////////////////
  41 // Specific stuff
  42 #ifdef Q_WS_X11
  43 #include <X11/Xlib.h>
  44 #endif
  45
  46 #ifdef Q_WS_MACX
  47 #include <Carbon/Carbon.h>
  48 #include <support/lstrings.h>
  49 using lyx::support::subst;
  50 #endif
  51
  52 // You can find other qt-immodule, X11 and MACX specific stuff
  53 // at the end of this file...
  54 ///////////////////////////////////////////////////////////////
  55
  56 using std::endl;
  57 using std::string;
  58
  59 namespace os = lyx::support::os;
  60
  61 namespace {
  62
  63 QWorkArea * wa_ptr = 0;
  64
  65 /// return the LyX key state from Qt's
  66 key_modifier::state q_key_state(Qt::ButtonState state)
  67 {
  68         key_modifier::state k = key_modifier::none;
  69         if (state & Qt::ControlModifier)
  70                 k |= key_modifier::ctrl;
  71         if (state & Qt::ShiftModifier)
  72                 k |= key_modifier::shift;
  73         if (state & Qt::AltModifier)
  74                 k |= key_modifier::alt;
  75         return k;
  76 }
  77
  78
  79 /// return the LyX mouse button state from Qt's
  80 mouse_button::state q_button_state(Qt::ButtonState button)
  81 {
  82         mouse_button::state b = mouse_button::none;
  83         switch (button) {
  84                 case Qt::LeftButton:
  85                         b = mouse_button::button1;
  86                         break;
  87                 case Qt::MidButton:
  88                         b = mouse_button::button2;
  89                         break;
  90                 case Qt::RightButton:
  91                         b = mouse_button::button3;
  92                         break;
  93                 default:
  94                         break;
  95         }
  96         return b;
  97 }
  98
  99
 100 /// return the LyX mouse button state from Qt's
 101 mouse_button::state q_motion_state(Qt::ButtonState state)
 102 {
 103         mouse_button::state b = mouse_button::none;
 104         if (state & Qt::LeftButton)
 105                 b |= mouse_button::button1;
 106         if (state & Qt::MidButton)
 107                 b |= mouse_button::button2;
 108         if (state & Qt::RightButton)
 109                 b |= mouse_button::button3;
 110         return b;
 111 }
 112
 113 } // namespace anon
 114
 115 // This is a 'heartbeat' generating synthetic mouse move events when the
 116 // cursor is at the top or bottom edge of the viewport. One scroll per 0.2 s
 117 SyntheticMouseEvent::SyntheticMouseEvent()
 118         : timeout(200), restart_timeout(true),
 119           x_old(-1), y_old(-1), scrollbar_value_old(-1.0)
 120 {}
 121
 122
 123 QWorkArea::QWorkArea(LyXView & owner, int w, int h)
 124     : QAbstractScrollArea(qApp->mainWidget()), WorkArea(), view_(owner), painter_(this)
 125 {
 126         setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 127         setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 128
 129         (static_cast<QMainWindow*>(qApp->mainWidget()))->setCentralWidget(this);
 130
 131         setAcceptDrops(true);
 132
 133         setMinimumSize(100, 70);
 134
 135         viewport()->setAutoFillBackground(false);
 136         viewport()->setAttribute(Qt::WA_OpaquePaintEvent);
 137
 138         viewport()->setFocusPolicy(Qt::WheelFocus);
 139         viewport()->setFocus();
 140         setFocusPolicy(Qt::WheelFocus);
 141
 142         viewport()->setCursor(Qt::IBeamCursor);
 143
 144         resize(w, h);
 145         show();
 146         workWidth_ = w;
 147         workHeight_ = h;
 148
 149         synthetic_mouse_event_.timeout.timeout.connect(
 150                 boost::bind(&QWorkArea::generateSyntheticMouseEvent,
 151                             this));
 152
 153         // Initialize the vertical Scroll Bar
 154         QObject::connect(verticalScrollBar(), SIGNAL(actionTriggered(int)),
 155                 this, SLOT(adjustViewWithScrollBar(int)));
 156
 157         // PageStep only depends on the viewport height.
 158         verticalScrollBar()->setPageStep(workHeight_);
 159
 160         lyxerr[Debug::GUI] << BOOST_CURRENT_FUNCTION
 161                 << "\n Area width\t" << width()
 162                 << "\n Area height\t" << height()
 163                 << "\n viewport width\t" << viewport()->width()
 164                 << "\n viewport height\t" << viewport()->height()
 165                 << endl;
 166
 167 /*
 168         // This is the keyboard buffering stuff...
 169         // I don't see any need for this under windows. The keyboard is reactive
 170     // enough...
 171
 172         if ( !QObject::connect(&step_timer_, SIGNAL(timeout()),
 173                 this, SLOT(keyeventTimeout())) )
 174                         lyxerr[Debug::GUI] << "ERROR: keyeventTimeout cannot connect!" << endl;
 175
 176         // Start the timer, one-shot.
 177         step_timer_.start(50, true);
 178 */
 179
 180         ///////////////////////////////////////////////////////////////////////
 181         // Specific stuff goes here...
 182
 183 #if USE_INPUT_METHODS
 184         // to make qt-immodule work
 185         setInputMethodEnabled(true);
 186 #endif
 187
 188 #ifdef Q_WS_X11
 189         // doubleClickInterval() is 400 ms on X11 witch is just too long.
 190         // On Windows and Mac OS X, the operating system's value is used.
 191         // On Microsoft Windows, calling this function sets the double
 192         // click interval for all applications. So we don't!
 193         QApplication::setDoubleClickInterval(300);
 194 #endif
 195
 196 #ifdef Q_WS_MACX
 197         wa_ptr = this;
 198 #endif
 199 }
 200
 201 QWorkArea::~QWorkArea()
 202 {
 203 }
 204
 205 void QWorkArea::setScrollbarParams(int h, int scroll_pos, int scroll_line_step)
 206 {
 207         // do what cursor movement does (some grey)
 208         h += height() / 4;
 209         int scroll_max_ = std::max(0, h - height());
 210
 211         verticalScrollBar()->setRange(0, scroll_max_);
 212         verticalScrollBar()->setSliderPosition(scroll_pos);
 213         verticalScrollBar()->setLineStep(scroll_line_step);
 214 }
 215
 216 void QWorkArea::adjustViewWithScrollBar(int action)
 217 {
 218         lyxerr[Debug::GUI] << BOOST_CURRENT_FUNCTION
 219                 << " verticalScrollBar val=" << verticalScrollBar()->value()
 220                 << " verticalScrollBar pos=" << verticalScrollBar()->sliderPosition()
 221                 << " min=" << verticalScrollBar()->minimum()
 222                 << " max=" << verticalScrollBar()->maximum()
 223                 << " pagestep=" << verticalScrollBar()->pageStep()
 224                 << " linestep=" << verticalScrollBar()->lineStep()
 225                 << endl;
 226
 227         view_.view()->scrollDocView(verticalScrollBar()->sliderPosition());
 228 }
 229
 230
 231 void QWorkArea::haveSelection(bool own) const
 232 {
 233         wa_ptr = this;
 234
 235         if (!QApplication::clipboard()->supportsSelection())
 236                 return;
 237
 238         if (own) {
 239                 QApplication::clipboard()->setText(QString(), QClipboard::Selection);
 240         }
 241         // We don't need to do anything if own = false, as this case is
 242         // handled by QT.
 243 }
 244
 245
 246 string const QWorkArea::getClipboard() const
 247 {
 248         QString str = QApplication::clipboard()->text(QClipboard::Selection);
 249         lyxerr[Debug::ACTION] << "getClipboard: " << (const char*) str << endl;
 250         if (str.isNull())
 251                 return string();
 252 #ifdef Q_WS_MACX
 253         // The MAC clipboard uses \r for lineendings, and we use \n
 254         return subst(fromqstr(str), '\r', '\n');
 255 #else
 256         return fromqstr(str);
 257 #endif
 258 }
 259
 260
 261 void QWorkArea::putClipboard(string const & str) const
 262 {
 263 #ifdef Q_WS_MACX
 264         // The MAC clipboard uses \r for lineendings, and we use \n
 265         QApplication::clipboard()->setText(toqstr(subst(str, '\n', '\r')),
 266                                            QClipboard::Selection);
 267 #else
 268         QApplication::clipboard()->setText(toqstr(str), QClipboard::Selection);
 269 #endif
 270         lyxerr[Debug::ACTION] << "putClipboard: " << str << endl;
 271 }
 272
 273
 274 void QWorkArea::dragEnterEvent(QDragEnterEvent * event)
 275 {
 276         event->accept(Q3UriDrag::canDecode(event));
 277
 278         /// \todo Ask lyx-devel is this is enough:
 279         /// if (event->mimeData()->hasFormat("text/plain"))
 280         ///     event->acceptProposedAction();
 281
 282 }
 283
 284
 285 void QWorkArea::dropEvent(QDropEvent* event)
 286 {
 287         QStringList files;
 288
 289         if (Q3UriDrag::decodeLocalFiles(event, files)) {
 290                 lyxerr[Debug::GUI] << "QWorkArea::dropEvent: got URIs!"
 291                                    << endl;
 292                 for (QStringList::Iterator i = files.begin();
 293                      i!=files.end(); ++i) {
 294                         string const file = os::internal_path(fromqstr(*i));
 295                         view_.view()->workAreaDispatch(FuncRequest(LFUN_FILE_OPEN, file));
 296                 }
 297         }
 298 }
 299
 300
 301 void QWorkArea::mousePressEvent(QMouseEvent * e)
 302 {
 303         if (dc_event_.active && dc_event_ == *e) {
 304                 dc_event_.active = false;
 305                 FuncRequest cmd(LFUN_MOUSE_TRIPLE,
 306                         dc_event_.x, dc_event_.y,
 307                         q_button_state(dc_event_.state));
 308                 view_.view()->workAreaDispatch(cmd);
 309                 return;
 310         }
 311
 312         FuncRequest const cmd(LFUN_MOUSE_PRESS, e->x(), e->y(),
 313                               q_button_state(e->button()));
 314         view_.view()->workAreaDispatch(cmd);
 315 }
 316
 317
 318 void QWorkArea::mouseReleaseEvent(QMouseEvent * e)
 319 {
 320         if (synthetic_mouse_event_.timeout.running())
 321                 synthetic_mouse_event_.timeout.stop();
 322
 323         FuncRequest const cmd(LFUN_MOUSE_RELEASE, e->x(), e->y(),
 324                               q_button_state(e->button()));
 325         view_.view()->workAreaDispatch(cmd);
 326 }
 327
 328
 329 void QWorkArea::mouseMoveEvent(QMouseEvent * e)
 330 {
 331         FuncRequest cmd(LFUN_MOUSE_MOTION, e->x(), e->y(),
 332                               q_motion_state(e->state()));
 333
 334         // If we're above or below the work area...
 335         if (e->y() <= 20 || e->y() >= viewport()->height() - 20) {
 336                 // Make sure only a synthetic event can cause a page scroll,
 337                 // so they come at a steady rate:
 338                 if (e->y() <= 20)
 339                         // _Force_ a scroll up:
 340                         cmd.y = -40;
 341                 else
 342                         cmd.y = viewport()->height();
 343                 // Store the event, to be handled when the timeout expires.
 344                 synthetic_mouse_event_.cmd = cmd;
 345
 346                 if (synthetic_mouse_event_.timeout.running())
 347                         // Discard the event. Note that it _may_ be handled
 348                         // when the timeout expires if
 349                         // synthetic_mouse_event_.cmd has not been overwritten.
 350                         // Ie, when the timeout expires, we handle the
 351                         // most recent event but discard all others that
 352                         // occurred after the one used to start the timeout
 353                         // in the first place.
 354                         return;
 355                 else {
 356                         synthetic_mouse_event_.restart_timeout = true;
 357                         synthetic_mouse_event_.timeout.start();
 358                         // Fall through to handle this event...
 359                 }
 360
 361         } else if (synthetic_mouse_event_.timeout.running()) {
 362                 // Store the event, to be possibly handled when the timeout
 363                 // expires.
 364                 // Once the timeout has expired, normal control is returned
 365                 // to mouseMoveEvent (restart_timeout = false).
 366                 // This results in a much smoother 'feel' when moving the
 367                 // mouse back into the work area.
 368                 synthetic_mouse_event_.cmd = cmd;
 369                 synthetic_mouse_event_.restart_timeout = false;
 370                 return;
 371         }
 372
 373         // Has anything changed on-screen since the last QMouseEvent
 374         // was received?
 375         double const scrollbar_value = verticalScrollBar()->value();
 376         if (e->x() != synthetic_mouse_event_.x_old ||
 377             e->y() != synthetic_mouse_event_.y_old ||
 378             scrollbar_value != synthetic_mouse_event_.scrollbar_value_old) {
 379                 // Yes it has. Store the params used to check this.
 380                 synthetic_mouse_event_.x_old = e->x();
 381                 synthetic_mouse_event_.y_old = e->y();
 382                 synthetic_mouse_event_.scrollbar_value_old = scrollbar_value;
 383
 384                 // ... and dispatch the event to the LyX core.
 385                 view_.view()->workAreaDispatch(cmd);
 386         }
 387 }
 388
 389
 390 void QWorkArea::wheelEvent(QWheelEvent * e)
 391 {
 392         // Wheel rotation by one notch results in a delta() of 120 (see
 393         // documentation of QWheelEvent)
 394         int const lines = QApplication::wheelScrollLines() * e->delta() / 120;
 395         verticalScrollBar()->setValue(verticalScrollBar()->value() -
 396                         lines *  verticalScrollBar()->lineStep());
 397         adjustViewWithScrollBar();
 398 }
 399
 400
 401 void QWorkArea::generateSyntheticMouseEvent()
 402 {
 403         // Set things off to generate the _next_ 'pseudo' event.
 404         if (synthetic_mouse_event_.restart_timeout)
 405                 synthetic_mouse_event_.timeout.start();
 406
 407         // Has anything changed on-screen since the last timeout signal
 408         // was received?
 409         double const scrollbar_value = verticalScrollBar()->value();
 410         if (scrollbar_value != synthetic_mouse_event_.scrollbar_value_old) {
 411                 // Yes it has. Store the params used to check this.
 412                 synthetic_mouse_event_.scrollbar_value_old = scrollbar_value;
 413
 414                 // ... and dispatch the event to the LyX core.
 415                 view_.view()->workAreaDispatch(synthetic_mouse_event_.cmd);
 416         }
 417 }
 418
 419 void QWorkArea::keyPressEvent(QKeyEvent * e)
 420 {
 421         lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
 422                 << " count=" << e->count()
 423                 << " text=" << (const char *) e->text()
 424                 << " isAutoRepeat=" << e->isAutoRepeat()
 425                 << " key=" << e->key()
 426                 << endl;
 427
 428 //      keyeventQueue_.push(boost::shared_ptr<QKeyEvent>(new QKeyEvent(*e)));
 429
 430     boost::shared_ptr<QLyXKeySym> sym(new QLyXKeySym);
 431     sym->set(e);
 432     view_.view()->workAreaKeyPress(sym, q_key_state(e->state()));
 433
 434 }
 435
 436 // This is not used for now...
 437 void QWorkArea::keyeventTimeout()
 438 {
 439         bool handle_autos = true;
 440
 441         while (!keyeventQueue_.empty()) {
 442                 boost::shared_ptr<QKeyEvent> ev = keyeventQueue_.front();
 443
 444                 // We never handle more than one auto repeated
 445                 // char in a list of queued up events.
 446                 if (!handle_autos && ev->isAutoRepeat()) {
 447                         keyeventQueue_.pop();
 448                         continue;
 449                 }
 450
 451                 boost::shared_ptr<QLyXKeySym> sym(new QLyXKeySym);
 452                 sym->set(ev.get());
 453
 454                 lyxerr[Debug::GUI] << BOOST_CURRENT_FUNCTION
 455                                    << " count=" << ev->count()
 456                                    << " text=" << (const char *) ev->text()
 457                                    << " isAutoRepeat=" << ev->isAutoRepeat()
 458                                    << " key=" << ev->key()
 459                                    << endl;
 460
 461                 view_.view()->workAreaKeyPress(sym, q_key_state(ev->state()));
 462                 keyeventQueue_.pop();
 463
 464                 handle_autos = false;
 465         }
 466
 467         // Restart the timer.
 468         step_timer_.start(25, true);
 469 }
 470
 471
 472 void QWorkArea::mouseDoubleClickEvent(QMouseEvent * e)
 473 {
 474         dc_event_ = double_click(e);
 475
 476         if (!dc_event_.active)
 477                 return;
 478
 479         dc_event_.active = false;
 480
 481         FuncRequest cmd(LFUN_MOUSE_DOUBLE,
 482                 dc_event_.x, dc_event_.y,
 483                 q_button_state(dc_event_.state));
 484         view_.view()->workAreaDispatch(cmd);
 485 }
 486
 487
 488 void QWorkArea::resizeEvent(QResizeEvent * resizeEvent)
 489 {
 490         workWidth_ = viewport()->width();
 491         workHeight_ = viewport()->height();
 492
 493         verticalScrollBar()->setPageStep(viewport()->height());
 494
 495         screen_device_ = QPixmap(viewport()->width(), viewport()->height());
 496         paint_device_ = QImage(viewport()->width(), viewport()->height(), QImage::Format_RGB32);
 497
 498         view_.view()->workAreaResize();
 499
 500         /*
 501         lyxerr[Debug::GUI] << BOOST_CURRENT_FUNCTION
 502                 << "\n QWidget width\t" << this->QWidget::width()
 503                 << "\n QWidget height\t" << this->QWidget::height()
 504                 << "\n viewport width\t" << viewport()->width()
 505                 << "\n viewport height\t" << viewport()->height()
 506                 << "\n QResizeEvent rect left\t" << rect().left()
 507                 << "\n QResizeEvent rect right\t" << rect().right()
 508                 << endl;
 509                 */
 510 }
 511
 512 void QWorkArea::update(int x, int y, int w, int h)
 513 {
 514         //screen_device_.fromImage(paint_device_);
 515         QPainter q(&screen_device_);
 516         q.drawImage(x, y, paint_device_.copy(x, y, w, h));
 517
 518         viewport()->update(x, y, w, h);
 519 }
 520
 521 void QWorkArea::paintEvent(QPaintEvent * e)
 522 {
 523         /*
 524         lyxerr[Debug::GUI] << BOOST_CURRENT_FUNCTION
 525                 << "\n QWidget width\t" << this->width()
 526                 << "\n QWidget height\t" << this->height()
 527                 << "\n viewport width\t" << viewport()->width()
 528                 << "\n viewport height\t" << viewport()->height()
 529                 << "\n pixmap width\t" << pixmap_->width()
 530                 << "\n pixmap height\t" << pixmap_->height()
 531                 << "\n QPaintEvent x\t" << e->rect().x()
 532                 << "\n QPaintEvent y\t" << e->rect().y()
 533                 << "\n QPaintEvent w\t" << e->rect().width()
 534                 << "\n QPaintEvent h\t" << e->rect().height()
 535                 << endl;
 536         */
 537         QPainter q(viewport());
 538         q.drawPixmap(e->rect(), screen_device_, e->rect());
 539 }
 540
 541
 542 QPixmap QWorkArea::copyScreen(int x, int y, int w, int h) const
 543 {
 544         return screen_device_.copy(x, y, w, h);
 545 }
 546
 547 void QWorkArea::drawScreen(int x, int y, QPixmap pixmap)
 548 {
 549         QPainter q(&screen_device_);
 550         q.drawPixmap(x, y, pixmap);
 551         viewport()->update(x, y, pixmap.width(), pixmap.height());
 552 }
 553
 554
 555 ///////////////////////////////////////////////////////////////
 556 ///////////////////////////////////////////////////////////////
 557 // Specific stuff
 558
 559 ////////////////////////////////////////////////////////////////////////
 560 // qt-immodule specific stuff goes here...
 561
 562 #if USE_INPUT_METHODS
 563 // to make qt-immodule work
 564
 565 void QWorkArea::inputMethodEvent(QInputMethodEvent * e)
 566 {
 567         QString const text = e->text();
 568         if (!text.isEmpty()) {
 569                 int key = 0;
 570                 // needed to make math superscript work on some systems
 571                 // ideally, such special coding should not be necessary
 572                 if (text == "^")
 573                         key = Qt::Key_AsciiCircum;
 574                 QKeyEvent ev(QEvent::KeyPress, key, *text.ascii(), 0, text);
 575                 keyPressEvent(&ev);
 576         }
 577         e->accept();
 578 }
 579 #endif
 580
 581
 582 ////////////////////////////////////////////////////////////////////////
 583 // X11 specific stuff goes here...
 584
 585 #ifdef Q_WS_X11
 586 bool lyxX11EventFilter(XEvent * xev)
 587 {
 588         switch (xev->type) {
 589         case SelectionRequest:
 590                 lyxerr[Debug::GUI] << "X requested selection." << endl;
 591                 if (wa_ptr)
 592                         wa_ptr->view().view()->selectionRequested();
 593                 break;
 594         case SelectionClear:
 595                 lyxerr[Debug::GUI] << "Lost selection." << endl;
 596                 if (wa_ptr)
 597                         wa_ptr->view().view()->selectionLost();
 598                 break;
 599         }
 600         return false;
 601 }
 602 #endif
 603
 604
 605 ////////////////////////////////////////////////////////////////////////
 606 // Mac OSX specific stuff goes here...
 607
 608 #ifdef Q_WS_MACX
 609 namespace{
 610 OSErr checkAppleEventForMissingParams(const AppleEvent& theAppleEvent)
 611  {
 612         DescType returnedType;
 613         Size actualSize;
 614         OSErr err = AEGetAttributePtr(&theAppleEvent, keyMissedKeywordAttr,
 615                                       typeWildCard, &returnedType, nil, 0,
 616                                       &actualSize);
 617         switch (err) {
 618         case errAEDescNotFound:
 619                 return noErr;
 620         case noErr:
 621                 return errAEEventNotHandled;
 622         default:
 623                 return err;
 624         }
 625  }
 626 }
 627
 628 pascal OSErr handleOpenDocuments(const AppleEvent* inEvent,
 629                                  AppleEvent* /*reply*/, long /*refCon*/)
 630 {
 631         QString s_arg;
 632         AEDescList documentList;
 633         OSErr err = AEGetParamDesc(inEvent, keyDirectObject, typeAEList,
 634                                    &documentList);
 635         if (err != noErr)
 636                 return err;
 637
 638         err = checkAppleEventForMissingParams(*inEvent);
 639         if (err == noErr) {
 640                 long documentCount;
 641                 err = AECountItems(&documentList, &documentCount);
 642                 for (long documentIndex = 1;
 643                      err == noErr && documentIndex <= documentCount;
 644                      documentIndex++) {
 645                         DescType returnedType;
 646                         Size actualSize;
 647                         AEKeyword keyword;
 648                         FSRef ref;
 649                         char qstr_buf[1024];
 650                         err = AESizeOfNthItem(&documentList, documentIndex,
 651                                               &returnedType, &actualSize);
 652                         if (err == noErr) {
 653                                 err = AEGetNthPtr(&documentList, documentIndex,
 654                                                   typeFSRef, &keyword,
 655                                                   &returnedType, (Ptr)&ref,
 656                                                   sizeof(FSRef), &actualSize);
 657                                 if (err == noErr) {
 658                                         FSRefMakePath(&ref, (UInt8*)qstr_buf,
 659                                                       1024);
 660                                         s_arg=QString::fromUtf8(qstr_buf);
 661                                         wa_ptr->view().view()->workAreaDispatch(
 662                                                 FuncRequest(LFUN_FILE_OPEN,
 663                                                             fromqstr(s_arg)));
 664                                         break;
 665                                 }
 666                         }
 667                 } // for ...
 668         }
 669         AEDisposeDesc(&documentList);
 670         return err;
 671 }
 672 #endif  // Q_WS_MACX