// Accessible 인터페이스 사용 예시
JButton button = new JButton("클릭하세요");
Accessible accessible = button;
AccessibleContext context = accessible.getAccessibleContext();

// 접근성 정보 출력
System.out.println("역할: " + context.getAccessibleRole());
System.out.println("이름: " + context.getAccessibleName());
System.out.println("설명: " + context.getAccessibleDescription());

// 다양한 AccessibleRole 예시
JButton button = new JButton("확인");
System.out.println(button.getAccessibleContext().getAccessibleRole()); 
// 출력: push button

JTextField textField = new JTextField();
System.out.println(textField.getAccessibleContext().getAccessibleRole()); 
// 출력: text

JCheckBox checkBox = new JCheckBox("동의합니다");
System.out.println(checkBox.getAccessibleContext().getAccessibleRole()); 
// 출력: check box

JLabel label = new JLabel("이름:");
System.out.println(label.getAccessibleContext().getAccessibleRole()); 
// 출력: label

JButton button = new JButton("클릭");
AccessibleContext context = button.getAccessibleContext();
AccessibleStateSet stateSet = context.getAccessibleStateSet();

// 상태 확인
if (stateSet.contains(AccessibleState.ENABLED)) {
    System.out.println("버튼이 활성화되어 있습니다");
}

if (stateSet.contains(AccessibleState.FOCUSED)) {
    System.out.println("버튼이 포커스를 받았습니다");
}

if (stateSet.contains(AccessibleState.VISIBLE)) {
    System.out.println("버튼이 화면에 보입니다");
}

// 버튼 비활성화
button.setEnabled(false);
stateSet = context.getAccessibleStateSet();

if (!stateSet.contains(AccessibleState.ENABLED)) {
    System.out.println("이제 버튼이 비활성화되었습니다");
}

import javax.swing.*;
import java.awt.*;

public class BadLoginForm extends JFrame {
    public BadLoginForm() {
        setTitle("로그인");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel panel = new JPanel(new GridLayout(3, 2, 10, 10));
        
        // 레이블과 필드를 단순히 나열
        panel.add(new JLabel("아이디"));
        JTextField userField = new JTextField();
        panel.add(userField);
        
        panel.add(new JLabel("비밀번호"));
        JPasswordField passField = new JPasswordField();
        panel.add(passField);
        
        // 버튼에 아이콘만 사용
        JButton loginBtn = new JButton("→");
        JButton cancelBtn = new JButton("✕");
        panel.add(loginBtn);
        panel.add(cancelBtn);
        
        add(panel);
        setVisible(true);
    }
}

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

public class GoodLoginForm extends JFrame {
    public GoodLoginForm() {
        setTitle("로그인");
        setSize(400, 250);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel panel = new JPanel(new GridBagLayout());
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.insets = new Insets(5, 5, 5, 5);
        gbc.fill = GridBagConstraints.HORIZONTAL;
        
        // 아이디 레이블과 필드
        JLabel userLabel = new JLabel("아이디(I):");
        userLabel.setDisplayedMnemonic('I'); // Alt+I로 접근 가능
        gbc.gridx = 0;
        gbc.gridy = 0;
        panel.add(userLabel, gbc);
        
        JTextField userField = new JTextField(20);
        userLabel.setLabelFor(userField); // 레이블과 필드 연결
        
        // 접근성 정보 설정
        userField.getAccessibleContext().setAccessibleName("아이디 입력");
        userField.getAccessibleContext().setAccessibleDescription(
            "로그인할 아이디를 입력하세요. 영문과 숫자를 사용할 수 있습니다.");
        
        gbc.gridx = 1;
        gbc.gridy = 0;
        panel.add(userField, gbc);
        
        // 비밀번호 레이블과 필드
        JLabel passLabel = new JLabel("비밀번호(P):");
        passLabel.setDisplayedMnemonic('P'); // Alt+P로 접근 가능
        gbc.gridx = 0;
        gbc.gridy = 1;
        panel.add(passLabel, gbc);
        
        JPasswordField passField = new JPasswordField(20);
        passLabel.setLabelFor(passField); // 레이블과 필드 연결
        
        // 접근성 정보 설정
        passField.getAccessibleContext().setAccessibleName("비밀번호 입력");
        passField.getAccessibleContext().setAccessibleDescription(
            "로그인할 비밀번호를 입력하세요. 대소문자를 구분합니다.");
        
        gbc.gridx = 1;
        gbc.gridy = 1;
        panel.add(passField, gbc);
        
        // 버튼 패널
        JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        
        // 로그인 버튼
        JButton loginBtn = new JButton("로그인(L)");
        loginBtn.setMnemonic('L'); // Alt+L로 접근 가능
        loginBtn.getAccessibleContext().setAccessibleDescription(
            "입력한 정보로 로그인을 시도합니다");
        
        // 엔터 키로도 로그인 가능하도록
        getRootPane().setDefaultButton(loginBtn);
        
        loginBtn.addActionListener(e -> {
            // 로그인 로직
            System.out.println("로그인 시도");
        });
        
        // 취소 버튼
        JButton cancelBtn = new JButton("취소(C)");
        cancelBtn.setMnemonic('C'); // Alt+C로 접근 가능
        cancelBtn.getAccessibleContext().setAccessibleDescription(
            "로그인을 취소하고 창을 닫습니다");
        
        // ESC 키로도 취소 가능하도록
        cancelBtn.addActionListener(e -> dispose());
        KeyStroke escapeKey = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
        cancelBtn.registerKeyboardAction(
            e -> dispose(),
            escapeKey,
            JComponent.WHEN_IN_FOCUSED_WINDOW
        );
        
        buttonPanel.add(loginBtn);
        buttonPanel.add(cancelBtn);
        
        gbc.gridx = 0;
        gbc.gridy = 2;
        gbc.gridwidth = 2;
        panel.add(buttonPanel, gbc);
        
        // 상태 표시 레이블 (스크린 리더가 읽을 수 있도록)
        JLabel statusLabel = new JLabel(" ");
        statusLabel.getAccessibleContext().setAccessibleName("상태 메시지");
        gbc.gridy = 3;
        panel.add(statusLabel, gbc);
        
        add(panel);
        
        // 초기 포커스 설정
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowOpened(WindowEvent e) {
                userField.requestFocusInWindow();
            }
        });
        
        setVisible(true);
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new GoodLoginForm());
    }
}

import javax.accessibility.*;
import javax.swing.*;

