TImage.java

   1 /*
   2  * Jexer - Java Text User Interface
   3  *
   4  * The MIT License (MIT)
   5  *
   6  * Copyright (C) 2019 Kevin Lamonte
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  *
  26  * @author Kevin Lamonte [kevin.lamonte@gmail.com]
  27  * @version 1
  28  */
  29 package jexer;
  30
  31 import java.awt.image.BufferedImage;
  32
  33 import jexer.backend.ECMA48Terminal;
  34 import jexer.backend.MultiScreen;
  35 import jexer.backend.SwingTerminal;
  36 import jexer.bits.Cell;
  37 import jexer.event.TCommandEvent;
  38 import jexer.event.TKeypressEvent;
  39 import jexer.event.TMouseEvent;
  40 import jexer.event.TResizeEvent;
  41 import static jexer.TCommand.*;
  42 import static jexer.TKeypress.*;
  43
  44 /**
  45  * TImage renders a piece of a bitmap image on screen.
  46  */
  47 public class TImage extends TWidget implements EditMenuUser {
  48
  49     // ------------------------------------------------------------------------
  50     // Constants --------------------------------------------------------------
  51     // ------------------------------------------------------------------------
  52
  53     /**
  54      * Selections for fitting the image to the text cells.
  55      */
  56     public enum Scale {
  57         /**
  58          * No scaling.
  59          */
  60         NONE,
  61
  62         /**
  63          * Stretch/shrink the image in both directions to fully fill the text
  64          * area width/height.
  65          */
  66         STRETCH,
  67
  68         /**
  69          * Scale the image, preserving aspect ratio, to fill the text area
  70          * width/height (like letterbox).  The background color for the
  71          * letterboxed area is specified in scaleBackColor.
  72          */
  73         SCALE,
  74     }
  75
  76     // ------------------------------------------------------------------------
  77     // Variables --------------------------------------------------------------
  78     // ------------------------------------------------------------------------
  79
  80     /**
  81      * Scaling strategy to use.
  82      */
  83     private Scale scale = Scale.NONE;
  84
  85     /**
  86      * Scaling strategy to use.
  87      */
  88     private java.awt.Color scaleBackColor = java.awt.Color.BLACK;
  89
  90     /**
  91      * The action to perform when the user clicks on the image.
  92      */
  93     private TAction clickAction;
  94
  95     /**
  96      * The image to display.
  97      */
  98     private BufferedImage image;
  99
 100     /**
 101      * The original image from construction time.
 102      */
 103     private BufferedImage originalImage;
 104
 105     /**
 106      * The current scaling factor for the image.
 107      */
 108     private double scaleFactor = 1.0;
 109
 110     /**
 111      * The current clockwise rotation for the image.
 112      */
 113     private int clockwise = 0;
 114
 115     /**
 116      * If true, this widget was resized and a new scaled image must be
 117      * produced.
 118      */
 119     private boolean resized = false;
 120
 121     /**
 122      * Left column of the image.  0 is the left-most column.
 123      */
 124     private int left;
 125
 126     /**
 127      * Top row of the image.  0 is the top-most row.
 128      */
 129     private int top;
 130
 131     /**
 132      * The cells containing the broken up image pieces.
 133      */
 134     private Cell cells[][];
 135
 136     /**
 137      * The number of rows in cells[].
 138      */
 139     private int cellRows;
 140
 141     /**
 142      * The number of columns in cells[].
 143      */
 144     private int cellColumns;
 145
 146     /**
 147      * Last text width value.
 148      */
 149     private int lastTextWidth = -1;
 150
 151     /**
 152      * Last text height value.
 153      */
 154     private int lastTextHeight = -1;
 155
 156     // ------------------------------------------------------------------------
 157     // Constructors -----------------------------------------------------------
 158     // ------------------------------------------------------------------------
 159
 160     /**
 161      * Public constructor.
 162      *
 163      * @param parent parent widget
 164      * @param x column relative to parent
 165      * @param y row relative to parent
 166      * @param width number of text cells for width of the image
 167      * @param height number of text cells for height of the image
 168      * @param image the image to display
 169      * @param left left column of the image.  0 is the left-most column.
 170      * @param top top row of the image.  0 is the top-most row.
 171      */
 172     public TImage(final TWidget parent, final int x, final int y,
 173         final int width, final int height,
 174         final BufferedImage image, final int left, final int top) {
 175
 176         this(parent, x, y, width, height, image, left, top, null);
 177     }
 178
 179     /**
 180      * Public constructor.
 181      *
 182      * @param parent parent widget
 183      * @param x column relative to parent
 184      * @param y row relative to parent
 185      * @param width number of text cells for width of the image
 186      * @param height number of text cells for height of the image
 187      * @param image the image to display
 188      * @param left left column of the image.  0 is the left-most column.
 189      * @param top top row of the image.  0 is the top-most row.
 190      * @param clickAction function to call when mouse is pressed
 191      */
 192     public TImage(final TWidget parent, final int x, final int y,
 193         final int width, final int height,
 194         final BufferedImage image, final int left, final int top,
 195         final TAction clickAction) {
 196
 197         // Set parent and window
 198         super(parent, x, y, width, height);
 199
 200         setCursorVisible(false);
 201         this.originalImage = image;
 202         this.left = left;
 203         this.top = top;
 204         this.clickAction = clickAction;
 205
 206         sizeToImage(true);
 207     }
 208
 209     // ------------------------------------------------------------------------
 210     // Event handlers ---------------------------------------------------------
 211     // ------------------------------------------------------------------------
 212
 213     /**
 214      * Handle mouse press events.
 215      *
 216      * @param mouse mouse button press event
 217      */
 218     @Override
 219     public void onMouseDown(final TMouseEvent mouse) {
 220         if (clickAction != null) {
 221             clickAction.DO(this);
 222             return;
 223         }
 224     }
 225
 226     /**
 227      * Handle keystrokes.
 228      *
 229      * @param keypress keystroke event
 230      */
 231     @Override
 232     public void onKeypress(final TKeypressEvent keypress) {
 233         if (!keypress.getKey().isFnKey()) {
 234             if (keypress.getKey().getChar() == '+') {
 235                 // Make the image bigger.
 236                 scaleFactor *= 1.25;
 237                 image = null;
 238                 sizeToImage(true);
 239                 return;
 240             }
 241             if (keypress.getKey().getChar() == '-') {
 242                 // Make the image smaller.
 243                 scaleFactor *= 0.80;
 244                 image = null;
 245                 sizeToImage(true);
 246                 return;
 247             }
 248         }
 249         if (keypress.equals(kbAltUp)) {
 250             // Make the image bigger.
 251             scaleFactor *= 1.25;
 252             image = null;
 253             sizeToImage(true);
 254             return;
 255         }
 256         if (keypress.equals(kbAltDown)) {
 257             // Make the image smaller.
 258             scaleFactor *= 0.80;
 259             image = null;
 260             sizeToImage(true);
 261             return;
 262         }
 263         if (keypress.equals(kbAltRight)) {
 264             // Rotate clockwise.
 265             clockwise++;
 266             clockwise %= 4;
 267             image = null;
 268             sizeToImage(true);
 269             return;
 270         }
 271         if (keypress.equals(kbAltLeft)) {
 272             // Rotate counter-clockwise.
 273             clockwise--;
 274             if (clockwise < 0) {
 275                 clockwise = 3;
 276             }
 277             image = null;
 278             sizeToImage(true);
 279             return;
 280         }
 281
 282         if (keypress.equals(kbShiftLeft)) {
 283             switch (scale) {
 284             case NONE:
 285                 setScaleType(Scale.SCALE);
 286                 return;
 287             case STRETCH:
 288                 setScaleType(Scale.NONE);
 289                 return;
 290             case SCALE:
 291                 setScaleType(Scale.STRETCH);
 292                 return;
 293             }
 294         }
 295         if (keypress.equals(kbShiftRight)) {
 296             switch (scale) {
 297             case NONE:
 298                 setScaleType(Scale.STRETCH);
 299                 return;
 300             case STRETCH:
 301                 setScaleType(Scale.SCALE);
 302                 return;
 303             case SCALE:
 304                 setScaleType(Scale.NONE);
 305                 return;
 306             }
 307         }
 308
 309         // Pass to parent for the things we don't care about.
 310         super.onKeypress(keypress);
 311     }
 312
 313     /**
 314      * Handle resize events.
 315      *
 316      * @param event resize event
 317      */
 318     @Override
 319     public void onResize(final TResizeEvent event) {
 320         // Get my width/height set correctly.
 321         super.onResize(event);
 322
 323         if (scale == Scale.NONE) {
 324             return;
 325         }
 326         image = null;
 327         resized = true;
 328     }
 329
 330     /**
 331      * Handle posted command events.
 332      *
 333      * @param command command event
 334      */
 335     @Override
 336     public void onCommand(final TCommandEvent command) {
 337         if (command.equals(cmCopy)) {
 338             // Copy image to clipboard.
 339             getClipboard().copyImage(image);
 340             return;
 341         }
 342     }
 343
 344     // ------------------------------------------------------------------------
 345     // TWidget ----------------------------------------------------------------
 346     // ------------------------------------------------------------------------
 347
 348     /**
 349      * Draw the image.
 350      */
 351     @Override
 352     public void draw() {
 353         sizeToImage(false);
 354
 355         // We have already broken the image up, just draw the last set of
 356         // cells.
 357         for (int x = 0; (x < getWidth()) && (x + left < cellColumns); x++) {
 358             if ((left + x) * lastTextWidth > image.getWidth()) {
 359                 continue;
 360             }
 361
 362             for (int y = 0; (y < getHeight()) && (y + top < cellRows); y++) {
 363                 if ((top + y) * lastTextHeight > image.getHeight()) {
 364                     continue;
 365                 }
 366                 assert (x + left < cellColumns);
 367                 assert (y + top < cellRows);
 368
 369                 getWindow().putCharXY(x, y, cells[x + left][y + top]);
 370             }
 371         }
 372
 373     }
 374
 375     // ------------------------------------------------------------------------
 376     // TImage -----------------------------------------------------------------
 377     // ------------------------------------------------------------------------
 378
 379     /**
 380      * Size cells[][] according to the screen font size.
 381      *
 382      * @param always if true, always resize the cells
 383      */
 384     private void sizeToImage(final boolean always) {
 385         int textWidth = getScreen().getTextWidth();
 386         int textHeight = getScreen().getTextHeight();
 387
 388         if (image == null) {
 389             image = rotateImage(originalImage, clockwise);
 390             image = scaleImage(image, scaleFactor, getWidth(), getHeight(),
 391                 textWidth, textHeight);
 392         }
 393
 394         if ((always == true) ||
 395             (resized == true) ||
 396             ((textWidth > 0)
 397                 && (textWidth != lastTextWidth)
 398                 && (textHeight > 0)
 399                 && (textHeight != lastTextHeight))
 400         ) {
 401             resized = false;
 402
 403             cellColumns = image.getWidth() / textWidth;
 404             if (cellColumns * textWidth < image.getWidth()) {
 405                 cellColumns++;
 406             }
 407             cellRows = image.getHeight() / textHeight;
 408             if (cellRows * textHeight < image.getHeight()) {
 409                 cellRows++;
 410             }
 411
 412             // Break the image up into an array of cells.
 413             cells = new Cell[cellColumns][cellRows];
 414
 415             for (int x = 0; x < cellColumns; x++) {
 416                 for (int y = 0; y < cellRows; y++) {
 417
 418                     int width = textWidth;
 419                     if ((x + 1) * textWidth > image.getWidth()) {
 420                         width = image.getWidth() - (x * textWidth);
 421                     }
 422                     int height = textHeight;
 423                     if ((y + 1) * textHeight > image.getHeight()) {
 424                         height = image.getHeight() - (y * textHeight);
 425                     }
 426
 427                     Cell cell = new Cell();
 428                     cell.setImage(image.getSubimage(x * textWidth,
 429                             y * textHeight, width, height));
 430
 431                     cells[x][y] = cell;
 432                 }
 433             }
 434
 435             lastTextWidth = textWidth;
 436             lastTextHeight = textHeight;
 437         }
 438
 439         if ((left + getWidth()) > cellColumns) {
 440             left = cellColumns - getWidth();
 441         }
 442         if (left < 0) {
 443             left = 0;
 444         }
 445         if ((top + getHeight()) > cellRows) {
 446             top = cellRows - getHeight();
 447         }
 448         if (top < 0) {
 449             top = 0;
 450         }
 451     }
 452
 453     /**
 454      * Get the top corner to render.
 455      *
 456      * @return the top row
 457      */
 458     public int getTop() {
 459         return top;
 460     }
 461
 462     /**
 463      * Set the top corner to render.
 464      *
 465      * @param top the new top row
 466      */
 467     public void setTop(final int top) {
 468         this.top = top;
 469         if (this.top > cellRows - getHeight()) {
 470             this.top = cellRows - getHeight();
 471         }
 472         if (this.top < 0) {
 473             this.top = 0;
 474         }
 475     }
 476
 477     /**
 478      * Get the left corner to render.
 479      *
 480      * @return the left column
 481      */
 482     public int getLeft() {
 483         return left;
 484     }
 485
 486     /**
 487      * Set the left corner to render.
 488      *
 489      * @param left the new left column
 490      */
 491     public void setLeft(final int left) {
 492         this.left = left;
 493         if (this.left > cellColumns - getWidth()) {
 494             this.left = cellColumns - getWidth();
 495         }
 496         if (this.left < 0) {
 497             this.left = 0;
 498         }
 499     }
 500
 501     /**
 502      * Get the number of text cell rows for this image.
 503      *
 504      * @return the number of rows
 505      */
 506     public int getRows() {
 507         return cellRows;
 508     }
 509
 510     /**
 511      * Get the number of text cell columns for this image.
 512      *
 513      * @return the number of columns
 514      */
 515     public int getColumns() {
 516         return cellColumns;
 517     }
 518
 519     /**
 520      * Get the raw (unprocessed) image.
 521      *
 522      * @return the image
 523      */
 524     public BufferedImage getImage() {
 525         return originalImage;
 526     }
 527
 528     /**
 529      * Set the raw image, and reprocess to make the visible image.
 530      *
 531      * @param image the new image
 532      */
 533     public void setImage(final BufferedImage image) {
 534         this.originalImage = image;
 535         this.image = null;
 536         sizeToImage(true);
 537     }
 538
 539     /**
 540      * Get the visible (processed) image.
 541      *
 542      * @return the image that is currently on screen
 543      */
 544     public BufferedImage getVisibleImage() {
 545         return image;
 546     }
 547
 548     /**
 549      * Get the scaling strategy.
 550      *
 551      * @return Scale.NONE, Scale.STRETCH, etc.
 552      */
 553     public Scale getScaleType() {
 554         return scale;
 555     }
 556
 557     /**
 558      * Set the scaling strategy.
 559      *
 560      * @param scale Scale.NONE, Scale.STRETCH, etc.
 561      */
 562     public void setScaleType(final Scale scale) {
 563         this.scale = scale;
 564         this.image = null;
 565         sizeToImage(true);
 566     }
 567
 568     /**
 569      * Get the scale factor.
 570      *
 571      * @return the scale factor
 572      */
 573     public double getScaleFactor() {
 574         return scaleFactor;
 575     }
 576
 577     /**
 578      * Set the scale factor.  1.0 means no scaling.
 579      *
 580      * @param scaleFactor the new scale factor
 581      */
 582     public void setScaleFactor(final double scaleFactor) {
 583         this.scaleFactor = scaleFactor;
 584         image = null;
 585         sizeToImage(true);
 586     }
 587
 588     /**
 589      * Get the rotation, as degrees.
 590      *
 591      * @return the rotation in degrees
 592      */
 593     public int getRotation() {
 594         switch (clockwise) {
 595         case 0:
 596             return 0;
 597         case 1:
 598             return 90;
 599         case 2:
 600             return 180;
 601         case 3:
 602             return 270;
 603         default:
 604             // Don't know how this happened, but fix it.
 605             clockwise = 0;
 606             image = null;
 607             sizeToImage(true);
 608             return 0;
 609         }
 610     }
 611
 612     /**
 613      * Set the rotation, as degrees clockwise.
 614      *
 615      * @param rotation 0, 90, 180, or 270
 616      */
 617     public void setRotation(final int rotation) {
 618         switch (rotation) {
 619         case 0:
 620             clockwise = 0;
 621             break;
 622         case 90:
 623             clockwise = 1;
 624             break;
 625         case 180:
 626             clockwise = 2;
 627             break;
 628         case 270:
 629             clockwise = 3;
 630             break;
 631         default:
 632             // Don't know how this happened, but fix it.
 633             clockwise = 0;
 634             break;
 635         }
 636
 637         image = null;
 638         sizeToImage(true);
 639     }
 640
 641     /**
 642      * Scale an image by to be scaleFactor size.
 643      *
 644      * @param image the image to scale
 645      * @param factor the scale to make the new image
 646      * @param width the number of text cell columns for the destination image
 647      * @param height the number of text cell rows for the destination image
 648      * @param textWidth the width in pixels for one text cell
 649      * @param textHeight the height in pixels for one text cell
 650      */
 651     private BufferedImage scaleImage(final BufferedImage image,
 652         final double factor, final int width, final int height,
 653         final int textWidth, final int textHeight) {
 654
 655         if ((scale == Scale.NONE) && (Math.abs(factor - 1.0) < 0.03)) {
 656             // If we are within 3% of 1.0, just return the original image.
 657             return image;
 658         }
 659
 660         int destWidth = 0;
 661         int destHeight = 0;
 662         int x = 0;
 663         int y = 0;
 664
 665         BufferedImage newImage = null;
 666
 667         switch (scale) {
 668         case NONE:
 669             destWidth = (int) (image.getWidth() * factor);
 670             destHeight = (int) (image.getHeight() * factor);
 671             newImage = new BufferedImage(destWidth, destHeight,
 672                 BufferedImage.TYPE_INT_ARGB);
 673             break;
 674         case STRETCH:
 675             destWidth = width * textWidth;
 676             destHeight = height * textHeight;
 677             newImage = new BufferedImage(destWidth, destHeight,
 678                 BufferedImage.TYPE_INT_ARGB);
 679             break;
 680         case SCALE:
 681             double a = (double) image.getWidth() / image.getHeight();
 682             double b = (double) (width * textWidth) / (height * textHeight);
 683             assert (a > 0);
 684             assert (b > 0);
 685
 686             /*
 687             System.err.println("Scale: original " + image.getWidth() +
 688                 "x" + image.getHeight());
 689             System.err.println("         screen " + (width * textWidth) +
 690                 "x" + (height * textHeight));
 691             System.err.println("A " + a + " B " + b);
 692              */
 693
 694             if (a > b) {
 695                 // Horizontal letterbox
 696                 destWidth = width * textWidth;
 697                 destHeight = (int) (destWidth / a);
 698                 y = ((height * textHeight) - destHeight) / 2;
 699                 assert (y >= 0);
 700                 /*
 701                 System.err.println("Horizontal letterbox: " + destWidth +
 702                     "x" + destHeight + ", Y offset " + y);
 703                  */
 704             } else {
 705                 // Vertical letterbox
 706                 destHeight = height * textHeight;
 707                 destWidth = (int) (destHeight * a);
 708                 x = ((width * textWidth) - destWidth) / 2;
 709                 assert (x >= 0);
 710                 /*
 711                 System.err.println("Vertical letterbox: " + destWidth +
 712                     "x" + destHeight + ", X offset " + x);
 713                  */
 714             }
 715             newImage = new BufferedImage(width * textWidth, height * textHeight,
 716                 BufferedImage.TYPE_INT_ARGB);
 717             break;
 718         }
 719
 720         java.awt.Graphics gr = newImage.createGraphics();
 721         if (scale == Scale.SCALE) {
 722             gr.setColor(scaleBackColor);
 723             gr.fillRect(0, 0, width * textWidth, height * textHeight);
 724         }
 725         gr.drawImage(image, x, y, destWidth, destHeight, null);
 726         gr.dispose();
 727         return newImage;
 728     }
 729
 730     /**
 731      * Rotate an image either clockwise or counterclockwise.
 732      *
 733      * @param image the image to scale
 734      * @param clockwise number of turns clockwise
 735      */
 736     private BufferedImage rotateImage(final BufferedImage image,
 737         final int clockwise) {
 738
 739         if (clockwise % 4 == 0) {
 740             return image;
 741         }
 742
 743         BufferedImage newImage = null;
 744
 745         if (clockwise % 4 == 1) {
 746             // 90 degrees clockwise
 747             newImage = new BufferedImage(image.getHeight(), image.getWidth(),
 748                 BufferedImage.TYPE_INT_ARGB);
 749             for (int x = 0; x < image.getWidth(); x++) {
 750                 for (int y = 0; y < image.getHeight(); y++) {
 751                     newImage.setRGB(y, x,
 752                         image.getRGB(x, image.getHeight() - 1 - y));
 753                 }
 754             }
 755         } else if (clockwise % 4 == 2) {
 756             // 180 degrees clockwise
 757             newImage = new BufferedImage(image.getWidth(), image.getHeight(),
 758                 BufferedImage.TYPE_INT_ARGB);
 759             for (int x = 0; x < image.getWidth(); x++) {
 760                 for (int y = 0; y < image.getHeight(); y++) {
 761                     newImage.setRGB(x, y,
 762                         image.getRGB(image.getWidth() - 1 - x,
 763                             image.getHeight() - 1 - y));
 764                 }
 765             }
 766         } else if (clockwise % 4 == 3) {
 767             // 270 degrees clockwise
 768             newImage = new BufferedImage(image.getHeight(), image.getWidth(),
 769                 BufferedImage.TYPE_INT_ARGB);
 770             for (int x = 0; x < image.getWidth(); x++) {
 771                 for (int y = 0; y < image.getHeight(); y++) {
 772                     newImage.setRGB(y, x,
 773                         image.getRGB(image.getWidth() - 1 - x, y));
 774                 }
 775             }
 776         }
 777
 778         return newImage;
 779     }
 780
 781     // ------------------------------------------------------------------------
 782     // EditMenuUser -----------------------------------------------------------
 783     // ------------------------------------------------------------------------
 784
 785     /**
 786      * Check if the cut menu item should be enabled.
 787      *
 788      * @return true if the cut menu item should be enabled
 789      */
 790     public boolean isEditMenuCut() {
 791         return false;
 792     }
 793
 794     /**
 795      * Check if the copy menu item should be enabled.
 796      *
 797      * @return true if the copy menu item should be enabled
 798      */
 799     public boolean isEditMenuCopy() {
 800         return true;
 801     }
 802
 803     /**
 804      * Check if the paste menu item should be enabled.
 805      *
 806      * @return true if the paste menu item should be enabled
 807      */
 808     public boolean isEditMenuPaste() {
 809         return false;
 810     }
 811
 812     /**
 813      * Check if the clear menu item should be enabled.
 814      *
 815      * @return true if the clear menu item should be enabled
 816      */
 817     public boolean isEditMenuClear() {
 818         return false;
 819     }
 820
 821 }