~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

new Object[] { String.valueOf(mes.getName()), String.valueOf(mes.getStartLifeline().getName()), Integer.valueOf(mes.getStartOccurrence()), String.valueOf(mes.getEndLifeline().getName()),

307

Integer.valueOf(mes.getEndOccurrence()) });

308

} else if ((mes.getStartLifeline() == null) && (mes.getEndLifeline() != null)) {

309

e.result = MessageFormat.format(SDMessages._4, new Object[] { String.valueOf(mes.getName()), String.valueOf(mes.getEndLifeline().getName()), Integer.valueOf(mes.getEndOccurrence()) });

310

} else if ((mes.getStartLifeline() != null) && (mes.getEndLifeline() == null)) {

311

e.result = MessageFormat.format(SDMessages._3, new Object[] { String.valueOf(mes.getName()), String.valueOf(mes.getStartLifeline().getName()), Integer.valueOf(mes.getStartOccurrence()) });

312

}

313

} else if (getFocusNode() instanceof BasicExecutionOccurrence) {

314

BasicExecutionOccurrence exec = (BasicExecutionOccurrence) getFocusNode();

315

e.result = MessageFormat.format(SDMessages._5,

316

new Object[] { String.valueOf(exec.getName()), String.valueOf(exec.getLifeline().getName()), Integer.valueOf(exec.getStartOccurrence()), Integer.valueOf(exec.getEndOccurrence()) });

317

}

318

319

}

320

}

321

}

322

});

323

324

fAccessible.addAccessibleControlListener(new AccessibleControlAdapter() {

325

326

* (non-Javadoc)

327

* @see org.eclipse.swt.accessibility.AccessibleControlAdapter#getFocus(org.eclipse.swt.accessibility.AccessibleControlEvent)

328

329

@Override

330

public void getFocus(AccessibleControlEvent e) {

331

if (fFocusedWidget == -1) {

332

e.childID = ACC.CHILDID_SELF;

333

} else {

334

e.childID = fFocusedWidget;

335

}

336

}

337

338

339

* (non-Javadoc)

340

* @see org.eclipse.swt.accessibility.AccessibleControlAdapter#getRole(org.eclipse.swt.accessibility.AccessibleControlEvent)

341

342

@Override

343

public void getRole(AccessibleControlEvent e) {

344

switch (e.childID) {

345

case ACC.CHILDID_SELF:

346

e.detail = ACC.ROLE_CLIENT_AREA;

347

break;

348

case 0:

349

e.detail = ACC.ROLE_TOOLTIP;

350

break;

351

case 1:

352

e.detail = ACC.ROLE_LABEL;

353

break;

354

default:

355

break;

356

}

357

}

358

359

360

* (non-Javadoc)

361

* @see org.eclipse.swt.accessibility.AccessibleControlAdapter#getState(org.eclipse.swt.accessibility.AccessibleControlEvent)

362

363

@Override

364

public void getState(AccessibleControlEvent e) {

365

e.detail = ACC.STATE_FOCUSABLE;

366

if (e.childID == ACC.CHILDID_SELF) {

367

e.detail |= ACC.STATE_FOCUSED;

368

} else {

369

e.detail |= ACC.STATE_SELECTABLE;

370

if (e.childID == fFocusedWidget) {

371

e.detail |= ACC.STATE_FOCUSED | ACC.STATE_SELECTED | ACC.STATE_CHECKED;

372

}

373

}

374

}

375

});

376

377

fInsertionCartet = new Caret((Canvas) getViewControl(), SWT.NONE);

378

fInsertionCartet.setVisible(false);

379

380

fCollapaseCaretImg = Activator.getDefault().getImageFromPath(ITmfImageConstants.IMG_UI_ARROW_COLLAPSE_OBJ);

381

fArrowUpCaretImg = Activator.getDefault().getImageFromPath(ITmfImageConstants.IMG_UI_ARROW_UP_OBJ);

382

383

fReorderList = new ArrayList<Lifeline[]>();

384

getViewControl().addTraverseListener(new LocalTraverseListener());

385

386

addTraverseListener(new LocalTraverseListener());

387

388

getViewControl().addFocusListener(new FocusListener() {

389

390

391

* (non-Javadoc)

392

* @see org.eclipse.swt.events.FocusListener#focusGained(org.eclipse.swt.events.FocusEvent)

393

394

@Override

395

public void focusGained(FocusEvent e) {

396

SDViewPref.getInstance().setNoFocusSelection(false);

397

fCtrlSelection = false;

398

fShiftSelection = false;

399

redraw();

400

}

401

402

403

* (non-Javadoc)

404

* @see org.eclipse.swt.events.FocusListener#focusLost(org.eclipse.swt.events.FocusEvent)

405

406

@Override

407

public void focusLost(FocusEvent e) {

408

SDViewPref.getInstance().setNoFocusSelection(true);

409

redraw();

410

}

411

});

412

}

413

414

// ------------------------------------------------------------------------

415

// Operations

416

// ------------------------------------------------------------------------

417

/**

418

* Sets the time compression bar.

419

420

* @param bar The time compression bar to set

421

422

public void setTimeBar(TimeCompressionBar bar) {

423

if (bar != null) {

424

fTimeBar = bar;

425

fTimeBar.addTimeCompressionListener(this);

426

}

427

}

428

429

/**

430

* Resize the contents to insure the frame fit into the view

431

432

* @param frame the frame which will be drawn in the view

433

434

public void resizeContents(Frame frame) {

435

int width = Math.round((frame.getWidth() + 2 * Metrics.FRAME_H_MARGIN) * fZoomValue);

436

int height = Math.round((frame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);

437

resizeContents(width, height);

438

}

439

440

/**

441

* The frame to render (the sequence diagram)

442

443

* @param theFrame the frame to display

444

* @param resetPosition boolean

445

446

public void setFrame(Frame theFrame, boolean resetPosition) {

447

fReorderList.clear();

448

fSelectedNodeList.clear();

449

fSelProvider.setSelection(new StructuredSelection());

450

fFrame = theFrame;

451

if (resetPosition) {

452

setContentsPos(0, 0);

453

resizeContents(fFrame);

454

redraw();

455

}

456

// prepare the old overview to be reused

457

if (fOverView != null) {

458

fOverView.dispose();

459

}

460

fOverView = null;

461

resizeContents(fFrame);

462

}

463

464

/**

465

* Returns the current Frame (the sequence diagram container)

466

467

* @return the frame

468

469

public Frame getFrame() {

470

return fFrame;

471

}

472

473

/**

474

* Returns the selection provider for the current sequence diagram

475

476

* @return the selection provider

477

478

public ISelectionProvider getSelectionProvider() {

479

return fSelProvider;

480

}

481

482

/**

483

* Returns a list of selected graph nodes.

484

485

* @return a list of selected graph nodes.

486

487

public List<GraphNode> getSelection() {

488

return fSelectedNodeList;

489

}

490

491

/**

492

* Adds a graph node to the selected nodes list.

493

494

* @param node A graph node

495

496

public void addSelection(GraphNode node) {

497

if (node == null) {

498

return;

499

}

500

fSelectedNodeList.add(node);

501

node.setSelected(true);

502

fCurrentGraphNode = node;

503

StructuredSelection selection = new StructuredSelection(fSelectedNodeList);

504

fSelProvider.setSelection(selection);

505

}

506

507

/**

508

* Adds a list of node to the selected nodes list.

509

510

* @param list of graph nodes

511

512

public void addSelection(List<GraphNode> list) {

513

// selectedNodeList.addAll(list);

514

for (int i = 0; i < list.size(); i++) {

515

if (!fSelectedNodeList.contains(list.get(i))) {

516

fSelectedNodeList.add(list.get(i));

517

((GraphNode) list.get(i)).setSelected(true);

518

}

519

}

520

StructuredSelection selection = new StructuredSelection(fSelectedNodeList);

521

fSelProvider.setSelection(selection);

522

}

523

524

/**

525

* Removes a node from the selected nodes list.

526

527

* @param node to remove

528

529

public void removeSelection(GraphNode node) {

530

fSelectedNodeList.remove(node);

531

node.setSelected(false);

532

node.setFocused(false);

533

StructuredSelection selection = new StructuredSelection(fSelectedNodeList);

534

fSelProvider.setSelection(selection);

535

}

536

537

/**

538

* Removes a list of graph nodes from the selected nodes list.

539

540

* @param list of nodes to remove.

541

542

public void removeSelection(List<GraphNode> list) {

543

fSelectedNodeList.removeAll(list);

544

for (int i = 0; i < list.size(); i++) {

545

((GraphNode) list.get(i)).setSelected(false);

546

((GraphNode) list.get(i)).setFocused(false);

547

}

548

StructuredSelection selection = new StructuredSelection(fSelectedNodeList);

549

fSelProvider.setSelection(selection);

550

}

551

552

/**

553

* Clear the list of GraphNodes which must be drawn selected.

554

555

public void clearSelection() {

556

for (int i = 0; i < fSelectedNodeList.size(); i++) {

557

((GraphNode) fSelectedNodeList.get(i)).setSelected(false);

558

((GraphNode) fSelectedNodeList.get(i)).setFocused(false);

559

}

560

fCurrentGraphNode = null;

561

fSelectedNodeList.clear();

562

fSelProvider.setSelection(new StructuredSelection());

563

}

564

565

/**

566

* Sets view part.

567

568

* @param viewSite The view part to set

569

570

public void setSite(ViewPart viewSite) {

571

fSite = viewSite;

572

fSite.getSite().setSelectionProvider(fSelProvider);

573

IContextService service = (IContextService) fSite.getSite().getWorkbenchWindow().getService(IContextService.class);

574

service.activateContext("org.eclipse.linuxtools.tmf.ui.view.uml2sd.context"); //$NON-NLS-1$

575

service.activateContext(IContextIds.CONTEXT_ID_WINDOW);

576

}

577

578

/**

579

* Returns the GraphNode overView the mouse if any

580

581

* @return the current graph node

582

* */

