Skip to content
Snippets Groups Projects
Commit e59fe78b authored by Torstein Strømme's avatar Torstein Strømme
Browse files

First draft

parents
No related branches found
No related tags found
No related merge requests found
Showing
with 777 additions and 0 deletions
README.md 0 → 100644
# Rutenett
![Illustrasjon av ferdig program](./img/screenshot-done.png)
I denne lab'en skal vi tegne et rutenett som vist over. Oppgaven består i hovedsak av to deler:
1. Skriv en klasse `ColorGrid` som representerer et rutenett av farger.
2. Skriv en klasse `CellPositionToPixelConverter` som har en metode som regner ut piksel-koordinatene for en gitt rute.
2. Skriv en klasse `GridView` som kan tegne et rutenett av farger.
* [Anbefalte forberedelser](#anbefalte-forberedelser)
* [Bli kjent med utlevert kode](#bli-kjent-med-utlevert-kode)
* [Opprett rutenett av farger](#opprett-rutenett-av-farger)
* [Tegning](#tegning)
* [Opprett rutetnettet som skal tegnes](#opprett-rutenettet-som-skal-tegnes)
* [CellPositionToPixelConverter](#cellpositiontopixelconverter)
* [drawGrid](#drawgrid)
* [drawCell](#drawcell)
## Anbefalte forberedelser
* Laben antar at du har kjennskap til grunnleggende java, inkludert [grensesnitt](https://inf101.ii.uib.no/notat/grensesnitt/), [klasser og objekter](https://inf101.ii.uib.no/notat/objekter/).
* Du bør ha skummet igjennom kursnotatene om [arv](https://inf101.ii.uib.no/notat/arv), men vi kommer ikke til å gå i dypden på dette i denne lab'en.
* Kursnotatene om [grafikk](https://inf101.ii.uib.no/notat/grafikk) vil være spesielt relevante. Kan brukes som et oppslagsverk for å finne ut hvordan noe kan tegnes.
## Bli kjent med utlevert kode
Undersøk filene i pakken `no.uib.inf101.colorgrid`, og besvar spørsmålene i `TextQuestions` ([link](./src/main/java/no/uib/inf101/colorgrid/TextQuestions.java)).
✅ Du er klar til gå videre når alle testene i `TestTextQuestions` ([link](./src/test/java/no/uib/inf101/colorgrid/TestTextQuestions.java)) passerer.
## Opprett rutenett av farger
I denne oppgaven skal du lage klassen `ColorGrid` ([link](./src/main/java/no/uib/inf101/colorgrid/ColorGrid.java)). Den er nå helt tom.
* [ ] La klassen implementere grensesnittet `IColorGrid`
* [ ] La klassen ha en konstruktør med to parametre: en int som beskriver antall rader, og en int som beskriver antall kolonner. Standard-verdien til en posisjon i rutenettet (før `set`-metoden har blitt kalt på gitt posisjon) skal være `null`.
* [ ] Fyll ut metodene du trenger i overenstemmelse med javadoc-kommentarene til `IColorGrid`.
Du kan leke deg litt i `Main::main` for å sjekke for deg selv at klassen fungerer som du forventer. For eksempel:
```java
IColorGrid grid = new ColorGrid(3, 4);
System.out.println(grid.rows()); // forventer 3
System.out.println(grid.cols()); // forventer 4
System.out.println(grid.get(new CellPosition(1, 2))); // forventer null
grid.set(new CellPosition(1, 2), Color.RED);
System.out.println(grid.get(new CellPosition(1, 2))); // forventer rød
System.out.println(grid.get(new CellPosition(2, 1))); // forventer null
```
Husk å rydde opp etter deg i `Main::main` når du er ferdig!
✅ Du er klar til gå videre når alle testene i `TestColorGrid` ([link](./src/test/java/no/uib/inf101/colorgrid/TestColorGrid.java)) passerer.
.
## Tegning
Ha kursnotatene om [grafikk](https://inf101.ii.uib.no/notat/grafikk) i bakhodet når du gjør denne oppgaven.
I `GridView`:
* [ ] La klassen utvide `JPanel`
* [ ] La konstruktøren til `GridView` sette standard størrelse på lerretet til 400x300 piksler
* [ ] Overskriv metoden `public void paintComponent(Graphics g)`. Begynn med å kalle på super-metoden og opprett en Graphics2D -variabel fra g, slik som vist i kursnotatene om grafikk.
* [ ] Velg din favoritt-figur fra kursnotatene og tegn den i paintComponent (midlertidig, fjern den igjen når vi senere skal tegne rutenettet )
I `Main`:
* [ ] Opprett et `GridView` -objekt
* [ ] Opprett et `JFrame` -objekt
* [ ] Kall `setContentPane` -metoden på JFrame-objektet med GridView-objektet som argument
* [ ] Kall `setTitle`, `setDefaultCloseOperation`, `pack` og `setVisible` på JFrame-objektet etter mønster fra kursnotatene om grafikk.
✅ Du er klar til å gå videre hvis du ser tegningen din i et vindu når du kjører `Main`.
## Opprett rutenettet som skal tegnes
I `Main::main` skal vi nå opprette et rutenett, og gi det til `GridView`-konstruktøren som et argument ved opprettelse. Deretter skal vi endre GridView slik at den tegner dette rutenettet.
* [ ] I `Main::main`, opprett et ColorGrid-objekt med 3 rader og 4 kolonner. Sett fargene i hjørnene til å være
* Rød i hjørnet oppe til venstre (posisjon (0, 0))
* Blå i hjørnet oppe til høyre (posisjon (0, 3))
* Gul i hjørnet nede til venstre (posisjon (2, 0))
* Grønn i hjørnet nede til høyre (posisjon (2, 3))
* [ ] I `GridView`, legg til en parameter av typen `IColorGrid` i konstruktøren, og legg også til en instansvariabel av samme type. Initialiser feltvariabelen med argumentet gitt til konstruktøren.
For å tegne rutenettet gjenstår det å endre på *paintComponent* -metoden. Vi skal benytte oss av tre hjelpemetoder for å tegne rutenettet:
* `drawGrid` har som ansvar å tegne et fullstendig rutenett, inkludert alle rammer og ruter (alt innenfor det grå området i illustrasjonen). For å tegne selve rutene, kaller denne metoden på
* `drawCells`, som har som ansvar å tegne en samling av ruter. For hver rute regner denne metode ut hvor ruten skal være ved å kalle på hjelpemetoden
* `getBoundsForCell` som vet hvordan å regne ut posisjonen til én rute i rutenettet.
Det viser seg at det er den sistnevnte metoden som er mest komplisert. Vi kunne hatt `getBoundForCell` som en vanlig hjelpemetode, men siden dette er en relativt isolert operasjon som vi ønsker å kunne teste separat, oppretter vi en en klasse for denne hjelpemetoden: *CellPositionToPixelConverter*.
## CellPositionToPixelConverter
Vi ønsker å opprette en hjelpemetode `getBoundsForCell` som oversetter koordinater i rutenettet til et rektangel med posisjon og størrelse beskrevet som piksler til bruk på et lerret. Det er naturlig at denne metoden
* har en parameter av typen `CellPosition` og
* returnerer et `Rectangle2D` -objekt.
Men -- dette er ikke tilstrekkelig informasjon for å gjøre utregningen; vi trenger i tillegg å vite
* innefor hvilket område rutenettet befinner seg
* hvor mange rader og kolonner det er i rutenettet som helhet, og
* hvor stor avstanden mellom rutene skal være.
Disse siste delene med informasjon vil ikke endre seg særlig fra kall til kall, men er en del av *konteksten* metoden kjører i. Slik kontekst er best beskrevet som feltvariabler.
I klassen `CellPositionToPixelConverter`:
* [ ] Opprett feltvariabler:
* Et `Rectangle2D` -objekt `box` som beskriver innenfor hvilket område rutenettet skal tegnes
* Et `GridDimension` -objekt `gd` som beskriver størrelsen til rutenettet rutene vil være en del av
* En `double` kalt `margin` som beskriver hvor stor avstanden skal være mellom rutene
* [ ] Opprett en konstruktør i klassen med tre parametre: et `Rectangle2D` -objekt, et `GridDimension` -objekt og en `double`. Initaliser feltvariablene med verdiene mottat i konstruktøren.
* [ ] Opprett metoden `getBoundsForCell` med en parameter av typen `CellPosition` (i figur under navgitt `cp`) og returtype `Rectangle2D`.
Returverdien er et `Rectangle2D` -objekt. For å opprette dette objektet, må du regne ut fire verdier: x, y, bredde og høyde for den gitte ruten. Så kan du returnere et nytt `Rectangle2D.Double` -objekt med disse verdiene.
Illustrasjonen under visualiserer parameterne og resultatvariablene. Svarte variabler er gitt som input eller er tilgjengelig som feltvariabler, mens de røde variablene er de du skal regne ut og returnere.
![Illustrasjon av variabler som opptrer i getBoundsForCell](./img/getBoundsForCell.png)
Hint:
* Benytt `double` hvis du gjør regnestykker som involverer divisjon, da unngår du avrundingsfeil.
* Ikke bland horisontale og vertikale verdier. Horsiontale begreper: x, bredde, kolonne. Vertikale begreper: y, høyde, rad.
* Begynn med å regne ut *cellWidth* og *cellHeight*, og bruk verdiene du finner der for videre kalkulasjoner.
> Eksempel: anta at du får følgende parametre (som i illustrasjonen):
> * `box.getX()` er 30 og `box.getY()` er 30
> * `box.getWidth()` er 340 og `box.getHeight()` er 240
> * `cellPosition.col()` er 2 og `cellPosition.row()` er 1
> * `gd.cols()` er 4 og `gd.rows()` er 3
> * `margin` er 30
>
> Vi begynner med å regne ut `cellWidth`. Siden vi har 4 kolonner totalt, vil det gå med 5*30=150 piksler til marginer, og vi får da 190 piksler igjen å fordele på de fire kolonnene. Vi får da at cellen skal ha bredde 47.5.
>
> For å finne verdien til `cellX` begynner vi på `box.getX()` og legger til margin + rutebredde + margin + rutebredde + margin. Verdien blir da 30+30+47.5+30+47.5+30 = 215.
>
> Tilsvarende finner vi at `cellHeight` blir 40 og `cellY` blir 130.
✅ Du er klar til å gå videre når testene i `TestCellPositionToPixelConverter` passerer.
## drawGrid
Denne metoden i `GridView` skal ha et `Graphics2D` -objekt som parameter, og ikke ha noen returverdi. Planen er å først tegne en stor grå firkant, og så tegne selve rutene «oppå».
- [ ] Opprett et Rectangle2D -objekt med en fast 30 pikslers avstand til kanten på vinduet (se avsnitt om fast avstand til kantene på lerretet i kursnotater om [grafikk](https://inf101.ii.uib.no/notat/grafikk/#fast-avstand-til-kantene-på-lerretet))
* Det kan være lurt å lagre tallet som en konstant med et beskrivende navn (altså opprett en static final feltvariabel `private static final double OUTERMARGIN = 30;` og så bruke `OUTERMARGIN` i stedet for 30 når du kommer tilbake her)
- [ ] Fyll rektangelet med gråfarge på lerretet.
* Det kan være lurt å lagre fargen som en konstant med et beskrivende navn (altså opprett en static final feltvariabel `private static final Color MARGINCOLOR = Color.LIGHT_GRAY;` og så bruke `MARGINCOLOR` i stedet for Color.LIGHT_GRAY når du kommer tilbake her)
- [ ] Opprett et `CellPositionToPixelConverter` -objekt.
* Hvilket objekt med typen GridDimension skal du bruke som argument ved opprettelsen? Har du et slik objekt liggende et sted allerede?
* Marginen skal være et fast tall; i eksempelillustrasjonen er tallet 30 blitt brukt. Det kan være lurt å lagre tallet som en konstant med et beskrivende navn.
- [ ] Gjør et kall til en hjelpemetoden `drawCells` beskrevet under
PS: Siden metoden benytter instansmetoder kan metoden *ikke* være static. Siden metoden ikke skal benyttes av noen utenfor `GridView` -klassen, bør metoden være *private*.
## drawCell
Denne metoden i `GridView` er uten returverdi, men skal ha tre parametre:
* et `Graphics2D` -objekt, lerretet rutene skal tegnes på
* et `CellColorCollection` -objekt, rutene som skal tegnes
* et `CellPositionToPixelConverter` -objekt som kan regne ut rutene sin posisjon
La metoden iterere gjennom rutene i CellColorCollection -objektet, og tegne hver av dem på lerretet. Dersom fargen er null, bruk `Color.DARK_GRAY` i stedet.
PS: siden drawCells ikke er avhengig av instansvariabler, bør metoden være *static*. Siden den ikke benyttes utenfor `GridCell` -klassen bør metoden være *private*.
✅ Du er ferdig med lab'en når testene i `TestGridView` passerer, og du kan kjøre Main-metoden og ser samme bilde som vist i illustrasjonen nå programmet kjører. Det skal fungere å endre størrelse på vinduet, og rutenettet skal strekke seg for å fylle hele lerretet med en fast avstand til kanten.
\ No newline at end of file
source diff could not be displayed: it is too large. Options to address this: view the blob.
img/getBoundsForCell.png

358 KiB

source diff could not be displayed: it is too large. Options to address this: view the blob.
img/gridmeasures.png

353 KiB

img/screenshot-done.png

201 KiB

img/screenshot.png

161 KiB

#!/bin/bash
# Script for packaging a Java application as a Mac installer.
# Designed to be used with Maven (see example pom.xml at
# https://github.com/torsteins/JavaInstallerForSwing)
#
# Inspired by a template made by dlemmermann at
# https://github.com/dlemmermann/JPackageScriptFX
#
# Simplified by Torstein Strømme to fit INF101 at the University of Bergen.
# ------ ENVIRONMENT ----------------------------------------------
# The script depends on environment variables to exist in order to
# run properly (think of them as input parameters to the script).
# We print them all here:
echo "required input environment variables..."
echo " ABOUT_NAME: $ABOUT_NAME" # name of colorgrid in menu
echo " APP_PACKAGE: $APP_PACKAGE" # e.g. "no.uib.inf101.colorgrid"
echo " APP_VENDOR: $APP_VENDOR" # info shown in ~about~ dialog
echo " APP_VERSION: $APP_VERSION" # version shown in ~about~ dialog
echo " ICON_PATH: $ICON_PATH" # path to .icns -file
echo " INSTALLER_TYPE: $INSTALLER_TYPE" # e.g. "dmg" or "pkg"
echo " JAVA_HOME: $JAVA_HOME" # path to java installation
echo " JAVA_VERSION: $JAVA_VERSION" # e.g. "17"
echo " MAIN_CLASS: $MAIN_CLASS" # e.g. "no.uib.inf101.gridview.Main"
echo " MAIN_JAR: $MAIN_JAR" # filename produced in package phase
echo " PROJECT_NAME: $PROJECT_NAME" # human-friendly name of application
echo " PROJECT_VERSION: $PROJECT_VERSION" # version in pom, e.g. "1.0-SNAPSHOT"
echo "computed variables..."
CURRENT_YEAR=$(date +'%Y')
echo " CURRENT_YEAR: $CURRENT_YEAR"
#PATH_TO_MAIN_CLASS="target/classes/${MAIN_CLASS//'.'//}.class"
PATH_TO_MAIN_CLASS="target/classes/${APP_PACKAGE//'.'//}/"
echo " PATH_TO_MAIN_CLASS: $PATH_TO_MAIN_CLASS"
echo " pwd: "
pwd
# ------ SETUP DIRECTORIES AND FILES ----------------------------------------
# Remove previously generated java runtime and installers. Copy all required
# jar files into the input/libs folder.
echo "setting up directories and files..."
rm -rfd ./target/java-runtime/
rm -rfd target/installer/
mkdir -p target/installer/input/libs/
if [[ -d target/libs ]]; then
cp target/libs/* target/installer/input/libs
fi
cp "target/${MAIN_JAR}" target/installer/input/libs/
## ------ REQUIRED MODULES ---------------------------------------------------
## Use jlink to detect all modules that are required to run the application.
## Starting point for the jdep analysis is the set of jars being used by the
## application.
echo "detecting required modules.."
echo "$JAVA_HOME/bin/jdeps" \
-q \
--multi-release "${JAVA_VERSION}" \
--ignore-missing-deps \
--print-module-deps \
--class-path "target/installer/input/libs/*" \
"$PATH_TO_MAIN_CLASS"
detected_modules=$("$JAVA_HOME/bin/jdeps" \
-q \
--multi-release "${JAVA_VERSION}" \
--ignore-missing-deps \
--print-module-deps \
--class-path "target/installer/input/libs/*" \
"$PATH_TO_MAIN_CLASS")
echo " detected modules: ${detected_modules}"
# Note: in the original version of this script by dlemmermann (reference
# above), there is a separate section on manual required modules. Please
# adapt from that script if you find that this is required. Only applies
# to certain modules, such as jdk.crypto.ec or jdk.localedata.
# ------ RUNTIME IMAGE ------------------------------------------------------
# Use the jlink tool to create a runtime image for our application. We are
# doing this in a separate step instead of letting jlink do the work as part
# of the jpackage tool. This approach allows for finer configuration and also
# works with dependencies that are not fully modularized, yet.
echo "creating java runtime image..."
echo "$JAVA_HOME/bin/jlink" \
--strip-native-commands \
--no-header-files \
--no-man-pages \
--compress=2 \
--strip-debug \
--add-modules "${detected_modules}" \
--output target/java-runtime
"$JAVA_HOME/bin/jlink" \
--strip-native-commands \
--no-header-files \
--no-man-pages \
--compress=2 \
--strip-debug \
--add-modules "${detected_modules}" \
--output target/java-runtime
# ------ PACKAGING ----------------------------------------------------------
# In the end we will find the package inside the target/installer directory.
echo "creating installer of type $INSTALLER_TYPE..."
echo "$JAVA_HOME/bin/jpackage" \
--type "$INSTALLER_TYPE" \
--dest target/installer \
--input target/installer/input/libs \
--name "${PROJECT_NAME}" \
--main-class "${MAIN_CLASS}" \
--main-jar "${MAIN_JAR}" \
--runtime-image target/java-runtime \
--icon "${ICON_PATH}" \
--app-version "${APP_VERSION}" \
--vendor "${APP_VENDOR}" \
--copyright "Copyright © ${CURRENT_YEAR} ${APP_VENDOR}." \
--mac-package-identifier "${APP_PACKAGE}"
# --java-options -Xmx2048m \
"$JAVA_HOME/bin/jpackage" \
--type "$INSTALLER_TYPE" \
--dest target/installer \
--input target/installer/input/libs \
--name "${PROJECT_NAME}" \
--main-class "${MAIN_CLASS}" \
--main-jar "${MAIN_JAR}" \
--runtime-image target/java-runtime \
--icon "${ICON_PATH}" \
--app-version "${APP_VERSION}" \
--vendor "${APP_VENDOR}" \
--copyright "Copyright © ${CURRENT_YEAR} ${APP_VENDOR}." \
--mac-package-identifier "${APP_PACKAGE}"
# --java-options -Xmx2048m \
@ECHO OFF
REM Script for packaging a Java application as a Windows installer.
REM Designed to be used with Maven (see example pom.xml at
REM https://github.com/torsteins/JavaInstallerForSwing)
REM
REM Inspired by a template made by dlemmermann at
REM https://github.com/dlemmermann/JPackageScriptFX
REM
REM Simplified by Torstein Strømme to fit INF101 at the University of Bergen.
REM ------ ENVIRONMENT --------------------------------------------------------
REM The script depends on various environment variables to exist in order to
REM run properly. The location of the java binaries (java home), and the
REM project version as defined inside the pom.xml file, e.g. 1.0-SNAPSHOT.
ECHO "required input environment variables..."
ECHO " APP_PACKAGE: %APP_PACKAGE%"
ECHO " APP_VENDOR: %APP_VENDOR%"
REM APP_VERSION: the application version, e.g. 1.0.0, shown in "about" dialog
ECHO " APP_VERSION: %APP_VERSION%"
ECHO " ICON_PATH: %ICON_PATH%"
REM Set desired installer type: "msi" "exe" (or "app-image").
ECHO " INSTALLER_TYPE: %INSTALLER_TYPE%"
ECHO " JAVA_HOME: %JAVA_HOME%"
ECHO " JAVA_VERSION: %JAVA_VERSION%"
ECHO " MAIN_JAR: %MAIN_JAR%"
ECHO " MAIN_CLASS: %MAIN_CLASS%"
ECHO " PROJECT_NAME: %PROJECT_NAME%"
ECHO " PROJECT_VERSION: %PROJECT_VERSION%"
ECHO "computed variables..."
@REM SET PATH_TO_MAIN="target\classes\%MAIN_CLASS:.=\%.class"
SET PATH_TO_MAIN="target\classes\%APP_PACKAGE:.=\%"
ECHO " PATH_TO_MAIN: %PATH_TO_MAIN%"
SET YEAR=%DATE:~6,4%
ECHO " YEAR: %YEAR%"
REM ------ SETUP DIRECTORIES AND FILES ----------------------------------------
REM Remove previously generated java runtime and installers. Copy all required
REM jar files into the input/libs folder.
ECHO "setting up directories and files..."
IF EXIST target\java-runtime RMDIR /S /Q .\target\java-runtime
IF EXIST target\installer RMDIR /S /Q target\installer
MKDIR target\installer\input\libs
XCOPY /S /Q target\libs\* target\installer\input\libs\
COPY target\%MAIN_JAR% target\installer\input\libs\
REM ------ REQUIRED MODULES ---------------------------------------------------
REM Use jlink to detect all modules that are required to run the application.
REM Starting point for the jdep analysis is the set of jars being used by the
REM application.
ECHO "detecting required modules with jdeps..."
"%JAVA_HOME%\bin\jdeps" ^
-q ^
--multi-release %JAVA_VERSION% ^
--ignore-missing-deps ^
--class-path "target\installer\input\libs\*" ^
--print-module-deps "%PATH_TO_MAIN%" > temp.txt
SET /p detected_modules=<temp.txt
DEL temp.txt
ECHO " detected modules: %detected_modules%"
REM ------ RUNTIME IMAGE ------------------------------------------------------
REM Use the jlink tool to create a runtime image for our application. We are
REM doing this in a separate step instead of letting jlink do the work as part
REM of the jpackage tool. This approach allows for finer configuration and also
REM works with dependencies that are not fully modularized, yet.
ECHO "creating java runtime image with jlink..."
CALL "%JAVA_HOME%\bin\jlink" ^
--strip-native-commands ^
--no-header-files ^
--no-man-pages ^
--compress=2 ^
--strip-debug ^
--add-modules "%detected_modules%" ^
--output target/java-runtime
REM ------ PACKAGING ----------------------------------------------------------
REM In the end we will find the package inside the target/installer directory.
ECHO "creating install package with jpackage..."
CALL "%JAVA_HOME%\bin\jpackage" ^
--type %INSTALLER_TYPE% ^
--dest target/installer ^
--input target/installer/input/libs ^
--name "%PROJECT_NAME%" ^
--main-class "%MAIN_CLASS%" ^
--main-jar "%MAIN_JAR%" ^
--runtime-image target/java-runtime ^
--icon "%ICON_PATH%" ^
--app-version %APP_VERSION% ^
--vendor "%APP_VENDOR%" ^
--copyright "Copyright © %YEAR% %APP_VENDOR%" ^
--win-dir-chooser ^
--win-per-user-install ^
--win-shortcut ^
--win-menu
REM --java-options -Xmx2048m
pom.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- Major project properties -->
<groupId>no.uib.inf101.grid</groupId> <!-- must match package of Main class -->
<artifactId>INF101GridLab</artifactId>
<version>1.0-SNAPSHOT</version>
<name>INF101 Grid Lab</name>
<packaging>jar</packaging>
<properties>
<!-- General project properties -->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>17</java.version>
<!-- Properties required for packaging application as JAR and installer -->
<app.main.class>${groupId}.Main</app.main.class> <!-- name of main class -->
<app.vendor>Torstein Strømme</app.vendor> <!-- replace with your name -->
<app.version>1.0.0</app.version> <!-- version displayed in "about" -->
<app.installer.macosx.type>dmg</app.installer.macosx.type> <!-- dmg, pkg -->
<app.installer.windows.type>msi</app.installer.windows.type> <!-- msi, exe -->
<app.macosx.icon.path>src/main/logo/macosx/logo.icns</app.macosx.icon.path>
<app.windows.icon.path>src/main/logo/windows/logo.ico</app.windows.icon.path>
<!-- Library and plugin versions -->
<junit.version>5.9.1</junit.version>
<maven.compiler.plugin.version>3.10.1</maven.compiler.plugin.version>
<maven.dependency.plugin.version>3.4.0</maven.dependency.plugin.version>
<maven.jar.plugin.version>3.3.0</maven.jar.plugin.version>
<maven.surefire.plugin.version>3.0.0-M5</maven.surefire.plugin.version>
<exec.maven.plugin.version>1.6.0</exec.maven.plugin.version>
<!-- Computed properties -->
<maven.compiler.release>${java.version}</maven.compiler.release>
</properties>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>${maven.compiler.plugin.version}</version>
<configuration>
<release>${java.version}</release>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>${maven.dependency.plugin.version}</version>
<executions>
<execution>
<id>copy-dependencies</id>
<phase>prepare-package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>
${project.build.directory}/libs
</outputDirectory>
<overWriteReleases>false</overWriteReleases>
<overWriteSnapshots>false</overWriteSnapshots>
<overWriteIfNewer>true</overWriteIfNewer>
<includeScope>compile</includeScope>
<includeScope>runtime</includeScope>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>${maven.jar.plugin.version}</version>
<configuration>
<archive>
<index>true</index>
<manifest>
<addClasspath>true</addClasspath>
<mainClass>${app.main.class}</mainClass>
</manifest>
</archive>
</configuration>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${maven.surefire.plugin.version}</version>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>${junit.version}</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
<profiles>
<profile>
<id>build-mac</id>
<activation>
<os><family>mac</family></os>
</activation>
<build>
<plugins>
<plugin>
<artifactId>exec-maven-plugin</artifactId>
<groupId>org.codehaus.mojo</groupId>
<version>${exec.maven.plugin.version}</version>
<executions>
<execution>
<id>Build Native Mac App</id>
<phase>install</phase>
<goals>
<goal>exec</goal>
</goals>
</execution>
</executions>
<configuration>
<workingDirectory>${project.basedir}</workingDirectory>
<executable>./make/build_app_mac.sh</executable>
<environmentVariables>
<APP_PACKAGE>${project.groupId}</APP_PACKAGE>
<ABOUT_NAME>${project.name}</ABOUT_NAME>
<APP_VENDOR>${app.vendor}</APP_VENDOR>
<APP_VERSION>${app.version}</APP_VERSION>
<ICON_PATH>${app.macosx.icon.path}</ICON_PATH>
<INSTALLER_TYPE>${app.installer.macosx.type}</INSTALLER_TYPE>
<JAVA_HOME>${java.home}</JAVA_HOME>
<JAVA_VERSION>${java.version}</JAVA_VERSION>
<MAIN_CLASS>${app.main.class}</MAIN_CLASS>
<MAIN_JAR>${project.artifactId}-${project.version}.jar</MAIN_JAR>
<PROJECT_NAME>${project.name}</PROJECT_NAME>
<PROJECT_VERSION>${project.version}</PROJECT_VERSION>
</environmentVariables>
</configuration>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>build-windows</id>
<activation>
<os><family>windows</family></os>
</activation>
<build>
<plugins>
<plugin>
<artifactId>exec-maven-plugin</artifactId>
<groupId>org.codehaus.mojo</groupId>
<version>${exec.maven.plugin.version}</version>
<executions>
<execution>
<id>Build Native Windows App</id>
<phase>install</phase>
<goals>
<goal>exec</goal>
</goals>
</execution>
</executions>
<configuration>
<workingDirectory>${project.basedir}</workingDirectory>
<executable>./make/build_app_windows.bat</executable>
<environmentVariables>
<APP_PACKAGE>${project.groupId}</APP_PACKAGE>
<APP_VENDOR>${app.vendor}</APP_VENDOR>
<APP_VERSION>${app.version}</APP_VERSION>
<ICON_PATH>${app.windows.icon.path}</ICON_PATH>
<INSTALLER_TYPE>${app.installer.windows.type}</INSTALLER_TYPE>
<JAVA_HOME>${java.home}</JAVA_HOME>
<JAVA_VERSION>${java.version}</JAVA_VERSION>
<MAIN_JAR>${project.artifactId}-${project.version}.jar</MAIN_JAR>
<MAIN_CLASS>${app.main.class}</MAIN_CLASS>
<PROJECT_NAME>${project.name}</PROJECT_NAME>
<PROJECT_VERSION>${project.version}</PROJECT_VERSION>
</environmentVariables>
</configuration>
</plugin>
</plugins>
</build>
</profile>
</profiles>
</project>
package no.uib.inf101.colorgrid;
import java.awt.Color;
/**
* A CellColor contains a CellPosition and a Color.
*
* @param cellPosition the position of the cell
* @param color the color of the cell
*/
public record CellColor(CellPosition cellPosition, Color color) { }
package no.uib.inf101.colorgrid;
import java.util.List;
/**
* Objects in a class extending CellColorCollection can assemble a list
* of CellColor objects through the getCells() method.
*/
public interface CellColorCollection {
/**
* Get a list containing the GridCell objects in this collection
*
* @return a list of all GridCell objects in this collection
*/
List<CellColor> getCells();
}
package no.uib.inf101.colorgrid;
/**
* A CellPosition consists of a row and a column.
*
* @param row the row of the cell
* @param col the column of the cell
*/
public record CellPosition(int row, int col) {}
package no.uib.inf101.colorgrid;
public class ColorGrid {
// TODO: Implement this class
}
package no.uib.inf101.colorgrid;
/**
* A grid dimension is a pair of integers representing the number of
* rows and columns in a grid.
*/
public interface GridDimension {
/** Number of rows in the grid. */
int rows();
/** Number of columns in the grid. */
int cols();
}
package no.uib.inf101.colorgrid;
import java.awt.Color;
public interface IColorGrid extends GridDimension, CellColorCollection {
/**
* Get the color of the cell at the given position.
*
* @param pos the position
* @return the color of the cell
* @throws IndexOutOfBoundsException if the position is out of bounds
*/
Color get(CellPosition pos);
/**
* Set the color of the cell at the given position.
*
* @param pos the position
* @param color the new color
* @throws IndexOutOfBoundsException if the position is out of bounds
*/
void set(CellPosition pos, Color color);
}
\ No newline at end of file
package no.uib.inf101.colorgrid;
public final class TextQuestions {
/**
* Consider the interface IColorGrid, and notice how it extends the
* interfaces GridDimension and CellColorCollection.
*
* How many methods does a class implementing IColorGrid need to
* implement at minimum?
*/
static final Integer a1 = null;
/**
* Consider the interface IColorGrid, and notice how it extends the
* interfaces GridDimension and CellColorCollection.
*
* true or false: If an object has the type IColorGrid, it must
* also have the type CellColorCollection.
*/
static final Boolean a2 = null;
/**
* Consider the interface IColorGrid, and notice how it extends the
* interfaces GridDimension and CellColorCollection.
*
* true or false: If an object has the type CellColorCollection, it
* must also have the type IColorGrid.
*/
static final Boolean a3 = null;
/**
* Consider the interface IColorGrid, and notice how it extends the
* interfaces GridDimension and CellColorCollection.
*
* true or false: If an object has the type GridDimension, it
* must also have the type CellColorCollection.
*/
static final Boolean a4 = null;
/**
* Consider the interface IColorGrid, and notice how it extends the
* interfaces GridDimension and CellColorCollection.
*
* true or false: for an object to have the type IColorGrid, it must
* belong to a class that implements the interface IColorGrid.
*/
static final Boolean a5 = null;
/**
* Consider the interface IColorGrid, and notice how it extends the
* interfaces GridDimension and CellColorCollection.
*
* true or false: for a class to inherit the type GridDimension, it is
* sufficient to implements IColorGrid.
*/
static final Boolean a6 = null;
}
package no.uib.inf101.gridview;
public class CellPositionToPixelConverter {
// TODO: Implement this class
}
package no.uib.inf101.gridview;
public class GridView {
// TODO: Implement this class
}
package no.uib.inf101.gridview;
public class Main {
public static void main(String[] args) {
// TODO: Implement this method
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment