Swing Event Handling: ActionListener & MouseListener - ඔබේ UI වලට ජීවය දෙමු!

ආයුබෝවන් මචංලා! කොහොමද ඉතින්? අද අපි කතා කරන්න යන්නේ Java Swing වලදී interactive, පණ තියෙන Application හදනකොට අත්‍යවශ්‍යම දෙයක් ගැන. ඒ තමයි Event Handling. කවුරු හරි GUI එකක් Click කරනකොට, Text Box එකකට ටයිප් කරනකොට, Keyboard එකේ button එකක් ඔබනකොට අපේ Application එකට ඒවා අඳුනගෙන ඒවට හරියට react කරන්න පුළුවන් වෙන්න එපැයි, නේද? ඒක තමයි Event Handling කියන්නේ. හරියට අපේ App එක අවට ලෝකේ වෙනදේට ඇහුම්කන් දෙනවා වගේ වැඩක්.

අද අපි විශේෂයෙන්ම බලමු ActionListener එකයි, MouseListener එකයි පාවිච්චි කරලා කොහොමද අපේ Swing Components වලට ජීවය දෙන්නේ කියලා. එහෙනම් වැඩේට බහිමුද?

Event Handling කියන්නේ මොකක්ද? - තේරුම් ගනිමු සරලව

සරලවම කිව්වොත්, Event එකක් කියන්නේ අපේ Application එකේ user කෙනෙක් කරන ක්‍රියාවක් (User Action) නැත්නම් System එකෙන් වෙන දෙයක්. උදාහරණයක් විදිහට:

• බොත්තමක් ක්ලික් කිරීම (Button Click)
• Mouse pointer එකක් component එකක් උඩින් යැවීම (Mouse Hover)
• Keyboard එකෙන් අකුරක් ටයිප් කිරීම (Key Press)
• Window එකක් close කිරීම (Window Closing)

මෙහෙම Event එකක් වුණාම, අපේ Application එකට ඒ ගැන දැනුම් දෙන්න ඕනේ. ඒ දැනුම් දීම කරන්නේ Event Source එකක් මගින්. ඊට පස්සේ, ඒ Event එකට ප්‍රතිචාර දක්වන්න පුළුවන් විදිහට අපි code ලියන්න ඕනේ. ඒකට තමයි Event Listener කියන්නේ. Listener එකක් Event එකට ඇහුම්කන් දීලා, ඒක detect වුණාම නිශ්චිත කාර්යයක් කරනවා.

Swing වලදී Event Handling වැඩ කරන්නේ Delegation Event Model එකට අනුවයි. මෙතනදී Event Source (උදා: JButton) එක Event Listener (අපේ ActionListener) එකට Event එකක් වුණා කියලා දැනුම් දෙනවා.

ActionListener - බොත්තම් වලට පණ දෙමු!

ඔබ GUI එකක් හදනකොට වැඩිපුරම පාවිච්චි කරන දෙයක් තමයි Buttons. Button එකක් click කරාම මොකක් හරි වැඩක් වෙන්න ඕනේ නේද? ඒ වැඩේට තමයි ActionListener Interface එක පාවිච්චි කරන්නේ.

ActionListener Interface එකේ තියෙන්නේ එකම එක method එකයි: public void actionPerformed(ActionEvent e). මේ method එක තමයි Button එක click කරාම නැත්නම් Enter key එක press කරාම Automatic ව activate වෙන්නේ.

උදාහරණයක් බලමු: සරල Click Counter එකක්

