Marcion Code

/* Marcion
Copyright (C) 2009 - 2011 Milan Konvicka

   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; version 2 of the License.

   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 */

#include "latcopt.h"
//
CLatCopt::CLatCopt( QWidget * parent, Qt::WFlags f) 
        : QWidget(parent, f),script(CTranslit::Copt),_tr(CTranslit::CopticTrToCopticN),
        popup(),keyb(tr("keyboard")),reg(tr("regexp")),scrmnu(tr("change script")),rmnw(false),_strip(false),_rm_spc(false),wkeyb(0),wreg(0),mk(0),rb(0)
{
	setupUi(this);

        on_cbTranslit_toggled(cbTranslit->isChecked());

        cmbChooseScript->addItem(tr("latin"),CTranslit::Latin);
        cmbChooseScript->addItem(tr("greek"),CTranslit::Greek);
        cmbChooseScript->addItem(tr("coptic"),CTranslit::Copt);
        cmbChooseScript->addItem(tr("hebrew"),CTranslit::Hebrew);
        cmbChooseScript->hide();

        /*completer->setCaseSensitivity(Qt::CaseSensitive);
        completer->setModelSorting(QCompleter::CaseSensitivelySortedModel);

        cmbLatin->setCompleter(completer);
        cmbLatin->setDuplicatesEnabled(true);*/

        cmbLatin->completer()->setCaseSensitivity(Qt::CaseSensitive);
        cmbLatin->completer()->setCompletionMode(QCompleter::PopupCompletion);



        //setLFont(cmbLatin->font());
        //wkeyb.setDefaultWidget(&c_keyb);
        //keyb.addAction(&wkeyb);

        connect(&keyb,SIGNAL(aboutToShow()),this,SLOT(slot_keyb_aboutToShow()));
        connect(&keyb,SIGNAL(aboutToHide()),this,SLOT(slot_keyb_aboutToHide()));
        connect(&reg,SIGNAL(aboutToShow()),this,SLOT(slot_reg_aboutToShow()));
        connect(&reg,SIGNAL(aboutToHide()),this,SLOT(slot_reg_aboutToHide()));

        (scr_l=scrmnu.addAction(tr("latin")))->setCheckable(true);
        (scr_g=scrmnu.addAction(tr("greek")))->setCheckable(true);
        (scr_c=scrmnu.addAction(tr("coptic")))->setCheckable(true);
        (scr_h=scrmnu.addAction(tr("hebrew")))->setCheckable(true);
        scrmnu.setEnabled(false);

        copy=popup.addAction(tr("copy"));
        clear=popup.addAction(tr("clear"));
        popup.addSeparator();
        rm_nw=popup.addAction(tr("strip"));
        upd=popup.addAction(tr("update"));

        popup.addSeparator();
        popup.addMenu(&scrmnu);
        popup.addSeparator();
        popup.addMenu(&keyb)->setIcon(QIcon(":/new/icons/icons/vkeyb.png"));
        popup.addMenu(&reg)->setIcon(QIcon(":/new/icons/icons/regexp.png"));
        popup.addSeparator();
        clr_hist=popup.addAction(tr("clear history"));
}

CLatCopt::~CLatCopt()
{
    if(mk)
        delete mk;
    if(rb)
        delete rb;
}

/*CLatCopt::CLatCopt(CTranslit::Script script,
                   QFont const & font,
                   bool tr_is_visible,
                    CTranslit::Tr tr,
                    bool rmnw,
                    bool strip,
                    bool rm_spc,
		QWidget * parent, Qt::WFlags f)
: QWidget(parent, f),script(script),_tr(tr),
        popup(),rmnw(rmnw),_strip(strip),_rm_spc(rm_spc)
{
	setupUi(this);



        cmbLatin->completer()->setCaseSensitivity(Qt::CaseSensitive);
        //completer->setModelSorting (QCompleter::CaseSensitivelySortedModel);



        cbTranslit->setChecked(true);
        cbTranslit->setVisible(tr_is_visible);
        setFont(font);
}*/
//

QString CLatCopt::text() const
{
        return cmbLatin->currentText();
}

void CLatCopt::setText(QString const & str)
{
        cmbLatin->setEditText(str);
}

void CLatCopt::setScript(CTranslit::Script script,bool cmb)
{
	CLatCopt::script=script;
        lblCoptic->setFont(m_sett()->bFont(script));
        switch(script)
        {
            case CTranslit::Copt :
            _tr=CTranslit::CopticTrToCopticN;
            break;
            case CTranslit::Greek :
            _tr=CTranslit::GreekTrToGreekN;
            break;
            case CTranslit::Hebrew :
            _tr=CTranslit::HebrewTrToHebrewN;
            break;
            case CTranslit::Latin :
            _tr=CTranslit::LatinTrToLatinN;
            break;
        }
        if(cmb)
            cmbChooseScript->setCurrentIndex(cmbChooseScript->findData(script));
        on_cmbLatin_editTextChanged(cmbLatin->currentText());
}

