root/trunk/orca/qt/qorca.cpp

/*============================================================================
    ORCA Qt Module
    Copyright (C) 2005-2006  Karl Robillard

    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
    as published by the Free Software Foundation; either version 2
    of the License, or (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
    02110-1301, USA.
============================================================================*/


#include <assert.h>
#include <QCloseEvent>
#include <QEventLoop>
#include <QFileDialog>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QMessageBox>
#include <QTextCursor>
#include "qorca.h"
#include "cbparse.h"


inline bool qEnvExists() { return qEnv.atom_close > 0; }


struct LayoutInfo
{
    LayoutInfo() : box(0), grid(0) {}

    QLayout* layout()
    {
        if( box )
            return box;
        return grid;
    }

    void addLayout( QLayout* );
    void addWidget( QWidget* );

    QBoxLayout*  box;
    QGridLayout* grid;
    int columns;
    int colN;
    int rowN;
};


QtEnv qEnv;


//----------------------------------------------------------------------------


void LayoutInfo::addLayout( QLayout* lo )
{
    if( box )
    {
        box->addLayout( lo );
    }
    else
    {
        grid->addLayout( lo, rowN, colN );

        ++colN;
        if( colN == columns )
        {
            colN = 0;
            ++rowN;
        }
    }
}


void LayoutInfo::addWidget( QWidget* wid )
{
    if( box )
    {
        box->addWidget( wid );
    }
    else
    {
        grid->addWidget( wid, rowN, colN );

        ++colN;
        if( colN == columns )
        {
            colN = 0;
            ++rowN;
        }
    }
}


//----------------------------------------------------------------------------


/**
  Returns REC id.
*/
int WIDPool::add( QObject* ptr, int type, int flags )
{
    int index;
    if( _freeCount )
    {
        index = _freeIndex;
        REC& rec = _records[ index ];

        _freeIndex = rec.type;

        rec.type   = type;
        rec.flags  = flags;
        rec.object = ptr;

        --_freeCount;
    }
    else
    {
        index = _records.size();
        REC rec;
        rec.type   = type;
        rec.flags  = flags;
        rec.object = ptr;
        _records.push_back( rec ); 
    }
    return index;
}


void WIDPool::remove( int id )
{
    if( qEnvExists() )
    {
        REC& rec = _records[ id ];

        assert( rec.widget ); 

        rec.type = _freeIndex;
        _freeIndex = id;
        rec.object = 0;

        ++_freeCount;
    }
}


WIDPool::REC* WIDPool::record( int id )
{
    if( (id > -1) && id < _records.size() )
    {
        REC* rec = &_records[ id ];
        if( rec->object )
            return rec;
    }
    return 0;
}


//----------------------------------------------------------------------------


struct AOString : public OString
{
    AOString()       { orArrayInit( this, sizeof(char), 0 ); }
    AOString(int n)  { orArrayInit( this, sizeof(char), n ); }
    ~AOString()      { orArrayFree( this ); }

    const char* mold( const OValue* val )
    {
        orMold( this, val );    // Calls orTermCStr() for us.
        return charArray;
    }

    const char* form( const OValue* val )
    {
        orForm( this, val );    // Calls orTermCStr() for us.
        return charArray;
    }
};


//----------------------------------------------------------------------------


/*
  Note that argc is a reference!  If it is not, QApplication will
  store the stack position of the local argc and crash when argc is used
  after the constructor exits.
*/
QOrcaApp::QOrcaApp( int& argc, char** argv ) : QApplication( argc, argv )
{
    setQuitOnLastWindowClosed( false );
}


/*
   Returns non-zero if error thrown.
*/
int qoError()
{
    if( orErrorThrown )
    {
        switch( orErrorType(orErrorThrown) )
        {
            case OR_ERROR_THROW:
                return 1;

            case OR_ERROR_QUIT:
                qApp->quit();
                return 1;

            //case OR_ERROR_HALT:
            default:
#ifdef _WIN32
            {
                QString msg;
                AOString str;

                if( str.form( orErrorThrown ) )
                    msg = str.charArray;

                QMessageBox::warning( 0, "Script Error", msg,
                                      QMessageBox::Ok, QMessageBox::NoButton );
            }
#else
                orPrintNative( orErrorThrown );
#endif
                break;
        }

        orErrorClear;
    }
    return 0;
}


