├── CODE_OF_CONDUCT.md ├── LICENSE.md ├── README.md ├── SECURITY.md ├── images ├── large.png ├── large2.png ├── preview.png ├── small.png ├── small2.png ├── socialpreview.png └── socialpreview2.png └── project ├── README.md ├── bin └── org │ ├── Main.class │ └── app │ ├── App.class │ ├── applications │ ├── encryption │ │ ├── ReadFile.class │ │ └── TestEncryption.class │ └── primality │ │ ├── SavePrimality.class │ │ └── TestPrimality.class │ └── windows │ ├── WinManager.class │ └── dependencies │ ├── components │ ├── WinHome$1$1.class │ ├── WinHome$1.class │ ├── WinHome$2.class │ ├── WinHome.class │ ├── encryption │ │ ├── WinEncryption.class │ │ ├── dialogs │ │ │ ├── WinErrorInEncryption$1.class │ │ │ ├── WinErrorInEncryption.class │ │ │ └── WinErrorOutEncryption.class │ │ └── panels │ │ │ ├── WinInEncryption$1.class │ │ │ ├── WinInEncryption$2.class │ │ │ ├── WinInEncryption$3.class │ │ │ ├── WinInEncryption$4.class │ │ │ ├── WinInEncryption$5.class │ │ │ ├── WinInEncryption$6.class │ │ │ ├── WinInEncryption.class │ │ │ ├── WinOutEncryption.class │ │ │ └── WinSaveEncryption.class │ └── primality │ │ ├── WinPrimality.class │ │ ├── dialogs │ │ ├── WinErrorInPrimality$1.class │ │ ├── WinErrorInPrimality.class │ │ └── WinErrorOutPrimality.class │ │ └── panels │ │ ├── WinInPrimality$1.class │ │ ├── WinInPrimality$2.class │ │ ├── WinInPrimality$3.class │ │ ├── WinInPrimality.class │ │ ├── WinOutPrimality$1.class │ │ ├── WinOutPrimality$2.class │ │ ├── WinOutPrimality$3.class │ │ ├── WinOutPrimality$4.class │ │ ├── WinOutPrimality.class │ │ └── WinSavePrimality.class │ └── managers │ ├── WinManagerEncryption.class │ └── WinManagerPrimality.class ├── doc └── doc.zip ├── lib └── flatlaf-3.2.5.jar ├── project.jar └── src └── org ├── Main.java └── app ├── App.java ├── applications ├── encryption │ ├── ReadFile.java │ └── TestEncryption.java └── primality │ ├── SavePrimality.java │ └── TestPrimality.java └── windows ├── WinManager.java └── dependencies ├── components ├── WinHome.java ├── encryption │ ├── WinEncryption.java │ ├── dialogs │ │ ├── WinErrorInEncryption.java │ │ └── WinErrorOutEncryption.java │ └── panels │ │ ├── WinInEncryption.java │ │ ├── WinOutEncryption.java │ │ └── WinSaveEncryption.java └── primality │ ├── WinPrimality.java │ ├── dialogs │ ├── WinErrorInPrimality.java │ └── WinErrorOutPrimality.java │ └── panels │ ├── WinInPrimality.java │ ├── WinOutPrimality.java │ └── WinSavePrimality.java └── managers ├── WinManagerEncryption.java └── WinManagerPrimality.java /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Fermat-And-RSA 2 | Soluzione software in Java che genera e salva su file i numeri primi con algoritmo di Fermat e algoritmo di crittografia RSA 3 | 4 | 5 | > [!NOTE] 6 | > Progetto scolastico 🎓 · Ⅳ 7 | 8 | 9 | > [!Warning] 10 | > Presenza di BUG nell'UI 11 | 12 | --- 13 | 14 | ## Javadoc 15 | 16 | Link al javadoc: [(link)](https://vittoriopiotti.altervista.org/FermatAndRsaJava/index.html) 17 | 18 | 19 | ## Preview 20 | 21 | Video di Test [(link)](https://drive.google.com/file/d/1IVb3ctowyLbrHMg7zlFN-Zv7If_51uzH/view?usp=sharing) 22 | 23 | 24 | --- 25 | 26 | 27 | 28 | 29 | 30 | 31 | ## Responsive 32 | 33 | ||| 34 | |-|-| 35 | |Small|Large| 36 | 37 | 38 | 39 | 40 | ## Utilizzo 41 | 42 | 1. Seleziona schermata di "Test Primalità" 43 | 2. Genera i numeri primi con algoritmo di Fermat 44 | 3. Salva su file i numeri primi 45 | 4. Seleziona schermata di "Algoritmo RSA" 46 | 5. Carica il file con i numeri primi 47 | 6. Cifra o decifra un messaggio 48 | 49 | 50 | 51 | 52 | ## Snippet Fermat Algorithm 53 | 54 | 55 | ```java 56 | public void algoritmoFermat(){ 57 | long start; //tempo inizio calcolo numeri primi 58 | long end; //tempo fine calcolo numeri primi 59 | boolean checkPrimo; //verifica se un numero è primo 60 | //check = true: primo 61 | //check = false: composto 62 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 63 | //ciclo for di i che scorre da min a max 64 | for ( 65 | BigInteger i = min; //è il numero di cui si verifica la primalità 66 | i.compareTo(max) <= 0; 67 | i = i.add(BigInteger.valueOf(1)) 68 | ) { 69 | incrementProgressBar.run(); 70 | checkPrimo = true; 71 | //ciclo for annidato di j che scorre da 2 al divisore massimo 72 | for ( 73 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 74 | j.compareTo(BigInteger.valueOf(10)) <= 0; //j compareTo fino al numero 75 | j = j.add(BigInteger.valueOf(1))) 76 | //verifica se j divisore di i ed in caso aggiorna check = false 77 | { 78 | if (Thread.currentThread().isInterrupted()) { 79 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 80 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 81 | return; 82 | } 83 | if (!j.modPow(i.subtract(BigInteger.valueOf(1)), i).equals(BigInteger.valueOf(1))) checkPrimo = false; 84 | } 85 | if (checkPrimo){ 86 | results.add(i.toString()); 87 | appendResult.run(); 88 | } 89 | } 90 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 91 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 92 | } 93 | 94 | ``` 95 | 96 | 97 | ## Albero di Path 98 | 99 | ```bash 100 | $ tree 101 | . 102 | ├──lib 103 | │ └── flatlaf-3.2.5.jar 104 | └──src 105 | └── org 106 | └── app 107 | ├── applications 108 | │ ├── encryption 109 | │ │ ├── ReadFile.java 110 | │ │ └── TestEncryption.java 111 | │ └── primality 112 | │ ├── SavePrimality.java 113 | │ └── TestPrimality.java 114 | ├── windows 115 | │ ├── dependencies 116 | │ │ ├── components 117 | │ │ │ ├── encryption 118 | │ │ │ │ ├── dialogs 119 | │ │ │ │ │ ├── WinErrorInEncryption.java 120 | │ │ │ │ │ └── WinErrorOutEncryption.java 121 | │ │ │ │ ├── panels 122 | │ │ │ │ │ ├── WinInEncryption.java 123 | │ │ │ │ │ ├── WinOutEncryption.java 124 | │ │ │ │ │ └── WinSaveEncryption.java 125 | │ │ │ │ └── WinEncryption.java 126 | │ │ │ ├── primality 127 | │ │ │ │ ├── dialogs 128 | │ │ │ │ │ ├── WinErrorInPrimality.java 129 | │ │ │ │ │ └── WinErrorOutPrimality.java 130 | │ │ │ │ ├── panels 131 | │ │ │ │ │ ├── WinInPrimality.java 132 | │ │ │ │ │ ├── WinOutPrimality.java 133 | │ │ │ │ │ └── WinSavePrimality.java 134 | │ │ │ │ └── WinPrimality.java 135 | │ │ │ └── WinHome.java 136 | │ │ └── managers 137 | │ │ ├── WinManagerEncryption.java 138 | │ │ └── WinManagerPrimality.java 139 | │ └── WinManager.java 140 | ├── App.java 141 | └── Main.java 142 | 143 | ``` 144 | 145 | ## Licenze 146 | 147 | 148 | ### Fermat And RSA 149 | 150 | **Copyright** 2024 Vittorio Piotti [(GitHub page)](https://github.com/vittorioPiotti) [(Personal page)](https://vittoriopiotti.altervista.org/) 151 | 152 | **Version** [v1.0.0](https://github.com/vittorioPiotti/FermatAndRSA-Java/releases/tag/1.0.0) 153 | 154 | **License** [GPL-3.0](https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 155 | 156 | 157 | --- 158 | 159 | ### FlatLaf 160 | 161 | **Copyright** 2024 JFormDesigner GmbH 162 | 163 | **Version** [v3.2.5](https://mvnrepository.com/artifact/com.formdev/flatlaf/3.2.5) 164 | 165 | **License** [Apache License 2.0](https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 166 | 167 | -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /images/large.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/large.png -------------------------------------------------------------------------------- /images/large2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/large2.png -------------------------------------------------------------------------------- /images/preview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/preview.png -------------------------------------------------------------------------------- /images/small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/small.png -------------------------------------------------------------------------------- /images/small2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/small2.png -------------------------------------------------------------------------------- /images/socialpreview.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/socialpreview.png -------------------------------------------------------------------------------- /images/socialpreview2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/images/socialpreview2.png -------------------------------------------------------------------------------- /project/README.md: -------------------------------------------------------------------------------- 1 | ## Getting Started 2 | 3 | Welcome to the VS Code Java world. Here is a guideline to help you get started to write Java code in Visual Studio Code. 4 | 5 | ## Folder Structure 6 | 7 | The workspace contains two folders by default, where: 8 | 9 | - `src`: the folder to maintain sources 10 | - `lib`: the folder to maintain dependencies 11 | 12 | Meanwhile, the compiled output files will be generated in the `bin` folder by default. 13 | 14 | > If you want to customize the folder structure, open `.vscode/settings.json` and update the related settings there. 15 | 16 | ## Dependency Management 17 | 18 | The `JAVA PROJECTS` view allows you to manage your dependencies. More details can be found [here](https://github.com/microsoft/vscode-java-dependency#manage-dependencies). 19 | -------------------------------------------------------------------------------- /project/bin/org/Main.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/Main.class -------------------------------------------------------------------------------- /project/bin/org/app/App.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/App.class -------------------------------------------------------------------------------- /project/bin/org/app/applications/encryption/ReadFile.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/applications/encryption/ReadFile.class -------------------------------------------------------------------------------- /project/bin/org/app/applications/encryption/TestEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/applications/encryption/TestEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/applications/primality/SavePrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/applications/primality/SavePrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/applications/primality/TestPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/applications/primality/TestPrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/WinManager.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/WinManager.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/WinHome$1$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/WinHome$1$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/WinHome$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/WinHome$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/WinHome$2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/WinHome$2.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/WinHome.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/WinHome.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/WinEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/WinEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/dialogs/WinErrorInEncryption$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/dialogs/WinErrorInEncryption$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/dialogs/WinErrorInEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/dialogs/WinErrorInEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/dialogs/WinErrorOutEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/dialogs/WinErrorOutEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$2.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$3.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$3.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$4.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$4.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$5.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$5.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$6.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption$6.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinInEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinOutEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinOutEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/encryption/panels/WinSaveEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/encryption/panels/WinSaveEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/WinPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/WinPrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/dialogs/WinErrorInPrimality$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/dialogs/WinErrorInPrimality$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/dialogs/WinErrorInPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/dialogs/WinErrorInPrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/dialogs/WinErrorOutPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/dialogs/WinErrorOutPrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality$2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality$2.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality$3.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality$3.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinInPrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$1.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$1.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$2.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$2.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$3.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$3.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$4.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality$4.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinOutPrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/components/primality/panels/WinSavePrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/components/primality/panels/WinSavePrimality.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/managers/WinManagerEncryption.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/managers/WinManagerEncryption.class -------------------------------------------------------------------------------- /project/bin/org/app/windows/dependencies/managers/WinManagerPrimality.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/bin/org/app/windows/dependencies/managers/WinManagerPrimality.class -------------------------------------------------------------------------------- /project/doc/doc.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/doc/doc.zip -------------------------------------------------------------------------------- /project/lib/flatlaf-3.2.5.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/lib/flatlaf-3.2.5.jar -------------------------------------------------------------------------------- /project/project.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vittorioPiotti/FermatAndRSA-Java/f8cefdb12fec8ec4b343c6d09e69a013e3e637b5/project/project.jar -------------------------------------------------------------------------------- /project/src/org/Main.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | 14 | package org; 15 | 16 | import org.app.App; 17 | 18 | 19 | 20 | /** 21 | * Punto di ingresso per l'applicazione Java. 22 | *

23 | * Questa classe contiene il metodo {@code main} che avvia l'applicazione. L'applicazione implementa due principali funzionalità: 24 | *

28 | *

29 | * 30 | *

31 | * La classe {@link App} è responsabile della gestione dell'interfaccia utente e della logica dell'applicazione, coordinando le operazioni di generazione dei numeri primi e di crittografia. Quando viene eseguita, crea una nuova istanza di {@link App}, avviando così l'intera applicazione. 32 | *

