~ubuntu-branches/debian/jessie/ugene/jessie : revision 4

src/plugins/expert_discovery/src/ExpertDiscoveryTreeWidgets.cpp

#include "ExpertDiscoveryTreeWidgets.h"

#include<QMessageBox>

#include <QtGui/QMouseEvent>

#include <strstream>

using std::strstream;

using std::ws;

namespace U2 {

////////////////////////////////////////////////////////////

EDPIPropertyType::EDPIPropertyType(){

}

EDPIPropertyType::~EDPIPropertyType(){

}

//////////////////////////////////////////////////////////////////

EDPIProperty::EDPIProperty(const EDPIProperty& rProperty)

: m_pType(NULL)

, m_pCallback(NULL)

{

*this = rProperty;

}

EDPIProperty::EDPIProperty(QString strName /* ="" */)

: m_pType(NULL)

, m_pCallback(NULL)

{

setType(EDPIPropertyTypeStaticString::getInstance());

setName( strName );

}

EDPIProperty::~EDPIProperty() {

delete m_pCallback;

}

const EDPIProperty& EDPIProperty::operator =(const EDPIProperty& rProperty) {

setType( rProperty.m_pType);

setName( rProperty.getName() );

if (rProperty.m_pCallback)

m_pCallback = rProperty.m_pCallback->clone();

else

m_pCallback = NULL;

return *this;

}

QString EDPIProperty::getName() const {

return m_strName;

}

void EDPIProperty::setName(QString strName) {

m_strName = strName;

}

QString EDPIProperty::getValue() const {

if (m_pCallback)

return m_pCallback->call();

else

{

QString strUndefined = "Undefined";

return strUndefined;

}

void EDPIProperty::setCallback(ICallback* pCallback)

{

m_pCallback = pCallback;

}

const EDPIPropertyType* EDPIProperty::getType() const

{

return m_pType;

}

void EDPIProperty::setType(EDPIPropertyType* pType)

{

m_pType = pType;

}

////////////////////////////////////////////////////////////////////////////////////////////////////////

EDPIPropertyGroup::EDPIPropertyGroup(QString strName /*=""*/)

{

setName(strName);

}

EDPIPropertyGroup::EDPIPropertyGroup(const EDPIPropertyGroup& rGroup)

{

*this = rGroup;

}

EDPIPropertyGroup::~EDPIPropertyGroup()

{

100

}

101

102

const EDPIPropertyGroup& EDPIPropertyGroup::operator=(const EDPIPropertyGroup& rGroup)

103

{

104

m_strName = rGroup.getName();

105

m_arProperties = rGroup.m_arProperties;

106

return *this;

107

}

108

109

QString EDPIPropertyGroup::getName() const

110

{

111

return m_strName;

112

}

113

114

void EDPIPropertyGroup::setName(QString strName)

115

{

116

m_strName = strName;

117

}

118

119

int EDPIPropertyGroup::getPropertiesNumber() const {

120

return m_arProperties.size();

121

}

122

123

EDPIProperty& EDPIPropertyGroup::getProperty(int nProp) {

124

assert( nProp>=0 && nProp<m_arProperties.size());

125

return m_arProperties[nProp];

126

}

127

128

const EDPIProperty& EDPIPropertyGroup::getProperty(int nProp) const {

129

assert( nProp>=0 && nProp<m_arProperties.size());

130

return m_arProperties[nProp];

131

}

132

133

void EDPIPropertyGroup::addProperty(EDPIProperty &rProperty) {

134

m_arProperties.append(rProperty);

135

}

136

137

//////////////////////////////////////////////////////////////////////////////

138

139

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeStaticString)

140

141

EDPIPropertyTypeStaticString::EDPIPropertyTypeStaticString()

142

{

143

}

144

145

EDPIPropertyTypeStaticString::~EDPIPropertyTypeStaticString()

146

{

147

}

148

149

bool EDPIPropertyTypeStaticString::isNumber() const

150

{

151

return false;

152

}

153

154

bool EDPIPropertyTypeStaticString::hasEdit() const

155

{

156

return false;

157

}

158

159

bool EDPIPropertyTypeStaticString::hasPredefinedValues() const

160

{

161

return false;

162

}

163

164

int EDPIPropertyTypeStaticString::getValueNumber() const

165

{

166

return 0;

167

}

168

169

QString EDPIPropertyTypeStaticString::getValue(int i) const

170

{

171

assert(0);

172

return "";

173

}

174

175

bool EDPIPropertyTypeStaticString::isValidValue(QString strValue) const

176

{

177

return TRUE;

178

}

179

180

//////////////////////////////////////////////////////////////////////////////

181

182

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeString)

183

184

EDPIPropertyTypeString::EDPIPropertyTypeString()

185

{

186

}

187

188

EDPIPropertyTypeString::~EDPIPropertyTypeString()

189

{

190

}

191

192

bool EDPIPropertyTypeString::hasEdit() const

193

{

194

return true;

195

}

196

197

//////////////////////////////////////////////////////////////////////////

198

199

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeUnsignedInt)

200

201

EDPIPropertyTypeUnsignedInt::EDPIPropertyTypeUnsignedInt()

202

{

203

}

204

205

EDPIPropertyTypeUnsignedInt::~EDPIPropertyTypeUnsignedInt()

206

{

207

}

208

209

bool EDPIPropertyTypeUnsignedInt::isNumber() const

210

{

211

return true;

212

}

213

214

bool EDPIPropertyTypeUnsignedInt::hasEdit() const

215

{

216

return true;

217

}

218

219

bool EDPIPropertyTypeUnsignedInt::hasPredefinedValues() const

220

{

221

return false;

222

}

223

224

int EDPIPropertyTypeUnsignedInt::getValueNumber() const

225

{

226

return 0;

227

}

228

229

QString EDPIPropertyTypeUnsignedInt::getValue(int i) const

230

{

231

assert(0);

232

return "";

233

}

234

235

bool EDPIPropertyTypeUnsignedInt::isValidValue(QString strValue) const

236

{

237

strstream str;

238

str << strValue.toStdString();

239

int value = 0;

240

str >> value;

241

str >> ws;

242

if (value>=0 && str.eof())

243

return true;

244

return false;

245

}

246

247

//////////////////////////////////////////////////////////////////////////////

248

249

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeUnsignedIntWithUnl)

250

251

EDPIPropertyTypeUnsignedIntWithUnl::EDPIPropertyTypeUnsignedIntWithUnl()

252

: EDPIPropertyTypeListEdit()

253

{

254

addValue("Unlimited");

255

}

256

257

EDPIPropertyTypeUnsignedIntWithUnl::~EDPIPropertyTypeUnsignedIntWithUnl()

258

{

259

}

260

261

bool EDPIPropertyTypeUnsignedIntWithUnl::isNumber() const

262

{

263

return true;

264

}

265

266

bool EDPIPropertyTypeUnsignedIntWithUnl::isValidValue(QString strValue) const

267

{

268

int nId = getValueId(strValue);

269

if (nId >= 0)

270

return true;

271

272

int nValue = 0;

273

strstream str;

274

str << strValue.toStdString();

275

str >> nValue;

276

str >> ws;

277

if (str.eof() && nValue>=0)

278

return true;

279

return false;

280

}

281

282

//////////////////////////////////////////////////////////////////////////////

283

284

EDPIPropertyTypeList::EDPIPropertyTypeList()

285

{

286

}

287

288

EDPIPropertyTypeList::~EDPIPropertyTypeList()

289

{

290

}