#if 0
static void comboBlock( QComboBox* combo, OValue* it, OValue* end )
{
    while( it != end )
    {
        if( it->type == OT_STRING )
        {
            OString* str = orSTRING(it);
            const char* cp = str->charArray + it->series.it;
            combo->addItem( cp );
        }
        ++it;
    }
}
#endif


QLayout* qoLayout( LayoutInfo& parent, OIndex blkN, OIndex si );

static void tabBlock( QTabWidget* tab, OValue* it, const char* label )
{
    LayoutInfo layout;
    QLayout* lo;
    QWidget* wid = new QWidget;

    lo = qoLayout( layout, it->index, it->series.it );
    wid->setLayout( lo );

    tab->addTab( wid, QString(label) );
}


static void tabWidgetBlock( QTabWidget* tab, OValue* it, OValue* end )
{
    const char* label = 0;

    while( it != end )
    {
        if( it->type == OT_STRING )
        {
            OString* str = orSTRING(it);
            label = str->charArray + it->series.it;
        }
        else if( it->type == OT_WORD )
        {
            OValue* val;
            OBlock* ctx;
            orWordVal( it, ctx, val );

            if( label && (val->type == OT_BLOCK) )
            {
                tabBlock( tab, val, label );
                label = 0;
            }
            //printf( "KR word\n" );
        }
        else if( it->type == OT_BLOCK )
        {
            if( label )
            {
                tabBlock( tab, it, label );
                label = 0;
            }
        }

        ++it;
    }
}


static void setWID( OValue*& prev, int id )
{
    if( prev )
    {
        OValue* val;
        OBlock* ctx;
        orWordVal( prev, ctx, val );
        orSetTF( val, OT_INTEGER );
        val->integer = id;
        prev = 0;
    }
}


static void valueToQString( const OValue* val, QString& str )
{
    if( orIsString( val->type ) )
    {
        str = cstring( val );
    }
    else if( val->type == OT_INTEGER )
    {
        str.setNum( val->integer );
    }
    else if( val->type == OT_DECIMAL )
    {
        str.setNum( val->num.decimal );
    }
    else if( val->type == OT_NONE )
    {
        str.clear();
    }
    else
    {
        AOString ts;
        str = ts.mold( val );
    }
}


#define LD_HBOX         0
#define LD_VBOX         1
#define LD_SPACER       2
#define LD_LABEL        3
#define LD_BUTTON       4
#define LD_CHECKBOX     5
#define LD_COMBO        6
#define LD_COMBO_BLK    7
#define LD_TIP          8
#define LD_TITLE        9
#define LD_RESIZE       10
#define LD_LINE_EDITS   11
#define LD_LINE_EDIT    12
#define LD_TEXT_EDITS   13
#define LD_TEXT_EDIT    14
#define LD_GROUP        15
#define LD_READ_ONLY    16
#define LD_ON_EVENT     17
#define LD_TAB          18
#define LD_STRING       19
#define LD_BLOCK        20
#define LD_SET_WORD     21
#define LD_GRID         22
#define LD_PROGRESS     23
#define LD_WEIGHT       24


