1、目录
2、代码
（1）主函数
package com.main;
import com.view.ColorJFrame;
import com.view.Home;
public class Main {
public static void main(String[] args){
//new ColorJFrame();// 第一代调色板
new Home();// 第二代调色板
}
}
（2）工具类
-1）CompUtils.java
package com.util;
import javax.swing.*;
import java.awt.*;
public class CompUtils {
public static JTextField input(int colorValue){
JTextField jtf = new JTextField(colorValue + "");
jtf.setPreferredSize(new Dimension(70,40));
jtf.setFont(new Font("宋体",Font.BOLD,20));
jtf.setForeground(Color.WHITE);
jtf.setHorizontalAlignment(JTextField.CENTER);
jtf.setFocusable(false);//不允许获取焦点
return jtf;
}
public static JLabel label(String text, Color color){
JLabel label = new JLabel(text);
label.setPreferredSize(new Dimension(70,25));
label.setFont(new Font("宋体",Font.BOLD,20));
label.setHorizontalAlignment(JLabel.CENTER);
label.setForeground(color);// 标签文本颜色
return label;
}
public static void add(JPanel p, Component... comps){
for (Component comp : comps){
p.add(comp);
}
}
}
-2)MathUtils.java
package com.util;
import java.util.Random;
import java.util.regex.Pattern;
public class MathUtils {
public final static int NUMERIC_INTEGER = 0;
public final static int NUMERIC_DECIMAL = 1;
public final static int NUMERIC_INTEGER_OR_DECIMAL = 2;
/**
* 功能：判断一个字符串是否为对应数字类型
* @param numeric Object 主参数
* @param numericType int 0-整数 副参数
* @param numericType int 1-小数
* @param numericType int 2-整数、小数
* @return boolean
* 注意： 1、必须非负数； 2、仅整数判断时，不允许出现小数点；3、仅小数判断时，必须有小数点且数字完整 （不符合以上要求时，一律 @return false）
* */
public static boolean isNumeric(Object numeric, int numericType){
String number = String.valueOf(numeric);
//是否有小数点
if (number.indexOf(".")>0){
//整数判断-非
if (numericType == NUMERIC_INTEGER){
return false;
}
// 只有一个小数点
// number.indexOf(".") == number.lastIndexOf(".") 第一个小数点与最后一个重合
// number.split("\\.").length==2 0个小数点分成一份，1个小数点分成两份，两个小数点分成三份 (不太准确: "0."一分,".0"两分,等等)
if (number.indexOf(".") == number.lastIndexOf(".") //确保只有1个小数点
&& number.split("\\.").length==2 //确保小数点可分成两分
&& number.split("\\.")[0].length()>0 && number.split("\\.")[1].length()>0){//确保小数点分成的两分长度都大于零
//去掉小数点后，整数判断-是or非
return Pattern.compile("[0-9]*").matcher(number.replace(".","")).matches();
}
//多个小数点
return false;
}else {
//小数判断-非
if (numericType == NUMERIC_DECIMAL){
return false;
}
//整数判断-是or非
return Pattern.compile("[0-9]*").matcher(number).matches();
}
}
/**
* 功能：获取一个指定要求的随机数数组
* @param count 取值数量（数组长度）
* @param minNum 取值（最小）范围
* @param maxNum 取值（最大）范围
* @param isDifferent true 随机数“不相同” ，false 随机数允许相同
* */
public static int[] randomArray(int count, int minNum, int maxNum, boolean isDifferent){
if (count<=0)
return null;
if (minNum>maxNum) {
int temp = minNum;
minNum = maxNum;
maxNum = temp;
}
int[] array = new int[count];
if (isDifferent){//true 要求随机数不相同时
for (int i=0;i<count;i++){
int random = new Random().nextInt(maxNum) + minNum;
if (i>0)
random = getDifferentRandomNum(array,random,minNum,maxNum);
array[i] = random;
}
}else {// false 允许随机数相同时
for (int i=0;i<count;i++){
array[i] = new Random().nextInt(maxNum) + minNum;
}
}
return array;
}
/**
* 功能：获取不相同的随机数
* @param numbers 对照组
* @param randomNum 实验组
* @param minNum 取值（最小）范围
* @param maxNum 取值（最大）范围
* */
private static int getDifferentRandomNum(int[] numbers, int randomNum, int minNum, int maxNum){
// 为空时直接返回
if (numbers==null || numbers.length==0)
return randomNum;
// 遍历已有数据
for (int number : numbers) {
// 发现当前随机数已存在
if (number == randomNum) {
// 生成一个新的随机数
randomNum = new Random().nextInt(maxNum) + minNum;
// 递归，直至找到新的、还未存在的随机数，并赋值（"randomNum = "必不可少）
randomNum = getDifferentRandomNum(numbers, randomNum, minNum, maxNum);
}
}
return randomNum;
}
}
(3)页面展示
-1）“第一代”调色板
package com.view;
import com.util.MathUtils;
import javax.imageio.ImageIO;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Objects;
/**
* 第一代调色板
* 2023.06.13~2023.06.26
* 功能：
* 1、滚动鼠标修改输入框颜值并刷新调色板
* 2、键盘输入修改输入框颜值并刷新调色板
* */
public class ColorJFrame {
private static int RED = 0;//红值
private static int GREEN = 0;//绿值
private static int BLUE = 0;//蓝值
private static JFrame f;//窗体
private static int vgap = 0;//基础面板与状态栏的间距
private static int width = 528;
private static int height = 520;
private static int x = (Toolkit.getDefaultToolkit().getScreenSize().width - width)/2;
private static int y = (Toolkit.getDefaultToolkit().getScreenSize().height - height)/2;
public ColorJFrame(){
createFrame();
init();
}
/**
* 创建窗体
* */
public void createFrame(){
// 窗体设置
JFrame f = new JFrame("三原色调色器");
f.setLayout(new FlowLayout(FlowLayout.CENTER,0,vgap));
f.setBounds(x,y,width,height);
f.setUndecorated(false);
f.setResizable(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//icon图标(修改程序在电脑任务栏处的默认图标)
BufferedImage icon = null;
try {
icon = ImageIO.read(Objects.requireNonNull(this.getClass().getClassLoader().getResource("com/icon/RGB.png")));
} catch (IOException e) {
e.printStackTrace();
}
f.setIconImage(icon);
ColorJFrame.f = f;
//主要监听窗体大小变化，保证基础面板居中
f.addComponentListener(new ComponentAdapter() {
@Override
public void componentResized(ComponentEvent e) {
// 窗体大小发生变化
vgap = (f.getHeight()-510)/2;
new utils().updateUI();
}
});
}
/**
* 界面初始化
* */
public void init(){
utils u = new utils();
// 基础面板
JPanel box = new JPanel();
box.setLayout(new FlowLayout(FlowLayout.CENTER,0,0));
box.setPreferredSize(new Dimension(500,460));
box.setBackground(Color.GREEN);
// 顶部面板
JPanel top = new JPanel();
top.setPreferredSize(new Dimension(500,310));
top.setLayout(new FlowLayout(FlowLayout.CENTER,0,105));
top.setBorder(BorderFactory.createMatteBorder(1,1,1,1, Color.BLACK));
if(RED>200&&GREEN>200&&BLUE>200){
top.setBackground(Color.BLACK);
}else {
top.setBackground(Color.white);
}
// 调色板（面板）
JPanel show = new JPanel();
show.setPreferredSize(new Dimension(100,100));
show.setBackground(new Color(RED, GREEN, BLUE));
show.setBorder(BorderFactory.createMatteBorder(1,1,1,1,Color.BLACK));
u.add(top,show);
//底部面板
JPanel bottom = new JPanel();
bottom.setPreferredSize(new Dimension(500,150));
bottom.setLayout(new FlowLayout(FlowLayout.CENTER,0,0));
bottom.setBackground(Color.BLUE);
// 文本框面板
JPanel textField = new JPanel();
textField.setLayout(new FlowLayout(FlowLayout.CENTER,20,35));
textField.setPreferredSize(new Dimension(500,75));
textField.setBackground(Color.WHITE);
// 标签面板
JPanel label = new JPanel();
label.setLayout(new FlowLayout(FlowLayout.CENTER,20,0));
label.setPreferredSize(new Dimension(500,75));
u.add(bottom,textField,label);
label.setBackground(Color.WHITE);
// 文本框
JTextField redTF = u.textField(RED);
JTextField greenTF = u.textField(GREEN);
JTextField blueTF = u.textField(BLUE);
redTF.setBackground(new Color(RED,0,0));
greenTF.setBackground(new Color(0,GREEN,0));
blueTF.setBackground(new Color(0,0,BLUE));
u.red(redTF);
u.green(greenTF);
u.blue(blueTF);
u.add(textField,redTF,greenTF,blueTF);
// 标签
JLabel redL = new utils().label("red", Color.red);
JLabel greenL = new utils().label("green", Color.GREEN);
JLabel blueL = new utils().label("blue", Color.BLUE);
u.add(label,redL,greenL,blueL);
JFrame frame = f;
u.add(box,top,bottom);
u.add(frame,box);
frame.setVisible(true);
}
/**
* 内部类
* */
class utils{
/**
* 刷新界面
* */
private void updateUI(){
JFrame f1 = f;
f1.getContentPane().removeAll();
f1.getContentPane().setVisible(false);
init();
f1.setLayout(new FlowLayout(FlowLayout.CENTER,0,vgap));
f = f1;
f1.getContentPane().setVisible(true);
}
/**
* 标签
* */
private JLabel label(String text, Color color){
JLabel label = new JLabel(text);
label.setPreferredSize(new Dimension(70,25));
label.setFont(new Font("宋体",Font.BOLD,20));
label.setHorizontalAlignment(JLabel.CENTER);
label.setForeground(color);
// label.setBorder(BorderFactory.createMatteBorder(1,1,1,1,Color.red));
return label;
}
/**
* 文本框
* */
private JTextField textField(int color){
JTextField textField = new JTextField(color+"");
textField.setPreferredSize(new Dimension(70,40));
textField.setFont(new Font("黑体",Font.BOLD,20));
textField.setForeground(Color.WHITE);
textField.setHorizontalAlignment(JTextField.CENTER);
// textField.setEnabled(false);
return textField;
}
/**
* 面板添加组件
* */
private void add(JPanel panel, Component... Comps){
for (Component comp : Comps){
panel.add(comp);
}
}
/**
* 面板添加组件
* */
private void add(JFrame frame, Component... Comps){
for (Component comp : Comps){
frame.add(comp);
}
}
/**
* 红值监听
* */
private void red(JTextField textField){
listen(textField,0);
}
/**
* 绿值监听
* */
private void green(JTextField textField){
listen(textField,1);
}
/**
* 蓝值监听
* */
private void blue(JTextField textField){
listen(textField,2);
}
/**
* 调色值监听事件
* */
private void listen(JTextField textField,int ToValue){
// 滚轮监听
textField.addMouseWheelListener(e -> {
String value = textField.getText();
if (MathUtils.isNumeric(value,MathUtils.NUMERIC_INTEGER) && value!=null && !value.equals("")){
int v = Integer.parseInt(value);
int w = e.getWheelRotation();
if (v == 0){
if (w > 0){
v = 255;
}else {
v = v - w;
}
}else if (v == 255){
if (w > 0){
v = v - w;
}else {
v = 0;
}
}else {
v = v - w;
}
textField.setText(String.valueOf(v));
updateUI();
}
});
// 数值变化监听
textField.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
//insertUpdate 是实时监听输入的内容，该方法可以跟踪文本框中输入的内容
toValue(textField,ToValue);
textFieldIOUpdateUI(textField);
}
@Override
public void removeUpdate(DocumentEvent e) {
//removeUpdate是实时监听删除内容，该方法可以跟踪文本框中移除的内容
toValue(textField,ToValue);
textFieldIOUpdateUI(textField);
}
@Override
public void changedUpdate(DocumentEvent e) {
// changedUpdate是更新内容，该方法可以跟踪当文本框中已存在的内容改变时（这个方法比较少用）
System.out.println("文本框内容已更新");
}
});
}
/**
* 键盘修改调色值时，刷新调色板
* */
private void textFieldIOUpdateUI(Component comp){
comp.addMouseListener(new MouseAdapter() {
@Override
public void mouseExited(MouseEvent e) {
//鼠标离开文本框
updateUI();
}
});
}
/**
* 缓存调色值
* */
private void toValue(JTextField textField,int TO_RGB){
String value = textField.getText();
if (MathUtils.isNumeric(value,MathUtils.NUMERIC_INTEGER) && value!=null && !value.equals("")){
int v = Integer.parseInt(value);
if (v >= 0 && v <= 255){
if (TO_RGB == 0){
RED = v;
}else if (TO_RGB == 1){
GREEN = v;
}else if (TO_RGB == 2){
BLUE = v;
}
}
}
}
}
}
-2）“第二代”调色板
package com.view;
import com.util.CompUtils;
import com.util.MathUtils;
import javax.swing.*;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.*;
import java.net.URL;
import java.util.Objects;
import java.util.Timer;
import java.util.TimerTask;
/**
* 第二代调色板
* 2024.08.15~2024.08.19
* 功能：
* 1、点击调色板区域，获取随机颜色
* 2、输入框（手动输入、滚动修改）输入，获取指定颜色
* 3、指定方法，自动滚动式获取颜色
* */
public class Home {
private static int RED = 0, GREEN = 0, BLUE = 0;// 三原色值
private static String[] startsTypes = new String[]{"R>G>B","R>B>G","G>R>B","G>B>R","B>R>G","B>G>R","RG>B","RB>G","GB>R","R>GB","G>RB","B>RG","RGB"};// 滚动方法
private static boolean isStop = true;// 默认暂停状态
private static String inputTime = "1";
//
private static Timer timer = new Timer();// 定时器
//
private static JPanel pColor;// 三原色调色板
private static JTextField redJTF, greenJTF, blueJTF, timeJTF;// 三原色设置、定时周期设置
private static JComboBox<String> rgbType = new JComboBox<>(startsTypes);// 滚动方式设置
private static JButton startBtn, stopBtn;// 滚动模式启动/暂停按钮
public Home(){
init();
}
// 界面初始化
private void init(){
//窗体
JFrame f = new JFrame("三原色调试器");
f.setSize(570,600);
f.setLocationRelativeTo(null);// 默认居中展示
f.setLayout(new FlowLayout(FlowLayout.CENTER));
URL url = getClass().getClassLoader().getResource("com/icon/RGB.png");// 图片存放位置
assert url != null;
f.setIconImage(new ImageIcon(url).getImage());// 设置ico图标（logo图标）
f.setResizable(false);// false不允许放大缩小
// 基础面板
JPanel base = new JPanel();
base.setPreferredSize(new Dimension(555,555));
base.setLayout(new FlowLayout(FlowLayout.CENTER,0,0));
// 展示区面板
JPanel show = new JPanel();
show.setPreferredSize(new Dimension(555,300));
show.setLayout(new FlowLayout(FlowLayout.CENTER,0,100));
show.setBorder(BorderFactory.createMatteBorder(2,2,1,2,Color.black));
show.setBackground(Color.WHITE);
// 输入区面板
JPanel input = new JPanel();
input.setPreferredSize(new Dimension(555,75));
input.setLayout(new FlowLayout(FlowLayout.CENTER,50,30));
input.setBorder(BorderFactory.createMatteBorder(1,2,0,2,Color.black));
input.setBackground(Color.WHITE);
// （输入区辅助）标签面板
JPanel tips = new JPanel();
tips.setPreferredSize(new Dimension(555,60));
tips.setLayout(new FlowLayout(FlowLayout.CENTER,50,0));
tips.setBorder(BorderFactory.createMatteBorder(0,2,1,2,Color.black));
tips.setBackground(Color.WHITE);
// 滚动类型选择及其定时任务面板
JPanel select = new JPanel();
select.setPreferredSize(new Dimension(555,120));
select.setBorder(BorderFactory.createMatteBorder(1,2,2,2,Color.BLACK));
select.setLayout(new FlowLayout(FlowLayout.CENTER,10,40));
select.setBackground(Color.WHITE);
// 调色板
pColor = new JPanel();
pColor.setPreferredSize(new Dimension(100,100));
pColor.setBackground(new Color(RED,GREEN,BLUE));
pColor.setBorder(BorderFactory.createMatteBorder(1,1,1,1,Color.BLACK));
// 颜值输入及展示
redJTF = CompUtils.input(RED);
redJTF.setBackground(new Color(RED,0,0));
greenJTF = CompUtils.input(GREEN);
greenJTF.setBackground(new Color(0,GREEN,0));
blueJTF = CompUtils.input(BLUE);
blueJTF.setBackground(new Color(0,0,BLUE));
// 标签
JLabel redJL = CompUtils.label("red", Color.red);
JLabel greenJL = CompUtils.label("green", Color.green);
JLabel blueJL = CompUtils.label("blue", Color.blue);
// 滚动方式选择下拉框
rgbType.setPreferredSize(new Dimension(120,40));
rgbType.setFont(new Font("宋体",Font.BOLD,20));
// 定时周期设置
timeJTF = CompUtils.input(1);
timeJTF.setPreferredSize(new Dimension(120,40));
timeJTF.setForeground(Color.BLACK);
// 清零启动按钮
startBtn = new JButton("从零开始");
startBtn.setPreferredSize(new Dimension(120,40));
startBtn.setFont(new Font("宋体",Font.BOLD,20));
startBtn.setFocusPainted(false);
// 启动及暂停按钮
stopBtn = new JButton("启动");
stopBtn.setPreferredSize(new Dimension(120,40));
stopBtn.setFont(new Font("宋体",Font.BOLD,20));
stopBtn.setFocusPainted(false);
// 组件“组装”
show.add(pColor);
CompUtils.add(input,redJTF,greenJTF,blueJTF);
CompUtils.add(tips, redJL, greenJL, blueJL);
CompUtils.add(select,rgbType,timeJTF,startBtn,stopBtn);
CompUtils.add(base,show,input,tips,select);
f.add(base);
// 监听事件
listen();
// 窗体
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 关闭即退出程序
f.setVisible(true);// 显示窗体
}
/**
* 从零开始执行定时任务
* */
private void startTimer(){
rgbZeroClearing();// 清零，重新计数
continueTimer();
}
/**
* 停止计时器
* */
private void stopTimer(){
timer.cancel();// 停用旧计时器(不停用的话，可能会造成多个计时器同时存在)
isStop = true;// 正在暂停状态，标记状态
stopBtn.setText("继续");
}
/**
* 继续计时器
* */
private void continueTimer(){
String startType = Objects.requireNonNull(rgbType.getSelectedItem()).toString();// 任务形式
int period = Integer.parseInt(timeJTF.getText());// 定时周期
timer.cancel();// 停用旧计时器(不停用的话，可能会造成多个计时器同时存在)
timer = new Timer();// 新建计时器
TimerTask task = startChangeRGB(startType);// 更新计时器任务
timer.scheduleAtFixedRate(task,0,period);// 启动计时器
isStop = false;// 正在非暂停状态，标记状态
stopBtn.setText("暂停");
}
/**
* 定时任务
* */
private TimerTask startChangeRGB(String startType){
//"R>G>B","R>B>G","G>R>B","G>B>R","B>R>G","B>G>R","RG>B","RB>G","GB>R","R>GB","G>RB","B>RG","RGB"
return new TimerTask() {
@Override
public void run() {
// 改变“颜”值
switch (startType){
case "R>G>B":
rgbAutoIncrement(0,1,2);
break;
case "R>B>G":
rgbAutoIncrement(0,2,1);
break;
case "G>R>B":
rgbAutoIncrement(1,0,2);
break;
case "G>B>R":
rgbAutoIncrement(1,2,0);
break;
case "B>R>G":
rgbAutoIncrement(2,0,1);
break;
case "B>G>R":
rgbAutoIncrement(2,1,0);
break;
case "RG>B":
rgbAutoIncrement(0,1);
break;
case "RB>G":
rgbAutoIncrement(0,2);
break;
case "GB>R":
rgbAutoIncrement(1,2);
break;
case "R>GB":
rgbAutoIncrement(0);
break;
case "G>RB":
rgbAutoIncrement(1);
break;
case "B>RG":
rgbAutoIncrement(2);
break;
case "RGB":
rgbAutoIncrement();
break;
default:
break;
}//
updateUI_pColor();
updateUI_rgbJTF(0);
updateUI_rgbJTF(1);
updateUI_rgbJTF(2);
}
};
}
/**
* 自增规则：255进制
* */
/**
* 顺序自增
* */
private void rgbAutoIncrement(int rgbType0, int rgbType1, int rgbType2){
if (rgbType0 != 1 && rgbType0 != 2)
rgbType0 = 0;
if (rgbType1 != 1 && rgbType1 != 2)
rgbType1 = 0;
if (rgbType2 != 1 && rgbType2 != 2)
rgbType2 = 0;
// 三参相同，1:2自增
// 两参相同，2:1自增
// 三参不同，顺序自增
if (rgbType0 == rgbType1 && rgbType0 == rgbType2){
//
rgbAutoIncrement(rgbType0);
}else if (rgbType0 == rgbType1 || rgbType0 == rgbType2 || rgbType1 == rgbType2){
//
if (rgbType0 == rgbType1){
rgbAutoIncrement(rgbType0,rgbType2);
} else {
rgbAutoIncrement(rgbType0,rgbType1);
}
}else {
//
if (rgbType0 == 1){
// 1->0->2 || 1->2->0
if (GREEN < 255){
AutoIncrement(1);
}else {
if (rgbType1 == 0){
if (RED < 255){
AutoIncrement(0);
rgbZeroClearing(rgbType0);
}else {
if (BLUE < 255){
AutoIncrement(2);
rgbZeroClearing(rgbType0,rgbType1);
}else {
rgbZeroClearing();
}
}
}else {
if (BLUE < 255){
AutoIncrement(2);
rgbZeroClearing(rgbType0);
}else {
if (RED < 255){
AutoIncrement(0);
rgbZeroClearing(rgbType0, rgbType1);
}else {
rgbZeroClearing();
}
}
}
}
}else if (rgbType0 == 2){
// 2->0->1 || 2->1->0
if (BLUE < 255){
AutoIncrement(2);
}else {
if (rgbType1 == 0){
if (RED < 255){
AutoIncrement(0);
rgbZeroClearing(rgbType0);
}else {
if (GREEN < 255){
AutoIncrement(1);
rgbZeroClearing(rgbType0, rgbType1);
}else {
rgbZeroClearing();
}
}
}else {
if (GREEN < 255){
AutoIncrement(1);
rgbZeroClearing(rgbType0);
}else {
if (RED < 255){
AutoIncrement(0);
rgbZeroClearing(rgbType0, rgbType1);
}else {
rgbZeroClearing();
}
}
}
}
}else {
// 0->1->2 || 0->2->1
if (RED < 255){
AutoIncrement(0);
}else {
if (rgbType1 == 1){
if (GREEN < 255){
AutoIncrement(1);
rgbZeroClearing(rgbType0);
}else {
if (BLUE < 255){
AutoIncrement(2);
rgbZeroClearing(rgbType0, rgbType1);
}else {
rgbZeroClearing();
}
}
}else {
if (BLUE < 255){
AutoIncrement(2);
rgbZeroClearing(rgbType0);
}else {
if (GREEN < 255){
AutoIncrement(1);
rgbZeroClearing(rgbType0, rgbType1);
}else {
rgbZeroClearing();
}
}
}
}
}
}
}
/**
* 2:1自增
* */
private void rgbAutoIncrement(int rgbType0, int rgbType1){
if (rgbType0 != 1 && rgbType0 != 2)
rgbType0 = 0;
if (rgbType1 != 1 && rgbType1 != 2)
rgbType1 = 0;
// 两参相同 ——> 1:2自增
if (rgbType0 == rgbType1){
rgbAutoIncrement(rgbType0);
}else {
int count = rgbType0 + rgbType1;
if (count==1){
if (RED < 255){
AutoIncrement(0);
AutoIncrement(1);
}else {
if (BLUE < 255){
AutoIncrement(2);
rgbZeroClearing(rgbType0);
rgbZeroClearing(rgbType1);
}else {
rgbZeroClearing();
}
}
}else if (count == 2){
if (RED < 255){
AutoIncrement(0);
AutoIncrement(2);
}else {
if (GREEN < 255){
AutoIncrement(1);
rgbZeroClearing(rgbType0);
rgbZeroClearing(rgbType1);
}else {
rgbZeroClearing();
}
}
}else {
if (GREEN < 255){
AutoIncrement(1);
AutoIncrement(2);
}else {
if (RED < 255){
AutoIncrement(0);
rgbZeroClearing(rgbType0);
rgbZeroClearing(rgbType1);
}else {
rgbZeroClearing();
}
}
}
}
}
/**
* 1:2自增
* */
private void rgbAutoIncrement(int rgbType0){
if (rgbType0 == 1){
if (GREEN < 255){
GREEN++;
}else {
if (RED < 255){
AutoIncrement(0);
AutoIncrement(2);
rgbZeroClearing(rgbType0);
}else {
rgbZeroClearing();
}
}
}else if (rgbType0 == 2){
if (BLUE < 255){
BLUE++;
}else {
if (RED < 255){
AutoIncrement(0);
AutoIncrement(1);
rgbZeroClearing(rgbType0);
}else {
rgbZeroClearing();
}
}
}else {
if (RED < 255){
RED++;
}else {
if (GREEN < 255){
AutoIncrement(1);
AutoIncrement(2);
rgbZeroClearing(rgbType0);
}else {
rgbZeroClearing();
}
}
}
}
/**
* 同步自增
* */
private void rgbAutoIncrement(){
AutoIncrement(0);
AutoIncrement(1);
AutoIncrement(2);
}
/**
* 自增
* */
private void AutoIncrement(int rgbType){
if (rgbType == 1){
if (GREEN < 255){
GREEN ++;
}else {
GREEN = 0;
}
}else if (rgbType == 2){
if (BLUE < 255){
BLUE ++;
}else {
BLUE = 0;
}
} else {
if (RED < 255){
RED ++;
}else {
RED = 0;
}
}
}
/**
* 全清零
* */
private void rgbZeroClearing(){
RED = 0;
GREEN = 0;
BLUE = 0;
}
/**
* 两个颜值清零
* */
private void rgbZeroClearing(int rgbType0, int rgbType1){
if (rgbType0 != 1 && rgbType0 != 2)
rgbType0 = 0;
if (rgbType1 != 1 && rgbType1 != 2)
rgbType1 = 0;
// 不用理会两参是否相同
rgbZeroClearing(rgbType0);
rgbZeroClearing(rgbType1);
}
/**
* 一个颜值清零
* */
private void rgbZeroClearing(int rgbType){
if (rgbType == 1){
GREEN = 0;
}else if (rgbType == 2){
BLUE = 0;
}else {
RED = 0;
}
}
// 监听事件
private void listen(){
// 开始按钮
startBtn.addActionListener(e -> {
// 开始计时器
startTimer();
});
// 暂停按钮
stopBtn.addActionListener(e -> {
if (!isStop){// 非停止状态时
// 停止计时器
stopTimer();
}else {// 停止状态时
// 继续计时器
continueTimer();
}
});
// 定时周期设置
// 1、鼠标进入、离开输入框时
timeJTF.addMouseListener(new MouseAdapter() {
@Override
public void mouseEntered(MouseEvent e){
timeJTF.setFocusable(true);// 恢复允许获取焦点
// 进入输入框时，更新输入内容
timeJTF.setText(inputTime);
// 获取焦点
timeJTF.requestFocusInWindow();
}
@Override
public void mouseExited(MouseEvent e) {
// 离开输入框时，更新输入内容
timeJTF.setText(inputTime);
}
});
// 2、插入、删除时
timeJTF.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
// 输入
String text = timeJTF.getText();
if (text != null && !text.equals("") && MathUtils.isNumeric(text,MathUtils.NUMERIC_INTEGER)){
int value = Integer.parseInt(text);
if (value >= 1 && value <= 1000){
inputTime = String.valueOf(value);
}else {
// 失去焦点，禁止继续输入
timeJTF.transferFocus();
}
}else {
// 失去焦点，禁止继续输入
timeJTF.transferFocus();
}
}
@Override
public void removeUpdate(DocumentEvent e) {
// 删除
String text = timeJTF.getText();
if (text != null && !text.equals("") && MathUtils.isNumeric(text,MathUtils.NUMERIC_INTEGER)){
int value = Integer.parseInt(text);
if (value >= 1 && value <= 1000){
inputTime = String.valueOf(value);
}
}
}
@Override
public void changedUpdate(DocumentEvent e) {
// 当文本改变（不是通过插入或删除）时调用 （目前没见过在此处获取文本内容）
//System.out.println("改变："+timeJTF.getText());
}
});
// 3、滚动时
timeJTF.addMouseWheelListener(e -> {
int time = Integer.parseInt(inputTime) - e.getWheelRotation();
if (time <= 0)
time = 1000;
if (time > 1000)
time = 1;
inputTime = String.valueOf(time);
timeJTF.setText(inputTime);
});
// 颜值设置
// 1、鼠标进入、离开输入框时
updateRGB_EnterAndExit(redJTF,0);
updateRGB_EnterAndExit(greenJTF,1);
updateRGB_EnterAndExit(blueJTF,2);
// 2、插入、删除时
updateRGB_InsertAndRemove(redJTF,0);
updateRGB_InsertAndRemove(greenJTF,1);
updateRGB_InsertAndRemove(blueJTF,2);
// 3、滚动时
updateRGB_Wheel(redJTF,0);
updateRGB_Wheel(greenJTF,1);
updateRGB_Wheel(blueJTF,2);
// 随机
pColor.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
int[] colorValues = MathUtils.randomArray(3,0,255,false);
assert colorValues != null;
// 刷新颜值
colorValue(colorValues[0],0);
colorValue(colorValues[1],1);
colorValue(colorValues[2],2);
// 刷新输入框颜值
updateUI_rgbJTF(0);
updateUI_rgbJTF(1);
updateUI_rgbJTF(2);
// 刷新调色板
updateUI_pColor();
}
});
}
/**
* 进、出输入框——更新输入框颜值
* */
private void updateRGB_EnterAndExit(JTextField jtf, int rgbType){
jtf.addMouseListener(new MouseAdapter() {
@Override
public void mouseEntered(MouseEvent e) {
jtf.setFocusable(true);// 恢复允许获取焦点
if (isStop){
// 刷新输入框
updateUI_rgbJTF(rgbType);
// 获取焦点
jtf.requestFocusInWindow();
// 刷新调色面板背景颜色
updateUI_pColor();
}
}
@Override
public void mouseExited(MouseEvent e) {
if (isStop){
// 刷新输入框
updateUI_rgbJTF(rgbType);
// 刷新调色面板背景颜色
updateUI_pColor();
}
}
});
}
/**
* 插入、删除输入框内容——更新颜值
* */
private void updateRGB_InsertAndRemove(JTextField jtf, int rgbType){
jtf.getDocument().addDocumentListener(new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
// 输入
String text = jtf.getText();
if (text != null && !text.equals("") && MathUtils.isNumeric(text,MathUtils.NUMERIC_INTEGER)){
int value = Integer.parseInt(text);
if (value >= 0 && value <= 255){
colorValue(value,rgbType);
}else {
// 失去焦点，禁止继续输入
jtf.transferFocus();
}
}else {
// 失去焦点，禁止继续输入
jtf.transferFocus();
}
}
@Override
public void removeUpdate(DocumentEvent e) {
// 删除
String time = jtf.getText();
if (time != null && !time.equals("") && MathUtils.isNumeric(time,MathUtils.NUMERIC_INTEGER)){
int value = Integer.parseInt(time);
if (value >= 0 && value <= 255){
colorValue(value,rgbType);
}
}
}
@Override
public void changedUpdate(DocumentEvent e) {
// 当文本改变（不是通过插入或删除）时调用 （目前没见过在此处获取文本内容）
}
});
}
/**
* 滚动时——更新颜值
* */
private void updateRGB_Wheel(JTextField jtf, int rgbType){
jtf.addMouseWheelListener(e -> {
// e.getWheelRotation() 上负下正
// 颜值刷新
int colorValue;
if (rgbType == 1){
colorValue = GREEN - e.getWheelRotation();
}else if (rgbType == 2){
colorValue = BLUE - e.getWheelRotation();
}else {
colorValue = RED - e.getWheelRotation();
}
if (colorValue < 0)
colorValue = 255;
if (colorValue > 255)
colorValue = 0;
colorValue(colorValue,rgbType);
// 输入框颜值刷新
updateUI_rgbJTF(rgbType);
// 刷新调色面板背景颜色
updateUI_pColor();
});
}
/**
* 更新rgb输入框
* */
private void updateUI_rgbJTF(int rgbType){
if (rgbType == 1){
greenJTF.setBackground(new Color(0,GREEN,0));
greenJTF.setText(String.valueOf(GREEN));
}else if (rgbType == 2){
blueJTF.setBackground(new Color(0,0,BLUE));
blueJTF.setText(String.valueOf(BLUE));
}else {
redJTF.setBackground(new Color(RED,0,0));
redJTF.setText(String.valueOf(RED));
}
}
/**
* 颜值赋值
* */
private void colorValue(int colorValue, int rgbType){
if (rgbType == 1){
GREEN = colorValue;
}else if (rgbType == 2){
BLUE = colorValue;
}else {
RED = colorValue;
}
}
/**
* 刷新调色面板背景颜色
* */
private void updateUI_pColor(){
pColor.setBackground(new Color(RED,GREEN,BLUE));
}
}
3、百度网盘链接
源码链接：https://pan.baidu.com/s/10QII9IHCUtzE6k6UEcuj4A
提取码：mxj1
4、页面展示效果：
1133
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