291

292

bool EDPIPropertyTypeList::isNumber() const

293

{

294

return false;

295

}

296

297

bool EDPIPropertyTypeList::hasEdit() const

298

{

299

return false;

300

}

301

302

bool EDPIPropertyTypeList::hasPredefinedValues() const

303

{

304

return true;

305

}

306

307

int EDPIPropertyTypeList::getValueNumber() const

308

{

309

return m_arValues.size();

310

}

311

312

QString EDPIPropertyTypeList::getValue(int i) const

313

{

314

return m_arValues[i];

315

}

316

317

bool EDPIPropertyTypeList::isValidValue(QString strValue) const

318

{

319

return getValueId(strValue) >= 0;

320

}

321

322

323

void EDPIPropertyTypeList::addValue(QString strValue)

324

{

325

m_arValues.append(strValue);

326

}

327

328

int EDPIPropertyTypeList::getValueId(QString strValue) const

329

{

330

int nValNum = getValueNumber();

331

for (int i=0; i<nValNum; i++) {

332

if (m_arValues[i].compare(strValue,Qt::CaseInsensitive) == 0)

333

return i;

334

}

335

return -1;

336

}

337

338

339

//////////////////////////////////////////////////////////////////////////////

340

341

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeListCSNodeTypes);

342

343

EDPIPropertyTypeListCSNodeTypes::EDPIPropertyTypeListCSNodeTypes()

344

{

345

addValue("Distance");

346

addValue("Repetition");

347

addValue("Interval");

348

addValue("Word");

349

addValue("Markup item");

350

}

351

352

//////////////////////////////////////////////////////////////////////////////

353

354

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeBool);

355

356

EDPIPropertyTypeBool::EDPIPropertyTypeBool()

357

{

358

addValue("False");

359

addValue("True");

360

}

361

362

//////////////////////////////////////////////////////////////////////////////

363

364

IMPLEMENT_GETINSTANCE(EDPIPropertyTypeDistType);

365

366

EDPIPropertyTypeDistType::EDPIPropertyTypeDistType()

367

{

368

addValue("finish to start");

369

addValue("start to start");

370

addValue("middle to start");

371

}

372

373

////////////////////////////////////////////////////////////

374

EDProjectItem::EDProjectItem():QTreeWidgetItem(), mInf(NULL){

375

setName("");

376

sortField = ED_FIELD_UNDEFINED;

377

sortOrd = ED_ORDER_DECREASING;

378

}

379

EDProjectItem::~EDProjectItem(){

380

clearGroups();

381

}

382

int EDProjectItem::getGroupNumber() const{

383

return m_arGroups.size();

384

}

385

EDPIPropertyGroup& EDProjectItem::getGroup(int nGroup){

386

assert(nGroup >=0 && nGroup<getGroupNumber());

387

return m_arGroups[nGroup];

388

}

389

const EDPIPropertyGroup& EDProjectItem::getGroup(int nGroup) const{

390

assert(nGroup >=0 && nGroup<getGroupNumber());

391

return m_arGroups[nGroup];

392

}

393

int EDProjectItem::addGroup(const EDPIPropertyGroup& rGroup){

394

m_arGroups.append(rGroup);

395

return m_arGroups.size();

396

}

397

void EDProjectItem::clearGroups(){

398

m_arGroups.clear();

399

}

400

EItemType EDProjectItem::getType() const{

401

return PIT_NONE;

402

}

403

404

const EDProjectItem* EDProjectItem::findItemConnectedTo(void *pData) const{

405

if (isConnectedTo(pData))

406

return this;

407

408

for (int i = 0; i < childCount(); i++){

409

EDProjectItem* item = dynamic_cast<EDProjectItem*>(child(i));

410

if(item){

411

const EDProjectItem* cItem = item->findItemConnectedTo(pData);

412

if(cItem){

413

return cItem;

414

}

415

416

}

417

}

418

return NULL;

419

420

}

421

422

bool EDProjectItem::operator<(const QTreeWidgetItem &other) const{

423

const EDProjectItem* pItem1 = dynamic_cast<const EDProjectItem*>(this);

424

const EDProjectItem* pItem2 = dynamic_cast<const EDProjectItem*>(&other);

425

426

if(!pItem2 || !pItem1){

427

return QTreeWidgetItem::operator<(other);

428

}

429

EItemType type1 = pItem1->getType();

430

EItemType type2 = pItem2->getType();

431

432

if(sortOrd == ED_ORDER_DECREASING){

433

434

if (type1 == PIT_CS && type2 == PIT_CS){

435

const EDProjectItem* pItem3;

436

pItem3 = pItem1;

437

pItem1 = pItem2;

438

pItem2 = pItem3;

439

440

}

441

}

442

if (type1 == PIT_CS && type2 == PIT_CS){

443

const Signal* pSnl1 = ((EDPICS*) pItem1)->getSignal();

444

const Signal* pSnl2 = ((EDPICS*) pItem2)->getSignal();

445

switch (sortField) {

446

case ED_FIELD_UNDEFINED: return QTreeWidgetItem::operator<(other);

447

case ED_FIELD_PROBABILITY: return (pSnl1->getPriorProbability()<pSnl2->getPriorProbability());

448

case ED_FIELD_COVERAGE: return (pSnl1->getPriorPosCoverage()<pSnl2->getPriorPosCoverage());

449

case ED_FIELD_FISHER: return (pSnl1->getPriorFisher()<pSnl2->getPriorFisher());

450

case ED_FIELD_NAME:

451

default: return pItem1->getName() < pItem2->getName();

452

453

}

454

}else if ( (type1 == PIT_CS_FOLDER || type1 == PIT_CS || type1 == PIT_MRK_ITEM) &&

455

(type2 == PIT_CS_FOLDER || type2 == PIT_CS || type2 == PIT_MRK_ITEM))

456

{

457

if ((int)type1 < (int)type2)

458

return false;

459

else

460

if ((int)type1 > (int)type2)

461

return true;

462

else

463

return pItem1->getName() < pItem2->getName();

464

}else{

465

const EDProjectItem *pParent = dynamic_cast<const EDProjectItem*>(dynamic_cast<const QTreeWidgetItem*>(pItem1)->parent());

466

if (pParent != NULL && pParent->getType() == PIT_CSN_DISTANCE) {

467

return (pParent->child(0) == pItem1) ? true : false;

468

}

469

else{

470

return QTreeWidgetItem::operator<(other);

471

}

472

}

473

}

474

/////////////////////////////////////////////////////////////////////////////////////

475

476

EDPISequenceRoot::EDPISequenceRoot(ExpertDiscoveryData& edD)

477

:edData(edD)

478

{

479

update(true);

480

}

481

482

EDPISequenceRoot::~EDPISequenceRoot()

483

{

484

}

485

486

EItemType EDPISequenceRoot::getType() const {

487

return PIT_SEQUENCEROOT;

488

}

489

490

void EDPISequenceRoot::update(bool bUpdateChildren)

491

{

492

QString strName = "Sequences";

493

setName(strName);

494

clearGroups();

495

496

if (bUpdateChildren) {

497

takeChildren();

498

499

addChild(new EDPIPosSequenceBase(edData.getPosSeqBase(), edData));

500

addChild(new EDPINegSequenceBase(edData.getNegSeqBase(), edData));

501

//if (pDoc->GetControlSeqBase().getSize() != 0)

502

addChild(new EDPIControlSequenceBase(edData.getConSeqBase(), edData));

503

}

504

}

505

506

507