/*
   Layout Dialect
*/
QLayout* qoLayout( LayoutInfo& parent, OIndex blkN, OIndex si )
{
    CBParser cbp;
    OBlock* ruleSet;
    OValue* match;
    OBlock* blk;
    OValue* val;
    OValue* setWord = 0;
    LayoutInfo lo;
    QWidget* wid = 0;

    blk = orBlockPtr( blkN );

    ruleSet = orBlockPtr( qEnv.layoutRulesBlkN );

    cbp_beginParse( &cbp, blk->values + si, blk->values + blk->used, ruleSet );
    while( (match = cbp_matchRule( &cbp )) )
    {
        switch( match->integer )
        {
            case LD_HBOX:
            case LD_VBOX:
            {
                wid = 0;

                lo.grid = 0;
                lo.box  = new QBoxLayout( (match->integer == LD_HBOX) ? 
                                          QBoxLayout::LeftToRight :
                                          QBoxLayout::TopToBottom );
                if( parent.layout() )
                    parent.addLayout( lo.box );

                val = cbp.values + 1;
                qoLayout( lo, val->index, val->series.it );
            }
                break;

            case LD_SPACER:
                if( ! parent.box )
                    goto no_layout;

                parent.box->addStretch( 1 );
                break;

            case LD_LABEL:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SLabel* pw = new SLabel;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );

                val = cbp.values + 1;
                if( orIs(val, OT_WORD) )
                {
                    orWordVal( val, blk, val );
                }
                QString txt;
                valueToQString( val, txt );
                pw->setText( txt );

                wid = pw;
            }
                break;

            case LD_BUTTON:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SButton* pw = new SButton;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                pw->setText( cstring( cbp.values + 1 ) );
                pw->setBlock( cbp.values + 2 );
                wid = pw;
            }
                break;

            case LD_CHECKBOX:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SCheck* pw = new SCheck;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                pw->setText( cstring( cbp.values + 1 ) );
                wid = pw;
            }
                break;

            case LD_COMBO:
            case LD_COMBO_BLK:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SCombo* pw = new SCombo;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                wid = pw;

                val = cbp.values + 1;
                if( orIs(val, OT_BLOCK) )
                {
                    OBlock* blk = orBLOCK(val);
                    OValue* it  = blk->values + val->series.it;
                    OValue* end = blk->values + blk->used;
                    while( it != end )
                    {
                        if( orIs(it, OT_STRING) )
                            pw->addItem( cstring( it ) );
                        ++it;
                    }
                }
                else
                {
                    pw->addItem( cstring( val ) );
                }
            }
                break;

            case LD_TAB:
            {
                if( ! parent.layout() )
                    goto no_layout;

                STabWidget* pw = new STabWidget;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                wid = pw;

                val = cbp.values + 1;
                OBlock* blk = orBLOCK( val );
                tabWidgetBlock( pw, blk->values + val->series.it,
                                    blk->values + blk->used );
            }
                break;

            case LD_TIP:
                if( wid )
                    wid->setToolTip( cstring(cbp.values + 1) );
                break;

            case LD_TITLE:
            {
                if( qEnv.curWidget )
                    qEnv.curWidget->setWindowTitle( cstring(cbp.values + 1) );
            }
                break;

            case LD_RESIZE:
            {
                if( qEnv.curWidget )
                {
                    val = cbp.values + 1;
                    qEnv.curWidget->resize( val->pair[0], val->pair[1] );
                }
            }
                break;

            case LD_LINE_EDITS:
            case LD_LINE_EDIT:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SLineEdit* pw = new SLineEdit;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                wid = pw;

                if( match->integer == LD_LINE_EDITS )
                    pw->setText( cstring( cbp.values + 1 ) );
            }
                break;

            case LD_TEXT_EDITS:
            case LD_TEXT_EDIT:
            {
                if( ! parent.layout() )
                    goto no_layout;

                STextEdit* pw = new STextEdit;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                wid = pw;

                if( match->integer == LD_TEXT_EDITS )
                {
                    const char* str = cstring( cbp.values + 1 );
                    if( *str == '<' )
                        pw->setHtml( str );
                    else
                        pw->setPlainText( str );
                }
            }
                break;

            case LD_GROUP:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SGroup* pw = new SGroup;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                wid = pw;

                val = cbp.values + 1;
                pw->setTitle( cstring( val ) );

                ++val;

                LayoutInfo lo2;
                pw->setLayout( qoLayout(lo2, val->index, val->series.it) );
            }
                break;

            case LD_READ_ONLY:
                if( wid )
                {
                    QTextEdit* tedit = qobject_cast<QTextEdit*>( wid );
                    if( tedit )
                        tedit->setReadOnly( true );
                }
                break;

            case LD_ON_EVENT:
                if( qEnv.curWidget )
                {
                    SWidget* sw = qobject_cast<SWidget*>( qEnv.curWidget );
                    if( sw )
                        sw->setEventBlock( cbp.values + 1 );
                }
                break;

            case LD_STRING:
                if( wid )
                {
                    SCombo* combo = qobject_cast<SCombo*>( wid );
                    if( combo )
                    {
                        combo->addItem( cstring( cbp.values ) );
                        break;
                    }

                    QTextEdit* texted = qobject_cast<QTextEdit*>( wid );
                    if( texted )
                    {
                        const char* str = cstring( cbp.values );
                        if( *str == '<' )
                            texted->setHtml( str );
                        else
                            texted->setPlainText( str );
                    }
                }
                break;

            case LD_BLOCK:
                if( wid )
                {
                    SCombo* combo = qobject_cast<SCombo*>( wid );
                    if( combo )
                        combo->setBlock( cbp.values );
                }
                break;

            case LD_SET_WORD:
                setWord = cbp.values;
                break;

            case LD_GRID:
                val = cbp.values + 1;

                wid = 0;

                lo.box     = 0;
                lo.grid    = new QGridLayout;
                lo.columns = val->integer;
                lo.colN    = 0;
                lo.rowN    = 0;

                if( parent.layout() )
                    parent.addLayout( lo.grid );

                ++val;
                qoLayout( lo, val->index, val->series.it );
                break;

            case LD_PROGRESS:
            {
                if( ! parent.layout() )
                    goto no_layout;

                SProgress* pw = new SProgress;
                parent.addWidget( pw );
                setWID( setWord, pw->_wid );
                pw->setRange( 0, cbp.values[1].integer );
                wid = pw;
            }
                break;

            case LD_WEIGHT:
                if( parent.box && wid )
                {
                    parent.box->setStretchFactor(wid, cbp.values[1].integer);
                }
                break;
        }
    }

    if( cbp.error )
    {
        orError( "layout parse error" );
        blk = orBlockPtr( blkN );
        orSetErrorLoc( blkN, cbp.error - blk->values );
    }

    return lo.layout();