33 | * 34 | * @author Vittorio Piotti 35 | * @version 1.0 36 | * @since 16-10-2023 37 | */ 38 | public class Main { 39 | /** 40 | * Metodo principale che avvia l'applicazione. 41 | *

42 | * Questo metodo è il punto di ingresso dell'applicazione. Crea una nuova istanza della classe {@link App}, che avvia il processo di generazione dei numeri primi e di crittografia RSA. 43 | *

44 | * 45 | * @param args Argomenti della riga di comando, non utilizzati in questa applicazione. 46 | */ 47 | public static void main(String[] args) { 48 | new App(); 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /project/src/org/app/App.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app; 14 | import org.app.applications.encryption.ReadFile; 15 | import org.app.applications.encryption.TestEncryption; 16 | import org.app.applications.primality.SavePrimality; 17 | import org.app.applications.primality.TestPrimality; 18 | import org.app.windows.WinManager; 19 | 20 | /** 21 | * @author Vittorio Piotti 22 | * @version 1.0 23 | * @since 16-10-2023 24 | * La classe {@code App} rappresenta il punto di ingresso principale dell'applicazione e gestisce l'inizializzazione e il controllo 25 | * dei vari componenti dell'interfaccia utente e delle operazioni di calcolo. 26 | *

27 | * Questa classe si occupa di: 28 | *

33 | *

34 | */ 35 | public class App { 36 | 37 | /** 38 | * Gestore delle finestre per la gestione delle operazioni di primalità e crittografia. 39 | *

40 | * Questo attributo è responsabile della creazione e del controllo delle finestre relative ai calcoli di primalità e crittografia. 41 | *

42 | */ 43 | private static WinManager windowManager; 44 | 45 | /** 46 | * Oggetto per eseguire i test di primalità. 47 | *

48 | * Questo attributo contiene l'istanza di {@link TestPrimality} che viene utilizzata per eseguire i test di primalità sui numeri. 49 | *

50 | */ 51 | private static TestPrimality primalityTest; 52 | 53 | /** 54 | * Oggetto per eseguire le operazioni di crittografia e decrittografia. 55 | *

56 | * Questo attributo contiene l'istanza di {@link TestEncryption} che viene utilizzata per gestire le operazioni di crittografia e decrittografia. 57 | *

58 | */ 59 | private static TestEncryption encryption; 60 | 61 | 62 | /** 63 | * Oggetto per gestire il salvataggio dei risultati dei test di primalità in un file. 64 | *

65 | * Questo attributo contiene l'istanza di {@link SavePrimality} che è responsabile del salvataggio dei risultati dei test di primalità in un file. 66 | *

67 | */ 68 | private static SavePrimality saveInFilePrimality; 69 | 70 | /** 71 | * Oggetto per leggere i file necessari alle operazioni di crittografia. 72 | *

73 | * Questo attributo contiene l'istanza di {@link ReadFile} che viene utilizzata per leggere i file e verificare i dati necessari per le operazioni di crittografia. 74 | *

75 | */ 76 | private static ReadFile readFileEncryption; 77 | 78 | /** 79 | * Thread utilizzato per eseguire i test di primalità. 80 | *

81 | * Questo attributo contiene il {@link Thread} che esegue il test di primalità, permettendo l'esecuzione in background. 82 | *

83 | */ 84 | private static Thread taskPrimalityTest; 85 | 86 | /** 87 | * {@link Runnable} per stampare i risultati del test di primalità e aggiornare l'interfaccia utente. 88 | *

89 | * Questo {@link Runnable} è responsabile dell'aggiornamento dell'interfaccia utente con i risultati calcolati dal test di primalità. 90 | *

91 | */ 92 | public static Runnable printResultPrimality = () -> { 93 | windowManager.incrementCalculatedPrimeNumbers(); 94 | if(!primalityTest.getResult().equals("1") && !primalityTest.getResult().equals("0") ){ 95 | windowManager.appendCalculatedNumber( " " + primalityTest.getResult() +"\n"); 96 | } 97 | }; 98 | 99 | /** 100 | * {@link Runnable} per incrementare la barra di progresso nell'interfaccia utente. 101 | *

102 | * Questo {@link Runnable} è responsabile dell'incremento della barra di progresso durante l'esecuzione del calcolo di primalità. 103 | *

104 | */ 105 | private static Runnable incrementProgressBar = () -> { 106 | windowManager.incrementProgressBar(); 107 | }; 108 | 109 | /** 110 | * {@link Runnable} per fermare il calcolo di primalità. 111 | *

112 | * Questo {@link Runnable} interrompe il thread di calcolo della primalità se è in esecuzione. 113 | *

114 | */ 115 | public static Runnable stopCalcPrimality = () -> { 116 | if (taskPrimalityTest != null) { 117 | taskPrimalityTest.interrupt(); 118 | } 119 | }; 120 | 121 | /** 122 | * Genera una stringa di risultati della ricerca sui numeri primi. 123 | *

124 | * Questo metodo costruisce una stringa che include informazioni dettagliate sui risultati della ricerca di numeri primi. 125 | * La stringa contiene: 126 | *

134 | *

135 | * 136 | * @return Una stringa che rappresenta i risultati della ricerca di numeri primi, formattata per la visualizzazione o la stampa. 137 | */ 138 | private static String getResults(){ 139 | StringBuilder stringResults = new StringBuilder(); 140 | stringResults.append("Ricerca Numeri Primi\n"); 141 | stringResults.append("Input minimo: " + ((windowManager.getExpMin() != 0)?windowManager.getValMin() + " * 10 ^ "+windowManager.getExpMin():windowManager.getMin()) +"\n"); 142 | stringResults.append("Input massimo: " + ((windowManager.getExpMax() != 0)?windowManager.getValMax() + " * 10 ^ "+windowManager.getExpMax():windowManager.getMax()) +"\n"); 143 | stringResults.append("Metodo calcolo: " + windowManager.toStringMetodo()+"\n"); 144 | stringResults.append("Tempo calcolo: " + primalityTest.getTime() + "s\n"); 145 | stringResults.append("Numeri calcolati: " + (primalityTest.getResults().size() == 1 && primalityTest.getResults().get(0).equals("") ? 0 : primalityTest.getResults().size()) + "\n"); 146 | for (String result : primalityTest.getResults()){ 147 | stringResults.append(result).append("\n"); 148 | } 149 | return stringResults.toString(); 150 | } 151 | 152 | /** 153 | * {@link Runnable} per avviare il salvataggio dei risultati dei test di primalità in un file. 154 | *

155 | * Questo {@link Runnable} crea un nuovo file e salva i risultati dei test di primalità se la finestra di salvataggio è visibile. 156 | *

157 | */ 158 | public static Runnable startSavingPrimality = () -> { 159 | if(windowManager.existWindowSaveInFile() == true){ 160 | saveInFilePrimality = new SavePrimality(getResults(), windowManager.getPath()); 161 | saveInFilePrimality.newFile(); 162 | } 163 | }; 164 | 165 | /** 166 | * {@link Runnable} per inizializzare e controllare la lettura del file di crittografia. 167 | *

168 | * Questo {@link Runnable} legge il file di crittografia, verifica la validità e crea un'istanza di {@link TestEncryption} se il file è valido. 169 | *

170 | */ 171 | public static Runnable initAndCheckReadingFile = () -> { 172 | 173 | readFileEncryption = new ReadFile(windowManager.getPathReading(),windowManager.getModInverse()); 174 | windowManager.setFileErrorType(readFileEncryption.checkFile()); 175 | readFileEncryption = new ReadFile(windowManager.getPathReading(),windowManager.getModInverse()); 176 | String[] selectedRows = readFileEncryption.getRows(); 177 | if (readFileEncryption.checkFile() == true) { 178 | encryption = new TestEncryption(windowManager.getModInverse(),selectedRows[0],selectedRows[1],selectedRows[2]); 179 | } 180 | 181 | }; 182 | 183 | 184 | 185 | /** 186 | * {@link Runnable} per avviare il calcolo dei numeri primi. 187 | *

188 | * Questo {@link Runnable} crea un'istanza di {@link TestPrimality}, avvia un nuovo thread per eseguire il calcolo e aggiorna l'interfaccia utente. 189 | *

190 | */ 191 | public static Runnable startCalcPrimality = () -> { 192 | primalityTest = new TestPrimality(windowManager.getMin(), windowManager.getMax(), windowManager.getMetodo(), stopCalcPrimality, incrementProgressBar,printResultPrimality); 193 | taskPrimalityTest = new Thread(primalityTest, "Thread-TestPrimalita"); 194 | taskPrimalityTest.start(); 195 | }; 196 | 197 | /** 198 | * {@link Runnable} per avviare il calcolo della crittografia. 199 | *

200 | * Questo {@link Runnable} legge il file di crittografia e, in base al metodo di crittografia, esegue l'operazione di crittografia o decrittografia. 201 | *

202 | */ 203 | public static Runnable startCalcEncryption = () -> { 204 | readFileEncryption = new ReadFile(windowManager.getPathReading(),windowManager.getModInverse()); 205 | if (readFileEncryption.checkFile() == true) { 206 | 207 | if(windowManager.getEncryptionMetodo() == 0){ 208 | windowManager.setResultsEncryption(encryption.encrypt(windowManager.getMessage())); 209 | }else{ 210 | windowManager.setResultsEncryption(encryption.decrypt(windowManager.getMessage())); 211 | } 212 | 213 | 214 | 215 | } 216 | 217 | 218 | }; 219 | 220 | /** 221 | * {@link Runnable} per controllare eventuali modifiche al file di crittografia. 222 | *

223 | * Questo {@link Runnable} verifica se il file di crittografia è stato modificato e, se necessario, aggiorna l'interfaccia utente di conseguenza. 224 | *

225 | */ 226 | public static Runnable checkFileOnchange = () -> { 227 | if (readFileEncryption != null){ 228 | if(readFileEncryption.checkFile()){ 229 | windowManager.setFileErrorType(false); 230 | windowManager.openWindowErrorOutput(); 231 | 232 | 233 | } 234 | 235 | } 236 | 237 | }; 238 | 239 | 240 | /** 241 | * Costruttore della classe {@code App}. 242 | *

243 | * Inizializza {@link WinManager} con i vari {@link Runnable} per gestire le operazioni di calcolo e le interazioni dell'interfaccia utente. 244 | *

245 | */ 246 | public App(){ 247 | windowManager = new WinManager(startCalcPrimality,stopCalcPrimality,startSavingPrimality,startCalcEncryption,initAndCheckReadingFile,checkFileOnchange); 248 | } 249 | 250 | 251 | } 252 | -------------------------------------------------------------------------------- /project/src/org/app/applications/encryption/ReadFile.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.applications.encryption; 14 | 15 | import java.io.BufferedReader; 16 | import java.io.File; 17 | import java.io.FileReader; 18 | import java.io.IOException; 19 | import java.util.ArrayList; 20 | import java.util.List; 21 | import java.util.Random; 22 | 23 | 24 | /** 25 | * Classe che gestisce la lettura di un file di testo contenente dati numerici. 26 | * Filtra le righe secondo specifiche condizioni e offre funzionalità per estrarre 27 | * o verificare i dati numerici contenuti nel file. 28 | * @author Vittorio Piotti 29 | * @version 1.0 30 | * @since 16-10-2023 31 | */ 32 | public class ReadFile { 33 | 34 | /** Percorso del file da leggere. */ 35 | private String path; 36 | 37 | /** Indica se il modulo inverso è attivo per il filtraggio dei dati. */ 38 | private boolean modInverse; 39 | 40 | /** 41 | * Costruttore della classe ReadFile. 42 | * 43 | * @param path Percorso del file da leggere. 44 | * @param modInverse Se true, applica un filtro meno restrittivo sui dati numerici. 45 | */ 46 | public ReadFile(String path,boolean modInverse) { 47 | this.path = path; 48 | this.modInverse = modInverse; 49 | } 50 | 51 | /** 52 | * Legge il file e restituisce i dati numerici filtrati. 53 | * 54 | * @return Una stringa con i dati numerici filtrati, o null se il file non esiste o si verifica un errore. 55 | */ 56 | public String readFile() { 57 | StringBuilder numericData = new StringBuilder(); 58 | 59 | if (!fileExists(path)) { 60 | return null; 61 | } 62 | 63 | try (BufferedReader br = new BufferedReader(new FileReader(path))) { 64 | String line; 65 | 66 | while ((line = br.readLine()) != null) { 67 | if (line.matches("^\\d+$") && line.length() >= 2) { 68 | if(modInverse == false){ 69 | if(line.length() <= String.valueOf(Integer.MAX_VALUE).length() - 1) { 70 | numericData.append(line); 71 | numericData.append("\n"); 72 | } 73 | }else{ 74 | numericData.append(line); 75 | numericData.append("\n"); 76 | } 77 | } 78 | } 79 | } catch (IOException e) { 80 | e.printStackTrace(); 81 | return null; 82 | } 83 | 84 | return numericData.toString(); 85 | } 86 | 87 | /** 88 | * Verifica se il file rispetta i criteri specificati (almeno 3 righe valide). 89 | * 90 | * @return true se il file contiene almeno 3 righe numeriche valide, altrimenti false. 91 | */ 92 | public boolean checkFile() { 93 | if (this.path == null || !this.path.endsWith(".txt")) { 94 | return false; 95 | } 96 | 97 | int count = 0; 98 | 99 | if (!fileExists(path)) { 100 | return false; 101 | } 102 | 103 | try (BufferedReader br = new BufferedReader(new FileReader(this.path))) { 104 | String line; 105 | 106 | while ((line = br.readLine()) != null) { 107 | if (line.matches("^\\d+$") && line.length() >= 2) { 108 | if (modInverse == false) { 109 | if (line.length() <= String.valueOf(Integer.MAX_VALUE).length() - 1) { 110 | count++; 111 | } 112 | } else { 113 | count++; 114 | } 115 | if (count >= 3) { 116 | return true; 117 | } 118 | } 119 | } 120 | } catch (IOException e) { 121 | e.printStackTrace(); 122 | return false; 123 | } 124 | 125 | return false; 126 | } 127 | 128 | /** 129 | * Estrae casualmente 3 righe numeriche dal file. 130 | * 131 | * @return Un array di 3 stringhe contenenti le righe numeriche estratte, o null se non ci sono abbastanza righe valide. 132 | */ 133 | public String[] getRows() { 134 | // Verifica se il file esiste 135 | if (!fileExists(path)) { 136 | return null; 137 | } 138 | 139 | List numericRows = new ArrayList<>(); 140 | 141 | try (BufferedReader br = new BufferedReader(new FileReader(path))) { 142 | String line; 143 | 144 | while ((line = br.readLine()) != null) { 145 | if (line.matches("^\\d+$")) { 146 | numericRows.add(line); 147 | } 148 | } 149 | } catch (IOException e) { 150 | e.printStackTrace(); 151 | return null; 152 | } 153 | 154 | if (numericRows.size() < 3) { 155 | return null; 156 | } 157 | 158 | String[] selectedRows = new String[3]; 159 | Random random = new Random(); 160 | 161 | for (int i = 0; i < 3; i++) { 162 | int randomIndex = random.nextInt(numericRows.size()); 163 | selectedRows[i] = numericRows.get(randomIndex); 164 | } 165 | 166 | return selectedRows; 167 | } 168 | 169 | /** 170 | * Verifica se il file esiste e se il percorso è valido. 171 | * 172 | * @param path Percorso del file da verificare. 173 | * @return true se il file esiste ed è valido, altrimenti false. 174 | */ 175 | private boolean fileExists(String path) { 176 | if (this.path == null) { 177 | return false; 178 | } 179 | File file = new File(path); 180 | return file.exists() && file.isFile(); 181 | } 182 | } 183 | -------------------------------------------------------------------------------- /project/src/org/app/applications/encryption/TestEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.applications.encryption; 14 | 15 | import java.math.BigInteger; 16 | 17 | /** 18 | * Classe che implementa la crittografia RSA semplice per cifrare e decifrare messaggi. 19 | * Fornisce un'opzione per calcolare la chiave privata (d) utilizzando il modulo inverso o 20 | * un metodo alternativo. 21 | * @author Vittorio Piotti 22 | * @version 1.0 23 | * @since 16-10-2023 24 | */ 25 | public class TestEncryption { 26 | 27 | /** Primo numero primo utilizzato per generare la chiave RSA. */ 28 | private BigInteger p; 29 | 30 | /** Secondo numero primo utilizzato per generare la chiave RSA. */ 31 | private BigInteger q; 32 | 33 | /** Esponente pubblico utilizzato per la crittografia. */ 34 | private BigInteger e; 35 | 36 | /** Modulo n utilizzato per la crittografia e la decrittografia. */ 37 | private BigInteger n; 38 | 39 | /** Esponente privato utilizzato per la decrittografia. */ 40 | private BigInteger d; 41 | 42 | /** 43 | * Costruttore per inizializzare i parametri RSA e calcolare la chiave privata (d). 44 | * 45 | * @param modInverse Se true, utilizza il metodo del modulo inverso per calcolare d, altrimenti utilizza un algoritmo alternativo. 46 | * @param p Primo numero primo come stringa. 47 | * @param q Secondo numero primo come stringa. 48 | * @param e Esponente pubblico come stringa. 49 | */ 50 | public TestEncryption(boolean modInverse,String p, String q, String e) { 51 | this.p = new BigInteger(p); 52 | this.q = new BigInteger(q); 53 | this.e = new BigInteger(e); 54 | this.n = this.p.multiply(this.q); 55 | BigInteger phi_n = this.p.subtract(BigInteger.ONE).multiply(this.q.subtract(BigInteger.ONE)); 56 | if(modInverse == true){ 57 | this.d = this.e.modInverse(phi_n); 58 | }else{ 59 | this.d = calculateD(this.e, phi_n); 60 | 61 | } 62 | 63 | } 64 | 65 | /** 66 | * Metodo privato per calcolare la chiave privata (d) senza utilizzare il modulo inverso. 67 | * 68 | * @param e Esponente pubblico. 69 | * @param phi_n Funzione di Eulero (φ(n)). 70 | * @return La chiave privata (d) calcolata. 71 | */ 72 | private BigInteger calculateD(BigInteger e, BigInteger phi_n) { 73 | BigInteger d = BigInteger.ZERO; 74 | BigInteger k = BigInteger.ONE; 75 | 76 | while (true) { 77 | BigInteger numerator = k.multiply(phi_n).add(BigInteger.ONE); 78 | if (numerator.mod(e).equals(BigInteger.ZERO)) { 79 | d = numerator.divide(e); 80 | break; 81 | } 82 | k = k.add(BigInteger.ONE); 83 | } 84 | 85 | return d; 86 | } 87 | 88 | /** 89 | * Cifra un messaggio di testo in chiaro utilizzando la chiave pubblica RSA. 90 | * 91 | * @param plaintext Il messaggio in chiaro da cifrare. 92 | * @return Il messaggio cifrato, rappresentato come una stringa di numeri separati da spazi. 93 | */ 94 | public String encrypt(String plaintext) { 95 | StringBuilder ciphertext = new StringBuilder(); 96 | for (char c : plaintext.toCharArray()) { 97 | BigInteger m = BigInteger.valueOf(c); 98 | BigInteger encrypted = m.modPow(e, n); 99 | ciphertext.append(encrypted).append(" "); 100 | } 101 | return ciphertext.toString().trim(); 102 | } 103 | 104 | /** 105 | * Decifra un messaggio cifrato utilizzando la chiave privata RSA. 106 | * 107 | * @param ciphertext Il messaggio cifrato da decifrare. 108 | * @return Il messaggio in chiaro decifrato. 109 | */ 110 | public String decrypt(String ciphertext) { 111 | StringBuilder plaintext = new StringBuilder(); 112 | for (String token : ciphertext.split(" ")) { 113 | BigInteger encrypted = new BigInteger(token); 114 | BigInteger decrypted = encrypted.modPow(d, n); 115 | plaintext.append((char) decrypted.intValue()); 116 | } 117 | return plaintext.toString(); 118 | } 119 | } 120 | -------------------------------------------------------------------------------- /project/src/org/app/applications/primality/SavePrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.applications.primality; 14 | 15 | 16 | import java.io.FileWriter; 17 | import java.io.IOException; 18 | 19 | /** 20 | * La classe {@code SavePrimality} gestisce la scrittura di una lista di stringhe formattate su un file TSV (Tab-Separated Values). 21 | *

22 | * Ogni volta che viene chiamato il metodo {@link #newFile()}, il file viene ricreato, ovvero viene eliminato il file esistente e ne viene creato uno nuovo con il contenuto fornito. 23 | *

24 | * 25 | * @author Vittorio Piotti 26 | * @version 1.0 27 | * @since 16-10-2023 28 | */ 29 | public class SavePrimality { 30 | 31 | /** 32 | * Contenuto formattato da scrivere nel file. 33 | * Questo campo contiene le stringhe che verranno scritte nel file TSV. 34 | */ 35 | private String content; 36 | 37 | /** 38 | * Percorso del file in cui salvare il contenuto. 39 | * Questo campo specifica il percorso completo del file in cui il contenuto sarà scritto. 40 | */ 41 | private String path; 42 | 43 | /** 44 | * Costruttore della classe {@code SavePrimality}. 45 | *

46 | * Inizializza il contenuto e il percorso del file in cui il contenuto verrà salvato. 47 | *

48 | * 49 | * @param content Il contenuto formattato da scrivere nel file. 50 | * @param path Il percorso completo del file in cui salvare il contenuto. 51 | */ 52 | public SavePrimality(String content,String path) { 53 | this.content = content; 54 | this.path = path; 55 | } 56 | 57 | /** 58 | * Scrive il contenuto nel file specificato dal percorso. 59 | *

60 | * Questo metodo elimina il file esistente e ne crea uno nuovo con il contenuto fornito. Se si verifica un'eccezione durante la scrittura, il metodo la gestisce silenziosamente senza interrompere l'esecuzione. 61 | *

62 | */ 63 | public void newFile() { 64 | 65 | try (FileWriter fileWriter = new FileWriter(path, false)) { 66 | fileWriter.write(content); 67 | } catch (IOException e) { 68 | return; 69 | } 70 | } 71 | 72 | } -------------------------------------------------------------------------------- /project/src/org/app/applications/primality/TestPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.applications.primality; 14 | 15 | 16 | import java.math.BigInteger; 17 | import java.util.ArrayList; 18 | import java.util.List; 19 | 20 | /** 21 | * La classe sviluppa e garantisce logica dei metodi di calcolo per il test di primalità
La classe utilizza BigInteger per gestire numeri di centinaia di cifre
La classe implementa Runnable in quanto le operazioni di calcolo impiegano un dispendio di tempo tale per cui il thread deve essere gestito in modo che non interferisca con altri thread impedendone la corretta esecuzione
I metodi di calcolo non sono ottimizzati per un tempo di esecuzione minore in quanto presentano due colback in App di cui la prima per aggiornare la UI e di cui la seconda per salvare o dati con Log 22 | * @author Vittorio Piotti 23 | * @version 1.0 24 | * @since 16-10-2023 25 | */ 26 | 27 | public class TestPrimality implements Runnable { 28 | 29 | /** 30 | * Rappresenta la scelta del metodo di calcolo utilizzato per la ricerca dei numeri primi. 31 | * Questo valore viene usato per determinare quale algoritmo di calcolo dei numeri primi utilizzare. 32 | */ 33 | private int choice; //corrisponde alla scelta del metodo di calcolo 34 | 35 | /** 36 | * Il numero minimo dell'intervallo da cui inizia la ricerca dei numeri primi. 37 | * Questo valore rappresenta il limite inferiore dell'intervallo di ricerca per trovare numeri primi. 38 | */ 39 | private BigInteger min; //corrisponde al numero minimo di partenza della ricerca dei numeri primi 40 | 41 | /** 42 | * Il numero massimo dell'intervallo fino al quale viene effettuata la ricerca dei numeri primi. 43 | * Questo valore rappresenta il limite superiore dell'intervallo di ricerca per trovare numeri primi. 44 | */ 45 | private BigInteger max; //corrisponde al numero massimo di termine della ricerca dei numeri primi 46 | 47 | /** 48 | * Il tempo impiegato per completare la ricerca dei numeri primi, espresso in secondi. 49 | * Questo valore viene aggiornato durante l'esecuzione della ricerca e utilizzato per misurare le prestazioni del calcolo. 50 | */ 51 | private double time; //corrisponde al tempo impiegato per la ricerca dei numeri primi 52 | 53 | /** 54 | * Una lista di stringhe che contiene tutti i numeri primi trovati all'interno dell'intervallo specificato. 55 | * Ogni stringa rappresenta un numero primo trovato durante la ricerca. 56 | */ 57 | private List < String > results = new ArrayList < >(); //corrisponde a tutti i numeri primi trovati nell'intervallo dato 58 | 59 | /** 60 | * Callback invocata alla fine dell'esecuzione del metodo {@link #run()}. 61 | * Questo callback fa riferimento a {@link Log} per salvare i risultati della ricerca e a {@link UI} per visualizzare i risultati all'utente. 62 | */ 63 | private Runnable stopCalc; 64 | 65 | /** 66 | * Callback utilizzato per aggiungere un risultato alla visualizzazione dell'interfaccia utente. 67 | * Questo callback è invocato ogni volta che viene trovato un numero primo e serve per aggiornare la visualizzazione dei risultati. 68 | */ 69 | private Runnable appendResult; 70 | 71 | /** 72 | * Callback invocato ad ogni iterazione della ricerca per aggiornare la barra di progresso nell'interfaccia utente. 73 | * Questo callback è utilizzato per incrementare la barra di caricamento e fornire un feedback visivo sul progresso della ricerca. 74 | */ 75 | private Runnable incrementProgressBar; 76 | 77 | /** 78 | * Questo costruttore definisce l'istanza degli attributi min e max rispettivamente i valori dell'intervallo entro cui ricercare numeri primi. 79 | * @param min Stringa rappresentante il valore minimo inserito in input per l'intervallo di ricerca dei numeri primi 80 | * @param max Stringa rappresentante il valore massimo inserito in input per l'intervallo di ricerca dei numeri primi 81 | * @param choice Rappresenta il numero del metodo scelto per il calcolo della ricerca dei numeri primi 82 | * @param stopCalc Callback definita nel fa riferimento a SaveInFile per salvare i risultati e App per visualizzare i risultati 83 | * @param incrementProgressBar Callback definita nel ed invocata ad ogni numero edll'intervallo di ricerca fa riferimento a App per incrementare la barra di caricamento 84 | * @param appendResult Callback definita nel ed invocata ad ogni numero edll'intervallo di ricerca fa riferimento a App per incrementare la barra di caricamento 85 | 86 | */ 87 | public TestPrimality(String min, String max, int choice, Runnable stopCalc, Runnable incrementProgressBar,Runnable appendResult) { 88 | this.min = new BigInteger(min); 89 | this.max = new BigInteger(max); 90 | this.choice = choice; 91 | this.stopCalc = stopCalc; 92 | this.appendResult = appendResult; 93 | this.incrementProgressBar = incrementProgressBar; 94 | 95 | } 96 | 97 | /** 98 | * Questo metodo assegna il valore all'attributo privato choice che è relativo all'algoritmo di calcolo scelto 99 | * @param choice numero del metodo di calcolo scelto 100 | */ 101 | public void setChoice(int choice) { 102 | this.choice = choice; 103 | } 104 | 105 | /** 106 | * Questo metodo restituisce il valore dell'attributo privato choice che è relativo all'algoritmo di calcolo scelto 107 | * @return numero del metodo scelto 108 | */ 109 | public int getChoice() { 110 | return choice; 111 | } 112 | 113 | /** 114 | * Questo metodo ripristina la lista dei risultati rimuovendo ogni elemento da essa 115 | */ 116 | public void setResults() { 117 | results.clear(); 118 | } 119 | 120 | /** 121 | * Questo metodo ritorna la lista dei risultati 122 | * @return risultati dei numeri primi derivati dai calcoli 123 | */ 124 | public List < String > getResults() { 125 | return results; 126 | } 127 | 128 | /** 129 | * Questo metodo ritorna il valore massimo di arrivo per la ricerca dei numeri primi. 130 | * @return numero massimo inserito in input per l'intervallo di ricerca dei numeri primi 131 | */ 132 | public String getMax() { 133 | return max.toString(); 134 | } 135 | 136 | /** 137 | * Questo metodo ritorna il valore minimo di partenza per la ricerca dei numeri primi. 138 | * @return numero minimo inserito in input per l'intervallo di ricerca dei numeri primi 139 | 140 | */ 141 | public String getMin() { 142 | return min.toString(); 143 | } 144 | 145 | /** 146 | * Questo metodo ritorna il tempo impiegato per la ricerca dei numeri primi. 147 | * @return tempo trascorso dall'inizio al termine della ricerca dei numeri primi 148 | */ 149 | public double getTime() { 150 | return time; 151 | } 152 | 153 | /** 154 | * Questo metodo imposta un nuovo valore al numero massimo di arrivo per la ricerca dei numeri primi. 155 | * @param max numero massimo inserito in input per l'intervallo di ricerca dei numeri primi 156 | */ 157 | public void setMax(String max) { 158 | this.max = new BigInteger(max); 159 | } 160 | 161 | /** 162 | * Questo metodo imposta un nuovo valore al numero minimo di partenza per la ricerca dei numeri primi. 163 | * @param min numero massimo inserito in input per l'intervallo di ricerca dei numeri primi 164 | */ 165 | public void setMin(String min) { 166 | this.min = new BigInteger(min); 167 | } 168 | 169 | /** 170 | * Questo metodo imposta un nuovo valore al tempo impiegato per la ricerca dei numeri primi. 171 | * @param time tempo trascorso dall'inizio al termine della ricerca dei numeri primi 172 | */ 173 | public void setTime(double time) { 174 | this.time = time; 175 | } 176 | 177 | /** 178 | * Questo metodo effettua il test di verifica della primalita con la logica della ricerca dei divisori fino al numero
Presenta un controllo isInterrupted() che ad ogni iterazione del ciclo annidato controlla se processo terminato ed in caso interrompe i calcoli sviluppando i dati ricavati per essere gestiti nel main 179 | */ 180 | public void calcPrimeUntilNum() { 181 | long start; //tempo inizio calcolo numeri primi 182 | long end; //tempo fine calcolo numeri primi 183 | boolean checkPrimo; //verifica se un numero è primo 184 | //check = true: primo 185 | //check = false: composto 186 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 187 | //ciclo for di i che scorre da min a max 188 | for ( 189 | BigInteger i = min; //è il numero di cui si verifica la primalità 190 | i.compareTo(max) <= 0; 191 | i = i.add(BigInteger.valueOf(1)) 192 | ) { 193 | 194 | incrementProgressBar.run(); 195 | checkPrimo = true; 196 | //ciclo for annidato di j che scorre da 2 al divisore massimo 197 | for ( 198 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 199 | j.compareTo(i) < 0; //j compareTo fino al numero 200 | j = j.add(BigInteger.valueOf(1))) 201 | //verifica se j divisore di i ed in caso aggiorna check = false 202 | { 203 | if (Thread.currentThread().isInterrupted()) { 204 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 205 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 206 | return; 207 | } 208 | if (i.mod(j).equals(BigInteger.valueOf(0))) checkPrimo = false; 209 | } 210 | if (checkPrimo){ 211 | results.add(i.toString()); 212 | appendResult.run(); 213 | } 214 | 215 | } 216 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 217 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 218 | } 219 | 220 | /** 221 | * Questo metodo effettua il test di verifica della primalita con la logica della ricerca dei divisori fino al numero uscendo dal ciclo appena possibile
Presenta un controllo isInterrupted() che ad ogni iterazione del ciclo annidato controlla se processo terminato ed in caso interrompe i calcoli sviluppando i dati ricavati per essere gestiti nel main 222 | */ 223 | public void calcPrimeUntilNumWithBreak() { 224 | long start; //tempo inizio calcolo numeri primi 225 | long end; //tempo fine calcolo numeri primi 226 | boolean checkPrimo; //verifica se un numero è primo 227 | //check = true: primo 228 | //check = false: composto 229 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 230 | //ciclo for di i che scorre da min a max 231 | for ( 232 | BigInteger i = min; //è il numero per cui si verifica la primalità 233 | i.compareTo(max) <= 0; 234 | i = i.add(BigInteger.valueOf(1))) { 235 | incrementProgressBar.run(); 236 | checkPrimo = true; 237 | //ciclo for annidato di j che scorre da 2 al divisore massimo 238 | for ( 239 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 240 | j.compareTo(i) < 0; //j compareTo fino al numero 241 | j = j.add(BigInteger.valueOf(1))) 242 | //verifica se j divisore di i ed in caso aggiorna check = false 243 | { 244 | if (Thread.currentThread().isInterrupted()) { 245 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 246 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 247 | return; 248 | } 249 | if (i.mod(j).equals(BigInteger.valueOf(0))) { 250 | checkPrimo = false; 251 | break; //fine ricerca primalita quindi interrompe il ciclo di j perche i è composto 252 | } 253 | 254 | } 255 | if (checkPrimo){ 256 | results.add(i.toString()); 257 | appendResult.run(); 258 | } 259 | } 260 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 261 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 262 | } 263 | 264 | /** 265 | * Questo metodo effettua il test di verifica della primalita con la logica della ricerca dei divisori fino alla meta del numero
Presenta un controllo isInterrupted() che ad ogni iterazione del ciclo annidato controlla se processo terminato ed in caso interrompe i calcoli sviluppando i dati ricavati per essere gestiti nel main 266 | */ 267 | public void calcPrimeUntilHalfNum() { 268 | long start; //tempo inizio calcolo numeri primi 269 | long end; //tempo fine calcolo numeri primi 270 | boolean checkPrimo; //verifica se un numero è primo 271 | //check = true: primo 272 | //check = false: composto 273 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 274 | //ciclo for di i che scorre da min a max 275 | for ( 276 | BigInteger i = min; //è il numero per cui si verifica la primalità 277 | i.compareTo(max) <= 0; 278 | i = i.add(BigInteger.valueOf(1))) { 279 | incrementProgressBar.run(); 280 | checkPrimo = true; 281 | //ciclo for annidato di j che scorre da 2 al divisore massimo 282 | for ( 283 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 284 | j.compareTo(i.divide(BigInteger.valueOf(2))) <= 0; //j compareTo fino alla meta del numero 285 | j = j.add(BigInteger.valueOf(1))) 286 | //verifica se j divisore di i ed in caso aggiorna check = false 287 | { 288 | if (Thread.currentThread().isInterrupted()) { 289 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 290 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 291 | return; 292 | } 293 | if (i.mod(j).equals(BigInteger.valueOf(0))) checkPrimo = false; 294 | } 295 | if (checkPrimo){ 296 | results.add(i.toString()); 297 | appendResult.run(); 298 | } 299 | } 300 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 301 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 302 | } 303 | 304 | /** 305 | * Questo metodo effettua il test di verifica della primalita con la logica della ricerca dei divisori fino alla meta del numero considerando solo i numeri dispari
Presenta un controllo isInterrupted() che ad ogni iterazione del ciclo annidato controlla se processo terminato ed in caso interrompe i calcoli sviluppando i dati ricavati per essere gestiti nel main 306 | */ 307 | public void calcPrimeUntilHalfNumOnlyOdd() { 308 | long start; //tempo inizio calcolo numeri primi 309 | long end; //tempo fine calcolo numeri primi 310 | boolean checkPrimo; //verifica se un numero è primo 311 | //check = true: primo 312 | //check = false: composto 313 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 314 | //ciclo for di i che scorre da min a max 315 | for ( 316 | BigInteger i = min; //è il numero per cui si verifica la primalità 317 | i.compareTo(max) <= 0; 318 | i = i.add(BigInteger.valueOf(1))) { 319 | incrementProgressBar.run(); 320 | checkPrimo = true; 321 | //ciclo for annidato di j che scorre da 2 al divisore massimo 322 | for ( 323 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 324 | j.compareTo(i.divide(BigInteger.valueOf(2))) <= 0; //j compareTo fino alla meta del numero 325 | j = j.add(BigInteger.valueOf(1))) 326 | //verifica se i è pari o se j divisore di i ed in caso aggiorna check = false 327 | { 328 | if (Thread.currentThread().isInterrupted()) { 329 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 330 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 331 | return; 332 | } 333 | if (i.mod(BigInteger.valueOf(2)).equals(BigInteger.valueOf(0)) //se i è pari 334 | || i.mod(j).equals(BigInteger.valueOf(0)) // se i è divisivbile 335 | ) checkPrimo = false; //allora i è composto 336 | } 337 | if (checkPrimo){ 338 | results.add(i.toString()); 339 | appendResult.run(); 340 | } 341 | } 342 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 343 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 344 | } 345 | 346 | /** 347 | * Questo metodo effettua il test di verifica della primalita con la logica della ricerca dei divisori fino alla radice del numero considerando solo i numeri dispari ed uscendo dal ciclo appena possibile
Presenta un controllo isInterrupted() che ad ogni iterazione del ciclo annidato controlla se processo terminato ed in caso interrompe i calcoli sviluppando i dati ricavati per essere gestiti nel main 348 | */ 349 | public void calcPrimeUntilRadixNumOnlyOddWithBreak() { 350 | long start; //tempo inizio calcolo numeri primi 351 | long end; //tempo fine calcolo numeri primi 352 | boolean checkPrimo; //verifica se un numero è primo 353 | //check = true: primo 354 | //check = false: composto 355 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 356 | //ciclo for di i che scorre da min a max 357 | for ( 358 | BigInteger i = min; //è il numero per cui si verifica la primalità 359 | i.compareTo(max) <= 0; 360 | i = i.add(BigInteger.valueOf(1))) { 361 | incrementProgressBar.run(); 362 | checkPrimo = true; 363 | //ciclo for annidato di j che scorre da 2 al divisore massimo 364 | for ( 365 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 366 | j.compareTo(i.sqrt().add(BigInteger.valueOf(1))) < 0; //j compareTo fino alla radice del numero 367 | j = j.add(BigInteger.valueOf(1))) 368 | //verifica se i è pari o se j divisore di i ed in caso aggiorna check = false 369 | { 370 | if (Thread.currentThread().isInterrupted()) { 371 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 372 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 373 | return; 374 | } 375 | if (i.mod(BigInteger.valueOf(2)).equals(BigInteger.valueOf(0)) //i è pari 376 | || i.mod(j).equals(BigInteger.valueOf(0)) //i è divisivbile 377 | ) { 378 | checkPrimo = false; //i è composto 379 | break; //fine ricerca primalita quindi interrompe il ciclo di j perche i è composto 380 | } 381 | } 382 | if (checkPrimo){ 383 | results.add(i.toString()); 384 | appendResult.run(); 385 | } 386 | } 387 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 388 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 389 | } 390 | 391 | /** 392 | * Questo metodo effettua il test di verifica della primalita con la logica dell'algoritmo di Fermat
Presenta un controllo isInterrupted() che ad ogni iterazione del ciclo annidato controlla se processo terminato ed in caso interrompe i calcoli sviluppando i dati ricavati per essere gestiti nel main 393 | */ 394 | public void algoritmoFermat(){ 395 | long start; //tempo inizio calcolo numeri primi 396 | long end; //tempo fine calcolo numeri primi 397 | boolean checkPrimo; //verifica se un numero è primo 398 | //check = true: primo 399 | //check = false: composto 400 | start = System.currentTimeMillis(); //tempo inizio calcolo numeri primi 401 | //ciclo for di i che scorre da min a max 402 | for ( 403 | BigInteger i = min; //è il numero di cui si verifica la primalità 404 | i.compareTo(max) <= 0; 405 | i = i.add(BigInteger.valueOf(1)) 406 | ) { 407 | incrementProgressBar.run(); 408 | checkPrimo = true; 409 | //ciclo for annidato di j che scorre da 2 al divisore massimo 410 | for ( 411 | BigInteger j = BigInteger.valueOf(2); //è il dvisore del numero per la verifica della primalità 412 | j.compareTo(BigInteger.valueOf(10)) <= 0; //j compareTo fino al numero 413 | j = j.add(BigInteger.valueOf(1))) 414 | //verifica se j divisore di i ed in caso aggiorna check = false 415 | { 416 | if (Thread.currentThread().isInterrupted()) { 417 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 418 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 419 | return; 420 | } 421 | if (!j.modPow(i.subtract(BigInteger.valueOf(1)), i).equals(BigInteger.valueOf(1))) checkPrimo = false; 422 | } 423 | if (checkPrimo){ 424 | results.add(i.toString()); 425 | appendResult.run(); 426 | } 427 | } 428 | end = System.currentTimeMillis(); //tempo fine calcolo numeri primi 429 | time = Math.abs(start - end) / 1000.0; //tempo durata calcolo numeri primi 430 | 431 | } 432 | 433 | /** 434 | * Questo metodo sviluppa il metodo di calcolo sulla base dell valore dell'attributo privato relativo
Questo metodo è l'implementazione dell'interfaccia 'Runnable' ed è utilizzo per creare il thread del calcolo in modo che la classe possa essere eseguita in modo concorrente rispetto alla classe UI
Nello specifico è stato necessario ciò in quanto il tempo di calcolo è tale per cui senza l'implementazione di runnable nella UI all'avvio del calcolo nella relativa finestra di dialogo questa o rimane in attesa fino al termine del calcolo o il calcolo viene avviato solo alla chiusura della finestra di dialogo
Il comportamento corretto reso possibile dall'implementazione prevede quindi che il calcolo non interferisca con la UI 435 | */ 436 | public void run() { 437 | //questa sleep è usato rispetto alla 'UI' 438 | //La 'UI' gestisce il calcolo con le schermata di richiesta, attesa e risultato 439 | //Ciò in modo che la 'UI' abbia il tempo di svilupparsi correttamente senza interferenze tra le schermate. 440 | try { 441 | Thread.sleep(500); 442 | } catch(InterruptedException e) { 443 | return; 444 | } 445 | switch (choice) { 446 | case 0: 447 | //senza break, anche dispari, tutti 448 | calcPrimeUntilNum(); 449 | break; 450 | case 1: 451 | //con break, anche dispari, tutti 452 | calcPrimeUntilNumWithBreak(); 453 | break; 454 | case 2: 455 | //senza break, anche dispari, fino meta 456 | calcPrimeUntilHalfNum(); 457 | break; 458 | case 3: 459 | //senza break, solo dispari, fino meta 460 | calcPrimeUntilHalfNumOnlyOdd(); 461 | break; 462 | case 4: 463 | //con break, solo dispari, fino radice 464 | calcPrimeUntilRadixNumOnlyOddWithBreak(); 465 | break; 466 | case 5: 467 | // Algoritmo di Fermat 468 | if(max.compareTo(BigInteger.valueOf(10)) > 0){ 469 | algoritmoFermat(); 470 | } 471 | break; 472 | } 473 | if(results.size() > 0){ 474 | if(results.get(0).equals("0"))results.remove(0); 475 | if(results.get(0).equals("1"))results.remove(0); 476 | } 477 | if(choice == 5){ 478 | final int [] primi = {2,3,5,7}; 479 | for(int i = 0; i < primi.length; i ++){ 480 | if(min.compareTo(BigInteger.valueOf(primi[i])) <= 0 && max.compareTo(BigInteger.valueOf(primi[i])) >= 0){ 481 | results.add(i,String.valueOf(primi[i])); 482 | } 483 | } 484 | } 485 | if(results.size() == 0){ 486 | results.add(""); 487 | } 488 | 489 | stopCalc.run(); 490 | } 491 | 492 | /** 493 | *@return ritorna i numeri risultati della ricerca dei numeri primi 494 | */ 495 | public String getResult(){ 496 | return ((results.size() == 0)?"":results.get(results.size() - 1)); 497 | } 498 | 499 | } -------------------------------------------------------------------------------- /project/src/org/app/windows/WinManager.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows; 14 | 15 | import java.util.function.Supplier; 16 | 17 | import javax.swing.JFrame; 18 | import javax.swing.UIManager; 19 | import javax.swing.UnsupportedLookAndFeelException; 20 | 21 | import org.app.windows.dependencies.components.WinHome; 22 | import org.app.windows.dependencies.managers.WinManagerEncryption; 23 | import org.app.windows.dependencies.managers.WinManagerPrimality; 24 | 25 | import com.formdev.flatlaf.FlatLightLaf; 26 | 27 | 28 | /** 29 | * @author Vittorio Piotti 30 | * @version 1.0 31 | * @since 16-10-2023 32 | * Classe principale per la gestione delle finestre dell'applicazione, che include la gestione delle finestre di test di primalità e di cifratura RSA. 33 | * 34 | * Questa classe coordina le finestre di test di primalità e di cifratura RSA attraverso i rispettivi gestori e gestisce le interazioni tra di esse. 35 | */ 36 | public class WinManager { 37 | 38 | 39 | 40 | /** 41 | * Gestore per le finestre e le funzionalità relative ai test di primalità. 42 | * 43 | * Questo attributo è utilizzato per accedere e gestire la finestra e le operazioni associate al test di primalità. 44 | */ 45 | private WinManagerPrimality winManagerPrimality; 46 | 47 | /** 48 | * Gestore per le finestre e le funzionalità relative alla cifratura RSA. 49 | * 50 | * Questo attributo è utilizzato per accedere e gestire la finestra e le operazioni associate alla cifratura RSA. 51 | */ 52 | private WinManagerEncryption winManagerEncryption; 53 | 54 | 55 | /** 56 | * Finestra principale dell'applicazione che gestisce la visualizzazione e l'interazione tra le finestre di test di primalità e cifratura RSA. 57 | * 58 | * Questo attributo rappresenta la finestra principale che ospita le finestre di test di primalità e cifratura RSA, e gestisce la loro disposizione e visibilità. 59 | */ 60 | private WinHome windowHome; 61 | 62 | 63 | 64 | 65 | /** 66 | * Fornisce un'istanza di {@link JFrame} della finestra principale dell'applicazione. 67 | * 68 | * Questo attributo è una funzione che restituisce la finestra principale dell'applicazione {@code JFrame}. 69 | * È utilizzato per ottenere una referenza alla finestra principale quando è necessario aggiornare o interagire con essa, 70 | * come nel caso di apertura di nuove finestre di errore o salvataggio. Viene utilizzato dai gestori di finestre secondarie 71 | * per avere accesso alla finestra principale per la gestione dell'interfaccia utente e delle operazioni correlate. 72 | */ 73 | private final Supplier getFrameWindowHome = () -> windowHome.getFrame(); 74 | 75 | 76 | /** 77 | * Costruttore della classe {@code WinManager}. 78 | * 79 | * @param startCalcPrimality Runnable per avviare il calcolo dei numeri primi. 80 | * @param stopCalcPrimality Runnable per fermare il calcolo dei numeri primi. 81 | * @param startSavingPrimality Runnable per avviare il salvataggio dei numeri primi. 82 | * @param startCalcEncryption Runnable per avviare il calcolo della cifratura. 83 | * @param initAndCheckReadingFile Runnable per inizializzare e controllare il file di lettura. 84 | * @param checkFileOnchange Runnable per controllare le modifiche al file. 85 | */ 86 | public WinManager(Runnable startCalcPrimality,Runnable stopCalcPrimality,Runnable startSavingPrimality,Runnable startCalcEncryption,Runnable initAndCheckReadingFile,Runnable checkFileOnchange){ 87 | try { 88 | UIManager.setLookAndFeel(new FlatLightLaf()); 89 | } catch (UnsupportedLookAndFeelException e) { 90 | e.printStackTrace(); 91 | } 92 | winManagerPrimality = new WinManagerPrimality(getFrameWindowHome,stopCalcPrimality,startSavingPrimality,startCalcPrimality); 93 | winManagerEncryption = new WinManagerEncryption(getFrameWindowHome,startCalcEncryption,initAndCheckReadingFile,checkFileOnchange); 94 | 95 | 96 | 97 | 98 | 99 | windowHome = new WinHome(winManagerPrimality.getWindow(),winManagerEncryption.getWindow(),resizeFromWidth,winManagerPrimality.switchWindow); 100 | 101 | 102 | 103 | windowHome.setVisible(); 104 | 105 | } 106 | 107 | /** 108 | * Runnable per ridimensionare la finestra in base alla larghezza. 109 | */ 110 | private final Runnable resizeFromWidth = () -> { 111 | 112 | if (windowHome != null){ 113 | boolean selectedWindow = windowHome.getSelectedWindow(); 114 | int frameWidth = windowHome.getFrameWidth(); 115 | if (frameWidth < 965) { 116 | if(selectedWindow == true){ 117 | winManagerPrimality.setGridPanel(2,1); 118 | }else { 119 | winManagerEncryption.setGridPanel(2, 1); 120 | } 121 | } else { 122 | if(selectedWindow == true){ 123 | winManagerPrimality.setGridPanel(1,2); 124 | }else { 125 | winManagerEncryption.setGridPanel(1,2); 126 | } 127 | } 128 | } 129 | }; 130 | 131 | 132 | 133 | /** 134 | * Restituisce il valore massimo per i numeri primi. 135 | * 136 | * @return Il valore massimo come {@code int}. 137 | */ 138 | public int getValMax(){ 139 | return winManagerPrimality.getValMax(); 140 | } 141 | 142 | /** 143 | * Restituisce il valore minimo per i numeri primi. 144 | * 145 | * @return Il valore minimo come {@code int}. 146 | */ 147 | public int getValMin(){ 148 | return winManagerPrimality.getValMin(); 149 | } 150 | 151 | /** 152 | * Restituisce l'esponente massimo per i numeri primi. 153 | * 154 | * @return L'esponente massimo come {@code int}. 155 | */ 156 | public int getExpMax(){ 157 | return winManagerPrimality.getExpMax(); 158 | } 159 | 160 | /** 161 | * Restituisce l'esponente minimo per i numeri primi. 162 | * 163 | * @return L'esponente minimo come {@code int}. 164 | */ 165 | public int getExpMin(){ 166 | return winManagerPrimality.getExpMax(); 167 | } 168 | 169 | /** 170 | * Restituisce il valore minimo come stringa. 171 | * 172 | * @return Il valore minimo come {@code String}. 173 | */ 174 | public String getMin(){ 175 | return winManagerPrimality.getMin(); 176 | } 177 | 178 | /** 179 | * Restituisce il valore massimo come stringa. 180 | * 181 | * @return Il valore massimo come {@code String}. 182 | */ 183 | public String getMax(){ 184 | return winManagerPrimality.getMax(); 185 | } 186 | 187 | /** 188 | * Restituisce il metodo di calcolo selezionato. 189 | * 190 | * @return Il metodo come {@code int}. 191 | */ 192 | public int getMetodo(){ 193 | return winManagerPrimality.getMetodo(); 194 | } 195 | 196 | /** 197 | * Restituisce una rappresentazione del metodo di calcolo come stringa. 198 | * 199 | * @return Il metodo come {@code String}. 200 | */ 201 | public String toStringMetodo(){ 202 | return winManagerPrimality.toStringMetodo(); 203 | } 204 | 205 | /** 206 | * Incrementa la barra di progresso nella finestra di test di primalità. 207 | */ 208 | public boolean existWindowSaveInFile(){ 209 | return winManagerPrimality.existWindowSaveInFile(); 210 | } 211 | 212 | /** 213 | * Incrementa il conteggio dei numeri primi calcolati nella finestra di test di primalità. 214 | */ 215 | public void incrementProgressBar(){ 216 | winManagerPrimality.incrementProgressBar(); 217 | } 218 | 219 | /** 220 | * Aggiunge un numero primo calcolato alla finestra di test di primalità. 221 | * 222 | * @param result Il numero primo calcolato come {@code String}. 223 | */ 224 | public void incrementCalculatedPrimeNumbers(){ 225 | winManagerPrimality.incrementCalculatedPrimeNumbers(); 226 | } 227 | 228 | /** 229 | * Verifica se esiste una finestra di salvataggio dei numeri primi. Se non esiste, viene aperta. 230 | * 231 | * @return {@code true} se la finestra di salvataggio esiste, {@code false} altrimenti. 232 | */ 233 | public void appendCalculatedNumber(String result){ 234 | winManagerPrimality.appendCalculatedNumber(result); 235 | } 236 | 237 | /** 238 | * Restituisce il percorso del file di salvataggio. 239 | * 240 | * @return Il percorso del file come {@code String}. 241 | */ 242 | public String getPath(){ 243 | return winManagerPrimality.getPath(); 244 | } 245 | 246 | /** 247 | * Restituisce il percorso del file di lettura per la cifratura RSA. 248 | * 249 | * @return Il percorso del file di lettura come {@code String}. 250 | */ 251 | public String getPathReading(){ 252 | return winManagerEncryption.getPathReading(); 253 | } 254 | 255 | /** 256 | * Imposta lo stato di errore del file nella finestra di cifratura RSA. 257 | * 258 | * @param state {@code true} se c'è un errore nel file, {@code false} altrimenti. 259 | */ 260 | public void setFileErrorType(boolean state){ 261 | winManagerEncryption.setFileErrorType(state); 262 | } 263 | 264 | /** 265 | * Restituisce il metodo di cifratura selezionato. 266 | * 267 | * @return Il metodo di cifratura come {@code int}. 268 | */ 269 | public int getEncryptionMetodo(){ 270 | return winManagerEncryption.getEncryptionMetodo(); 271 | } 272 | 273 | /** 274 | * Imposta i risultati della cifratura nella finestra di output della cifratura RSA. 275 | * 276 | * @param results I risultati della cifratura come {@code String}. 277 | */ 278 | public void setResultsEncryption(String results){ 279 | winManagerEncryption.setResultsEncryption(results); 280 | } 281 | 282 | /** 283 | * Restituisce lo stato della scelta dell'inverso modulare nella finestra di cifratura RSA. 284 | * 285 | * @return {@code true} se è selezionato l'inverso modulare, {@code false} altrimenti. 286 | */ 287 | public boolean getModInverse(){ 288 | return winManagerEncryption.getModInverse(); 289 | } 290 | 291 | /** 292 | * Apre la finestra di errore dell'output della cifratura RSA. 293 | */ 294 | public void openWindowErrorOutput(){ 295 | winManagerEncryption.openWindowErrorOutputEncryption.run(); 296 | } 297 | 298 | /** 299 | * Restituisce il messaggio da cifrare nella finestra di cifratura RSA. 300 | * 301 | * @return Il messaggio come {@code String}. 302 | */ 303 | public String getMessage(){ 304 | return winManagerEncryption.getMessage(); 305 | } 306 | 307 | 308 | } 309 | 310 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/WinHome.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components; 14 | 15 | import java.awt.BorderLayout; 16 | import java.awt.Color; 17 | import java.awt.Dimension; 18 | import java.awt.FlowLayout; 19 | import java.awt.Font; 20 | import java.awt.Frame; 21 | import java.awt.GridBagConstraints; 22 | import java.awt.GridBagLayout; 23 | import java.awt.event.ActionEvent; 24 | import java.awt.event.ActionListener; 25 | import java.awt.event.ComponentAdapter; 26 | import java.awt.event.ComponentEvent; 27 | import java.awt.event.WindowAdapter; 28 | import java.awt.event.WindowEvent; 29 | 30 | import javax.swing.BorderFactory; 31 | import javax.swing.BoxLayout; 32 | import javax.swing.JButton; 33 | import javax.swing.JFrame; 34 | import javax.swing.JLabel; 35 | import javax.swing.JPanel; 36 | import javax.swing.Timer; 37 | import javax.swing.border.CompoundBorder; 38 | 39 | 40 | /** 41 | * La classe `WinHome` rappresenta la finestra principale dell'applicazione che permette all'utente di 42 | * selezionare tra due moduli: uno per il test di primalità e l'altro per la crittografia RSA. 43 | * 44 | * La finestra include un'intestazione, una sezione di navigazione con pulsanti, e un piè di pagina. 45 | * I pulsanti nella sezione di navigazione permettono di passare tra le due visualizzazioni principali. 46 | * @author Vittorio Piotti 47 | * @version 1.0 48 | * @since 16-10-2023 49 | */ 50 | public class WinHome { 51 | 52 | /** 53 | * La finestra principale dell'applicazione. 54 | */ 55 | private final JFrame frame = new JFrame("Test Primalità"); 56 | 57 | /** 58 | * Il pannello principale che utilizza un layout BorderLayout. 59 | */ 60 | private final JPanel mainPanel = new JPanel(new BorderLayout()); 61 | 62 | /** 63 | * Il pannello dell'intestazione della finestra. 64 | */ 65 | private final JPanel header = new JPanel(new FlowLayout(FlowLayout.LEFT)); 66 | 67 | /** 68 | * L'etichetta che mostra il titolo nella parte superiore della finestra. 69 | */ 70 | private final JLabel labelHeader = new JLabel("Ricerca Numeri Primi"); 71 | 72 | /** 73 | * Il pannello del piè di pagina della finestra. 74 | */ 75 | private final JPanel footer = new JPanel(new GridBagLayout()); 76 | 77 | /** 78 | * L'etichetta che mostra il testo del piè di pagina. 79 | */ 80 | private final JLabel labelFooter = new JLabel("©VP - Sistemi e Reti - Test Primalità & Crittografia RSA"); 81 | 82 | /** 83 | * Il pannello di navigazione per i pulsanti di selezione. 84 | */ 85 | private final JPanel navPanel = new JPanel(); 86 | 87 | /** 88 | * Il pannello che contiene l'intestazione. 89 | */ 90 | private final JPanel containerLabelHeader = new JPanel(new FlowLayout(FlowLayout.LEFT)); 91 | 92 | /** 93 | * Un pannello separatore utilizzato nella sezione di navigazione. 94 | */ 95 | private final JPanel separator = new JPanel(); 96 | 97 | /** 98 | * Il pulsante per il test di primalità. 99 | */ 100 | private final JButton buttonPrimalityTest = new JButton("Test Primalità"); 101 | 102 | /** 103 | * Il pulsante per la crittografia RSA. 104 | */ 105 | private final JButton buttonEncryptionRsa = new JButton("Crittografia RSA"); 106 | 107 | 108 | /** 109 | * Il pannello per la visualizzazione del test di primalità. 110 | */ 111 | private JPanel windowPrimalityTest; 112 | 113 | /** 114 | * Il pannello per la visualizzazione della crittografia RSA. 115 | */ 116 | private JPanel windowEncryption; 117 | 118 | /** 119 | * Indica quale finestra è attualmente selezionata. 120 | */ 121 | private boolean selectedWindow = false; 122 | 123 | /** 124 | * Runnable per ridimensionare la finestra in base alla larghezza. 125 | */ 126 | private Runnable resizeFromWidth; 127 | 128 | /** 129 | * Runnable per cambiare la finestra visualizzata. 130 | */ 131 | private Runnable switchWindow; 132 | 133 | 134 | /** 135 | * Restituisce lo stato della finestra attualmente selezionata. 136 | * 137 | * @return true se la finestra di test di primalità è selezionata, false se la finestra di crittografia RSA è selezionata. 138 | */ 139 | public boolean getSelectedWindow(){ 140 | return selectedWindow; 141 | } 142 | 143 | /** 144 | * Inizializza le impostazioni dei pulsanti. 145 | * 146 | * @param button Il pulsante da inizializzare. 147 | */ 148 | private void initButton(JButton button){ 149 | button.setPreferredSize(new Dimension(200, 35)); 150 | button.setOpaque(true); 151 | button.setContentAreaFilled(true); 152 | button.setBorderPainted(false); 153 | button.setFocusPainted(false); 154 | button.setBackground(new Color(237,236,237)); 155 | button.setForeground(Color.BLACK); 156 | Font currentFont = button.getFont(); 157 | button.setFont(new Font(currentFont.getName(), Font.PLAIN, 17)); 158 | } 159 | 160 | 161 | /** 162 | * Attiva un pulsante e disattiva l'altro, cambiando il colore e il font per riflettere lo stato attivo. 163 | * 164 | * @param activeButton Il pulsante da attivare. 165 | * @param disactiveButton Il pulsante da disattivare. 166 | * @param currentWindow true se la finestra di test di primalità è selezionata, false se la finestra di crittografia RSA è selezionata. 167 | */ 168 | private void activeButton(JButton activeButton, JButton disactiveButton, boolean currentWindow){ 169 | if(selectedWindow != currentWindow){ 170 | 171 | Font currentFont; 172 | activeButton.setBackground(Color.GRAY); 173 | activeButton.setForeground(Color.WHITE); 174 | currentFont = activeButton.getFont(); 175 | activeButton.setFont(new Font(currentFont.getName(), Font.PLAIN, 17)); 176 | 177 | disactiveButton.setBackground(new Color(237,236,237)); 178 | disactiveButton.setForeground(Color.BLACK); 179 | currentFont = disactiveButton.getFont(); 180 | disactiveButton.setFont(new Font(currentFont.getName(), Font.PLAIN, 17)); 181 | selectedWindow = !selectedWindow; 182 | 183 | if (selectedWindow == false){ 184 | switchWindow.run(); 185 | 186 | mainPanel.add(windowEncryption); 187 | mainPanel.remove(windowPrimalityTest); 188 | 189 | labelHeader.setText("Crittografia RSA"); 190 | 191 | 192 | } else { 193 | mainPanel.add(windowPrimalityTest); 194 | mainPanel.remove(windowEncryption); 195 | 196 | labelHeader.setText("Ricerca Numeri Primi"); 197 | 198 | } 199 | mainPanel.revalidate(); 200 | mainPanel.repaint(); 201 | this.resizeFromWidth.run(); 202 | 203 | } 204 | 205 | } 206 | 207 | 208 | 209 | /** 210 | * Costruisce una nuova istanza della finestra principale. 211 | * 212 | * @param windowPrimalityTest Il pannello per il test di primalità. 213 | * @param windowEncryption Il pannello per la crittografia RSA. 214 | * @param resizeFromWidth Runnable per ridimensionare la finestra in base alla larghezza. 215 | * @param switchWindow Runnable per cambiare la finestra visualizzata. 216 | */ 217 | public WinHome(JPanel windowPrimalityTest,JPanel windowEncryption,Runnable resizeFromWidth,Runnable switchWindow) { 218 | this.windowPrimalityTest = windowPrimalityTest; 219 | this.resizeFromWidth = resizeFromWidth; 220 | this.windowEncryption = windowEncryption; 221 | this.switchWindow = switchWindow; 222 | frame.setSize(500, 614); 223 | frame.setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.X_AXIS)); 224 | frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 225 | frame.setLocationRelativeTo(null); 226 | if(!System.getProperty("os.name").toLowerCase().contains("windows") ){ 227 | frame.setMinimumSize(new Dimension(500, 614)); 228 | this.resizeFromWidth.run(); 229 | } 230 | 231 | 232 | labelFooter.setFont(new Font(labelFooter.getFont().getName(), Font.PLAIN, 15)); 233 | footer.add(labelFooter, new GridBagConstraints()); 234 | footer.setPreferredSize(new Dimension(1200, 40)); 235 | labelFooter.setForeground(Color.WHITE); 236 | footer.setBackground(new Color(70, 130, 180)); 237 | 238 | 239 | navPanel.setBackground(Color.WHITE); 240 | navPanel.setBorder(new CompoundBorder(navPanel.getBorder(), BorderFactory.createMatteBorder(0, 0, 2, 0, Color.BLACK))); 241 | navPanel.setLayout(new FlowLayout(FlowLayout.LEFT)); 242 | 243 | initButton(buttonPrimalityTest); 244 | initButton(buttonEncryptionRsa); 245 | activeButton(buttonPrimalityTest,buttonEncryptionRsa,true); 246 | 247 | buttonPrimalityTest.addActionListener(e -> { 248 | activeButton(buttonPrimalityTest,buttonEncryptionRsa,true); 249 | 250 | }); 251 | buttonEncryptionRsa.addActionListener(e -> { 252 | activeButton(buttonEncryptionRsa,buttonPrimalityTest,false); 253 | }); 254 | 255 | 256 | 257 | 258 | separator.setBackground(Color.BLACK); 259 | separator.setPreferredSize(new Dimension(2, 35)); 260 | 261 | navPanel.add(buttonPrimalityTest); 262 | navPanel.add(separator); 263 | navPanel.add(buttonEncryptionRsa); 264 | header.setLayout(new BoxLayout(header, BoxLayout.Y_AXIS)); 265 | header.add(navPanel); 266 | 267 | labelHeader.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 268 | 269 | labelHeader.setFont(new Font(labelHeader.getFont().getName(), Font.BOLD, 23)); 270 | 271 | containerLabelHeader.add(labelHeader); 272 | 273 | header.add(containerLabelHeader, new GridBagConstraints()); 274 | header.setPreferredSize(new Dimension(1200, 90)); 275 | frame.addComponentListener(new ComponentAdapter() { 276 | private Timer resizeTimer = new Timer(100, new ActionListener() { 277 | public void actionPerformed(ActionEvent e) { 278 | if (frame.getWidth() < 965) { 279 | if(frame.getWidth() < 500){ 280 | frame.setSize(500,frame.getHeight()); 281 | } 282 | if(frame.getHeight() < 614){ 283 | frame.setSize(frame.getWidth(),614); 284 | } 285 | }else{ 286 | if(frame.getHeight() < 361){ 287 | frame.setSize(frame.getWidth(),361); 288 | } 289 | } 290 | } 291 | }); 292 | @Override 293 | public void componentResized(ComponentEvent e) { 294 | resizeFromWidth.run(); 295 | if (!resizeTimer.isRunning()) { 296 | resizeTimer.start(); 297 | } else { 298 | resizeTimer.restart(); 299 | } 300 | } 301 | }); 302 | frame.addWindowStateListener(new WindowAdapter() { 303 | @Override 304 | public void windowStateChanged(WindowEvent e) { 305 | try { 306 | Thread.sleep(100); 307 | } catch (InterruptedException e1) { 308 | return; 309 | } 310 | int newState = e.getNewState(); 311 | if ((newState & Frame.MAXIMIZED_BOTH) == Frame.MAXIMIZED_BOTH) { 312 | resizeFromWidth.run(); 313 | } else { 314 | resizeFromWidth.run(); 315 | } 316 | } 317 | }); 318 | frame.add(mainPanel); 319 | mainPanel.add(footer, BorderLayout.SOUTH); 320 | mainPanel.add(windowPrimalityTest); 321 | 322 | mainPanel.add(header, BorderLayout.NORTH); 323 | frame.setVisible(true); 324 | } 325 | 326 | /** 327 | * Restituisce la larghezza attuale della finestra. 328 | * 329 | * @return La larghezza della finestra in pixel. 330 | */ 331 | public int getFrameWidth(){ 332 | return frame.getWidth(); 333 | } 334 | 335 | /** 336 | * Rende visibile la finestra principale e applica le modifiche di ridimensionamento. 337 | */ 338 | public void setVisible(){ 339 | resizeFromWidth.run(); 340 | frame.setVisible(true); 341 | } 342 | 343 | /** 344 | * Restituisce l'istanza della finestra principale. 345 | * 346 | * @return L'istanza della finestra principale. 347 | */ 348 | public JFrame getFrame(){ 349 | return frame; 350 | } 351 | 352 | } -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/encryption/WinEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.encryption; 14 | 15 | import java.awt.BorderLayout; 16 | import java.awt.Dimension; 17 | import java.awt.GridBagConstraints; 18 | import java.awt.GridBagLayout; 19 | import java.awt.GridLayout; 20 | 21 | import javax.swing.JPanel; 22 | 23 | 24 | /** 25 | * La classe WinEncryption gestisce la finestra principale dell'applicazione con un layout diviso in due pannelli: 26 | * uno per l'input e uno per l'output. 27 | * @author Vittorio Piotti 28 | * @version 1.0 29 | * @since 16-10-2023 30 | */ 31 | public class WinEncryption{ 32 | 33 | /** 34 | * Pannello principale che contiene i due pannelli input e output disposti con un layout a griglia. 35 | */ 36 | private final JPanel gridPanel = new JPanel(new GridLayout(1, 2)); 37 | 38 | /** 39 | * Pannello per l'input, che contiene altri componenti per inserire i dati. 40 | */ 41 | private final JPanel panelInput = new JPanel(); 42 | 43 | /** 44 | * Pannello per l'output, che contiene i risultati elaborati. 45 | */ 46 | private final JPanel panelOutput = new JPanel(); 47 | 48 | /** 49 | * Pannello principale che utilizza un BorderLayout per gestire la disposizione dei pannelli. 50 | */ 51 | private final JPanel mainPanel = new JPanel(new BorderLayout()); 52 | 53 | /** 54 | * Oggetto GridBagConstraints usato per posizionare i componenti all'interno dei pannelli centrati. 55 | */ 56 | private final GridBagConstraints gbc = new GridBagConstraints(); 57 | 58 | /** 59 | * Centra un pannello figlio all'interno del pannello genitore. 60 | * 61 | * @param parent Il pannello genitore in cui centrare il pannello figlio. 62 | * @param child Il pannello figlio da centrare. 63 | */ 64 | private void centerChildInParent(JPanel parent, JPanel child){ 65 | parent.setLayout(new GridBagLayout()); 66 | gbc.gridx = 0; 67 | gbc.gridy = 0; 68 | parent.add(child, gbc); 69 | } 70 | 71 | /** 72 | * Imposta il layout del pannello griglia con un numero specifico di righe e colonne. 73 | * 74 | * @param rows Numero di righe del layout a griglia. 75 | * @param cols Numero di colonne del layout a griglia. 76 | */ 77 | public void setGridPanel(int rows, int cols){ 78 | gridPanel.setLayout(new GridLayout(rows, cols)); 79 | 80 | } 81 | 82 | /** 83 | * Restituisce il pannello principale che rappresenta la finestra dell'applicazione. 84 | * 85 | * @return Un oggetto JPanel che rappresenta la finestra principale. 86 | */ 87 | public JPanel getWindow(){ 88 | return mainPanel; 89 | } 90 | 91 | /** 92 | * Costruttore della classe WinEncryption. 93 | * Inizializza i pannelli input e output, li centra e li aggiunge al pannello principale. 94 | * 95 | * @param panelInput Il pannello che contiene i componenti di input. 96 | * @param panelOutput Il pannello che contiene i componenti di output. 97 | */ 98 | public WinEncryption(JPanel panelInput,JPanel panelOutput) { 99 | panelOutput.setPreferredSize(new Dimension(476, 214)); 100 | panelInput.setPreferredSize(new Dimension(476, 214)); 101 | 102 | centerChildInParent(this.panelInput,panelInput); 103 | centerChildInParent(this.panelOutput,panelOutput); 104 | gridPanel.add(this.panelInput); 105 | gridPanel.add(this.panelOutput); 106 | mainPanel.add(gridPanel, BorderLayout.CENTER); 107 | 108 | } 109 | 110 | 111 | } -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/encryption/dialogs/WinErrorInEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.encryption.dialogs; 14 | 15 | 16 | import java.awt.BorderLayout; 17 | import java.awt.Color; 18 | import java.awt.Dimension; 19 | import java.awt.Font; 20 | import java.awt.GridBagConstraints; 21 | import java.awt.GridBagLayout; 22 | import java.awt.Insets; 23 | import java.awt.event.ActionEvent; 24 | import java.awt.event.ActionListener; 25 | 26 | import javax.swing.BorderFactory; 27 | import javax.swing.JButton; 28 | import javax.swing.JDialog; 29 | import javax.swing.JFrame; 30 | import javax.swing.JLabel; 31 | import javax.swing.JPanel; 32 | 33 | /** 34 | * Classe che rappresenta una finestra di dialogo per la visualizzazione di errori di inserimento durante la crittografia. 35 | * La finestra mostra un elenco di messaggi di errore e consente all'utente di chiudere la finestra con un pulsante. 36 | * @author Vittorio Piotti 37 | * @version 1.0 38 | * @since 16-10-2023 39 | */ 40 | public class WinErrorInEncryption { 41 | 42 | /** Finestra di dialogo per la visualizzazione degli errori. */ 43 | private final JDialog dialog = new JDialog(); 44 | 45 | /** Pannello principale della finestra di dialogo. */ 46 | private final JPanel mainPanel = new JPanel(new GridBagLayout()); 47 | 48 | /** Oggetto per la gestione della disposizione degli elementi nel pannello. */ 49 | private final GridBagConstraints gbc = new GridBagConstraints(); 50 | 51 | /** Etichetta principale che indica "Errore inserimento". */ 52 | private final JLabel label = new JLabel("Errore inserimento"); 53 | 54 | /** Pannello per la linea orizzontale di separazione. */ 55 | private final JPanel hr = new JPanel(new BorderLayout()); 56 | 57 | /** Pannello per la linea orizzontale più piccola di separazione. */ 58 | private final JPanel hr_small = new JPanel(new BorderLayout()); 59 | 60 | /** Pulsante per chiudere la finestra di dialogo. */ 61 | private final JButton closeButton = new JButton("Chiudi"); 62 | 63 | /** Array di etichette che rappresentano i messaggi di errore da visualizzare. */ 64 | private JLabel[] errorMessages; 65 | 66 | /** 67 | * Costruttore per creare e visualizzare una finestra di dialogo con i messaggi di errore. 68 | * 69 | * @param mainFrame Il frame principale a cui la finestra di dialogo è relativa. 70 | * @param errorMessages Un array di stringhe che rappresenta i messaggi di errore da visualizzare. 71 | */ 72 | public WinErrorInEncryption(JFrame mainFrame,String[] errorMessages){ 73 | dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); 74 | dialog.setResizable(false); 75 | gbc.insets = new Insets(10, 10, 10, 10); 76 | label.setHorizontalAlignment(JLabel.CENTER); 77 | label.setBorder(BorderFactory.createEmptyBorder(10, 20, 0, 20)); 78 | label.setFont(new Font(label.getFont().getFontName(), Font.BOLD, label.getFont().getSize())); 79 | gbc.gridy++; 80 | gbc.gridwidth = 0; 81 | gbc.anchor = GridBagConstraints.CENTER; 82 | mainPanel.add(label, gbc); 83 | gbc.gridy++; 84 | hr_small.setBackground(Color.BLACK); 85 | hr_small.setPreferredSize(new Dimension(15, 7)); 86 | mainPanel.add(hr_small, gbc); 87 | 88 | this.errorMessages = new JLabel[errorMessages.length]; 89 | for (int i = 0; i < errorMessages.length;i++) { 90 | this.errorMessages[i] = new JLabel(errorMessages[i]); 91 | gbc.gridy++; 92 | gbc.gridwidth = 0; 93 | gbc.anchor = GridBagConstraints.WEST; 94 | mainPanel.add(this.errorMessages[i], gbc); 95 | } 96 | 97 | hr.setBackground(Color.GRAY); 98 | hr.setPreferredSize(new Dimension(230, 1)); 99 | gbc.gridx = 0; 100 | gbc.gridwidth = 2; 101 | gbc.gridy++; 102 | gbc.anchor = GridBagConstraints.CENTER; 103 | mainPanel.add(hr, gbc); 104 | closeButton.addActionListener(new ActionListener() { 105 | public void actionPerformed(ActionEvent e) { 106 | dialog.dispose(); 107 | } 108 | }); 109 | gbc.gridx = 1; 110 | gbc.gridy++; 111 | gbc.gridwidth = 1; 112 | gbc.anchor = GridBagConstraints.EAST; 113 | mainPanel.add(closeButton, gbc); 114 | dialog.add(mainPanel); 115 | dialog.pack(); 116 | dialog.setLocationRelativeTo(mainFrame); 117 | dialog.setVisible(true); 118 | } 119 | 120 | /** 121 | * Chiude la finestra di dialogo. 122 | */ 123 | public void dispose(){ 124 | dialog.dispose(); 125 | } 126 | 127 | /** 128 | * Metodo placeholder per ottenere il tipo di errore. Attualmente restituisce null. 129 | * 130 | * @return Il tipo di errore, attualmente sempre null. 131 | */ 132 | public String getErrorType() { 133 | return null; 134 | } 135 | } 136 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/encryption/dialogs/WinErrorOutEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.encryption.dialogs; 14 | 15 | import java.awt.BorderLayout; 16 | import java.awt.FlowLayout; 17 | 18 | import javax.swing.Box; 19 | import javax.swing.Icon; 20 | import javax.swing.JButton; 21 | import javax.swing.JDialog; 22 | import javax.swing.JFrame; 23 | import javax.swing.JLabel; 24 | import javax.swing.JPanel; 25 | import javax.swing.UIManager; 26 | import javax.swing.border.EmptyBorder; 27 | 28 | /** 29 | * Classe che rappresenta una finestra di dialogo per visualizzare un messaggio di successo o errore 30 | * durante l'operazione di crittografia o decrittografia. La finestra può mostrare un'icona e un 31 | * messaggio personalizzati a seconda dello stato passato. 32 | * @author Vittorio Piotti 33 | * @version 1.0 34 | * @since 16-10-2023 35 | */ 36 | public class WinErrorOutEncryption { 37 | 38 | /** Finestra di dialogo per visualizzare l'errore o il successo. */ 39 | private final JDialog dialog = new JDialog(); 40 | 41 | /** Etichetta per mostrare l'icona (di errore o informazione). */ 42 | private final JLabel iconLabel = new JLabel(); 43 | 44 | /** Pannello per contenere il messaggio da visualizzare. */ 45 | private final JPanel messagePanel = new JPanel(); 46 | 47 | /** Etichetta per mostrare il messaggio principale. */ 48 | private final JLabel messageLabel = new JLabel(); 49 | 50 | /** Pannello per contenere il pulsante di chiusura. */ 51 | private final JPanel buttonPanel = new JPanel(); 52 | 53 | /** Pulsante per chiudere la finestra di dialogo. */ 54 | private final JButton button = new JButton("OK"); 55 | 56 | /** Icona di avviso (per segnalare un errore). */ 57 | private final Icon alertIcon = UIManager.getIcon("OptionPane.informationIcon"); 58 | 59 | /** Icona di errore (per segnalare un errore grave). */ 60 | private final Icon errorIcon = UIManager.getIcon("OptionPane.warningIcon"); 61 | 62 | /** 63 | * Costruttore per creare e visualizzare una finestra di dialogo con un messaggio di errore o successo. 64 | * 65 | * @param mainFrame Il frame principale a cui la finestra di dialogo è relativa. 66 | * @param state Se false, la finestra mostra un messaggio di errore; se true, mostra un messaggio di successo. 67 | */ 68 | public WinErrorOutEncryption(JFrame mainFrame,boolean state){ 69 | dialog.setTitle((state == false)?"Errore":"Successo"); 70 | dialog.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 71 | dialog.setSize(300, 180); 72 | dialog.setResizable(false); 73 | dialog.setLayout(new BorderLayout()); 74 | dialog.setLocationRelativeTo(mainFrame); 75 | iconLabel.setIcon((state == false)?errorIcon:alertIcon); 76 | iconLabel.setBorder(new EmptyBorder(20, 20, 0, 20)); 77 | dialog.add(iconLabel, BorderLayout.WEST); 78 | messagePanel.setBorder(new EmptyBorder(20, 0, 0,20)); 79 | messagePanel.setLayout(new BorderLayout()); 80 | messageLabel.setText((state == false)?"Formato file non valido":"File selezionato"); 81 | messagePanel.add(messageLabel, BorderLayout.CENTER); 82 | dialog.add(messagePanel, BorderLayout.CENTER); 83 | buttonPanel.setLayout(new FlowLayout(FlowLayout.RIGHT)); 84 | buttonPanel.setBorder(new EmptyBorder(0, 0, 20,20)); 85 | buttonPanel.add(Box.createVerticalGlue()); 86 | buttonPanel.add(button); 87 | buttonPanel.add(Box.createVerticalGlue()); 88 | dialog.add(buttonPanel, BorderLayout.SOUTH); 89 | button.addActionListener(e -> { 90 | dialog.dispose(); 91 | }); 92 | dialog.setVisible(true); 93 | } 94 | 95 | /** 96 | * Chiude la finestra di dialogo. 97 | */ 98 | public void dispose(){ 99 | dialog.dispose(); 100 | } 101 | 102 | } 103 | 104 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/encryption/panels/WinInEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.encryption.panels; 14 | 15 | import java.awt.BorderLayout; 16 | import java.awt.Color; 17 | import java.awt.Dimension; 18 | import java.awt.FlowLayout; 19 | import java.awt.Font; 20 | import java.awt.GridBagConstraints; 21 | import java.awt.GridBagLayout; 22 | import java.awt.Insets; 23 | import java.awt.event.ActionEvent; 24 | import java.awt.event.ActionListener; 25 | 26 | import javax.swing.BorderFactory; 27 | import javax.swing.JButton; 28 | import javax.swing.JComboBox; 29 | import javax.swing.JLabel; 30 | import javax.swing.JPanel; 31 | import javax.swing.JScrollPane; 32 | import javax.swing.JTextArea; 33 | import javax.swing.event.DocumentEvent; 34 | import javax.swing.event.DocumentListener; 35 | 36 | 37 | /** 38 | * Classe che rappresenta l'interfaccia grafica per la gestione dell'input e delle opzioni 39 | * per la crittografia e decrittografia RSA. La finestra include campi per selezionare il metodo, 40 | * caricare file, gestire l'opzione modInverse e mostrare i risultati. 41 | * @author Vittorio Piotti 42 | * @version 1.0 43 | * @since 16-10-2023 44 | */ 45 | public class WinInEncryption { 46 | 47 | /** Indice del metodo selezionato (0 = Crittografia, 1 = Decrittografia). */ 48 | private int sceltaMetodo = 0; 49 | 50 | /** Opzioni di metodi di crittografia e decrittografia disponibili. */ 51 | private final String[] metodi = { 52 | "Cripta messaggio con RSA", 53 | "Decripta messaggio con RSA", 54 | }; 55 | 56 | /** Etichette per i messaggi a seconda del metodo selezionato. */ 57 | private final String[] typeMessages = { 58 | "Messaggio
in chiaro:", 59 | "Messaggio
cifrato:" 60 | }; 61 | 62 | /** Etichette per l'opzione modInverse. */ 63 | private final String[] typeModInverse = { 64 | "On modInverse", 65 | "Off modInverse", 66 | }; 67 | 68 | /** Pannello principale per contenere tutti i componenti. */ 69 | private final JPanel panel = new JPanel(); 70 | 71 | /** Contenitore per la disposizione dei componenti nel pannello. */ 72 | private final JPanel panelContainer = new JPanel(); 73 | 74 | /** Etichetta del titolo della finestra. */ 75 | private final JLabel title = new JLabel("Input"); 76 | 77 | /** Etichetta per il metodo selezionato. */ 78 | private final JLabel labelMetodo = new JLabel("Metodo: "); 79 | 80 | /** Etichetta per il tipo di messaggio (chiaro o cifrato) visualizzato. */ 81 | private final JLabel labelMessage = new JLabel(typeMessages[0]); 82 | 83 | /** ComboBox per selezionare il metodo di crittografia o decrittografia. */ 84 | private final JComboBox < String > inputMetodo = new JComboBox <>(metodi); 85 | 86 | /** Constraints per la gestione del layout GridBag. */ 87 | private final GridBagConstraints gbc = new GridBagConstraints(); 88 | 89 | /** Pulsante per eseguire l'operazione selezionata. */ 90 | private final JButton buttonEsegui = new JButton("Esegui"); 91 | 92 | /** Pulsante per caricare un file di input. */ 93 | private final JButton buttonFile = new JButton("Carica file"); 94 | 95 | /** Pulsante per attivare o disattivare l'opzione modInverse. */ 96 | private final JButton buttonModInverse = new JButton(typeModInverse[0]); 97 | 98 | /** Etichetta che visualizza lo stato del file caricato. */ 99 | private final JLabel labelFile = new JLabel("Nessun file"); 100 | 101 | /** Pannello per separatori grafici nel layout. */ 102 | private final JPanel separator = new JPanel(); 103 | 104 | /** Contenitore per separatori grafici. */ 105 | private final JPanel containerSeparator = new JPanel(); 106 | 107 | /** Pannello per gestire l'opzione modInverse e il separatore. */ 108 | private final JPanel modInversePanel = new JPanel(new BorderLayout()); 109 | 110 | /** Etichetta per il separatore visivo. */ 111 | private final JLabel separatorLabel = new JLabel(" "); 112 | 113 | /** Area di testo per visualizzare i risultati. */ 114 | private final JTextArea results = new JTextArea(""); 115 | 116 | /** Pannello di scorrimento per l'area di testo dei risultati. */ 117 | private final JScrollPane scrollPaneResults = new JScrollPane(results); 118 | 119 | /** Contenitore per il pannello di scorrimento dei risultati. */ 120 | private final JPanel containerResults = new JPanel(); 121 | 122 | /** Stato attuale dell'opzione modInverse (true = attivo, false = disattivato). */ 123 | private boolean modInverse = true; 124 | 125 | /** Codice di errore per la gestione dello stato dell'input. */ 126 | private String errorType = "1"; 127 | 128 | 129 | /** 130 | * Costruttore della finestra di input per crittografia/decrittografia. 131 | * Configura i listener per i pulsanti e i componenti UI. 132 | * 133 | * @param openWindowErrorInput Runnable per aprire la finestra di errore in caso di input non valido. 134 | * @param openWindowReadingFile Runnable per aprire la finestra di lettura file. 135 | * @param checkFileOnchange Runnable per eseguire controlli sul file caricato quando cambia l'opzione modInverse. 136 | */ 137 | public WinInEncryption(Runnable openWindowErrorInput,Runnable openWindowReadingFile,Runnable checkFileOnchange) { 138 | setInputTextAreaListener(results); 139 | 140 | gbc.insets = new Insets(0, 0, 10, 0); 141 | inputMetodo.addActionListener(new ActionListener() { 142 | public void actionPerformed(ActionEvent e) { 143 | sceltaMetodo = inputMetodo.getSelectedIndex(); 144 | labelMessage.setText(typeMessages[sceltaMetodo]); 145 | 146 | } 147 | }); 148 | buttonEsegui.addActionListener(new ActionListener() { 149 | public void actionPerformed(ActionEvent e) { 150 | openWindowErrorInput.run(); 151 | 152 | } 153 | }); 154 | buttonFile.addActionListener(new ActionListener() { 155 | public void actionPerformed(ActionEvent e) { 156 | openWindowReadingFile.run(); 157 | } 158 | }); 159 | buttonModInverse.addActionListener(new ActionListener() { 160 | public void actionPerformed(ActionEvent e) { 161 | if(buttonModInverse.getText().equals(typeModInverse[0]) ){ 162 | buttonModInverse.setText(typeModInverse[1]); 163 | modInverse = false; 164 | }else { 165 | buttonModInverse.setText(typeModInverse[0]); 166 | modInverse = true; 167 | 168 | } 169 | checkFileOnchange.run(); 170 | } 171 | }); 172 | inputMetodo.addActionListener(new ActionListener() { 173 | public void actionPerformed(ActionEvent e) { 174 | sceltaMetodo = inputMetodo.getSelectedIndex(); 175 | } 176 | }); 177 | panel.setLayout(new FlowLayout(FlowLayout.LEFT)); 178 | panelContainer.setLayout(new GridBagLayout()); 179 | panelContainer.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 180 | title.setFont(new Font(title.getFont().getName(), Font.BOLD, 20)); 181 | gbc.anchor = GridBagConstraints.WEST; 182 | gbc.gridx = 0; 183 | gbc.gridy = 0; 184 | gbc.gridwidth = 4; 185 | panelContainer.add(title, gbc); 186 | gbc.gridy = 1; 187 | gbc.gridx = 0; 188 | gbc.gridwidth = 1; 189 | labelMetodo.setPreferredSize(new Dimension(100, 25)); 190 | labelMetodo.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 191 | labelMessage.setFont(new Font(labelMessage.getFont().getName(), Font.PLAIN, 13)); 192 | labelFile.setFont(new Font(labelFile.getFont().getName(), Font.PLAIN, 13)); 193 | 194 | inputMetodo.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 195 | buttonEsegui.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 196 | buttonFile.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 197 | buttonModInverse.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 198 | 199 | panelContainer.add(labelMetodo, gbc); 200 | gbc.gridx = 1; 201 | gbc.gridwidth = 4; 202 | gbc.anchor = GridBagConstraints.EAST; 203 | panelContainer.add(inputMetodo, gbc); 204 | gbc.anchor = GridBagConstraints.WEST; 205 | gbc.gridy = 2; 206 | gbc.gridx = 0; 207 | gbc.gridwidth = 1; 208 | panelContainer.add(labelMessage, gbc); 209 | 210 | gbc.gridy = 2; 211 | gbc.gridx = 1; 212 | gbc.gridwidth = 4; 213 | int width = 334; 214 | int height = 90; 215 | if(System.getProperty("os.name").toLowerCase().contains("windows")){ 216 | width = 300; 217 | height = 80; 218 | } 219 | scrollPaneResults.setPreferredSize(new Dimension(width, height)); 220 | containerResults.add(scrollPaneResults); 221 | panelContainer.add(containerResults, gbc); 222 | 223 | gbc.gridy = 4; 224 | gbc.anchor = GridBagConstraints.WEST; 225 | gbc.gridx = 0; 226 | gbc.gridwidth = 1; 227 | 228 | panelContainer.add(buttonEsegui,gbc); 229 | 230 | 231 | modInversePanel.add(buttonModInverse, BorderLayout.CENTER); 232 | 233 | 234 | int widthSeparator = 5; 235 | if(System.getProperty("os.name").toLowerCase().contains("windows")){ 236 | widthSeparator = 10; 237 | 238 | } 239 | separatorLabel.setPreferredSize(new Dimension(widthSeparator, 1)); 240 | 241 | modInversePanel.add(separatorLabel, BorderLayout.EAST); 242 | 243 | gbc.gridx = 1; 244 | panelContainer.add(modInversePanel, gbc); 245 | 246 | gbc.gridx = 2; 247 | 248 | panelContainer.add(buttonFile,gbc); 249 | 250 | gbc.gridx = 3; 251 | 252 | int heightSeparator = 20; 253 | if(System.getProperty("os.name").toLowerCase().contains("windows")){ 254 | heightSeparator = 25; 255 | } 256 | containerSeparator.setPreferredSize(new Dimension(20, heightSeparator )); 257 | separator.setBackground(Color.GRAY); 258 | separator.setPreferredSize(new Dimension(2, heightSeparator)); 259 | containerSeparator.add(separator); 260 | 261 | panelContainer.add(containerSeparator,gbc); 262 | gbc.gridx = 4; 263 | 264 | panelContainer.add(labelFile,gbc); 265 | 266 | 267 | 268 | panel.add(panelContainer); 269 | } 270 | 271 | /** 272 | * Restituisce il pannello principale della finestra. 273 | * 274 | * @return Il pannello principale che contiene l'interfaccia grafica. 275 | */ 276 | public JPanel getWindow() { 277 | return panel; 278 | } 279 | 280 | /** 281 | * Restituisce lo stato dell'opzione modInverse. 282 | * 283 | * @return true se modInverse è attivo, false altrimenti. 284 | */ 285 | public boolean getModInverse(){ 286 | return modInverse; 287 | } 288 | 289 | 290 | /** 291 | * Imposta il contenuto del campo numerico aggiungendo zeri. 292 | * 293 | * @param val Il valore numerico iniziale. 294 | * @param exp Il numero di zeri da aggiungere. 295 | * @return La stringa risultante con il valore numerico e gli zeri aggiunti. 296 | */ 297 | public String setNum(String val,String exp){ 298 | String num = ""; 299 | num += val; 300 | for(int i = 0; i< Integer.parseInt(exp); i ++){ 301 | num += "0"; 302 | } 303 | return num; 304 | } 305 | 306 | 307 | /** 308 | * Restituisce l'indice del metodo selezionato. 309 | * 310 | * @return L'indice del metodo selezionato (0 = Crittografia, 1 = Decrittografia). 311 | */ 312 | public int getMetodo(){ 313 | return sceltaMetodo; 314 | } 315 | 316 | /** 317 | * Restituisce il nome del metodo selezionato. 318 | * 319 | * @return Una stringa che rappresenta il metodo selezionato. 320 | */ 321 | public String toStringMetodo(){ 322 | return metodi[sceltaMetodo]; 323 | } 324 | 325 | /** 326 | * Imposta un listener per l'area di testo e aggiorna il codice di errore in base al contenuto. 327 | * 328 | * @param textArea L'area di testo da monitorare. 329 | */ 330 | private void setInputTextAreaListener(JTextArea textArea) { 331 | textArea.getDocument().addDocumentListener(new DocumentListener() { 332 | @Override 333 | public void insertUpdate(DocumentEvent e) { 334 | handleTextChange(textArea.getText()); 335 | } 336 | 337 | @Override 338 | public void removeUpdate(DocumentEvent e) { 339 | handleTextChange(textArea.getText()); 340 | } 341 | 342 | @Override 343 | public void changedUpdate(DocumentEvent e) { 344 | // Non applicabile ai componenti JTextArea 345 | } 346 | 347 | private void handleTextChange(String text) { 348 | if (text.isEmpty()) { 349 | errorType = "1"; // Testo vuoto 350 | } else { 351 | errorType = "0"; // Testo non vuoto 352 | } 353 | } 354 | }); 355 | } 356 | /** 357 | * Aggiorna l'etichetta dello stato del file in base al parametro passato. 358 | * 359 | * @param state Se true, imposta l'etichetta su "File caricato", altrimenti "Nessun file". 360 | */ 361 | public void setLabelFile(boolean state){ 362 | labelFile.setText((state == false)?"Nessun file":"File caricato"); 363 | 364 | } 365 | /** 366 | * Restituisce il codice di errore associato all'input corrente. 367 | * 368 | * @return Una stringa che rappresenta il tipo di errore: 369 | * "1" se il campo di testo è vuoto (errore), 370 | * "0" se è presente del testo valido (nessun errore). 371 | */ 372 | public String getErrorType(){ 373 | return errorType; 374 | } 375 | 376 | /** 377 | * Restituisce il contenuto dell'area di testo (messaggio di input). 378 | * 379 | * @return Una stringa contenente il messaggio digitato dall'utente. 380 | */ 381 | public String getMessage(){ 382 | return results.getText(); 383 | } 384 | } -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/encryption/panels/WinOutEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.encryption.panels; 14 | 15 | import java.awt.Dimension; 16 | import java.awt.FlowLayout; 17 | import java.awt.Font; 18 | import java.awt.GridBagConstraints; 19 | import java.awt.GridBagLayout; 20 | import java.awt.Insets; 21 | import java.awt.Toolkit; 22 | import java.awt.datatransfer.Clipboard; 23 | import java.awt.datatransfer.StringSelection; 24 | 25 | import javax.swing.BorderFactory; 26 | import javax.swing.JButton; 27 | import javax.swing.JLabel; 28 | import javax.swing.JPanel; 29 | import javax.swing.JScrollPane; 30 | import javax.swing.JTextArea; 31 | 32 | 33 | /** 34 | * Classe che rappresenta la finestra di output per la cifratura/decifratura. 35 | * Consente di visualizzare i risultati del processo e di copiarli negli appunti. 36 | * @author Vittorio Piotti 37 | * @version 1.0 38 | * @since 16-10-2023 39 | */ 40 | public class WinOutEncryption { 41 | 42 | /** 43 | * Il pannello principale della finestra di output. 44 | */ 45 | private final JPanel panel = new JPanel(); 46 | 47 | /** 48 | * Il pannello contenitore che organizza i componenti della finestra di output. 49 | */ 50 | private final JPanel panelContainer = new JPanel(); 51 | 52 | /** 53 | * Il pannello contenitore predefinito per la finestra di output. 54 | */ 55 | private final JPanel panelContainerDefault = new JPanel(); 56 | 57 | /** 58 | * L'etichetta del titolo principale della finestra di output. 59 | */ 60 | private final JLabel title = new JLabel("Output"); 61 | 62 | /** 63 | * L'etichetta del titolo predefinito della finestra di output. 64 | */ 65 | private final JLabel titleDef = new JLabel("Output"); 66 | 67 | /** 68 | * Il pulsante per copiare tutto il testo dei risultati negli appunti. 69 | */ 70 | private final JButton buttonCopy = new JButton("Copia tutto"); 71 | 72 | /** 73 | * Array di stringhe che contiene i messaggi descrittivi per il tipo di output. 74 | * Usato per cambiare dinamicamente l'etichetta in base al metodo selezionato. 75 | */ 76 | private final String[] typeMessages = { 77 | "Messaggio
cifrato:", 78 | "Messaggio
in chiaro:", 79 | }; 80 | 81 | /** 82 | * L'etichetta che descrive il tipo di messaggio visualizzato (cifrato o in chiaro). 83 | */ 84 | private final JLabel labelMessage = new JLabel(typeMessages[0]); 85 | 86 | /** 87 | * Etichetta che visualizza un messaggio predefinito quando non sono presenti risultati. 88 | */ 89 | private final JLabel advertiseOutput = new JLabel("I risultati saranno visualizzati qui"); 90 | 91 | /** 92 | * Area di testo per visualizzare i risultati dell'operazione di cifratura o decifratura. 93 | */ 94 | private final JTextArea results = new JTextArea(""); 95 | 96 | /** 97 | * Scroll pane per l'area di testo dei risultati. 98 | */ 99 | private final JScrollPane scrollPaneResults = new JScrollPane(results); 100 | 101 | /** 102 | * Pannello che contiene l'area di testo dei risultati. 103 | */ 104 | private final JPanel containerResults = new JPanel(); 105 | 106 | /** 107 | * Codice che rappresenta lo stato di errore dell'output. 108 | * Valore predefinito "1" indica che non ci sono risultati visibili. 109 | */ 110 | private String errorType = "1"; 111 | 112 | /** 113 | * Oggetto GridBagConstraints per gestire il layout dei componenti nel pannello. 114 | */ 115 | private final GridBagConstraints gbc = new GridBagConstraints(); 116 | 117 | /** 118 | * Oggetto GridBagConstraints per gestire il layout dei componenti nel pannello predefinito. 119 | */ 120 | private final GridBagConstraints gbcDef = new GridBagConstraints(); 121 | 122 | 123 | /** 124 | * Costruttore della classe WinOutEncryption. 125 | * Inizializza la finestra con il layout predefinito e configura i componenti dell'interfaccia. 126 | * Gestisce l'azione del pulsante di copia e prepara il layout per la visualizzazione dei risultati. 127 | */ 128 | public WinOutEncryption() { 129 | 130 | gbc.insets = new Insets(0, 0, 10, 0); 131 | 132 | results.setEditable(false); 133 | 134 | panel.setLayout(new FlowLayout(FlowLayout.LEFT)); 135 | panelContainer.setLayout(new GridBagLayout()); 136 | panelContainer.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 137 | title.setFont(new Font(title.getFont().getName(), Font.BOLD, 20)); 138 | gbc.anchor = GridBagConstraints.WEST; 139 | gbc.gridx = 0; 140 | gbc.gridy = 0; 141 | gbc.gridwidth = 4; 142 | panelContainer.add(title, gbc); 143 | gbc.gridy = 1; 144 | gbc.gridx = 0; 145 | gbc.gridwidth = 1; 146 | 147 | labelMessage.setFont(new Font(labelMessage.getFont().getName(), Font.PLAIN, 13)); 148 | 149 | buttonCopy.setFont(new Font(buttonCopy.getFont().getName(), Font.PLAIN, 13)); 150 | labelMessage.setPreferredSize(new Dimension(100, 30)); 151 | 152 | buttonCopy.addActionListener(e -> { 153 | String copiedText = results.getText(); 154 | Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); 155 | StringSelection stringSelection = new StringSelection(copiedText); 156 | clipboard.setContents(stringSelection, null); 157 | }); 158 | gbc.anchor = GridBagConstraints.WEST; 159 | gbc.gridy = 2; 160 | gbc.gridx = 0; 161 | gbc.gridwidth = 1; 162 | panelContainer.add(labelMessage, gbc); 163 | gbc.gridy = 2; 164 | gbc.gridx = 1; 165 | gbc.gridwidth = 3; 166 | int width = 334; 167 | int height = 90; 168 | if(System.getProperty("os.name").toLowerCase().contains("windows")){ 169 | width = 300; 170 | height = 80; 171 | } 172 | scrollPaneResults.setPreferredSize(new Dimension(width, height)); 173 | containerResults.add(scrollPaneResults); 174 | panelContainer.add(containerResults, gbc); 175 | gbc.anchor = GridBagConstraints.EAST; 176 | gbc.gridy = 3; 177 | gbc.gridx = 3; 178 | gbc.gridwidth = 3; 179 | panelContainer.add(buttonCopy, gbc); 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | panelContainerDefault.setLayout(new GridBagLayout()); 188 | panelContainerDefault.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 189 | gbcDef.anchor = GridBagConstraints.WEST; 190 | gbcDef.gridx = 0; 191 | gbcDef.gridy = 0; 192 | panelContainerDefault.add(titleDef,gbcDef); 193 | titleDef.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0)); 194 | titleDef.setFont(new Font( titleDef.getFont().getName(), Font.BOLD, 20)); 195 | gbcDef.gridy = 1; 196 | panelContainerDefault.add(advertiseOutput,gbcDef); 197 | panel.add(panelContainerDefault); 198 | } 199 | 200 | /** 201 | * Inizializza la finestra di output con l'interfaccia specifica per il metodo selezionato. 202 | * 203 | * @param metodo L'indice del metodo selezionato, dove 0 corrisponde alla cifratura 204 | * e 1 alla decifratura. Questo indice determina il messaggio visualizzato. 205 | */ 206 | public void initWindow(int metodo){ 207 | panel.removeAll(); 208 | panel.add(panelContainer); 209 | panel.revalidate(); 210 | panel.repaint(); 211 | labelMessage.setText(typeMessages[metodo]); 212 | 213 | } 214 | 215 | /** 216 | * Restituisce il pannello principale della finestra, contenente tutti i componenti. 217 | * 218 | * @return Un oggetto JPanel rappresentante la finestra principale. 219 | */ 220 | public JPanel getWindow() { 221 | return panel; 222 | } 223 | 224 | 225 | 226 | /** 227 | * Imposta il testo nei risultati di output. 228 | * 229 | * @param results Una stringa che contiene il testo da visualizzare nei risultati. 230 | */ 231 | public void setResults(String results){ 232 | this.results.setText(results); 233 | } 234 | 235 | 236 | 237 | /** 238 | * Restituisce il codice di errore associato all'output corrente. 239 | * 240 | * @return Una stringa rappresentante il tipo di errore: 241 | * "1" se non ci sono risultati visibili (stato iniziale), 242 | * "0" se i risultati sono presenti. 243 | */ 244 | public String getErrorType(){ 245 | return errorType; 246 | } 247 | 248 | } -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/encryption/panels/WinSaveEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.encryption.panels; 14 | 15 | import java.awt.FileDialog; 16 | 17 | import javax.swing.JDialog; 18 | 19 | 20 | /** 21 | * La classe WinSaveEncryption gestisce una finestra di dialogo per salvare file, con funzionalità 22 | * aggiuntive per rilevare eventuali errori e richiamare una finestra di avviso in caso di problemi. 23 | * @author Vittorio Piotti 24 | * @version 1.0 25 | * @since 16-10-2023 26 | */ 27 | public class WinSaveEncryption { 28 | 29 | /** 30 | * Dialog per visualizzare la finestra di selezione file. 31 | */ 32 | private final JDialog dialog = new JDialog(); 33 | 34 | /** 35 | * Finestra di dialogo nativa per l'apertura di file. 36 | */ 37 | private final FileDialog fileDialog = new FileDialog(dialog, "Apri File", FileDialog.LOAD); 38 | 39 | /** 40 | * Percorso completo del file selezionato dall'utente. 41 | */ 42 | private String fullPath; 43 | 44 | /** 45 | * Runnable che gestisce l'apertura della finestra di errore se si verifica un problema. 46 | */ 47 | private Runnable openWindowErrorOutput; 48 | 49 | 50 | /** 51 | * Indica se si è verificato un errore nel processo di salvataggio o apertura file. 52 | */ 53 | private Boolean errorType; 54 | 55 | /** 56 | * Costruttore della classe WinSaveEncryption. 57 | * Inizializza la finestra di dialogo e la mostra all'utente. 58 | * 59 | * @param openWindowErrorOutput Runnable per eseguire l'azione quando si verifica un errore. 60 | */ 61 | public WinSaveEncryption(Runnable openWindowErrorOutput) { 62 | this.openWindowErrorOutput = openWindowErrorOutput; 63 | fileDialog.setVisible(true); 64 | } 65 | 66 | 67 | /** 68 | * Inizializza la finestra di selezione file e gestisce il percorso selezionato dall'utente. 69 | * Se il percorso è valido, richiama la finestra di errore. 70 | */ 71 | public void initWindow() { 72 | String selectedDirectory = fileDialog.getDirectory(); 73 | String selectedFile = fileDialog.getFile(); 74 | if (selectedDirectory != null && selectedFile != null) { 75 | fullPath = selectedDirectory + selectedFile; 76 | openWindowErrorOutput.run(); 77 | } 78 | } 79 | 80 | /** 81 | * Resetta il percorso del file selezionato, impostandolo a null. 82 | */ 83 | public void resetPath( ) { 84 | fullPath = null; 85 | } 86 | 87 | /** 88 | * Restituisce il percorso completo del file selezionato. 89 | * 90 | * @return Una stringa rappresentante il percorso completo del file. 91 | */ 92 | public String getPath() { 93 | return fullPath; 94 | } 95 | 96 | /** 97 | * Imposta lo stato di errore dell'operazione di salvataggio. 98 | * 99 | * @param state Un booleano che indica se c'è stato un errore (true) o meno (false). 100 | */ 101 | public void setErrorType(boolean state) { 102 | errorType = state; 103 | } 104 | 105 | /** 106 | * Restituisce lo stato di errore corrente. 107 | * 108 | * @return Un booleano che indica se c'è un errore (true) o meno (false). 109 | */ 110 | public boolean getErrorType() { 111 | return errorType; 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/primality/WinPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.primality; 14 | 15 | import java.awt.BorderLayout; 16 | import java.awt.Dimension; 17 | import java.awt.GridBagConstraints; 18 | import java.awt.GridBagLayout; 19 | import java.awt.GridLayout; 20 | 21 | import javax.swing.JPanel; 22 | 23 | 24 | /** 25 | * Classe che gestisce la finestra principale dell'applicazione per la visualizzazione e l'interazione 26 | * con i pannelli di input e output. 27 | * 28 | * La classe dispone di un layout a griglia per disporre i pannelli di input e output e un layout 29 | * principale per gestire l'interfaccia utente dell'applicazione. 30 | * @author Vittorio Piotti 31 | * @version 1.0 32 | * @since 16-10-2023 33 | */ 34 | public class WinPrimality { 35 | 36 | /** 37 | * Il pannello che contiene i pannelli di input e output disposti in griglia. 38 | */ 39 | private final JPanel gridPanel = new JPanel(new GridLayout(1, 2)); 40 | 41 | /** 42 | * Il pannello per l'input dell'utente. 43 | */ 44 | private final JPanel panelInput = new JPanel(); 45 | 46 | /** 47 | * Il pannello per l'output dei risultati. 48 | */ 49 | private final JPanel panelOutput = new JPanel(); 50 | 51 | /** 52 | * Il pannello principale che contiene il pannello a griglia. 53 | */ 54 | private final JPanel mainPanel = new JPanel(new BorderLayout()); 55 | 56 | /** 57 | * I vincoli di layout per la disposizione dei componenti nel pannello. 58 | */ 59 | private final GridBagConstraints gbc = new GridBagConstraints(); 60 | 61 | /** 62 | * Allinea un pannello figlio al centro di un pannello genitore utilizzando un layout GridBagLayout. 63 | * 64 | * @param parent Il pannello genitore in cui il pannello figlio deve essere centrato. 65 | * @param child Il pannello figlio da centrare nel pannello genitore. 66 | */ 67 | private void centerChildInParent(JPanel parent, JPanel child){ 68 | parent.setLayout(new GridBagLayout()); 69 | gbc.gridx = 0; 70 | gbc.gridy = 0; 71 | parent.add(child, gbc); 72 | } 73 | 74 | /** 75 | * Imposta il layout a griglia per il pannello principale che contiene i pannelli di input e output. 76 | * 77 | * @param rows Il numero di righe nella griglia. 78 | * @param cols Il numero di colonne nella griglia. 79 | */ 80 | public void setGridPanel(int rows, int cols){ 81 | gridPanel.setLayout(new GridLayout(rows, cols)); 82 | 83 | } 84 | /** 85 | * Restituisce il pannello principale della finestra. 86 | * 87 | * @return Il pannello principale. 88 | */ 89 | public JPanel getWindow(){ 90 | return mainPanel; 91 | } 92 | 93 | /** 94 | * Costruisce una nuova istanza della finestra principale. 95 | * Inizializza i pannelli di input e output, li posiziona nella griglia e aggiunge la griglia al pannello principale. 96 | * 97 | * @param panelInput Il pannello per l'input dell'utente. 98 | * @param panelOutput Il pannello per l'output dei risultati. 99 | */ 100 | public WinPrimality(JPanel panelInput,JPanel panelOutput) { 101 | panelOutput.setPreferredSize(new Dimension(476, 214)); 102 | panelInput.setPreferredSize(new Dimension(476, 214)); 103 | 104 | centerChildInParent(this.panelInput,panelInput); 105 | centerChildInParent(this.panelOutput,panelOutput); 106 | gridPanel.add(this.panelInput); 107 | gridPanel.add(this.panelOutput); 108 | mainPanel.add(gridPanel, BorderLayout.CENTER); 109 | 110 | } 111 | 112 | 113 | } -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/primality/dialogs/WinErrorInPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.primality.dialogs; 14 | 15 | 16 | import java.awt.BorderLayout; 17 | import java.awt.Color; 18 | import java.awt.Dimension; 19 | import java.awt.Font; 20 | import java.awt.GridBagConstraints; 21 | import java.awt.GridBagLayout; 22 | import java.awt.Insets; 23 | import java.awt.event.ActionEvent; 24 | import java.awt.event.ActionListener; 25 | 26 | import javax.swing.BorderFactory; 27 | import javax.swing.JButton; 28 | import javax.swing.JDialog; 29 | import javax.swing.JFrame; 30 | import javax.swing.JLabel; 31 | import javax.swing.JPanel; 32 | 33 | /** 34 | * La classe WinErrorInPrimality rappresenta una finestra di dialogo che mostra un errore di inserimento relativo alla primalità. 35 | * Viene visualizzato un messaggio di errore con la possibilità di chiudere la finestra. 36 | * @author Vittorio Piotti 37 | * @version 1.0 38 | * @since 16-10-2023 39 | */ 40 | public class WinErrorInPrimality { 41 | 42 | /** 43 | * Dialogo principale che ospita la finestra di errore. 44 | */ 45 | private final JDialog dialog = new JDialog(); 46 | 47 | /** 48 | * Pannello principale che contiene tutti i componenti della finestra. 49 | */ 50 | private final JPanel mainPanel = new JPanel(new GridBagLayout()); 51 | 52 | /** 53 | * Gestisce la disposizione dei componenti nel pannello con le relative restrizioni. 54 | */ 55 | private final GridBagConstraints gbc = new GridBagConstraints(); 56 | 57 | /** 58 | * Etichetta che mostra il titolo del messaggio di errore. 59 | */ 60 | private final JLabel label = new JLabel("Errore inserimento"); 61 | 62 | /** 63 | * Pannello orizzontale che funge da separatore. 64 | */ 65 | private final JPanel hr = new JPanel(new BorderLayout()); 66 | 67 | /** 68 | * Pannello orizzontale più piccolo per un effetto di separazione sottile. 69 | */ 70 | private final JPanel hr_small = new JPanel(new BorderLayout()); 71 | 72 | /** 73 | * Bottone per chiudere la finestra di dialogo. 74 | */ 75 | private final JButton closeButton = new JButton("Chiudi"); 76 | 77 | /** 78 | * Array di etichette che mostra i messaggi di errore. 79 | */ 80 | private JLabel[] errorMessages; 81 | 82 | 83 | /** 84 | * Costruttore della classe WinErrorInPrimality. 85 | * Inizializza e configura la finestra di dialogo per mostrare i messaggi di errore specificati. 86 | * 87 | * @param mainFrame Il frame principale su cui la finestra di dialogo è centrata. 88 | * @param errorMessages Un array di stringhe contenente i messaggi di errore da visualizzare. 89 | */ 90 | public WinErrorInPrimality(JFrame mainFrame,String[] errorMessages){ 91 | dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE); 92 | dialog.setResizable(false); 93 | gbc.insets = new Insets(10, 10, 10, 10); 94 | label.setHorizontalAlignment(JLabel.CENTER); 95 | label.setBorder(BorderFactory.createEmptyBorder(10, 20, 0, 20)); 96 | label.setFont(new Font(label.getFont().getFontName(), Font.BOLD, label.getFont().getSize())); 97 | gbc.gridy++; 98 | gbc.gridwidth = 0; 99 | gbc.anchor = GridBagConstraints.CENTER; 100 | mainPanel.add(label, gbc); 101 | gbc.gridy++; 102 | hr_small.setBackground(Color.BLACK); 103 | hr_small.setPreferredSize(new Dimension(15, 7)); 104 | mainPanel.add(hr_small, gbc); 105 | 106 | this.errorMessages = new JLabel[errorMessages.length]; 107 | for (int i = 0; i < errorMessages.length;i++) { 108 | this.errorMessages[i] = new JLabel(errorMessages[i]); 109 | gbc.gridy++; 110 | gbc.gridwidth = 0; 111 | gbc.anchor = GridBagConstraints.WEST; 112 | mainPanel.add(this.errorMessages[i], gbc); 113 | } 114 | 115 | hr.setBackground(Color.GRAY); 116 | hr.setPreferredSize(new Dimension(230, 1)); 117 | gbc.gridx = 0; 118 | gbc.gridwidth = 2; 119 | gbc.gridy++; 120 | gbc.anchor = GridBagConstraints.CENTER; 121 | mainPanel.add(hr, gbc); 122 | closeButton.addActionListener(new ActionListener() { 123 | public void actionPerformed(ActionEvent e) { 124 | dialog.dispose(); 125 | } 126 | }); 127 | gbc.gridx = 1; 128 | gbc.gridy++; 129 | gbc.gridwidth = 1; 130 | gbc.anchor = GridBagConstraints.EAST; 131 | mainPanel.add(closeButton, gbc); 132 | dialog.add(mainPanel); 133 | dialog.pack(); 134 | dialog.setLocationRelativeTo(mainFrame); 135 | dialog.setVisible(true); 136 | } 137 | 138 | /** 139 | * Chiude e libera le risorse della finestra di dialogo. 140 | */ 141 | public void dispose(){ 142 | dialog.dispose(); 143 | } 144 | } 145 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/primality/dialogs/WinErrorOutPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.primality.dialogs; 14 | import java.awt.BorderLayout; 15 | import java.awt.FlowLayout; 16 | 17 | import javax.swing.Box; 18 | import javax.swing.Icon; 19 | import javax.swing.JButton; 20 | import javax.swing.JDialog; 21 | import javax.swing.JFrame; 22 | import javax.swing.JLabel; 23 | import javax.swing.JPanel; 24 | import javax.swing.UIManager; 25 | import javax.swing.border.EmptyBorder; 26 | 27 | 28 | /** 29 | * La classe WinErrorOutPrimality gestisce una finestra di dialogo che mostra un messaggio di errore o successo per un'operazione di primalità. 30 | * A seconda dello stato fornito, la finestra visualizza un'icona di avviso o di informazione, e un messaggio appropriato. 31 | * @author Vittorio Piotti 32 | * @version 1.0 33 | * @since 16-10-2023 34 | */ 35 | public class WinErrorOutPrimality { 36 | 37 | /** 38 | * Finestra di dialogo principale. 39 | */ 40 | private final JDialog dialog = new JDialog(); 41 | 42 | /** 43 | * Etichetta che visualizza l'icona di errore o successo. 44 | */ 45 | private final JLabel iconLabel = new JLabel(); 46 | 47 | /** 48 | * Pannello che contiene il messaggio da visualizzare. 49 | */ 50 | private final JPanel messagePanel = new JPanel(); 51 | 52 | /** 53 | * Etichetta che visualizza il testo del messaggio. 54 | */ 55 | private final JLabel messageLabel = new JLabel(); 56 | 57 | /** 58 | * Pannello che contiene il bottone di conferma. 59 | */ 60 | private final JPanel buttonPanel = new JPanel(); 61 | 62 | /** 63 | * Bottone per chiudere la finestra di dialogo. 64 | */ 65 | private final JButton button = new JButton("OK"); 66 | 67 | /** 68 | * Icona per messaggi di successo. 69 | */ 70 | private final Icon alertIcon = UIManager.getIcon("OptionPane.informationIcon"); 71 | 72 | /** 73 | * Icona per messaggi di errore. 74 | */ 75 | private final Icon errorIcon = UIManager.getIcon("OptionPane.warningIcon"); 76 | 77 | 78 | /** 79 | * Costruttore della classe WinErrorOutPrimality. 80 | * Inizializza e configura la finestra di dialogo con icona e messaggio in base allo stato specificato. 81 | * 82 | * @param mainFrame Il frame principale su cui la finestra di dialogo è centrata. 83 | * @param state Un booleano che determina il tipo di messaggio: 84 | * {@code false} per errore (icona di avviso), 85 | * {@code true} per successo (icona di informazione). 86 | */ 87 | public WinErrorOutPrimality(JFrame mainFrame,boolean state){ 88 | dialog.setTitle((state == false)?"Errore":"Successo"); 89 | dialog.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 90 | dialog.setSize(300, 180); 91 | dialog.setResizable(false); 92 | dialog.setLayout(new BorderLayout()); 93 | dialog.setLocationRelativeTo(mainFrame); 94 | iconLabel.setIcon((state == false)?errorIcon:alertIcon); 95 | iconLabel.setBorder(new EmptyBorder(20, 20, 0, 20)); 96 | dialog.add(iconLabel, BorderLayout.WEST); 97 | messagePanel.setBorder(new EmptyBorder(20, 0, 0,20)); 98 | messagePanel.setLayout(new BorderLayout()); 99 | messageLabel.setText((state == false)?"Accesso cartella vietato":"File salvato correttamente"); 100 | messagePanel.add(messageLabel, BorderLayout.CENTER); 101 | dialog.add(messagePanel, BorderLayout.CENTER); 102 | buttonPanel.setLayout(new FlowLayout(FlowLayout.RIGHT)); 103 | buttonPanel.setBorder(new EmptyBorder(0, 0, 20,20)); 104 | buttonPanel.add(Box.createVerticalGlue()); 105 | buttonPanel.add(button); 106 | buttonPanel.add(Box.createVerticalGlue()); 107 | dialog.add(buttonPanel, BorderLayout.SOUTH); 108 | button.addActionListener(e -> { 109 | dialog.dispose(); 110 | }); 111 | dialog.setVisible(true); 112 | } 113 | 114 | /** 115 | * Chiude e libera le risorse della finestra di dialogo. 116 | */ 117 | public void dispose(){ 118 | dialog.dispose(); 119 | } 120 | 121 | } 122 | 123 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/primality/panels/WinInPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.primality.panels; 14 | 15 | import java.awt.Dimension; 16 | import java.awt.FlowLayout; 17 | import java.awt.Font; 18 | import java.awt.GridBagConstraints; 19 | import java.awt.GridBagLayout; 20 | import java.awt.Insets; 21 | import java.awt.event.ActionEvent; 22 | import java.awt.event.ActionListener; 23 | import java.awt.event.KeyAdapter; 24 | import java.awt.event.KeyEvent; 25 | 26 | import javax.swing.BorderFactory; 27 | import javax.swing.JButton; 28 | import javax.swing.JComboBox; 29 | import javax.swing.JLabel; 30 | import javax.swing.JPanel; 31 | import javax.swing.JTextField; 32 | import javax.swing.SwingConstants; 33 | 34 | 35 | /** 36 | * La classe WinInPrimality gestisce la finestra di input per l'algoritmo di verifica della primalità. 37 | * L'utente può inserire un intervallo di valori (minimo e massimo) e scegliere un metodo per il calcolo. 38 | * @author Vittorio Piotti 39 | * @version 1.0 40 | * @since 16-10-2023 41 | */ 42 | public class WinInPrimality { 43 | 44 | /** 45 | * Indice del metodo scelto dall'utente. 46 | */ 47 | private int sceltaMetodo = 0; 48 | 49 | /** 50 | * Array di stringhe contenente i nomi dei metodi disponibili per il calcolo della primalità. 51 | */ 52 | private final String[] metodi = { 53 | "Divisori fino al numero anche pari no break", 54 | "Divisori fino al numero anche pari con break", 55 | "Divisori fino alla meta anche pari no break", 56 | "Divisori fino alla meta solo dispari no break", 57 | "Divisori fino alla radice solo dispari con break", 58 | "Algoritmo di Fermat" 59 | }; 60 | 61 | /** 62 | * Pannello principale che contiene il layout della finestra. 63 | */ 64 | private final JPanel panel = new JPanel(); 65 | 66 | /** 67 | * Contenitore del form di input. 68 | */ 69 | private final JPanel panelContainer = new JPanel(); 70 | 71 | /** 72 | * Etichetta del titolo della finestra. 73 | */ 74 | private final JLabel title = new JLabel("Input"); 75 | 76 | /** 77 | * Etichetta per campo di input del valore minimo. 78 | */ 79 | private final JLabel labelValMin = new JLabel("Minimo: "); 80 | /** 81 | * Casella di input del valore minimo. 82 | */ 83 | private final JTextField inputValMin = new JTextField(6); 84 | 85 | /** 86 | * Etichetta per campo di input del valore esponente minimo. 87 | */ 88 | 89 | private final JLabel labelExpMin = new JLabel(" * 10 ^ "); 90 | 91 | /** 92 | * Casella di input del valore esponente minimo. 93 | */ 94 | private final JTextField inputExpMin = new JTextField(3); 95 | 96 | /** 97 | * Etichetta per campo di input del valore massimo. 98 | */ 99 | private final JLabel labelValMax = new JLabel("Massimo: "); 100 | 101 | /** 102 | * Casella di input del valore massimo. 103 | */ 104 | private final JTextField inputValMax = new JTextField(6); 105 | 106 | /** 107 | * Casella di input del valore esponente massimo. 108 | */ 109 | private final JLabel labelExpMax = new JLabel(" * 10 ^ "); 110 | 111 | /** 112 | * Casella di input del valore massimo. 113 | */ 114 | private final JTextField inputExpMax = new JTextField(3); 115 | 116 | /** 117 | * Etichetta per la selezione del metodo. 118 | */ 119 | private final JLabel labelMetodo = new JLabel("Metodo: "); 120 | 121 | /** 122 | * ComboBox per la selezione del metodo. 123 | */ 124 | private final JComboBox < String > inputMetodo = new JComboBox <>(metodi); 125 | 126 | /** 127 | * Impostazioni del layout per il GridBagLayout. 128 | */ 129 | private final GridBagConstraints gbc = new GridBagConstraints(); 130 | 131 | /** 132 | * Bottone per eseguire l'algoritmo di verifica della primalità. 133 | */ 134 | private final JButton buttonEsegui = new JButton("Esegui"); 135 | 136 | /** 137 | * Stringa che memorizza l'errore corrente. 138 | */ 139 | private String errorType; 140 | 141 | /** 142 | * Runnable per aprire una finestra di errore in caso di input non valido. 143 | */ 144 | private Runnable openWindowErrorInput; 145 | 146 | /** 147 | * Valori e risultati delle operazioni di input. 148 | */ 149 | String numMin; 150 | String numMax; 151 | int valMin; 152 | int valMax; 153 | int expMin; 154 | int expMax; 155 | 156 | 157 | /** 158 | * Costruttore della classe WinInPrimality. Inizializza l'interfaccia utente e imposta i listener per i campi di input. 159 | * 160 | * @param openWindowErrorInput Runnable che gestisce l'apertura della finestra di errore in caso di input non valido. 161 | */ 162 | public WinInPrimality(Runnable openWindowErrorInput) { 163 | this.openWindowErrorInput = openWindowErrorInput; 164 | setInputKeyListener(inputValMin,7); 165 | setInputKeyListener(inputValMax,7); 166 | setInputKeyListener(inputExpMax,3); 167 | setInputKeyListener(inputExpMin,3); 168 | gbc.insets = new Insets(0, 0, 10, 0); 169 | inputMetodo.addActionListener(new ActionListener() { 170 | public void actionPerformed(ActionEvent e) { 171 | sceltaMetodo = inputMetodo.getSelectedIndex(); 172 | } 173 | }); 174 | buttonEsegui.addActionListener(new ActionListener() { 175 | public void actionPerformed(ActionEvent e) { 176 | errorType = findError(); 177 | openWindowErrorInput.run(); 178 | 179 | } 180 | }); 181 | panel.setLayout(new FlowLayout(FlowLayout.LEFT)); 182 | panelContainer.setLayout(new GridBagLayout()); 183 | panelContainer.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 184 | title.setFont(new Font(title.getFont().getName(), Font.BOLD, 20)); 185 | gbc.anchor = GridBagConstraints.WEST; 186 | gbc.gridx = 0; 187 | gbc.gridy = 0; 188 | gbc.gridwidth = 4; 189 | panelContainer.add(title, gbc); 190 | gbc.gridy = 1; 191 | gbc.gridx = 0; 192 | gbc.gridwidth = 1; 193 | labelMetodo.setPreferredSize(new Dimension(100, 20)); 194 | labelMetodo.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 195 | inputMetodo.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 196 | buttonEsegui.setFont(new Font(labelMetodo.getFont().getName(), Font.PLAIN, 13)); 197 | panelContainer.add(labelMetodo, gbc); 198 | gbc.gridx = 1; 199 | gbc.gridwidth = 4; 200 | panelContainer.add(inputMetodo, gbc); 201 | setInputRow(labelValMin, labelExpMin, inputValMin, inputExpMin); 202 | setInputRow(labelValMax, labelExpMax, inputValMax, inputExpMax); 203 | addInputRow(gbc, panelContainer, labelValMin, labelExpMin, inputValMin, inputExpMin, 2); 204 | addInputRow(gbc, panelContainer, labelValMax, labelExpMax, inputValMax, inputExpMax, 3); 205 | gbc.gridy = 4; 206 | gbc.anchor = GridBagConstraints.WEST; 207 | gbc.gridx = 0; 208 | gbc.gridwidth = 4; 209 | panelContainer.add(buttonEsegui,gbc); 210 | panel.add(panelContainer); 211 | } 212 | 213 | /** 214 | * Restituisce il pannello principale della finestra. 215 | * 216 | * @return Il pannello principale. 217 | */ 218 | public JPanel getWindow() { 219 | return panel; 220 | } 221 | 222 | /** 223 | * Verifica la presenza di errori negli input forniti. 224 | * 225 | * @return Una stringa rappresentante l'errore trovato, o una stringa vuota se non ci sono errori. 226 | */ 227 | private String findError(){ 228 | String error = ""; 229 | if(inputValMin.getText().equals(""))error += "1"; 230 | else error += "0"; 231 | if(inputValMax.getText().equals(""))error += "1"; 232 | else error += "0"; 233 | if(inputExpMin.getText().equals(""))inputExpMin.setText("0"); 234 | if(inputExpMax.getText().equals(""))inputExpMax.setText("0"); 235 | if(error.equals("00")){ 236 | valMin = Integer.parseInt(inputValMin.getText()); 237 | valMax = Integer.parseInt(inputValMax.getText()); 238 | expMin = Integer.parseInt(inputExpMin.getText()); 239 | expMax = Integer.parseInt(inputExpMax.getText()); 240 | numMin = setNum(inputValMin.getText(),inputExpMin.getText()); 241 | numMax = setNum(inputValMax.getText(),inputExpMax.getText()); 242 | if(valMin == valMax && expMin == expMax)return "33"; 243 | if(inputValMin.getText().length() + expMin > inputValMax.getText().length() + expMax || inputValMin.getText().length() + expMin == inputValMax.getText().length() + expMax && valMin>valMax)return "22"; 244 | } 245 | return error; 246 | } 247 | 248 | /** 249 | * Crea una rappresentazione numerica basata sui valori ed esponenti inseriti. 250 | * 251 | * @param val Il valore base. 252 | * @param exp L'esponente. 253 | * @return Il numero finale come stringa. 254 | */ 255 | public String setNum(String val,String exp){ 256 | String num = ""; 257 | num += val; 258 | for(int i = 0; i< Integer.parseInt(exp); i ++){ 259 | num += "0"; 260 | } 261 | return num; 262 | } 263 | 264 | /** 265 | * Restituisce il numero massimo calcolato. 266 | * 267 | * @return Il numero massimo. 268 | */ 269 | public String getMax(){ 270 | return numMax; 271 | } 272 | 273 | /** 274 | * Restituisce il numero minimo calcolato. 275 | * 276 | * @return Il numero minimo. 277 | */ 278 | public String getMin(){ 279 | return numMin; 280 | } 281 | 282 | /** 283 | * Restituisce il valore massimo inserito. 284 | * 285 | * @return Il valore massimo. 286 | */ 287 | public int getValMax(){ 288 | return valMax; 289 | } 290 | 291 | /** 292 | * Restituisce il valore minimo inserito. 293 | * 294 | * @return Il valore minimo. 295 | */ 296 | public int getValMin(){ 297 | return valMin; 298 | } 299 | 300 | /** 301 | * Restituisce l'esponente massimo inserito. 302 | * 303 | * @return L'esponente massimo. 304 | */ 305 | public int getExpMax(){ 306 | return expMax; 307 | } 308 | 309 | /** 310 | * Restituisce l'esponente minimo inserito. 311 | * 312 | * @return L'esponente minimo. 313 | */ 314 | public int getExpMin(){ 315 | return expMin; 316 | } 317 | 318 | /** 319 | * Restituisce l'indice del metodo selezionato. 320 | * 321 | * @return L'indice del metodo selezionato. 322 | */ 323 | public int getMetodo(){ 324 | return sceltaMetodo; 325 | } 326 | 327 | /** 328 | * Restituisce il nome del metodo selezionato in formato stringa. 329 | * 330 | * @return Il nome del metodo selezionato. 331 | */ 332 | public String toStringMetodo(){ 333 | return metodi[sceltaMetodo]; 334 | } 335 | 336 | /** 337 | * Imposta le proprietà del layout per una riga di input. 338 | * 339 | * @param labelVal Etichetta per il valore. 340 | * @param labelExp Etichetta per l'esponente. 341 | * @param inputVal Campo di input per il valore. 342 | * @param inputExp Campo di input per l'esponente. 343 | */ 344 | private static void setInputRow(JLabel labelVal,JLabel labelExp,JTextField inputVal,JTextField inputExp){ 345 | labelVal.setFont(new Font(labelVal.getFont().getName(), Font.PLAIN, 13)); 346 | labelExp.setFont(new Font(labelExp.getFont().getName(), Font.PLAIN, 13)); 347 | inputVal.setFont(new Font(inputVal.getFont().getName(), Font.PLAIN, 13)); 348 | inputExp.setFont(new Font(inputExp.getFont().getName(), Font.PLAIN, 13)); 349 | inputVal.setHorizontalAlignment(SwingConstants.RIGHT); 350 | inputExp.setHorizontalAlignment(SwingConstants.RIGHT); 351 | int width = 100; 352 | if(System.getProperty("os.name").toLowerCase().contains("windows") && (labelVal.getText().equals("Minimo: ")||labelVal.getText().equals("Massimo: ") ))width = 200; 353 | labelVal.setPreferredSize(new Dimension(width, 20)); 354 | labelVal.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 10)); 355 | } 356 | 357 | /** 358 | * Aggiunge una riga di input al pannello del form. 359 | * 360 | * @param gbc Configurazione del layout. 361 | * @param formContainer Pannello contenitore. 362 | * @param labelVal Etichetta per il valore. 363 | * @param labelExp Etichetta per l'esponente. 364 | * @param inputVal Campo di input per il valore. 365 | * @param inputExp Campo di input per l'esponente. 366 | * @param row Numero di riga in cui inserire gli elementi. 367 | */ 368 | private static void addInputRow(GridBagConstraints gbc, JPanel formContainer, JLabel labelVal, JLabel labelExp, JTextField inputVal, JTextField inputExp, int row) { 369 | gbc.gridy = row; 370 | gbc.gridx = 0; 371 | gbc.anchor = GridBagConstraints.WEST; 372 | gbc.gridwidth = 3; 373 | formContainer.add(labelVal, gbc); 374 | JPanel containerInput = new JPanel(new FlowLayout(FlowLayout.LEFT)); 375 | containerInput.add(inputVal); 376 | containerInput.add(labelExp); 377 | containerInput.add(inputExp); 378 | gbc.gridx = 3; 379 | gbc.gridwidth = 2; 380 | gbc.anchor = GridBagConstraints.EAST; 381 | formContainer.add(containerInput, gbc); 382 | } 383 | 384 | /** 385 | * Imposta un KeyListener per validare l'input e limitare il numero di caratteri. 386 | * 387 | * @param inputField Campo di input da validare. 388 | * @param max Numero massimo di caratteri consentiti. 389 | */ 390 | private void setInputKeyListener(JTextField inputField,int max){ 391 | inputField.addKeyListener(new KeyAdapter() { 392 | @Override 393 | public void keyTyped(KeyEvent e) { 394 | char c = e.getKeyChar(); 395 | if (Character.isDigit(c) || c == KeyEvent.VK_BACK_SPACE) { 396 | String currentText = inputField.getText(); 397 | int selectionStart = inputField.getSelectionStart(); 398 | int selectionEnd = inputField.getSelectionEnd(); 399 | if (selectionStart != selectionEnd) { 400 | e.consume(); 401 | String startStr = currentText.substring(0, selectionStart); 402 | String endStr = currentText.substring(selectionEnd, currentText.length()); 403 | inputField.setText(""); 404 | inputField.setText(startStr + c + endStr); 405 | inputField.setCaretPosition(selectionStart + 1); 406 | } else if (currentText.length() >= max && c != KeyEvent.VK_BACK_SPACE) { 407 | errorType = "44"; 408 | openWindowErrorInput.run(); 409 | e.consume(); 410 | } 411 | } else { 412 | errorType = "55"; 413 | openWindowErrorInput.run(); 414 | e.consume(); 415 | } 416 | } 417 | }); 418 | } 419 | 420 | /** 421 | * Restituisce l'errore corrente in formato stringa. 422 | * 423 | * @return La stringa dell'errore. 424 | */ 425 | public String getErrorType(){ 426 | return errorType; 427 | } 428 | 429 | } 430 | 431 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/primality/panels/WinOutPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.primality.panels; 14 | 15 | import java.awt.BorderLayout; 16 | import java.awt.Component; 17 | import java.awt.Dimension; 18 | import java.awt.FlowLayout; 19 | import java.awt.Font; 20 | import java.awt.GridBagConstraints; 21 | import java.awt.GridBagLayout; 22 | import java.awt.Insets; 23 | import java.awt.event.ActionEvent; 24 | import java.awt.event.ActionListener; 25 | import java.awt.event.AdjustmentEvent; 26 | import java.awt.event.AdjustmentListener; 27 | 28 | import javax.swing.BorderFactory; 29 | import javax.swing.Icon; 30 | import javax.swing.JButton; 31 | import javax.swing.JComponent; 32 | import javax.swing.JLabel; 33 | import javax.swing.JPanel; 34 | import javax.swing.JProgressBar; 35 | import javax.swing.JScrollBar; 36 | import javax.swing.JScrollPane; 37 | import javax.swing.JTextArea; 38 | import javax.swing.UIManager; 39 | 40 | 41 | /** 42 | * La classe `WinOutPrimality` rappresenta un'interfaccia grafica per la visualizzazione 43 | * dei risultati di un calcolo di numeri primi. Offre funzionalità per avviare, monitorare 44 | * e interrompere il calcolo, nonché per salvare i risultati in un file. 45 | * 46 | * La classe gestisce l'aggiornamento dei risultati calcolati in tempo reale e fornisce 47 | * strumenti per monitorare l'avanzamento del processo, come una barra di progresso e un timer. 48 | * @author Vittorio Piotti 49 | * @version 1.0 50 | * @since 16-10-2023 51 | */ 52 | public class WinOutPrimality { 53 | 54 | 55 | /** 56 | * Pannello principale dell'interfaccia grafica. 57 | */ 58 | private final JPanel panel = new JPanel(); 59 | 60 | /** 61 | * Pannello che contiene i componenti principali della finestra. 62 | */ 63 | private final JPanel panelContainer = new JPanel(); 64 | 65 | /** 66 | * Pannello utilizzato per la visualizzazione dei messaggi di output predefiniti. 67 | */ 68 | private final JPanel panelContainerDefault = new JPanel(); 69 | 70 | /** 71 | * Pannello che contiene le informazioni di caricamento e progresso, configurato con un layout BorderLayout. 72 | */ 73 | private final JPanel containerLoadingInfo = new JPanel(new BorderLayout()); 74 | 75 | /** 76 | * Etichetta per visualizzare il valore minimo specificato. 77 | */ 78 | private final JLabel labelMin = new JLabel("Minimo: "); 79 | 80 | /** 81 | * Etichetta per visualizzare il valore massimo specificato. 82 | */ 83 | private final JLabel labelMax = new JLabel("Massimo: "); 84 | 85 | /** 86 | * Etichetta per mostrare il numero di numeri calcolati fino ad ora. 87 | */ 88 | private final JLabel labelNum = new JLabel("Numeri calcolati: 0"); 89 | 90 | /** 91 | * Etichetta per visualizzare il tempo trascorso dal momento dell'inizio del calcolo. 92 | */ 93 | private final JLabel labelTime = new JLabel("Tempo di calcolo: 00:00"); 94 | 95 | /** 96 | * Etichetta che indica lo stato del calcolo in corso, ad esempio, se è stato interrotto o completato. 97 | */ 98 | private final JLabel stateCalculus = new JLabel(""); 99 | 100 | /** 101 | * Etichetta per il titolo della finestra di output. 102 | */ 103 | private final JLabel title = new JLabel("Output"); 104 | 105 | /** 106 | * Etichetta per il titolo predefinito nella finestra di output. 107 | */ 108 | private final JLabel titleDef = new JLabel("Output"); 109 | 110 | /** 111 | * Pulsante per salvare i risultati del calcolo in un file. 112 | */ 113 | private final JButton buttonSalva = new JButton("Salva"); 114 | 115 | /** 116 | * Oggetto GridBagConstraints utilizzato per gestire la disposizione dei pulsanti nel layout GridBag. 117 | */ 118 | private final GridBagConstraints gbcButtons = new GridBagConstraints(); 119 | 120 | /** 121 | * Pulsante per interrompere il calcolo in corso. 122 | */ 123 | private final JButton buttonStop = new JButton("Interrompi"); 124 | 125 | /** 126 | * Barra di progresso utilizzata per indicare l'avanzamento del calcolo. 127 | */ 128 | private final JProgressBar progressBar = new JProgressBar(); 129 | 130 | /** 131 | * Oggetto GridBagConstraints utilizzato per gestire la disposizione dei componenti principali nel layout GridBag. 132 | */ 133 | private final GridBagConstraints gbc = new GridBagConstraints(); 134 | 135 | /** 136 | * Oggetto GridBagConstraints utilizzato per gestire la disposizione dei componenti predefiniti nel layout GridBag. 137 | */ 138 | private final GridBagConstraints gbcDef = new GridBagConstraints(); 139 | 140 | /** 141 | * Area di testo utilizzata per visualizzare i risultati del calcolo. 142 | */ 143 | private final JTextArea results = new JTextArea(""); 144 | 145 | /** 146 | * Panello che contiene l'area di testo per i risultati. 147 | */ 148 | private final JScrollPane scrollPaneResults = new JScrollPane(results); 149 | 150 | /** 151 | * Pannello che contiene l'area di testo dei risultati. 152 | */ 153 | private final JPanel containerResults = new JPanel(); 154 | 155 | /** 156 | * Pannello che contiene lo stato del calcolo. 157 | */ 158 | private final JPanel containerStatoCalc = new JPanel(); 159 | 160 | /** 161 | * Icona utilizzata per visualizzare notifiche e avvisi relativi allo stato del calcolo. 162 | */ 163 | private final Icon alertIcon = UIManager.getIcon("OptionPane.informationIcon"); 164 | 165 | /** 166 | * Variabile del tempo di inizio in funzione del tempo corrente 167 | */ 168 | private long startTime = System.currentTimeMillis(); 169 | 170 | /** 171 | * Etichetta per visualizzare un avviso quando non è possibile stimare il tempo di attesa. 172 | */ 173 | private final JLabel loadingAdvertise = new JLabel("Impossibile stimare attesa"); 174 | 175 | /** 176 | * Etichetta per visualizzare un messaggio che indica che i risultati saranno mostrati in questa area. 177 | */ 178 | private final JLabel advertiseOutput = new JLabel("I risultati saranno visualizzati qui"); 179 | 180 | /** 181 | * Barra di scorrimento verticale dell'area di testo dei risultati. 182 | */ 183 | private final JScrollBar scrollBarResults = scrollPaneResults.getVerticalScrollBar(); 184 | 185 | /** 186 | * Flag che indica se l'utente ha interagito con la barra di scorrimento dell'area di testo dei risultati. 187 | */ 188 | private boolean scrolled = false; 189 | 190 | /** 191 | * Numero di numeri primi calcolati fino ad ora. 192 | */ 193 | private int calculatedNumers = 0; 194 | /** 195 | * Funzione Runnable per interrompere il calcolo in corso. 196 | */ 197 | private Runnable stopCalc; 198 | 199 | 200 | 201 | /** 202 | * Interrompe il calcolo in corso e aggiorna lo stato dell'interfaccia utente. 203 | * Imposta l'icona di stato e il testo dell'etichetta dello stato del calcolo. 204 | * Interrompe il timer e esegue il runnable associato per fermare il calcolo. 205 | */ 206 | public void stopCalc(){ 207 | stateCalculus.setIcon(alertIcon); 208 | if(!stateCalculus.getText().equals("Calcolo terminato"))stateCalculus.setText("Calcolo interrotto"); 209 | stopCalc.run(); 210 | timer.stop(); 211 | } 212 | 213 | /** 214 | * Aggiorna il tempo trascorso dal momento dell'inizio del calcolo. 215 | * Calcola i minuti e i secondi trascorsi e aggiorna l'etichetta del tempo di calcolo. 216 | */ 217 | private void updateTime() { 218 | final long currentTime = System.currentTimeMillis(); 219 | final long elapsedTime = currentTime - startTime; 220 | final long minutes = (elapsedTime / 1000) / 60; 221 | final long seconds = (elapsedTime / 1000) % 60; 222 | final String elapsedTimeStr = String.format("%02d:%02d", minutes, seconds); 223 | labelTime.setText("Tempo di calcolo: " + elapsedTimeStr); 224 | } 225 | 226 | /** 227 | * Timer utilizzato per aggiornare il tempo trascorso ogni secondo. 228 | * La durata dell'intervallo è impostata su 1000 millisecondi. 229 | */ 230 | private final javax.swing.Timer timer = new javax.swing.Timer(1000, new ActionListener() { 231 | @Override 232 | public void actionPerformed(ActionEvent e) { 233 | updateTime(); 234 | } 235 | }); 236 | 237 | 238 | /** 239 | * Costruttore della classe `WinOutPrimality`. 240 | * Inizializza i componenti dell'interfaccia grafica e configura le azioni dei pulsanti. 241 | * 242 | * @param stopCalc Runnable che definisce l'azione da eseguire quando si interrompe il calcolo. 243 | * @param openWindowSaveInFile Runnable che definisce l'azione da eseguire per aprire la finestra di salvataggio del file. 244 | */ 245 | public WinOutPrimality(Runnable stopCalc,Runnable openWindowSaveInFile){ 246 | this.stopCalc = stopCalc; 247 | loadingAdvertise.setFont(loadingAdvertise.getFont().deriveFont(Font.ITALIC)); 248 | gbc.insets = new Insets(0, 0, 10, 0); 249 | scrollBarResults.addAdjustmentListener(new AdjustmentListener() { 250 | @Override 251 | public void adjustmentValueChanged(AdjustmentEvent e) { 252 | if (e.getValueIsAdjusting()) { 253 | scrolled = true; 254 | } else { 255 | scrolled = false; 256 | } 257 | } 258 | }); 259 | buttonSalva.addActionListener(new ActionListener() { 260 | public void actionPerformed(ActionEvent e) { 261 | buttonStop.setEnabled(false); 262 | 263 | stopCalc(); 264 | openWindowSaveInFile.run(); 265 | 266 | } 267 | }); 268 | buttonStop.addActionListener(new ActionListener() { 269 | public void actionPerformed(ActionEvent e) { 270 | buttonStop.setEnabled(false); 271 | stopCalc(); 272 | 273 | 274 | 275 | } 276 | }); 277 | results.setEditable(false); 278 | results.setCaretPosition(0); 279 | panel.setLayout(new FlowLayout(FlowLayout.LEFT)); 280 | panelContainer.setLayout(new GridBagLayout()); 281 | panelContainer.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 282 | newLabelRow(title, Font.BOLD,20,0,0); 283 | newLabelRow(labelMin,Font.PLAIN,13,1,0); 284 | newLabelRow(labelMax,Font.PLAIN,13,2,0); 285 | newLabelRow(labelNum,Font.PLAIN,13,3,0); 286 | newLabelRow(labelTime,Font.PLAIN,13,4,0); 287 | newLabelRow(labelTime,Font.PLAIN,13,5,0); 288 | gbc.insets = new Insets(0, 0, 0, 0); 289 | 290 | newLabelRow(containerLoadingInfo,Font.PLAIN,13,6,0); 291 | JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT)); 292 | buttonSalva.setFont(new Font(buttonSalva.getFont().getName(), Font.PLAIN, 13)); 293 | buttonStop.setFont(new Font(buttonStop.getFont().getName(), Font.PLAIN, 13)); 294 | 295 | buttonPanel.add(buttonSalva); 296 | buttonPanel.add(buttonStop); 297 | 298 | gbcButtons.anchor = GridBagConstraints.WEST; 299 | gbcButtons.gridx = 0; 300 | gbcButtons.gridy = 7; 301 | panelContainer.add(buttonPanel, gbcButtons); 302 | 303 | gbc.anchor = GridBagConstraints.WEST; 304 | gbc.gridx = 1; 305 | gbc.gridy = 1; 306 | gbc.gridheight = 5; 307 | containerResults.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 308 | int width = 215; 309 | if(System.getProperty("os.name").toLowerCase().contains("windows"))width = 165; 310 | scrollPaneResults.setPreferredSize(new Dimension(width, 90)); 311 | containerResults.add(scrollPaneResults); 312 | panelContainer.add(containerResults, gbc); 313 | gbc.anchor = GridBagConstraints.WEST; 314 | gbc.gridx = 1; 315 | gbc.gridy = 5; 316 | gbc.gridheight = 3; 317 | containerStatoCalc.setBorder(BorderFactory.createEmptyBorder(14, 20, 0, 0)); 318 | containerStatoCalc.add(stateCalculus); 319 | panelContainer.add(containerStatoCalc, gbc); 320 | panelContainerDefault.setLayout(new GridBagLayout()); 321 | panelContainerDefault.setBorder(BorderFactory.createEmptyBorder(0, 20, 0, 0)); 322 | gbcDef.anchor = GridBagConstraints.WEST; 323 | gbcDef.gridx = 0; 324 | gbcDef.gridy = 0; 325 | panelContainerDefault.add(titleDef,gbcDef); 326 | titleDef.setBorder(BorderFactory.createEmptyBorder(0, 0, 10, 0)); 327 | titleDef.setFont(new Font( titleDef.getFont().getName(), Font.BOLD, 20)); 328 | gbcDef.gridy = 1; 329 | panelContainerDefault.add(advertiseOutput,gbcDef); 330 | panel.add(panelContainerDefault); 331 | } 332 | 333 | /** 334 | * Inizializza la finestra per la visualizzazione dei risultati. 335 | * Abilita il pulsante di stop, rimuove tutti i componenti esistenti e aggiunge il pannello principale. 336 | */ 337 | public void initWindow(){ 338 | buttonStop.setEnabled(true); 339 | panel.removeAll(); 340 | panel.add(panelContainer); 341 | } 342 | 343 | /** 344 | * Incrementa il numero di numeri primi calcolati e aggiorna l'etichetta che mostra questo numero. 345 | */ 346 | public void incrementCalculatedPrimeNumbers(){ 347 | calculatedNumers++; 348 | labelNum.setText("Numeri calcolati: " + calculatedNumers); 349 | } 350 | 351 | /** 352 | * Aggiunge un risultato calcolato all'area di testo dei risultati. 353 | * Scorre automaticamente verso il basso se l'utente non ha interagito con la barra di scorrimento. 354 | * 355 | * @param result Il risultato calcolato da aggiungere all'area di testo. 356 | */ 357 | public void appendCalculatedNumber(String result){ 358 | results.append(result); 359 | if(scrolled == false)results.setCaretPosition(results.getDocument().getLength()); 360 | } 361 | 362 | /** 363 | * Inizializza la barra di avanzamento e aggiorna l'interfaccia utente per il calcolo in corso. 364 | * Imposta il testo delle etichette, ripristina lo stato del calcolo e avvia il timer. 365 | * Se il valore massimo è lungo più di 10 caratteri, visualizza un'etichetta di avviso 366 | * invece della barra di avanzamento. 367 | * 368 | * @param max Il valore massimo del calcolo. 369 | * @param min Il valore minimo del calcolo. 370 | */ 371 | public void initProgressBar(String max,String min){ 372 | results.setText(""); 373 | containerLoadingInfo.removeAll(); 374 | stateCalculus.setIcon(null); 375 | stateCalculus.setText(""); 376 | calculatedNumers = 0; 377 | labelMin.setText("Minimo: " + ((getExp(min) != 0)?getNum(min) + " * 10 ^ "+getExp(min):min) +"\n"); 378 | labelMax.setText("Massimo: " + ((getExp(max) != 0)?getNum(max) + " * 10 ^ "+getExp(max):max) +"\n"); 379 | labelTime.setText("Tempo di calcolo: 00:00"); 380 | labelNum.setText("Numeri calcolati: 0"); 381 | startTime = System.currentTimeMillis(); 382 | timer.start(); 383 | if(max.length() <= 10){ 384 | progressBar.setStringPainted(false); 385 | progressBar.setIndeterminate(false); 386 | progressBar.setValue(0); 387 | progressBar.setMinimum(0); 388 | progressBar.setMaximum(Integer.parseInt(max) - Integer.parseInt(min)); 389 | containerLoadingInfo.add(progressBar, BorderLayout.WEST); 390 | }else{ 391 | containerLoadingInfo.add(loadingAdvertise); 392 | } 393 | panel.revalidate(); // Aggiorna il layout 394 | panel.repaint(); 395 | } 396 | 397 | /** 398 | * Aggiunge un nuovo componente all'interfaccia utente in una riga e colonna specifica 399 | * con il formato di font specificato. 400 | * 401 | * @param object Il componente da aggiungere. 402 | * @param fontSyle Lo stile del font (es. Font.PLAIN, Font.BOLD). 403 | * @param fontSize La dimensione del font. 404 | * @param row La riga nella quale posizionare il componente. 405 | * @param column La colonna nella quale posizionare il componente. 406 | */ 407 | public void newLabelRow(JComponent object, int fontSyle, int fontSize, int row, int column) { 408 | gbc.anchor = GridBagConstraints.WEST; 409 | gbc.gridx = column; 410 | gbc.gridy = row; 411 | object.setFont(new Font(object.getFont().getName(), fontSyle, fontSize)); 412 | if (!(object instanceof JButton)){ 413 | object.setPreferredSize(new Dimension(200, 20)); 414 | } 415 | panelContainer.add(object, gbc); 416 | } 417 | 418 | 419 | /** 420 | * Restituisce il pannello principale dell'interfaccia utente. 421 | * 422 | * @return Il pannello principale. 423 | */ 424 | public JPanel getWindow(){ 425 | return panel; 426 | } 427 | 428 | /** 429 | * Incrementa il valore della barra di avanzamento e aggiorna lo stato se il calcolo è completato. 430 | * Se il valore della barra di avanzamento raggiunge il massimo, disabilita il pulsante di stop, 431 | * ferma il timer e aggiorna lo stato del calcolo per indicare che il calcolo è terminato. 432 | */ 433 | public void incrementProgressBar(){ 434 | Component[] components = containerLoadingInfo.getComponents(); 435 | if(components != null && components[0] instanceof JProgressBar){ 436 | if (progressBar.getValue() != progressBar.getMaximum()) { 437 | progressBar.setValue(progressBar.getValue() + 1); 438 | if (progressBar.getValue() == progressBar.getMaximum()){ 439 | buttonStop.setEnabled(false); 440 | timer.stop(); 441 | stateCalculus.setIcon(alertIcon); 442 | stateCalculus.setText("Calcolo terminato"); 443 | } 444 | } 445 | } 446 | } 447 | 448 | 449 | /** 450 | * Calcola l'esponente della potenza di 10 da applicare a un valore numerico. 451 | * Se il valore termina con uno o più zeri, ritorna l'esponente della potenza di 10 452 | * altrimenti ritorna 0. 453 | * 454 | * @param val La stringa del valore numerico. 455 | * @return L'esponente della potenza di 10. 456 | */ 457 | private int getExp(String val){ 458 | final int length = val.length(); 459 | int exp = 1; 460 | if(length > 1 ){ 461 | if(val.charAt(length - 1) == '0'){ 462 | for(int i = length - 2; i > 0 ; i --){ 463 | if(val.charAt(i) == '0')exp++; 464 | } 465 | return exp;//esponente potenza di 10 466 | }else{ 467 | return 0;//esponente potenza di 10 468 | } 469 | }else{ 470 | return 0;//esponente potenza di 10 471 | } 472 | } 473 | 474 | /** 475 | * Estrae il valore numerico puro da una stringa che potrebbe contenere uno o più zeri finali. 476 | * Se la stringa termina con uno o più zeri, ritorna il valore numerico senza gli zeri finali. 477 | * Altrimenti ritorna il valore numerico come è. 478 | * 479 | * @param val La stringa del valore numerico. 480 | * @return Il valore numerico puro. 481 | */ 482 | private int getNum(String val){ 483 | final int length = val.length(); 484 | int exp = 1; 485 | int num = 0; 486 | if(length > 1 ){ 487 | if(val.charAt(length - 1) == '0'){ 488 | for(int i = length - 2; i > 0 ; i --){ 489 | if(val.charAt(i) == '0')exp++; 490 | } 491 | num = Integer.parseInt(val.substring(0, length -exp)); 492 | return num;//valore puro 493 | }else{ 494 | return Integer.parseInt(val);//valore puro 495 | } 496 | }else{ 497 | return Integer.parseInt(val);//valore puro 498 | } 499 | } 500 | } 501 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/components/primality/panels/WinSavePrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.components.primality.panels; 14 | 15 | import java.awt.FileDialog; 16 | import java.io.File; 17 | 18 | import javax.swing.JDialog; 19 | 20 | 21 | /** 22 | * Gestisce la finestra di salvataggio per i risultati del calcolo di primalità. 23 | * Permette all'utente di scegliere un percorso e un nome di file per salvare i dati. 24 | * Controlla anche se il percorso di salvataggio è all'interno di una directory bloccata 25 | * e gestisce gli errori associati. 26 | * @author Vittorio Piotti 27 | * @version 1.0 28 | * @since 16-10-2023 29 | */ 30 | public class WinSavePrimality { 31 | 32 | /** 33 | * La finestra di dialogo principale per la selezione del file. 34 | */ 35 | private final JDialog dialog = new JDialog(); 36 | 37 | /** 38 | * La finestra di dialogo per la selezione e il salvataggio del file. 39 | */ 40 | private final FileDialog fileDialog = new FileDialog(dialog, "Salva File", FileDialog.SAVE); 41 | 42 | /** 43 | * Il percorso del file JAR in cui è eseguita l'applicazione. 44 | */ 45 | private final String jarFilePath = WinSavePrimality.class.getProtectionDomain().getCodeSource().getLocation().getPath(); 46 | 47 | /** 48 | * Il percorso della cartella Desktop dell'utente. 49 | */ 50 | private final String desktopPath = System.getProperty("user.home") + System.getProperty("file.separator") + "Desktop"; 51 | 52 | /** 53 | * Il percorso della directory da cui il salvataggio è bloccato, se applicabile. 54 | */ 55 | private String directoryToBlock = (jarFilePath.toLowerCase().endsWith(".jar") ? new File(jarFilePath).getParent() : System.getProperty("user.dir")); 56 | 57 | /** 58 | * Il percorso completo del file selezionato per il salvataggio. 59 | */ 60 | private String fullPath; 61 | 62 | /** 63 | * Il runnable da eseguire in caso di errore nel percorso di salvataggio. 64 | */ 65 | private Runnable openWindowErrorOutput; 66 | 67 | /** 68 | * Indica se si è verificato un errore relativo al percorso di salvataggio. 69 | */ 70 | private Boolean errorType; 71 | 72 | 73 | /** 74 | * Costruisce una finestra di salvataggio con il nome di file predefinito e 75 | * il runnable per gestire gli errori di percorso di salvataggio. 76 | * 77 | * @param fileName Il nome del file predefinito per il salvataggio. 78 | * @param openWindowErrorOutput Il runnable da eseguire in caso di errore nel percorso di salvataggio. 79 | */ 80 | public WinSavePrimality(String fileName,Runnable openWindowErrorOutput) { 81 | if (!directoryToBlock.equals(File.separator)) { 82 | directoryToBlock = new File(directoryToBlock).getParent(); 83 | } 84 | this.openWindowErrorOutput = openWindowErrorOutput; 85 | fileDialog.setDirectory(desktopPath); 86 | fileDialog.setFile(fileName); 87 | fileDialog.setVisible(true); 88 | } 89 | 90 | /** 91 | * Inizializza la finestra di salvataggio e verifica il percorso selezionato. 92 | * Controlla se il percorso di salvataggio è all'interno della directory bloccata. 93 | * Esegue il runnable associato in caso di errore di percorso. 94 | */ 95 | public void initWindow(){ 96 | String selectedDirectory = fileDialog.getDirectory(); 97 | String selectedFile = fileDialog.getFile(); 98 | if (selectedDirectory != null && selectedFile != null) { 99 | if (!selectedFile.endsWith(".txt")) { 100 | selectedFile += ".txt"; 101 | } 102 | fullPath = selectedDirectory + selectedFile; 103 | if (fullPath.startsWith(directoryToBlock)) { 104 | errorType = false; 105 | } else { 106 | errorType = true; 107 | } 108 | openWindowErrorOutput.run(); 109 | } 110 | } 111 | 112 | /** 113 | * Restituisce il percorso completo del file selezionato per il salvataggio. 114 | * 115 | * @return Il percorso completo del file. 116 | */ 117 | public String getPath(){ 118 | return fullPath; 119 | } 120 | 121 | /** 122 | * Restituisce il tipo di errore associato al percorso di salvataggio. 123 | * 124 | * @return {@code true} se il percorso di salvataggio è al di fuori della directory bloccata, {@code false} altrimenti. 125 | */ 126 | public boolean getErrorType(){ 127 | return errorType; 128 | } 129 | 130 | 131 | } 132 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/managers/WinManagerEncryption.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.managers; 14 | 15 | import java.util.function.Supplier; 16 | 17 | import javax.swing.JFrame; 18 | import javax.swing.JPanel; 19 | 20 | import org.app.windows.dependencies.components.encryption.WinEncryption; 21 | import org.app.windows.dependencies.components.encryption.dialogs.WinErrorInEncryption; 22 | import org.app.windows.dependencies.components.encryption.dialogs.WinErrorOutEncryption; 23 | import org.app.windows.dependencies.components.encryption.panels.WinInEncryption; 24 | import org.app.windows.dependencies.components.encryption.panels.WinOutEncryption; 25 | import org.app.windows.dependencies.components.encryption.panels.WinSaveEncryption; 26 | 27 | 28 | /** 29 | * Gestisce l'interfaccia utente per le operazioni di crittografia, inclusi l'input dell'utente, l'output, e le finestre di errore. 30 | * Coordina le azioni tra le finestre di input, output e errore, e gestisce le operazioni di crittografia. 31 | * @author Vittorio Piotti 32 | * @version 1.0 33 | * @since 16-10-2023 34 | */ 35 | public class WinManagerEncryption { 36 | 37 | 38 | /** 39 | * Messaggi di errore per la crittografia. 40 | */ 41 | private final static String[] errorMessagesEncryption = { 42 | "Messaggio vuoto", 43 | "Nessun file selezionato", 44 | }; 45 | 46 | /** 47 | * Finestra di errore per input di crittografia. 48 | */ 49 | private WinErrorInEncryption windowErrorInputEncryption; 50 | 51 | /** 52 | * Finestra di errore per output di crittografia. 53 | */ 54 | private WinErrorOutEncryption windowErrorOutputEncryption; 55 | 56 | /** 57 | * Finestra di input per la crittografia. 58 | */ 59 | private WinInEncryption windowInputEncryption; 60 | 61 | /** 62 | * Finestra di output per la crittografia. 63 | */ 64 | private WinOutEncryption windowOutputEncryption; 65 | 66 | /** 67 | * Finestra di salvataggio file per la crittografia. 68 | */ 69 | private WinSaveEncryption windowReadingFileEncryption; 70 | 71 | /** 72 | * Finestra principale di crittografia. 73 | */ 74 | private WinEncryption windowEncryption; 75 | 76 | /** 77 | * Fornisce il frame principale dell'applicazione. 78 | */ 79 | private Supplier getFrameWindowHome; 80 | 81 | /** 82 | * Azione da eseguire per avviare la crittografia. 83 | */ 84 | private Runnable startCalcEncryption; 85 | 86 | /** 87 | * Azione da eseguire per inizializzare e controllare la lettura del file. 88 | */ 89 | private Runnable initAndCheckReadingFile; 90 | 91 | 92 | /** 93 | * Costruisce un'istanza di WinManagerEncryption. 94 | * 95 | * @param getFrameWindowHome Fornisce il frame principale dell'applicazione. 96 | * @param startCalcEncryption Runnable per avviare la crittografia. 97 | * @param initAndCheckReadingFile Runnable per inizializzare e controllare la lettura del file. 98 | * @param checkFileOnchange Runnable per controllare i cambiamenti del file. 99 | */ 100 | public WinManagerEncryption(Supplier getFrameWindowHome,Runnable startCalcEncryption,Runnable initAndCheckReadingFile,Runnable checkFileOnchange){ 101 | this.getFrameWindowHome = getFrameWindowHome; 102 | this.startCalcEncryption = startCalcEncryption; 103 | this.initAndCheckReadingFile = initAndCheckReadingFile; 104 | windowInputEncryption = new WinInEncryption(openWindowErrorInputEncryption,openWindowReadingFile,checkFileOnchange); 105 | windowOutputEncryption = new WinOutEncryption(); 106 | windowEncryption = new WinEncryption(windowInputEncryption.getWindow(),windowOutputEncryption.getWindow()); 107 | 108 | } 109 | 110 | /** 111 | * Runnable per aprire la finestra di errore dell'input di crittografia. 112 | */ 113 | private final Runnable openWindowErrorInputEncryption = () -> { 114 | if(windowErrorInputEncryption != null){ 115 | windowErrorInputEncryption.dispose(); 116 | } 117 | 118 | switch(windowInputEncryption.getErrorType() + ((windowReadingFileEncryption == null || windowReadingFileEncryption.getPath() == null)?"1":"0")){ 119 | case "00": 120 | 121 | windowOutputEncryption.initWindow(windowInputEncryption.getMetodo()); 122 | startCalcEncryption.run(); 123 | 124 | 125 | break; 126 | case "10": 127 | windowErrorInputEncryption = new WinErrorInEncryption(getFrameWindowHome.get(), new String[]{errorMessagesEncryption[0]}); 128 | break; 129 | case "01": 130 | windowErrorInputEncryption = new WinErrorInEncryption(getFrameWindowHome.get(), new String[]{errorMessagesEncryption[1]}); 131 | break; 132 | default: 133 | windowErrorInputEncryption = new WinErrorInEncryption(getFrameWindowHome.get(), errorMessagesEncryption); 134 | break; 135 | } 136 | 137 | }; 138 | 139 | 140 | /** 141 | * Runnable per aprire la finestra di errore dell'output di crittografia. 142 | */ 143 | public final Runnable openWindowErrorOutputEncryption = () -> { 144 | if(windowReadingFileEncryption != null){ 145 | if(windowErrorOutputEncryption != null)windowErrorOutputEncryption.dispose(); 146 | initAndCheckReadingFile.run(); 147 | windowErrorOutputEncryption = new WinErrorOutEncryption(getFrameWindowHome.get(), windowReadingFileEncryption.getErrorType()); 148 | } 149 | }; 150 | 151 | /** 152 | * Runnable per aprire la finestra di salvataggio del file di crittografia. 153 | */ 154 | private final Runnable openWindowReadingFile = () ->{ 155 | 156 | windowReadingFileEncryption = new WinSaveEncryption(openWindowErrorOutputEncryption); 157 | windowReadingFileEncryption.initWindow(); 158 | 159 | }; 160 | 161 | 162 | /** 163 | * Imposta il tipo di errore del file nella finestra di salvataggio. 164 | * 165 | * @param state Indica se il file ha un errore (true) o meno (false). 166 | */ 167 | public void setFileErrorType(boolean state){ 168 | if(windowReadingFileEncryption != null){ 169 | windowReadingFileEncryption.setErrorType(state); 170 | windowInputEncryption.setLabelFile(state); 171 | if(state == false){ 172 | windowReadingFileEncryption.resetPath(); 173 | } 174 | } 175 | 176 | } 177 | 178 | /** 179 | * Ottiene se è stato selezionato l'inverso mod. 180 | * 181 | * @return true se l'inverso mod è selezionato, false altrimenti. 182 | */ 183 | public boolean getModInverse(){ 184 | return windowInputEncryption.getModInverse(); 185 | } 186 | 187 | /** 188 | * Ottiene il percorso del file di lettura. 189 | * 190 | * @return Il percorso del file di lettura, o una stringa vuota se non è stato selezionato un file. 191 | */ 192 | public String getPathReading(){ 193 | if(windowReadingFileEncryption != null){ 194 | return windowReadingFileEncryption.getPath(); 195 | } else return ""; 196 | } 197 | 198 | 199 | /** 200 | * Imposta i risultati della crittografia nella finestra di output. 201 | * 202 | * @param results I risultati della crittografia da visualizzare. 203 | */ 204 | public void setResultsEncryption(String results){ 205 | windowOutputEncryption.setResults(results); 206 | } 207 | 208 | /** 209 | * Ottiene il metodo di crittografia selezionato. 210 | * 211 | * @return Il metodo di crittografia selezionato. 212 | */ 213 | public int getEncryptionMetodo(){ 214 | return windowInputEncryption.getMetodo(); 215 | } 216 | 217 | /** 218 | * Ottiene il messaggio di crittografia dall'input dell'utente. 219 | * 220 | * @return Il messaggio di crittografia. 221 | */ 222 | public String getMessage(){ 223 | return windowInputEncryption.getMessage(); 224 | } 225 | 226 | 227 | /** 228 | * Ottiene la finestra principale di crittografia. 229 | * 230 | * @return La finestra principale di crittografia. 231 | */ 232 | public JPanel getWindow(){ 233 | return windowEncryption.getWindow(); 234 | } 235 | 236 | 237 | /** 238 | * Imposta il layout della griglia nella finestra principale di crittografia. 239 | * 240 | * @param rows Il numero di righe nella griglia. 241 | * @param cols Il numero di colonne nella griglia. 242 | */ 243 | public void setGridPanel(int rows, int cols){ 244 | windowEncryption.setGridPanel(rows, cols); 245 | } 246 | } 247 | -------------------------------------------------------------------------------- /project/src/org/app/windows/dependencies/managers/WinManagerPrimality.java: -------------------------------------------------------------------------------- 1 | /* 2 | Fermat And RSA v1.0.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/releases/tag/1.0.0) 3 | Copyright 2024 Vittorio Piotti 4 | Licensed under GPL-3.0 (https://github.com/vittorioPiotti/Fermat-And-RSA/blob/main/LICENSE.md) 5 | */ 6 | 7 | /* 8 | FlatLaf v3.2.5 (https://github.com/JFormDesigner/FlatLaf/releases/tag/3.2.5) 9 | Copyright 2024 JFormDesigner GmbH 10 | Licensed under Apache License 2.0 (https://github.com/JFormDesigner/FlatLaf/blob/main/LICENSE) 11 | */ 12 | 13 | package org.app.windows.dependencies.managers; 14 | 15 | 16 | import java.util.function.Supplier; 17 | 18 | import javax.swing.JFrame; 19 | import javax.swing.JPanel; 20 | 21 | import org.app.windows.dependencies.components.primality.WinPrimality; 22 | import org.app.windows.dependencies.components.primality.dialogs.WinErrorInPrimality; 23 | import org.app.windows.dependencies.components.primality.dialogs.WinErrorOutPrimality; 24 | import org.app.windows.dependencies.components.primality.panels.WinInPrimality; 25 | import org.app.windows.dependencies.components.primality.panels.WinOutPrimality; 26 | import org.app.windows.dependencies.components.primality.panels.WinSavePrimality; 27 | 28 | /** 29 | * Gestisce l'interfaccia utente per il test di primalità, inclusi l'input dell'utente, l'output, e le finestre di errore e salvataggio. 30 | * Coordina le azioni tra le finestre di input, output e errore e gestisce le operazioni di calcolo dei numeri primi. 31 | * @author Vittorio Piotti 32 | * @version 1.0 33 | * @since 16-10-2023 34 | */ 35 | public class WinManagerPrimality { 36 | 37 | /** 38 | * Messaggi di errore per il test di primalità. 39 | */ 40 | private final static String[] errorMessages = { 41 | "Numero minimo", 42 | "Numero massimo", 43 | "Minimo maggiore di massimo", 44 | "Minimo uguale a massimo", 45 | "Overflow caratteri", 46 | "Ammessi solo numeri", 47 | }; 48 | 49 | /** 50 | * Finestra di errore per input di primalità. 51 | */ 52 | private WinErrorInPrimality windowErrorInput; 53 | 54 | /** 55 | * Finestra di errore per output di primalità. 56 | */ 57 | private WinErrorOutPrimality windowErrorOutput; 58 | 59 | /** 60 | * Finestra di input per il test di primalità. 61 | */ 62 | private WinInPrimality windowInput; 63 | 64 | /** 65 | * Finestra di output per il test di primalità. 66 | */ 67 | private WinOutPrimality windowOutput; 68 | 69 | /** 70 | * Finestra di salvataggio file per il test di primalità. 71 | */ 72 | private WinSavePrimality windowSaveInFile; 73 | 74 | /** 75 | * Finestra principale del test di primalità. 76 | */ 77 | private WinPrimality windowPrimalityTest; 78 | 79 | /** 80 | * Fornisce il frame principale dell'applicazione. 81 | */ 82 | private Supplier getFrameWindowHome; 83 | 84 | /** 85 | * Azione da eseguire per fermare il calcolo della primalità. 86 | */ 87 | private Runnable stopCalcPrimality; 88 | 89 | /** 90 | * Azione da eseguire per avviare il salvataggio dei risultati della primalità. 91 | */ 92 | private Runnable startSavingPrimality; 93 | 94 | /** 95 | * Azione da eseguire per avviare il calcolo della primalità. 96 | */ 97 | private Runnable startCalcPrimality; 98 | 99 | 100 | /** 101 | * Costruisce un'istanza di WinManagerPrimality. 102 | * 103 | * @param getFrameWindowHome Fornisce il frame principale dell'applicazione. 104 | * @param stopCalcPrimality Runnable per fermare il calcolo della primalità. 105 | * @param startSavingPrimality Runnable per avviare il salvataggio dei risultati della primalità. 106 | * @param startCalcPrimality Runnable per avviare il calcolo della primalità. 107 | */ 108 | public WinManagerPrimality(Supplier getFrameWindowHome,Runnable stopCalcPrimality,Runnable startSavingPrimality, Runnable startCalcPrimality ){ 109 | this.getFrameWindowHome = getFrameWindowHome; 110 | this.stopCalcPrimality = stopCalcPrimality; 111 | this.startSavingPrimality = startSavingPrimality; 112 | this.startCalcPrimality = startCalcPrimality; 113 | windowInput = new WinInPrimality(openWindowErrorInput); 114 | windowOutput = new WinOutPrimality(this.stopCalcPrimality,openWindowSaveInFile ); 115 | windowPrimalityTest = new WinPrimality(windowInput.getWindow(),windowOutput.getWindow()); 116 | } 117 | 118 | /** 119 | * Runnable per cambiare la finestra di output e fermare il calcolo della primalità. 120 | */ 121 | public final Runnable switchWindow = () ->{ 122 | windowOutput.stopCalc(); 123 | }; 124 | 125 | /** 126 | * Runnable per aprire la finestra di errore dell'output di primalità. 127 | */ 128 | public final Runnable openWindowErrorOutput = () -> { 129 | if(windowErrorOutput != null)windowErrorOutput.dispose(); 130 | windowErrorOutput = new WinErrorOutPrimality(getFrameWindowHome.get(), windowSaveInFile.getErrorType()); 131 | if(windowSaveInFile.getErrorType())startSavingPrimality.run(); 132 | }; 133 | 134 | /** 135 | * Runnable per aprire la finestra di salvataggio dei risultati della primalità. 136 | */ 137 | private final Runnable openWindowSaveInFile = () ->{ 138 | windowSaveInFile = new WinSavePrimality("numeri-primi",openWindowErrorOutput); 139 | windowSaveInFile.initWindow(); 140 | }; 141 | 142 | /** 143 | * Runnable per aprire la finestra di errore dell'input di primalità. 144 | */ 145 | private final Runnable openWindowErrorInput = () -> { 146 | if(windowErrorInput != null)windowErrorInput.dispose(); 147 | switch(windowInput.getErrorType()){ 148 | case "00": 149 | stopCalcPrimality.run(); 150 | windowOutput.initWindow(); 151 | windowOutput.initProgressBar(getMax(), getMin()); 152 | startCalcPrimality.run(); 153 | break; 154 | case "22": 155 | windowErrorInput = new WinErrorInPrimality(getFrameWindowHome.get(),new String[]{errorMessages[2]}); 156 | break; 157 | case "33": 158 | windowErrorInput = new WinErrorInPrimality(getFrameWindowHome.get(),new String[]{errorMessages[3]}); 159 | break; 160 | case "44": 161 | windowErrorInput = new WinErrorInPrimality(getFrameWindowHome.get(),new String[]{errorMessages[4]}); 162 | break; 163 | case "55": 164 | windowErrorInput = new WinErrorInPrimality(getFrameWindowHome.get(),new String[]{errorMessages[5]}); 165 | break; 166 | default: 167 | String [] newMessage; 168 | int c = 0; 169 | for(int i = 0; i < 2; i ++){ 170 | if(windowInput.getErrorType().charAt(i) == '1')c++; 171 | } 172 | newMessage = new String [c]; 173 | c = 0; 174 | for(int i = 0; i < 2; i ++){ 175 | if(windowInput.getErrorType().charAt(i) == '1'){ 176 | newMessage[c] = errorMessages[i]; 177 | c++; 178 | } 179 | } 180 | windowErrorInput = new WinErrorInPrimality(getFrameWindowHome.get(),newMessage); 181 | break; 182 | } 183 | }; 184 | 185 | 186 | /** 187 | * Ottiene il valore massimo per il test di primalità. 188 | * 189 | * @return Il valore massimo. 190 | */ 191 | public int getValMax(){ 192 | return windowInput.getValMax(); 193 | } 194 | 195 | /** 196 | * Ottiene il valore minimo per il test di primalità. 197 | * 198 | * @return Il valore minimo. 199 | */ 200 | public int getValMin(){ 201 | return windowInput.getValMin(); 202 | } 203 | 204 | /** 205 | * Ottiene l'esponente massimo per il test di primalità. 206 | * 207 | * @return L'esponente massimo. 208 | */ 209 | public int getExpMax(){ 210 | return windowInput.getExpMax(); 211 | } 212 | 213 | /** 214 | * Ottiene l'esponente minimo per il test di primalità. 215 | * 216 | * @return L'esponente minimo. 217 | */ 218 | public int getExpMin(){ 219 | return windowInput.getExpMax(); 220 | } 221 | 222 | /** 223 | * Ottiene il valore minimo come stringa per il test di primalità. 224 | * 225 | * @return Il valore minimo come stringa. 226 | */ 227 | public String getMin(){ 228 | return windowInput.getMin(); 229 | } 230 | 231 | /** 232 | * Ottiene il valore massimo come stringa per il test di primalità. 233 | * 234 | * @return Il valore massimo come stringa. 235 | */ 236 | public String getMax(){ 237 | return windowInput.getMax(); 238 | } 239 | 240 | /** 241 | * Ottiene il metodo di test di primalità selezionato. 242 | * 243 | * @return Il metodo di test di primalità selezionato. 244 | */ 245 | public int getMetodo(){ 246 | return windowInput.getMetodo(); 247 | } 248 | 249 | /** 250 | * Ottiene una rappresentazione del metodo di test di primalità come stringa. 251 | * 252 | * @return La rappresentazione del metodo come stringa. 253 | */ 254 | public String toStringMetodo(){ 255 | return windowInput.toStringMetodo(); 256 | } 257 | 258 | /** 259 | * Incrementa la barra di progresso nella finestra di output di primalità. 260 | */ 261 | public void incrementProgressBar(){ 262 | windowOutput.incrementProgressBar(); 263 | } 264 | 265 | /** 266 | * Incrementa il conteggio dei numeri primi calcolati nella finestra di output di primalità. 267 | */ 268 | public void incrementCalculatedPrimeNumbers(){ 269 | windowOutput.incrementCalculatedPrimeNumbers(); 270 | } 271 | 272 | /** 273 | * Aggiunge un numero calcolato ai risultati nella finestra di output di primalità. 274 | * 275 | * @param result Il numero calcolato da aggiungere ai risultati. 276 | */ 277 | public void appendCalculatedNumber(String result){ 278 | windowOutput.appendCalculatedNumber(result); 279 | } 280 | 281 | /** 282 | * Verifica se esiste una finestra di salvataggio dei risultati di primalità e, se necessario, la apre. 283 | * 284 | * @return true se la finestra di salvataggio esiste, false altrimenti. 285 | */ 286 | public boolean existWindowSaveInFile(){ 287 | if(windowSaveInFile == null)openWindowSaveInFile.run(); 288 | return windowSaveInFile != null; 289 | } 290 | 291 | /** 292 | * Ottiene il percorso del file di salvataggio. 293 | * 294 | * @return Il percorso del file di salvataggio. 295 | */ 296 | public String getPath(){ 297 | return windowSaveInFile.getPath(); 298 | } 299 | 300 | /** 301 | * Imposta il pannello della griglia nella finestra di test di primalità. 302 | * 303 | * @param rows Il numero di righe da impostare nella griglia. 304 | * @param cols Il numero di colonne da impostare nella griglia. 305 | */ 306 | public void setGridPanel(int rows, int cols){ 307 | windowPrimalityTest.setGridPanel(rows, cols); 308 | } 309 | 310 | /** 311 | * Ottiene il pannello della finestra di test di primalità. 312 | * 313 | * @return Il pannello della finestra di test di primalità come {@link JPanel}. 314 | */ 315 | public JPanel getWindow(){ 316 | return windowPrimalityTest.getWindow(); 317 | } 318 | 319 | 320 | 321 | } 322 | --------------------------------------------------------------------------------