/***************************************************************************
* Reset the default settings.
***************************************************************************/
void setup::resetDefaults(){
removeGroup("away");
//removeGroup("away list");
removeGroup("chat");
removeGroup("general");
removeGroup("network");
removeGroup("sound");
read();
}
/*! \brief show the context menu
*/
void XletSwitchBoard::contextMenuEvent(QContextMenuEvent *event)
{
// check if there is a group under the cursor
Group *group = getGroup(m_layout->getPosInGrid(event->pos()));
QMenu contextMenu(this);
QAction *action;
if (group) {
action = contextMenu.addAction(tr("Remove group %1").arg(group->name()),
this, SLOT(removeGroup()));
action->setProperty("group", QVariant::fromValue((void *)group));
action = contextMenu.addAction(tr("Change color of group %1").arg(group->name()),
this, SLOT(changeGroupColor()));
action->setProperty("group", QVariant::fromValue((void *)group));
action = contextMenu.addAction(tr("Rename group %1").arg(group->name()),
this, SLOT(changeGroupName()));
action->setProperty("group", QVariant::fromValue((void *)group));
}
action = contextMenu.addAction(tr("Add Phone number entry"),
this, SLOT(addPhoneNumberEntry()));
action->setProperty("pos", m_layout->getPosInGrid(event->pos()));
action = new QAction(tr("Draw the grid"), this);
action->setCheckable(true);
action->setChecked(m_drawGrid);
connect(action, SIGNAL(toggled(bool)),
this, SLOT(drawTheGrid(bool)));
contextMenu.addAction(action);
contextMenu.exec(event->globalPos());
}
void Widget::clearContactsList()
{
QList<Friend*> friends = FriendList::getAllFriends();
for (Friend* f : friends)
removeFriend(f);
for (Group* g : GroupList::groupList)
removeGroup(g);
}
Scene::~Scene()
{
// Delete all scene items and groups cleanly
m_isDestructing = true;
while(!m_groups.isEmpty())
removeGroup(m_groups.last().group);
m_profile->pruneLayerGroups(); // As it's disabled in `removeGroup()`
}
void Widget::clearContactsList()
{
QList<Friend*> friends = FriendList::getAllFriends();
for (Friend* f : friends)
removeFriend(f, true);
QList<Group*> groups = GroupList::getAllGroups();
for (Group* g : groups)
removeGroup(g, true);
}
void KNCollectionView::removeAccount(KNNntpAccount *a)
{
if(!a->listItem())
return;
KNCollectionViewItem *child = 0, *aitem = a->listItem();
while((child = static_cast<KNCollectionViewItem *>(aitem->firstChild())))
removeGroup(static_cast<KNGroup *>(child->coll));
delete aitem;
a->setListItem(0);
}
void GroupWidget::contextMenuEvent(QContextMenuEvent* event)
{
if (!active) {
setBackgroundRole(QPalette::Highlight);
}
installEventFilter(this); // Disable leave event.
QMenu menu(this);
QAction* openChatWindow = nullptr;
QAction* removeChatWindow = nullptr;
// TODO: Move to model
ContentDialog* contentDialog = ContentDialogManager::getInstance()->getGroupDialog(groupId);
const bool notAlone = contentDialog != nullptr && contentDialog->chatroomWidgetCount() > 1;
if (contentDialog == nullptr || notAlone) {
openChatWindow = menu.addAction(tr("Open chat in new window"));
}
if (contentDialog && contentDialog->hasContactWidget(groupId)) {
removeChatWindow = menu.addAction(tr("Remove chat from this window"));
}
menu.addSeparator();
QAction* setTitle = menu.addAction(tr("Set title..."));
QAction* quitGroup = menu.addAction(tr("Quit group", "Menu to quit a groupchat"));
QAction* selectedItem = menu.exec(event->globalPos());
removeEventFilter(this);
if (!active) {
setBackgroundRole(QPalette::Window);
}
if (!selectedItem) {
return;
}
if (selectedItem == quitGroup) {
emit removeGroup(groupId);
} else if (selectedItem == openChatWindow) {
emit newWindowOpened(this);
} else if (selectedItem == removeChatWindow) {
// TODO: move to model
ContentDialog* contentDialog = ContentDialogManager::getInstance()->getGroupDialog(groupId);
contentDialog->removeGroup(groupId);
} else if (selectedItem == setTitle) {
editName();
}
}
void Ut_DBusInterfaceNotificationSink::init()
{
qDBusConnectionConnectService.clear();
qDBusConnectionConnectPath.clear();
qDBusConnectionConnectInterface.clear();
qDBusConnectionConnectName.clear();
qDBusConnectionConnectReceiver.clear();
qDBusConnectionConnectSlot.clear();
manager = new NotificationManager;
sink = new DBusInterfaceNotificationSink(manager);
connect(this, SIGNAL(addNotification(Notification)), sink, SLOT(addNotification(Notification)));
connect(this, SIGNAL(addGroup(uint,NotificationParameters)), sink, SLOT(addGroup(uint,NotificationParameters)));
connect(this, SIGNAL(removeNotification(uint)), sink, SLOT(removeNotification(uint)));
connect(this, SIGNAL(removeGroup(uint)), sink, SLOT(removeGroup(uint)));
gNotificationManagerStub->stubReset();
gNotificationGroupStub->stubReset();
gNotificationGroupStub->stubSetReturnValue<const NotificationParameters&>("parameters", fakeParams);
}
void DrMain::removeOptionGlobally(const QString &name)
{
DrGroup *grp(0);
DrBase *opt = findOption(name, &grp);
if(opt && grp)
{
grp->removeOption(name);
if(grp->isEmpty())
removeGroup(grp);
}
}
bool SSIManager::removeGroup( const QString &group )
{
Oscar::SSI gr = findGroup( group );
if ( gr.isValid() && removeGroup( gr ) )
{
return true;
}
else
kdDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "Group " << group << " not found." << endl;
return false;
}
int AgentLuaInterface::l_removeGroup(lua_State *L)
{
int id = lua_tonumber(L, -2);
int group = lua_tonumber(L, -1);
bool removed = false;
auto autonPtr = Interfacer::getAgentPtr(id);
if (autonPtr != NULL)
{
removed = autonPtr->removeGroup(group);
}
lua_pushboolean(L, removed);
return 1;
}
void Ut_DBusInterfaceNotificationSink::testNothingCalledWhenNothingRegistered()
{
Notification n;
NotificationParameters np;
emit addNotification(n);
emit addGroup(0, np);
emit removeNotification(0);
emit removeGroup(0);
QCOMPARE(gAddNotificationProxies.count(), 0);
QCOMPARE(gAddGroupProxies.count(), 0);
QCOMPARE(gRemoveNotificationProxies.count(), 0);
QCOMPARE(gRemoveGroupProxies.count(), 0);
}
// called on Group removing
void MergeTask::remove(ARegistrar &group) {
CGroup *g = dynamic_cast<CGroup*>(&group);
assert(g != NULL);
bool isReelectionNeeded = (masterGroup && masterGroup->key == g->key);
mergable.erase(g->key);
removeGroup(*g);
if (isReelectionNeeded) {
masterGroup = NULL;
reelectMasterGroup();
}
}
GroupsTab::GroupsTab(GroupManager* manager, QWidget* parent): QWidget(parent)
{
this->manager = manager;
//scrollArea = new QScrollArea(this);
//scrollArea->setLayout(scrolledLayout);
//scrolledWidget = new QWidget(scrollArea);
//scrolledWidget = scrollArea;
//scrolledLayout = new QVBoxLayout(scrolledWidget);
layout = new QVBoxLayout(this);
foreach(QString name, manager->groupNames())
createGroup(name);
//scrollArea->setWidget(scrolledWidget);
//layout->addWidget(scrollArea);
QObject::connect(manager, SIGNAL(groupCreated(QString)), this, SLOT(createGroup(QString)));
QObject::connect(manager, SIGNAL(groupRemoved(QString)), this, SLOT(removeGroup(QString)));
}
void ContentDialog::onChatroomWidgetClicked(GenericChatroomWidget *widget, bool group)
{
if (group)
{
ContentDialog* contentDialog = new ContentDialog(settingsWidget);
contentDialog->show();
if (widget->getFriend() != nullptr)
{
removeFriend(widget->getFriend()->getFriendID());
Widget::getInstance()->addFriendDialog(widget->getFriend(), contentDialog);
}
else
{
removeGroup(widget->getGroup()->getGroupId());
Widget::getInstance()->addGroupDialog(widget->getGroup(), contentDialog);
}
contentDialog->raise();
contentDialog->activateWindow();
return;
}
// If we clicked on the currently active widget, don't reload and relayout everything
if (activeChatroomWidget == widget)
return;
contentLayout->clear();
if (activeChatroomWidget != nullptr)
activeChatroomWidget->setAsInactiveChatroom();
activeChatroomWidget = widget;
widget->setChatForm(contentLayout);
widget->setAsActiveChatroom();
widget->resetEventFlags();
widget->updateStatusLight();
updateTitle(widget);
if (widget->getFriend())
widget->getFriend()->getFriendWidget()->updateStatusLight();
else
widget->getGroup()->getGroupWidget()->updateStatusLight();
}
MainMenuItem::MainMenuItem()
: m_defaultItemSize( 55 )
{
m_timer.setSingleShot( true );
connect( &m_timer, SIGNAL( timeout() ), SLOT( hideItems() ) );
setItemSize( m_defaultItemSize );
setBrush( QColor( 230,229,229 ) );
QPen pen;
pen.setBrush( Qt::NoBrush );
setPen( pen );
QGraphicsTextItem *textItem = new QGraphicsTextItem( i18n("Menu"), this );
int textWidth = textItem->boundingRect().width();
int textHeight = textItem->boundingRect().height();
textItem->setPos( - textWidth / 2, - textHeight / 2 );
m_fanMenu = new FanMenu( this );
m_fanMenu->setZValue( 50 );
m_fanMenu->hide();
m_fanMenu->setStartAngle( 170 );
m_fanMenu->setEndAngle( 280 );
m_fanMenu->setRadius( 220 );
m_fanMenu->setSpacing( 5 );
FanMenuItem *menuItem = m_fanMenu->addItem( i18n("Clone\ngroup") );
connect( menuItem, SIGNAL( clicked() ), SIGNAL( cloneGroup() ) );
menuItem = m_fanMenu->addItem( i18n("Remove\ngroup") );
connect( menuItem, SIGNAL( clicked() ), SIGNAL( removeGroup() ) );
menuItem = m_fanMenu->addItem( i18n("Add\ngroup") );
connect( menuItem, SIGNAL( clicked() ), SIGNAL( addGroup() ) );
menuItem = m_fanMenu->addItem( i18n("Add\nperson") );
connect( menuItem, SIGNAL( clicked() ), SIGNAL( addPerson() ) );
m_fanMenu->setupItems( 90 );
setAcceptHoverEvents( true );
}
bool CountTable::setNamesOfGroups(vector<string> mygroups) {
try {
//remove groups from table not in new groups we are setting
for (int i = 0; i < groups.size(); i++) {
if (m->inUsersGroups(groups[i], mygroups)) {}
else { removeGroup(groups[i]); }
}
//add any new groups in new groups list to table
for (int i = 0; i < mygroups.size(); i++) {
if (m->inUsersGroups(mygroups[i], groups)) {}
else { addGroup(mygroups[i]); }
}
//false if error
return (!m->control_pressed);
}
catch(exception& e) {
m->errorOut(e, "CountTable", "setNamesOfGroups");
exit(1);
}
}
void Ut_DBusInterfaceNotificationSink::testProxyCalledWhenServiceRegistered()
{
Notification n;
NotificationParameters np;
sink->registerSink("service1", "path");
QCOMPARE(gNewSinkProxies.count(), 1);
emit addNotification(n);
emit addGroup(0, np);
emit removeNotification(0);
emit removeGroup(0);
QCOMPARE(gAddNotificationProxies.count(), 1);
QCOMPARE(gAddNotificationProxies.at(0), gNewSinkProxies.at(0));
QCOMPARE(gAddGroupProxies.count(), 1);
QCOMPARE(gAddGroupProxies.at(0), gNewSinkProxies.at(0));
QCOMPARE(gRemoveNotificationProxies.count(), 1);
QCOMPARE(gRemoveNotificationProxies.at(0), gNewSinkProxies.at(0));
QCOMPARE(gRemoveGroupProxies.count(), 1);
QCOMPARE(gRemoveGroupProxies.at(0), gNewSinkProxies.at(0));
}
void CtrlrLuaMethodEditor::itemClicked (const MouseEvent &e, ValueTree &item)
{
if (e.mods.isPopupMenu())
{
if ( item.hasType (Ids::luaManagerMethods) || item.hasType (Ids::luaMethodGroup) )
{
PopupMenu m;
m.addSectionHeader ("Group operations");
m.addItem (1, "Add method");
m.addItem (2, "Add files");
m.addItem (3, "Add group");
m.addSeparator();
if (item.hasType (Ids::luaMethodGroup))
{
m.addItem (4, "Remove group");
m.addItem (5, "Rename group");
}
m.addSeparator();
m.addItem (6, "Sort by name");
m.addItem (7, "Sort by size");
const int ret = m.show();
if (ret == 1)
{
addNewMethod (item);
}
else if (ret == 2)
{
addMethodFromFile (item);
}
else if (ret == 3)
{
addNewGroup (item);
}
else if (ret == 4)
{
removeGroup (item);
}
else if (ret == 5)
{
renameGroup (item);
}
else if (ret == 6)
{
ChildSorter sorter(true);
getMethodManager().getManagerTree().sort (sorter, nullptr, false);
triggerAsyncUpdate();
}
else if (ret == 7)
{
ChildSorter sorter(false);
getMethodManager().getManagerTree().sort (sorter, nullptr, false);
triggerAsyncUpdate();
}
}
else if (item.hasType(Ids::luaMethod))
{
PopupMenu m;
m.addSectionHeader ("Method " + item.getProperty(Ids::luaMethodName).toString());
if ((int)item.getProperty(Ids::luaMethodSource) == CtrlrLuaMethod::codeInFile)
{
if (!File(item.getProperty(Ids::luaMethodSourcePath)).existsAsFile())
{
m.addItem (12, "Locate file on disk");
}
}
m.addSeparator();
m.addItem (2,"Remove method");
const int ret = m.show();
if (ret == 11)
{
/* convert a in-memory method to a file based one */
}
else if (ret == 12)
{
/* locate a missing file on disk */
}
else if (ret == 10)
{
/* convert a method from a file to a in-memory property */
}
else if (ret == 2)
{
/* remove a method */
if (SURE("Delete the selected method?", this))
{
{
methodEditArea->closeTabWithMethod (item);
getMethodManager().removeMethod (item.getProperty(Ids::uuid).toString());
}
triggerAsyncUpdate();
}
}
}
}
}
QgsStyleV2ManagerDialog::QgsStyleV2ManagerDialog( QgsStyleV2* style, QWidget* parent )
: QDialog( parent ), mStyle( style ), mModified( false )
{
setupUi( this );
#ifdef Q_OS_MAC
setWindowModality( Qt::WindowModal );
#endif
QSettings settings;
restoreGeometry( settings.value( "/Windows/StyleV2Manager/geometry" ).toByteArray() );
mSplitter->setSizes( QList<int>() << 170 << 540 );
mSplitter->restoreState( settings.value( "/Windows/StyleV2Manager/splitter" ).toByteArray() );
tabItemType->setDocumentMode( true );
searchBox->setPlaceholderText( tr( "Type here to filter symbols..." ) );
connect( this, SIGNAL( finished( int ) ), this, SLOT( onFinished() ) );
connect( listItems, SIGNAL( doubleClicked( const QModelIndex & ) ), this, SLOT( editItem() ) );
connect( btnAddItem, SIGNAL( clicked() ), this, SLOT( addItem() ) );
connect( btnEditItem, SIGNAL( clicked() ), this, SLOT( editItem() ) );
connect( btnRemoveItem, SIGNAL( clicked() ), this, SLOT( removeItem() ) );
QMenu *shareMenu = new QMenu( tr( "Share Menu" ), this );
QAction *exportAsPNGAction = shareMenu->addAction( tr( "Export as PNG" ) );
QAction *exportAsSVGAction = shareMenu->addAction( tr( "Export as SVG" ) );
QAction *exportAction = shareMenu->addAction( tr( "Export" ) );
QAction *importAction = shareMenu->addAction( tr( "Import" ) );
exportAsPNGAction->setIcon( QIcon( QgsApplication::iconPath( "mActionSharingExport.svg" ) ) );
exportAsSVGAction->setIcon( QIcon( QgsApplication::iconPath( "mActionSharingExport.svg" ) ) );
exportAction->setIcon( QIcon( QgsApplication::iconPath( "mActionSharingExport.svg" ) ) );
importAction->setIcon( QIcon( QgsApplication::iconPath( "mActionSharingImport.svg" ) ) );
connect( exportAsPNGAction, SIGNAL( triggered() ), this, SLOT( exportItemsPNG() ) );
connect( exportAsSVGAction, SIGNAL( triggered() ), this, SLOT( exportItemsSVG() ) );
connect( exportAction, SIGNAL( triggered() ), this, SLOT( exportItems() ) );
connect( importAction, SIGNAL( triggered() ), this, SLOT( importItems() ) );
btnShare->setMenu( shareMenu );
// Set editing mode off by default
mGrouppingMode = false;
QStandardItemModel* model = new QStandardItemModel( listItems );
listItems->setModel( model );
listItems->setSelectionMode( QAbstractItemView::ExtendedSelection );
connect( model, SIGNAL( itemChanged( QStandardItem* ) ), this, SLOT( itemChanged( QStandardItem* ) ) );
connect( listItems->selectionModel(), SIGNAL( currentChanged( const QModelIndex&, const QModelIndex& ) ),
this, SLOT( symbolSelected( const QModelIndex& ) ) );
populateTypes();
QStandardItemModel* groupModel = new QStandardItemModel( groupTree );
groupTree->setModel( groupModel );
groupTree->setHeaderHidden( true );
populateGroups();
connect( groupTree->selectionModel(), SIGNAL( currentChanged( const QModelIndex&, const QModelIndex& ) ),
this, SLOT( groupChanged( const QModelIndex& ) ) );
connect( groupModel, SIGNAL( itemChanged( QStandardItem* ) ),
this, SLOT( groupRenamed( QStandardItem* ) ) );
QMenu *groupMenu = new QMenu( tr( "Group Actions" ), this );
QAction *groupSymbols = groupMenu->addAction( tr( "Group Symbols" ) );
QAction *editSmartgroup = groupMenu->addAction( tr( "Edit Smart Group" ) );
btnManageGroups->setMenu( groupMenu );
connect( groupSymbols, SIGNAL( triggered() ), this, SLOT( groupSymbolsAction() ) );
connect( editSmartgroup, SIGNAL( triggered() ), this, SLOT( editSmartgroupAction() ) );
connect( btnAddGroup, SIGNAL( clicked() ), this, SLOT( addGroup() ) );
connect( btnRemoveGroup, SIGNAL( clicked() ), this, SLOT( removeGroup() ) );
on_tabItemType_currentChanged( 0 );
connect( searchBox, SIGNAL( textChanged( QString ) ), this, SLOT( filterSymbols( QString ) ) );
tagsLineEdit->installEventFilter( this );
// Context menu for groupTree
groupTree->setContextMenuPolicy( Qt::CustomContextMenu );
connect( groupTree, SIGNAL( customContextMenuRequested( const QPoint& ) ),
this, SLOT( grouptreeContextMenu( const QPoint& ) ) );
// Context menu for listItems
listItems->setContextMenuPolicy( Qt::CustomContextMenu );
connect( listItems, SIGNAL( customContextMenuRequested( const QPoint& ) ),
this, SLOT( listitemsContextMenu( const QPoint& ) ) );
}
int CountTable::createTable(string namefile, string groupfile, bool createGroup) {
try {
if (namefile == "") { m->mothurOut("[ERROR]: namefile cannot be blank when creating a count table.\n"); m->control_pressed = true; }
GroupMap* groupMap;
int numGroups = 0;
groups.clear();
totalGroups.clear();
indexGroupMap.clear();
indexNameMap.clear();
counts.clear();
map<int, string> originalGroupIndexes;
if (groupfile != "") {
hasGroups = true;
groupMap = new GroupMap(groupfile); groupMap->readMap();
numGroups = groupMap->getNumGroups();
groups = groupMap->getNamesOfGroups();
totalGroups.resize(numGroups, 0);
}else if(createGroup) {
hasGroups = true;
numGroups = 1;
groups.push_back("Group1");
totalGroups.resize(numGroups, 0);
}
//sort groups to keep consistent with how we store the groups in groupmap
sort(groups.begin(), groups.end());
for (int i = 0; i < groups.size(); i++) { indexGroupMap[groups[i]] = i; }
m->setAllGroups(groups);
bool error = false;
string name;
uniques = 0;
total = 0;
//open input file
ifstream in;
m->openInputFile(namefile, in);
int total = 0;
while (!in.eof()) {
if (m->control_pressed) { break; }
string firstCol, secondCol;
in >> firstCol; m->gobble(in); in >> secondCol; m->gobble(in);
m->checkName(firstCol);
m->checkName(secondCol);
vector<string> names;
m->splitAtChar(secondCol, names, ',');
map<string, int> groupCounts;
int thisTotal = 0;
if (groupfile != "") {
//set to 0
for (int i = 0; i < groups.size(); i++) { groupCounts[groups[i]] = 0; }
//get counts for each of the users groups
for (int i = 0; i < names.size(); i++) {
string group = groupMap->getGroup(names[i]);
if (group == "not found") { m->mothurOut("[ERROR]: " + names[i] + " is not in your groupfile, please correct."); m->mothurOutEndLine(); error=true; }
else {
map<string, int>::iterator it = groupCounts.find(group);
//if not found, then this sequence is not from a group we care about
if (it != groupCounts.end()) {
it->second++;
thisTotal++;
}
}
}
}else if (createGroup) {
groupCounts["Group1"]=0;
for (int i = 0; i < names.size(); i++) {
string group = "Group1";
groupCounts["Group1"]++; thisTotal++;
}
}else { thisTotal = names.size(); }
//if group info, then read it
vector<int> thisGroupsCount; thisGroupsCount.resize(numGroups, 0);
for (int i = 0; i < numGroups; i++) {
thisGroupsCount[i] = groupCounts[groups[i]];
totalGroups[i] += thisGroupsCount[i];
}
map<string, int>::iterator it = indexNameMap.find(firstCol);
if (it == indexNameMap.end()) {
if (hasGroups) { counts.push_back(thisGroupsCount); }
indexNameMap[firstCol] = uniques;
totals.push_back(thisTotal);
total += thisTotal;
uniques++;
}else {
error = true;
m->mothurOut("[ERROR]: Your count table contains more than 1 sequence named " + firstCol + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();
}
}
in.close();
if (error) { m->control_pressed = true; }
else { //check for zero groups
if (hasGroups) {
for (int i = 0; i < totalGroups.size(); i++) {
if (totalGroups[i] == 0) { m->mothurOut("\nRemoving group: " + groups[i] + " because all sequences have been removed.\n"); removeGroup(groups[i]); i--; }
}
}
}
if (groupfile != "") { delete groupMap; }
return 0;
}
catch(exception& e) {
m->errorOut(e, "CountTable", "createTable");
exit(1);
}
}
void SettingsSerializer::readIni()
{
QSettings s(path, QSettings::IniFormat);
// Read all keys of all groups, reading arrays as raw keys
QList<QString> gstack;
do {
// Add all keys
if (!s.group().isEmpty())
beginGroup(s.group());
for (QString k : s.childKeys())
{
setValue(k, s.value(k));
}
// Add all groups
gstack.push_back(QString());
for (QString g : s.childGroups())
gstack.push_back(g);
// Visit the next group, if any
while (!gstack.isEmpty())
{
QString g = gstack.takeLast();
if (g.isEmpty())
{
if (gstack.isEmpty())
break;
else
s.endGroup();
}
else
{
s.beginGroup(g);
break;
}
}
} while (!gstack.isEmpty());
// We can convert keys that look like arrays into real arrays
// If a group's only key is called size, we'll consider it to be an array,
// and its elements are all groups matching the pattern "[<group>/]<arrayName>/<arrayIndex>"
// Find groups that only have 1 key
std::unique_ptr<int[]> groupSizes{new int[groups.size()]};
memset(groupSizes.get(), 0, static_cast<size_t>(groups.size()) * sizeof(int));
for (const Value& v : values)
{
if (v.group < 0 || v.group > groups.size())
continue;
groupSizes[static_cast<size_t>(v.group)]++;
}
// Find arrays, remove their size key from the values, and add them to `arrays`
QVector<int> groupsToKill;
for (int i=values.size()-1; i>=0; i--)
{
const Value& v = values[i];
if (v.group < 0 || v.group > groups.size())
continue;
if (groupSizes[static_cast<size_t>(v.group)] != 1)
continue;
if (v.key != "size")
continue;
if (!v.value.canConvert(QVariant::Int))
continue;
Array a;
a.size = v.value.toInt();
int slashIndex = groups[static_cast<int>(v.group)].lastIndexOf('/');
if (slashIndex == -1)
{
a.group = -1;
a.name = groups[static_cast<int>(v.group)];
a.size = v.value.toInt();
}
else
{
a.group = -1;
for (int i=0; i<groups.size(); i++)
if (groups[i] == groups[static_cast<int>(v.group)].left(slashIndex))
a.group = i;
a.name = groups[static_cast<int>(v.group)].mid(slashIndex+1);
}
groupSizes[static_cast<size_t>(v.group)]--;
groupsToKill.append(static_cast<int>(v.group));
arrays.append(a);
values.removeAt(i);
}
// Associate each array's values with the array
for (int ai=0; ai<arrays.size(); ai++)
{
Array& a = arrays[ai];
QString arrayPrefix;
if (a.group != -1)
arrayPrefix += groups[static_cast<int>(a.group)]+'/';
arrayPrefix += a.name+'/';
// Find groups which represent each array index
for (int g=0; g<groups.size(); g++)
{
if (!groups[g].startsWith(arrayPrefix))
continue;
bool ok;
int groupArrayIndex = groups[g].mid(arrayPrefix.size()).toInt(&ok);
if (!ok)
continue;
groupsToKill.append(g);
if (groupArrayIndex > a.size)
a.size = groupArrayIndex;
// Associate the values for this array index
for (int vi = values.size() - 1; vi >= 0; vi--)
{
Value& v = values[vi];
if (v.group != g)
continue;
groupSizes[static_cast<size_t>(g)]--;
v.group = a.group;
v.array = ai;
v.arrayIndex = groupArrayIndex;
a.values.append(vi);
}
}
}
// Clean up spurious array element groups
std::sort(std::begin(groupsToKill), std::end(groupsToKill),
std::greater_equal<int>());
for (int g : groupsToKill)
{
if (groupSizes[static_cast<size_t>(g)])
continue;
removeGroup(g);
}
group = array = -1;
}
int CountTable::readTable(string file, bool readGroups, bool mothurRunning) {
try {
filename = file;
ifstream in;
m->openInputFile(filename, in);
string headers = m->getline(in); m->gobble(in);
vector<string> columnHeaders = m->splitWhiteSpace(headers);
int numGroups = 0;
groups.clear();
totalGroups.clear();
indexGroupMap.clear();
indexNameMap.clear();
counts.clear();
map<int, string> originalGroupIndexes;
if ((columnHeaders.size() > 2) && readGroups) { hasGroups = true; numGroups = columnHeaders.size() - 2; }
for (int i = 2; i < columnHeaders.size(); i++) { groups.push_back(columnHeaders[i]); originalGroupIndexes[i-2] = columnHeaders[i]; totalGroups.push_back(0); }
//sort groups to keep consistent with how we store the groups in groupmap
sort(groups.begin(), groups.end());
for (int i = 0; i < groups.size(); i++) { indexGroupMap[groups[i]] = i; }
m->setAllGroups(groups);
bool error = false;
string name;
int thisTotal;
uniques = 0;
total = 0;
while (!in.eof()) {
if (m->control_pressed) { break; }
in >> name; m->gobble(in); in >> thisTotal; m->gobble(in);
if (m->debug) { m->mothurOut("[DEBUG]: " + name + '\t' + toString(thisTotal) + "\n"); }
if ((thisTotal == 0) && !mothurRunning) { error=true; m->mothurOut("[ERROR]: Your count table contains a sequence named " + name + " with a total=0. Please correct."); m->mothurOutEndLine();
}
//if group info, then read it
vector<int> groupCounts; groupCounts.resize(numGroups, 0);
if (columnHeaders.size() > 2) { //file contains groups
if (readGroups) { //user wants to save them
for (int i = 0; i < numGroups; i++) { int thisIndex = indexGroupMap[originalGroupIndexes[i]]; in >> groupCounts[thisIndex]; m->gobble(in); totalGroups[thisIndex] += groupCounts[thisIndex]; }
}else { //read and discard
m->getline(in); m->gobble(in);
}
}
map<string, int>::iterator it = indexNameMap.find(name);
if (it == indexNameMap.end()) {
if (hasGroups) { counts.push_back(groupCounts); }
indexNameMap[name] = uniques;
totals.push_back(thisTotal);
total += thisTotal;
uniques++;
}else {
error = true;
m->mothurOut("[ERROR]: Your count table contains more than 1 sequence named " + name + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();
}
}
in.close();
if (error) { m->control_pressed = true; }
else { //check for zero groups
if (hasGroups) {
for (int i = 0; i < totalGroups.size(); i++) {
if (totalGroups[i] == 0) { m->mothurOut("\nRemoving group: " + groups[i] + " because all sequences have been removed.\n"); removeGroup(groups[i]); i--; }
}
}
}
return 0;
}
void Widget::removeGroup(int groupId)
{
removeGroup(GroupList::findGroup(groupId));
}
FiGroupWidget::FiGroupWidget(FClass* parent)
: FWidget(parent, FUNC)
{
mEditing = false;
QPixmap icon(10, 10);
mGroupView = new MyTableWidget(this);
//mGroupView->setDragEnabled(false);
//mGroupView->setAcceptDrops(false);
mGroupView->setEditTriggers(QAbstractItemView::EditKeyPressed);
connect(mGroupView, SIGNAL(currentRowChanged(int))
, this, SLOT(groupRowChanged(int)));
connect(mGroupView, SIGNAL(cellDoubleClicked(int, int))
, this, SLOT(groupOpen(int, int)));
connect(mGroupView, SIGNAL(cellChanged(int, int))
, this, SLOT(groupEdited(int, int)));
connect(mGroupView, SIGNAL(dragToNirvana())
, this, SLOT(removeGroup()));
mMotherName = new QLabel(this);
//mMotherName->setWordWrap(true);
mMotherName->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored);
QToolButton* btn = new QToolButton(this);
btn->setAutoRaise(true);
btn->setArrowType(Qt::UpArrow);
btn->setToolTip("Up to Mother Group");
connect(btn, SIGNAL(clicked(bool)), this, SLOT(groupUp()));
QToolButton* newGroupBtn = new QToolButton(this);
newGroupBtn->setAutoRaise(true);
icon.fill(Qt::green);
newGroupBtn->setIcon(icon);
newGroupBtn->setToolTip("Add New Group");
connect(newGroupBtn, SIGNAL(clicked(bool)), this, SLOT(newGroup()));
//mMotherName->setAlignment(Qt::AlignVertical_Mask);
//mMotherName->setOrientation(Qt::Vertical);
QGridLayout* gbox = new QGridLayout;
gbox->setMargin(0);
gbox->addWidget(mMotherName, 0, 0);
gbox->addWidget(newGroupBtn, 0, 1);
gbox->addWidget(btn, 0, 2);
gbox->addWidget(mGroupView, 1, 0, 1, 3);
QWidget* gboxw = new QWidget;
gboxw->setLayout(gbox);
mMemberView = new MyTableWidget;
connect( mMemberView, SIGNAL(currentRowChanged(int))
, this, SLOT(memberRowChanged(int)));
connect( mMemberView, SIGNAL(dragInFromTableView(QTableView*))
, this, SLOT(userDragInData(QTableView*)));
connect(mMemberView, SIGNAL(dragToNirvana())
, this, SLOT(removeFromGroup()));
mSplitter = new QSplitter(Qt::Vertical);
//mSplitter->addWidget(mGroupView);
mSplitter->addWidget(gboxw);
mSplitter->addWidget(mMemberView);
mSplitter->setStretchFactor(0, 1);
mSplitter->setStretchFactor(1, 3);
QGridLayout* layout = new QGridLayout;
layout->setMargin(0);
layout->addWidget(mSplitter, 0, 0);
//layout->addWidget(, 0, 1);
setLayout(layout);
}
void FieldMap::removeGroup( int field )
{ QF_STACK_PUSH(FieldMap::removeGroup)
removeGroup( groupCount(field), field );
QF_STACK_POP
}
void ExecutiveUser::globalRemoveGroup(const LinqDB& db, const Group& g) {
std::for_each(db.begin(), db.end(), RemoveGroup(const_cast<Group*> (&g)));
removeGroup(g);
}
int CountTable::createTable(set<string>& n, map<string, string>& g, set<string>& gs) {
try {
hasGroups = false;
int numGroups = 0;
groups.clear();
totalGroups.clear();
indexGroupMap.clear();
indexNameMap.clear();
counts.clear();
for (set<string>::iterator it = gs.begin(); it != gs.end(); it++) { groups.push_back(*it); hasGroups = true; }
numGroups = groups.size();
totalGroups.resize(numGroups, 0);
//sort groups to keep consistent with how we store the groups in groupmap
sort(groups.begin(), groups.end());
for (int i = 0; i < groups.size(); i++) { indexGroupMap[groups[i]] = i; }
m->setAllGroups(groups);
uniques = 0;
total = 0;
bool error = false;
//n contains treenames
for (set<string>::iterator it = n.begin(); it != n.end(); it++) {
if (m->control_pressed) { break; }
string seqName = *it;
vector<int> groupCounts; groupCounts.resize(numGroups, 0);
map<string, string>::iterator itGroup = g.find(seqName);
if (itGroup != g.end()) {
groupCounts[indexGroupMap[itGroup->second]] = 1;
totalGroups[indexGroupMap[itGroup->second]]++;
}else {
//look for it in names of groups to see if the user accidently used the wrong file
if (m->inUsersGroups(seqName, groups)) {
m->mothurOut("[WARNING]: Your group or design file contains a group named " + seqName + ". Perhaps you are used a group file instead of a design file? A common cause of this is using a tree file that relates your groups (created by the tree.shared command) with a group file that assigns sequences to a group."); m->mothurOutEndLine();
}
m->mothurOut("[ERROR]: Your group file does not contain " + seqName + ". Please correct."); m->mothurOutEndLine();
}
map<string, int>::iterator it2 = indexNameMap.find(seqName);
if (it2 == indexNameMap.end()) {
if (hasGroups) { counts.push_back(groupCounts); }
indexNameMap[seqName] = uniques;
totals.push_back(1);
total++;
uniques++;
}else {
error = true;
m->mothurOut("[ERROR]: Your count table contains more than 1 sequence named " + seqName + ", sequence names must be unique. Please correct."); m->mothurOutEndLine();
}
}
if (error) { m->control_pressed = true; }
else { //check for zero groups
if (hasGroups) {
for (int i = 0; i < totalGroups.size(); i++) {
if (totalGroups[i] == 0) { m->mothurOut("\nRemoving group: " + groups[i] + " because all sequences have been removed.\n"); removeGroup(groups[i]); i--; }
}
}
}
return 0;
}
catch(exception& e) {
m->errorOut(e, "CountTable", "createTable");
exit(1);
}
}