අපි හදමු පොඩි Application එකක්. ඒකේ Button එකක් තියෙනවා, ඒ Button එක click කරාම "Clicked!" කියලා Message එකක් Console එකේ Print වෙනවා.

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class MyActionListenerApp extends JFrame {

    private JLabel clickCountLabel;
    private int clickCount = 0;

    public MyActionListenerApp() {
        setTitle("ActionListener Example SC Guide");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null); // Center the window

        JPanel panel = new JPanel();
        JButton clickButton = new JButton("Click Me!");
        clickCountLabel = new JLabel("Clicks: 0");

        // ActionListener එක implement කරමු
        clickButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                clickCount++;
                clickCountLabel.setText("Clicks: " + clickCount);
                System.out.println("Button Clicked! Current Clicks: " + clickCount);
            }
        });

        panel.add(clickButton);
        panel.add(clickCountLabel);
        add(panel);
        setVisible(true);
    }

    public static void main(String[] args) {
        // GUI එක Event Dispatch Thread (EDT) එකේ run කරන්න ඕනේ
        SwingUtilities.invokeLater(MyActionListenerApp::new);
    }
}

මේ Code එකේදී අපි කරේ, JButton එකක් හදලා, ඒකට ActionListener එකක් add කරපු එකයි. actionPerformed method එක ඇතුලේ අපි clickCount එක වැඩි කරලා JLabel එක update කරා. දැක්කා නේද? Button එකට පණ ආවා!

MouseListener - මවුස් එකට ඇහුම්කන් දෙමු!

MouseListener කියන්නේ Mouse එක සම්බන්ධ Events handle කරන්න පාවිච්චි කරන Interface එකක්. මේකේ Methods 5ක් තියෙනවා:

• mouseClicked(MouseEvent e): Mouse button එක Click කරලා Release කරාම.
• mousePressed(MouseEvent e): Mouse button එක Press කරපු ගමන්.
• mouseReleased(MouseEvent e): Mouse button එක Release කරපු ගමන්.
• mouseEntered(MouseEvent e): Mouse pointer එක Component එකකට ඇතුල් වුණාම.
• mouseExited(MouseEvent e): Mouse pointer එක Component එකකින් එලියට ගියාම.

මේ Methods 5ම Implement කරන්න ඕනේ නිසා, ගොඩක් වෙලාවට අපි පාවිච්චි කරන්නේ MouseAdapter කියන Abstract Class එක. මේක MouseListener Interface එක Implement කරන Class එකක්. අපිට ඕන Methods ටික විතරක් Override කරන්න පුළුවන්. ඒක නම් සිරා වැඩක් නේද?

උදාහරණයක් බලමු: Mouse Clicks Detect කරමු

අපි හදමු පොඩි JPanel එකක්. ඒක උඩ Mouse එක Click කරාම Click කරපු තැන Coordinate Print වෙන විදිහට. Mouse එක JPanel එකට ඇතුල් වුණාම සහ එලියට ගියාම Message Print වෙන්නත් හදමු.

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class MyMouseListenerApp extends JFrame {

    private JLabel statusLabel;
    private JPanel mousePanel;

    public MyMouseListenerApp() {
        setTitle("MouseListener Example SC Guide");
        setSize(500, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        setLayout(new BorderLayout());

        statusLabel = new JLabel("Ready...");
        add(statusLabel, BorderLayout.SOUTH); // Status bar at the bottom

        mousePanel = new JPanel();
        mousePanel.setBackground(Color.LIGHT_GRAY);
        mousePanel.setBorder(BorderFactory.createLineBorder(Color.DARK_GRAY, 2));
        add(mousePanel, BorderLayout.CENTER);

        // MouseListener එක MouseAdapter පාවිච්චි කරලා
        mousePanel.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                statusLabel.setText("Mouse Clicked at: (" + e.getX() + ", " + e.getY() + ")");
                System.out.println("Panel Clicked at: (" + e.getX() + ", " + e.getY() + ")");
            }

            @Override
            public void mouseEntered(MouseEvent e) {
                mousePanel.setBackground(Color.CYAN); // Change color on entry
                statusLabel.setText("Mouse Entered the panel!");
                System.out.println("Mouse Entered");
            }

            @Override
            public void mouseExited(MouseEvent e) {
                mousePanel.setBackground(Color.LIGHT_GRAY); // Revert color on exit
                statusLabel.setText("Mouse Exited the panel!");
                System.out.println("Mouse Exited");
            }
        });

        setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(MyMouseListenerApp::new);
    }
}