508

bool EDPISequenceRoot::isConnectedTo(void *pData) const

509

{

510

return false;

511

}

512

513

/////////////////////////////////////////////////////////////////////////////////////

514

515

516

EDPISequenceBase::EDPISequenceBase(QString strName, const SequenceBase& rSeqBase, ExpertDiscoveryData& edD)

517

: m_rSeqBase (rSeqBase)

518

,edData(edD)

519

{

520

//assert(strName != NULL);

521

setName(strName);

522

update(true);

523

}

524

525

void EDPISequenceBase::update(bool bUpdateChildren)

526

{

527

clearGroups();

528

takeChildren();

529

530

int nSize = m_rSeqBase.getSize();

531

532

QString strSize = "Size";

533

QString strGenInfo = "General information";

534

535

536

EDPIProperty PropSize(strSize);

537

PropSize.setCallback(new Callback<const DDisc::SequenceBase, int>(&m_rSeqBase, &DDisc::SequenceBase::getSize));

538

539

EDPIPropertyGroup GenInfo(strGenInfo);

540

GenInfo.addProperty(PropSize);

541

addGroup(GenInfo);

542

543

if (bUpdateChildren) {

544

for (int id=0; id<nSize; id++)

545

addChild(new EDPISequence(m_rSeqBase, id, edData));

546

}

547

}

548

549

EDPISequenceBase::~EDPISequenceBase()

550

{

551

}

552

553

const SequenceBase& EDPISequenceBase::getSequenceBase() const

554

{

555

return m_rSeqBase;

556

}

557

558

bool EDPISequenceBase::isConnectedTo(void *pData) const

559

{

560

return ((void*) &m_rSeqBase) == pData;

561

}

562

563

/////////////////////////////////////////////////////////////////////////////////////

564

565

EDPIPosSequenceBase::EDPIPosSequenceBase(const SequenceBase& rBase, ExpertDiscoveryData& edD)

566

: EDPISequenceBase("", rBase, edD)

567

{

568

QString strPosName = "Positive";

569

setName(strPosName);

570

}

571

572

EDPIPosSequenceBase::~EDPIPosSequenceBase()

573

{

574

}

575

576

void EDPIPosSequenceBase::update(bool bUpdateChildren)

577

{

578

EDPISequenceBase::update(bUpdateChildren);

579

}

580

581

EItemType EDPIPosSequenceBase::getType() const

582

{

583

return PIT_POSSEQUENCEBASE;

584

}

585

586

587

/////////////////////////////////////////////////////////////////////////////////////

588

589

EDPINegSequenceBase::EDPINegSequenceBase(const SequenceBase& rBase, ExpertDiscoveryData& edD)

590

: EDPISequenceBase("", rBase, edD)

591

{

592

QString strNegName = "Negative";

593

setName(strNegName);

594

}

595

596

EDPINegSequenceBase::~EDPINegSequenceBase()

597

{

598

}

599

600

void EDPINegSequenceBase::update(bool bUpdateChildren)

601

{

602

EDPISequenceBase::update(bUpdateChildren);

603

}

604

605

EItemType EDPINegSequenceBase::getType() const

606

{

607

return PIT_NEGSEQUENCEBASE;

608

}

609

610

/////////////////////////////////////////////////////////////////////////////////////

611

612

EDPIControlSequenceBase::EDPIControlSequenceBase(const SequenceBase& rBase, ExpertDiscoveryData& edD)

613

: EDPISequenceBase("", rBase, edD)

614

{

615

QString strControlName = "Control";

616

setName(strControlName);

617

update(true);

618

}

619

620

EDPIControlSequenceBase::~EDPIControlSequenceBase()

621

{

622

}

623

624

void EDPIControlSequenceBase::update(bool bUpdateChildren)

625

{

626

clearGroups();

627

628

int nSize = m_rSeqBase.getSize();

629

630

QString strSize = "Size";

631

QString strGenInfo = "General information";

632

633

EDPIProperty PropSize(strSize);

634

PropSize.setCallback(new Callback<const DDisc::SequenceBase, int>(&m_rSeqBase, &DDisc::SequenceBase::getSize));

635

EDPIPropertyGroup GenInfo(strGenInfo);

636

GenInfo.addProperty(PropSize);

637

addGroup(GenInfo);

638

639

if (bUpdateChildren) {

640

takeChildren();

641

for (int id=0; id<nSize; id++)

642

addChild(new EDPIControlSequence(m_rSeqBase, id, edData));

643

}

644

}

645

646

EItemType EDPIControlSequenceBase::getType() const

647

{

648

return PIT_CONTROLSEQUENCEBASE;

649

}

650

651

////////////////////////////////////////////////////////

652

653

EDPISequence::EDPISequence(const SequenceBase& rSeqBase, int id, ExpertDiscoveryData& edD)

654

: m_id (id)

655

, m_rSeq (rSeqBase.getSequence(id))

656

, m_firstCall(true)

657

,edData(edD)

658

{

659

assert(id>=0 && id<rSeqBase.getSize());

660

update(true);

661

}

662

663

void EDPISequence::update(bool bUpdateChildren)

664

{

665

setName( m_rSeq.getName().c_str() );

666

clearGroups();

667

takeChildren();

668

669

QString strName = "Name";

670

QString strLength = "Length";

671

QString strGenInfo = "Sequence info";

672

QString strRecognizationInfo = "Sequence recogn. data";

673

QString strScore = "Score";

674

QString strBound = "Bound";

675

QString strRecResult = "Result";

676

677

678

EDPIProperty PropName(strName);

679

EDPIProperty PropSize(strLength);

680

PropName.setCallback(new Callback<const DDisc::Sequence, const std::string>(&m_rSeq, &DDisc::Sequence::getName));

681

PropSize.setCallback(new Callback<const DDisc::Sequence, size_t>(&m_rSeq, &DDisc::Sequence::getSize));

682

EDPIPropertyGroup GenInfo(strGenInfo);

683

GenInfo.addProperty(PropName);

684

GenInfo.addProperty(PropSize);

685

addGroup(GenInfo);

686

687

double dScore = m_rSeq.getScore();

688

double dBound = edData.getRecognizationBound();

689

690

EDPIProperty PropScore(strScore);

691

PropScore.setCallback(new Callback<EDPISequence, QString>(this, &EDPISequence::getScore));

692

EDPIProperty PropBound(strBound);

693

PropBound.setCallback(new Callback<ExpertDiscoveryData, double>(&edData, &ExpertDiscoveryData::getRecognizationBound));

694

EDPIProperty PropResult(strRecResult);

695

PropResult.setCallback(new Callback<EDPISequence, QString>(this, &EDPISequence::getResult));

696

EDPIPropertyGroup RecInfo(strRecognizationInfo);

697

RecInfo.addProperty(PropScore);

698

RecInfo.addProperty(PropBound);

699

RecInfo.addProperty(PropResult);

700

addGroup(RecInfo);

701

//}

702

}

703

704

QString EDPISequence::getScore() const

705

{

706

if (getType() == PIT_CONTROLSEQUENCE)

707

return "0";

708

if (m_rSeq.isHasScore() || edData.updateScore(const_cast<Sequence&>(m_rSeq)))

709

return toString(m_rSeq.getScore());

710

return "0";

711

}

712

713

QString EDPISequence::getResult() const

714

{

715

if (getType() == PIT_CONTROLSEQUENCE)

716

return "False";

717

718

if ((m_rSeq.isHasScore() || edData.updateScore(const_cast<Sequence&>(m_rSeq))) &&

719

m_rSeq.getScore() > edData.getRecognizationBound())

720

return "True";

721

else

722

return "False";

723

}