public class AccessibleTextExample {
    public static void main(String[] args) {
        JTextArea textArea = new JTextArea("안녕하세요!\n접근성 테스트입니다.");
        
        AccessibleContext context = textArea.getAccessibleContext();
        AccessibleText accessibleText = context.getAccessibleText();
        
        if (accessibleText != null) {
            // 전체 텍스트 길이
            int charCount = accessibleText.getCharCount();
            System.out.println("전체 문자 수: " + charCount);
            
            // 특정 위치의 문자
            char charAt5 = accessibleText.getAtIndex(
                AccessibleText.CHARACTER, 5);
            System.out.println("5번째 문자: " + charAt5);
            
            // 특정 위치의 단어
            String wordAt5 = accessibleText.getAtIndex(
                AccessibleText.WORD, 5);
            System.out.println("5번째 위치의 단어: " + wordAt5);
            
            // 커서 위치
            int caretPos = accessibleText.getCaretPosition();
            System.out.println("현재 커서 위치: " + caretPos);
            
            // 선택된 텍스트
            String selectedText = accessibleText.getSelectedText();
            if (selectedText != null) {
                System.out.println("선택된 텍스트: " + selectedText);
            }
            
            // 특정 범위의 텍스트
            String textBetween = accessibleText.getTextRange(0, 5);
            System.out.println("0~5 범위의 텍스트: " + textBetween);
        }
    }
}

import javax.accessibility.*;
import javax.swing.*;

public class AccessibleActionExample extends JFrame {
    public AccessibleActionExample() {
        setTitle("동작 접근성 예제");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JButton button = new JButton("저장");
        button.addActionListener(e -> {
            System.out.println("파일이 저장되었습니다!");
        });
        
        // AccessibleAction 정보 확인
        AccessibleContext context = button.getAccessibleContext();
        AccessibleAction action = context.getAccessibleAction();
        
        if (action != null) {
            int actionCount = action.getAccessibleActionCount();
            System.out.println("사용 가능한 동작 수: " + actionCount);
            
            for (int i = 0; i < actionCount; i++) {
                String actionDesc = action.getAccessibleActionDescription(i);
                System.out.println("동작 " + i + ": " + actionDesc);
            }
            
            // 프로그래밍 방식으로 버튼 클릭
            // 보조 기술이 이렇게 버튼을 활성화할 수 있어
            JButton testButton = new JButton("동작 테스트");
            testButton.addActionListener(e -> {
                boolean success = action.doAccessibleAction(0);
                System.out.println("동작 실행 " + 
                    (success ? "성공" : "실패"));
            });
            
            JPanel panel = new JPanel();
            panel.add(button);
            panel.add(testButton);
            add(panel);
        }
        
        setVisible(true);
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new AccessibleActionExample());
    }
}

import javax.accessibility.*;
import javax.swing.*;

public class AccessibleValueExample extends JFrame {
    public AccessibleValueExample() {
        setTitle("값 접근성 예제");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel panel = new JPanel();
        
        // 슬라이더 생성
        JSlider slider = new JSlider(0, 100, 50);
        slider.setMajorTickSpacing(25);
        slider.setMinorTickSpacing(5);
        slider.setPaintTicks(true);
        slider.setPaintLabels(true);
        
        // 접근성 정보 설정
        AccessibleContext context = slider.getAccessibleContext();
        context.setAccessibleName("볼륨 조절");
        context.setAccessibleDescription(
            "0에서 100 사이의 값으로 볼륨을 조절합니다");
        
        // AccessibleValue 사용
        AccessibleValue accessibleValue = context.getAccessibleValue();
        
        if (accessibleValue != null) {
            // 현재 값
            Number currentValue = accessibleValue.getCurrentAccessibleValue();
            System.out.println("현재 값: " + currentValue);
            
            // 최소값
            Number minValue = accessibleValue.getMinimumAccessibleValue();
            System.out.println("최소값: " + minValue);
            
            // 최대값
            Number maxValue = accessibleValue.getMaximumAccessibleValue();
            System.out.println("최대값: " + maxValue);
            
            // 값 변경 버튼
            JButton setButton = new JButton("75로 설정");
            setButton.addActionListener(e -> {
                boolean success = accessibleValue.setCurrentAccessibleValue(75);
                System.out.println("값 설정 " + 
                    (success ? "성공" : "실패"));
            });
            
            panel.add(slider);
            panel.add(setButton);
        }
        
        add(panel);
        setVisible(true);
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new AccessibleValueExample());
    }
}

import javax.accessibility.*;
import javax.swing.*;
import javax.swing.table.*;

public class AccessibleTableExample extends JFrame {
    public AccessibleTableExample() {
        setTitle("테이블 접근성 예제");
        setSize(600, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        // 테이블 데이터
        String[] columnNames = {"이름", "나이", "직업"};
        Object[][] data = {
            {"김철수", 28, "개발자"},
            {"이영희", 32, "디자이너"},
            {"박민수", 25, "기획자"}
        };
        
        JTable table = new JTable(data, columnNames);
        
        // 접근성 정보 설정
        AccessibleContext context = table.getAccessibleContext();
        context.setAccessibleName("직원 목록");
        context.setAccessibleDescription(
            "직원들의 이름, 나이, 직업 정보를 담은 테이블입니다");
        
        // 각 열에 대한 설명 추가
        TableColumnModel columnModel = table.getColumnModel();
        columnModel.getColumn(0).setHeaderValue("이름");
        columnModel.getColumn(1).setHeaderValue("나이");
        columnModel.getColumn(2).setHeaderValue("직업");
        
        // AccessibleTable 정보 확인
        AccessibleTable accessibleTable = context.getAccessibleTable();
        
        if (accessibleTable != null) {
            System.out.println("행 수: " + 
                accessibleTable.getAccessibleRowCount());
            System.out.println("열 수: " + 
                accessibleTable.getAccessibleColumnCount());
            
            // 특정 셀의 설명
            Accessible cellAccessible = 
                accessibleTable.getAccessibleAt(0, 0);
            if (cellAccessible != null) {
                AccessibleContext cellContext = 
                    cellAccessible.getAccessibleContext();
                System.out.println("(0,0) 셀 내용: " + 
                    cellContext.getAccessibleName());
            }
            
            // 열 헤더 정보
            AccessibleTable columnHeader = 
                accessibleTable.getAccessibleColumnHeader();
            if (columnHeader != null) {
                System.out.println("열 헤더가 설정되어 있습니다");
            }
        }
        
        JScrollPane scrollPane = new JScrollPane(table);
        add(scrollPane);
        
        setVisible(true);
    }
    
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new AccessibleTableExample());
    }
}

