Java-Task-Management-Tool für Windows und Mac selber programmieren

[SepoHH2020]

Moin Allerseits,

ich würde mich gerne mit meiner Projekt-Idee an euch wenden und bedanke mich im Voraus für eure Anteilnahme.

Gerne würde ich ein Task-Management-Tool für Windows und MacOS programmieren. Und da stellt sich mir die Frage, ob ich dieses Projekt in der Programmiersprache Java programmieren könnte. Was meine Java-Kenntnisse betrifft, da würde ich mich als Anfänger bis Vorgeschritten zuordnen. Ich habe Java programmieren im Studium gelernt, programmiere aber hauptsächlich in C und C++.

Das Programm soll dazu in der Lage sein aktuell laufende Programm anzeigen (z.B. Browser, Word, PDF-Reader ect.) und schließen zu können. Das wars auch eigentlich schon. Ich hatte an meiner Hochschule Betriebssysteme. Unter Anderem haben wir da Fenster mit unterschiedlichen Funktionalitäten Programmiert. Das Ganze aber unter Linux/Unix und nicht unter, bez. für Windows programmiert.

Was ist eure Meinung zu meiner Projekt-Idee. Ist die umsetzbar in Java? Oder empfahlt ihr lieber eine andere Programmiersprach als Java? Ist meine Idee für mein Java-"Kenntnisstand" realisierbar?

Ich würde mich sehr über anregende Ideen, bez. eure Meinung zu der Umsetzung freuen, danke.

Lieben Gruß
Sebastian

 

[Thallius]

Um das zu können muss dein Programm auf dem Mac dann aber als Superuser laufen. Ich muss ehrlich sagen, ich würde das keinem Programm erlauben das ich nicht selber geschrieben habe oder das von Apple selber kommt

Gruß

Claus

 

[mihe7]

Seit Java 9: https://docs.oracle.com/javase/9/docs/api/java/lang/ProcessHandle.html

 

[BestGoalkeeper]

import java.lang.ProcessHandle.Info;
import java.time.Duration;
import java.util.Arrays;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

public class Processes {
    public static void main(String[] args) {
        DefaultTableModel tm = new DefaultTableModel(1, 8);
        JTable jt = new JTable(tm);
        JFrame f = new JFrame();
        f.add(new JScrollPane(jt));
        f.setSize(1000, 500);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);