724

725

726

EDPISequence::~EDPISequence()

727

{

728

729

}

730

731

EItemType EDPISequence::getType() const

732

{

733

return PIT_SEQUENCE;

734

}

735

736

QString EDPISequence::getSequenceCode()

737

{

738

return QString::fromStdString(m_rSeq.getSequence());

739

}

740

741

QString EDPISequence::getSequenceName()

742

{

743

return QString::fromStdString(m_rSeq.getName());

744

}

745

746

bool EDPISequence::isConnectedTo(void *pData) const

747

{

748

return ((void*) &m_rSeq) == pData;

749

}

750

////////////////////////////////////////////////////////////

751

752

const CSFolder* EDPICSDirectory::getFolder() const{

753

return folder;

754

}

755

void EDPICSDirectory::setFolder(const CSFolder* pFolder){

756

folder = pFolder;

757

}

758

void EDPICSDirectory::update(bool bupdateChildren){

759

if (bupdateChildren) {

760

takeChildren();

761

762

const CSFolder* pFolder = getFolder();

763

int nSubfolderNum = pFolder->getFolderNumber();

764

for (int nSubfolder=0; nSubfolder<nSubfolderNum; nSubfolder++){

765

EDPICSFolder* nFol = new EDPICSFolder(pFolder->getSubfolder(nSubfolder));

766

addChild(dynamic_cast<EDProjectItem*>(nFol));

767

}

768

769

770

int nSignalNum = pFolder->getSignalNumber();

771

for (int nSignal=0; nSignal<nSignalNum; nSignal++){

772

EDPICS* nSig = new EDPICS( pFolder->getSignal(nSignal) );

773

addChild(dynamic_cast<EDProjectItem*>(nSig));

774

}

775

776

}

777

}

778

779

bool EDPICSDirectory::isConnectedTo(void *pData) const{

780

return ((void*) folder) == pData;

781

}

782

783

////////////////////////////////////////////////

784

EDPICSFolder::EDPICSFolder(const CSFolder *pFolder)

785

: EDPICSDirectory(pFolder){

786

update(true);

787

}

788

EDPICSFolder::~EDPICSFolder(){

789

790

}

791

EItemType EDPICSFolder::getType() const{

792

return PIT_CS_FOLDER;

793

}

794

void EDPICSFolder::update(bool bupdateChildren){

795

clearGroups();

796

797

QString strName = "Name";

798

QString strEditor = "Editor";

799

800

EDPIProperty propName(strName);

801

propName.setCallback(new Callback<const CSFolder, QString>(getFolder(), &CSFolder::getName));

802

propName.setType(EDPIPropertyTypeString::getInstance());

803

804

EDPIPropertyGroup editor(strEditor);

805

editor.addProperty(propName);

806

addGroup(editor);

807

808

EDPICSDirectory::update(bupdateChildren);

809

}

810

//virtual CExtPopupMenuWnd* CreatePopupMenu(HWND hWndCmdRecieve) const;

811

QString EDPICSFolder::getName() const{

812

return getFolder()->getName();

813

}

814

////////////////////////////////////////////////

815

816

EDPICSRoot::EDPICSRoot(CSFolder& rootF)

817

: EDPICSDirectory(NULL)

818

{

819

setFolder(&rootF);

820

update(true);

821

}

822

823

void EDPICSRoot::update(bool bUpdateChildren)

824

{

825

QString strCSRoot = "Complex signals";

826

827

setName(strCSRoot);

828

EDPICSDirectory::update(bUpdateChildren);

829

}

830

831

EDPICSRoot::~EDPICSRoot()

832

{

833

}

834

835

EItemType EDPICSRoot::getType() const

836

{

837

return PIT_CS_ROOT;

838

}

839

840

841

///////////////////////////////////////////////////

842

843

EDPICSNode::EDPICSNode(Operation *pOp1)

844

:pOp(pOp1)

845

,m_pPS(NULL)

846

{

847

848

}

849

EDPICSNode::~EDPICSNode(){

850

delete m_pPS;

851

}

852

Operation* EDPICSNode::getOperation(){

853

return pOp;

854

}

855

856

void EDPICSNode::setOperation(Operation *pOp){

857

this->pOp = pOp;

858

}

859

const Operation* EDPICSNode::getOperation() const{

860

return pOp;

861

}

862

void EDPICSNode::update(bool bupdateChildren){

863

delete m_pPS;

864

m_pPS = NULL;

865

866

if (pOp == NULL) {

867

setName("Undefined");

868

}

869

else {

870

setName(QString::fromStdString(pOp->getDescription()));

871

if (bupdateChildren) {

872

takeChildren();

873

int nArgNum = pOp->getArgumentNumber();

874

for (int nArg=0; nArg<nArgNum; nArg++){

875

EDProjectItem* ch = dynamic_cast<EDProjectItem*>(EDPICSNode::createCSN(pOp->getArgument(nArg)));

876

emit si_getMetaInfoBase();

877

ch->setMetainfoBase(getMinfo());

878

addChild( ch );

879

if(ch->getType() != PIT_CSN_UNDEFINED){

880

ch->update(true);

881

}

882

//addChild(dynamic_cast<EDProjectItem*>( EDPICSNode::createCSN( pOp->getArgument(nArg) )));

883

}

884

}

885

}

886

}

887

888

EDPICSNode* EDPICSNode::createCSN( Operation *pOp )

889

{

890

if (pOp == NULL) return new EDPICSNUndefined();

891

switch (pOp->getType()) {

892

case OP_DISTANCE : return new EDPICSNDistance(dynamic_cast<OpDistance*>(pOp));

893

case OP_REITERATION : return new EDPICSNRepetition(dynamic_cast<OpReiteration*>(pOp));

894

case OP_INTERVAL : return new EDPICSNInterval(dynamic_cast<OpInterval*>(pOp));

895

case OP_TS :

896

{

897

TS* pTS = dynamic_cast<TS*>(pOp);

898

if (!pTS->isFromMarking())

899

return new EDPICSNTSWord(pTS);

900

else{

901

return new EDPICSNTSMrkItem(pTS);

902

}

903

}

904

}

905

assert(0);

906

return NULL;

907

}

908

bool EDPICSNode::isConnectedTo(void *pData) const{

909

return ((void*) pOp) == pData;

910

}

911

const EDProcessedSignal* EDPICSNode::getProcessedSignal(ExpertDiscoveryData& edData){

912

if (m_pPS == NULL) {

913

m_pPS = EDProcessedSignal::processSignal(pOp, &edData.getPosSeqBase(), &edData.getNegSeqBase());

914

if (m_pPS != NULL) {

915

QString strGenInfo = "General information";

916

917

EDPIPropertyGroup GenInfo(strGenInfo);

918

EDPIProperty prob("Probability");

919

EDPIProperty posCoverage("Pos. coverage");

920

EDPIProperty negCoverage("Neg. coverage");

921

EDPIProperty fisher("Fisher");

922

//EDPIProperty ul("ul");

923

924

prob.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getProbability));

925

posCoverage.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getPosCoverage));

926

negCoverage.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getNegCoverage));

927

fisher.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getFisher));

928

//ul.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getUl));

929

930

GenInfo.addProperty(prob);

931

GenInfo.addProperty(posCoverage);

932

GenInfo.addProperty(negCoverage);

933

GenInfo.addProperty(fisher);