import javax.accessibility.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class AccessibleColorPicker extends JComponent 
        implements Accessible {
    
    private Color selectedColor = Color.RED;
    private Color[] colors = {
        Color.RED, Color.ORANGE, Color.YELLOW,
        Color.GREEN, Color.BLUE, Color.MAGENTA
    };
    private int selectedIndex = 0;
    
    public AccessibleColorPicker() {
        setPreferredSize(new Dimension(300, 50));
        setFocusable(true);
        
        // 마우스 클릭 처리
        addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                int colorWidth = getWidth() / colors.length;
                int clickedIndex = e.getX() / colorWidth;
                if (clickedIndex >= 0 && clickedIndex < colors.length) {
                    setSelectedIndex(clickedIndex);
                }
            }
        });
        
        // 키보드 내비게이션
        addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                switch (e.getKeyCode()) {
                    case KeyEvent.VK_LEFT:
                        if (selectedIndex > 0) {
                            setSelectedIndex(selectedIndex - 1);
                        }
                        break;
                    case KeyEvent.VK_RIGHT:
                        if (selectedIndex < colors.length - 1) {
                            setSelectedIndex(selectedIndex + 1);
                        }
                        break;
                    case KeyEvent.VK_HOME:
                        setSelectedIndex(0);
                        break;
                    case KeyEvent.VK_END:
                        setSelectedIndex(colors.length - 1);
                        break;
                }
            }
        });
        
        // 포커스 시각화
        addFocusListener(new FocusAdapter() {
            @Override
            public void focusGained(FocusEvent e) {
                repaint();
            }
            
            @Override
            public void focusLost(FocusEvent e) {
                repaint();
            }
        });
    }
    
    private void setSelectedIndex(int index) {
        selectedIndex = index;
        selectedColor = colors[index];
        repaint();
        
        // 접근성 이벤트 발생
        firePropertyChange(
            AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
            null,
            selectedColor
        );
    }
    
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        
        int colorWidth = getWidth() / colors.length;
        
        // 각 색상 그리기
        for (int i = 0; i < colors.length; i++) {
            g.setColor(colors[i]);
            g.fillRect(i * colorWidth, 0, colorWidth, getHeight());
            
            // 선택된 색상 표시
            if (i == selectedIndex) {
                g.setColor(Color.WHITE);
                g.drawRect(i * colorWidth + 2, 2, 
                    colorWidth - 4, getHeight() - 4);
                g.drawRect(i * colorWidth + 3, 3, 
                    colorWidth - 6, getHeight() - 6);
            }
        }
        
        // 포커스 표시
        if (hasFocus()) {
            Graphics2D g2d = (Graphics2D) g;
            g2d.setColor(Color.BLACK);
            g2d.setStroke(new BasicStroke(2, 
                BasicStroke.CAP_BUTT, 
                BasicStroke.JOIN_MITER, 
                10, new float[]{5, 5}, 0));
            g2d.drawRect(1, 1, getWidth() - 2, getHeight() - 2);
        }
    }
    
    public Color getSelectedColor() {
        return selectedColor;
    }
    
    // AccessibleContext 구현
    @Override
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleColorPicker();
        }
        return accessibleContext;
    }
    
    // 내부 AccessibleContext 클래스
    protected class AccessibleColorPicker extends AccessibleJComponent
            implements AccessibleValue {
        
        @Override
        public AccessibleRole getAccessibleRole() {
            return AccessibleRole.SLIDER;
        }
        
        @Override
        public AccessibleStateSet getAccessibleStateSet() {
            AccessibleStateSet states = super.getAccessibleStateSet();
            if (hasFocus()) {
                states.add(AccessibleState.FOCUSED);
            }
            if (isEnabled()) {
                states.add(AccessibleState.ENABLED);
            }
            if (isVisible()) {
                states.add(AccessibleState.VISIBLE);
            }
            states.add(AccessibleState.FOCUSABLE);
            return states;
        }
        
        @Override
        public String getAccessibleName() {
            String name = super.getAccessibleName();
            if (name == null) {
                name = "색상 선택기";
            }
            return name;
        }
        
        @Override
        public String getAccessibleDescription() {
            String desc = super.getAccessibleDescription();
            if (desc == null) {
                desc = "화살표 키로 색상을 선택하세요. " +
                       "현재 선택: " + getColorName(selectedColor);
            }
            return desc;
        }
        
        // AccessibleValue 구현
        @Override
        public Number getCurrentAccessibleValue() {
            return selectedIndex;
        }
        
        @Override
        public boolean setCurrentAccessibleValue(Number n) {
            int newIndex = n.intValue();
            if (newIndex >= 0 && newIndex < colors.length) {
                setSelectedIndex(newIndex);
                return true;
            }
            return false;
        }
        
        @Override
        public Number getMinimumAccessibleValue() {
            return 0;
        }
        
        @Override
        public Number getMaximumAccessibleValue() {
            return colors.length - 1;
        }
        
        @Override
        public AccessibleValue getAccessibleValue() {
            return this;
        }
    }
    
    private String getColorName(Color color) {
        if (color.equals(Color.RED)) return "빨강";
        if (color.equals(Color.ORANGE)) return "주황";
        if (color.equals(Color.YELLOW)) return "노랑";
        if (color.equals(Color.GREEN)) return "초록";
        if (color.equals(Color.BLUE)) return "파랑";
        if (color.equals(Color.MAGENTA)) return "자주";
        return "알 수 없음";
    }
    
    // 테스트용 메인 메서드
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            JFrame frame = new JFrame("접근 가능한 색상 선택기");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            
            AccessibleColorPicker picker = new AccessibleColorPicker();
            picker.getAccessibleContext().setAccessibleName("배경색 선택");
            picker.getAccessibleContext().setAccessibleDescription(
                "문서의 배경색을 선택합니다. " +
                "좌우 화살표 키로 색상을 변경할 수 있습니다.");
            
            JLabel label = new JLabel("선택된 색상: 빨강");
            label.setHorizontalAlignment(SwingConstants.CENTER);
            
            picker.addPropertyChangeListener(
                AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
                e -> {
                    Color color = picker.getSelectedColor();
                    label.setText("선택된 색상: " + 
                        picker.getColorName(color));
                    label.setForeground(color);
                }
            );
            
            JPanel panel = new JPanel(new BorderLayout(10, 10));
            panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));
            panel.add(picker, BorderLayout.CENTER);
            panel.add(label, BorderLayout.SOUTH);
            
            frame.add(panel);
            frame.pack();
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        });
    }
}

import javax.accessibility.*;
import javax.swing.*;
import java.awt.*;
import java.util.*;

public class AccessibilityChecker {
    
    private java.util.List<String> issues = new ArrayList<>();
    