        new Thread(() -> {
            while (true) {
                tm.setRowCount(0);
                ProcessHandle.allProcesses().forEach(p -> {
                    Info info = p.info();
                    tm.addRow(new Object[] {
                            p.pid(),
                            p.isAlive(),
                            info.command().orElse("none"),
                            info.commandLine().orElse("none"),
                            info.arguments().map(Arrays::toString).orElse("none"),
                            info.startInstant().map(Object::toString).orElse("none"),
                            info.totalCpuDuration().map(Duration::toMillis).orElse(-1L),
                            info.user().orElse("none")
                        });
                });
                tm.fireTableDataChanged();
                try {
                    Thread.sleep(2500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

Umbringen geht dann mit destroy().

 

[BestGoalkeeper]

Hier das Ganze noch etwas hübscher:
[CODE lang="java" highlight="195-233"]import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.event.*;
import java.lang.ProcessHandle.Info;
import java.time.Duration;
import javax.swing.AbstractAction;
import javax.swing.AbstractCellEditor;
import javax.swing.Action;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.UIManager;
import javax.swing.border.Border;
import javax.swing.border.LineBorder;
import javax.swing.table.*;

public class Processes {
public static class ButtonColumn extends AbstractCellEditor implements TableCellRenderer, TableCellEditor, ActionListener, MouseListener {
private JTable table;
private Action action;
private int mnemonic;
private Border originalBorder;
private Border focusBorder;

private JButton renderButton;
private JButton editButton;
private Object editorValue;
private boolean isButtonColumnEditor;

/**
* Create the ButtonColumn to be used as a renderer and editor. The renderer and
* editor will automatically be installed on the TableColumn of the specified
* column.
*
* @param table the table containing the button renderer/editor
* @param action the Action to be invoked when the button is invoked
* @param column the column to which the button renderer/editor is added
*/
public ButtonColumn(JTable table, Action action, int column) {
this.table = table;
this.action = action;

renderButton = new JButton();
editButton = new JButton();
editButton.setFocusPainted(false);
editButton.addActionListener(this);
originalBorder = editButton.getBorder();
setFocusBorder(new LineBorder(Color.BLUE));

TableColumnModel columnModel = table.getColumnModel();
columnModel.getColumn(column).setCellRenderer(this);
columnModel.getColumn(column).setCellEditor(this);
table.addMouseListener(this);
}

/**
* Get foreground color of the button when the cell has focus
*
* @return the foreground color
*/
public Border getFocusBorder() {
return focusBorder;
}

/**
* The foreground color of the button when the cell has focus
*
* @param focusBorder the foreground color
*/
public void setFocusBorder(Border focusBorder) {
this.focusBorder = focusBorder;
editButton.setBorder(focusBorder);
}

public int getMnemonic() {
return mnemonic;
}

/**
* The mnemonic to activate the button when the cell has focus
*
* @param mnemonic the mnemonic
*/
public void setMnemonic(int mnemonic) {
this.mnemonic = mnemonic;
renderButton.setMnemonic(mnemonic);
editButton.setMnemonic(mnemonic);
}

@Override
public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
if (value == null) {
editButton.setText("");
editButton.setIcon(null);
} else if (value instanceof Icon) {
editButton.setText("");
editButton.setIcon((Icon) value);
} else {
editButton.setText(value.toString());
editButton.setIcon(null);
}

this.editorValue = value;
return editButton;
}

@Override
public Object getCellEditorValue() {
return editorValue;
}

//
// Implement TableCellRenderer interface
//
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
if (isSelected) {
renderButton.setForeground(table.getSelectionForeground());
renderButton.setBackground(table.getSelectionBackground());
} else {
renderButton.setForeground(table.getForeground());
renderButton.setBackground(UIManager.getColor("Button.background"));
}

if (hasFocus) {
renderButton.setBorder(focusBorder);
} else {
renderButton.setBorder(originalBorder);
}

// renderButton.setText( (value == null) ? "" : value.toString() );
if (value == null) {
renderButton.setText("");
renderButton.setIcon(null);
} else if (value instanceof Icon) {
renderButton.setText("");
renderButton.setIcon((Icon) value);
} else {
renderButton.setText(value.toString());
renderButton.setIcon(null);
}

return renderButton;
}

//
// Implement ActionListener interface
//
/*
* The button has been pressed. Stop editing and invoke the custom Action
*/
public void actionPerformed(ActionEvent e) {
int row = table.convertRowIndexToModel(table.getEditingRow());
fireEditingStopped();

// Invoke the Action

ActionEvent event = new ActionEvent(table, ActionEvent.ACTION_PERFORMED, "" + row);
action.actionPerformed(event);
}

//
// Implement MouseListener interface
//
/*
* When the mouse is pressed the editor is invoked. If you then then drag the
* mouse to another cell before releasing it, the editor is still active. Make
* sure editing is stopped when the mouse is released.
*/
public void mousePressed(MouseEvent e) {
if (table.isEditing() && table.getCellEditor() == this)
isButtonColumnEditor = true;
}

public void mouseReleased(MouseEvent e) {
if (isButtonColumnEditor && table.isEditing())
table.getCellEditor().stopCellEditing();

isButtonColumnEditor = false;
}

public void mouseClicked(MouseEvent e) {
}

public void mouseEntered(MouseEvent e) {
}

public void mouseExited(MouseEvent e) {
}
}

public static void main(String[] args) {
final int columns = 6;

JButton updatebutton = new JButton("Update");
DefaultTableModel tm = new DefaultTableModel(0, columns);
JTable jt = new JTable(tm);
JFrame f = new JFrame();
f.setLayout(new BorderLayout());
f.add(BorderLayout.CENTER, new JScrollPane(jt));
f.add(BorderLayout.SOUTH, updatebutton);
f.setSize(1000, 500);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);

updatebutton.addActionListener(u -> {
tm.setRowCount(0);
ProcessHandle.allProcesses().filter(ProcessHandle::isAlive).forEach(p -> {
Info info = p.info();
tm.addRow(new Object[] {
p.pid(),
info.command().orElse("none"),
info.startInstant().map(Object::toString).orElse("none"),
info.totalCpuDuration().map(Duration::toMillis).orElse(-1L),
info.user().orElse("none"),
"destroy " + p.pid()
});
});
new ButtonColumn(jt, new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
int modelRow = Integer.valueOf(e.getActionCommand());
long pid = (Long) tm.getValueAt(modelRow, 0);
JOptionPane.showMessageDialog(jt, ProcessHandle.of(pid).get().destroy() + "");
}
}, columns - 1)
.setMnemonic(KeyEvent.VK_DELETE);
tm.fireTableDataChanged();
});
}
}[/CODE]

Die Klasse "ButtonColumn" habe ich von hier: https://tips4java.wordpress.com/2009/07/12/table-button-column/ .