934

// GenInfo.addProperty(ul);

935

addGroup(GenInfo);

936

}

937

}

938

return m_pPS;

939

}

940

941

QString EDPICSNode::getProbability() const{

942

if (m_pPS)

943

return m_pPS->getPropertyValue("Probability");

944

return QString();

945

}

946

QString EDPICSNode::getFisher() const{

947

if (m_pPS)

948

return m_pPS->getPropertyValue("Fisher");

949

return QString();

950

}

951

QString EDPICSNode::getUl() const{

952

if (m_pPS)

953

return m_pPS->getPropertyValue("Ul");

954

return QString();

955

}

956

QString EDPICSNode::getPosCoverage() const{

957

if (m_pPS)

958

return m_pPS->getPropertyValue("Pos. coverage");

959

return QString();

960

}

961

QString EDPICSNode::getNegCoverage() const{

962

if (m_pPS)

963

return m_pPS->getPropertyValue("Neg. coverage");

964

return QString();

965

}

966

QString EDPICSNode::getTypeAsString() const{

967

QString str;

968

EDPIPropertyTypeList *pTList = EDPIPropertyTypeListCSNodeTypes::getInstance();

969

switch (getType()) {

970

case PIT_CSN_UNDEFINED: str = "Undefined"; break;

971

case PIT_CSN_DISTANCE: str = pTList->getValue(EDPIPropertyTypeListCSNodeTypes::DISTANCE); break;

972

case PIT_CSN_REPETITION:str = pTList->getValue(EDPIPropertyTypeListCSNodeTypes::REPETITION); break;

973

case PIT_CSN_INTERVAL: str = pTList->getValue(EDPIPropertyTypeListCSNodeTypes::INTERVAL); break;

974

case PIT_CSN_WORD: str = pTList->getValue(EDPIPropertyTypeListCSNodeTypes::WORD); break;

975

case PIT_CSN_MRK_ITEM: str = pTList->getValue(EDPIPropertyTypeListCSNodeTypes::MRK_ITEM); break;

976

}

977

return str;

978

}

979

980

EDPICS::EDPICS(const Signal *pSignal)

981

: EDPICSNode(pSignal->getSignal())

982

, m_pSignal(pSignal)

983

{

984

update(true);

985

}

986

EDPICS::~EDPICS(){

987

pOp = NULL;

988

}

989

EItemType EDPICS::getType() const{

990

return PIT_CS;

991

}

992

const Signal* EDPICS::getSignal() const{

993

return m_pSignal;

994

}

995

996

void EDPICS::update(bool bupdateChildren){

997

clearGroups();

998

999

QString strName = "Name";

1000

QString strEditor = "Editor";

1001

QString strDescription = "Description";

1002

QString strPriorParams = "Prior parameter";

1003

QString strPriorProb = "Probability";

1004

QString strPriorFisher = "Fisher criteria";

1005

QString strPriorPosCoverage = "Pos. Coverage";

1006

QString strPriorNegCoverage = "Neg. Coverage";

1007

1008

1009

EDPIProperty PropName(strName);

1010

PropName.setCallback(new Callback<const DDisc::Signal, const std::string>(m_pSignal, &DDisc::Signal::getName));

1011

PropName.setType(EDPIPropertyTypeString::getInstance());

1012

1013

EDPIProperty PropDesc(strDescription);

1014

PropDesc.setCallback(new Callback<const DDisc::Signal, const std::string>(m_pSignal, &DDisc::Signal::getDescription));

1015

PropDesc.setType(EDPIPropertyTypeString::getInstance());

1016

1017

EDPIPropertyGroup Editor(strEditor);

1018

Editor.addProperty(PropName);

1019

Editor.addProperty(PropDesc);

1020

addGroup(Editor);

1021

1022

EDPICSNode::update(false);

1023

setName(m_pSignal->getName().c_str());

1024

1025

// if (m_pSignal->isPriorParamsDefined()) {

1026

// EDPIProperty PropPriorProb(strPriorProb);

1027

// PropPriorProb.setCallback(new Callback<EDPICS, QString>(this, &EDPICS::getPriorProbability));

1028

// PropPriorProb.setType(EDPIPropertyTypeStaticString::getInstance());

1029

1030

// EDPIProperty PropPriorPosCoverage(strPriorPosCoverage);

1031

// PropPriorPosCoverage.setCallback(new Callback<EDPICS, QString>(this, &EDPICS::getPriorPosCoverage));

1032

// PropPriorPosCoverage.setType(EDPIPropertyTypeStaticString::getInstance());

1033

1034

// EDPIProperty PropPriorNegCoverage(strPriorNegCoverage);

1035

// PropPriorNegCoverage.setCallback(new Callback<EDPICS, QString>(this, &EDPICS::getPriorNegCoverage));

1036

// PropPriorNegCoverage.setType(EDPIPropertyTypeStaticString::getInstance());

1037

1038

// EDPIProperty PropPriorFisher(strPriorFisher);

1039

// PropPriorFisher.setCallback(new Callback<EDPICS, QString>(this, &EDPICS::getPriorFisher));

1040

// PropPriorFisher.setType(EDPIPropertyTypeStaticString::getInstance());

1041

1042

// EDPIPropertyGroup PriorParams(strPriorParams);

1043

// PriorParams.addProperty(PropPriorProb);

1044

// PriorParams.addProperty(PropPriorFisher);

1045

// PriorParams.addProperty(PropPriorPosCoverage);

1046

// PriorParams.addProperty(PropPriorNegCoverage);

1047

// addGroup(PriorParams);

1048

// }

1049

1050

if (bupdateChildren) {

1051

takeChildren();

1052

if (m_pSignal->getSignal() == NULL) {

1053

addChild(dynamic_cast<EDProjectItem*>( new EDPICSNUndefined() ));

1054

}

1055

else {

1056

EDProjectItem* ch = dynamic_cast<EDProjectItem*>(EDPICSNode::createCSN(m_pSignal->getSignal()));

1057

emit si_getMetaInfoBase();

1058

ch->setMetainfoBase(getMinfo());

1059

addChild( ch );

1060

ch->update(true);

1061

}

1062

}

1063

}

1064

bool EDPICS::isConnectedTo(void *pData) const{

1065

return ((void*) m_pSignal) == pData;

1066

}

1067

//virtual CExtPopupMenuWnd* CreatePopupMenu(HWND hWndCmdRecieve) const;

1068

//virtual bool isSelected() const;

1069

1070

QString EDPICS::getPriorProbability() const{

1071

QString str = "%1";

1072

if (m_pSignal->getPriorProbability() != UNDEFINED_VALUE)

1073

str = str.arg(m_pSignal->getPriorProbability());

1074

else

1075

str = "Undefined";

1076

return str;

1077

}

1078

QString EDPICS::getPriorFisher() const{

1079

QString str = "%1";

1080

if (m_pSignal->getPriorFisher() != UNDEFINED_VALUE)

1081

str = str.arg(m_pSignal->getPriorFisher());

1082

else

1083

str = "Undefined";

1084

return str;

1085

}

1086

QString EDPICS::getPriorPosCoverage() const{

1087

QString str = "%1";

1088

if (m_pSignal->getPriorPosCoverage() != UNDEFINED_VALUE)

1089

str = str.arg(m_pSignal->getPriorPosCoverage());

1090

else

1091

str = "Undefined";

1092

return str;

1093

}

1094