    public void checkComponent(Component component) {
        issues.clear();
        checkComponentRecursive(component, "");
        printReport();
    }
    
    private void checkComponentRecursive(Component comp, String indent) {
        if (!(comp instanceof Accessible)) {
            issues.add(indent + "⚠️ 컴포넌트가 Accessible을 구현하지 않음: " + 
                comp.getClass().getSimpleName());
            return;
        }
        
        Accessible accessible = (Accessible) comp;
        AccessibleContext context = accessible.getAccessibleContext();
        
        if (context == null) {
            issues.add(indent + "❌ AccessibleContext가 null: " + 
                comp.getClass().getSimpleName());
            return;
        }
        
        // 이름 검사
        String name = context.getAccessibleName();
        if (name == null || name.trim().isEmpty()) {
            if (needsName(context.getAccessibleRole())) {
                issues.add(indent + "⚠️ 접근성 이름이 없음: " + 
                    comp.getClass().getSimpleName() + 
                    " (역할: " + context.getAccessibleRole() + ")");
            }
        }
        
        // 설명 검사
        String description = context.getAccessibleDescription();
        if (description == null || description.trim().isEmpty()) {
            if (needsDescription(context.getAccessibleRole())) {
                issues.add(indent + "ℹ️ 접근성 설명이 없음: " + 
                    comp.getClass().getSimpleName());
            }
        }
        
        // 키보드 포커스 검사
        if (comp instanceof JComponent) {
            JComponent jcomp = (JComponent) comp;
            if (isInteractive(context.getAccessibleRole())) {
                if (!jcomp.isFocusable()) {
                    issues.add(indent + "⚠️ 상호작용 가능한 컴포넌트가 " +
                        "포커스를 받을 수 없음: " + 
                        comp.getClass().getSimpleName());
                }
            }
        }
        
        // 레이블 연결 검사 (텍스트 필드의 경우)
        if (comp instanceof JTextField || 
            comp instanceof JTextArea ||
            comp instanceof JPasswordField) {
            
            AccessibleRelationSet relations = 
                context.getAccessibleRelationSet();
            if (relations == null || 
                relations.get(AccessibleRelation.LABELED_BY) == null) {
                issues.add(indent + "⚠️ 텍스트 입력 필드에 " +
                    "레이블이 연결되지 않음: " + 
                    comp.getClass().getSimpleName());
            }
        }
        
        // 자식 컴포넌트 검사
        if (comp instanceof Container) {
            Container container = (Container) comp;
            for (Component child : container.getComponents()) {
                checkComponentRecursive(child, indent + "  ");
            }
        }
    }
    
    private boolean needsName(AccessibleRole role) {
        return role == AccessibleRole.PUSH_BUTTON ||
               role == AccessibleRole.TEXT ||
               role == AccessibleRole.PASSWORD_TEXT ||
               role == AccessibleRole.CHECK_BOX ||
               role == AccessibleRole.RADIO_BUTTON ||
               role == AccessibleRole.COMBO_BOX ||
               role == AccessibleRole.LIST ||
               role == AccessibleRole.TABLE;
    }
    
    private boolean needsDescription(AccessibleRole role) {
        return role == AccessibleRole.PUSH_BUTTON ||
               role == AccessibleRole.TEXT ||
               role == AccessibleRole.PASSWORD_TEXT;
    }
    
    private boolean isInteractive(AccessibleRole role) {
        return role == AccessibleRole.PUSH_BUTTON ||
               role == AccessibleRole.TEXT ||
               role == AccessibleRole.PASSWORD_TEXT ||
               role == AccessibleRole.CHECK_BOX ||
               role == AccessibleRole.RADIO_BUTTON ||
               role == AccessibleRole.COMBO_BOX ||
               role == AccessibleRole.SLIDER;
    }
    
    private void printReport() {
        System.out.println("\n" + "=".repeat(60));
        System.out.println("접근성 검사 보고서");
        System.out.println("=".repeat(60));
        
        if (issues.isEmpty()) {
            System.out.println("✅ 발견된 문제 없음! 훌륭합니다!");
        } else {
            System.out.println("발견된 문제: " + issues.size() + "개\n");
            for (String issue : issues) {
                System.out.println(issue);
            }
        }
        
        System.out.println("=".repeat(60) + "\n");
    }
    
    // 테스트용 메인 메서드
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            // 나쁜 예제 프레임
            JFrame badFrame = new JFrame("접근성 문제가 있는 폼");
            JPanel badPanel = new JPanel();
            badPanel.add(new JLabel("이름"));
            badPanel.add(new JTextField(20)); // 레이블 연결 없음
            JButton badButton = new JButton("→"); // 의미 없는 텍스트
            badButton.getAccessibleContext().setAccessibleName(null);
            badPanel.add(badButton);
            badFrame.add(badPanel);
            badFrame.pack();
            
            // 검사 실행
            AccessibilityChecker checker = new AccessibilityChecker();
            System.out.println("나쁜 예제 검사:");
            checker.checkComponent(badFrame);
            
            // 좋은 예제 프레임
            JFrame goodFrame = new JFrame("접근성이 좋은 폼");
            JPanel goodPanel = new JPanel();
            JLabel nameLabel = new JLabel("이름:");
            JTextField nameField = new JTextField(20);
            nameLabel.setLabelFor(nameField); // 레이블 연결
            nameField.getAccessibleContext().setAccessibleName("이름 입력");
            nameField.getAccessibleContext().setAccessibleDescription(
                "사용자의 이름을 입력하세요");
            
            JButton goodButton = new JButton("제출");
            goodButton.getAccessibleContext().setAccessibleDescription(
                "폼을 제출합니다");
            
            goodPanel.add(nameLabel);
            goodPanel.add(nameField);
            goodPanel.add(goodButton);
            goodFrame.add(goodPanel);
            goodFrame.pack();
            
            System.out.println("\n좋은 예제 검사:");
            checker.checkComponent(goodFrame);
        });
    }
}

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.web.WebView;
import javafx.stage.Stage;

