goldendict-ng/groups_widgets.cc

999 lines
26 KiB
C++
Raw Normal View History

2012-02-20 21:47:14 +00:00
/* This file is (c) 2008-2012 Konstantin Isakov <ikm@goldendict.org>
* Part of GoldenDict. Licensed under GPLv3 or later, see the LICENSE file */
#include "groups_widgets.hh"
#include "instances.hh"
#include "config.hh"
2009-04-22 21:37:32 +00:00
#include "langcoder.hh"
#include "language.hh"
#include "fsencoding.hh"
//#include "initializing.hh"
#include <QMenu>
#include <QDir>
#include <QIcon>
2012-12-18 12:35:11 +00:00
#include <QMap>
#include <QVector>
#include <QFileInfo>
using std::vector;
/// DictGroupWidget
DictGroupWidget::DictGroupWidget( QWidget * parent,
vector< sptr< Dictionary::Class > > const & dicts,
Config::Group const & group ):
QWidget( parent ),
groupId( group.id )
{
ui.setupUi( this );
ui.dictionaries->populate( Instances::Group( group, dicts ).dictionaries, dicts );
// Populate icons' list
QStringList icons = QDir( ":/flags/" ).entryList( QDir::Files, QDir::NoSort );
ui.groupIcon->addItem( tr( "None" ), "" );
bool usesIconData = !group.iconData.isEmpty();
if ( !usesIconData )
ui.groupIcon->addItem( tr( "From file..." ), "" );
else
ui.groupIcon->addItem( Instances::iconFromData( group.iconData ), group.icon, group.icon );
for( int x = 0; x < icons.size(); ++x )
{
QString n( icons[ x ] );
n.chop( 4 );
n[ 0 ] = n[ 0 ].toUpper();
ui.groupIcon->addItem( QIcon( ":/flags/" + icons[ x ] ), n, icons[ x ] );
if ( !usesIconData && icons[ x ] == group.icon )
ui.groupIcon->setCurrentIndex( x + 2 );
}
if ( usesIconData )
ui.groupIcon->setCurrentIndex( 1 );
ui.shortcut->setHotKey( Config::HotKey( group.shortcut ) );
connect( ui.groupIcon, SIGNAL(activated(int)),this,SLOT(groupIconActivated(int)),
Qt::QueuedConnection );
ui.dictionaries->setContextMenuPolicy( Qt::CustomContextMenu );
connect( ui.dictionaries, SIGNAL( customContextMenuRequested( QPoint ) ),
this, SLOT( showDictInfo( QPoint ) ) );
connect( ui.dictionaries, SIGNAL( doubleClicked( QModelIndex ) ),
this, SLOT( removeCurrentItem( QModelIndex ) ) );
}
void DictGroupWidget::groupIconActivated( int index )
{
if ( index == 1 )
{
QList< QByteArray > supImageFormats = QImageReader::supportedImageFormats();
QString formatList( " (" );
for( int x = 0; x < supImageFormats.size(); ++x )
formatList += "*." + QString::fromAscii( supImageFormats[ x ] ) + " ";
formatList.chop( 1 );
formatList.append( ")" );
QString chosenFile =
QFileDialog::getOpenFileName( this, tr( "Choose a file to use as group icon" ),
QString(),
tr( "Images" ) + formatList + ";;" +
tr( "All files" ) + " (*.*)" );
if ( !chosenFile.isEmpty() )
{
QIcon icon( chosenFile );
if ( icon.isNull() )
QMessageBox::critical( this, tr( "Error" ), tr( "Can't read the specified image file." ) );
else
{
ui.groupIcon->setItemIcon( 1, icon );
QString baseName = QFileInfo( chosenFile ).completeBaseName();
ui.groupIcon->setItemText( 1, baseName );
ui.groupIcon->setItemData( 1, baseName );
}
}
}
}
Config::Group DictGroupWidget::makeGroup() const
{
Instances::Group g( "" );
g.id = groupId;
g.dictionaries = ui.dictionaries->getCurrentDictionaries();
int currentIndex = ui.groupIcon->currentIndex();
if ( currentIndex == 1 ) // File
g.iconData = ui.groupIcon->itemIcon( currentIndex );
g.icon = ui.groupIcon->itemData( currentIndex ).toString();
g.shortcut = ui.shortcut->getHotKey().toKeySequence();
return g.makeConfigGroup();
}
void DictGroupWidget::showDictInfo( QPoint const & pos )
{
QVariant data = ui.dictionaries->getModel()->data( ui.dictionaries->indexAt( pos ), Qt::EditRole );
QString id;
if( data.canConvert< QString >() )
id = data.toString();
if( !id.isEmpty() )
{
vector< sptr< Dictionary::Class > > const & dicts = ui.dictionaries->getCurrentDictionaries();
unsigned n;
for( n = 0; n < dicts.size(); n++ )
if( id.compare( QString::fromUtf8( dicts.at( n )->getId().c_str() ) ) == 0 )
break;
if( n < dicts.size() )
emit showDictionaryInfo( id );
}
}
void DictGroupWidget::removeCurrentItem( QModelIndex const & index )
{
(void)index;
ui.dictionaries->getModel()->removeSelectedRows( ui.dictionaries->selectionModel() );
}
/// DictListModel
void DictListModel::populate(
std::vector< sptr< Dictionary::Class > > const & active,
std::vector< sptr< Dictionary::Class > > const & available )
{
dictionaries = active;
allDicts = &available;
reset();
}
2012-12-18 12:33:53 +00:00
void DictListModel::populate(
std::vector< sptr< Dictionary::Class > > const & active )
{
dictionaries = active;
reset();
}
void DictListModel::setAsSource()
{
isSource = true;
}
std::vector< sptr< Dictionary::Class > > const &
DictListModel::getCurrentDictionaries() const
{
return dictionaries;
}
Qt::ItemFlags DictListModel::flags( QModelIndex const & index ) const
{
Qt::ItemFlags defaultFlags = QAbstractListModel::flags( index );
if (index.isValid())
return Qt::ItemIsDragEnabled | defaultFlags;
else
return Qt::ItemIsDropEnabled | defaultFlags;
}
int DictListModel::rowCount( QModelIndex const & ) const
{
return dictionaries.size();
}
QVariant DictListModel::data( QModelIndex const & index, int role ) const
{
if( index.row() < 0 )
return QVariant();
sptr< Dictionary::Class > const & item = dictionaries[ index.row() ];
if ( !item )
return QVariant();
switch ( role )
2009-04-21 19:03:16 +00:00
{
case Qt::ToolTipRole:
{
QString tt = "<b>" + QString::fromUtf8( item->getName().c_str() ) + "</b>";
QString lfrom( Language::localizedNameForId( item->getLangFrom() ) );
QString lto( Language::localizedNameForId( item->getLangTo() ) );
if ( !lfrom.isEmpty() )
{
if ( lfrom == lto )
tt += "<br>" + lfrom;
else
tt += "<br>" + lfrom + " - " + lto;
}
int entries = item->getArticleCount();
if ( !entries )
entries = item->getWordCount();
if ( entries )
tt += "<br>" + tr( "%1 entries" ).arg( entries );
const std::vector< std::string > & dirs = item->getDictionaryFilenames();
if ( dirs.size() )
{
tt += "<hr>";
tt += FsEncoding::decode( dirs.at( 0 ).c_str() );
}
tt.replace( " ", "&nbsp;" );
return tt;
}
case Qt::DisplayRole :
return QString::fromUtf8( item->getName().c_str() );
2009-04-21 19:03:16 +00:00
case Qt::EditRole :
return QString::fromUtf8( item->getId().c_str() );
2009-04-21 19:03:16 +00:00
case Qt::DecorationRole:
// make all icons of the same size to avoid visual size/alignment problems
return item->getIcon().pixmap( 32 ).scaledToHeight( 21, Qt::SmoothTransformation );
2009-04-21 19:03:16 +00:00
default:;
}
return QVariant();
}
2009-05-03 19:24:25 +00:00
bool DictListModel::insertRows( int row, int count, const QModelIndex & parent )
{
if ( isSource )
return false;
beginInsertRows( parent, row, row + count - 1 );
dictionaries.insert( dictionaries.begin() + row, count,
sptr< Dictionary::Class >() );
endInsertRows();
2012-12-21 20:20:54 +00:00
emit contentChanged();
2009-05-03 19:24:25 +00:00
return true;
}
void DictListModel::addRow(const QModelIndex & parent, sptr< Dictionary::Class > dict)
{
2012-09-26 13:00:35 +00:00
for (unsigned i = 0; i < dictionaries.size(); i++)
{
if (dictionaries[i]->getId() == dict->getId())
return;
}
beginInsertRows( parent, dictionaries.size(), dictionaries.size()+1 );
dictionaries.push_back(dict);
endInsertRows();
2012-12-21 20:20:54 +00:00
emit contentChanged();
}
2009-05-03 19:24:25 +00:00
bool DictListModel::removeRows( int row, int count,
const QModelIndex & parent )
{
if ( isSource )
return false;
beginRemoveRows( parent, row, row + count - 1 );
dictionaries.erase( dictionaries.begin() + row,
dictionaries.begin() + row + count );
endRemoveRows();
2012-12-21 20:20:54 +00:00
emit contentChanged();
2009-05-03 19:24:25 +00:00
return true;
}
bool DictListModel::setData( QModelIndex const & index, const QVariant & value,
int role )
{
if ( isSource || !allDicts || !index.isValid() ||
index.row() >= (int)dictionaries.size() )
return false;
2009-04-21 19:03:16 +00:00
if ( ( role == Qt::DisplayRole ) || ( role == Qt::DecorationRole ) )
{
// Allow changing that, but do nothing
return true;
}
2009-05-03 19:24:25 +00:00
if ( role == Qt::EditRole )
{
Config::Group g;
g.dictionaries.push_back( Config::DictionaryRef( value.toString(), QString() ) );
Instances::Group i( g, *allDicts );
if ( i.dictionaries.size() == 1 )
{
// Found that dictionary
dictionaries[ index.row() ] = i.dictionaries.front();
emit dataChanged( index, index );
return true;
}
}
return false;
}
Qt::DropActions DictListModel::supportedDropActions() const
{
return Qt::MoveAction;
}
void DictListModel::removeSelectedRows( QItemSelectionModel * source )
{
if ( !source )
return;
QModelIndexList rows = source->selectedRows();
if ( !rows.count() )
return;
for ( int i = rows.count()-1; i >= 0; --i )
{
dictionaries.erase( dictionaries.begin() + rows.at( i ).row() );
}
reset();
2012-12-21 20:20:54 +00:00
emit contentChanged();
}
void DictListModel::addSelectedUniqueFromModel( QItemSelectionModel * source )
{
if ( !source )
return;
QModelIndexList rows = source->selectedRows();
if ( !rows.count() )
return;
const DictListModel * baseModel = dynamic_cast< const DictListModel * > ( source->model() );
if ( !baseModel )
return;
QVector< std::string > list;
QVector< std::string > dicts;
for ( unsigned i = 0; i < dictionaries.size(); i++ )
dicts.append( dictionaries.at( i )->getId() );
for ( int i = 0; i < rows.count(); i++ )
{
std::string id = baseModel->dictionaries.at( rows.at( i ).row() )->getId();
if ( !dicts.contains( id ) )
list.append( id );
}
if ( list.empty() )
return;
for ( unsigned i = 0; i < allDicts->size(); i++ )
{
2009-05-02 20:36:12 +00:00
for ( int j = 0; j < list.size(); j++ )
{
if ( allDicts->at( i )->getId() == list.at( j ) )
{
dictionaries.push_back( allDicts->at( i ) );
2009-05-02 20:36:12 +00:00
list.remove( j );
if ( list.isEmpty() )
{
reset();
2012-12-21 20:20:54 +00:00
emit contentChanged();
2009-05-02 20:36:12 +00:00
return;
}
break;
}
}
}
reset();
2012-12-21 20:20:54 +00:00
emit contentChanged();
}
2009-05-03 19:24:25 +00:00
void DictListModel::filterDuplicates()
{
QSet< QString > ids;
bool doReset = false;
for ( unsigned i = 0; i < dictionaries.size(); i++ )
2009-05-03 19:24:25 +00:00
{
QString id = QString::fromStdString( dictionaries.at( i )->getId() );
if ( ids.contains( id ) )
{
dictionaries.erase( dictionaries.begin() + i-- );
2009-05-03 19:24:25 +00:00
doReset = true;
continue;
}
ids.insert( id );
}
if ( doReset )
2012-12-21 20:20:54 +00:00
{
2009-05-03 19:24:25 +00:00
reset();
2012-12-21 20:20:54 +00:00
emit contentChanged();
}
2009-05-03 19:24:25 +00:00
}
/// DictListWidget
DictListWidget::DictListWidget( QWidget * parent ): QListView( parent ),
model( this )
{
setModel( &model );
setSelectionMode( ExtendedSelection );
setDragEnabled( true );
setAcceptDrops( true );
setDropIndicatorShown( true );
}
DictListWidget::~DictListWidget()
{
setModel( 0 );
}
void DictListWidget::populate(
std::vector< sptr< Dictionary::Class > > const & active,
std::vector< sptr< Dictionary::Class > > const & available )
{
model.populate( active, available );
}
2012-12-18 12:33:53 +00:00
void DictListWidget::populate(
std::vector< sptr< Dictionary::Class > > const & active )
{
model.populate( active );
}
void DictListWidget::setAsSource()
{
setDropIndicatorShown( false );
model.setAsSource();
}
std::vector< sptr< Dictionary::Class > > const &
DictListWidget::getCurrentDictionaries() const
{
return model.getCurrentDictionaries();
}
void DictListWidget::dropEvent( QDropEvent * event )
{
DictListWidget * sourceList = dynamic_cast< DictListWidget * > ( event->source() );
2009-05-03 19:24:25 +00:00
QListView::dropEvent( event );
if ( sourceList != this )
{
2009-05-03 19:24:25 +00:00
model.filterDuplicates();
}
}
void DictListWidget::rowsInserted( QModelIndex const & parent, int start, int end )
{
QListView::rowsInserted( parent, start, end );
// When inserting new rows, make the first of them current
selectionModel()->setCurrentIndex( model.index( start, 0, parent ),
QItemSelectionModel::NoUpdate );
}
void DictListWidget::rowsAboutToBeRemoved( QModelIndex const & parent, int start, int end )
{
// When removing rows, if the current row is among the removed ones, select
// an item just before the first row to be removed, if there's one.
QModelIndex current = currentIndex();
if ( current.isValid() && current.row() &&
current.row() >= start && current.row() <= end )
selectionModel()->setCurrentIndex( model.index( current.row() - 1, 0, parent ),
QItemSelectionModel::NoUpdate );
QListView::rowsAboutToBeRemoved( parent, start, end );
}
// DictGroupsWidget
2009-04-21 19:03:16 +00:00
DictGroupsWidget::DictGroupsWidget( QWidget * parent ):
2012-12-18 12:35:11 +00:00
QTabWidget( parent ), nextId( 1 ), allDicts( 0 ), activeDicts( 0 )
{
#if QT_VERSION >= 0x040500
setMovable( true );
#endif
2012-12-21 11:48:41 +00:00
setContextMenuPolicy( Qt::CustomContextMenu );
connect( this, SIGNAL( customContextMenuRequested( QPoint ) ),
this, SLOT( contextMenu( QPoint ) ) );
}
namespace {
QString escapeAmps( QString const & str )
{
QString result( str );
result.replace( "&", "&&" );
return result;
}
QString unescapeAmps( QString const & str )
{
QString result( str );
result.replace( "&&", "&" );
return result;
}
}
void DictGroupsWidget::populate( Config::Groups const & groups,
2012-12-18 12:35:11 +00:00
vector< sptr< Dictionary::Class > > const & allDicts_,
vector< sptr< Dictionary::Class > > const & activeDicts_ )
{
while( count() )
removeCurrentGroup();
allDicts = &allDicts_;
2012-12-18 12:35:11 +00:00
activeDicts = &activeDicts_;
2012-12-10 12:49:45 +00:00
for( int x = 0; x < groups.size(); ++x )
{
DictGroupWidget *gr = new DictGroupWidget( this, *allDicts, groups[ x ] );
addTab( gr, escapeAmps( groups[ x ].name ) );
connect( gr, SIGNAL( showDictionaryInfo( QString const & ) ),
this, SIGNAL( showDictionaryInfo( QString const & ) ) );
2012-12-21 20:20:54 +00:00
connect( gr->getModel(), SIGNAL( contentChanged() ), this, SLOT( tabDataChanged() ) );
setCurrentIndex( x );
QString toolTipStr = "\"" + tabText( x ) + "\"\n" + tr( "Dictionaries: " )
+ QString::number( getCurrentModel()->getCurrentDictionaries().size() );
setTabToolTip( x, toolTipStr );
}
nextId = groups.nextId;
2012-11-28 17:50:31 +00:00
2012-12-21 20:20:54 +00:00
setCurrentIndex( 0 );
2012-11-28 17:50:31 +00:00
setUsesScrollButtons( count() > 3 );
}
/// Creates groups from what is currently set up
Config::Groups DictGroupsWidget::makeGroups() const
{
Config::Groups result;
result.nextId = nextId;
for( int x = 0; x < count(); ++x )
{
result.push_back( dynamic_cast< DictGroupWidget & >( *widget( x ) ).makeGroup() );
result.back().name = unescapeAmps( tabText( x ) );
}
return result;
}
DictListModel * DictGroupsWidget::getCurrentModel() const
{
int current = currentIndex();
if ( current >= 0 )
{
DictGroupWidget * w = ( DictGroupWidget * ) widget( current );
return w->getModel();
}
return 0;
}
QItemSelectionModel * DictGroupsWidget::getCurrentSelectionModel() const
{
int current = currentIndex();
if ( current >= 0 )
{
DictGroupWidget * w = ( DictGroupWidget * ) widget( current );
return w->getSelectionModel();
}
return 0;
}
void DictGroupsWidget::addNewGroup( QString const & name )
{
if ( !allDicts )
return;
int idx = currentIndex() + 1;
Config::Group newGroup;
newGroup.id = nextId++;
DictGroupWidget *gr = new DictGroupWidget( this, *allDicts, newGroup );
insertTab( idx, gr, escapeAmps( name ) );
connect( gr, SIGNAL( showDictionaryInfo( QString const & ) ),
this, SIGNAL( showDictionaryInfo( QString const & ) ) );
setCurrentIndex( idx );
2012-12-21 20:20:54 +00:00
connect( gr->getModel(), SIGNAL( contentChanged() ), this, SLOT( tabDataChanged() ) );
QString toolTipStr = "\"" + tabText( idx ) + "\"\n" + tr( "Dictionaries: " )
+ QString::number( getCurrentModel()->getCurrentDictionaries().size() );
setTabToolTip( idx, toolTipStr );
setUsesScrollButtons( count() > 3 );
}
2012-12-21 11:48:41 +00:00
int DictGroupsWidget::addUniqueGroup( const QString & name )
{
for( int n = 0; n < count(); n++ )
if( tabText( n ) == name )
{
setCurrentIndex( n );
return n;
}
addNewGroup( name );
return currentIndex();
}
void DictGroupsWidget::addAutoGroups()
{
2012-12-18 12:35:11 +00:00
if( !activeDicts )
return;
if ( QMessageBox::information( this, tr( "Confirmation" ),
tr( "Are you sure you want to generate a set of groups "
"based on language pairs?" ), QMessageBox::Yes,
QMessageBox::Cancel ) != QMessageBox::Yes )
return;
2012-12-18 12:35:11 +00:00
QMap< QString, QVector< sptr<Dictionary::Class> > > dictMap;
QMap< QString, QVector< sptr<Dictionary::Class> > > morphoMap;
// Put active dictionaries into lists
2012-12-18 12:35:11 +00:00
for ( unsigned i = 0; i < activeDicts->size(); i++ )
{
2012-12-18 12:35:11 +00:00
sptr<Dictionary::Class> dict = activeDicts->at( i );
int idFrom = dict->getLangFrom();
int idTo = dict->getLangTo();
if( idFrom == 0)
{
// Attempt to find language pair in dictionary name
QPair<quint32,quint32> ids = LangCoder::findIdsForName( QString::fromUtf8( dict->getName().c_str() ) );
idFrom = ids.first;
idTo = ids.second;
}
2012-12-18 12:35:11 +00:00
QString name("Unassigned");
if ( idFrom != 0 && idTo != 0 )
{
QString lfrom = LangCoder::intToCode2( idFrom );
QString lto = LangCoder::intToCode2( idTo );
2012-12-18 12:35:11 +00:00
lfrom[ 0 ] = lfrom[ 0 ].toTitleCase();
lto[ 0 ] = lto[ 0 ].toTitleCase();
name = lfrom + " - " + lto;
}
else if( !dict->getDictionaryFilenames().empty() )
{
// Handle special case - morphology dictionaries
QString fileName = QFileInfo( FsEncoding::decode( dict->getDictionaryFilenames()[ 0 ].c_str() ) ).fileName();
if( fileName.endsWith( ".aff", Qt::CaseInsensitive ) )
{
QString code = fileName.left( 2 ).toLower();
QVector<sptr<Dictionary::Class> > vd = morphoMap[ code ];
vd.append( dict );
morphoMap[ code ] = vd;
continue;
}
}
2012-12-18 12:35:11 +00:00
QVector<sptr<Dictionary::Class> > vd = dictMap[ name ];
vd.append( dict );
dictMap[ name ] = vd;
}
QStringList groupList = dictMap.uniqueKeys();
QStringList morphoList = morphoMap.uniqueKeys();
// Insert morphology dictionaries into corresponding lists
for( QStringList::ConstIterator ln = morphoList.begin(); ln != morphoList.end(); ++ln )
{
for( QStringList::ConstIterator gr = groupList.begin(); gr != groupList.end(); ++gr )
if( ln->compare( gr->left( 2 ), Qt::CaseInsensitive ) == 0 )
{
QVector<sptr<Dictionary::Class> > vdg = dictMap[ *gr ];
vdg += morphoMap[ *ln ];
dictMap[ *gr ] = vdg;
}
}
// Make groups
2012-12-18 12:35:11 +00:00
for( QStringList::ConstIterator gr = groupList.begin(); gr != groupList.end(); ++gr )
{
2012-12-21 11:48:41 +00:00
if( count() )
setCurrentIndex( count() - 1 );
2012-12-21 11:48:41 +00:00
addUniqueGroup( *gr );
2012-12-18 12:35:11 +00:00
// add dictionaries into the current group
QVector< sptr<Dictionary::Class> > vd = dictMap[ *gr ];
DictListModel *model = getCurrentModel();
2012-12-18 12:35:11 +00:00
for( int i = 0; i < vd.count(); i++ )
model->addRow(QModelIndex(), vd.at( i ) );
}
}
QString DictGroupsWidget::getCurrentGroupName() const
{
int current = currentIndex();
if ( current >= 0 )
return unescapeAmps( tabText( current ) );
return QString();
}
void DictGroupsWidget::renameCurrentGroup( QString const & name )
{
int current = currentIndex();
if ( current >= 0 )
setTabText( current, escapeAmps( name ) );
}
void DictGroupsWidget::removeCurrentGroup()
{
int current = currentIndex();
if ( current >= 0 )
{
QWidget * w = widget( current );
removeTab( current );
delete w;
}
setUsesScrollButtons( count() > 3 );
}
void DictGroupsWidget::removeAllGroups()
{
while ( count() )
{
QWidget * w = widget( 0 );
removeTab( 0 );
delete w;
}
}
2012-12-21 11:48:41 +00:00
2012-12-21 16:46:17 +00:00
void DictGroupsWidget::combineGroups( int source, int target )
{
if( source < 0 || source >= count() || target < 0 || target >= count() )
return;
setCurrentIndex( source );
vector< sptr< Dictionary::Class > > const & dicts = getCurrentModel()->getCurrentDictionaries();
setCurrentIndex( target );
DictListModel *model = getCurrentModel();
2012-12-21 20:20:54 +00:00
disconnect( model, SIGNAL( contentChanged() ), this, SLOT( tabDataChanged() ) );
2012-12-21 16:46:17 +00:00
for( unsigned i = 0; i < dicts.size(); i++ )
model->addRow( QModelIndex(), dicts[ i ] );
2012-12-21 20:20:54 +00:00
connect( model, SIGNAL( contentChanged() ), this, SLOT( tabDataChanged() ) );
QString toolTipStr = "\"" + tabText( target ) + "\"\n" + tr( "Dictionaries: " )
+ QString::number( model->getCurrentDictionaries().size() );
setTabToolTip( target, toolTipStr );
2012-12-21 16:46:17 +00:00
}
2012-12-21 11:48:41 +00:00
void DictGroupsWidget::contextMenu( QPoint const & pos )
{
int clickedGroup = tabBar()->tabAt( pos );
if( clickedGroup < 0 )
return;
QString name = tabText( clickedGroup );
if( name.length() != 7 || name.mid( 2, 3 ) != " - " )
return;
QMenu menu( this );
QAction *combineSourceAction = new QAction( QString( tr( "Combine groups by source language to \"%1->\"" ) )
.arg( name.left( 2 ) ), &menu );
combineSourceAction->setEnabled( false );
2012-12-21 16:46:17 +00:00
QString grLeft = name.left( 2 );
QString grRight = name.right( 2 );
2012-12-21 11:48:41 +00:00
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
2012-12-21 16:46:17 +00:00
if( i != clickedGroup && str.length() == 7 && str.mid( 2, 3 ) == " - " && str.startsWith( grLeft ) )
2012-12-21 11:48:41 +00:00
{
combineSourceAction->setEnabled( true );
break;
}
}
menu.addAction( combineSourceAction );
QAction *combineTargetAction = new QAction( QString( tr( "Combine groups by target language to \"->%1\"" ) )
.arg( name.right( 2 ) ), &menu );
combineTargetAction->setEnabled( false );
2012-12-21 16:46:17 +00:00
2012-12-21 11:48:41 +00:00
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
2012-12-21 16:46:17 +00:00
if( i != clickedGroup && str.length() == 7 && str.mid( 2, 3 ) == " - " && str.endsWith( grRight ) )
2012-12-21 11:48:41 +00:00
{
combineTargetAction->setEnabled( true );
break;
}
}
menu.addAction( combineTargetAction );
QAction *combineTwoSidedAction = NULL;
2012-12-21 16:46:17 +00:00
if( grLeft != grRight )
2012-12-21 11:48:41 +00:00
{
2012-12-21 16:46:17 +00:00
combineTwoSidedAction = new QAction( QString( tr( "Make two-side translate group \"%1-%2-%1\"" ) )
.arg( grLeft ).arg( grRight ), &menu );
2012-12-21 11:48:41 +00:00
combineTwoSidedAction->setEnabled( false );
2012-12-21 16:46:17 +00:00
QString str = grRight + " - " + grLeft;
2012-12-21 11:48:41 +00:00
for( int i = 0; i < count(); i++ )
{
if( str == tabText( i ) )
{
combineTwoSidedAction->setEnabled( true );
break;
}
}
menu.addAction( combineTwoSidedAction );
}
2012-12-21 16:46:17 +00:00
QAction *combineFirstAction = new QAction( QString( tr( "Combine groups with \"%1\"" ) )
.arg( grLeft ), &menu );
combineFirstAction->setEnabled( false );
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
if( i != clickedGroup && str.length() == 7 && str.mid( 2, 3 ) == " - " &&
( str.startsWith( grLeft ) || str.endsWith( grLeft ) ) )
{
combineFirstAction->setEnabled( true );
break;
}
}
menu.addAction( combineFirstAction );
QAction *combineSecondAction = NULL;
if( grLeft != grRight )
{
combineSecondAction = new QAction( QString( tr( "Combine groups with \"%1\"" ) )
.arg( grRight ), &menu );
combineSecondAction->setEnabled( false );
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
if( i != clickedGroup && str.length() == 7 && str.mid( 2, 3 ) == " - " &&
( str.startsWith( grRight ) || str.endsWith( grRight ) ) )
{
combineSecondAction->setEnabled( true );
break;
}
}
menu.addAction( combineSecondAction );
}
2012-12-21 11:48:41 +00:00
QAction *result = menu.exec( mapToGlobal( pos ) );
setUpdatesEnabled( false );
int targetGroup;
if( result && result == combineSourceAction )
{
setCurrentIndex( clickedGroup );
2012-12-21 16:46:17 +00:00
targetGroup = addUniqueGroup( grLeft + "->" );
2012-12-21 11:48:41 +00:00
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
2012-12-21 16:46:17 +00:00
if( str.length() == 7 && str.mid( 2, 3 ) == " - " && str.startsWith( grLeft ) )
combineGroups( i, targetGroup );
2012-12-21 11:48:41 +00:00
}
2012-12-21 16:46:17 +00:00
2012-12-21 11:48:41 +00:00
setCurrentIndex( targetGroup );
}
else
if( result && result == combineTargetAction )
{
setCurrentIndex( clickedGroup );
2012-12-21 16:46:17 +00:00
targetGroup = addUniqueGroup( "->" + grRight );
2012-12-21 11:48:41 +00:00
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
2012-12-21 16:46:17 +00:00
if( str.length() == 7 && str.mid( 2, 3 ) == " - " && str.endsWith( grRight ) )
combineGroups( i, targetGroup );
2012-12-21 11:48:41 +00:00
}
2012-12-21 16:46:17 +00:00
2012-12-21 11:48:41 +00:00
setCurrentIndex( targetGroup );
}
else
if( result && result == combineTwoSidedAction )
{
setCurrentIndex( clickedGroup );
2012-12-21 16:46:17 +00:00
targetGroup = addUniqueGroup( name + " - " + grLeft );
QString str = grRight + " - " + grLeft;
2012-12-21 11:48:41 +00:00
for( int i = 0; i < count(); i++ )
if( tabText( i ) == name || tabText( i ) == str )
2012-12-21 16:46:17 +00:00
combineGroups( i, targetGroup );
2012-12-21 11:48:41 +00:00
2012-12-21 16:46:17 +00:00
setCurrentIndex( targetGroup );
}
else
if( result && ( result == combineFirstAction || result == combineSecondAction ) )
{
QString const & grBase = result == combineFirstAction ? grLeft : grRight;
setCurrentIndex( clickedGroup );
targetGroup = addUniqueGroup( grBase );
2012-12-21 11:48:41 +00:00
2012-12-21 16:46:17 +00:00
for( int i = 0; i < count(); i++ )
{
QString str = tabText( i );
if( str.length() == 7 && str.mid( 2, 3 ) == " - " &&
( str.startsWith( grBase ) || str.endsWith( grBase ) ) )
combineGroups( i, targetGroup );
2012-12-21 11:48:41 +00:00
}
2012-12-21 16:46:17 +00:00
2012-12-21 11:48:41 +00:00
setCurrentIndex( targetGroup );
}
setUpdatesEnabled( true );
}
2012-12-21 20:20:54 +00:00
void DictGroupsWidget::tabDataChanged()
{
QString toolTipStr = "\"" + tabText( currentIndex() ) + "\"\n" + tr( "Dictionaries: " )
+ QString::number( getCurrentModel()->getCurrentDictionaries().size() );
setTabToolTip( currentIndex(), toolTipStr );
}