QString EDPICS::getPriorNegCoverage() const{

1095

QString str = "%1";

1096

if (m_pSignal->getPriorNegCoverage() != UNDEFINED_VALUE)

1097

str = str.arg(m_pSignal->getPriorNegCoverage());

1098

else

1099

str = "Undefined";

1100

return str;

1101

}

1102

////////////////////////////////////////////////////////////

1103

1104

EDPICSNUndefined::EDPICSNUndefined()

1105

: EDPICSNode(NULL)

1106

{

1107

update(true);

1108

}

1109

1110

1111

void EDPICSNUndefined::update(bool bupdateChildren)

1112

{

1113

QString strType = "Type";

1114

QString strEditor = "Editor";

1115

1116

1117

EDPIProperty PropType(strType);

1118

PropType.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getTypeAsString));

1119

PropType.setType(EDPIPropertyTypeListCSNodeTypes::getInstance());

1120

EDPIPropertyGroup Editor(strEditor);

1121

Editor.addProperty(PropType);

1122

addGroup(Editor);

1123

1124

EDPICSNode::update(bupdateChildren);

1125

}

1126

1127

EDPICSNUndefined::~EDPICSNUndefined()

1128

{

1129

}

1130

1131

EItemType EDPICSNUndefined::getType() const

1132

{

1133

return PIT_CSN_UNDEFINED;

1134

}

1135

1136

///////////////////////////////////////////////////////////////////////////////////////

1137

1138

EDPICSNDistance::EDPICSNDistance(OpDistance *pOp)

1139

: EDPICSNode(pOp)

1140

{

1141

update(true);

1142

}

1143

1144

void EDPICSNDistance::update(bool bupdateChildren) {

1145

clearGroups();

1146

1147

QString strType = "Type";

1148

QString strFrom = "Distance from";

1149

QString strTo = "Distance to";

1150

QString strEditor = "Editor";

1151

QString strOrder = "Order";

1152

QString strDistanceType = "Distance type";

1153

1154

1155

OpDistance* pOp = dynamic_cast<OpDistance*>(getOperation());

1156

assert(pOp != NULL);

1157

1158

EDPIPropertyTypeList *pTList = EDPIPropertyTypeListCSNodeTypes::getInstance();

1159

EDPIProperty PropType(strType);

1160

PropType.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getTypeAsString));

1161

PropType.setType(pTList);

1162

1163

EDPIProperty PropFrom(strFrom);

1164

PropFrom.setCallback(new Callback<EDPICSNDistance, QString>(this, &EDPICSNDistance::getPropFrom));

1165

PropFrom.setType(EDPIPropertyTypeUnsignedInt::getInstance());

1166

1167

EDPIProperty PropTo(strTo);

1168

PropTo.setCallback(new Callback<EDPICSNDistance, QString>(this, &EDPICSNDistance::getPropTo));

1169

PropTo.setType(EDPIPropertyTypeUnsignedIntWithUnl::getInstance());

1170

1171

EDPIProperty PropOrder(strOrder);

1172

PropOrder.setType(EDPIPropertyTypeBool::getInstance());

1173

PropOrder.setCallback(new Callback<EDPICSNDistance, QString>(this, &EDPICSNDistance::getPropOrder));

1174

1175

EDPIProperty PropDistType(strDistanceType);

1176

PropDistType.setType(EDPIPropertyTypeDistType::getInstance());

1177

PropDistType.setCallback(new Callback<EDPICSNDistance, QString>(this, &EDPICSNDistance::getPropDistType));

1178

1179

EDPIPropertyGroup Editor(strEditor);

1180

Editor.addProperty(PropType);

1181

Editor.addProperty(PropDistType);

1182

Editor.addProperty(PropFrom);

1183

Editor.addProperty(PropTo);

1184

Editor.addProperty(PropOrder);

1185

addGroup(Editor);

1186

1187

emit si_getMetaInfoBase();

1188

1189

EDPICSNode::update(bupdateChildren);

1190

}

1191

1192

EDPICSNDistance::~EDPICSNDistance()

1193

{

1194

}

1195

1196

EItemType EDPICSNDistance::getType() const

1197

{

1198

return PIT_CSN_DISTANCE;

1199

}

1200

1201

QString EDPICSNDistance::getPropDistType() const

1202

{

1203

const OpDistance* pOp = dynamic_cast<const OpDistance*>(getOperation());

1204

assert(pOp != NULL);

1205

int nType = (int) pOp->getDistanceType();

1206

return EDPIPropertyTypeDistType::getInstance()->getValue(nType);

1207

}

1208

1209

QString EDPICSNDistance::getPropFrom() const

1210

{

1211

const OpDistance* pOp = dynamic_cast<const OpDistance*>(getOperation());

1212

assert(pOp != NULL);

1213

return QString("%1").arg(pOp->getDistance().getFrom());

1214

}

1215

1216

QString EDPICSNDistance::getPropTo() const

1217

{

1218

const OpDistance* pOp = dynamic_cast<const OpDistance*>(getOperation());

1219

assert(pOp != NULL);

1220

int nTo = pOp->getDistance().getTo();

1221

if (nTo == PINF)

1222

return EDPIPropertyTypeUnsignedIntWithUnl::getInstance()->getValue(0);

1223

else

1224

return QString("%1").arg(nTo);

1225

}

1226

1227

QString EDPICSNDistance::getPropOrder() const

1228

{

1229

const OpDistance* pOp = dynamic_cast<const OpDistance*>(getOperation());

1230

assert(pOp != NULL);

1231

bool bOrder = pOp->isOrderImportant();

1232

return EDPIPropertyTypeBool::getInstance()->getValue((!bOrder)?EDPIPropertyTypeBool::False : EDPIPropertyTypeBool::True);

1233

}

1234

1235

1236

///////////////////////////////////////////////////////////////////////////////////////

1237

1238

EDPICSNRepetition::EDPICSNRepetition(OpReiteration *pOp)

1239

: EDPICSNode(pOp)

1240

{

1241

update(true);

1242

}

1243

1244

void EDPICSNRepetition::update(bool bupdateChildren)

1245

{

1246

clearGroups();

1247

1248

QString strType = "Type";

1249

QString strCountFrom = "Count from";

1250

QString strCountTo = "Count to";

1251

QString strFrom = "Distance from";

1252

QString strTo = "Distance to";

1253

QString strEditor = "Editor";

1254

QString strDistanceType = "Distance type";

1255

1256

OpReiteration* pOp = dynamic_cast<OpReiteration*>(getOperation());

1257

assert(pOp != NULL);

1258

1259

EDPIPropertyTypeList *pTList = EDPIPropertyTypeListCSNodeTypes::getInstance();

1260

EDPIProperty PropType(strType);

1261

PropType.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getTypeAsString));

1262

PropType.setType(pTList);

1263

1264

EDPIProperty PropFrom(strFrom);

1265

PropFrom.setCallback(new Callback<EDPICSNRepetition, QString>(this, &EDPICSNRepetition::getPropFrom));

1266

PropFrom.setType(EDPIPropertyTypeUnsignedInt::getInstance());

1267

1268

EDPIProperty PropTo(strTo);

1269

PropTo.setCallback(new Callback<EDPICSNRepetition, QString>(this, &EDPICSNRepetition::getPropTo));

1270

PropTo.setType(EDPIPropertyTypeUnsignedIntWithUnl::getInstance());

1271

1272

EDPIProperty PropDistType(strDistanceType);

1273

PropDistType.setType(EDPIPropertyTypeDistType::getInstance());

1274

PropDistType.setCallback(new Callback<EDPICSNRepetition, QString>(this, &EDPICSNRepetition::getPropDistType));