public class AccessibleWebViewExample extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        WebView webView = new WebView();
        
        // 접근성 정보 설정
        webView.setAccessibleText("웹 콘텐츠 뷰어");
        webView.setAccessibleHelp(
            "이 영역에는 웹 페이지가 표시됩니다. " +
            "Tab 키로 링크와 폼 요소를 탐색할 수 있습니다.");
        
        // 접근성이 고려된 HTML 로드
        String accessibleHTML = """
            
            
            
            
                <a href="#main" class="skip-link">본문으로 건너뛰기</a>
                
                <header role="banner">
                    <h1>접근 가능한 웹 애플리케이션</h1>
                </header>
                
                <nav role="navigation" aria-label="주 메뉴">
                    <ul>
                        <li><a href="#home">홈</a></li>
                        <li><a href="#about">소개</a></li>
                        <li><a href="#contact">연락처</a></li>
                    </ul>
                </nav>
                
                <main id="main" role="main">
                    <h2>로그인</h2>
                    
                    <form onsubmit="return validateForm()">
                        <div>
                            <label for="username">사용자 이름:</label>
                            <input type="text" id="username" name="username" aria-required="true" aria-describedby="username-help">
                            <span id="username-help" class="help-text">
                                영문과 숫자만 사용 가능합니다
                            </span>
                        </div>
                        
                        <div>
                            <label for="password">비밀번호:</label>
                            <input type="password" id="password" name="password" aria-required="true">
                        </div>
                        
                        <div role="alert" id="error-message" class="error" aria-live="assertive" style="display: none;">
                        </div>
                        
                        <button type="submit" aria-label="로그인 버튼">
                            로그인
                        </button>
                    </form>
                    
                    <section aria-labelledby="status-heading">
                        <h3 id="status-heading">시스템 상태</h3>
                        <div role="status" aria-live="polite" id="status-message">
                            모든 시스템이 정상 작동 중입니다.
                        </div>
                    </section>
                </main>
                
                <footer role="contentinfo">
                    <p>© 2024 접근 가능한 애플리케이션</p>
                </footer>
                
                <script>
                    function validateForm() {
                        const username = 
                            document.getElementById('username').value;
                        const password = 
                            document.getElementById('password').value;
                        const errorDiv = 
                            document.getElementById('error-message');
                        
                        if (!username || !password) {
                            errorDiv.textContent = 
                                '모든 필드를 입력해주세요.';
                            errorDiv.style.display = 'block';
                            
                            // 첫 번째 빈 필드에 포커스
                            if (!username) {
                                document.getElementById('username').focus();
                            } else {
                                document.getElementById('password').focus();
                            }
                            
                            return false;
                        }
                        
                        errorDiv.style.display = 'none';
                        return true;
                    }
                    
                    // 동적 콘텐츠 업데이트 예시
                    setInterval(() => {
                        const now = new Date();
                        const statusDiv = 
                            document.getElementById('status-message');
                        statusDiv.textContent = 
                            '마지막 업데이트: ' + now.toLocaleTimeString();
                    }, 30000);
                </script>
            
            
            """;
        
        webView.getEngine().loadContent(accessibleHTML);
        
        Scene scene = new Scene(webView, 900, 700);
        primaryStage.setTitle("접근 가능한 WebView");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}

// 접근성 유틸리티 클래스 예시
public class AccessibilityUtils {
    
    /**
     * 컴포넌트에 기본 접근성 정보를 설정합니다.
     */
    public static void setupBasicAccessibility(
            JComponent component,
            String name,
            String description) {
        
        AccessibleContext context = component.getAccessibleContext();
        if (context != null) {
            context.setAccessibleName(name);
            context.setAccessibleDescription(description);
        }
    }
    
    /**
     * 레이블과 컴포넌트를 연결하고 니모닉을 설정합니다.
     */
    public static void linkLabelToComponent(
            JLabel label,
            JComponent component,
            char mnemonic) {
        
        label.setLabelFor(component);
        label.setDisplayedMnemonic(mnemonic);
    }
    
    /**
     * 버튼에 완전한 접근성 정보를 설정합니다.
     */
    public static void setupAccessibleButton(
            JButton button,
            String text,
            String description,
            char mnemonic) {
        
        button.setText(text);
        button.setMnemonic(mnemonic);
        
        AccessibleContext context = button.getAccessibleContext();
        context.setAccessibleDescription(description);
    }
    
    /**
     * 다이얼로그의 초기 포커스를 설정합니다.
     */
    public static void setInitialFocus(
            final JDialog dialog,
            final JComponent component) {
        
        dialog.addWindowListener(new java.awt.event.WindowAdapter() {
            @Override
            public void windowOpened(java.awt.event.WindowEvent e) {
                component.requestFocusInWindow();
            }
        });
    }
    
    /**
     * 색상 대비를 계산합니다.
     * WCAG 2.1 기준: 일반 텍스트 4.5:1, 큰 텍스트 3:1
     */
    public static double calculateContrastRatio(
            Color foreground,
            Color background) {
        
        double l1 = getRelativeLuminance(foreground);
        double l2 = getRelativeLuminance(background);
        
        double lighter = Math.max(l1, l2);
        double darker = Math.min(l1, l2);
        
        return (lighter + 0.05) / (darker + 0.05);
    }
    
    private static double getRelativeLuminance(Color color) {
        double r = color.getRed() / 255.0;
        double g = color.getGreen() / 255.0;
        double b = color.getBlue() / 255.0;
        
        r = (r <= 0.03928) ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4);
        g = (g <= 0.03928) ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4);
        b = (b <= 0.03928) ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4);
        
        return 0.2126 * r + 0.7152 * g + 0.0722 * b;
    }
    
    /**
     * 색상 대비가 충분한지 검사합니다.
     */
    public static boolean hasGoodContrast(
            Color foreground,
            Color background,
            boolean isLargeText) {
        
        double ratio = calculateContrastRatio(foreground, background);
        double requiredRatio = isLargeText ? 3.0 : 4.5;
        
        return ratio >= requiredRatio;
    }
    
    /**
     * 컴포넌트 트리를 순회하며 접근성 정보를 출력합니다.
     */
    public static void printAccessibilityTree(Component component) {
        printAccessibilityTreeRecursive(component, 0);
    }
    
    private static void printAccessibilityTreeRecursive(
            Component comp,
            int level) {
        
        String indent = "  ".repeat(level);
        
        if (comp instanceof Accessible) {
            Accessible accessible = (Accessible) comp;
            AccessibleContext context = accessible.getAccessibleContext();
            
            if (context != null) {
                System.out.println(indent + "├─ " + 
                    comp.getClass().getSimpleName());
                System.out.println(indent + "│  이름: " + 
                    context.getAccessibleName());
                System.out.println(indent + "│  역할: " + 
                    context.getAccessibleRole());
                System.out.println(indent + "│  설명: " + 
                    context.getAccessibleDescription());
            }
        }
        
        if (comp instanceof Container) {
            Container container = (Container) comp;
            for (Component child : container.getComponents()) {
                printAccessibilityTreeRecursive(child, level + 1);
            }
        }
    }
}