/*void CLatCopt::setFont(QFont const & font)
{
    lblCoptic->setFont(font);
    _font=font;
}*/

/*QFont CLatCopt::font() const
{
    return _font;
}*/

/*void CLatCopt::setLFont(QFont const & font)
{
    orig_lfont=font;
    on_cbTranslit_toggled(cbTranslit->isChecked());
}*/
void CLatCopt::setSwitch(bool visible)
{
    cbTranslit->setVisible(visible);
}
void CLatCopt::setSwitchState(bool state)
{
    cbTranslit->setChecked(state);
    //on_cmbLatin_editTextChanged(cmbLatin->currentText());
}

/*void CLatCopt::on_cmbLatin_returnPressed()
{
    emit query();
}*/
/*QString CLatCopt::specText() const
{
    switch(script)
    {
        case CTranslit::Greek :
        case CTranslit::Latin :
        case CTranslit::Hebrew :
        {
            return text_utf8();
            break;
        }
        case CTranslit::Copt :
        {
            return text();
            break;
        }
    }
    return text_utf8();
}*/

void CLatCopt::copyText() const
{
    QString st(lblCoptic->selectedText());
    if(st.isEmpty())
        QApplication::clipboard()->setText(lblCoptic->text());
    else
        QApplication::clipboard()->setText(st);
}

void CLatCopt::on_lblCoptic_customContextMenuRequested(QPoint )
{
    scr_l->setChecked(script==CTranslit::Latin);
    scr_g->setChecked(script==CTranslit::Greek);
    scr_c->setChecked(script==CTranslit::Copt);
    scr_h->setChecked(script==CTranslit::Hebrew);

    QAction * a;
    if((a=popup.exec(QCursor::pos())))
    {
        if(a==copy)
            copyText();
        else if(a==clear)
            cmbLatin->setEditText(QString());
        else if(a==rm_nw)
        {
            cmbLatin->setEditText(cmbLatin->currentText().remove(QRegExp("[^a-zA-Z]")));

        }
        else if(a==upd)
            updateL(false,false);
        else if(a==upd_st)
            updateL(true,false);
        else if(a==clr_hist)
            cmbLatin->clear();
        else if(a==scr_l)
        {
            setScript(CTranslit::Latin);
            //cmbChooseScript->setCurrentIndex(cmbChooseScript->findData(script));
        }
        else if(a==scr_g)
        {
            setScript(CTranslit::Greek);
            //cmbChooseScript->setCurrentIndex(cmbChooseScript->findData(script));
        }
        else if(a==scr_c)
        {
            setScript(CTranslit::Copt);
            //cmbChooseScript->setCurrentIndex(cmbChooseScript->findData(script));
        }
        else if(a==scr_h)
        {
            setScript(CTranslit::Hebrew);
            //cmbChooseScript->setCurrentIndex(cmbChooseScript->findData(script));
        }
    }
}
bool CLatCopt::rmNonWordChars() const
{
    return rmnw;
}

void CLatCopt::setRmNonWordChars(bool rm)
{
    rmnw=rm;
    on_cmbLatin_editTextChanged(text());
}

CTranslit::Tr CLatCopt::Tr() const
{
    return _tr;
}

void CLatCopt::setTr(CTranslit::Tr tr)
{
    _tr=tr;
    on_cmbLatin_editTextChanged(text());
}

bool CLatCopt::strip() const
{
    return _strip;
}

void CLatCopt::setStrip(bool strip)
{
    _strip=strip;
    on_cmbLatin_editTextChanged(text());
}

bool CLatCopt::rmSpc() const
{
    return _rm_spc;
}

void CLatCopt::setRmSpc(bool rm_spc)
{
    _rm_spc=rm_spc;
    on_cmbLatin_editTextChanged(text());
}

QString CLatCopt::updateL(bool strip,bool rm_spaces)
{
    QString s(CTranslit::tr(cmbLatin->currentText(),Tr(),false,false));
    switch(Tr())
    {
        case CTranslit::CopticTrToCopticN :
        s=CTranslit::tr(s,CTranslit::CopticNToCopticTr,strip,rm_spaces);
        break;
        case CTranslit::GreekTrToGreekN :
        s=CTranslit::tr(s,CTranslit::GreekNToGreekTr,strip,rm_spaces);
        break;
        case CTranslit::HebrewTrToHebrewN :
        s=CTranslit::tr(s,CTranslit::HebrewNToHebrewTr,strip,rm_spaces);
        break;
        case CTranslit::LatinTrToLatinN :
        s=CTranslit::tr(s,CTranslit::LatinNToLatinTr,strip,rm_spaces);
        break;
    }
    setText(s);
    return cmbLatin->currentText();
}