1275

EDPIProperty PropCountFrom(strCountFrom);

1276

PropCountFrom.setType(EDPIPropertyTypeUnsignedInt::getInstance());

1277

PropCountFrom.setCallback(new Callback<EDPICSNRepetition, QString>(this, &EDPICSNRepetition::getCountFrom));

1278

1279

EDPIProperty PropCountTo(strCountTo);

1280

PropCountTo.setType(EDPIPropertyTypeUnsignedInt::getInstance());

1281

PropCountTo.setCallback(new Callback<EDPICSNRepetition, QString>(this, &EDPICSNRepetition::getCountTo));

1282

1283

EDPIPropertyGroup Editor(strEditor);

1284

Editor.addProperty(PropType);

1285

Editor.addProperty(PropCountFrom);

1286

Editor.addProperty(PropCountTo);

1287

Editor.addProperty(PropDistType);

1288

Editor.addProperty(PropFrom);

1289

Editor.addProperty(PropTo);

1290

addGroup(Editor);

1291

1292

emit si_getMetaInfoBase();

1293

1294

EDPICSNode::update(bupdateChildren);

1295

}

1296

1297

EDPICSNRepetition::~EDPICSNRepetition()

1298

{

1299

}

1300

1301

EItemType EDPICSNRepetition::getType() const

1302

{

1303

return PIT_CSN_REPETITION;

1304

}

1305

1306

QString EDPICSNRepetition::getPropDistType() const

1307

{

1308

const OpReiteration* pOp = dynamic_cast<const OpReiteration*>(getOperation());

1309

assert(pOp != NULL);

1310

int nType = (int) pOp->getDistanceType();

1311

return EDPIPropertyTypeDistType::getInstance()->getValue(nType);

1312

}

1313

1314

QString EDPICSNRepetition::getPropFrom() const

1315

{

1316

const OpReiteration* pOp = dynamic_cast<const OpReiteration*>(getOperation());

1317

assert(pOp != NULL);

1318

return QString("%1").arg(pOp->getDistance().getFrom());

1319

}

1320

1321

QString EDPICSNRepetition::getPropTo() const

1322

{

1323

const OpReiteration* pOp = dynamic_cast<const OpReiteration*>(getOperation());

1324

assert(pOp != NULL);

1325

int nTo = pOp->getDistance().getTo();

1326

if (nTo == PINF)

1327

return EDPIPropertyTypeUnsignedIntWithUnl::getInstance()->getValue(0);

1328

else

1329

return QString("%1").arg(nTo);

1330

}

1331

1332

QString EDPICSNRepetition::getCountFrom() const

1333

{

1334

const OpReiteration* pOp = dynamic_cast<const OpReiteration*>(getOperation());

1335

assert(pOp != NULL);

1336

return QString("%1").arg(pOp->getCount().getFrom());

1337

}

1338

1339

QString EDPICSNRepetition::getCountTo() const

1340

{

1341

const OpReiteration* pOp = dynamic_cast<const OpReiteration*>(getOperation());

1342

assert(pOp != NULL);

1343

return QString("%1").arg(pOp->getCount().getTo());

1344

}

1345

1346

1347

///////////////////////////////////////////////////////////////////////////////////////

1348

1349

EDPICSNInterval::EDPICSNInterval(OpInterval *pOp)

1350

: EDPICSNode(pOp)

1351

{

1352

update(true);

1353

}

1354

1355

void EDPICSNInterval::update(bool bupdateChildren)

1356

{

1357

clearGroups();

1358

1359

QString strType = "Type";

1360

QString strFrom = "Distance from";

1361

QString strTo = "Distance to";

1362

QString strEditor = "Editor";

1363

1364

OpInterval* pOp = dynamic_cast<OpInterval*>(getOperation());

1365

1366

EDPIPropertyTypeList *pTList = EDPIPropertyTypeListCSNodeTypes::getInstance();

1367

EDPIProperty PropType(strType);

1368

PropType.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getTypeAsString));

1369

PropType.setType(pTList);

1370

1371

EDPIProperty PropFrom(strFrom);

1372

PropFrom.setCallback(new Callback<EDPICSNInterval, QString>(this, &EDPICSNInterval::getPropFrom));

1373

PropFrom.setType(EDPIPropertyTypeUnsignedInt::getInstance());

1374

1375

EDPIProperty PropTo(strTo);

1376

PropTo.setCallback(new Callback<EDPICSNInterval, QString>(this, &EDPICSNInterval::getPropTo));

1377

PropTo.setType(EDPIPropertyTypeUnsignedIntWithUnl::getInstance());

1378

1379

EDPIPropertyGroup Editor(strEditor);

1380

Editor.addProperty(PropType);

1381

Editor.addProperty(PropFrom);

1382

Editor.addProperty(PropTo);

1383

addGroup(Editor);

1384

1385

emit si_getMetaInfoBase();

1386

1387

EDPICSNode::update(bupdateChildren);

1388

1389

}

1390

1391

EDPICSNInterval::~EDPICSNInterval()

1392

{

1393

}

1394

1395

EItemType EDPICSNInterval::getType() const

1396

{

1397

return PIT_CSN_INTERVAL;

1398

}

1399

1400

QString EDPICSNInterval::getPropFrom() const

1401

{

1402

const OpInterval* pOp = dynamic_cast<const OpInterval*>(getOperation());

1403

assert(pOp != NULL);

1404

return QString("%1").arg(pOp->getInt().getFrom());

1405

}

1406

1407

QString EDPICSNInterval::getPropTo() const

1408

{

1409

const OpInterval* pOp = dynamic_cast<const OpInterval*>(getOperation());

1410

assert(pOp != NULL);

1411

int nTo = pOp->getInt().getTo();

1412

if (nTo == PINF)

1413

return EDPIPropertyTypeUnsignedIntWithUnl::getInstance()->getValue(0);

1414

else

1415

return QString("%1").arg(nTo);

1416

}

1417

1418

1419

///////////////////////////////////////////////////////////////////////////////////////

1420

1421

EDPICSNTSWord::EDPICSNTSWord(TS *pTS)

1422

: EDPICSNode(pTS)

1423

{

1424

update(true);

1425

}

1426

1427

void EDPICSNTSWord::update(bool bupdateChildren)

1428

{

1429

clearGroups();

1430

1431

QString strType = "Type";

1432

QString strEditor = "Editor";

1433

QString strWord = "Word";

1434

1435

EDPIPropertyTypeList *pTList = EDPIPropertyTypeListCSNodeTypes::getInstance();

1436

EDPIProperty PropType(strType);

1437

PropType.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getTypeAsString));

1438

PropType.setType(pTList);

1439

1440

EDPIProperty PropWord(strWord);

1441

PropWord.setType(EDPIPropertyTypeString::getInstance());

1442

PropWord.setCallback(new Callback<EDPICSNTSWord, QString>(this, &EDPICSNTSWord::getPropWord));

1443

1444

EDPIPropertyGroup Editor(strEditor);

1445

Editor.addProperty(PropType);

1446

Editor.addProperty(PropWord);

1447

addGroup(Editor);

1448

1449

EDPICSNode::update(bupdateChildren);

1450

}

1451

1452

EDPICSNTSWord::~EDPICSNTSWord()

1453

{

1454

}

1455

1456

EItemType EDPICSNTSWord::getType() const

1457

{

1458

return PIT_CSN_WORD;

1459

}

1460

1461