// 사용 예시
public class AccessibilityUtilsDemo {
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> {
            JFrame frame = new JFrame("접근성 유틸리티 데모");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            
            JPanel panel = new JPanel(new GridBagLayout());
            GridBagConstraints gbc = new GridBagConstraints();
            gbc.insets = new Insets(5, 5, 5, 5);
            gbc.fill = GridBagConstraints.HORIZONTAL;
            
            // 레이블과 텍스트 필드
            JLabel nameLabel = new JLabel("이름:");
            JTextField nameField = new JTextField(20);
            
            AccessibilityUtils.linkLabelToComponent(
                nameLabel, nameField, 'N');
            AccessibilityUtils.setupBasicAccessibility(
                nameField,
                "이름 입력",
                "사용자의 이름을 입력하세요");
            
            gbc.gridx = 0;
            gbc.gridy = 0;
            panel.add(nameLabel, gbc);
            
            gbc.gridx = 1;
            panel.add(nameField, gbc);
            
            // 버튼
            JButton submitButton = new JButton();
            AccessibilityUtils.setupAccessibleButton(
                submitButton,
                "제출",
                "입력한 정보를 제출합니다",
                'S');
            
            gbc.gridx = 0;
            gbc.gridy = 1;
            gbc.gridwidth = 2;
            panel.add(submitButton, gbc);
            
            // 색상 대비 테스트
            Color fg = Color.BLACK;
            Color bg = Color.WHITE;
            double ratio = AccessibilityUtils.calculateContrastRatio(fg, bg);
            boolean goodContrast = 
                AccessibilityUtils.hasGoodContrast(fg, bg, false);
            
            System.out.println("색상 대비 비율: " + ratio);
            System.out.println("충분한 대비: " + goodContrast);
            
            // 접근성 트리 출력
            System.out.println("\n접근성 트리:");
            AccessibilityUtils.printAccessibilityTree(panel);
            
            frame.add(panel);
            frame.pack();
            frame.setLocationRelativeTo(null);
            frame.setVisible(true);
        });
    }
}

// 접근 가능한 커스텀 버튼 컴포넌트
public class AccessibleButton extends JButton {
    
    public AccessibleButton(String text) {
        super(text);
        setupDefaults();
    }
    
    public AccessibleButton(String text, String description) {
        super(text);
        setupDefaults();
        getAccessibleContext().setAccessibleDescription(description);
    }
    
    public AccessibleButton(String text, String description, char mnemonic) {
        super(text);
        setupDefaults();
        getAccessibleContext().setAccessibleDescription(description);
        setMnemonic(mnemonic);
    }
    
    private void setupDefaults() {
        // 최소 크기 보장 (터치 타겟 크기)
        setMinimumSize(new Dimension(44, 44));
        setPreferredSize(new Dimension(100, 44));
        
        // 포커스 표시 강화
        setFocusPainted(true);
        
        // 툴팁을 접근성 설명과 동기화
        addPropertyChangeListener(
            AccessibleContext.ACCESSIBLE_DESCRIPTION_PROPERTY,
            evt -> {
                String desc = getAccessibleContext()
                    .getAccessibleDescription();
                if (desc != null && !desc.isEmpty()) {
                    setToolTipText(desc);
                }
            }
        );
    }
    
    /**
     * 빌더 패턴으로 접근성 설정
     */
    public static class Builder {
        private String text;
        private String description;
        private Character mnemonic;
        private Icon icon;
        private ActionListener action;
        
        public Builder text(String text) {
            this.text = text;
            return this;
        }
        
        public Builder description(String description) {
            this.description = description;
            return this;
        }
        
        public Builder mnemonic(char mnemonic) {
            this.mnemonic = mnemonic;
            return this;
        }
        
        public Builder icon(Icon icon) {
            this.icon = icon;
            return this;
        }
        
        public Builder action(ActionListener action) {
            this.action = action;
            return this;
        }
        
        public AccessibleButton build() {
            AccessibleButton button = new AccessibleButton(
                text != null ? text : "",
                description != null ? description : "",
                mnemonic != null ? mnemonic : '\0'
            );
            
            if (icon != null) {
                button.setIcon(icon);
            }
            
            if (action != null) {
                button.addActionListener(action);
            }
            
            return button;
        }
    }
}

// 사용 예시
AccessibleButton saveButton = new AccessibleButton.Builder()
    .text("저장")
    .description("현재 문서를 저장합니다")
    .mnemonic('S')
    .action(e -> saveDocument())
    .build();