no_layout:

    orError( "layout requires hbox or vbox" );
    return 0;
}


static int catchExit( OValue* a1 )
{
    if( orErrorThrown && orErrorIsType( OR_ERROR_THROW ) )
    {
        if( orErrorThrown->error.msg == qEnv.atom_exec_exit )
        {
            orCopyV( a1, *(orErrorThrown + 1) );
            orErrorClear;
            return qEnv.atom_exec_exit;
        }
        else if( orErrorThrown->error.msg == qEnv.atom_close )
        {
            orCopyV( a1, *(orErrorThrown + 1) );
            orErrorClear;
            return qEnv.atom_close;
        }
    }
    return 0;
}


OR_NATIVE( execNative )
{
    if( a1->type == OT_INTEGER )
    {
        WIDPool::REC* rec = qEnv.pool.record( a1->integer );
        if( rec )
        {
            if( rec->type == WT_Dialog )
            {
                QDialog* saveDialog = qEnv.dialog;

                qEnv.dialog = (QDialog*) rec->widget;
                qEnv.dialog->exec();
                qEnv.dialog = saveDialog;

                catchExit( a1 );
            }
            else if( rec->type == WT_Widget )
            {
                QWidget* widget = rec->widget;

                widget->show();
                qEnv.loop->exec();
                if( catchExit( a1 ) == qEnv.atom_close )
                    widget->hide();
            }
            else
            {
                rec = 0;
            }
        }
        if( ! rec )
        {
            orError( "Invalid widget ID %d", a1->integer );
            return;
        }
    }
    else
    {
        // Update.
        qEnv.loop->processEvents();
        catchExit( a1 );
    }
}


