Java 2D Graphics: රූප අඳිමු, පාට දාමු! | SC Guide

කොහොමද යාලුවනේ!

අද අපි කතා කරමු Java program වල ලස්සන graphics හදන හැටි ගැන. ඔයා game එකක්, data visualization tool එකක්, නැත්නම් ලස්සන user interface එකක් හදන්න හිතාගෙන ඉන්නවා නම්, මේ Java 2D Graphics කියන දේ ඔයාට අනිවාර්යයෙන්ම දැනගන්න ඕන දෙයක්. මේක හරිම powerful API එකක්, ඒ වගේම මුලින් ඉගෙන ගන්නත් ලේසියි.

ඉතින්, Java 2D Graphics කියන්නේ මොකක්ද? සරලව කිව්වොත්, Java application එකක් ඇතුළේ 2D (ද්වි-මාන) රූප, හැඩතල, අකුරු, සහ පින්තූර අඳින්න, පාට කරන්න, ඒවායේ ප්‍රමාණය වෙනස් කරන්න, එහෙම නැත්නම් කරකවන්න පුළුවන් විදියට හදපු tools ටිකක්. මේක Swing (හෝ AWT) components එක්ක වැඩ කරන නිසා, ඔයාට ඔයාගේ GUI application වලට visual elements එකතු කරන්න පුළුවන්.

මේ ලිපියෙන් අපි බලමු Java 2D Graphics පාවිච්චි කරලා කොහොමද මූලික හැඩතල (shapes), අකුරු (text), සහ පින්තූර (images) අඳින්නේ කියලා. අපි හැම step එකක්ම පැහැදිලිව කතා කරනවා, ඒ වගේම code examples එක්කම. එහෙනම්, අපි පටන් ගමු!

අපි පටන් ගමු: Setup එක (Let's Start: The Setup)

Java වල Graphics අඳින්න අපිට Swing (හෝ AWT) components ඕනේ. මේක හරියට කැන්වසයක් වගේ. අපි රූප අඳින්නේ මේ කැන්වසය උඩ. සාමාන්‍යයෙන්, අපි මේකට JPanel එකක් පාවිච්චි කරනවා. මොකද JPanel එකක් කියන්නේ අපිට ඕන විදියට customize කරන්න පුළුවන් lightweight component එකක්.

අපි කරන්න ඕන දේ තමයි, JPanel එකක් extend කරලා, ඒකේ paintComponent(Graphics g) method එක override කරන එක. මේ paintComponent() method එක තමයි Java Swing විසින් component එක draw කරන්න ඕන වුණාම automatically call කරන්නේ. මේකට Graphics object එකක් parameter එකක් විදියට ලැබෙනවා. අපි මේ Graphics object එක Graphics2D object එකකට cast කරගන්නවා, මොකද Graphics2D කියන්නේ Graphics වලට වඩා advanced features තියෙන class එකක්.

හරි, දැන් අපි බලමු මූලික setup එක කොහොමද කරන්නේ කියලා:

import javax.swing.JFrame;
import javax.swing.JPanel;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.Dimension;

public class MyGraphicsApp extends JFrame {

    public MyGraphicsApp() {
        setTitle("මගේ පළමු Java Graphics App"); // Window එකේ Title එක
        setSize(800, 600); // Window එකේ size එක
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // Window එක වහද්දි program එක terminate වෙන්න
        setLocationRelativeTo(null); // Window එක screen එකේ මැදට එන්න

        MyDrawingPanel panel = new MyDrawingPanel();
        add(panel); // අපේ custom panel එක frame එකට එකතු කරනවා
    }

    public static void main(String[] args) {
        // GUI operations main thread එකේ කරන්න ඕන නිසා EventQueue.invokeLater භාවිතා කරනවා
        java.awt.EventQueue.invokeLater(() -> {
            new MyGraphicsApp().setVisible(true);
        });
    }

    // අපේ custom drawing panel class එක
    class MyDrawingPanel extends JPanel {
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g); // මෙය අනිවාර්යයෙන්ම මුලින්ම call කරන්න ඕන
            Graphics2D g2d = (Graphics2D) g; // Graphics object එක Graphics2D විදියට cast කරනවා

            // මේක තමයි අපේ Drawing Canvas එක. 
            // මෙතනින් පස්සේ තමයි අපි රූප, අකුරු, පින්තූර අඳින්නේ.
            
            // උදාහරණයක් විදියට පසුබිම පාට කරමු
            g2d.setColor(Color.LIGHT_GRAY);
            g2d.fillRect(0, 0, getWidth(), getHeight());
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(800, 600);
        }
    }
}