import javax.accessibility.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.undo.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class AccessibleTextEditor extends JFrame {
    
    private JTextArea textArea;
    private JLabel statusLabel;
    private UndoManager undoManager;
    private File currentFile;
    private boolean isModified = false;
    
    public AccessibleTextEditor() {
        super("접근 가능한 텍스트 에디터");
        initializeComponents();
        setupAccessibility();
        setupKeyboardShortcuts();
        
        setSize(800, 600);
        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                exitApplication();
            }
        });
        
        setLocationRelativeTo(null);
        setVisible(true);
    }
    
    private void initializeComponents() {
        // 메뉴 바
        JMenuBar menuBar = createAccessibleMenuBar();
        setJMenuBar(menuBar);
        
        // 텍스트 영역
        textArea = new JTextArea();
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);
        textArea.setFont(new Font("Monospaced", Font.PLAIN, 14));
        
        // Undo 기능
        undoManager = new UndoManager();
        textArea.getDocument().addUndoableEditListener(undoManager);
        
        // 문서 변경 감지
        textArea.getDocument().addDocumentListener(new DocumentListener() {
            public void insertUpdate(DocumentEvent e) { documentChanged(); }
            public void removeUpdate(DocumentEvent e) { documentChanged(); }
            public void changedUpdate(DocumentEvent e) { documentChanged(); }
        });
        
        JScrollPane scrollPane = new JScrollPane(textArea);
        add(scrollPane, BorderLayout.CENTER);
        
        // 상태 표시줄
        statusLabel = new JLabel(" ");
        statusLabel.setBorder(BorderFactory.createEmptyBorder(5, 10, 5, 10));
        add(statusLabel, BorderLayout.SOUTH);
        
        updateStatus();
    }
    
    private void setupAccessibility() {
        // 프레임 접근성
        getAccessibleContext().setAccessibleName("텍스트 에디터 메인 창");
        getAccessibleContext().setAccessibleDescription(
            "텍스트 파일을 편집할 수 있는 에디터입니다");
        
        // 텍스트 영역 접근성
        textArea.getAccessibleContext().setAccessibleName("문서 편집 영역");
        textArea.getAccessibleContext().setAccessibleDescription(
            "여기에 텍스트를 입력하고 편집할 수 있습니다. " +
            "Ctrl+Z로 실행 취소, Ctrl+Y로 다시 실행할 수 있습니다.");
        
        // 상태 표시줄 접근성
        statusLabel.getAccessibleContext().setAccessibleName("상태 표시줄");
        statusLabel.getAccessibleContext().setAccessibleDescription(
            "현재 문서의 상태 정보를 표시합니다");
    }
    
    private JMenuBar createAccessibleMenuBar() {
        JMenuBar menuBar = new JMenuBar();
        
        // 파일 메뉴
        JMenu fileMenu = new JMenu("파일(F)");
        fileMenu.setMnemonic('F');
        fileMenu.getAccessibleContext().setAccessibleDescription(
            "파일 관련 작업을 수행합니다");
        
        JMenuItem newItem = createMenuItem(
            "새 파일(N)", 'N',
            KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.CTRL_DOWN_MASK),
            "새 문서를 만듭니다",
            e -> newFile()
        );
        fileMenu.add(newItem);
        
        JMenuItem openItem = createMenuItem(
            "열기(O)", 'O',
            KeyStroke.getKeyStroke(KeyEvent.VK_O, InputEvent.CTRL_DOWN_MASK),
            "파일을 엽니다",
            e -> openFile()
        );
        fileMenu.add(openItem);
        
        JMenuItem saveItem = createMenuItem(
            "저장(S)", 'S',
            KeyStroke.getKeyStroke(KeyEvent.VK_S, InputEvent.CTRL_DOWN_MASK),
            "현재 문서를 저장합니다",
            e -> saveFile()
        );
        fileMenu.add(saveItem);
        
        JMenuItem saveAsItem = createMenuItem(
            "다른 이름으로 저장(A)", 'A',
            KeyStroke.getKeyStroke(KeyEvent.VK_S, 
                InputEvent.CTRL_DOWN_MASK | InputEvent.SHIFT_DOWN_MASK),
            "현재 문서를 새 이름으로 저장합니다",
            e -> saveFileAs()
        );
        fileMenu.add(saveAsItem);
        
        fileMenu.addSeparator();
        
        JMenuItem exitItem = createMenuItem(
            "종료(X)", 'X',
            KeyStroke.getKeyStroke(KeyEvent.VK_Q, InputEvent.CTRL_DOWN_MASK),
            "프로그램을 종료합니다",
            e -> exitApplication()
        );
        fileMenu.add(exitItem);
        
        menuBar.add(fileMenu);
        
        // 편집 메뉴
        JMenu editMenu = new JMenu("편집(E)");
        editMenu.setMnemonic('E');
        editMenu.getAccessibleContext().setAccessibleDescription(
            "편집 관련 작업을 수행합니다");
        
        JMenuItem undoItem = createMenuItem(
            "실행 취소(U)", 'U',
            KeyStroke.getKeyStroke(KeyEvent.VK_Z, InputEvent.CTRL_DOWN_MASK),
            "마지막 작업을 취소합니다",
            e -> undo()
        );
        editMenu.add(undoItem);
        
        JMenuItem redoItem = createMenuItem(
            "다시 실행(R)", 'R',
            KeyStroke.getKeyStroke(KeyEvent.VK_Y, InputEvent.CTRL_DOWN_MASK),
            "취소한 작업을 다시 실행합니다",
            e -> redo()
        );
        editMenu.add(redoItem);
        
        editMenu.addSeparator();
        
        JMenuItem selectAllItem = createMenuItem(
            "모두 선택(A)", 'A',
            KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.CTRL_DOWN_MASK),
            "모든 텍스트를 선택합니다",
            e -> textArea.selectAll()
        );
        editMenu.add(selectAllItem);
        
        menuBar.add(editMenu);
        
        // 도움말 메뉴
        JMenu helpMenu = new JMenu("도움말(H)");
        helpMenu.setMnemonic('H');
        helpMenu.getAccessibleContext().setAccessibleDescription(
            "도움말과 정보를 제공합니다");
        
        JMenuItem aboutItem = createMenuItem(
            "정보(A)", 'A',
            null,
            "프로그램 정보를 표시합니다",
            e -> showAbout()
        );
        helpMenu.add(aboutItem);
        
        menuBar.add(helpMenu);
        
        return menuBar;
    }
    
    private JMenuItem createMenuItem(
            String text,
            char mnemonic,
            KeyStroke accelerator,
            String description,
            ActionListener action) {
        
        JMenuItem item = new JMenuItem(text);
        item.setMnemonic(mnemonic);
        
        if (accelerator != null) {
            item.setAccelerator(accelerator);
        }
        
        item.getAccessibleContext().setAccessibleDescription(description);
        item.addActionListener(action);
        
        return item;
    }
    
    private void setupKeyboardShortcuts() {
        // 추가 키보드 단축키 설정
        InputMap inputMap = textArea.getInputMap(
            JComponent.WHEN_IN_FOCUSED_WINDOW);
        ActionMap actionMap = textArea.getActionMap();
        
        // Ctrl+Z: 실행 취소
        inputMap.put(
            KeyStroke.getKeyStroke(KeyEvent.VK_Z, InputEvent.CTRL_DOWN_MASK),
            "undo");
        actionMap.put("undo", new AbstractAction() {
            public void actionPerformed(ActionEvent e) {
                undo();
            }
        });
        
        // Ctrl+Y: 다시 실행
        inputMap.put(
            KeyStroke.getKeyStroke(KeyEvent.VK_Y, InputEvent.CTRL_DOWN_MASK),
            "redo");
        actionMap.put("redo", new AbstractAction() {
            public void actionPerformed(ActionEvent e) {
                redo();
            }
        });
    }
    
    private void newFile() {
        if (checkSaveBeforeAction()) {
            textArea.setText("");
            currentFile = null;
            isModified = false;
            updateTitle();
            updateStatus();
            announceToScreenReader("새 문서를 만들었습니다");
        }
    }
    
    private void openFile() {
        if (!checkSaveBeforeAction()) {
            return;
        }
        
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle("파일 열기");
        
        // 파일 선택기 접근성
        fileChooser.getAccessibleContext().setAccessibleDescription(
            "열 파일을 선택하세요");
        
        int result = fileChooser.showOpenDialog(this);
        
        if (result == JFileChooser.APPROVE_OPTION) {
            File file = fileChooser.getSelectedFile();
            try {
                StringBuilder content = new StringBuilder();
                BufferedReader reader = new BufferedReader(
                    new FileReader(file));
                String line;
                while ((line = reader.readLine()) != null) {
                    content.append(line).append("\n");
                }
                reader.close();
                
                textArea.setText(content.toString());
                currentFile = file;
                isModified = false;
                updateTitle();
                updateStatus();
                announceToScreenReader("파일을 열었습니다: " + 
                    file.getName());
                
            } catch (IOException ex) {
                showError("파일을 열 수 없습니다: " + ex.getMessage());
            }
        }
    }
    
    private void saveFile() {
        if (currentFile == null) {
            saveFileAs();
        } else {
            try {
                BufferedWriter writer = new BufferedWriter(
                    new FileWriter(currentFile));
                writer.write(textArea.getText());
                writer.close();
                
                isModified = false;
                updateTitle();
                updateStatus();
                announceToScreenReader("파일을 저장했습니다");
                
            } catch (IOException ex) {
                showError("파일을 저장할 수 없습니다: " + ex.getMessage());
            }
        }
    }
    
    private void saveFileAs() {
        JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle("다른 이름으로 저장");
        
        // 파일 선택기 접근성
        fileChooser.getAccessibleContext().setAccessibleDescription(
            "저장할 파일 이름을 입력하세요");
        
        int result = fileChooser.showSaveDialog(this);
        
        if (result == JFileChooser.APPROVE_OPTION) {
            currentFile = fileChooser.getSelectedFile();
            saveFile();
        }
    }
    
    private void undo() {
        if (undoManager.canUndo()) {
            undoManager.undo();
            announceToScreenReader("실행 취소했습니다");
        } else {
            announceToScreenReader("더 이상 취소할 수 없습니다");
        }
    }
    
    private void redo() {
        if (undoManager.canRedo()) {
            undoManager.redo();
            announceToScreenReader("다시 실행했습니다");
        } else {
            announceToScreenReader("더 이상 다시 실행할 수 없습니다");
        }
    }
    
    private boolean checkSaveBeforeAction() {
        if (isModified) {
            int result = JOptionPane.showConfirmDialog(
                this,
                "변경사항을 저장하시겠습니까?",
                "확인",
                JOptionPane.YES_NO_CANCEL_OPTION,
                JOptionPane.QUESTION_MESSAGE
            );
            
            if (result == JOptionPane.YES_OPTION) {
                saveFile();
                return !isModified; // 저장 성공 시 true
            } else if (result == JOptionPane.CANCEL_OPTION) {
                return false;
            }
        }
        return true;
    }
    
    private void exitApplication() {
        if (checkSaveBeforeAction()) {
            System.exit(0);
        }
    }
    
    private void showAbout() {
        String message = 
            "접근 가능한 텍스트 에디터 v1.0\n\n" +
            "모든 사용자를 위한 텍스트 편집기입니다.\n" +
            "완전한 키보드 접근성과 스크린 리더 지원을 제공합니다.\n\n" +
            "단축키:\n" +
            "Ctrl+N: 새 파일\n" +
            "Ctrl+O: 열기\n" +
            "Ctrl+S: 저장\n" +
            "Ctrl+Z: 실행 취소\n" +
            "Ctrl+Y: 다시 실행";
        
        JOptionPane.showMessageDialog(
            this,
            message,
            "정보",
            JOptionPane.INFORMATION_MESSAGE
        );
    }
    
    private void showError(String message) {
        JOptionPane.showMessageDialog(
            this,
            message,
            "오류",
            JOptionPane.ERROR_MESSAGE
        );
        announceToScreenReader("오류: " + message);
    }
    
    private void documentChanged() {
        isModified = true;
        updateTitle();
        updateStatus();
    }
    
    private void updateTitle() {
        String title = "접근 가능한 텍스트 에디터";
        if (currentFile != null) {
            title += " - " + currentFile.getName();
        }
        if (isModified) {
            title += " *";
        }
        setTitle(title);
    }
    
    private void updateStatus() {
        int lines = textArea.getLineCount();
        int chars = textArea.getText().length();
        String status = String.format(
            "줄: %d | 문자: %d%s",
            lines,
            chars,
            isModified ? " | 수정됨" : ""
        );
        statusLabel.setText(status);
        
        // 상태 변경을 스크린 리더에 알림
        statusLabel.getAccessibleContext().firePropertyChange(
            AccessibleContext.ACCESSIBLE_TEXT_PROPERTY,
            null,
            status
        );
    }
    
    /**
     * 스크린 리더에 메시지를 알립니다.
     */
    private void announceToScreenReader(String message) {
        // 임시 레이블을 사용한 알림
        JLabel announcement = new JLabel(message);
        announcement.getAccessibleContext().setAccessibleName(message);
        announcement.getAccessibleContext().firePropertyChange(
            AccessibleContext.ACCESSIBLE_NAME_PROPERTY,
            null,
            message
        );
    }
    
    public static void main(String[] args) {
        // Look and Feel 설정
        try {
            UIManager.setLookAndFeel(
                UIManager.getSystemLookAndFeelClassName());
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        SwingUtilities.invokeLater(() -> new AccessibleTextEditor());
    }
}