QString EDPICSNTSWord::getPropWord() const

1462

{

1463

const TS *pTS = dynamic_cast<const TS*>(getOperation());

1464

assert(pTS != NULL);

1465

return pTS->getWord().c_str();

1466

}

1467

1468

///////////////////////////////////////////////////////////////////////////////////////

1469

1470

EDPICSNTSMrkItem::EDPICSNTSMrkItem(TS *pTS)

1471

: EDPICSNode(pTS)

1472

{

1473

update(true);

1474

}

1475

1476

void EDPICSNTSMrkItem::update(bool bupdateChildren)

1477

{

1478

clearGroups();

1479

1480

QString strType = "Type";

1481

QString strEditor = "Editor";

1482

QString strFamily = "Family";

1483

QString strSignal = "Signal";

1484

1485

TS *pTS = dynamic_cast<TS*>(getOperation());

1486

1487

EDPIPropertyTypeList *pTList = EDPIPropertyTypeListCSNodeTypes::getInstance();

1488

EDPIProperty PropType(strType);

1489

PropType.setCallback(new Callback<EDPICSNode, QString>(this, &EDPICSNode::getTypeAsString));

1490

PropType.setType(pTList);

1491

1492

emit si_getMetaInfoBase();

1493

1494

if(getMinfo()){

1495

1496

const MetaInfoBase& rDesc = *getMinfo();

1497

EDPIPropertyTypeDynamicList *pTFamily = EDPIPropertyTypeDynamicList::getInstance();

1498

int nFamilyNum = rDesc.getFamilyNumber();

1499

for (int i=0; i<nFamilyNum; i++)

1500

pTFamily->addValue(rDesc.getSignalFamily(i).getName().c_str());

1501

EDPIProperty PropFamily(strFamily);

1502

PropFamily.setType(pTFamily);

1503

PropFamily.setCallback(new Callback<EDPICSNTSMrkItem, QString>(this, &EDPICSNTSMrkItem::getPropFamily));

1504

1505

EDPIPropertyTypeDynamicList *pTSignal = EDPIPropertyTypeDynamicList::getInstance();

1506

try {

1507

const Family& rFamily = rDesc.getSignalFamily(pTS->getFamily());

1508

int nSigNum = rFamily.getSignalNumber();

1509

for (int i=0;i<nSigNum; i++)

1510

pTSignal->addValue(rFamily.getMetaInfo(i).getName().c_str());

1511

}

1512

catch (exception) {

1513

1514

}

1515

EDPIProperty PropSignal(strSignal);

1516

PropSignal.setType(pTSignal);

1517

PropSignal.setCallback(new Callback<EDPICSNTSMrkItem, QString>(this, &EDPICSNTSMrkItem::getPropSignal));

1518

1519

EDPIPropertyGroup Editor(strEditor);

1520

Editor.addProperty(PropType);

1521

Editor.addProperty(PropFamily);

1522

Editor.addProperty(PropSignal);

1523

addGroup(Editor);

1524

}

1525

1526

EDPICSNode::update(bupdateChildren);

1527

}

1528

1529

EDPICSNTSMrkItem::~EDPICSNTSMrkItem()

1530

{

1531

}

1532

1533

EItemType EDPICSNTSMrkItem::getType() const

1534

{

1535

return PIT_CSN_MRK_ITEM;

1536

}

1537

1538

QString EDPICSNTSMrkItem::getPropFamily() const

1539

{

1540

const TS *pTS = dynamic_cast<const TS*>(getOperation());

1541

return pTS->getFamily().c_str();

1542

}

1543

1544

QString EDPICSNTSMrkItem::getPropSignal() const

1545

{

1546

const TS *pTS = dynamic_cast<const TS*>(getOperation());

1547

return pTS->getName().c_str();

1548

}

1549

1550

///////////////////////////////////////////////////////////////////////////////////////

1551

1552

EDPIMrkRoot::EDPIMrkRoot()

1553

: EDProjectItem()

1554

{

1555

update(true);

1556

}

1557

1558

EDPIMrkRoot::~EDPIMrkRoot()

1559

{

1560

}

1561

1562

EItemType EDPIMrkRoot::getType() const

1563

{

1564

return PIT_MRK_ROOT;

1565

}

1566

1567

void EDPIMrkRoot::update( bool bUpdateChildren)

1568

{

1569

setName("Markup");

1570

}

1571

1572

void EDPIMrkRoot::updMarkup(const ExpertDiscoveryData& d){

1573

takeChildren();

1574

const MetaInfoBase& rDesc = d.getDescriptionBase();

1575

int nFamilyNum = rDesc.getFamilyNumber();

1576

for (int i=0; i<nFamilyNum; i++){

1577

addChild( new EDPIMrkFamily(rDesc.getSignalFamily(i)) );

1578

}

1579

1580

}

1581

1582

bool EDPIMrkRoot::isConnectedTo(void *pData) const

1583

{

1584

//return (pData == (void *)&GlobalgetDocument()->getDescriptionBase());

1585

return NULL;

1586

}

1587

1588

1589

///////////////////////////////////////////////////////////////////////////////////////

1590

1591

EDPIMrkFamily::EDPIMrkFamily(const Family& rFamily)

1592

: EDProjectItem()

1593

, m_rFamily (rFamily)

1594

{

1595

update(true);

1596

}

1597

1598

EDPIMrkFamily::~EDPIMrkFamily()

1599

{

1600

}

1601

1602

EItemType EDPIMrkFamily::getType() const

1603

{

1604

return PIT_MRK_FAMILY;

1605

}

1606

1607

void EDPIMrkFamily::update(bool bupdateChildren)

1608

{

1609

QString strName = m_rFamily.getName().c_str();

1610

setName( strName );

1611

1612

if (bupdateChildren) {

1613

takeChildren();

1614

int nSigNum = m_rFamily.getSignalNumber();

1615

for (int i=0; i<nSigNum; i++)

1616

addChild(dynamic_cast<EDProjectItem*>( new EDPIMrkItem(strName, m_rFamily.getMetaInfo(i)) ));

1617

}

1618

}

1619

1620

bool EDPIMrkFamily::isConnectedTo(void *pData) const

1621

{

1622

return (pData == (void *) &m_rFamily);

1623

}

1624

1625

///////////////////////////////////////////////////////////////////////////////////////

1626

1627

EDPIMrkItem::EDPIMrkItem(QString strFamilyName, const MetaInfo& rMetaInfo)

1628

: EDPICSNode(NULL)

1629

, m_rMetaInfo(rMetaInfo)

1630

{

1631

TS* pTS = new TS;

1632

pTS->setFromMarking(true);

1633

pTS->setName(m_rMetaInfo.getName());

1634

pTS->setFamily(strFamilyName.toStdString());

1635

pOp = pTS;

1636

update(true);

1637

setName(m_rMetaInfo.getName().c_str());

1638

}

1639

1640

EDPIMrkItem::~EDPIMrkItem()

1641

{

1642

delete pOp;

1643

}

1644

1645

EItemType EDPIMrkItem::getType() const

1646

{

1647

return PIT_MRK_ITEM;

1648

}

1649

1650

void EDPIMrkItem::update(bool bupdateChildren)

1651

{

1652

setName( m_rMetaInfo.getName().c_str() );

1653

EDPICSNode::update(true);

1654

}

1655

1656

bool EDPIMrkItem::isConnectedTo(void *pData) const

1657

{

1658

return (pData == (void *) &m_rMetaInfo);

1659

}

1660

1661

} //namespace

1662

Older »