දැන් මේ Code එක Run කරලා බලන්න. Mouse එක Panel එක උඩින් අරන් යනකොට, එලියට ගන්නකොට, Click කරනකොට ඒ හැමදෙයක්ම අපිට Detect කරගන්න පුළුවන් නේද? ඒක තමයි MouseListener එකේ ආතල් එක.

පොඩි Tips ටිකක්! - වැඩේ ලේසි කරගන්න

Event Handling කරනකොට ඔයාට තව ගොඩක් දේවල් දැනගන්න පුළුවන්. මෙන්න පොඩි Tips ටිකක්:

1. Event Dispatch Thread (EDT): Swing Components සියල්ලම Access කරන්න ඕනේ EDT එක ඇතුලෙන්. අපි SwingUtilities.invokeLater() පාවිච්චි කරන්නේ මේක සහතික කරගන්නයි. මේක කරන්නේ නැත්නම් GUI Freez වෙන්න පුළුවන් නැත්නම් Undesired Behaviors එන්න පුළුවන්. මේක හොඳට මතක තියාගන්න ඕනේ වැදගත් දෙයක්.
2. Other Listeners: Swing වල තව ගොඩක් Listener Interfaces තියෙනවා. උදාහරණයක් විදිහට: KeyListener (Keyboard events වලට), WindowListener (Window events වලට), ItemListener (Checkbox, RadioButton වගේ දේවල් වලට) වගේ ගොඩක් ඒවා තියෙනවා. ඔයාගේ Project එකේ අවශ්‍යතාවය අනුව ඔයාට ඒවා Use කරන්න පුළුවන්.
3. Multiple Listeners: එකම Component එකකට Listeners කීපයක් Add කරන්න පුළුවන්. ඒ වගේම එකම Listener Object එකක් Listeners කීපයකට Add කරන්නත් පුළුවන්.

Lambda Expressions: Java 8 ඉඳලා අපිට Functional Interface (එකම එක Abstract method එකක් තියෙන Interface) වෙනුවෙන් Lambda Expressions පාවිච්චි කරන්න පුළුවන්. ActionListener එකත් Functional Interface එකක් නිසා, Code එක තවත් ලස්සනට ලියන්න පුළුවන්.

        clickButton.addActionListener(e -> {
            clickCount++;
            clickCountLabel.setText("Clicks: " + clickCount);
            System.out.println("Button Clicked! Current Clicks: " + clickCount);
        });
        

දැන් බලන්න කොච්චර කෙටිද කියලා! මේකනම් සිරාවටම සුපිරි වැඩක්!

ඉතින් මොකද කියන්නේ?

දැන් ඔයාලට Event Handling කියන්නේ මොකක්ද, ActionListener සහ MouseListener කොහොමද පාවිච්චි කරන්නේ කියලා හොඳ අදහසක් ඇති, නේද? මේක තමයි interactive GUI Applications හදන්න තියෙන මුලිකම පදනම. මේක තේරුම් ගත්තම, ඔයාගේ Swing Projects වලට පණ දෙන්න එක තැනක නවතින්නේ නැහැ!

ගෙදර ගිහින් අනිවාර්යෙන්ම මේ Code ටික Try කරලා බලන්න. පොඩි පොඩි වෙනස්කම් කරලා බලන්න. ඊට පස්සේ Keyboard Listener එකක් හදලා බලන්න පුළුවන්ද කියලා. එතකොට තමයි වැඩේ ගාණට තේරෙන්නේ!

මේ Article එක ගැන මොකද හිතන්නේ? ඔයාට ප්‍රශ්න තියෙනවද? එහෙම නැත්නම් මේ වගේ තව මොන Topics ගැනද දැනගන්න ඕනේ කියලා පහලින් Comment එකක් දාලා යන්න. ඔයාගේ ප්‍රතිචාර අපිට ගොඩක් වටිනවා! අපි ඊළඟ Article එකෙන් හම්බවෙමු! තෙරුවන් සරණයි!