// JavaFX와 웹 기술의 통합 예시
import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.web.WebEngine;
import javafx.scene.web.WebView;
import javafx.stage.Stage;
import netscape.javascript.JSObject;

public class HybridAccessibleApp extends Application {
    
    @Override
    public void start(Stage primaryStage) {
        WebView webView = new WebView();
        WebEngine engine = webView.getEngine();
        
        // 자바와 자바스크립트 간 브리지
        engine.getLoadWorker().stateProperty().addListener(
            (obs, oldState, newState) -> {
                if (newState == javafx.concurrent.Worker.State.SUCCEEDED) {
                    JSObject window = (JSObject) engine.executeScript("window");
                    window.setMember("javaApp", new JavaBridge());
                }
            }
        );
        
        // 접근성이 고려된 하이브리드 앱 로드
        String html = """
            
            
            
                <meta charset="UTF-8">
                <title>하이브리드 접근 가능한 앱</title>
            
            
                <h1>하이브리드 애플리케이션</h1>
                <button onclick="javaApp.performAction('save')" aria-label="저장">
                    저장
                </button>
                <div role="status" aria-live="polite" id="status">
                    준비됨
                </div>
            
            
            """;
        
        engine.loadContent(html);
        
        Scene scene = new Scene(webView, 800, 600);
        primaryStage.setScene(scene);
        primaryStage.setTitle("하이브리드 접근 가능한 앱");
        primaryStage.show();
    }
    
    // 자바스크립트에서 호출할 수 있는 자바 클래스
    public class JavaBridge {
        public void performAction(String action) {
            System.out.println("자바에서 실행: " + action);
            // 실제 자바 로직 실행
        }
    }
    
    public static void main(String[] args) {
        launch(args);
    }
}