583

public GraphNode getMouseOverNode() {

584

return fCurrentGraphNode;

585

}

586

587

/**

588

* Sets the zoom in mode.

589

590

* @param The mode value to set.

591

592

public void setZoomInMode(boolean value) {

593

if (value) {

594

setZoomOutMode(false);

595

}

596

fZoomInMode = value;

597

}

598

599

/**

600

* Sets the zoom out mode.

601

602

* @param The mode value to set.

603

604

public void setZoomOutMode(boolean value) {

605

if (value) {

606

setZoomInMode(false);

607

}

608

fZoomOutMode = value;

609

}

610

611

/**

612

* Moves the Sequence diagram to ensure the given node is visible and draw it selected

613

614

* @param node the GraphNode to move to

615

616

public void moveTo(GraphNode node) {

617

if (node == null) {

618

return;

619

}

620

clearSelection();

621

addSelection(node);

622

ensureVisible(node);

623

}

624

625

/**

626

* Moves the Sequence diagram to ensure the given node is visible

627

628

* @param node the GraphNode to move to

629

630

public void ensureVisible(GraphNode node) {

631

if (node == null) {

632

return;

633

}

634

int x = Math.round(node.getX() * fZoomValue);

635

int y = Math.round(node.getY() * fZoomValue);

636

int width = Math.round(node.getWidth() * fZoomValue);

637

int height = Math.round(node.getHeight() * fZoomValue);

638

if ((node instanceof BaseMessage) && (height == 0)) {

639

int header = Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN * 2 + Metrics.getLifelineHeaderFontHeigth();

640

height = -Math.round((Metrics.getMessagesSpacing() + header) * fZoomValue);

641

y = y + Math.round(Metrics.SYNC_INTERNAL_MESSAGE_HEIGHT * fZoomValue);

642

}

643

if (node instanceof BasicExecutionOccurrence) {

644

width = 1;

645

height = 1;

646

}

647

if (node instanceof Lifeline) {

648

y = getContentsY();

649

height = getVisibleHeight();

650

}

651

ensureVisible(x, y, width, height, SWT.CENTER, true);

652

redraw();

653

}

654

655

/**

656

* Returns the current zoom factor.

657

* @return the current zoom factor.

658

659

public float getZoomFactor() {

660

return fZoomValue;

661

}

662

663

/**

664

* Returns teh printer reference.

665

666

* @return the printer reference

667

668

public Printer getPrinter() {

669

return fPrinter;

670

}

671

672

/**

673

* Returns whether the widget is used for printing or not.

674

675

* @return whether the widget is used for printing or not

676

677

public boolean isPrinting() {

678

return fIsPrinting;

679

}

680

681

/**

682

* Gets the overview image.

683

684

* @param rect Rectangle to include overview.

685

* @return the overview image

686

687

public Image getOverview(Rectangle rect) {

688

float oldzoom = fZoomValue;

689

if ((fOverView != null) && ((rect.width != fOverView.getBounds().width) || (rect.height != fOverView.getBounds().height))) {

690

fOverView.dispose();

691

fOverView = null;

692

}

693

if (fOverView == null) {

694

int backX = getContentsX();

695

int backY = getContentsY();

696

setContentsPos(0, 0);

697

fOverView = new Image(getDisplay(), rect.width, rect.height);

698

GC gcim = new GC(fOverView);

699

NGC context = new NGC(this, gcim);

700

context.setBackground(SDViewPref.getInstance().getBackGroundColor(SDViewPref.PREF_FRAME));

701

fFrame.draw(context);

702

setContentsPos(backX, backY);

703

gcim.dispose();

704

context.dispose();

705

}

706

fZoomValue = oldzoom;

707

return fOverView;

708

}

709

710

/**

711

* Resets the zoom factor.

712

713

public void resetZoomFactor() {

714

int currentX = Math.round(getContentsX() / fZoomValue);

715

int currentY = Math.round(getContentsY() / fZoomValue);

716

fZoomValue = 1;

717

if (fTimeBar != null && !fTimeBar.isDisposed()) {

718

fTimeBar.setZoom(fZoomValue);

719

}

720

redraw();

721

update();

722

setContentsPos(currentX, currentY);

723

}

724

725

/**

726

* Enable or disable the lifeline reodering using Drag and Drop

727

728

* @param mode - true to enable false otherwise

729

730

public void setReorderMode(boolean mode) {

731

fReorderMode = mode;

732

}

733

734

/**

735

* Return the lifelines reorder sequence (using Drag and Drop) if the the reorder mode is turn on. Each ArryList

736

* element is of type Lifeline[2] with Lifeline[0] inserted before Lifeline[1] in the diagram

737

738

* @return - the re-odered sequence

739

740

public List<Lifeline[]> getLifelineReoderList() {

741

return fReorderList;

742

}

743

744

/**

745

* Sets the focus on given graph node (current node).

746

747

* @param the graph node to focus on.

748

749

public void setFocus(GraphNode node) {

750

if (node == null) {

751

return;

752

}

753

if (fCurrentGraphNode != null) {

754

fCurrentGraphNode.setFocused(false);

755

}

756

fCurrentGraphNode = node;

757

node.setFocused(true);

758

ensureVisible(node);

759

setFocus(0);

760

}

761

762

/**

763

* Returns the graph node focused on.

764

765

* @return the current graph node

766

767

public GraphNode getFocusNode() {

768

return fCurrentGraphNode;

769

}

770

771

/**

772

* Method to traverse right.

773

774

public void traverseRight() {

775

Object selectedNode = getFocusNode();

776

if (selectedNode == null) {

777

traverseLeft();

778

}

779

GraphNode node = null;

780

if ((selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getEndLifeline() != null)) {

781

node = fFrame.getCalledMessage((BaseMessage) selectedNode);

782

}

783

if (selectedNode instanceof BasicExecutionOccurrence) {

784

selectedNode = ((BasicExecutionOccurrence) selectedNode).getLifeline();

785

}

786

if ((node == null) && (selectedNode instanceof Lifeline)) {

787

for (int i = 0; i < fFrame.lifeLinesCount(); i++) {

788

if ((selectedNode == fFrame.getLifeline(i)) && (i < fFrame.lifeLinesCount() - 1)) {

789

node = fFrame.getLifeline(i + 1);

790

break;

791

}

792

}

793

}

794

if (node != null) {

795

setFocus(node);

796

redraw();

797

}

798

}

799

800

/**

801

* Method to traverse left.

802

803

public void traverseLeft() {

804

Object selectedNode = getFocusNode();

805

GraphNode node = null;

806

if ((selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getStartLifeline() != null)) {

807

node = fFrame.getCallerMessage((BaseMessage) selectedNode);

808

}

809

if (selectedNode instanceof BasicExecutionOccurrence) {

810

selectedNode = ((BasicExecutionOccurrence) selectedNode).getLifeline();

811

}

812

if (node == null) {

813

if ((selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getEndLifeline() != null)) {

814

selectedNode = ((BaseMessage) selectedNode).getEndLifeline();

815

}

816

for (int i = 0; i < fFrame.lifeLinesCount(); i++) {

817

if ((selectedNode == fFrame.getLifeline(i)) && (i > 0)) {

818

node = fFrame.getLifeline(i - 1);

819

break;

820

}

821

}

822

if ((fFrame.lifeLinesCount() > 0) && (node == null)) {

823

node = fFrame.getLifeline(0);

824

}

825

}

826

if (node != null) {

827

setFocus(node);

828

redraw();

829

}

830

}

831

832

/**

833

* Method to traverse up.

834

835

public void traverseUp() {

836

Object selectedNode = getFocusNode();

837

if (selectedNode == null) {

838

traverseLeft();

839

}

840

GraphNode node = null;

841

if (selectedNode instanceof BaseMessage) {

842

node = fFrame.getPrevLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), (BaseMessage) selectedNode);

843

} else if (selectedNode instanceof Lifeline) {

844

node = fFrame.getPrevLifelineMessage((Lifeline) selectedNode, null);

845

if (!(node instanceof Lifeline)) {

846

node = null;

847

}

848

} else if (selectedNode instanceof BasicExecutionOccurrence) {

849

node = fFrame.getPrevExecOccurrence((BasicExecutionOccurrence) selectedNode);

850

if (node == null) {

851

node = ((BasicExecutionOccurrence) selectedNode).getLifeline();

852

}

853

}

854

if ((node == null) && (selectedNode instanceof BaseMessage) && (((BaseMessage) selectedNode).getStartLifeline() != null)) {

855

node = ((BaseMessage) selectedNode).getStartLifeline();

856

}

857

858

if (node != null) {

859

setFocus(node);

860

redraw();

861

}

862

}

863

864

/**

865

* Method to traverse down.

866

867

public void traverseDown() {

868

Object selectedNode = getFocusNode();

869

if (selectedNode == null) {

870

traverseLeft();

871

}

872

GraphNode node;

873

if (selectedNode instanceof BaseMessage) {

874

node = fFrame.getNextLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), (BaseMessage) selectedNode);

875

} else if (selectedNode instanceof Lifeline) {

876

// node = frame.getNextLifelineMessage((Lifeline)selectedNode,null);

877

node = fFrame.getFirstExecution((Lifeline) selectedNode);

878

} else if (selectedNode instanceof BasicExecutionOccurrence) {

879

node = fFrame.getNextExecOccurrence((BasicExecutionOccurrence) selectedNode);

880

} else {

881

return;

882

}

883

884

if (node != null) {

885

setFocus(node);

886

redraw();

887

}

888

}

889

890

/**

891

* Method to traverse home.

892

893

public void traverseHome() {

894

Object selectedNode = getFocusNode();

895

if (selectedNode == null) {

896

traverseLeft();

897

}

898

GraphNode node = null;

899

900

if (selectedNode instanceof BaseMessage) {

901

if (((BaseMessage) selectedNode).getStartLifeline() != null) {

902

node = fFrame.getNextLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), null);

903

} else {

904

node = fFrame.getNextLifelineMessage(((BaseMessage) selectedNode).getEndLifeline(), null);

905

}

906

} else if (selectedNode instanceof Lifeline) {

907

node = fFrame.getNextLifelineMessage((Lifeline) selectedNode, null);

908

} else if (selectedNode instanceof BasicExecutionOccurrence) {

909

node = fFrame.getFirstExecution(((BasicExecutionOccurrence) selectedNode).getLifeline());

910

} else {

911

if (fFrame.lifeLinesCount() > 0) {

912

Lifeline lifeline = fFrame.getLifeline(0);

913

node = fFrame.getNextLifelineMessage(lifeline, null);

914

}

915

}

916

917

if (node != null) {

918

setFocus(node);

919

redraw();

920

}

921

}

922

923

/**

924

* Method to traverse to the end.

925

926

public void traverseEnd() {

927

Object selectedNode = getFocusNode();

928

if (selectedNode == null) {

929

traverseLeft();

930

}

931

GraphNode node;

932

if (selectedNode instanceof BaseMessage) {

933

node = fFrame.getPrevLifelineMessage(((BaseMessage) selectedNode).getStartLifeline(), null);

934

} else if (selectedNode instanceof Lifeline) {

935

node = fFrame.getPrevLifelineMessage((Lifeline) selectedNode, null);

936

} else if (selectedNode instanceof BasicExecutionOccurrence) {

937

node = fFrame.getLastExecOccurrence(((BasicExecutionOccurrence) selectedNode).getLifeline());

938

} else {

939

if (fFrame.lifeLinesCount() > 0) {

940

Lifeline lifeline = fFrame.getLifeline(0);

941

node = fFrame.getPrevLifelineMessage(lifeline, null);

942

} else {

943

return;

944

}

945

}

946

947

if (node != null) {

948

setFocus(node);

949

redraw();

950

}

951

}

952

953

/**

954

* Method to print UI.

955

956

* @param sdPrintDialog the sequence diagram printer dialog.

957

958

public void printUI(SDPrintDialogUI sdPrintDialog) {

959

PrinterData data = sdPrintDialog.getPrinterData();

960

961

if ((data == null) || (fFrame == null)) {

962

return;

963

}

964

965

fPrinter = new Printer(data);

966

967

String jobName = MessageFormat.format(SDMessages._116, new Object[] { String.valueOf(fSite.getContentDescription()), String.valueOf(fFrame.getName()) });

968

fPrinter.startJob(jobName);

969

970

GC gc = new GC(fPrinter);

971

// Frame.setUserPref(SDViewPref.getInstance());

972

973

float lastZoom = fZoomValue;

974

975

Rectangle area = getClientArea();

976

GC gcim = null;

977

978

gcim = gc;

979

NGC context = new NGC(this, gcim);

980

981

// Set the metrics to use for lifeline text and message text

982

// using the Graphical Context

983

Metrics.setLifelineFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE)));

984

Metrics.setLifelineFontWidth(context.getFontWidth(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE)));

985

Metrics.setLifelineWidth(SDViewPref.getInstance().getLifelineWidth());

986

Metrics.setFrameFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_FRAME_NAME)));

987

Metrics.setLifelineHeaderFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE_HEADER)));

988

989

int syncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_SYNC_MESS));

990

int syncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_SYNC_MESS_RET));

991

int asyncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_ASYNC_MESS));

992

int asyncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_ASYNC_MESS_RET));

993

994

int messageFontHeight = 0;

995

if (syncMessFontH > syncMessRetFontH) {

996

messageFontHeight = syncMessFontH;

997

} else {

998

messageFontHeight = syncMessRetFontH;

999

}

1000

if (messageFontHeight < asyncMessFontH) {

1001

messageFontHeight = asyncMessFontH;

1002

}

1003

if (messageFontHeight < asyncMessRetFontH) {

1004

messageFontHeight = asyncMessRetFontH;

1005

}

1006

Metrics.setMessageFontHeight(messageFontHeight);

1007

context.setFont(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE));

1008

1009

int width = Math.round((fFrame.getWidth() + 2 * Metrics.FRAME_H_MARGIN) * fZoomValue);

1010

int height = Math.round((fFrame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);

1011

if (width < area.width) {

1012

width = area.width;

1013

}

1014

if (height < area.height) {

1015

height = area.height;

1016

}

1017

resizeContents(width, height);

1018

1019

context.setBackground(SDViewPref.getInstance().getBackGroundColor(ISDPreferences.PREF_FRAME));

1020

context.fillRectangle(0, 0, getContentsWidth(), Metrics.FRAME_V_MARGIN);

1021

context.fillRectangle(0, 0, fFrame.getX(), getContentsHeight());

1022

context.fillRectangle(fFrame.getX() + fFrame.getWidth() + 1, 0, getContentsWidth() - (fFrame.getX() + fFrame.getWidth() + 1), getContentsHeight());

1023

context.fillRectangle(0, fFrame.getY() + fFrame.getHeight() + 1, getContentsWidth(), getContentsHeight() - (fFrame.getY() + fFrame.getHeight() + 1));

1024

gcim.setLineWidth(1);

1025

1026

fPrinter.startPage();

1027

fZoomValue = lastZoom;

1028

1029

int restoreX = getContentsX();

1030

int restoreY = getContentsY();

1031

1032

float zh = sdPrintDialog.getStepY() * sdPrintDialog.getZoomFactor();

1033

float zw = sdPrintDialog.getStepX() * sdPrintDialog.getZoomFactor();

1034

1035

float zoomValueH = fPrinter.getClientArea().height / zh;

1036

float zoomValueW = fPrinter.getClientArea().width / zw;

1037

if (zoomValueH > zoomValueW) {

1038

fPrinterZoom = zoomValueH;

1039

} else {

1040

fPrinterZoom = zoomValueW;

1041

}

1042

1043

if (sdPrintDialog.printSelection()) {

1044

int[] pagesList = sdPrintDialog.getPageList();

1045

1046

for (int pageIndex = 0; pageIndex < pagesList.length; pageIndex++) {

1047

printPage(pagesList[pageIndex], sdPrintDialog, context);

1048

}

1049

} else if (sdPrintDialog.printAll()) {

1050

for (int pageIndex = 1; pageIndex <= sdPrintDialog.maxNumOfPages(); pageIndex++) {

1051

printPage(pageIndex, sdPrintDialog, context);

1052

}

1053

} else if (sdPrintDialog.printCurrent()) {

1054

printPage(getContentsX(), getContentsY(), sdPrintDialog, context, 1);

1055

} else if (sdPrintDialog.printRange()) {

1056

for (int pageIndex = sdPrintDialog.getFrom(); pageIndex <= sdPrintDialog.maxNumOfPages() && pageIndex <= sdPrintDialog.getTo(); pageIndex++) {

1057

printPage(pageIndex, sdPrintDialog, context);

1058

}

1059

}

1060

1061

fPrinter.endJob();

1062

fIsPrinting = false;

1063

1064

gc.dispose();

1065

context.dispose();

1066

1067

fZoomValue = lastZoom;

1068

fPrinter.dispose();

1069

setContentsPos(restoreX, restoreY);

1070

}

1071

1072

/**

1073

* Method to print.

1074

1075

public void print() {

1076

SDPrintDialog sdPrinter = new SDPrintDialog(this.getShell(), this);

1077

try {

1078

if (sdPrinter.open() != 0) {

1079

return;

1080

}

1081

} catch (Exception e) {

1082

Activator.getDefault().logError("Error creating image", e); //$NON-NLS-1$

1083

return;

1084

}

1085

printUI(sdPrinter.getDialogUI());

1086

}

1087

1088

/**

1089

* Method to print a page.

1090

1091

* @param pageNum The page number

1092

* @param pd The sequence diagram print dialog

1093

* @param context The graphical context

1094

1095

public void printPage(int pageNum, SDPrintDialogUI pd, NGC context) {

1096

int j = pageNum / pd.getNbRow();

1097

int i = pageNum % pd.getNbRow();

1098

if (i != 0) {

1099

j++;

1100

} else {

1101

i = pd.getNbRow();

1102

}

1103

1104

i--;

1105

j--;

1106

1107

i = (int) (i * pd.getStepX());

1108

j = (int) (j * pd.getStepY());

1109

1110

printPage(i, j, pd, context, pageNum);

1111

1112

fPrinter.endPage();

1113

}

1114

1115

/**

1116

* Method to print page ranges.

1117

1118

* @param i The start page

1119

* @param j The end page

1120

* @param pd The sequence diagram print dialog

1121

* @param context The graphical context

1122

* @param pageNum int the current page

1123

1124

public void printPage(int i, int j, SDPrintDialogUI pd, NGC context, int pageNum) {

1125

fIsPrinting = false;

1126

int pageNumFontZoom = fPrinter.getClientArea().height / getVisibleHeight();

1127

fPrinterX = i;

1128

fPrinterY = j;

1129

setContentsPos(i, j);

1130

update();

1131

fIsPrinting = true;

1132

float lastZoom = fZoomValue;

1133

fZoomValue = fPrinterZoom * lastZoom;

1134

1135

fFrame.draw(context);

1136

1137

fZoomValue = pageNumFontZoom;

1138

context.setFont(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE));

1139

String currentPageNum = String.valueOf(pageNum);

1140

int ii = context.textExtent(currentPageNum);

1141

int jj = context.getCurrentFontHeight();

1142

// context.setBackground(ColorImpl.getSystemColor(SWT.COLOR_BLACK));

1143

// context.setForeground(ColorImpl.getSystemColor(SWT.COLOR_WHITE));

1144

fZoomValue = fPrinterZoom * lastZoom;

1145

context.drawText(currentPageNum, Math.round(fPrinterX + getVisibleWidth() / fPrinterZoom - ii / fPrinterZoom), Math.round(fPrinterY + getVisibleHeight() / fPrinterZoom - jj / fPrinterZoom), false);

1146

fIsPrinting = false;

1147

fZoomValue = lastZoom;

1148

}

1149

1150

/**

1151

* Sets the collapse provider.

1152

1153

* @param provider The collapse provider to set

1154

1155

protected void setCollapseProvider(ISDCollapseProvider provider) {

1156

fCollapseProvider = provider;

1157

}

1158

1159

1160

/**

1161

* Checks for focus of children.

1162

1163

* @param children Control to check

1164

* @return true if child is on focus else false

1165

1166

protected boolean checkFocusOnChilds(Control children) {

1167

if (children instanceof Composite) {

1168

Control[] child = ((Composite) children).getChildren();

1169

for (int i = 0; i < child.length; i++) {

1170

if (child[i].isFocusControl()) {

1171

return true;

1172

} else {

1173

checkFocusOnChilds(child[i]);

1174

}

1175

}

1176

}

1177

return false;

1178

}

1179

1180

/**

1181

* A post action for a tooltip (before displaying).

1182

1183

* @param accessible true if accessible else false

1184

* @return the tooltip text.

1185

1186

protected String getPostfixForTooltip(boolean accessible) {

1187

StringBuffer postfix = new StringBuffer();

1188

// String postfix = "";//$NON-NLS-1$

1189

// Determine if the tooltip must show the time difference between the current mouse position and

1190

// the last selected graphNode

1191

if ((fCurrentGraphNode != null) &&

1192

(fCurrentGraphNode instanceof ITimeRange) &&

1193

(fToolTipNode instanceof ITimeRange) &&

1194

(fCurrentGraphNode != fToolTipNode) &&

1195

((ITimeRange) fToolTipNode).hasTimeInfo() &&

1196

((ITimeRange) fCurrentGraphNode).hasTimeInfo()) {

1197

postfix.append(" -> "); //$NON-NLS-1$

1198

postfix.append(fCurrentGraphNode.getName());

1199

postfix.append("\n"); //$NON-NLS-1$

1200

postfix.append(SDMessages._138);

1201

postfix.append(" "); //$NON-NLS-1$

1202

1203

// postfix = " -> " + fCurrentGraphNode.getName() + "\n" + SDMessages._138 + " "; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

1204

1205

//double delta = ((ITimeRange)toolTipNode).getLastTime()-((ITimeRange)currentGraphNode).getLastTime();

1206

ITmfTimestamp firstTime = ((ITimeRange) fCurrentGraphNode).getEndTime();

1207

ITmfTimestamp lastTime = ((ITimeRange) fToolTipNode).getEndTime();

1208

TmfTimestamp delta = (TmfTimestamp) lastTime.getDelta(firstTime);

1209

postfix.append(delta.toString());

1210

1211

// postfix += delta.toString();

1212

} else {

1213

if ((fToolTipNode instanceof ITimeRange) && ((ITimeRange) fToolTipNode).hasTimeInfo()) {

1214

postfix.append("\n"); //$NON-NLS-1$

1215

// postfix = "\n";//$NON-NLS-1$

1216

ITmfTimestamp firstTime = ((ITimeRange) fToolTipNode).getStartTime();

1217

ITmfTimestamp lastTime = ((ITimeRange) fToolTipNode).getEndTime();

1218

1219

if (firstTime != null) {

1220

if (lastTime != null && firstTime.compareTo(lastTime, true) != 0) {

1221

postfix.append("start: "); //$NON-NLS-1$

1222

postfix.append(firstTime.toString());

1223

postfix.append("\n"); //$NON-NLS-1$

1224

postfix.append("end: "); //$NON-NLS-1$

1225

postfix.append(lastTime.toString());

1226

postfix.append("\n"); //$NON-NLS-1$

1227

// postfix += "start: " + firstTime + "\n"; //$NON-NLS-1$ //$NON-NLS-2$

1228

// postfix += "end: " + lastTime + "\n"; //$NON-NLS-1$ //$NON-NLS-2$

1229

} else {

1230

postfix.append(firstTime.toString());

1231

// postfix += firstTime.toString();

1232

}

1233

}

1234

else if (lastTime != null) {

1235

postfix.append(lastTime.toString());

1236

// postfix += lastTime.toString();

1237

}

1238

}

1239

}

1240

return postfix.toString();

1241

}

1242

1243

/**

1244

* Sets a new focused widget.

1245

1246

* @param newFocusShape A new focus shape.

1247

1248

protected void setFocus(int newFocusShape) {

1249

fFocusedWidget = newFocusShape;

1250

if (fFocusedWidget == -1) {

1251

getViewControl().getAccessible().setFocus(ACC.CHILDID_SELF);

1252

} else {

1253

getViewControl().getAccessible().setFocus(fFocusedWidget);

1254

}

1255

}

1256

1257

/**

1258

* Highlight the given GraphNode<br>

1259

* The GraphNode is then displayed using the system default selection color

1260

1261

* @param node the GraphNode to highlight

1262

1263

protected void performSelection(GraphNode node) {

1264

if ((fCtrlSelection) || (fShiftSelection)) {

1265

if (node != null) {

1266

if (fSelectedNodeList.contains(node)) {

1267

removeSelection(node);

1268

} else {

1269

addSelection(node);

1270

}

1271

} else {

1272

return;

1273

}

1274

} else {

1275

clearSelection();

1276

if (node != null) {

1277

addSelection(node);

1278

}

1279

}

1280

}

1281

1282

/**

1283

* Returns a draw buffer image.

1284

1285

* @return a Image containing the draw buffer.

1286

1287

protected Image getDrawBuffer() {

1288

1289

update();

1290

Rectangle area = getClientArea();

1291

Image dbuffer = null;

1292

GC gcim = null;

1293

1294

try {

1295

dbuffer = new Image(getDisplay(), area.width, area.height);

1296

} catch (Exception e) {

1297

Activator.getDefault().logError("Error creating image", e); //$NON-NLS-1$

1298

}

1299

1300

gcim = new GC(dbuffer);

1301

1302

NGC context = new NGC(this, gcim);

1303

1304

// Set the metrics to use for lifeline text and message text

1305

// using the Graphical Context

1306

Metrics.setLifelineFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE)));

1307

Metrics.setLifelineFontWidth(context.getFontWidth(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE)));

1308

Metrics.setLifelineWidth(SDViewPref.getInstance().getLifelineWidth());

1309

Metrics.setFrameFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_FRAME_NAME)));

1310

Metrics.setLifelineHeaderFontHeight(context.getFontHeight(SDViewPref.getInstance().getFont(ISDPreferences.PREF_LIFELINE_HEADER)));

1311

1312

int syncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_SYNC_MESS));

1313

int syncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_SYNC_MESS_RET));

1314

int asyncMessFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_ASYNC_MESS));

1315

int asyncMessRetFontH = context.getFontHeight(SDViewPref.getInstance().getFont(SDViewPref.PREF_ASYNC_MESS_RET));

1316

1317

int messageFontHeight = 0;

1318

if (syncMessFontH > syncMessRetFontH) {

1319

messageFontHeight = syncMessFontH;

1320

} else {

1321

messageFontHeight = syncMessRetFontH;

1322

}

1323

if (messageFontHeight < asyncMessFontH) {

1324

messageFontHeight = asyncMessFontH;

1325

}

1326

if (messageFontHeight < asyncMessRetFontH) {

1327

messageFontHeight = asyncMessRetFontH;

1328

}

1329

Metrics.setMessageFontHeight(messageFontHeight);

1330

context.setFont(SDViewPref.getInstance().getFont(SDViewPref.PREF_LIFELINE));

1331

1332

int width = (int) ((fFrame.getWidth() + 2 * Metrics.FRAME_H_MARGIN) * fZoomValue);

1333

int height = (int) ((fFrame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);

1334

1335

resizeContents(width, height);

1336

1337

context.setBackground(SDViewPref.getInstance().getBackGroundColor(ISDPreferences.PREF_FRAME));

1338

context.fillRectangle(0, 0, getContentsWidth(), Metrics.FRAME_V_MARGIN);

1339

context.fillRectangle(0, 0, fFrame.getX(), getContentsHeight());

1340

context.fillRectangle(fFrame.getX() + fFrame.getWidth() + 1, 0, getContentsWidth() - (fFrame.getX() + fFrame.getWidth() + 1), getContentsHeight());

1341

context.fillRectangle(0, fFrame.getY() + fFrame.getHeight() + 1, getContentsWidth(), getContentsHeight() - (fFrame.getY() + fFrame.getHeight() + 1));

1342

gcim.setLineWidth(1);

1343

1344

fFrame.draw(context);

1345

if (fDragAndDrop != null) {

1346

Lifeline node = (Lifeline) fDragAndDrop;

1347

boolean isSelected = fDragAndDrop.isSelected();

1348

boolean hasFocus = fDragAndDrop.hasFocus();

1349

node.setSelected(false);

1350

node.setFocused(false);

1351

node.draw(context, fDragX, fDragY);

1352

node.setSelected(isSelected);

1353

node.setFocused(hasFocus);

1354

}

1355

gcim.dispose();

1356

context.dispose();

1357

return dbuffer;

1358

}

1359

1360

1361

* (non-Javadoc)

1362

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#keyPressedEvent(org.eclipse.swt.events.KeyEvent)

1363

1364

@Override

1365

protected void keyPressedEvent(KeyEvent event) {

1366

if (!(isFocusControl() || getViewControl().isFocusControl())) {

1367

Control[] child = getParent().getChildren();

1368

for (int i = 0; i < child.length; i++) {

1369

if ((child[i].isFocusControl())&& (!(child[i] instanceof ScrollView))) {

1370

getViewControl().setFocus();

1371

break;

1372

}

1373

}

1374

}

1375

setFocus(-1);

1376

1377

if (event.keyCode == SWT.CTRL) {

1378

fCtrlSelection = true;

1379

}

1380

if (event.keyCode == SWT.SHIFT) {

1381

fShiftSelection = true;

1382

fPrevList = new ArrayList<GraphNode>();

1383

fPrevList.addAll(getSelection());

1384

}

1385

1386

GraphNode prevNode = getFocusNode();

1387

1388

if (event.keyCode == SWT.ARROW_RIGHT) {

1389

traverseRight();

1390

}

1391

1392

if (event.keyCode == SWT.ARROW_LEFT) {

1393

traverseLeft();

1394

}

1395

1396

if (event.keyCode == SWT.ARROW_DOWN) {

1397

traverseDown();

1398

}

1399

1400

if (event.keyCode == SWT.ARROW_UP) {

1401

traverseUp();

1402

}

1403

1404

if (event.keyCode == SWT.HOME) {

1405

traverseHome();

1406

}

1407

1408

if (event.keyCode == SWT.END) {

1409

traverseEnd();

1410

}

1411

1412

if ((!fShiftSelection) && (!fCtrlSelection)) {

1413

fListStart = fCurrentGraphNode;

1414

}

1415

1416

if (event.character == ' ') {

1417

performSelection(fCurrentGraphNode);

1418

if (!fShiftSelection) {

1419

fListStart = fCurrentGraphNode;

1420

}

1421

}

1422

1423

if ((fShiftSelection) && (prevNode != getFocusNode())) {

1424

clearSelection();

1425

addSelection(fPrevList);

1426

addSelection(fFrame.getNodeList(fListStart, getFocusNode()));

1427

if (getFocusNode() instanceof Lifeline) {

1428

ensureVisible(getFocusNode().getX(), getFocusNode().getY(), getFocusNode().getWidth(), getFocusNode().getHeight(), SWT.CENTER | SWT.VERTICAL, true);

1429

} else {

1430

ensureVisible(getFocusNode());

1431

}

1432

} else if ((!fCtrlSelection) && (!fShiftSelection)) {

1433

1434

clearSelection();

1435

if (getFocusNode() != null) {

1436

addSelection(getFocusNode());

1437

1438

if (getFocusNode() instanceof Lifeline) {

1439

ensureVisible(getFocusNode().getX(), getFocusNode().getY(), getFocusNode().getWidth(), getFocusNode().getHeight(), SWT.CENTER | SWT.VERTICAL, true);

1440

} else {

1441

ensureVisible(getFocusNode());

1442

}

1443

}

1444

}

1445

1446

if (fCurrentGraphNode != null) {

1447

fCurrentGraphNode.setFocused(true);

1448

}

1449

redraw();

1450

1451

if ((event.character == ' ') && ((fZoomInMode) || (fZoomOutMode))) {

1452

int cx = Math.round((getContentsX() + getVisibleWidth() / 2) / fZoomValue);

1453

int cy = Math.round((getContentsY() + getVisibleHeight() / 2) / fZoomValue);

1454

if (fZoomInMode) {

1455

if (fZoomValue < 64) {

1456

fZoomValue = fZoomValue * (float) 1.25;

1457

}

1458

} else {

1459

fZoomValue = fZoomValue / (float) 1.25;

1460

}

1461

int x = Math.round(cx * fZoomValue - getVisibleWidth() / (float) 2);

1462

int y = Math.round(cy * fZoomValue - getVisibleHeight() / (float) 2);

1463

setContentsPos(x, y);

1464

if (fTimeBar != null) {

1465

fTimeBar.setZoom(fZoomValue);

1466

}

1467

// redraw also resize the scrollView content

1468

redraw();

1469

}

1470

}

1471

1472

1473

* (non-Javadoc)

1474

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#keyReleasedEvent(org.eclipse.swt.events.KeyEvent)

1475

1476

@Override

1477

protected void keyReleasedEvent(KeyEvent event) {

1478

setFocus(-1);

1479

if (event.keyCode == SWT.CTRL) {

1480

fCtrlSelection = false;

1481

}

1482

if (event.keyCode == SWT.SHIFT) {

1483

fShiftSelection = false;

1484

}

1485

super.keyReleasedEvent(event);

1486

setFocus(1);

1487

}

1488

1489

1490

* (non-Javadoc)

1491

* @see org.eclipse.swt.widgets.Control#isFocusControl()

1492

1493

@Override

1494

public boolean isFocusControl() {

1495

Control[] child = getChildren();

1496

for (int i = 0; i < child.length; i++) {

1497

if (child[i].isFocusControl()) {

1498

return true;

1499

} else {

1500

checkFocusOnChilds(child[i]);

1501

}

1502

}

1503

return false;

1504

}

1505

1506

1507

* (non-Javadoc)

1508

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#setContentsPos(int, int)

1509

1510

@Override

1511

public boolean setContentsPos(int x, int y) {

1512

int localX = x;

1513

int localY = y;

1514

1515

if (localX < 0) {

1516

localX = 0;

1517

}

1518

if (localY < 0) {

1519

localY = 0;

1520

}

1521

if (fFrame == null) {

1522

return false;

1523

}

1524

if (localX + getVisibleWidth() > getContentsWidth()) {

1525

localX = getContentsWidth() - getVisibleWidth();

1526

}

1527

if (localY + getVisibleHeight() > getContentsHeight()) {

1528

localY = getContentsHeight() - getVisibleHeight();

1529

}

1530

int x1 = Math.round(localX / fZoomValue);

1531

int y2 = Math.round(localY / fZoomValue);

1532

int width = Math.round(getVisibleWidth() / fZoomValue);

1533

int height = Math.round(getVisibleHeight() / fZoomValue);

1534

fFrame.updateIndex(x1, y2, width, height);

1535

1536

if (fInsertionCartet != null && fInsertionCartet.isVisible()) {

1537

fInsertionCartet.setVisible(false);

1538

}

1539

1540

return super.setContentsPos(localX, localY);

1541

}

1542

1543

1544

* (non-Javadoc)

1545

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#contentsMouseHover(org.eclipse.swt.events.MouseEvent)

1546

1547

@Override

1548

protected void contentsMouseHover(MouseEvent event) {

1549

GraphNode graphNode = null;

1550

if (fFrame != null) {

1551

int x = Math.round(event.x / fZoomValue);

1552

int y = Math.round(event.y / fZoomValue);

1553

graphNode = fFrame.getNodeAt(x, y);

1554

if ((graphNode != null) && (SDViewPref.getInstance().tooltipEnabled())) {

1555

fToolTipNode = graphNode;

1556

String postfix = getPostfixForTooltip(true);

1557

if (graphNode instanceof Lifeline) {

1558

Lifeline lifeline = (Lifeline) graphNode;

1559

fToolTip.showToolTip(lifeline.getToolTipText() + postfix);

1560

setFocus(0);

1561

} else {

1562

fToolTip.showToolTip(graphNode.getName() + postfix);

1563

setFocus(0);

1564

}

1565

} else {

1566

fToolTip.hideToolTip();

1567

}

1568

}

1569

}

1570

1571

1572

* (non-Javadoc)

1573

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#contentsMouseMoveEvent(org.eclipse.swt.events.MouseEvent)

1574

1575

@Override

1576

protected void contentsMouseMoveEvent(MouseEvent e) {

1577

fScrollToolTip.hideToolTip();

1578

fToolTip.hideToolTip();

1579

// super.contentsMouseMoveEvent(e);

1580

if (!(isFocusControl() || getViewControl().isFocusControl())) {

1581

Control[] child = getParent().getChildren();

1582

for (int i = 0; i < child.length; i++) {

1583

if ((child[i].isFocusControl()) && (!(child[i] instanceof ScrollView))) {

1584

getViewControl().setFocus();

1585

break;

1586

}

1587

}

1588

}

1589

setFocus(-1);

1590

1591

if (((e.stateMask & SWT.BUTTON_MASK) != 0) && ((fDragAndDrop != null) || fIsDragAndDrop) && (fReorderMode || fCollapseProvider != null)) {

1592

fIsDragAndDrop = false;

1593

if (fCurrentGraphNode instanceof Lifeline) {

1594

fDragAndDrop = (Lifeline) fCurrentGraphNode;

1595

}

1596

if (fDragAndDrop != null) {

1597

int dx = 0;

1598

int dy = 0;

1599

if (e.x > getContentsX() + getVisibleWidth()) {

1600

dx = e.x - (getContentsX() + getVisibleWidth());

1601

} else if (e.x < getContentsX()) {

1602

dx = -getContentsX() + e.x;

1603

}

1604

if (e.y > getContentsY() + getVisibleHeight()) {

1605

dy = e.y - (getContentsY() + getVisibleHeight());

1606

} else if (e.y < getContentsY()) {

1607

dy = -getContentsY() + e.y;

1608

}

1609

fDragX = e.x;

1610

fDragY = e.y;

1611

if (dx != 0 || dy != 0) {

1612

if (fLocalAutoScroll == null) {

1613

if (fLocalAutoScrollTimer == null) {

1614

fLocalAutoScrollTimer = new Timer(true);

1615

}

1616

fLocalAutoScroll = new AutoScroll(this, dx, dy);

1617

fLocalAutoScrollTimer.schedule(fLocalAutoScroll, 0, 75);

1618

} else {

1619

fLocalAutoScroll.fDeltaX = dx;

1620

fLocalAutoScroll.fDeltaY = dy;

1621

}

1622

} else if (fLocalAutoScroll != null) {

1623

fLocalAutoScroll.cancel();

1624

fLocalAutoScroll = null;

1625

}

1626

fDragX = Math.round(e.x / fZoomValue);

1627

fDragY = Math.round(e.y / fZoomValue);

1628

redraw();

1629

Lifeline node = fFrame.getCloserLifeline(fDragX);

1630

if ((node != null) && (node != fDragAndDrop)) {

1631

int y = 0;

1632

int y1 = 0;

1633

int height = Metrics.getLifelineHeaderFontHeigth() + 2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN;

1634

int hMargin = Metrics.LIFELINE_VT_MAGIN / 4;

1635

int x = node.getX();

1636

int width = node.getWidth();

1637

if (fFrame.getVisibleAreaY() < node.getY() + node.getHeight() - height - hMargin) {

1638

y = contentsToViewY(Math.round((node.getY() + node.getHeight()) * fZoomValue));

1639

} else {

1640

y = Math.round(height * fZoomValue);

1641

}

1642

1643

if (fFrame.getVisibleAreaY() < contentsToViewY(node.getY() - hMargin)) {

1644

y1 = contentsToViewY(Math.round((node.getY() - hMargin) * fZoomValue));

1645

} else {

1646

y1 = Math.round(height * fZoomValue);

1647

}

1648

1649

int rx = Math.round(x * fZoomValue);

1650

1651

fInsertionCartet.setVisible(true);

1652

if ((fInsertionCartet.getImage() != null) && (!fInsertionCartet.getImage().isDisposed())) {

1653

fInsertionCartet.getImage().dispose();

1654

}

1655

if (rx <= e.x && Math.round(rx + (width * fZoomValue)) >= e.x) {

1656

if (fCollapseProvider != null) {

1657

ImageData data = fCollapaseCaretImg.getImageData();

1658

data = data.scaledTo(Math.round(fCollapaseCaretImg.getBounds().width * fZoomValue), Math.round(fCollapaseCaretImg.getBounds().height * fZoomValue));

1659

fCurrentCaretImage = new Image(Display.getCurrent(), data);

1660

fInsertionCartet.setImage(fCurrentCaretImage);

1661

fInsertionCartet.setLocation(contentsToViewX(rx + Math.round((width / (float) 2) * fZoomValue)) - fCurrentCaretImage.getBounds().width / 2, y);

1662

}

1663

} else if (fReorderMode) {

1664

if (rx > e.x) {

1665

if (node.getIndex() > 1 && fFrame.getLifeline(node.getIndex() - 2) == fDragAndDrop) {

1666

return;

1667

}

1668

ImageData data = fArrowUpCaretImg.getImageData();

1669

data = data.scaledTo(Math.round(fArrowUpCaretImg.getBounds().width * fZoomValue), Math.round(fArrowUpCaretImg.getBounds().height * fZoomValue));

1670

fCurrentCaretImage = new Image(Display.getCurrent(), data);

1671

fInsertionCartet.setImage(fCurrentCaretImage);

1672

fInsertionCartet.setLocation(contentsToViewX(Math.round((x - Metrics.LIFELINE_SPACING / 2) * fZoomValue)) - fCurrentCaretImage.getBounds().width / 2, y1);

1673

} else {

1674

if (node.getIndex() < fFrame.lifeLinesCount() && fFrame.getLifeline(node.getIndex()) == fDragAndDrop) {

1675

return;

1676

}

1677

ImageData data = fArrowUpCaretImg.getImageData();

1678

data = data.scaledTo(Math.round(fArrowUpCaretImg.getBounds().width * fZoomValue), Math.round(fArrowUpCaretImg.getBounds().height * fZoomValue));

1679

fCurrentCaretImage = new Image(Display.getCurrent(), data);

1680

fInsertionCartet.setImage(fCurrentCaretImage);

1681

fInsertionCartet.setLocation(contentsToViewX(Math.round((x + width + Metrics.LIFELINE_SPACING / 2) * fZoomValue)) - fCurrentCaretImage.getBounds().width / 2 + 1, y1);

1682

}

1683

}

1684

} else {

1685

fInsertionCartet.setVisible(false);

1686

}

1687

}

1688

} else {

1689

super.contentsMouseMoveEvent(e);

1690

}

1691

}

1692

1693

1694

* (non-Javadoc)

1695

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#contentsMouseUpEvent(org.eclipse.swt.events.MouseEvent)

1696

1697

@Override

1698

protected void contentsMouseUpEvent(MouseEvent event) {

1699

// Just in case the diagram highlight a time compression region

1700

// this region need to be released when clicking everywhere

1701

fInsertionCartet.setVisible(false);

1702

if (fDragAndDrop != null) {

1703

if ((fOverView != null) && (!fOverView.isDisposed())) {

1704

fOverView.dispose();

1705

}

1706

fOverView = null;

1707

Lifeline node = fFrame.getCloserLifeline(fDragX);

1708

if (node != null) {

1709

int rx = Math.round(node.getX() * fZoomValue);

1710

if (rx <= event.x && Math.round(rx + (node.getWidth() * fZoomValue)) >= event.x) {

1711

if ((fCollapseProvider != null) && (fDragAndDrop != node)) {

1712

fCollapseProvider.collapseTwoLifelines((Lifeline) fDragAndDrop, node);

1713

}

1714

} else if (rx < event.x) {

1715

fFrame.insertLifelineAfter((Lifeline) fDragAndDrop, node);

1716

if (node.getIndex() < fFrame.lifeLinesCount()) {

1717

Lifeline temp[] = { (Lifeline) fDragAndDrop, fFrame.getLifeline(node.getIndex()) };

1718

fReorderList.add(temp);

1719

} else {

1720

Lifeline temp[] = { (Lifeline) fDragAndDrop, null };

1721

fReorderList.add(temp);

1722

}

1723

} else {

1724

fFrame.insertLifelineBefore((Lifeline) fDragAndDrop, node);

1725

Lifeline temp[] = { (Lifeline) fDragAndDrop, node };

1726

fReorderList.add(temp);

1727

}

1728

}

1729

}

1730

fDragAndDrop = null;

1731

redraw();

1732

if (fFrame == null) {

1733

return;

1734

}

1735

fFrame.resetTimeCompression();

1736

1737

// reset auto scroll if it's engaged

1738

if (fLocalAutoScroll != null) {

1739

fLocalAutoScroll.cancel();

1740

fLocalAutoScroll = null;

1741

}

1742

super.contentsMouseUpEvent(event);

1743

}

1744

1745

1746

* (non-Javadoc)

1747

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#contentsMouseDownEvent(org.eclipse.swt.events.MouseEvent)

1748

1749

@Override

1750

protected void contentsMouseDownEvent(MouseEvent event) {

1751

if (fCurrentGraphNode != null) {

1752

fCurrentGraphNode.setFocused(false);

1753

}

1754

1755

// Just in case the diagram highlight a time compression region

1756

// this region need to be released when clicking everywhere

1757

if (fFrame == null) {

1758

return;

1759

}

1760

1761

fFrame.resetTimeCompression();

1762

1763

if ((event.stateMask & SWT.CTRL) != 0) {

1764

fCtrlSelection = true;

1765

} else {

1766

fCtrlSelection = false;

1767

}

1768

1769

if (((fZoomInMode) || (fZoomOutMode)) && (event.button == 1)) {

1770

int cx = Math.round(event.x / fZoomValue);

1771

int cy = Math.round(event.y / fZoomValue);

1772

if (fZoomInMode) {

1773

if (fZoomValue < 64) {

1774

fZoomValue = fZoomValue * (float) 1.25;

1775

}

1776

} else {

1777

fZoomValue = fZoomValue / (float) 1.25;

1778

}

1779

int x = Math.round(cx * fZoomValue - getVisibleWidth() / (float) 2);

1780

int y = Math.round(cy * fZoomValue - getVisibleHeight() / (float) 2);

1781

setContentsPos(x, y);

1782

if (fTimeBar != null) {

1783

fTimeBar.setZoom(fZoomValue);

1784

}

1785

// redraw also resize the scrollView content

1786

redraw();

1787

} else {// if (event.button ==1)

1788

GraphNode node = null;

1789

int x = Math.round(event.x / fZoomValue);

1790

int y = Math.round(event.y / fZoomValue);

1791

node = fFrame.getNodeAt(x, y);

1792

1793

if ((event.button == 1) || ((node != null) && !node.isSelected())) {

1794

if (!fShiftSelection) {

1795

fListStart = node;

1796

}

1797

if (fShiftSelection) {

1798

clearSelection();

1799

addSelection(fFrame.getNodeList(fListStart, node));

1800

} else {

1801

performSelection(node);

1802

}

1803

fCurrentGraphNode = node;

1804

if (node != null) {

1805

node.setFocused(true);

1806

}

1807

}

1808

redraw();

1809

}

1810

if (fDragAndDrop == null) {

1811

super.contentsMouseDownEvent(event);

1812

}

1813

fIsDragAndDrop = (event.button == 1);

1814

1815

}

1816

1817

/**

1818

* TimerTask for auto scroll feature.

1819

1820

protected static class AutoScroll extends TimerTask {

1821

/**

1822

* Field delta x.

1823

1824

public int fDeltaX;

1825

/**

1826

* Field delta y.

1827

1828

public int fDeltaY;

1829

/**

1830

* Field sequence diagram reference.

1831

1832

public SDWidget fSdWidget;

1833

1834

/**

1835

* Constructor for AutoScroll.

1836

* @param sv sequence diagram widget reference

1837

* @param dx delta x

1838

* @param dy delta y

1839

1840

public AutoScroll(SDWidget sv, int dx, int dy) {

1841

fSdWidget = sv;

1842

fDeltaX = dx;

1843

fDeltaY = dy;

1844

}

1845

1846

1847

* (non-Javadoc)

1848

* @see java.util.TimerTask#run()

1849

1850

@Override

1851

public void run() {

1852

Display.getDefault().asyncExec(new Runnable() {

1853

@Override

1854

public void run() {

1855

if (fSdWidget.isDisposed()) {

1856

return;

1857

}

1858

fSdWidget.fDragX += fDeltaX;

1859

fSdWidget.fDragY += fDeltaY;

1860

fSdWidget.scrollBy(fDeltaX, fDeltaY);

1861

}

1862

});

1863

}

1864

}

1865

1866

1867

* (non-Javadoc)

1868

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#drawContents(org.eclipse.swt.graphics.GC, int, int, int, int)

1869

1870

@Override

1871

protected void drawContents(GC gc, int clipx, int clipy, int clipw, int cliph) {

1872

if (fFrame == null) {

1873

gc.setBackground(getDisplay().getSystemColor(SWT.COLOR_WHITE));

1874

gc.fillRectangle(0, 0, getVisibleWidth(), getVisibleHeight());

1875

gc.dispose();

1876

return;

1877

} else {

1878

// Frame.setUserPref(SDViewPref.getInstance());

1879

SDViewPref.getInstance();

1880

}

1881

1882

Rectangle area = getClientArea();

1883

Image dbuffer = getDrawBuffer();

1884

int height = Math.round((fFrame.getHeight() + 2 * Metrics.FRAME_V_MARGIN) * fZoomValue);

1885

1886

try {

1887

gc.drawImage(dbuffer, 0, 0, area.width, area.height, 0, 0, area.width, area.height);

1888

} catch (Exception e) {

1889

Activator.getDefault().logError("Error drawin content", e); //$NON-NLS-1$

1890

}

1891

dbuffer.dispose();

1892

setHScrollBarIncrement(Math.round(SDViewPref.getInstance().getLifelineWidth() / (float) 2 * fZoomValue));

1893

setVScrollBarIncrement(Math.round(Metrics.getMessagesSpacing() * fZoomValue));

1894

if ((fTimeBar != null) && (fFrame.hasTimeInfo())) {

1895

fTimeBar.resizeContents(9, height + getHorizontalBarHeight());

1896

fTimeBar.setContentsPos(getContentsX(), getContentsY());

1897

fTimeBar.redraw();

1898

fTimeBar.update();

1899

}

1900

float xRatio = getContentsWidth() / (float) getVisibleWidth();

1901

float yRatio = getContentsHeight() / (float) getVisibleHeight();

1902

if (yRatio > xRatio) {

1903

setOverviewSize((int) (getVisibleHeight() * 0.75));

1904

} else {

1905

setOverviewSize((int) (getVisibleWidth() * 0.75));

1906

}

1907

}

1908

1909

1910

* (non-Javadoc)

1911

* @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)

1912

1913

@Override

1914

public void widgetDefaultSelected(SelectionEvent event) {

1915

}

1916

1917

1918

* (non-Javadoc)

1919

* @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)

1920

1921

@Override

1922

public void widgetSelected(SelectionEvent event) {

1923

if (event.widget == fZoomIn) {

1924

fZoomValue = fZoomValue * 2;

1925

} else if (event.widget == fZoomOut) {

1926

fZoomValue = fZoomValue / 2;

1927

}

1928

redraw();

1929

}

1930

1931

1932

* Called when property changed occurs in the preference page. "PREFOK" is fired when the user press the ok or apply button

1933

1934

* (non-Javadoc)

1935

* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)

1936

1937

@Override

1938

public void propertyChange(PropertyChangeEvent e) {

1939

if (fFrame != null && !isDisposed()) {

1940

fFrame.resetTimeCompression();

1941

}

1942

if (e.getProperty().equals("PREFOK")) //$NON-NLS-1$

1943

{

1944

// Prepare the overview to be reused for the new

1945

// settings (especially the colors)

1946

if (fOverView != null) {

1947

fOverView.dispose();

1948

}

1949

fOverView = null;

1950

redraw();

1951

}

1952

}

1953

1954

1955

* (non-Javadoc)

1956

* @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)

1957

1958

@Override

1959

public void widgetDisposed(DisposeEvent e) {

1960

if (fOverView != null) {

1961

fOverView.dispose();

1962

}

1963

super.removeDisposeListener(this);

1964

if ((fCurrentCaretImage != null) && (!fCurrentCaretImage.isDisposed())) {

1965

fCurrentCaretImage.dispose();

1966

}

1967

if ((fArrowUpCaretImg != null) && (!fArrowUpCaretImg.isDisposed())) {

1968

fArrowUpCaretImg.dispose();

1969

}

1970

if ((fCollapaseCaretImg != null) && (!fCollapaseCaretImg.isDisposed())) {

1971

fCollapaseCaretImg.dispose();

1972

}

1973

SDViewPref.getInstance().removePropertyChangeListener(this);

1974

LoadersManager lm = LoadersManager.getInstance();

1975

if (fSite instanceof SDView) {

1976

((SDView) fSite).resetProviders();

1977

if (lm != null) {

1978

lm.resetLoader(((SDView) fSite).getViewSite().getId());

1979

}

1980

}

1981

}

1982

1983

1984

* (non-Javadoc)

1985

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#drawOverview(org.eclipse.swt.graphics.GC, org.eclipse.swt.graphics.Rectangle)

1986

1987

@Override

1988

protected void drawOverview(GC gc, Rectangle r) {

1989

float oldzoom = fZoomValue;

1990

if (getContentsWidth() > getContentsHeight()) {

1991

fZoomValue = (float) r.width / (float) getContentsWidth() * oldzoom;

1992

} else {

1993

fZoomValue = (float) r.height / (float) getContentsHeight() * oldzoom;

1994

}

1995

if ((fOverView != null) && ((r.width != fOverView.getBounds().width) || (r.height != fOverView.getBounds().height))) {

1996

fOverView.dispose();

1997

fOverView = null;

1998

}

1999

if (fOverView == null) {

2000

int backX = getContentsX();

2001

int backY = getContentsY();

2002

setContentsPos(0, 0);

2003

fOverView = new Image(getDisplay(), r.width, r.height);

2004

GC gcim = new GC(fOverView);

2005

NGC context = new NGC(this, gcim);

2006

context.setBackground(SDViewPref.getInstance().getBackGroundColor(SDViewPref.PREF_FRAME));

2007

fFrame.draw(context);

2008

setContentsPos(backX, backY);

2009

gcim.dispose();

2010

context.dispose();

2011

}

2012

if ((fOverView != null) && (r.width == fOverView.getBounds().width) && (r.height == fOverView.getBounds().height)) {

2013

gc.drawImage(fOverView, 0, 0, r.width, r.height, 0, 0, r.width, r.height);

2014

}

2015

2016

fZoomValue = oldzoom;

2017

2018

super.drawOverview(gc, r);

2019

}

2020

2021

2022

* (non-Javadoc)

2023

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ITimeCompressionListener#deltaSelected(org.eclipse.linuxtools.tmf.ui.views.uml2sd.core.Lifeline, int, int, org.eclipse.linuxtools.tmf.ui.views.uml2sd.drawings.IColor)

2024

2025

@Override

2026

public void deltaSelected(Lifeline lifeline, int startEvent, int nbEvent, IColor color) {

2027

fFrame.highlightTimeCompression(lifeline, startEvent, nbEvent, color);

2028

ensureVisible(lifeline);

2029

int y1 = lifeline.getY() + lifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * startEvent;

2030

int y2 = lifeline.getY() + lifeline.getHeight() + (Metrics.getMessageFontHeigth() + Metrics.getMessagesSpacing()) * (startEvent + nbEvent);

2031

ensureVisible(lifeline.getX(), y1 - (Metrics.getLifelineHeaderFontHeigth() + +2 * Metrics.LIFELINE_HEARDER_TEXT_V_MARGIN), lifeline.getWidth(), y2 - y1 + 3, SWT.CENTER | SWT.VERTICAL, true);

2032

redraw();

2033

update();

2034

}

2035

2036

2037

* (non-Javadoc)

2038

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#getVisibleWidth()

2039

2040

@Override

2041

public int getVisibleWidth() {

2042

if (fIsPrinting) {

2043

return fPrinter.getClientArea().width;

2044

}

2045

return super.getVisibleWidth();

2046

}

2047

2048

2049

* (non-Javadoc)

2050

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#getVisibleHeight()

2051

2052

@Override

2053

public int getVisibleHeight() {

2054

if (fIsPrinting) {

2055

return fPrinter.getClientArea().height;

2056

}

2057

return super.getVisibleHeight();

2058

}

2059

2060

2061

* (non-Javadoc)

2062

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#contentsToViewX(int)

2063

2064

@Override

2065

public int contentsToViewX(int x) {

2066

if (fIsPrinting) {

2067

int v = Math.round(fPrinterX * fPrinterZoom);

2068

return x - v;

2069

}

2070

return x - getContentsX();

2071

}

2072

2073

2074

* (non-Javadoc)

2075

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#contentsToViewY(int)

2076

2077

@Override

2078

public int contentsToViewY(int y) {

2079

if (fIsPrinting) {

2080

int v = Math.round(fPrinterY * fPrinterZoom);

2081

return y - v;

2082

}

2083

return y - getContentsY();

2084

}

2085

2086

2087

* (non-Javadoc)

2088

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#getContentsX()

2089

2090

@Override

2091

public int getContentsX() {

2092

if (fIsPrinting) {

2093

return Math.round(fPrinterX * fPrinterZoom);

2094

}

2095

return super.getContentsX();

2096

2097

}

2098

2099

2100

* (non-Javadoc)

2101

* @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#getContentsY()

2102

2103

@Override

2104

public int getContentsY() {

2105

if (fIsPrinting) {

2106

return Math.round(fPrinterY * fPrinterZoom);

2107

}

2108

return super.getContentsY();

2109

}

2110

2111

/**

2112

* Traverse Listener implementation.

2113

2114

protected static class LocalTraverseListener implements TraverseListener {

2115

2116

2117

* (non-Javadoc)

2118

* @see org.eclipse.swt.events.TraverseListener#keyTraversed(org.eclipse.swt.events.TraverseEvent)

2119

2120

@Override

2121

public void keyTraversed(TraverseEvent e) {

2122

if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {

2123

e.doit = true;

2124

}

2125

}

2126

}

2127

2128

}

Older »