First draft

README.md

+# 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

make/build_app_mac.sh

+#!/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 \

make/build_app_windows.bat

+@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

+<?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>

src/main/java/no/uib/inf101/colorgrid/CellColor.java

+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) { }

src/main/java/no/uib/inf101/colorgrid/CellColorCollection.java

+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();
+
+}

src/main/java/no/uib/inf101/colorgrid/CellPosition.java

+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) {}

src/main/java/no/uib/inf101/colorgrid/ColorGrid.java

+package no.uib.inf101.colorgrid;
+
+public class ColorGrid {
+  // TODO: Implement this class
+}

src/main/java/no/uib/inf101/colorgrid/GridDimension.java

+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();
+
+}

src/main/java/no/uib/inf101/colorgrid/IColorGrid.java

+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

src/main/java/no/uib/inf101/colorgrid/TextQuestions.java

+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;
+}

src/main/java/no/uib/inf101/gridview/CellPositionToPixelConverter.java

+package no.uib.inf101.gridview;
+
+public class CellPositionToPixelConverter {
+  // TODO: Implement this class
+}

src/main/java/no/uib/inf101/gridview/GridView.java

+package no.uib.inf101.gridview;
+
+public class GridView {
+  // TODO: Implement this class
+}

src/main/java/no/uib/inf101/gridview/Main.java

+package no.uib.inf101.gridview;
+
+public class Main {
+  public static void main(String[] args) {
+    // TODO: Implement this method
+  }
+}