static void execExit( OAtom word, OValue* a1 )
{
    if( qEnv.dialog )
        qEnv.dialog->accept();
    else
        qEnv.loop->quit();

    // Only allowing simple values - complex ones will become invalid if
    // garbage collection occurs.

    // Same as orThrowNative (throw/name a1 'close)
    {
    a1[1] = *a1;

    orSetError( a1, OR_ERROR_THROW );

    a1->error.msg     = word;
    a1->error.block   = 0;
    a1->error.nearVal = 0;
    }
}


OR_NATIVE( execExitNative )
{
    execExit( qEnv.atom_exec_exit, a1 );
}


OR_NATIVE( closeNative )
{
    execExit( qEnv.atom_close, a1 );
}


OR_NATIVE( showNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        if( rec->type == WT_Widget )
        {
            rec->widget->show();

            // Update.
            qEnv.loop->processEvents();
            catchExit( a1 );
        }
    }
}


static int layoutWidget( QWidget* wid, OValue* a1 )
{
    LayoutInfo li;
    QLayout* lo;

    QWidget* saveWidget = qEnv.curWidget;
    qEnv.curWidget = wid;

    lo = qoLayout( li, a1->index, a1->series.it );

    qEnv.curWidget = saveWidget;

    if( orErrorThrown )
    {
        delete wid;
        qoError();
        return 0;
    }

    if( lo )
    {
        wid->setLayout( lo );
    }
    else
    {
        orError( "Invalid widget layout" );
        qoError();
        return 0;
    }

    return 1;
}


OR_NATIVE( dialogNative )
{
    SDialog* dlg = new SDialog;
    dlg->setModal( true );
    if( layoutWidget( dlg, a1 ) )
    {
        orResult( OT_INTEGER, dlg->_wid );
    }
}


OR_NATIVE( widgetNative )
{
    SWidget* wid = new SWidget;
    if( layoutWidget( wid, a1 ) )
    {
        orResult( OT_INTEGER, wid->_wid );
    }
}


OR_NATIVE( destroyNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        delete rec->object;
    }
    orResultNONE;
}


#define REF_RF_SAVE    a1+1
#define REF_RF_DIR     a1+2
#define REF_RF_INIT    a1+3
#define REF_RF_PATH    a1+4

OR_NATIVE( requestFileNative )
{
    QString fn;
    QString dir;
    OString* str;
    const char* cp;

    if( orRefineSet( REF_RF_INIT ) )
    {
        OValue* ref = REF_RF_PATH;
        str = orSTRING( ref );
        orTermCStr( str );
        dir = orStrChars( str, ref );
    }
    else
    {
        dir = qEnv.filePath;
    }

    str = orSTRING(a1);
    orTermCStr( str );
    cp = orStrChars( str, a1 );

    if( orRefineSet( REF_RF_DIR ) )
    {
        fn = QFileDialog::getExistingDirectory(0, QString(cp), dir );
    }
    else if( orRefineSet( REF_RF_SAVE ) )
    {
        fn = QFileDialog::getSaveFileName( 0, QString(cp), dir );
    }
    else
    {
        fn = QFileDialog::getOpenFileName( 0, QString(cp), dir );
    }

    if( fn.isEmpty() )
    {
        orResultNONE;
    }
    else
    {
        qEnv.filePath = fn;
        OIndex index = orMakeCString( (const char*) fn.toAscii(), -1 );
        orResultFILE( index );
    }
}


OR_NATIVE( enableNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        QWidget* widget = qobject_cast<QWidget*>( rec->object );
        if( widget )
            widget->setEnabled( true );
    }
}


OR_NATIVE( disableNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        QWidget* widget = qobject_cast<QWidget*>( rec->object );
        if( widget )
            widget->setEnabled( false );
    }
}