void CLatCopt::on_cmbLatin_editTextChanged(QString str)
{
    if(cbTranslit->isChecked())
        lblCoptic->setText(CTranslit::tr(str,Tr(),strip(),rmSpc()));
    else
        lblCoptic->setText(str);
    emit textChanged(text_utf8());
}

/*void CLatCopt::on_cmbLatin_activated(QString )
{
    emit query();
}*/

void CLatCopt::updateHistory()
{
    QString s(cmbLatin->currentText());
    if(cmbLatin->findText(s,Qt::MatchFixedString|Qt::MatchCaseSensitive)==-1)
        cmbLatin->insertItem(-1,cmbLatin->currentText());
}

void CLatCopt::on_cbTranslit_toggled(bool checked)
{
    if(checked)
        cmbLatin->setFont(m_sett()->bFont(CTranslit::Latin));
    else
        cmbLatin->setFont(lblCoptic->font());
    on_cmbLatin_editTextChanged(cmbLatin->currentText());
}

void CLatCopt::showKeyboard(bool in_menu)
{
    CMarcKeyb::Script sc;

    switch(script)
    {
    case CTranslit::Copt :
        sc=CMarcKeyb::Coptic;
        break;
    case CTranslit::Greek :
        sc=CMarcKeyb::Greek;
        break;
    case CTranslit::Hebrew :
        sc=CMarcKeyb::Hebrew;
        break;
    case CTranslit::Latin :
        sc=CMarcKeyb::Latin;
        break;
    /*default :
            QMessageBox(QMessageBox::Information,"tr","keyboard is available only for coptic and greek script",QMessageBox::Close,this).exec();
            return;
        break;*/
    }

    if(mk)
        delete mk;

    mk=new CMarcKeyb(sc,lblCoptic->font(),lblCoptic->text(),cmbLatin,in_menu);

    if(in_menu)
    {
        wkeyb.setDefaultWidget(mk);
        keyb.addAction(&wkeyb);
    }
    else
    {
        mk->setWindowFlags(Qt::Tool|Qt::Popup);
        mk->setWindowIcon(tbKeyb->icon());
        mk->move(tbKeyb->mapToGlobal(QPoint(0,0)));
        mk->show();
        //mk->setFocus();
        mk->activateWindow();
    }


}

void CLatCopt::slot_keyb_aboutToShow()
{
    showKeyboard(true);
}

void CLatCopt::slot_keyb_aboutToHide()
{
    if(keyb.actions().contains(&wkeyb))
        keyb.removeAction(&wkeyb);
}

void CLatCopt::slot_reg_aboutToShow()
{
    showRegExp(true);
}

void CLatCopt::slot_reg_aboutToHide()
{
    if(reg.actions().contains(&wreg))
        reg.removeAction(&wreg);
}

void CLatCopt::on_tbKeyb_clicked()
{
    showKeyboard(false);
}

void CLatCopt::showRegExp(bool in_menu)
{
    if(rb)
        delete rb;

    rb= new MRegExpBuilder(cmbLatin->currentText(),cmbLatin,in_menu);

    if(in_menu)
    {
        wreg.setDefaultWidget(rb);
        reg.addAction(&wreg);
    }
    else
    {
        rb->setWindowFlags(Qt::Tool|Qt::Popup);
        rb->setWindowIcon(tbReg->icon());
        rb->move(tbReg->mapToGlobal(QPoint(0,0)));
        rb->show();
        //rb->setFocus();
        rb->activateWindow();
    }
}

void CLatCopt::on_tbReg_clicked()
{
    showRegExp(false);
}

void CLatCopt::setVAsPreferred()
{
    lblCoptic->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Preferred);
}

void CLatCopt::keyPressEvent ( QKeyEvent * event )
{
    switch(event->key())
    {
    case Qt::Key_Return :
    case Qt::Key_Enter :
        emit query();
        event->accept();
        break;
    default:
        event->ignore();
        break;
    }
}

void CLatCopt::allowChangeScript()
{
    cmbChooseScript->show();
    scrmnu.setEnabled(true);
}

void CLatCopt::on_cmbChooseScript_currentIndexChanged(int index)
{
    setScript((CTranslit::Script)cmbChooseScript->itemData(index).toInt(),false);
}

void CLatCopt::refreshFonts()
{
    lblCoptic->setFont(m_sett()->bFont(script));
    on_cbTranslit_toggled(cbTranslit->isChecked());
}