මේ code එකෙන් අපි මූලික JFrame එකක් සහ ඒකට custom JPanel එකක් (MyDrawingPanel) එකතු කරලා තියෙනවා. paintComponent() method එක ඇතුළෙ super.paintComponent(g) call කරන එක වැදගත්. මොකද ඒකෙන් component එකේ default background drawing වගේ දේවල් ටිකක් සිද්ධ වෙනවා. ඊට පස්සේ තමයි අපි Graphics object එක Graphics2D එකකට cast කරගෙන අපේ drawing operations පටන් ගන්නේ.

ප්‍රාථමික හැඩතල අඳිමු (Let's Draw Basic Shapes)

දැන් අපි බලමු Graphics2D පාවිච්චි කරලා කොහොමද විවිධ හැඩතල අඳින්නේ කියලා. හැඩතල අඳින්න කලින්, අපිට ඒවට ඕන කරන පාට තෝරගන්න පුළුවන් setColor() method එකෙන්. මේකට java.awt.Color class එකේ predefined colors (Color.RED, Color.BLUE, etc.) පාවිච්චි කරන්න පුළුවන්, නැත්නම් ඔයාටම custom RGB color එකක් හදාගන්නත් පුළුවන් (new Color(R, G, B)).

ඉරි (Lines)

ඉරක් අඳින්න අපි drawLine(x1, y1, x2, y2) method එක පාවිච්චි කරනවා. මෙතන (x1, y1) කියන්නේ ඉර පටන් ගන්න තැන, (x2, y2) කියන්නේ ඉර ඉවර වෙන තැන.

// ... inside MyDrawingPanel's paintComponent method ...

g2d.setColor(Color.BLUE); // නිල් පාට තෝරනවා
g2d.drawLine(50, 50, 200, 50); // (50,50) ඉඳන් (200,50) දක්වා නිල් ඉරක් අඳිනවා
g2d.drawLine(50, 60, 50, 200); // සිරස් ඉරක්

කොටු (Rectangles)

කොටු අඳින්න, අපිට drawRect(x, y, width, height) method එක පාවිච්චි කරන්න පුළුවන්. මේකෙන් කොටුවේ දාර විතරක් අඳිනවා. කොටුවක් පාටින් පුරවන්න ඕන නම්, fillRect(x, y, width, height) method එක පාවිච්චි කරන්න පුළුවන්. මෙතන (x, y) කියන්නේ කොටුවේ වම්-උඩ කෙළවරේ co-ordinates, width එක සහ height එක තමයි කොටුවේ පළලයි උසයි.

// ... inside MyDrawingPanel's paintComponent method ...

g2d.setColor(Color.RED); // රතු පාට
g2d.drawRect(50, 100, 150, 80); // (50,100) ඉඳන් 150 පළල, 80 උස කොටුවක්

g2d.setColor(Color.GREEN); // කොළ පාට
g2d.fillRect(250, 100, 150, 80); // (250,100) ඉඳන් 150 පළල, 80 උස කොළ පාටින් පුරවපු කොටුවක්

වටකුරු හැඩතල (Ovals/Circles)

වටකුරු හැඩතල අඳින්න, අපි drawOval(x, y, width, height) සහ fillOval(x, y, width, height) method භාවිතා කරනවා. මේකත් Rectangles වගේමයි, හැබැයි මේකේදී අඳින්නේ x, y, width, height කියන දේවල් ඇතුළේ තියෙන ellipse එකක්. width එකයි height එකයි සමාන වුණොත් Circle එකක් අඳින්න පුළුවන්.

// ... inside MyDrawingPanel's paintComponent method ...

g2d.setColor(Color.ORANGE); // තැඹිලි පාට
g2d.drawOval(50, 200, 100, 100); // (50,200) ඉඳන් 100x100 ප්‍රමාණයේ වටකුරු හැඩයක් (Circle එකක්)

g2d.setColor(Color.MAGENTA); // දම් පාට
g2d.fillOval(250, 200, 100, 100); // (250,200) ඉඳන් 100x100 ප්‍රමාණයේ දම් පාටින් පුරවපු වටකුරු හැඩයක්

මේ වගේම Arc, RoundRect, Polygon වගේ තව හැඩතලත් අඳින්න පුළුවන්. ඒවා ගැන ඔයාට පස්සේ ඉගෙන ගන්න පුළුවන්.

ලස්සනට අකුරු ලියමු (Let's Write Beautiful Text)

රූප වගේම, අපිට අපේ program වලට අකුරුත් add කරන්න පුළුවන්. ඒකට අපි drawString(String text, int x, int y) method එක පාවිච්චි කරනවා. මෙතන x, y කියන්නේ text එක පටන් ගන්න තැන co-ordinates (වම් කෙළවර, baseline එක).

අකුරුවල font එක, size එක, style එක වෙනස් කරන්න පුළුවන් setFont(Font font) method එකෙන්. මේකට java.awt.Font class එක පාවිච්චි කරනවා. Font object එකක් හදද්දි, Font name (eg: "Arial", "Serif"), Style (Font.PLAIN, Font.BOLD, Font.ITALIC), සහ Size එක දෙන්න ඕන.

// ... inside MyDrawingPanel's paintComponent method ...

g2d.setColor(Color.DARK_GRAY); // තද අළු පාට
g2d.setFont(new Font("Serif", Font.BOLD, 28)); // "Serif" font එක, Bold, size 28
g2d.drawString("SC Guide - Java Graphics", 50, 350); // අකුරු අඳිනවා

g2d.setColor(new Color(0, 120, 0)); // Custom කොළ පාටක්
g2d.setFont(new Font("Arial", Font.ITALIC | Font.PLAIN, 18)); // "Arial" font එක, Italic සහ Plain, size 18
g2d.drawString("දැන් ඔයාට ලස්සනට අකුරු ලියන්නත් පුළුවන්!", 50, 380);

ඔයාට කැමති Font එකක්, Size එකක්, Style එකක් පාවිච්චි කරලා ඔයාගේ UI එකට ලස්සනක් දෙන්න පුළුවන්. Font.ITALIC | Font.BOLD වගේ දේවල් පාවිච්චි කරලා එකපාර style දෙකක් combine කරන්නත් පුළුවන්.

පින්තූර දාමු (Let's Add Pictures)

අපේ program වලට images (පින්තූර) add කරන එකත් හරිම ලේසියි. මේකට අපි javax.imageio.ImageIO class එක පාවිච්චි කරනවා image එක load කරගන්න. ඊට පස්සේ Graphics2D එකේ drawImage() method එකෙන් ඒ image එක අපේ panel එක උඩ අඳිනවා.

Image එකක් load කරද්දී IOException එකක් එන්න පුළුවන්, මොකද file එක නැති වෙන්න, නැත්නම් file එක corrupt වෙන්න පුළුවන්. ඒ නිසා අපි මේක try-catch block එකක් ඇතුළේ දාන එක වැදගත්.

Image file එක (e.g., sc_logo.png) ඔයාගේ project folder එකේ root එකේ හෝ resource folder එකක් ඇතුළේ තියෙන්න ඕන. එතකොට තමයි program එකට ඒක හොයාගන්න පුළුවන් වෙන්නේ.

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

// ... inside MyDrawingPanel's paintComponent method ...

try {
    // "sc_logo.png" කියන්නේ ඔයාගේ image file එකේ නම
    // මේක project එකේ root folder එකේ තියෙන්න ඕන
    BufferedImage image = ImageIO.read(new File("sc_logo.png")); 
    if (image != null) {
        // image එක අඳිනවා (500, 50) කියන co-ordinates වලට
        g2d.drawImage(image, 500, 50, null); 
        
        // Image එක යටතේ පොඩි text එකක්
        g2d.setColor(Color.BLUE);
        g2d.setFont(new Font("SansSerif", Font.PLAIN, 14));
        g2d.drawString("මේ තියෙන්නේ අපේ Image එක!", 500, 180); // Y co-ordinate එක image එකේ උසට වඩා වැඩි තැනක
    } else {
        g2d.setColor(Color.RED);
        g2d.drawString("Image එක load කරන්න බැරි වුණා: Image object එක null", 500, 50);
    }
} catch (IOException e) {
    g2d.setColor(Color.RED);
    g2d.drawString("Image load කරන්න බැරි වුණා: " + e.getMessage(), 500, 50);
    System.err.println("Image loading error: " + e.getMessage());
}

මේ code එක ඔයාගේ paintComponent method එකට දාලා, project folder එකේ sc_logo.png වගේ image එකක් දැම්මොත්, ඔයාට පුළුවන් ඒ image එක program එකේ display කරන්න.

drawImage() method එකේ අන්තිම parameter එක තමයි ImageObserver. සරල scenario වලදී අපිට null දෙන්න පුළුවන්. Complex cases වලදී (උදා: image එක load වෙද්දී update කරන්න ඕන නම්) මේක වැදගත් වෙනවා.

ඉතින් මොකද කරන්නේ? (So, What's Next?)

අද අපි Java 2D Graphics වල මූලික දේවල් ගොඩක් කතා කළා. Shapes (ඉරි, කොටු, වටකුරු හැඩතල), Text (අකුරු), සහ Images (පින්තූර) කොහොමද Java program එකක් ඇතුළේ අඳින්නේ කියලා අපි බැලුවා. මේවා තමයි ඕනෑම graphics application එකක Building Blocks.

මේ දැනුමෙන් ඔයාට ගොඩක් දේවල් කරන්න පුළුවන්:

• Simple games (ටෙට්‍රිස්, snake වගේ)
• Data visualization (charts, graphs)
• Custom UI components
• Drawing tools

මේක Graphics2D වල මූලිකම පියවර විතරයි. මේකේ Stroke, Gradient, Transparency, Transformation (rotate, scale, translate) වගේ තව ගොඩක් advanced දේවල් තියෙනවා. ඒවා ගැනත් අපි ඉදිරියේදී කතා කරමු.

දැන් ඔයාට තියෙන්නේ මේ code එක ඔයාගේ computer එකේ run කරලා බලන එක. Code එක modify කරලා අලුත් දේවල් අඳින්න උත්සාහ කරන්න. පාට වෙනස් කරන්න, හැඩතල වල size වෙනස් කරන්න, අකුරු වල font එක වෙනස් කරන්න. මේ හැමදේම කරලා අත්දැකීම් ගන්න. ඒක තමයි හොඳම විදිය ඉගෙන ගන්න.

මේ ලිපිය ගැන ඔයාට මොනවා හරි ප්‍රශ්න තියෙනවා නම්, නැත්නම් ඔයාට මේ වගේම තව මොනවා හරි subject එකක් ගැන දැනගන්න ඕන නම්, පහළ comment section එකේ අහන්න. ඔයාගේ අදහස් අපිට ගොඩක් වටිනවා.

එහෙනම්, තවත් අලුත් ලිපියකින් හමුවෙමු! Happy Coding! ❤️