OR_NATIVE( widgetValueNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        switch( rec->type )
        {
            case WT_CheckBox:
            {
                Qt::CheckState state = ((QCheckBox*) rec->widget)->checkState();
                orResult( OT_LOGIC, (state == Qt::Unchecked) ? 0 : 1 );
            }
                break;

            case WT_Combo:
                orResult( OT_INTEGER,
                          ((QComboBox*) rec->widget)->currentIndex() + 1 );
                break;

            case WT_LineEdit:
            {
                QString text = ((QLineEdit*) rec->widget)->text();
                orResultSTRING( orMakeCString( text.toAscii(), -1 ) );
            }
                break;

            case WT_TextEdit:
            {
                QString text = ((QTextEdit*) rec->widget)->toPlainText();
                orResultSTRING( orMakeCString( text.toAscii(), -1 ) );
            }
                break;

            default:
                break;
        }
    }
}


OR_NATIVE( setWidgetValueNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        const OValue* a2 = a1 + 1;

        switch( rec->type )
        {
            case WT_CheckBox:
            {
                Qt::CheckState state;

                if( (a2->type == OT_NONE) ||
                    ((a2->type == OT_LOGIC) && (a2->integer == OR_FALSE)) )
                    state = Qt::Unchecked;
                else
                    state = Qt::Checked;

                ((QCheckBox*) rec->widget)->setCheckState( state );
            }
                break;

            case WT_Combo:
                if( a2->type == OT_INTEGER )
                {
                    ((QComboBox*)rec->widget)->setCurrentIndex( a2->integer-1 );
                }
                else if( a2->type == OT_LOGIC )
                {
                    ((QComboBox*)rec->widget)->setCurrentIndex( a2->integer );
                }
                break;

            case WT_Label:
            {
                QString txt;
                valueToQString( a2, txt );
                ((QLabel*) rec->widget)->setText( txt );
            }
                break;

            case WT_LineEdit:
            {
                QString txt;
                valueToQString( a2, txt );
                ((QLineEdit*) rec->widget)->setText( txt );
            }
                break;

            case WT_TextEdit:
            {
                QString txt;
                valueToQString( a2, txt );
                ((QTextEdit*) rec->widget)->setPlainText( txt );
            }
                break;

            case WT_Progress:
                if( a2->type == OT_INTEGER )
                {
                    ((QProgressBar*) rec->widget)->setValue( a2->integer );
                }
                else if( a2->type == OT_NONE )
                {
                    ((QProgressBar*) rec->widget)->reset();
                }
                break;

            default:
                break;
        }
    }
}


OR_NATIVE( appendTextNative )
{
    WIDPool::REC* rec = qEnv.pool.record( a1->integer );
    if( rec )
    {
        const OValue* a2 = a1 + 1;

        switch( rec->type )
        {
            case WT_LineEdit:
            {
                QString cur;
                QString txt;
                valueToQString( a2, txt );
                cur = ((QLineEdit*) rec->widget)->text();
                cur.append( txt );
                ((QLineEdit*) rec->widget)->setText( cur );
            }
                break;

            case WT_TextEdit:
            {
                QString txt;
                QTextCursor cursor;

                valueToQString( a2, txt );

                QTextEdit* edit = (QTextEdit*) rec->widget;

                cursor = edit->textCursor();
                cursor.movePosition( QTextCursor::End );
                cursor.insertText( txt );

                //edit->insertPlainText( txt );
                //edit->append( txt );  // Adds linefeed before text.
            }
                break;

            default:
                break;
        }
    }
}


OR_NATIVE( messageNative )
{
#define REF_MSG_WARN    a1+2
    OString* str1;
    OString* str2;
    const char* cp1;
    const char* cp2;
    OValue* a2 = a1 + 1;

    str1 = orSTRING(a1);
    str2 = orSTRING(a2);
    orTermCStr( str1 );
    orTermCStr( str2 );
    cp1 = orStrChars(str1, a1);
    cp2 = orStrChars(str2, a2);

    if( orRefineSet( REF_MSG_WARN ) )
        QMessageBox::warning( 0, cp1, cp2 );
    else
        QMessageBox::information( 0, cp1, cp2 );
}


OR_NATIVE( questionNative )
{
#define REF_QUESTION_DEF    a1+4
#define REF_QUESTION_BTN    a1+5
    OString* ostr;
    QString str[4];
    int def = 0;
    int i;

    for( i = 0; i < 4; ++i )