int Appender::resetMask()
{
emptyMask();
addMask(COMLOG_FATAL);
addMask(COMLOG_WARNING);
addMask(COMLOG_NOTICE);
addMask(COMLOG_TRACE);
addMask(COMLOG_DEBUG);
return 0;
}
int
runScanJoin(NDBT_Context* ctx, NDBT_Step* step){
int loops = ctx->getNumLoops();
int joinlevel = ctx->getProperty("JoinLevel", 3);
int until_stopped = ctx->getProperty("UntilStopped", (Uint32)0);
Uint32 stepNo = step->getStepNo();
int i = 0;
HugoQueryBuilder qb(GETNDB(step), ctx->getTab(), HugoQueryBuilder::O_SCAN);
qb.setJoinLevel(joinlevel);
const NdbQueryDef * query = qb.createQuery(GETNDB(step));
HugoQueries hugoTrans(* query);
while ((i<loops || until_stopped) && !ctx->isTestStopped())
{
g_info << i << ": ";
if (hugoTrans.runScanQuery(GETNDB(step)))
{
g_info << endl;
return NDBT_FAILED;
}
addMask(ctx, (1 << stepNo), "Running");
i++;
}
g_info << endl;
return NDBT_OK;
}
// full image mask overlay
void Mask::addMask(const Mask &mask2, const MASKING_OPERATION op) {
assert(valid == true);
// assert(mask.rows == the_mask2.rows);
// assert(mask.cols == the_mask2.cols);
addMask(mask2, cv::Vec2i(0, 0), op);
}
template <typename T> bool
pcl::visualization::ImageViewer::addMask (
const typename pcl::PointCloud<T>::ConstPtr &image,
const pcl::PointCloud<T> &mask,
const std::string &layer_id, double opacity)
{
return (addMask (image, mask, 1.0, 0.0, 0.0, layer_id, opacity));
}
void KviRegisteredUserDataBase::load(const QString & filename)
{
QString szCurrent;
KviConfigurationFile cfg(filename, KviConfigurationFile::Read);
KviConfigurationFileIterator it(*cfg.dict());
while(it.current())
{
cfg.setGroup(it.currentKey());
szCurrent = it.currentKey();
if(KviQString::equalCSN("#Group ", szCurrent, 7))
{
szCurrent.remove(0, 7);
addGroup(szCurrent);
}
else
{
KviRegisteredUser * u = addUser(szCurrent);
if(u)
{
u->setIgnoreEnabled(cfg.readBoolEntry("IgnoreEnabled", false));
u->setIgnoreFlags(cfg.readIntEntry("IgnoreFlags", 0));
KviConfigurationFileGroupIterator sdi(*(it.current()));
while(sdi.current())
{
QString tmp = sdi.currentKey();
if(KviQString::equalCSN("prop_", tmp, 5))
{
tmp.remove(0, 5);
u->setProperty(tmp, *(sdi.current()));
}
else if(KviQString::equalCSN("mask_", tmp, 5))
{
KviIrcMask * mask = new KviIrcMask(*(sdi.current()));
addMask(u, mask);
}
else if(KviQString::equalCI(tmp, "Group"))
{
u->setGroup(*(sdi.current()));
}
++sdi;
}
}
}
++it;
}
if(!m_pGroupDict->find(__tr("Default")))
addGroup(__tr("Default"));
}
ReturnCode AEA::decode(NetworkBuffer& tsdu) {
ReturnCode rc = OK;
rc = SPDU::control(tsdu);
if (sli() == 0)
return OK;
while (tsdu.hasRemaining()) {
tsdu.markit();
byte code = tsdu.get();
switch (code) {
case PI::PI_SERIAL: {
SERIAL pi(tsdu);
aea_serial = pi.getValue();
addMask(SMASK_AEA_SERIAL);
}
break;
case PI::PI_ENCLOSE: {
ENCLOSE pi(tsdu);
setEnclose(pi.getValue());
addMask(SMASK_ENCLOSE);
}
break;
case PI::PI_UDATA: {
UDATA pi(tsdu);
int cc = 0;
const byte* data = pi.getValue(cc);
setData(cc, data);
}
break;
default:
tsdu.reset();
goto EXIT;
}
}
EXIT:
return rc;
}
void KviRegisteredUserDataBase::copyFrom(KviRegisteredUserDataBase * db)
{
m_pUserDict->clear();
m_pWildMaskList->clear();
m_pMaskDict->clear();
m_pGroupDict->clear();
emit(databaseCleared());
KviPointerHashTableIterator<QString, KviRegisteredUser> it(*(db->m_pUserDict));
while(KviRegisteredUser * theCur = it.current())
{
KviRegisteredUser * u = getUser(theCur->name());
// copy masks
KviPointerList<KviIrcMask> * l = theCur->maskList();
for(KviIrcMask * m = l->first(); m; m = l->next())
{
KviIrcMask * m2 = new KviIrcMask(*m);
addMask(u, m2);
}
// copy properties
KviPointerHashTable<QString, QString> * pd = theCur->propertyDict();
if(pd)
{
KviPointerHashTableIterator<QString, QString> pdi(*pd);
while(pdi.current())
{
u->setProperty(pdi.currentKey(), *(pdi.current()));
++pdi;
}
}
u->m_iIgnoreFlags = theCur->m_iIgnoreFlags;
u->m_bIgnoreEnabled = theCur->m_bIgnoreEnabled;
u->setGroup(theCur->group());
++it;
}
KviPointerHashTableIterator<QString, KviRegisteredUserGroup> git(*db->m_pGroupDict);
while(git.current())
{
addGroup(git.currentKey());
++git;
}
}
void CollisionMatrix::addMask(std::string name, std::string category, Categories... others) {
addOneMask(name, category);
addMask(name, others...);
}
WEdition::WEdition(QWidget* widget) : QWidget(widget), select(ActiveSelection::getInstance())
{
QHBoxLayout * mainLayout = new QHBoxLayout();
QVBoxLayout * leftLayout = new QVBoxLayout(); //treeWidget + 3 buttons
QVBoxLayout * rightLayout = new QVBoxLayout(); //tools (pen , eraser, bucket, ..., spacer)
//QStandardItemModel * treeModel = new QStandardItemModel();
treeModel = new TreeModel();
QTreeView * treeView = new QTreeView(this);
treeView->setModel(treeModel);
controller = new Controller(treeView,treeModel);
QHBoxLayout * buttons = new QHBoxLayout(); // 3 buttons
addGroupe = new QPushButton("Add Group",this);
addMaskBt = new QPushButton("Add Mask",this);
fusion = new QPushButton("Merge",this);
buttons->addWidget(addGroupe);
buttons->addWidget(addMaskBt);
buttons->addWidget(fusion);
leftLayout->addWidget(treeView);
leftLayout->addLayout(buttons);
nothingButton = new QPushButton("",this);
penButton = new QPushButton("",this);
penButton->setIcon(QIcon(":/resources/images/pen.png"));
eraserButton = new QPushButton("",this);
eraserButton->setIcon(QIcon(":/resources/images/eraser.png"));
bucketButton = new QPushButton("",this);
bucketButton->setIcon(QIcon(":/resources/images/bucket.png"));
bevelButton = new QPushButton("",this);
bevelButton->setIcon(QIcon(":/resources/images/pen.png")); //TODO found GPL bevel icon
rightLayout->addWidget(nothingButton);
rightLayout->addWidget(penButton);
rightLayout->addWidget(eraserButton);
rightLayout->addWidget(bucketButton);
rightLayout->addWidget(bevelButton);
rightLayout->addWidget(new QSpinBox());
rightLayout->addItem(new QSpacerItem(20, 40, QSizePolicy::Minimum, QSizePolicy::Expanding));
mainLayout->addLayout(leftLayout);
mainLayout->addLayout(rightLayout);
widget->setLayout(mainLayout);
ToolsButtonGroup * toolsButtons = new ToolsButtonGroup();
toolsButtons->addButton(nothingButton);
toolsButtons->addButton(penButton);
toolsButtons->addButton(eraserButton);
toolsButtons->addButton(bucketButton);
toolsButtons->addButton(bevelButton);
nothingButton->setCheckable(true);
penButton->setCheckable(true);
eraserButton->setCheckable(true);
bucketButton->setCheckable(true);
bevelButton->setCheckable(true);
nothingButton->setAutoExclusive(true);
penButton->setAutoExclusive(true);
eraserButton->setAutoExclusive(true);
bucketButton->setAutoExclusive(true);
bevelButton->setAutoExclusive(true);
connect(nothingButton, SIGNAL(toggled(bool)),toolsButtons, SLOT(nothingAction()));
connect(penButton, SIGNAL(toggled(bool)),toolsButtons, SLOT(penAction()));
connect(eraserButton, SIGNAL(toggled(bool)),toolsButtons, SLOT(eraserAction()));
connect(bucketButton, SIGNAL(toggled(bool)),toolsButtons, SLOT(bucketAction()));
connect(bevelButton, SIGNAL(toggled(bool)),toolsButtons, SLOT(bevelAction()));
connect(addGroupe,SIGNAL(clicked()),treeModel,SLOT(addGroupe()));
connect(addMaskBt,SIGNAL(clicked()),controller,SLOT(addMask()));
}
KviMaskEditor::KviMaskEditor(QWidget * par, KviChannelWindow * pChannel, KviWindowToolPageButton * button, std::vector<KviMaskEntry *> maskList, char cMode, const char * name)
: KviWindowToolWidget(par, button)
{
setObjectName(name);
m_pChannel = pChannel;
setFocusPolicy(Qt::ClickFocus);
QGridLayout * g = new QGridLayout(this);
m_cFlag = cMode;
KviIrcConnectionServerInfo * pServerInfo = nullptr;
QString szDescription = "";
if(m_pChannel)
pServerInfo = m_pChannel->serverInfo();
if(pServerInfo)
szDescription = pServerInfo->getChannelModeDescription(cMode);
if(szDescription.isEmpty())
szDescription = __tr2qs("Mode \"%1\" masks").arg(cMode);
switch(cMode)
{
case 'b':
m_eIcon = KviIconManager::Ban;
break;
case 'e':
m_eIcon = KviIconManager::BanExcept;
break;
case 'I':
m_eIcon = KviIconManager::InviteExcept;
break;
case 'a':
m_eIcon = KviIconManager::ChanAdmin;
break;
case 'q':
// this could also be quiet bans..
m_eIcon = KviIconManager::Kick;
break;
default:
m_eIcon = KviIconManager::Ban;
break;
}
KviTalHBox * pTitleLayout = new KviTalHBox(this);
g->addWidget(pTitleLayout, 0, 0);
QLabel * l = new QLabel("", pTitleLayout);
l->setPixmap(*(g_pIconManager->getSmallIcon(m_eIcon)));
l = new QLabel(szDescription, pTitleLayout);
QFrame * pFrame = new QFrame(this);
pFrame->setFrameStyle(QFrame::HLine | QFrame::Sunken);
g->addWidget(pFrame, 1, 0, 1, -1);
KviTalHBox * hb = new KviTalHBox(this);
g->addWidget(hb, 2, 0, 1, 2);
new QLabel(__tr2qs("Filter:"), hb);
m_pSearch = new QLineEdit(hb);
connect(m_pSearch, SIGNAL(textChanged(const QString &)), this, SLOT(searchTextChanged(const QString &)));
l = new QLabel(__tr2qs("Use double-click to edit item"), this);
g->addWidget(l, 2, 1);
g->addWidget(l, 3, 0, 1, 2);
m_pMaskBox = new QTreeWidget(this);
m_pMaskBox->setFocusPolicy(Qt::ClickFocus);
m_pMaskBox->setFocusProxy(this);
m_pMaskBox->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
m_pMaskBox->setSelectionMode(QAbstractItemView::ExtendedSelection);
QStringList columnLabels;
m_pMaskBox->setColumnCount(3);
columnLabels.append(__tr2qs("Mask"));
columnLabels.append(__tr2qs("Set by"));
columnLabels.append(__tr2qs("Set at"));
m_pMaskBox->setHeaderLabels(columnLabels);
m_pMaskBox->setAllColumnsShowFocus(true);
m_pMaskBox->setSortingEnabled(true);
connect(m_pMaskBox, SIGNAL(itemDoubleClicked(QTreeWidgetItem *, int)), this, SLOT(itemDoubleClicked(QTreeWidgetItem *, int)));
g->addWidget(m_pMaskBox, 4, 0, 1, 2);
m_pRemoveMask = new QPushButton(__tr2qs("Re&move"), this);
m_pRemoveMask->setFocusPolicy(Qt::ClickFocus);
m_pRemoveMask->setFocusProxy(this);
g->addWidget(m_pRemoveMask, 5, 1);
connect(m_pRemoveMask, SIGNAL(clicked()), this, SLOT(removeClicked()));
m_pRemoveMask->setIcon(*(g_pIconManager->getSmallIcon(KviIconManager::DeleteItem)));
m_pAddButton = new QPushButton(__tr2qs("&Add"), this);
g->addWidget(m_pAddButton, 5, 0);
connect(m_pAddButton, SIGNAL(clicked()), this, SLOT(addClicked()));
m_pAddButton->setIcon(*(g_pIconManager->getSmallIcon(KviIconManager::NewItem)));
g->setColumnStretch(1, 1);
if(m_pChannel && (!m_pChannel->connection()))
{
m_pRemoveMask->setEnabled(false);
m_pAddButton->setEnabled(false);
return;
}
for(auto & e : maskList)
addMask(e);
updateOpStatus();
if(m_pChannel)
connect(m_pChannel, SIGNAL(opStatusChanged()), this, SLOT(updateOpStatus()));
}
ReturnCode CN_AC::decode(NetworkBuffer& tsdu) {
SPDU::control(tsdu);
if (sli() == 0)
return OK;
ReturnCode rc = OK;
while (tsdu.hasRemaining()) {
/*
switch (code) {
case PI_UDATA:
if (!bool(pmask & PMASK_UDATA) || li() > 512)
spkt.spdu_errno = SC_PROTOCOL;
break;
case PI_XDATA:
if (!bool(pmask & PMASK_XDATA) || li() <= 512)
spkt.spdu_errno = SC_PROTOCOL;
break;
default:
if (bool(code < pi_table.length) && bool(pi_table[code])
&& !bool(pmask & pi_table[code]))
spkt.spdu_errno = SC_PROTOCOL;
break;
}
if (code < pi_table.length && bool(pi_table[code])&& !bool(pi_table[code] & PMASK_PGI)) {
if (li() > 0) {
if (bool(pi_table[code] & PMASK_VARLEN)) {
if (li() > pi_length[code]) {
spkt.spdu_errno = SC_PROTOCOL;
// break;
}
} else
if (li() != pi_length[code]) {
spkt.spdu_errno = SC_PROTOCOL;
// break;
}
}
}
*/
tsdu.markit();
byte code = tsdu.get() & 0xFF;
switch (code) {
case PGI::PGI_CN_ID: {
CN_ID pi(*this, tsdu);
addMask(SMASK_CN_REF);
}
break;
case PGI::PGI_CN_ITEMS: {
CN_ITEMS pgi(*this, tsdu);
addMask(SMASK_CN_REF);
}
break;
case PI::PI_CALLED_SS: {
CALLED_SS pi(tsdu);
int length = 0;
const byte* data = pi.getValue(length);
cn_reference.udata(length, data);
addMask(SMASK_CN_REF);
}
break;
case PI::PI_CALLING_SS: {
// case PI_AR_CALLED:
// case PI_AR_CALLING:
CALLING_SS pi(tsdu);
int length = 0;
const byte* data = pi.getValue(length);
cn_reference.udata(length, data);
addMask(SMASK_CN_REF);
}
break;
case PI::PI_COMMON_REF: {
// case PI_AR_COMMON:
COMMON_REF pi(tsdu);
int length = 0;
const byte* data = pi.getValue(length);
cn_reference.cdata(length, data);
addMask(SMASK_CN_REF);
}
break;
case PI::PI_ADD_INFO: {
// case PI_AR_ADDT:
ADD_INFO pi(tsdu);
int length = 0;
const byte* data = pi.getValue(length);
cn_reference.adata(length, data);
addMask(SMASK_CN_REF);
}
break;
case PI::PI_VERSION: {
VERSION pi(tsdu);
cn_version = pi.getValue();
addMask(SMASK_CN_VRSN);
}
break;
case PI::PI_USER_REQ: {
USER_REQ pi(tsdu);
cn_require = pi.getValue();
addMask(SMASK_CN_REQ);
}
break;
case PI::PI_ISN: {
ISN pi(tsdu);
cn_isn = pi.getValue();
addMask(SMASK_CN_ISN);
}
break;
case PI::PI_TOKEN: {
if (si() != SPDU_AC) {
//FIXME throw exception
}
TOKEN pi(tsdu);
ac_token = pi.getValue();
addMask(SMASK_AC_TOKEN);
}
break;
case PI::PI_TOISN: {/* not supported yet */
}
break;
case PI::PI_SSAP_CALLING: {
SSAP_CALLING pi(tsdu);
int length = 0;
const byte* data = pi.getValue(length);
cn_callinglen = pi.pli();
//FIXME check cn_callinglen == length
memcpy(cn_calling, data, min(cn_callinglen, sizeof(cn_calling)));
addMask(SMASK_CN_CALLING);
}
break;
case PI::PI_SSAP_CALLED: {
SSAP_CALLED pi(tsdu);
int length = 0;
const byte* data = pi.getValue(length);
cn_calledlen = pi.pli();
//FIXME check cn_callinglen == length
memcpy(cn_called, data, min(cn_calledlen, sizeof(cn_calling)));
addMask(SMASK_CN_CALLED);
}
break;
case PI::PI_UDATA: {
UDATA pi(tsdu);
addMask(SMASK_UDATA_PGI);
if (pi.pli() > 0) {
// if (si() == SPDU_AB && !spkt.hasMask(SMASK_SPDU_AB)) {
// throw SSAPException(SC_PROTOCOL);
// } else
if (pi.pli() > MAX_CONNECT_DATA_SIZE) {
throw Exception(AbortCode::SC_PROTOCOL);
}
int length = 0;
const byte* data = pi.getValue(length);
setData(length, data);
}
}
break;
case PI::PI_XDATA: {
XDATA pi(tsdu);
addMask(SMASK_UDATA_PGI);
if (pi.pli() > 0) {
// if (si() == SPDU_AB && !spkt.hasMask(SMASK_SPDU_AB)) {
// throw SSAPException(SC_PROTOCOL);
// } else
if (pi.pli() > MAX_CONNECT_DATA_SIZE) {
throw Exception(AbortCode::SC_PROTOCOL);
}
int length = 0;
const byte* data = pi.getValue(length);
setData(length, data);
}
}
break;
default:
tsdu.reset();
goto EXIT;
}
}
EXIT:
return rc;
}
