org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/uml2sd/dialogs/SDPrintDialogUI.java

   1 /**********************************************************************
   2  * Copyright (c) 2005, 2008 IBM Corporation and others.
   3  * Copyright (c) 2011, 2012 Ericsson.
   4  *
   5  * All rights reserved.   This program and the accompanying materials
   6  * are made available under the terms of the Eclipse Public License v1.0
   7  * which accompanies this distribution, and is available at
   8  * http://www.eclipse.org/legal/epl-v10.html
   9  *
  10  * Contributors:
  11  * IBM - Initial API and implementation
  12  * Bernd Hufmann - Updated for TMF
  13  **********************************************************************/
  14 package org.eclipse.linuxtools.tmf.ui.views.uml2sd.dialogs;
  15
  16 import java.text.MessageFormat;
  17 import java.util.Arrays;
  18
  19 import org.eclipse.jface.dialogs.MessageDialog;
  20 import org.eclipse.jface.wizard.WizardPage;
  21 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.GridUtil;
  22 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.DiagramToolTip;
  23 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.NGC;
  24 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget;
  25 import org.eclipse.linuxtools.tmf.ui.views.uml2sd.util.SDMessages;
  26 import org.eclipse.swt.SWT;
  27 import org.eclipse.swt.events.FocusEvent;
  28 import org.eclipse.swt.events.FocusListener;
  29 import org.eclipse.swt.events.KeyEvent;
  30 import org.eclipse.swt.events.ModifyEvent;
  31 import org.eclipse.swt.events.ModifyListener;
  32 import org.eclipse.swt.events.MouseEvent;
  33 import org.eclipse.swt.events.MouseTrackListener;
  34 import org.eclipse.swt.events.SelectionEvent;
  35 import org.eclipse.swt.events.SelectionListener;
  36 import org.eclipse.swt.events.TraverseEvent;
  37 import org.eclipse.swt.events.TraverseListener;
  38 import org.eclipse.swt.graphics.GC;
  39 import org.eclipse.swt.graphics.Image;
  40 import org.eclipse.swt.graphics.ImageData;
  41 import org.eclipse.swt.graphics.RGB;
  42 import org.eclipse.swt.graphics.Rectangle;
  43 import org.eclipse.swt.layout.GridData;
  44 import org.eclipse.swt.layout.GridLayout;
  45 import org.eclipse.swt.printing.PrintDialog;
  46 import org.eclipse.swt.printing.Printer;
  47 import org.eclipse.swt.printing.PrinterData;
  48 import org.eclipse.swt.widgets.Button;
  49 import org.eclipse.swt.widgets.Composite;
  50 import org.eclipse.swt.widgets.Control;
  51 import org.eclipse.swt.widgets.Display;
  52 import org.eclipse.swt.widgets.Group;
  53 import org.eclipse.swt.widgets.Label;
  54 import org.eclipse.swt.widgets.Shell;
  55 import org.eclipse.swt.widgets.Text;
  56
  57 /**
  58  * The class implements the actual print dialog UI for collecting printing data.
  59  *
  60  * @version 1.0
  61  * @author sveyrier
  62  */
  63 public class SDPrintDialogUI {
  64     // ------------------------------------------------------------------------
  65     // Attributes
  66     // ------------------------------------------------------------------------
  67     /**
  68      * The set horizontal pages number.
  69      */
  70     protected Button fSetHPagesNumber;
  71     /**
  72      * The set vertical pages number.
  73      */
  74     protected Button fSetVPagesNumber;
  75     /**
  76      * Flag whether to use current zoom or not.
  77      */
  78     protected Button fUseCurrentZoom;
  79     /**
  80      * Flag whether to print all pages or not
  81      */
  82     protected Button fAllPages;
  83     /**
  84      * Flag whether to print current page only
  85      */
  86     protected Button fCurrentPage;
  87     /**
  88      * Button to select a page list.
  89      */
  90     protected Button fPageList;
  91     /**
  92      * Button to select a page range.
  93      */
  94     protected Button fPageRange;
  95     /**
  96      * Text field to enter from page.
  97      */
  98     protected Text fFromPage;
  99     /**
 100      * Text field to enter to page.
 101      */
 102     protected Text fToPage;
 103     /**
 104      *  The sequence diagram widget reference.
 105      */
 106     protected SDWidget fSdView;
 107     /**
 108      * Text field for number of horizontal pages
 109      */
 110     protected Text fHorPagesNum;
 111     /**
 112      * Text field for number of vertical pages
 113      */
 114     protected Text fVertPagesNum;
 115     /**
 116      * Text field for toal number of pages
 117      */
 118     protected Text fTotalPages;
 119     /**
 120      * A modify listener implementation to handle modifications.
 121      */
 122     protected ModifyListener fModifyListener;
 123     /**
 124      * A selection listener implementation to handle selections.
 125      */
 126     protected SelectionListener fSelectionListener;
 127     /**
 128      * Local canvas displaying sequence diagram overview.
 129      */
 130     protected LocalSD fOverviewCanvas;
 131     /**
 132      * Number of pages
 133      */
 134     protected int fNbPages = 0;
 135     /**
 136      * Number of selected pages.
 137      */
 138     protected int fPageNum = -1;
 139     /**
 140      * Number of first page.
 141      */
 142     protected int fFirstPage = -1;
 143     /**
 144      * List of pages to print.
 145      */
 146     protected int fPagesList[];
 147     /**
 148      * Values for dividing sequence diagram into pages.
 149      */
 150     protected float fStepX, fStepY, sTX, sTY;
 151     /**
 152      * Page which to print from.
 153      */
 154     protected int fFrom;
 155     /**
 156      * Page which to print to.
 157      */
 158     protected int fTo;
 159     /**
 160      * Flag for enabling multi-selection.
 161      */
 162     protected boolean fMultiSelection = false;
 163     /**
 164      * Flag for enabling area selection.
 165      */
 166     protected boolean fAreaSelection = false;
 167     /**
 168      * Flag for printing all.
 169      */
 170     protected boolean fPrintAll;
 171     /**
 172      * Flag for printing current page only.
 173      */
 174     protected boolean fPrintCurrent;
 175     /**
 176      * Flag for printing a selection of pages.
 177      */
 178     protected boolean fPrintSelection;
 179     /**
 180      * Flag for printing a range of pages.
 181      */
 182     protected boolean fPrintRange;
 183     /**
 184      * Number of selected rows
 185      */
 186     protected int fNbRows;
 187     /**
 188      * Number of selected lines
 189      */
 190     protected int fNbLines;
 191     /**
 192      * The zoom factor.
 193      */
 194     protected float fZoomFactor;
 195     /**
 196      * The printer data reference.
 197      */
 198     protected PrinterData fPrinterData;
 199     /**
 200      * The diagram tooltip to show if necessary.
 201      */
 202     protected DiagramToolTip fToolTip = null;
 203     /**
 204      * Label for current selection.
 205      */
 206     protected Label fCurrentSelection;
 207     /**
 208      * The shell reference.
 209      */
 210     protected Shell fShell;
 211     /**
 212      * Button to open printer dialog from OS.
 213      */
 214     protected Button fPrinterDialog;
 215     /**
 216      * Flag for showing print button.
 217      */
 218     protected boolean fShowPrintButton;
 219     /**
 220      * Test value
 221      */
 222     protected int fTest = 3;
 223     /**
 224      * Parent wizard page if used as wizard
 225      */
 226     protected WizardPage fParentWizardPage = null;
 227     /**
 228      * Reference to parent print dialog.
 229      */
 230     protected SDPrintDialog fParentDialog = null;
 231
 232     // ------------------------------------------------------------------------
 233     // Helper Class
 234     // ------------------------------------------------------------------------
 235     /**
 236      * Local sequence diagram widget used to display overview of sequence diagram to print.
 237      * @version 1.0
 238      */
 239     protected class LocalSD extends SDWidget {
 240
 241         /**
 242          * Constructor
 243          * @param c Parent composite
 244          * @param s Style bits
 245          */
 246         public LocalSD(Composite c, int s) {
 247             super(c, s);
 248         }
 249
 250         /*
 251          * (non-Javadoc)
 252          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#getContentsHeight()
 253          */
 254         @Override
 255         public int getContentsHeight() {
 256             if (fSdView.getContentsHeight() > fSdView.getContentsHeight()) {
 257                 return (int) (fSdView.getVisibleHeight() / (float) fTest / fSdView.fZoomValue);
 258             }
 259             return (int) (super.getContentsHeight());
 260         }
 261
 262         /*
 263          * (non-Javadoc)
 264          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#getContentsWidth()
 265          */
 266         @Override
 267         public int getContentsWidth() {
 268             if (fSdView.getVisibleWidth() > fSdView.getContentsWidth()) {
 269                 return (int) (fSdView.getVisibleWidth() / (float) fTest / fSdView.fZoomValue);
 270             }
 271             return (int) (super.getContentsWidth());
 272         }
 273
 274         /*
 275          * (non-Javadoc)
 276          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget#contentsMouseHover(org.eclipse.swt.events.MouseEvent)
 277          */
 278         @Override
 279         protected void contentsMouseHover(MouseEvent event) {
 280         }
 281
 282         /**
 283          * Creates page selection images.
 284          *
 285          * @param img - Overview image
 286          * @param width -The width value
 287          * @param stepX - Step X
 288          * @param height - Height value
 289          * @param stepY - Step Y
 290          * @return new image
 291          */
 292         protected Image createPagesSelectionImages(Image img, int width, float stepX, int height, float stepY) {
 293
 294             Image over = new Image(super.getShell().getDisplay(), img.getImageData());
 295
 296             for (int pageIndex = 0; pageIndex < fPagesList.length; pageIndex++) {
 297
 298                 int pageNum = fPagesList[pageIndex];
 299
 300                 if (getPagesForSelection() > 0 && pageNum > 0) {
 301                     int line = pageNum / getNbRow();
 302                     int row = pageNum % getNbRow();
 303                     if (row != 0) {
 304                         line++;
 305                     } else {
 306                         row = getNbRow();
 307                     }
 308
 309                     line--;
 310                     row--;
 311
 312                     Image toDel = over;
 313                     if (fOverviewCanvas.isFocusControl()) {
 314                         over = new Image(super.getShell().getDisplay(), drawRegionSelected(toDel, new Rectangle(contentsToViewX((int) (row * stepX * fOverviewCanvas.fZoomValue)), contentsToViewY((int) (line * stepY * fOverviewCanvas.fZoomValue)),
 315                                 ((int) (stepX * fOverviewCanvas.fZoomValue)), ((int) (stepY * fOverviewCanvas.fZoomValue))), new RGB(0, 0, 128)));
 316                     } else {
 317                         over = new Image(super.getShell().getDisplay(), drawRegionSelected(toDel, new Rectangle(contentsToViewX((int) (row * stepX * fOverviewCanvas.fZoomValue)), contentsToViewY((int) (line * stepY * fOverviewCanvas.fZoomValue)),
 318                                 ((int) (stepX * fOverviewCanvas.fZoomValue)), ((int) (stepY * fOverviewCanvas.fZoomValue))), new RGB(221, 208, 200)));
 319                     }
 320                     toDel.dispose();
 321                 }
 322             }
 323
 324             Arrays.sort(fPagesList);
 325             int pos = Arrays.binarySearch(fPagesList, fPageNum);
 326             if ((pos < 0) && (getPagesForSelection() > 0 && fPageNum > 0)) {
 327                 int line = fPageNum / getNbRow();
 328                 int row = fPageNum % getNbRow();
 329                 if (row != 0) {
 330                     line++;
 331                 } else {
 332                     row = getNbRow();
 333                 }
 334
 335                 line--;
 336                 row--;
 337
 338                 Image toDel = over;
 339                 over = new Image(super.getShell().getDisplay(), drawRegionSelected(toDel, new Rectangle(contentsToViewX((int) (row * stepX * fOverviewCanvas.fZoomValue)), contentsToViewY((int) (line * stepY * fOverviewCanvas.fZoomValue)),
 340                         ((int) (stepX * fOverviewCanvas.fZoomValue)), ((int) (stepY * fOverviewCanvas.fZoomValue))), new RGB(221, 208, 200)));
 341                 toDel.dispose();
 342             }
 343
 344             GC imGC2 = new GC(over);
 345             imGC2.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_BLACK));
 346             NGC imGC = new NGC(fOverviewCanvas, imGC2);
 347             for (int i = 0, x = 0; x <= width && stepX > 0; i++, x = (int) (i * stepX)) {
 348                 imGC.drawLine(x, 0, x, height);
 349             }
 350
 351             for (int j = 0, y = 0; y <= height && stepY > 0; j++, y = (int) (j * stepY)) {
 352                 imGC.drawLine(0, y, width, y);
 353             }
 354
 355             imGC2.dispose();
 356             imGC.dispose();
 357             return over;
 358         }
 359
 360         /*
 361          * (non-Javadoc)
 362          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget#drawContents(org.eclipse.swt.graphics.GC, int, int, int, int)
 363          */
 364         @Override
 365         protected void drawContents(GC gc, int clipx, int clipy, int clipw, int cliph) {
 366
 367             Image dbuffer = getDrawBuffer();
 368             computeStepXY();
 369             Image d;
 370
 371             int lw = (int) (getContentsWidth() / fZoomValue);
 372             if (getContentsWidth() < getVisibleWidth()) {
 373                 lw = (int) (getVisibleWidth() / fZoomValue);
 374             }
 375
 376             int lh = (int) (getContentsHeight() / fZoomValue);
 377             if (getContentsHeight() < getVisibleHeight()) {
 378                 lh = (int) (getVisibleHeight() / fZoomValue);
 379             }
 380             d = createPagesSelectionImages(dbuffer, lw, fStepX, lh, fStepY);
 381
 382             if (!isEnabled()) {
 383                 Image toDel = d;
 384                 d = new Image(super.getShell().getDisplay(), drawRegionSelected(d, new Rectangle(0, 0, lw, lh), new RGB(221, 208, 200)));
 385                 // d, new Rectangle(0,0,((int)(stepX*overviewCanvas.zoomValue)),((int)(
 386                 // stepY*overviewCanvas.zoomValue))),new RGB(221,208,200)));
 387                 toDel.dispose();
 388             }
 389
 390             Rectangle area = getClientArea();
 391             int w = d.getBounds().width;
 392             int h = d.getBounds().height;
 393             gc.drawImage(d, 0, 0, w, h, 0, 0, area.width, area.height);
 394
 395             fTotalPages.setText(Integer.valueOf(maxNumOfPages()).toString());
 396             displayPageNum();
 397             dbuffer.dispose();
 398             d.dispose();
 399             gc.dispose();
 400
 401         }
 402
 403         /*
 404          * (non-Javadoc)
 405          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget#keyPressedEvent(org.eclipse.swt.events.KeyEvent)
 406          */
 407         @Override
 408         protected void keyPressedEvent(KeyEvent e) {
 409             if (e.keyCode == SWT.CTRL) {
 410                 fMultiSelection = true;
 411             }
 412             if (e.keyCode == SWT.SHIFT) {
 413                 fAreaSelection = true;
 414             }
 415             if (e.keyCode == SWT.ARROW_DOWN) {
 416                 if (fPageNum + getNbRow() <= maxNumOfPages()) {
 417                     fPageNum += getNbRow();
 418                 }
 419                 int line = fPageNum / getNbRow();
 420                 int row = fPageNum % getNbRow();
 421                 if (row == 0) {
 422                     line--;
 423                 }
 424                 if ((line + 1) * fStepY > (fOverviewCanvas.getContentsY() + fOverviewCanvas.getVisibleHeight()) / fOverviewCanvas.fZoomValue) {
 425                     fOverviewCanvas.scrollBy(0, (int) (fStepY * fOverviewCanvas.fZoomValue));
 426                 }
 427             }
 428             if (e.keyCode == SWT.ARROW_UP) {
 429                 if (fPageNum - getNbRow() > 0) {
 430                     fPageNum -= getNbRow();
 431                 }
 432                 int line = fPageNum / getNbRow();
 433                 int row = fPageNum % getNbRow();
 434                 if (row == 0) {
 435                     line--;
 436                 }
 437                 if ((line) * fStepY <= fOverviewCanvas.getContentsY() / fOverviewCanvas.fZoomValue) {
 438                     fOverviewCanvas.scrollBy(0, -(int) (fStepY * fOverviewCanvas.fZoomValue));
 439                 }
 440             }
 441             if (e.keyCode == SWT.ARROW_LEFT) {
 442                 if ((fPageNum - 2) / getNbRow() == (fPageNum - 1) / getNbRow() && fPageNum > 1) {
 443                     fPageNum--;
 444                 }
 445                 int row = fPageNum % getNbRow();
 446                 if ((row - 1) * fStepX < (fOverviewCanvas.getContentsX()) / fOverviewCanvas.fZoomValue) {
 447                     fOverviewCanvas.scrollBy(-(int) (fStepX * fOverviewCanvas.fZoomValue), 0);
 448                 }
 449             }
 450             if (e.keyCode == SWT.ARROW_RIGHT) {
 451                 if ((fPageNum - 1) / getNbRow() == fPageNum / getNbRow()) {
 452                     fPageNum++;
 453                 }
 454                 int row = fPageNum % getNbRow();
 455                 if (row == 0) {
 456                     row = getNbRow();
 457                 }
 458                 if ((row) * fStepX > (fOverviewCanvas.getContentsX() + fOverviewCanvas.getVisibleWidth()) / fOverviewCanvas.fZoomValue) {
 459                     fOverviewCanvas.scrollBy((int) (fStepX * fOverviewCanvas.fZoomValue), 0);
 460                 }
 461             }
 462
 463             if (e.keyCode == 32 && fPageNum > -1) {
 464                 Arrays.sort(fPagesList);
 465                 int pos = Arrays.binarySearch(fPagesList, fPageNum);
 466                 if (pos < 0) {
 467                     addToPagesList(fPageNum);
 468                 } else {
 469                     removeFromPagesList(fPageNum);
 470                 }
 471             }
 472
 473             if (!fAreaSelection && !fMultiSelection) {
 474                 fFirstPage = fPageNum;
 475                 fPagesList = new int[1];
 476                 fPagesList[0] = fPageNum;
 477             } else if ((fPageNum != -1) && (fAreaSelection) && (fFirstPage != -1)) {
 478                 fPagesList = new int[0];
 479                 int line1 = fFirstPage / getNbRow();
 480                 int row1 = fFirstPage % getNbRow();
 481                 if (row1 != 0) {
 482                     line1++;
 483                 } else {
 484                     row1 = getNbRow();
 485                 }
 486
 487                 int line2 = fPageNum / getNbRow();
 488                 int row2 = fPageNum % getNbRow();
 489                 if (row2 != 0) {
 490                     line2++;
 491                 } else {
 492                     row2 = getNbRow();
 493                 }
 494
 495                 int temp;
 496                 if (line1 > line2) {
 497                     temp = line2;
 498                     line2 = line1;
 499                     line1 = temp;
 500                 }
 501
 502                 if (row1 > row2) {
 503                     temp = row2;
 504                     row2 = row1;
 505                     row1 = temp;
 506                 }
 507
 508                 for (int i = row1 - 1; i < row2; i++) {
 509                     for (int j = line1 - 1; j < line2; j++) {
 510                         addToPagesList(i + j * getNbRow() + 1);
 511                     }
 512                 }
 513             }
 514             displayPageNum();
 515             fOverviewCanvas.redraw();
 516         }
 517
 518         /*
 519          * (non-Javadoc)
 520          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget#keyReleasedEvent(org.eclipse.swt.events.KeyEvent)
 521          */
 522         @Override
 523         protected void keyReleasedEvent(KeyEvent e) {
 524             if (e.keyCode == SWT.CTRL) {
 525                 fMultiSelection = false;
 526             }
 527             if (e.keyCode == SWT.SHIFT) {
 528                 fAreaSelection = false;
 529             }
 530         }
 531
 532         /*
 533          * (non-Javadoc)
 534          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget#contentsMouseDownEvent(org.eclipse.swt.events.MouseEvent)
 535          */
 536         @Override
 537         protected void contentsMouseDownEvent(MouseEvent event) {
 538
 539             computeStepXY();
 540             int x1 = (int) ((event.x / fOverviewCanvas.fZoomValue) / fStepX);
 541             int x2 = (int) ((event.y / fOverviewCanvas.fZoomValue) / fStepY);
 542
 543             int oldPage = fPageNum;
 544
 545             fPageNum = x1 + x2 * getNbRow() + 1;
 546
 547             if (fPageNum > maxNumOfPages()) {
 548                 fPageNum = oldPage;
 549                 return;
 550             }
 551
 552             if (!fAreaSelection) {
 553                 fFirstPage = fPageNum;
 554             }
 555
 556             if ((fPageNum != -1) && (fMultiSelection)) {
 557                 Arrays.sort(fPagesList);
 558                 int pos = Arrays.binarySearch(fPagesList, fPageNum);
 559                 if (pos < 0) {
 560                     addToPagesList(fPageNum);
 561                 } else {
 562                     removeFromPagesList(fPageNum);
 563                 }
 564             } else if ((fPageNum != -1) && (fAreaSelection) && (fFirstPage != -1)) {
 565
 566                 fPagesList = new int[0];
 567
 568                 int line1 = fFirstPage / getNbRow();
 569                 int row1 = fFirstPage % getNbRow();
 570                 if (row1 != 0) {
 571                     line1++;
 572                 } else {
 573                     row1 = getNbRow();
 574                 }
 575
 576                 int line2 = fPageNum / getNbRow();
 577                 int row2 = fPageNum % getNbRow();
 578                 if (row2 != 0) {
 579                     line2++;
 580                 } else {
 581                     row2 = getNbRow();
 582                 }
 583
 584                 int temp;
 585                 if (line1 > line2) {
 586                     temp = line2;
 587                     line2 = line1;
 588                     line1 = temp;
 589                 }
 590
 591                 if (row1 > row2) {
 592                     temp = row2;
 593                     row2 = row1;
 594                     row1 = temp;
 595                 }
 596
 597                 for (int i = row1 - 1; i < row2; i++) {
 598                     for (int j = line1 - 1; j < line2; j++) {
 599                         addToPagesList(i + j * getNbRow() + 1);
 600                     }
 601                 }
 602             } else {
 603                 fPagesList = new int[1];
 604                 fPagesList[0] = fPageNum;
 605             }
 606             if ((event.stateMask & SWT.CTRL) != 0) {
 607                 fMultiSelection = true;
 608             }
 609             displayPageNum();
 610             redraw();
 611         }
 612
 613         /*
 614          * (non-Javadoc)
 615          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.SDWidget#contentsMouseMoveEvent(org.eclipse.swt.events.MouseEvent)
 616          */
 617         @Override
 618         protected void contentsMouseMoveEvent(MouseEvent e) {
 619             fToolTip.hideToolTip();
 620         }
 621
 622         /*
 623          * (non-Javadoc)
 624          * @see org.eclipse.linuxtools.tmf.ui.views.uml2sd.ScrollView#resizeContents(int, int)
 625          */
 626         @Override
 627         public void resizeContents(int w, int h) {
 628             super.resizeContents(w, h);
 629         }
 630
 631     }
 632
 633     // ------------------------------------------------------------------------
 634     // Constructors
 635     // ------------------------------------------------------------------------
 636     /**
 637      * Constructor
 638      *
 639      * @param shell The shell reference
 640      * @param sdWidget The sequence diagram widget reference
 641      */
 642     public SDPrintDialogUI(Shell shell, SDWidget sdWidget) {
 643         this(shell, sdWidget, false);
 644     }
 645
 646     /**
 647      * Constructor
 648      *
 649      * @param shello The shell reference
 650      * @param sdWidget The sequence diagram widget reference
 651      * @param showPrintBtn Flag for showing print buttons
 652      */
 653     public SDPrintDialogUI(Shell shell, SDWidget sdWidget, boolean showPrintBtn) {
 654         fShell = shell;
 655         fSdView = sdWidget;
 656         fShowPrintButton = showPrintBtn;
 657
 658         fPrinterData = Printer.getDefaultPrinterData();
 659         if (fPrinterData != null) {
 660             fPrinterData.scope = PrinterData.SELECTION;
 661         }
 662
 663         fPagesList = new int[0];
 664
 665         fSelectionListener = new SelectionListener() {
 666
 667             @Override
 668             public void widgetSelected(SelectionEvent e) {
 669                 if (fUseCurrentZoom.getSelection()) {
 670                     fHorPagesNum.setEnabled(false);
 671                     fVertPagesNum.setEnabled(false);
 672                 }
 673                 if (fSetHPagesNumber.getSelection()) {
 674                     fHorPagesNum.setEnabled(true);
 675                     fVertPagesNum.setEnabled(false);
 676                     if (fCurrentPage.getSelection()) {
 677                         fCurrentPage.setSelection(false);
 678                         fAllPages.setSelection(true);
 679                     }
 680                     if ("".equals(fHorPagesNum.getText())) { //$NON-NLS-1$
 681                         fHorPagesNum.setText("1"); //$NON-NLS-1$
 682                     }
 683                 }
 684                 if (fSetVPagesNumber.getSelection()) {
 685                     fHorPagesNum.setEnabled(false);
 686                     fVertPagesNum.setEnabled(true);
 687                     if (fCurrentPage.getSelection()) {
 688                         fCurrentPage.setSelection(false);
 689                         fAllPages.setSelection(true);
 690                     }
 691                     if (fVertPagesNum.getText() == "") { //$NON-NLS-1$
 692                         fVertPagesNum.setText("1"); //$NON-NLS-1$
 693                     }
 694                 }
 695                 if (fCurrentPage.getSelection() || fAllPages.getSelection() || fPageList.getSelection()) {
 696                     fFromPage.setEnabled(false);
 697                     fToPage.setEnabled(false);
 698                 } else {
 699                     fFromPage.setEnabled(true);
 700                     fToPage.setEnabled(true);
 701                 }
 702
 703                 fCurrentPage.setEnabled(fUseCurrentZoom.getSelection());
 704                 fOverviewCanvas.setEnabled(fPageList.getSelection());
 705                 if (fOverviewCanvas.isEnabled() && (e.widget == fUseCurrentZoom || e.widget == fSetHPagesNumber || e.widget == fSetVPagesNumber)) {
 706                     fPagesList = new int[1];
 707                     fPagesList[0] = 1;
 708                     fPageNum = 1;
 709                     fFirstPage = 1;
 710                 } else if ((fOverviewCanvas.isEnabled() && (e.widget == fPageList)) &&
 711                            (fPagesList == null || fPagesList.length <= 0)) {
 712
 713                     fPagesList = new int[1];
 714                     fPagesList[0] = 1;
 715                     fPageNum = 1;
 716                     fFirstPage = 1;
 717                 }
 718                 computeStepXY();
 719                 fTotalPages.setText(Integer.valueOf(maxNumOfPages()).toString());
 720                 fOverviewCanvas.redraw();
 721                 fOverviewCanvas.update();
 722             }
 723
 724             /*
 725              * (non-Javadoc)
 726              * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
 727              */
 728             @Override
 729             public void widgetDefaultSelected(SelectionEvent e) {
 730                 fPagesList = new int[0];
 731                 computeStepXY();
 732                 fOverviewCanvas.redraw();
 733             }
 734
 735         };
 736
 737         fModifyListener = new ModifyListener() {
 738             /*
 739              * (non-Javadoc)
 740              * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
 741              */
 742             @Override
 743             public void modifyText(ModifyEvent e) {
 744                 fPagesList = new int[0];
 745                 computeStepXY();
 746                 fTotalPages.setText(Integer.valueOf(maxNumOfPages()).toString());
 747                 fOverviewCanvas.redraw();
 748             }
 749
 750         };
 751     }
 752
 753     // ------------------------------------------------------------------------
 754     // Methods
 755     // ------------------------------------------------------------------------
 756
 757     /**
 758      * Creates new grid data object.
 759      *
 760      * @param span horizontal span.
 761      * @return grid data
 762      */
 763     protected GridData newGridData(int span) {
 764         GridData data = new GridData(GridData.GRAB_VERTICAL | GridData.VERTICAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL);
 765         data.horizontalSpan = span;
 766         return data;
 767     }
 768
 769     /**
 770      * Creates the dialog area.
 771      *
 772      * @param parent The parent composite
 773      * @return dialog control
 774      */
 775     public Control createDialogArea(Composite parent) {
 776
 777         GridLayout parentLayout = new GridLayout();
 778         parentLayout.numColumns = 6;
 779         parent.setLayout(parentLayout);
 780
 781         Group g1 = new Group(parent, SWT.SHADOW_NONE);
 782         g1.setText(SDMessages._113);
 783         g1.setLayoutData(newGridData(3));
 784         GridLayout g1layout = new GridLayout();
 785         g1layout.numColumns = 2;
 786         g1.setLayout(g1layout);
 787
 788         fUseCurrentZoom = new Button(g1, SWT.RADIO);
 789         fUseCurrentZoom.setText(SDMessages._112);
 790         fUseCurrentZoom.setLayoutData(newGridData(2));
 791         fUseCurrentZoom.addSelectionListener(fSelectionListener);
 792
 793         fSetHPagesNumber = new Button(g1, SWT.RADIO);
 794         fSetHPagesNumber.setText(SDMessages._110);
 795         fSetHPagesNumber.setLayoutData(newGridData(1));
 796         fSetHPagesNumber.addSelectionListener(fSelectionListener);
 797
 798         fHorPagesNum = new Text(g1, SWT.SINGLE | SWT.BORDER);
 799         fHorPagesNum.addModifyListener(fModifyListener);
 800
 801         fSetVPagesNumber = new Button(g1, SWT.RADIO);
 802         fSetVPagesNumber.setText(SDMessages._111);
 803         fSetVPagesNumber.setLayoutData(newGridData(1));
 804         fSetVPagesNumber.addSelectionListener(fSelectionListener);
 805
 806         fVertPagesNum = new Text(g1, SWT.SINGLE | SWT.BORDER);
 807         fVertPagesNum.addModifyListener(fModifyListener);
 808
 809         Label nbTotal = new Label(g1, SWT.SHADOW_NONE | SWT.RIGHT);
 810         nbTotal.setText(SDMessages._109);
 811         // nbTotal.setLayoutData(newGridData(1));
 812
 813         fTotalPages = new Text(g1, SWT.SINGLE | SWT.BORDER | SWT.READ_ONLY);
 814         // nbHV.addModifyListener(modifListener);
 815
 816         Group g2 = new Group(parent, SWT.SHADOW_NONE);
 817         g2.setText(SDMessages._119);
 818         GridData data = new GridData(GridData.GRAB_VERTICAL | GridData.VERTICAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL);
 819         data.horizontalSpan = 3;
 820         data.verticalSpan = 2;
 821         g2.setLayoutData(data);
 822         GridLayout g2layout = new GridLayout();
 823         // g2layout.
 824         g2layout.numColumns = 1;
 825         // SVLayout g2layout = new SVLayout();
 826         g2.setLayout(g2layout);
 827
 828         GridData data2 = new GridData(GridData.GRAB_VERTICAL | GridData.VERTICAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL | GridData.HORIZONTAL_ALIGN_FILL);
 829         data2.horizontalSpan = 1;
 830         data2.verticalSpan = 1;
 831
 832         fOverviewCanvas = new LocalSD(g2, SWT.NO_BACKGROUND);
 833         GridData seqDiagLayoutData = new GridData(GridData.HORIZONTAL_ALIGN_FILL// |GridData.GRAB_HORIZONTAL|
 834                 /* GridData.GRAB_VERTICAL| */| GridData.VERTICAL_ALIGN_FILL);
 835         // seqDiagLayoutData.widthHint=400;
 836         // seqDiagLayoutData.horizontalAlignment=GridData.HORIZONTAL_ALIGN_FILL;
 837         fOverviewCanvas.setLayoutData(seqDiagLayoutData);
 838         // overviewCanvas.resizeContents(100,100);
 839         if (fSdView.getContentsWidth() < fSdView.getVisibleWidth() && fSdView.getContentsHeight() < fSdView.getVisibleHeight()) {
 840             fTest = 3;
 841         } else {
 842             fTest = 10;
 843         }
 844         fOverviewCanvas.setFrame(fSdView.getFrame(), true);
 845         fOverviewCanvas.fZoomValue = (float) 1 / fTest;
 846         fOverviewCanvas.setCornerControl(null);
 847         seqDiagLayoutData.widthHint = fOverviewCanvas.getContentsWidth() / fTest;
 848         seqDiagLayoutData.widthHint = fOverviewCanvas.getFrame().getWidth() / fTest + 15;
 849
 850         if (fSdView.getVisibleWidth() < fSdView.getContentsWidth()) {
 851             seqDiagLayoutData.widthHint = fOverviewCanvas.getContentsWidth() / fTest;
 852             if (seqDiagLayoutData.widthHint > Display.getDefault().getClientArea().width / 4) {
 853                 seqDiagLayoutData.widthHint = Display.getDefault().getClientArea().width / 4;
 854             }
 855         } else {
 856             seqDiagLayoutData.widthHint = fOverviewCanvas.getFrame().getWidth() / fTest + 15;
 857         }
 858
 859         if (fSdView.getVisibleHeight() < fSdView.getContentsHeight()) {
 860             seqDiagLayoutData.heightHint = fOverviewCanvas.getContentsHeight() / fTest;
 861             if (seqDiagLayoutData.heightHint > Display.getDefault().getClientArea().width / 4) {
 862                 seqDiagLayoutData.heightHint = Display.getDefault().getClientArea().width / 4;
 863             }
 864         } else {
 865             seqDiagLayoutData.heightHint = fOverviewCanvas.getFrame().getHeight() / fTest;
 866         }
 867
 868         fOverviewCanvas.setEnabled(false);
 869
 870         fCurrentSelection = new Label(g2, SWT.SHADOW_NONE | SWT.LEFT);
 871         fCurrentSelection.setLayoutData(newGridData(1));
 872
 873         Group g3 = new Group(parent, SWT.SHADOW_NONE);
 874         g3.setText(SDMessages._118);
 875         g3.setLayoutData(newGridData(3));
 876         GridLayout g3layout = new GridLayout();
 877         g3layout.numColumns = 4;
 878         g3.setLayout(g3layout);
 879
 880         fAllPages = new Button(g3, SWT.RADIO);
 881         fAllPages.setText(SDMessages._108);
 882         fAllPages.setLayoutData(newGridData(4));
 883         fAllPages.addSelectionListener(fSelectionListener);
 884
 885         fCurrentPage = new Button(g3, SWT.RADIO);
 886         fCurrentPage.setText(SDMessages._107);
 887         fCurrentPage.setLayoutData(newGridData(4));
 888         fCurrentPage.setEnabled(true);
 889         fCurrentPage.setSelection(true);
 890         fCurrentPage.addSelectionListener(fSelectionListener);
 891
 892         fPageList = new Button(g3, SWT.RADIO);
 893         fPageList.setText(SDMessages._106);
 894         fPageList.setLayoutData(newGridData(4));
 895         fPageList.addSelectionListener(fSelectionListener);
 896
 897         fPageRange = new Button(g3, SWT.RADIO);
 898         fPageRange.setText(SDMessages._103);
 899         fPageRange.setLayoutData(newGridData(1));
 900         fPageRange.addSelectionListener(fSelectionListener);
 901
 902         fFromPage = new Text(g3, SWT.SINGLE | SWT.BORDER);
 903
 904         Label labelTo = new Label(g3, SWT.CENTER);
 905         labelTo.setText(SDMessages._105);
 906
 907         fToPage = new Text(g3, SWT.SINGLE | SWT.BORDER);
 908
 909         fToolTip = new DiagramToolTip(fOverviewCanvas);
 910
 911         fOverviewCanvas.getViewControl().addMouseTrackListener(new MouseTrackListener() {
 912             /*
 913              * (non-Javadoc)
 914              * @see org.eclipse.swt.events.MouseTrackListener#mouseEnter(org.eclipse.swt.events.MouseEvent)
 915              */
 916             @Override
 917             public void mouseEnter(MouseEvent e) {
 918                 fToolTip.hideToolTip();
 919             }
 920
 921             /*
 922              * (non-Javadoc)
 923              * @see org.eclipse.swt.events.MouseTrackListener#mouseExit(org.eclipse.swt.events.MouseEvent)
 924              */
 925             @Override
 926             public void mouseExit(MouseEvent e) {
 927                 fToolTip.hideToolTip();
 928             }
 929
 930             /*
 931              * (non-Javadoc)
 932              * @see org.eclipse.swt.events.MouseTrackListener#mouseHover(org.eclipse.swt.events.MouseEvent)
 933              */
 934             @Override
 935             public void mouseHover(MouseEvent e) {
 936                 int x1 = (int) (fOverviewCanvas.viewToContentsX(e.x) / fOverviewCanvas.fZoomValue / fStepX);
 937                 int x2 = (int) (fOverviewCanvas.viewToContentsY(e.y) / fOverviewCanvas.fZoomValue / fStepY);
 938                 int num = x1 + x2 * getNbRow() + 1;
 939                 if (num > maxNumOfPages()) {
 940                     return;
 941                 }
 942                 if (num > 0) {
 943                     fToolTip.showToolTip(String.valueOf(num));
 944                     displayPageNum();
 945                 } else {
 946                     fCurrentSelection.setText("");//$NON-NLS-1$
 947                     fToolTip.hideToolTip();
 948                 }
 949             }
 950
 951         });
 952
 953         fOverviewCanvas.addTraverseListener(new TraverseListener() {
 954             /*
 955              * (non-Javadoc)
 956              * @see org.eclipse.swt.events.TraverseListener#keyTraversed(org.eclipse.swt.events.TraverseEvent)
 957              */
 958             @Override
 959             public void keyTraversed(TraverseEvent e) {
 960                 if ((e.detail == SWT.TRAVERSE_TAB_NEXT) || (e.detail == SWT.TRAVERSE_TAB_PREVIOUS)) {
 961                     e.doit = true;
 962                 }
 963             }
 964         });
 965
 966         fOverviewCanvas.addFocusListener(new FocusListener() {
 967             /*
 968              * (non-Javadoc)
 969              * @see org.eclipse.swt.events.FocusListener#focusGained(org.eclipse.swt.events.FocusEvent)
 970              */
 971             @Override
 972             public void focusGained(FocusEvent e) {
 973                 fOverviewCanvas.redraw();
 974             }
 975
 976             /*
 977              * (non-Javadoc)
 978              * @see org.eclipse.swt.events.FocusListener#focusLost(org.eclipse.swt.events.FocusEvent)
 979              */
 980             @Override
 981             public void focusLost(FocusEvent e) {
 982                 fOverviewCanvas.redraw();
 983             }
 984         });
 985
 986         if (fShowPrintButton) {
 987             Composite printerDlg = new Composite(parent, SWT.NONE);
 988             data = GridUtil.createHorizontalFill();
 989             data.horizontalSpan = 6;
 990             parentLayout = new GridLayout();
 991             parentLayout.numColumns = 2;
 992             printerDlg.setLayout(parentLayout);
 993             printerDlg.setLayoutData(data);
 994
 995             Label label = new Label(printerDlg, SWT.NONE);
 996             label.setLayoutData(GridUtil.createHorizontalFill());
 997             fPrinterDialog = new Button(printerDlg, SWT.PUSH);
 998             fPrinterDialog.setText(SDMessages._115);
 999
1000             fPrinterDialog.addSelectionListener(new SelectionListener() {
1001
1002                 /*
1003                  * (non-Javadoc)
1004                  * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
1005                  */
1006                 @Override
1007                 public void widgetSelected(SelectionEvent e) {
1008
1009                     printButtonSelected();
1010                 }
1011
1012                 /*
1013                  * (non-Javadoc)
1014                  * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
1015                  */
1016                 @Override
1017                 public void widgetDefaultSelected(SelectionEvent e) {
1018                 }
1019
1020             });
1021         }
1022
1023         updatePrinterStatus();
1024
1025         return parent;
1026     }
1027
1028     /**
1029      * Get number of pages for selection.
1030      * @return number of pages for selection.
1031      */
1032     public int getPagesForSelection() {
1033         return fNbPages;
1034     }
1035
1036     public boolean okPressed() {
1037         fPrintAll = fAllPages.getSelection();
1038         fPrintCurrent = fCurrentPage.getSelection();
1039         fPrintSelection = fPageList.getSelection();
1040         fPrintRange = fPageRange.getSelection();
1041         try {
1042             if (fPrintRange) {
1043                 fFrom = Integer.valueOf(fFromPage.getText()).intValue();
1044                 fTo = Integer.valueOf(fToPage.getText()).intValue();
1045                 if (fFrom > maxNumOfPages() || fTo > maxNumOfPages() || fFrom <= 0 || fTo <= 0) {
1046                     MessageDialog.openError(getShell(), SDMessages._98, SDMessages._99);
1047                     return false;
1048                 }
1049             } else if (fSetHPagesNumber.getSelection() && fNbPages <= 0) {
1050                 MessageDialog.openError(getShell(), SDMessages._98, SDMessages._101);
1051                 return false;
1052             } else if (fSetVPagesNumber.getSelection() && fNbPages <= 0) {
1053                 MessageDialog.openError(getShell(), SDMessages._98, SDMessages._100);
1054                 return false;
1055             } else if (fPrintSelection && getPageList().length <= 0) {
1056                 MessageDialog.openError(getShell(), SDMessages._98, SDMessages._102);
1057                 return false;
1058             }
1059
1060         } catch (Exception e) {
1061             MessageDialog.openError(getShell(), SDMessages._98, SDMessages._99);
1062             fFrom = 0;
1063             fTo = 0;
1064             return false;
1065         }
1066
1067         return true;
1068     }
1069
1070     /**
1071      * Draws region that was selected
1072      * @param img The corresponding image
1073      * @param r The selected rectangle.
1074      * @param color The color to use for selection
1075      * @return image data reference
1076      */
1077     public ImageData drawRegionSelected(Image img, Rectangle r, RGB color) {
1078         ImageData id = img.getImageData();
1079         for (int a = 0; a < r.width && r.x + a < id.width; a++) {
1080             for (int b = 0; b < r.height && r.y + b < id.height; b++) {
1081                 int index = id.getPixel(r.x + a, r.y + b);
1082                 RGB rgb = id.palette.getRGB(index);
1083                 rgb = combine(color, rgb);
1084                 id.setPixel(r.x + a, r.y + b, id.palette.getPixel(rgb));
1085             }
1086         }
1087         return id;
1088     }
1089
1090     /**
1091      * Combines two RGB colors.
1092      * @param front The front color
1093      * @param back The back color
1094      * @return new RGB color
1095      */
1096     public static RGB combine(RGB front, RGB back) {
1097         int _af = 128;
1098         int _ab = 200;
1099
1100         double af = (_af) / 255.0;
1101         double rf = front.red;
1102         double gf = front.green;
1103         double bf = front.blue;
1104
1105         double ab = (_ab) / 255.0;
1106         double rb = back.red;
1107         double gb = back.green;
1108         double bb = back.blue;
1109
1110         double k = (1.0 - af) * ab;
1111         int r = (int) ((af * rf + k * rb));
1112         int g = (int) ((af * gf + k * gb));
1113         int b = (int) ((af * bf + k * bb));
1114
1115         return new RGB(r, g, b);
1116     }
1117
1118     /**
1119      * Computes value for X coordinates step and Y coordinates step.
1120      */
1121     protected void computeStepXY() {
1122         float cw = fOverviewCanvas.getContentsWidth() / fOverviewCanvas.fZoomValue;
1123         float ch = fOverviewCanvas.getContentsHeight() / fOverviewCanvas.fZoomValue;
1124         try {
1125             if (fPrinterData == null) {
1126                 fStepX = 0;
1127                 fStepY = 0;
1128                 fNbPages = 0;
1129                 fZoomFactor = 0;
1130             } else {
1131                 Printer printer = new Printer(fPrinterData);
1132                 if (fSetHPagesNumber.getSelection()) {
1133                     fNbPages = Integer.valueOf(fHorPagesNum.getText()).intValue();
1134                     float z1 = (float) fSdView.getContentsWidth() / (cw);
1135                     float z2 = printer.getClientArea().width / ((float) fSdView.getContentsWidth() / fNbPages);
1136
1137                     fStepY = printer.getClientArea().height / z1 / z2;
1138                     fStepX = cw / fNbPages;
1139                 } else if (fSetVPagesNumber.getSelection()) {
1140                     fNbPages = Integer.valueOf(fVertPagesNum.getText()).intValue();
1141                     float z1 = (float) fSdView.getContentsHeight() / (ch);
1142                     float z2 = printer.getClientArea().height / ((float) fSdView.getContentsHeight() / fNbPages);
1143                     fStepX = printer.getClientArea().width / z1 / z2;
1144                     fStepY = ch / fNbPages;
1145                 } else {
1146                     float z1 = fSdView.getContentsWidth() / (cw);
1147                     fStepX = ((float) fSdView.getVisibleWidth() / z1);
1148                     fNbPages = Math.round(cw / fStepX);
1149                     if (fNbPages == 0) {
1150                         fNbPages = 1;
1151                     }
1152                     int pw = printer.getClientArea().width;
1153                     int ph = printer.getClientArea().height;
1154                     float z2 = pw / ((float) fSdView.getContentsWidth() / fNbPages);
1155                     fStepY = ((float) ph / z1 / z2);
1156                 }
1157             }
1158         } catch (NumberFormatException e) {
1159             fStepX = fStepY = fNbPages = 0;
1160             fZoomFactor = 0;
1161         }
1162         sTX = fStepX * (fSdView.getContentsWidth() / cw);
1163         sTY = fStepY * (fSdView.getContentsHeight() / ch);
1164         float rat = 1;
1165         if ((fSdView.getVisibleWidth() > fSdView.getContentsWidth()) && (fSetVPagesNumber.getSelection() || fSetHPagesNumber.getSelection())) {
1166             rat = (float) fSdView.getVisibleWidth() / (float) fSdView.getContentsWidth();
1167         }
1168         fZoomFactor = (fOverviewCanvas.getContentsWidth() / cw) / fOverviewCanvas.getZoomFactor() * rat;// /view.getZoomFactor();
1169     }
1170
1171     /**
1172      * Returns the pages list.
1173      *
1174      * @return the pages list.
1175      */
1176     public int[] getPageList() {
1177         return Arrays.copyOf(fPagesList, fPagesList.length);
1178     }
1179
1180     /**
1181      * Adds a page to pages list.
1182      * @param num
1183      */
1184     public void addToPagesList(int num) {
1185         int temp[] = new int[fPagesList.length + 1];
1186         System.arraycopy(fPagesList, 0, temp, 0, fPagesList.length);
1187         temp[temp.length - 1] = num;
1188         fPagesList = new int[temp.length];
1189         System.arraycopy(temp, 0, fPagesList, 0, temp.length);
1190     }
1191
1192     /**
1193      * Removes a page from the pages list.
1194      * @param num
1195      */
1196     public void removeFromPagesList(int num) {
1197         int pos = Arrays.binarySearch(fPagesList, num);
1198         int temp[] = new int[fPagesList.length - 1];
1199         System.arraycopy(fPagesList, 0, temp, 0, pos);
1200         System.arraycopy(fPagesList, pos + 1, temp, pos, fPagesList.length - pos - 1);
1201         fPagesList = new int[temp.length];
1202         System.arraycopy(temp, 0, fPagesList, 0, temp.length);
1203     }
1204
1205     /**
1206      * Returns the maximum number of pages.
1207      *
1208      * @return maximum number of pages.
1209      */
1210     public int maxNumOfPages() {
1211         return (getNbRow() * getNbLines());
1212     }
1213
1214     /**
1215      * Returns the number of rows.
1216      *
1217      * @return number of rows.
1218      */
1219     public int getNbRow() {
1220         if (!fSetHPagesNumber.isDisposed()) {
1221             int cw = (int) (fOverviewCanvas.getContentsWidth() / fOverviewCanvas.fZoomValue);
1222             int row = 1;
1223             if (fStepX != 0) {
1224                 row = (int) (cw / fStepX);
1225                 if (fSetHPagesNumber.getSelection()) {
1226                     row = Math.round((float) cw / fStepX);
1227                 } else if ((cw % fStepX != 0)) {
1228                     row++;
1229                 }
1230             }
1231             fNbRows = row;
1232         }
1233         return fNbRows;
1234     }
1235
1236     /**
1237      * Returns the number of lines.
1238      *
1239      * @return number of lines
1240      */
1241     public int getNbLines() {
1242         if (!fSetVPagesNumber.isDisposed()) {
1243             int ch = (int) (fOverviewCanvas.getContentsHeight() / fOverviewCanvas.fZoomValue);
1244             int line = 1;
1245             if (fStepY != 0) {
1246                 line = (int) (ch / fStepY);
1247                 if (fSetVPagesNumber.getSelection()) {
1248                     line = Math.round((float) ch / fStepY);
1249                 } else if (ch % fStepY != 0) {
1250                     line++;
1251                 }
1252             }
1253             fNbLines = line;
1254         }
1255         return fNbLines;
1256     }
1257
1258     /**
1259      * Returns whether to print all pages or not.
1260      *
1261      * @return <code>true</code> for all pages else <code>false</code>.
1262      */
1263     public boolean printAll() {
1264         return fPrintAll;
1265     }
1266
1267     /**
1268      * Returns whether to print only current page
1269      *
1270      * @return <code>true</code> for current page only else <code>false</code>..
1271      */
1272     public boolean printCurrent() {
1273         return fPrintCurrent;
1274     }
1275
1276     /**
1277      * Returns whether to print selected pages.
1278      *
1279      * @return <code>true</code> for selected pages only else <code>false</code>.
1280      */
1281     public boolean printSelection() {
1282         return fPrintSelection;
1283     }
1284
1285     /**
1286      * Returns whether to print range of pages.
1287      *
1288      * @return <code>true</code> for range of pages only else <code>false</code>.
1289      */
1290     public boolean printRange() {
1291         return fPrintRange;
1292     }
1293
1294     /**
1295      * Returns the step in X direction.
1296      *
1297      * @return step in X direction
1298      */
1299     public float getStepX() {
1300         return sTX;
1301     }
1302
1303     /**
1304      * Returns the step in Y direction.
1305      *
1306      * @return step in Y direction
1307      */
1308     public float getStepY() {
1309         return sTY;
1310     }
1311
1312     /**
1313      * Returns the zoom factor
1314      *
1315      * @return zoom factor
1316      */
1317     public float getZoomFactor() {
1318         return fZoomFactor;
1319     }
1320
1321     /**
1322      * Returns the printer data reference.
1323      *
1324      * @return printer data reference
1325      */
1326     public PrinterData getPrinterData() {
1327         return fPrinterData;
1328     }
1329
1330     /**
1331      * Returns the page number to start printing from.
1332      *
1333      * @return page number to start printing from
1334      */
1335     public int getFrom() {
1336         return fFrom;
1337     }
1338
1339     /**
1340      * Returns the page number to print to.
1341      *
1342      * @return page number to print to
1343      */
1344     public int getTo() {
1345         return fTo;
1346     }
1347
1348     /**
1349      * Displays current number of pages
1350      */
1351     protected void displayPageNum() {
1352         if (fPageNum > 0) {
1353             String message = MessageFormat.format(SDMessages._117, new Object[] { Integer.valueOf(fPageNum) });
1354             fCurrentSelection.setText(message);
1355             fCurrentSelection.getParent().layout();
1356         }
1357     }
1358
1359     /**
1360      * Returns the shell reference.
1361      *
1362      * @return the shell reference.
1363      */
1364     public Shell getShell() {
1365         return fShell;
1366     }
1367
1368     /**
1369      * Sets the shell.
1370      *
1371      * @param shell The shell reference.
1372      */
1373     public void setShell(Shell shell) {
1374         fShell = shell;
1375     }
1376
1377     /**
1378      * Handle selection of print button.
1379      */
1380     public void printButtonSelected() {
1381         PrintDialog printer = new PrintDialog(getShell());
1382         if (fAllPages.getSelection()) {
1383             printer.setScope(PrinterData.ALL_PAGES);
1384         }
1385         if (fCurrentPage.getSelection()) {
1386             printer.setScope(PrinterData.SELECTION);
1387         }
1388         if (fPageList.getSelection()) {
1389             printer.setScope(PrinterData.SELECTION);
1390         }
1391         if (fPageRange.getSelection()) {
1392             printer.setScope(PrinterData.PAGE_RANGE);
1393             fFrom = Integer.valueOf(fFromPage.getText()).intValue();
1394             fTo = Integer.valueOf(fToPage.getText()).intValue();
1395             printer.setStartPage(fFrom);
1396             printer.setEndPage(fTo);
1397         }
1398
1399         PrinterData newPrinterData = printer.open();
1400         if (newPrinterData != null) {
1401             fPrinterData = newPrinterData;
1402         }
1403         updatePrinterStatus();
1404
1405         if (printer.getScope() == PrinterData.ALL_PAGES) {
1406             fAllPages.setSelection(true);
1407             fCurrentPage.setSelection(false);
1408             fPageList.setSelection(false);
1409             fPageRange.setSelection(false);
1410             fHorPagesNum.setEnabled(false);
1411             fVertPagesNum.setEnabled(false);
1412         }
1413         if (printer.getScope() == PrinterData.PAGE_RANGE) {
1414             fAllPages.setSelection(false);
1415             fCurrentPage.setSelection(false);
1416             fPageList.setSelection(false);
1417             fPageRange.setSelection(true);
1418             fFromPage.setEnabled(true);
1419             fToPage.setEnabled(true);
1420             fFromPage.setText((Integer.valueOf(printer.getStartPage())).toString());
1421             fToPage.setText((Integer.valueOf(printer.getEndPage())).toString());
1422         }
1423         computeStepXY();
1424         fOverviewCanvas.redraw();
1425     }
1426
1427     /**
1428      * Sets parent wizard page
1429      *
1430      * @param parent The parent wizard page
1431      */
1432     public void setParentWizardPage(WizardPage parent) {
1433         fParentWizardPage = parent;
1434     }
1435
1436     /**
1437      * Sets the parent dialog box.
1438      *
1439      * @param parent The parent dialog box.
1440      */
1441     public void setParentDialog(SDPrintDialog parent) {
1442         fParentDialog = parent;
1443     }
1444
1445     /**
1446      * Updates the printer status
1447      */
1448     protected void updatePrinterStatus() {
1449         if (fParentWizardPage != null) {
1450             // used in the wizard dialog
1451             if (fPrinterData == null) {
1452                 // show error message and disable Finish button
1453                 fParentWizardPage.setErrorMessage(SDMessages._135);
1454                 fParentWizardPage.setPageComplete(false);
1455             } else {
1456                 // clear error message and enable Finish button
1457                 fParentWizardPage.setErrorMessage(null);
1458                 fParentWizardPage.setPageComplete(true);
1459             }
1460         } else if (fParentDialog != null) {
1461             // used in the print dialog
1462             if (fPrinterData == null) {
1463                 // show error message and disable OK button
1464                 fParentDialog.setErrorMessage(SDMessages._135);
1465                 fParentDialog.setPageComplete(false);
1466             } else {
1467                 // clear error message and enable OK button
1468                 fParentDialog.setErrorMessage(null);
1469                 fParentDialog.setPageComplete(true);
1470             }
1471         }
1472     }
1473
1474 }