Added a lot of icons to all context menus & separated Color/SoundSource (s)

lib/ocelot-brain

@@ -1 +1 @@
-Subproject commit 8222b1287c40965622fffcdeff4ae93f5d0418b5
+Subproject commit db1a8c3ac5ebc247086327303a47313456a4e987

src/main/resources/ocelot/desktop/colorscheme.txt

@@ -24,11 +24,12 @@ Connection       = #909090
 NodeSelectorRing       = #4c7f66
 NodeSelectorBackground = #00000066
 
-ContextMenuBackground = #222222cc
+ContextMenuBackground = #222222ee
 ContextMenuBorder     = #444444
 ContextMenuText       = #b0b0b0
-ContextMenuHover      = #333333
+ContextMenuHover      = #363636
 ContextMenuSeparator  = #444444
+ContextMenuIcon       = #7F7F7F
 
 ComponentSelectorBackground = #222222cc
 ComponentSelectorBorder     = #444444

src/main/resources/ocelot/desktop/images/spritesheet/spritesheet.txt

@@ -1,251 +1,273 @@
 BackgroundPattern 0 0 304 304
-BarSegment 69 479 16 4
+BarSegment 459 479 16 4
-Empty 426 305 16 16
+Empty 473 277 16 16
-EmptySlot 404 330 18 18
+EmptySlot 233 379 18 18
-Knob 459 208 50 50
+Knob 447 208 50 50
-KnobCenter 406 129 50 50
+KnobCenter 233 305 50 50
-KnobLimits 457 129 50 50
+KnobLimits 284 305 50 50
-ShadowBorder 505 0 1 24
+ShadowBorder 497 305 1 24
-ShadowCorner 301 305 24 24
+ShadowCorner 372 305 24 24
-TabArrow 16 479 8 14
+TabArrow 85 496 8 14
-blocks/Generic 443 305 16 16
+blocks/Generic 490 277 16 16
-blocks/HologramEffect 507 18 4 4
+blocks/HologramEffect 277 498 4 4
-blocks/HologramProjector1Top 460 305 16 16
+blocks/HologramProjector1Top 486 129 16 16
-blocks/HologramProjector2Top 477 305 16 16
+blocks/HologramProjector2Top 486 146 16 16
-blocks/HologramProjectorSide 494 305 16 16
+blocks/HologramProjectorSide 486 163 16 16
-buttons/BottomDrawerClose 423 330 18 18
+buttons/BottomDrawerClose 252 379 18 18
-buttons/BottomDrawerOpen 442 330 18 18
+buttons/BottomDrawerOpen 271 379 18 18
-buttons/OpenFMRadioCloseOff 502 117 7 8
+buttons/OpenFMRadioCloseOff 248 496 7 8
-buttons/OpenFMRadioCloseOn 131 494 7 8
+buttons/OpenFMRadioCloseOn 256 496 7 8
-buttons/OpenFMRadioRedstoneOff 502 72 8 8
+buttons/OpenFMRadioRedstoneOff 203 496 8 8
-buttons/OpenFMRadioRedstoneOn 502 81 8 8
+buttons/OpenFMRadioRedstoneOn 212 496 8 8
-buttons/OpenFMRadioStartOff 326 305 24 24
+buttons/OpenFMRadioStartOff 397 305 24 24
-buttons/OpenFMRadioStartOn 351 305 24 24
+buttons/OpenFMRadioStartOn 422 305 24 24
-buttons/OpenFMRadioStopOff 376 305 24 24
+buttons/OpenFMRadioStopOff 447 305 24 24
-buttons/OpenFMRadioStopOn 401 305 24 24
+buttons/OpenFMRadioStopOn 472 305 24 24
-buttons/OpenFMRadioVolumeDownOff 25 479 10 10
+buttons/OpenFMRadioVolumeDownOff 130 496 10 10
-buttons/OpenFMRadioVolumeDownOn 36 479 10 10
+buttons/OpenFMRadioVolumeDownOn 141 496 10 10
-buttons/OpenFMRadioVolumeUpOff 47 479 10 10
+buttons/OpenFMRadioVolumeUpOff 152 496 10 10
-buttons/OpenFMRadioVolumeUpOn 58 479 10 10
+buttons/OpenFMRadioVolumeUpOn 163 496 10 10
-buttons/PowerOff 461 330 18 18
+buttons/PowerOff 290 379 18 18
-buttons/PowerOn 480 330 18 18
+buttons/PowerOn 309 379 18 18
-icons/ButtonCheck 301 378 17 17
+icons/Antenna 486 180 16 16
-icons/ButtonClipboard 319 378 17 17
+icons/AspectRatio 0 411 16 16
-icons/ButtonRandomize 337 378 17 17
+icons/ButtonCheck 447 259 17 17
-icons/CPU 406 180 16 16
+icons/ButtonClipboard 465 259 17 17
-icons/Card 423 180 16 16
+icons/ButtonRandomize 483 259 17 17
-icons/Close 0 479 15 14
+icons/CPU 17 411 16 16
-icons/ComponentBus 440 180 16 16
+icons/Card 34 411 16 16
-icons/DragLMB 301 363 21 14
+icons/Close 0 496 15 14
-icons/DragRMB 323 363 21 14
+icons/Code 51 411 16 16
-icons/EEPROM 457 180 16 16
+icons/ComponentBus 68 411 16 16
-icons/Floppy 474 180 16 16
+icons/Copy 85 411 16 16
-icons/Grid 335 330 22 22
+icons/Cross 102 411 16 16
-icons/GridOff 358 330 22 22
+icons/Delete 119 411 16 16
-icons/HDD 491 180 16 16
+icons/DragLMB 302 356 21 14
-icons/Home 381 330 22 22
+icons/DragRMB 324 356 21 14
-icons/LMB 71 494 11 14
+icons/EEPROM 136 411 16 16
-icons/Memory 459 259 16 16
+icons/Edit 153 411 16 16
-icons/NA 476 259 16 16
+icons/Eject 170 411 16 16
-icons/NotificationError 95 494 11 11
+icons/File 187 411 16 16
-icons/NotificationInfo 107 494 11 11
+icons/Floppy 204 411 16 16
-icons/NotificationWarning 119 494 11 11
+icons/Folder 221 411 16 16
-icons/Pin 26 494 14 14
+icons/FolderSlash 238 411 16 16
-icons/RMB 83 494 11 14
+icons/Grid 233 356 22 22
-icons/Server 493 259 16 16
+icons/GridOff 256 356 22 22
-icons/SettingsSound 0 494 12 17
+icons/HDD 255 411 16 16
-icons/SettingsUI 13 494 12 17
+icons/Home 279 356 22 22
-icons/Tier0 379 279 16 16
+icons/LMB 61 496 11 14
-icons/Tier1 396 279 16 16
+icons/Label 272 411 16 16
-icons/Tier2 413 279 16 16
+icons/Link 289 411 16 16
-icons/Unpin 41 494 14 14
+icons/LinkSlash 306 411 16 16
-icons/WaveLFSR 359 462 24 10
+icons/Memory 323 411 16 16
-icons/WaveNoise 384 462 24 10
+icons/Microchip 340 411 16 16
-icons/WaveSawtooth 409 462 24 10
+icons/NA 357 411 16 16
-icons/WaveSine 434 462 24 10
+icons/NotificationError 94 496 11 11
-icons/WaveSquare 459 462 24 10
+icons/NotificationInfo 106 496 11 11
-icons/WaveTriangle 484 462 24 10
+icons/NotificationWarning 118 496 11 11
-icons/WireArrowLeft 507 0 4 8
+icons/Pin 16 496 14 14
-icons/WireArrowRight 507 9 4 8
+icons/Plus 374 411 16 16
-items/APU0 233 305 16 96
+icons/Power 391 411 16 16
-items/APU1 250 305 16 96
+icons/RMB 73 496 11 14
-items/APU2 267 305 16 96
+icons/Restart 408 411 16 16
-items/CPU0 430 279 16 16
+icons/Save 425 411 16 16
-items/CPU1 447 279 16 16
+icons/SaveAs 442 411 16 16
-items/CPU2 464 279 16 16
+icons/Server 459 411 16 16
-items/CardBase 481 279 16 16
+icons/SettingsSound 447 277 12 17
-items/CircuitBoard 0 411 16 16
+icons/SettingsUI 460 277 12 17
-items/ComponentBus0 17 411 16 16
+icons/Tier0 476 411 16 16
-items/ComponentBus1 34 411 16 16
+icons/Tier1 493 411 16 16
-items/ComponentBus2 51 411 16 16
+icons/Tier2 0 428 16 16
-items/ComponentBus3 68 411 16 16
+icons/Tiers 17 428 16 16
+icons/Unpin 31 496 14 14
+icons/WaveLFSR 335 344 24 10
+icons/WaveNoise 360 344 24 10
+icons/WaveSawtooth 385 344 24 10
+icons/WaveSine 410 344 24 10
+icons/WaveSquare 435 344 24 10
+icons/WaveTriangle 460 344 24 10
+icons/Window 34 428 16 16
+icons/WireArrowLeft 264 496 4 8
+icons/WireArrowRight 269 496 4 8
+items/APU0 305 208 16 96
+items/APU1 322 208 16 96
+items/APU2 339 208 16 96
+items/CPU0 51 428 16 16
+items/CPU1 68 428 16 16
+items/CPU2 85 428 16 16
+items/CardBase 102 428 16 16
+items/CircuitBoard 119 428 16 16
+items/ComponentBus0 136 428 16 16
+items/ComponentBus1 153 428 16 16
+items/ComponentBus2 170 428 16 16
+items/ComponentBus3 187 428 16 16
 items/DataCard0 434 0 16 128
 items/DataCard1 451 0 16 128
 items/DataCard2 468 0 16 128
-items/DebugCard 85 411 16 16
+items/DebugCard 204 428 16 16
-items/DiskDriveMountable 102 411 16 16
+items/DiskDriveMountable 221 428 16 16
-items/EEPROM 119 411 16 16
+items/EEPROM 238 428 16 16
-items/FloppyDisk_dyeBlack 136 411 16 16
+items/FloppyDisk_dyeBlack 255 428 16 16
-items/FloppyDisk_dyeBlue 153 411 16 16
+items/FloppyDisk_dyeBlue 272 428 16 16
-items/FloppyDisk_dyeBrown 170 411 16 16
+items/FloppyDisk_dyeBrown 289 428 16 16
-items/FloppyDisk_dyeCyan 187 411 16 16
+items/FloppyDisk_dyeCyan 306 428 16 16
-items/FloppyDisk_dyeGray 204 411 16 16
+items/FloppyDisk_dyeGray 323 428 16 16
-items/FloppyDisk_dyeGreen 221 411 16 16
+items/FloppyDisk_dyeGreen 340 428 16 16
-items/FloppyDisk_dyeLightBlue 238 411 16 16
+items/FloppyDisk_dyeLightBlue 357 428 16 16
-items/FloppyDisk_dyeLightGray 255 411 16 16
+items/FloppyDisk_dyeLightGray 374 428 16 16
-items/FloppyDisk_dyeLime 272 411 16 16
+items/FloppyDisk_dyeLime 391 428 16 16
-items/FloppyDisk_dyeMagenta 289 411 16 16
+items/FloppyDisk_dyeMagenta 408 428 16 16
-items/FloppyDisk_dyeOrange 306 411 16 16
+items/FloppyDisk_dyeOrange 425 428 16 16
-items/FloppyDisk_dyePink 323 411 16 16
+items/FloppyDisk_dyePink 442 428 16 16
-items/FloppyDisk_dyePurple 340 411 16 16
+items/FloppyDisk_dyePurple 459 428 16 16
-items/FloppyDisk_dyeRed 357 411 16 16
+items/FloppyDisk_dyeRed 476 428 16 16
-items/FloppyDisk_dyeWhite 374 411 16 16
+items/FloppyDisk_dyeWhite 493 428 16 16
-items/FloppyDisk_dyeYellow 391 411 16 16
+items/FloppyDisk_dyeYellow 0 445 16 16
-items/GraphicsCard0 408 411 16 16
+items/GraphicsCard0 17 445 16 16
-items/GraphicsCard1 425 411 16 16
+items/GraphicsCard1 34 445 16 16
-items/GraphicsCard2 442 411 16 16
+items/GraphicsCard2 51 445 16 16
-items/HardDiskDrive0 459 411 16 16
+items/HardDiskDrive0 68 445 16 16
-items/HardDiskDrive1 476 411 16 16
+items/HardDiskDrive1 85 445 16 16
-items/HardDiskDrive2 493 411 16 16
+items/HardDiskDrive2 102 445 16 16
-items/InternetCard 301 330 16 32
+items/InternetCard 338 305 16 32
-items/LinkedCard 284 305 16 96
+items/LinkedCard 356 208 16 96
-items/Memory0 0 428 16 16
+items/Memory0 119 445 16 16
-items/Memory1 17 428 16 16
+items/Memory1 136 445 16 16
-items/Memory2 34 428 16 16
+items/Memory2 153 445 16 16
-items/Memory3 51 428 16 16
+items/Memory3 170 445 16 16
-items/Memory4 68 428 16 16
+items/Memory4 187 445 16 16
-items/Memory5 85 428 16 16
+items/Memory5 204 445 16 16
-items/NetworkCard 102 428 16 16
+items/NetworkCard 221 445 16 16
-items/RedstoneCard0 119 428 16 16
+items/RedstoneCard0 238 445 16 16
-items/RedstoneCard1 136 428 16 16
+items/RedstoneCard1 255 445 16 16
-items/SelfDestructingCard 318 330 16 32
+items/SelfDestructingCard 355 305 16 32
-items/Server0 153 428 16 16
+items/Server0 272 445 16 16
-items/Server1 170 428 16 16
+items/Server1 289 445 16 16
-items/Server2 187 428 16 16
+items/Server2 306 445 16 16
-items/Server3 204 428 16 16
+items/Server3 323 445 16 16
 items/SoundCard 485 0 16 128
-items/WirelessNetworkCard0 221 428 16 16
+items/WirelessNetworkCard0 340 445 16 16
-items/WirelessNetworkCard1 238 428 16 16
+items/WirelessNetworkCard1 357 445 16 16
-light-panel/BookmarkLeft 340 462 18 14
+light-panel/BookmarkLeft 328 379 18 14
-light-panel/BookmarkRight 355 378 20 14
+light-panel/BookmarkRight 346 356 20 14
-light-panel/BorderB 139 494 4 4
+light-panel/BorderB 282 498 4 4
-light-panel/BorderL 229 494 4 2
+light-panel/BorderL 372 498 4 2
-light-panel/BorderR 144 494 4 4
+light-panel/BorderR 287 498 4 4
-light-panel/BorderT 149 494 4 4
+light-panel/BorderT 292 498 4 4
-light-panel/CornerBL 154 494 4 4
+light-panel/CornerBL 297 498 4 4
-light-panel/CornerBR 159 494 4 4
+light-panel/CornerBR 302 498 4 4
-light-panel/CornerTL 164 494 4 4
+light-panel/CornerTL 307 498 4 4
-light-panel/CornerTR 169 494 4 4
+light-panel/CornerTR 312 498 4 4
-light-panel/Fill 88 479 2 2
+light-panel/Fill 492 479 2 2
-light-panel/Vent 502 0 2 38
+light-panel/Vent 335 305 2 38
-nodes/Cable 502 90 8 8
+nodes/Cable 221 496 8 8
-nodes/Camera 255 428 16 16
+nodes/Camera 374 445 16 16
-nodes/Chest 56 494 14 14
+nodes/Chest 46 496 14 14
-nodes/HologramProjector0 272 428 16 16
+nodes/HologramProjector0 391 445 16 16
-nodes/HologramProjector1 289 428 16 16
+nodes/HologramProjector1 408 445 16 16
-nodes/IronNoteBlock 306 428 16 16
+nodes/IronNoteBlock 425 445 16 16
-nodes/Lamp 323 428 16 16
+nodes/Lamp 442 445 16 16
-nodes/LampFrame 340 428 16 16
+nodes/LampFrame 459 445 16 16
 nodes/LampGlow 305 0 128 128
-nodes/NewNode 357 428 16 16
+nodes/NewNode 476 445 16 16
-nodes/NoteBlock 374 428 16 16
+nodes/NoteBlock 493 445 16 16
-nodes/OpenFMRadio 391 428 16 16
+nodes/OpenFMRadio 0 462 16 16
-nodes/Relay 408 428 16 16
+nodes/Relay 17 462 16 16
-nodes/computer/Activity 425 428 16 16
+nodes/computer/Activity 34 462 16 16
-nodes/computer/Default 442 428 16 16
+nodes/computer/Default 51 462 16 16
-nodes/computer/Error 459 428 16 16
+nodes/computer/Error 68 462 16 16
-nodes/computer/On 476 428 16 16
+nodes/computer/On 85 462 16 16
-nodes/disk-drive/Activity 493 428 16 16
+nodes/disk-drive/Activity 102 462 16 16
-nodes/disk-drive/Default 0 445 16 16
+nodes/disk-drive/Default 119 462 16 16
-nodes/disk-drive/Floppy 17 445 16 16
+nodes/disk-drive/Floppy 136 462 16 16
-nodes/rack/Default 34 445 16 16
+nodes/rack/Default 153 462 16 16
-nodes/rack/Empty 51 445 16 16
+nodes/rack/Empty 170 462 16 16
-nodes/rack/drive/0/Activity 68 445 16 16
+nodes/rack/drive/0/Activity 187 462 16 16
-nodes/rack/drive/0/Default 85 445 16 16
+nodes/rack/drive/0/Default 204 462 16 16
-nodes/rack/drive/0/Floppy 102 445 16 16
+nodes/rack/drive/0/Floppy 221 462 16 16
-nodes/rack/drive/1/Activity 119 445 16 16
+nodes/rack/drive/1/Activity 238 462 16 16
-nodes/rack/drive/1/Default 136 445 16 16
+nodes/rack/drive/1/Default 255 462 16 16
-nodes/rack/drive/1/Floppy 153 445 16 16
+nodes/rack/drive/1/Floppy 272 462 16 16
-nodes/rack/drive/2/Activity 170 445 16 16
+nodes/rack/drive/2/Activity 289 462 16 16
-nodes/rack/drive/2/Default 187 445 16 16
+nodes/rack/drive/2/Default 306 462 16 16
-nodes/rack/drive/2/Floppy 204 445 16 16
+nodes/rack/drive/2/Floppy 323 462 16 16
-nodes/rack/drive/3/Activity 221 445 16 16
+nodes/rack/drive/3/Activity 340 462 16 16
-nodes/rack/drive/3/Default 238 445 16 16
+nodes/rack/drive/3/Default 357 462 16 16
-nodes/rack/drive/3/Floppy 255 445 16 16
+nodes/rack/drive/3/Floppy 374 462 16 16
-nodes/rack/drive/Floppy 272 445 16 16
+nodes/rack/drive/Floppy 391 462 16 16
-nodes/rack/server/0/Activity 289 445 16 16
+nodes/rack/server/0/Activity 408 462 16 16
-nodes/rack/server/0/Default 306 445 16 16
+nodes/rack/server/0/Default 425 462 16 16
-nodes/rack/server/0/Error 323 445 16 16
+nodes/rack/server/0/Error 442 462 16 16
-nodes/rack/server/0/On 340 445 16 16
+nodes/rack/server/0/On 459 462 16 16
-nodes/rack/server/1/Activity 357 445 16 16
+nodes/rack/server/1/Activity 476 462 16 16
-nodes/rack/server/1/Default 374 445 16 16
+nodes/rack/server/1/Default 493 462 16 16
-nodes/rack/server/1/Error 391 445 16 16
+nodes/rack/server/1/Error 0 479 16 16
-nodes/rack/server/1/On 408 445 16 16
+nodes/rack/server/1/On 17 479 16 16
-nodes/rack/server/2/Activity 425 445 16 16
+nodes/rack/server/2/Activity 34 479 16 16
-nodes/rack/server/2/Default 442 445 16 16
+nodes/rack/server/2/Default 51 479 16 16
-nodes/rack/server/2/Error 459 445 16 16
+nodes/rack/server/2/Error 68 479 16 16
-nodes/rack/server/2/On 476 445 16 16
+nodes/rack/server/2/On 85 479 16 16
-nodes/rack/server/3/Activity 493 445 16 16
+nodes/rack/server/3/Activity 102 479 16 16
-nodes/rack/server/3/Default 0 462 16 16
+nodes/rack/server/3/Default 119 479 16 16
-nodes/rack/server/3/Error 17 462 16 16
+nodes/rack/server/3/Error 136 479 16 16
-nodes/rack/server/3/On 34 462 16 16
+nodes/rack/server/3/On 153 479 16 16
-nodes/screen/BottomLeft 51 462 16 16
+nodes/screen/BottomLeft 170 479 16 16
-nodes/screen/BottomMiddle 68 462 16 16
+nodes/screen/BottomMiddle 187 479 16 16
-nodes/screen/BottomRight 85 462 16 16
+nodes/screen/BottomRight 204 479 16 16
-nodes/screen/ColumnBottom 102 462 16 16
+nodes/screen/ColumnBottom 221 479 16 16
-nodes/screen/ColumnMiddle 119 462 16 16
+nodes/screen/ColumnMiddle 238 479 16 16
-nodes/screen/ColumnTop 136 462 16 16
+nodes/screen/ColumnTop 255 479 16 16
-nodes/screen/Middle 153 462 16 16
+nodes/screen/Middle 272 479 16 16
-nodes/screen/MiddleLeft 170 462 16 16
+nodes/screen/MiddleLeft 289 479 16 16
-nodes/screen/MiddleRight 187 462 16 16
+nodes/screen/MiddleRight 306 479 16 16
-nodes/screen/PowerOnOverlay 204 462 16 16
+nodes/screen/PowerOnOverlay 323 479 16 16
-nodes/screen/RowLeft 221 462 16 16
+nodes/screen/RowLeft 340 479 16 16
-nodes/screen/RowMiddle 238 462 16 16
+nodes/screen/RowMiddle 357 479 16 16
-nodes/screen/RowRight 255 462 16 16
+nodes/screen/RowRight 374 479 16 16
-nodes/screen/Standalone 272 462 16 16
+nodes/screen/Standalone 391 479 16 16
-nodes/screen/TopLeft 289 462 16 16
+nodes/screen/TopLeft 408 479 16 16
-nodes/screen/TopMiddle 306 462 16 16
+nodes/screen/TopMiddle 425 479 16 16
-nodes/screen/TopRight 323 462 16 16
+nodes/screen/TopRight 442 479 16 16
-panel/BorderB 174 494 4 4
+panel/BorderB 317 498 4 4
-panel/BorderL 234 494 4 2
+panel/BorderL 377 498 4 2
-panel/BorderR 179 494 4 4
+panel/BorderR 322 498 4 4
-panel/BorderT 184 494 4 4
+panel/BorderT 327 498 4 4
-panel/CornerBL 189 494 4 4
+panel/CornerBL 332 498 4 4
-panel/CornerBR 194 494 4 4
+panel/CornerBR 337 498 4 4
-panel/CornerTL 199 494 4 4
+panel/CornerTL 342 498 4 4
-panel/CornerTR 204 494 4 4
+panel/CornerTR 347 498 4 4
-panel/Fill 91 479 2 2
+panel/Fill 495 479 2 2
-particles/Note 502 61 7 10
+particles/Note 192 496 7 10
-screen/BorderB 508 25 2 8
+screen/BorderB 274 496 2 8
-screen/BorderT 505 25 2 10
+screen/BorderT 200 496 2 10
-screen/CornerBL 502 99 8 8
+screen/CornerBL 230 496 8 8
-screen/CornerBR 502 108 8 8
+screen/CornerBR 239 496 8 8
-screen/CornerTL 502 39 8 10
+screen/CornerTL 174 496 8 10
-screen/CornerTR 502 50 8 10
+screen/CornerTR 183 496 8 10
-window/BorderDark 510 117 1 4
+window/BorderDark 476 479 1 4
-window/BorderLight 86 479 1 4
+window/BorderLight 478 479 1 4
-window/CornerBL 209 494 4 4
+window/CornerBL 352 498 4 4
-window/CornerBR 214 494 4 4
+window/CornerBR 357 498 4 4
-window/CornerTL 219 494 4 4
+window/CornerTL 362 498 4 4
-window/CornerTR 224 494 4 4
+window/CornerTR 367 498 4 4
 window/OpenFMRadio 0 305 232 105
-window/case/Motherboard 379 208 79 70
+window/case/Motherboard 406 129 79 70
-window/rack/Lines 305 208 73 91
+window/rack/Lines 373 208 73 91
 window/rack/Motherboard 305 129 100 78
-window/rack/NetworkBack 149 499 1 2
+window/rack/NetworkBack 498 479 1 2
-window/rack/NetworkBottom 151 499 1 2
+window/rack/NetworkBottom 500 479 1 2
-window/rack/NetworkConnector 153 499 1 2
+window/rack/NetworkConnector 502 479 1 2
-window/rack/NetworkLeft 155 499 1 2
+window/rack/NetworkLeft 504 479 1 2
-window/rack/NetworkRight 157 499 1 2
+window/rack/NetworkRight 506 479 1 2
-window/rack/NetworkTop 159 499 1 2
+window/rack/NetworkTop 508 479 1 2
-window/rack/NodeBack 239 494 5 1
+window/rack/NodeBack 277 496 5 1
-window/rack/NodeBottom 245 494 5 1
+window/rack/NodeBottom 283 496 5 1
-window/rack/NodeLeft 251 494 5 1
+window/rack/NodeLeft 289 496 5 1
-window/rack/NodeRight 257 494 5 1
+window/rack/NodeRight 295 496 5 1
-window/rack/NodeTop 263 494 5 1
+window/rack/NodeTop 301 496 5 1
-window/rack/SideBack 510 122 1 3
+window/rack/SideBack 480 479 1 3
-window/rack/SideBottom 139 499 1 3
+window/rack/SideBottom 482 479 1 3
-window/rack/SideConnector 141 499 1 3
+window/rack/SideConnector 484 479 1 3
-window/rack/SideLeft 143 499 1 3
+window/rack/SideLeft 486 479 1 3
-window/rack/SideRight 145 499 1 3
+window/rack/SideRight 488 479 1 3
-window/rack/SideTop 147 499 1 3
+window/rack/SideTop 490 479 1 3

src/main/scala/ocelot/desktop/audio/SoundSource.scala

@@ -56,16 +56,6 @@ class SoundSource(val kind: SoundSource.Kind,
 }
 
 object SoundSource {
-  lazy val InterfaceClick: SoundSource = SoundSource.fromBuffer(SoundBuffers.InterfaceClick, SoundCategory.Interface)
-  lazy val InterfaceClickLow: SoundSource = SoundSource.fromBuffer(SoundBuffers.InterfaceClick, SoundCategory.Interface, pitch = 0.8f)
-  lazy val InterfaceTick: SoundSource = SoundSource.fromBuffer(SoundBuffers.InterfaceTick, SoundCategory.Interface)
-
-  lazy val MinecraftClick: SoundSource = SoundSource.fromBuffer(SoundBuffers.MinecraftClick, SoundCategory.Interface)
-  lazy val MinecraftExplosion: SoundSource = SoundSource.fromBuffer(SoundBuffers.MinecraftExplosion, SoundCategory.Environment)
-
-  lazy val MachineFloppyInsert: SoundSource = SoundSource.fromBuffer(SoundBuffers.MachineFloppyInsert, SoundCategory.Environment)
-  lazy val MachineFloppyEject: SoundSource = SoundSource.fromBuffer(SoundBuffers.MachineFloppyEject, SoundCategory.Environment)
-
   sealed trait Kind
 
   case class KindSoundBuffer(buffer: SoundBuffer) extends Kind
@@ -92,4 +82,16 @@ object SoundSource {
   object Status extends Enumeration {
     val Playing, Paused, Stopped = Value
   }
+
+  // ----------------------------------------------------------------
+
+  lazy val InterfaceClick: SoundSource = SoundSource.fromBuffer(SoundBuffers.InterfaceClick, SoundCategory.Interface)
+  lazy val InterfaceClickLow: SoundSource = SoundSource.fromBuffer(SoundBuffers.InterfaceClick, SoundCategory.Interface, pitch = 0.8f)
+  lazy val InterfaceTick: SoundSource = SoundSource.fromBuffer(SoundBuffers.InterfaceTick, SoundCategory.Interface)
+
+  lazy val MinecraftClick: SoundSource = SoundSource.fromBuffer(SoundBuffers.MinecraftClick, SoundCategory.Interface)
+  lazy val MinecraftExplosion: SoundSource = SoundSource.fromBuffer(SoundBuffers.MinecraftExplosion, SoundCategory.Environment)
+
+  lazy val MachineFloppyInsert: SoundSource = SoundSource.fromBuffer(SoundBuffers.MachineFloppyInsert, SoundCategory.Environment)
+  lazy val MachineFloppyEject: SoundSource = SoundSource.fromBuffer(SoundBuffers.MachineFloppyEject, SoundCategory.Environment)
 }

src/main/scala/ocelot/desktop/color/Color.scala

@@ -1,5 +1,15 @@
 package ocelot.desktop.color
 
+trait Color {
+  def toInt: IntColor
+
+  def toRGBA: RGBAColor
+
+  def toRGBANorm: RGBAColorNorm
+
+  def toHSVA: HSVAColor
+}
+
 object Color {
   val White: RGBAColorNorm = RGBAColorNorm(1, 1, 1)
   val Black: RGBAColorNorm = RGBAColorNorm(0, 0, 0)
@@ -10,13 +20,3 @@ object Color {
   val Grey: RGBAColorNorm = RGBAColorNorm(0.5f, 0.5f, 0.5f)
   val Transparent: RGBAColorNorm = RGBAColorNorm(0, 0, 0, 0)
 }
-
-trait Color {
-  def toInt: IntColor
-
-  def toRGBA: RGBAColor
-
-  def toRGBANorm: RGBAColorNorm
-
-  def toHSVA: HSVAColor
-}

src/main/scala/ocelot/desktop/graphics/Graphics.scala

@@ -257,12 +257,12 @@ class Graphics(private var scalingFactor: Float) extends Logging with Resource {
   }
 
   // I hate scala. Overloaded methods with default arguments are not allowed
-  def sprite(icon: IconDef, bounds: Rect2D): Unit = {
+  def sprite(icon: IconSource, bounds: Rect2D): Unit = {
-    sprite(icon.icon, bounds.x, bounds.y, bounds.w, bounds.h, icon.color, icon.animation)
+    sprite(icon.path, bounds.x, bounds.y, bounds.w, bounds.h, Color.White, icon.animation)
   }
 
-  def sprite(icon: IconDef, pos: Vector2D, size: Size2D): Unit = {
+  def sprite(icon: IconSource, pos: Vector2D, size: Size2D): Unit = {
-    sprite(icon.icon, pos.x, pos.y, size.width, size.height, icon.color, icon.animation)
+    sprite(icon.path, pos.x, pos.y, size.width, size.height, Color.White, icon.animation)
   }
 
   def sprite(name: String, bounds: Rect2D): Unit = {
@@ -287,7 +287,7 @@ class Graphics(private var scalingFactor: Float) extends Logging with Resource {
 
   def sprite(name: String, x: Float, y: Float, width: Float, height: Float,
              color: Color = RGBAColorNorm(1f, 1f, 1f),
-             animation: Option[IconDef.Animation] = None): Unit =
+             animation: Option[IconSource.Animation] = None): Unit =
   {
     sprite = name
     foreground = color

src/main/scala/ocelot/desktop/graphics/IconDef.scala

@@ -1,14 +0,0 @@
-package ocelot.desktop.graphics
-
-import ocelot.desktop.color.Color
-
-case class IconDef(
-  icon: String,
-  sizeMultiplier: Float = 2f,
-  animation: Option[IconDef.Animation] = None,
-  color: Color = Color.White
-)
-
-object IconDef {
-  type Animation = Array[(Int, Float)]
-}

src/main/scala/ocelot/desktop/graphics/IconSource.scala

@@ -0,0 +1,137 @@
+package ocelot.desktop.graphics
+
+import ocelot.desktop.ui.widget.modal.notification.NotificationType.NotificationType
+import totoro.ocelot.brain.util.DyeColor
+import totoro.ocelot.brain.util.ExtendedTier.ExtendedTier
+import totoro.ocelot.brain.util.Tier.Tier
+
+case class IconSource(
+   path: String,
+   animation: Option[IconSource.Animation] = None
+)
+
+object IconSource {
+  type Animation = Array[(Int, Float)]
+
+  val CardIcon: IconSource = IconSource("icons/Card")
+  val CpuIcon: IconSource = IconSource("icons/CPU")
+  val HddIcon: IconSource = IconSource("icons/HDD")
+  val EepromIcon: IconSource = IconSource("icons/EEPROM")
+  val FloppyIcon: IconSource = IconSource("icons/Floppy")
+  val MemoryIcon: IconSource = IconSource("icons/Memory")
+  val ServerIcon: IconSource = IconSource("icons/Server")
+  val ComponentBusIcon: IconSource = IconSource("icons/ComponentBus")
+
+  val TierIcon: Tier => IconSource = { tier =>
+    IconSource(s"icons/Tier${tier.id}")
+  }
+
+  val Cpu: Tier => IconSource = { tier =>
+    IconSource(s"items/CPU${tier.id}")
+  }
+
+  val Apu: Tier => IconSource = { tier =>
+    IconSource(s"items/APU${tier.id}", animation = Some(Animations.Apu))
+  }
+
+  val GraphicsCard: Tier => IconSource = { tier =>
+    IconSource(s"items/GraphicsCard${tier.id}")
+  }
+
+  val NetworkCard: IconSource = IconSource("items/NetworkCard")
+
+  val WirelessNetworkCard: Tier => IconSource = { tier =>
+    IconSource(s"items/WirelessNetworkCard${tier.id}")
+  }
+
+  val LinkedCard: IconSource = IconSource("items/LinkedCard", animation = Some(Animations.LinkedCard))
+
+  val InternetCard: IconSource = IconSource("items/InternetCard", animation = Some(Animations.InternetCard))
+
+  val RedstoneCard: Tier => IconSource = { tier =>
+    IconSource(s"items/RedstoneCard${tier.id}")
+  }
+
+  val DataCard: Tier => IconSource = { tier =>
+    IconSource(s"items/DataCard${tier.id}", animation = Some(Animations.DataCard))
+  }
+
+  val SoundCard: IconSource = IconSource("items/SoundCard", animation = Some(Animations.DataCard))
+
+  val SelfDestructingCard: IconSource = IconSource("items/SelfDestructingCard", animation = Some(Animations.SelfDestructingCard))
+
+  val HardDiskDrive: Tier => IconSource = { tier =>
+    IconSource(s"items/HardDiskDrive${tier.id}")
+  }
+
+  val Eeprom: IconSource = IconSource("items/EEPROM")
+
+  val FloppyDisk: DyeColor => IconSource = { color =>
+    IconSource(s"items/FloppyDisk_${color.name}")
+  }
+
+  val Memory: ExtendedTier => IconSource = { tier =>
+    IconSource(s"items/Memory${tier.id}")
+  }
+
+  val Server: Tier => IconSource = { tier =>
+    IconSource(s"items/Server${tier.id}")
+  }
+
+  val ComponentBus: Tier => IconSource = { tier =>
+    IconSource(s"items/ComponentBus${tier.id}")
+  }
+
+  val DiskDriveMountable: IconSource = IconSource("items/DiskDriveMountable")
+
+  //noinspection ScalaWeakerAccess
+  object Animations {
+    val Apu: Animation = Array(
+      (0, 3f), (1, 3f), (2, 3f), (3, 3f), (4, 3f), (5, 3f),
+      (4, 3f), (3, 3f), (2, 3f), (1, 3f), (0, 3f))
+
+    val LinkedCard: Animation =
+      Array((0, 3f), (1, 3f), (2, 3f), (3, 3f), (4, 3f), (5, 3f))
+
+    val InternetCard: Animation = Array(
+      (0, 2f), (1, 7f), (0, 5f), (1, 4f), (0, 7f), (1, 2f), (0, 8f),
+      (1, 9f), (0, 6f), (1, 4f))
+
+    val DataCard: Animation = Array(
+      (0, 4f), (1, 4f), (2, 4f), (3, 4f), (4, 4f), (5, 4f), (6, 4f), (7, 4f))
+
+    val SelfDestructingCard: Animation = Array((0, 4f), (1, 4f))
+  }
+
+  // ----------------------- Ocelot interface icons -----------------------
+
+
+  val Notification: NotificationType => IconSource = { notificationType =>
+    IconSource(s"icons/Notification$notificationType")
+  }
+
+  val SettingsSound: IconSource = IconSource("icons/SettingsSound")
+  val SettingsUI: IconSource = IconSource("icons/SettingsUI")
+  val Delete: IconSource = IconSource("icons/Delete")
+  val Label: IconSource = IconSource("icons/Label")
+  val Copy: IconSource = IconSource("icons/Copy")
+  val AspectRatio: IconSource = IconSource("icons/AspectRatio")
+  val Eject: IconSource = IconSource("icons/Eject")
+  val Restart: IconSource = IconSource("icons/Restart")
+  val Edit: IconSource = IconSource("icons/Edit")
+  val Folder: IconSource = IconSource("icons/Folder")
+  val FolderSlash: IconSource = IconSource("icons/FolderSlash")
+  val Code: IconSource = IconSource("icons/Code")
+  val File: IconSource = IconSource("icons/File")
+  val Link: IconSource = IconSource("icons/Link")
+  val LinkSlash: IconSource = IconSource("icons/LinkSlash")
+  val Power: IconSource = IconSource("icons/Power")
+  val Save: IconSource = IconSource("icons/Save")
+  val SaveAs: IconSource = IconSource("icons/SaveAs")
+  val Plus: IconSource = IconSource("icons/Plus")
+  val Cross: IconSource = IconSource("icons/Cross")
+  val Microchip: IconSource = IconSource("icons/Microchip")
+  val Antenna: IconSource = IconSource("icons/Antenna")
+  val Window: IconSource = IconSource("icons/Window")
+  val Tiers: IconSource = IconSource("icons/Tiers")
+}

src/main/scala/ocelot/desktop/graphics/Icons.scala

@@ -1,108 +0,0 @@
-package ocelot.desktop.graphics
-
-import ocelot.desktop.graphics.IconDef.Animation
-import ocelot.desktop.ui.widget.modal.notification.NotificationType.NotificationType
-import totoro.ocelot.brain.util.DyeColor
-import totoro.ocelot.brain.util.ExtendedTier.ExtendedTier
-import totoro.ocelot.brain.util.Tier.Tier
-
-object Icons {
-  // Icons
-  val CardIcon: IconDef = IconDef("icons/Card")
-  val CpuIcon: IconDef = IconDef("icons/CPU")
-  val HddIcon: IconDef = IconDef("icons/HDD")
-  val EepromIcon: IconDef = IconDef("icons/EEPROM")
-  val FloppyIcon: IconDef = IconDef("icons/Floppy")
-  val MemoryIcon: IconDef = IconDef("icons/Memory")
-  val ServerIcon: IconDef = IconDef("icons/Server")
-  val ComponentBusIcon: IconDef = IconDef("icons/ComponentBus")
-
-  val TierIcon: Tier => IconDef = { tier =>
-    IconDef(s"icons/Tier${tier.id}")
-  }
-
-  val NotificationIcon: NotificationType => IconDef = { notificationType =>
-    IconDef(s"icons/Notification$notificationType", 4)
-  }
-
-  val SettingsSound: IconDef = IconDef("icons/SettingsSound")
-  val SettingsUI: IconDef = IconDef("icons/SettingsUI")
-
-  // Items
-  val Cpu: Tier => IconDef = { tier =>
-    IconDef(s"items/CPU${tier.id}")
-  }
-
-  val Apu: Tier => IconDef = { tier =>
-    IconDef(s"items/APU${tier.id}", animation = Some(Animations.Apu))
-  }
-
-  val GraphicsCard: Tier => IconDef = { tier =>
-    IconDef(s"items/GraphicsCard${tier.id}")
-  }
-
-  val NetworkCard: IconDef = IconDef("items/NetworkCard")
-
-  val WirelessNetworkCard: Tier => IconDef = { tier =>
-    IconDef(s"items/WirelessNetworkCard${tier.id}")
-  }
-
-  val LinkedCard: IconDef = IconDef("items/LinkedCard", animation = Some(Animations.LinkedCard))
-
-  val InternetCard: IconDef = IconDef("items/InternetCard", animation = Some(Animations.InternetCard))
-
-  val RedstoneCard: Tier => IconDef = { tier =>
-    IconDef(s"items/RedstoneCard${tier.id}")
-  }
-
-  val DataCard: Tier => IconDef = { tier =>
-    IconDef(s"items/DataCard${tier.id}", animation = Some(Animations.DataCard))
-  }
-
-  val SoundCard: IconDef = IconDef("items/SoundCard", animation = Some(Animations.DataCard))
-
-  val SelfDestructingCard: IconDef = IconDef("items/SelfDestructingCard", animation = Some(Animations.SelfDestructingCard))
-
-  val HardDiskDrive: Tier => IconDef = { tier =>
-    IconDef(s"items/HardDiskDrive${tier.id}")
-  }
-
-  val Eeprom: IconDef = IconDef("items/EEPROM")
-
-  val FloppyDisk: DyeColor => IconDef = { color =>
-    IconDef(s"items/FloppyDisk_${color.name}")
-  }
-
-  val Memory: ExtendedTier => IconDef = { tier =>
-    IconDef(s"items/Memory${tier.id}")
-  }
-
-  val Server: Tier => IconDef = { tier =>
-    IconDef(s"items/Server${tier.id}")
-  }
-
-  val ComponentBus: Tier => IconDef = { tier =>
-    IconDef(s"items/ComponentBus${tier.id}")
-  }
-
-  val DiskDriveMountable: IconDef = IconDef("items/DiskDriveMountable")
-
-  //noinspection ScalaWeakerAccess
-  object Animations {
-    val Apu: Animation = Array(
-      (0, 3f), (1, 3f), (2, 3f), (3, 3f), (4, 3f), (5, 3f),
-      (4, 3f), (3, 3f), (2, 3f), (1, 3f), (0, 3f))
-
-    val LinkedCard: Animation =
-      Array((0, 3f), (1, 3f), (2, 3f), (3, 3f), (4, 3f), (5, 3f))
-
-    val InternetCard: Animation = Array(
-      (0, 2f), (1, 7f), (0, 5f), (1, 4f), (0, 7f), (1, 2f), (0, 8f),
-      (1, 9f), (0, 6f), (1, 4f))
-
-    val DataCard: Animation = Array(
-      (0, 4f), (1, 4f), (2, 4f), (3, 4f), (4, 4f), (5, 4f), (6, 4f), (7, 4f))
-
-    val SelfDestructingCard: Animation = Array((0, 4f), (1, 4f))
-  }
-}

src/main/scala/ocelot/desktop/inventory/Item.scala

@@ -2,7 +2,7 @@ package ocelot.desktop.inventory
 
 import ocelot.desktop.ColorScheme
 import ocelot.desktop.color.Color
-import ocelot.desktop.graphics.IconDef
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.event.EventAware
 import ocelot.desktop.ui.widget.Updatable
 import ocelot.desktop.ui.widget.contextmenu.ContextMenu
@@ -64,7 +64,7 @@ trait Item extends EventAware with Updatable with Disposable {
   /**
     * The icon used to draw the item in a slot.
     */
-  def icon: IconDef = factory.icon
+  def icon: IconSource = factory.icon
 
   /**
     * The tier of the item (if it has one).

src/main/scala/ocelot/desktop/inventory/ItemFactory.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory
 
-import ocelot.desktop.graphics.IconDef
+import ocelot.desktop.graphics.IconSource
 import totoro.ocelot.brain.util.Tier.Tier
 
 /**
@@ -45,7 +45,7 @@ trait ItemFactory {
     *
     * Used by the [[ocelot.desktop.ui.widget.slot.ItemChooser ItemChooser]] in its entries.
     */
-  def icon: IconDef
+  def icon: IconSource
 
   /**
     * Constructs a new item instance.

src/main/scala/ocelot/desktop/inventory/Items.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory
 
-import ocelot.desktop.graphics.IconDef
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.item._
 import ocelot.desktop.util.Logging
 import ocelot.desktop.util.ReflectionUtils.linearizationOrder
@@ -60,7 +60,7 @@ object Items extends Logging {
     }
   }
 
-  def registerArbitrary(name: String, icon: IconDef, factories: IterableOnce[(String, ItemFactory)]): Unit = {
+  def registerArbitrary(name: String, icon: IconSource, factories: IterableOnce[(String, ItemFactory)]): Unit = {
     val group = ArbitraryItemGroup(name, icon, factories.iterator.toSeq)
     _groups += group
 
@@ -93,7 +93,7 @@ object Items extends Logging {
 
   case class ExtendedTieredItemGroup(name: String, factories: Seq[(ExtendedTier, ItemFactory)]) extends ItemGroup
 
-  case class ArbitraryItemGroup(name: String, icon: IconDef, factories: Seq[(String, ItemFactory)]) extends ItemGroup
+  case class ArbitraryItemGroup(name: String, icon: IconSource, factories: Seq[(String, ItemFactory)]) extends ItemGroup
 
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 

src/main/scala/ocelot/desktop/inventory/SyncedInventory.scala

@@ -4,7 +4,7 @@ import ocelot.desktop.OcelotDesktop
 import ocelot.desktop.inventory.PersistedInventory.ItemLoadException
 import ocelot.desktop.inventory.SyncedInventory.SlotStatus.SlotStatus
 import ocelot.desktop.inventory.SyncedInventory.SyncDirection.SyncDirection
-import ocelot.desktop.inventory.SyncedInventory.{SyncDirection, _}
+import ocelot.desktop.inventory.SyncedInventory._
 import ocelot.desktop.inventory.traits.ComponentItem
 import ocelot.desktop.ui.event.BrainEvent
 import ocelot.desktop.ui.widget.EventHandlers

src/main/scala/ocelot/desktop/inventory/item/ApuItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{ComponentItem, CpuLikeItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.APU
@@ -26,7 +26,7 @@ object ApuItem {
     // we keep the latter tier internally and increment it when dealing with the rest of the world
     override def tier: Option[Tier] = Some(_tier.saturatingAdd(1))
 
-    override def icon: IconDef = Icons.Apu(_tier)
+    override def icon: IconSource = IconSource.Apu(_tier)
 
     override def build(): ApuItem = new ApuItem(new APU(_tier))
 

src/main/scala/ocelot/desktop/inventory/item/ComponentBusItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.ComponentItem
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.ComponentBus
@@ -25,7 +25,7 @@ object ComponentBusItem {
 
     override def tier: Option[Tier] = Some(_tier)
 
-    override def icon: IconDef = Icons.ComponentBus(_tier)
+    override def icon: IconSource = IconSource.ComponentBus(_tier)
 
     override def build(): ComponentBusItem = new ComponentBusItem(new ComponentBus(_tier))
 

src/main/scala/ocelot/desktop/inventory/item/CpuItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{ComponentItem, CpuLikeItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.CPU
@@ -23,7 +23,7 @@ object CpuItem {
 
     override def tier: Option[Tier] = Some(_tier)
 
-    override def icon: IconDef = Icons.Cpu(_tier)
+    override def icon: IconSource = IconSource.Cpu(_tier)
 
     override def build(): CpuItem = new CpuItem(new CPU(_tier))
 

src/main/scala/ocelot/desktop/inventory/item/DataCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.DataCard
@@ -14,7 +14,7 @@ object DataCardItem {
   abstract class Factory extends ItemFactory {
     override def name: String = s"Data Card (${tier.get.label})"
 
-    override def icon: IconDef = Icons.DataCard(tier.get)
+    override def icon: IconSource = IconSource.DataCard(tier.get)
   }
 
   class Tier1(val dataCard: DataCard.Tier1) extends DataCardItem {

src/main/scala/ocelot/desktop/inventory/item/DiskDriveMountableItem.scala

@@ -1,9 +1,8 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.{ItemFactory, ItemRecoverer}
 import ocelot.desktop.util.DiskDriveAware
-import totoro.ocelot.brain.entity.traits.{Entity, RackMountable}
 import totoro.ocelot.brain.entity.{DiskDriveMountable, FloppyDiskDrive}
 import totoro.ocelot.brain.util.Tier.Tier
 
@@ -27,7 +26,7 @@ object DiskDriveMountableItem {
 
     override def name: String = "Disk drive"
 
-    override def icon: IconDef = Icons.DiskDriveMountable
+    override def icon: IconSource = IconSource.DiskDriveMountable
 
     override def build(): DiskDriveMountableItem = new DiskDriveMountableItem(new DiskDriveMountable())
 

src/main/scala/ocelot/desktop/inventory/item/EepromItem.scala

@@ -1,11 +1,11 @@
 package ocelot.desktop.inventory.item
 
 import ocelot.desktop.OcelotDesktop
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import ocelot.desktop.ui.widget.InputDialog
-import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuSubmenu}
+import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuIcon, ContextMenuSubmenu}
 import ocelot.desktop.ui.widget.tooltip.ItemTooltip
 import totoro.ocelot.brain.entity.EEPROM
 import totoro.ocelot.brain.entity.traits.{Entity, Environment}
@@ -32,10 +32,8 @@ class EepromItem(val eeprom: EEPROM) extends Item with ComponentItem with Persis
   }
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
-    menu.addEntry(
+    menu.addEntry(new ContextMenuSubmenu("External data source", Some(ContextMenuIcon(IconSource.Code))) {
-      new ContextMenuSubmenu("External data source") {
+      addEntry(ContextMenuEntry("Local file", IconSource.File) {
-        addEntry(
-          ContextMenuEntry("Local file") {
         OcelotDesktop.showFileChooserDialog(JFileChooser.OPEN_DIALOG, JFileChooser.FILES_ONLY) { file =>
           Try {
             for (file <- file) {
@@ -43,11 +41,9 @@ class EepromItem(val eeprom: EEPROM) extends Item with ComponentItem with Persis
             }
           }
         }
-          }
+      })
-        )
 
-        addEntry(
+      addEntry(ContextMenuEntry("File via URL", IconSource.Link) {
-          ContextMenuEntry("File via URL") {
         new InputDialog(
           title = "File via URL",
           onConfirmed = { text =>
@@ -61,18 +57,14 @@ class EepromItem(val eeprom: EEPROM) extends Item with ComponentItem with Persis
               case _: MalformedURLException => false
             },
         ).show()
-          }
+      })
-        )
 
       if (eeprom.codePath.nonEmpty || eeprom.codeURL.nonEmpty) {
-          addEntry(
+        addEntry(ContextMenuEntry("Detach", IconSource.LinkSlash) {
-            ContextMenuEntry("Detach") {
           eeprom.codeBytes = Some(Array.empty)
+        })
       }
-          )
+    })
-        }
-      }
-    )
 
     super.fillRmbMenu(menu)
   }
@@ -92,7 +84,7 @@ object EepromItem {
 
     override def tier: Option[Tier] = None
 
-    override def icon: IconDef = Icons.Eeprom
+    override def icon: IconSource = IconSource.Eeprom
 
     override def recoverers: Iterable[ItemRecoverer[_, _]] = Some(ItemRecoverer(new EepromItem(_)))
   }

src/main/scala/ocelot/desktop/inventory/item/FloppyItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{ComponentItem, DiskItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import ocelot.desktop.ui.widget.contextmenu.ContextMenu
@@ -65,7 +65,7 @@ class FloppyItem(var floppy: Floppy) extends Item with ComponentItem with Persis
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
     floppy match {
-      case floppy: FloppyManaged => addSetDirectoryEntry(menu, floppy)
+      case floppy: FloppyManaged => addRealPathContextMenuEntries(menu, floppy)
       case _ => // unmanaged floppies don't need any special entries
     }
 
@@ -94,7 +94,7 @@ object FloppyItem {
 
     override def tier: Option[Tier] = None
 
-    override def icon: IconDef = Icons.FloppyDisk(color)
+    override def icon: IconSource = IconSource.FloppyDisk(color)
 
     override def recoverers: Iterable[ItemRecoverer[_, _]] = Some(ItemRecoverer(new FloppyItem(_)))
   }

src/main/scala/ocelot/desktop/inventory/item/GraphicsCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.GraphicsCard
@@ -21,7 +21,7 @@ object GraphicsCardItem {
 
     override def name: String = s"Graphics Card (${_tier.label})"
     override def tier: Option[Tier] = Some(_tier)
-    override def icon: IconDef = Icons.GraphicsCard(_tier)
+    override def icon: IconSource = IconSource.GraphicsCard(_tier)
 
     override def build(): GraphicsCardItem = new GraphicsCardItem(new GraphicsCard(_tier))
 

src/main/scala/ocelot/desktop/inventory/item/HddItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.item.HddItem.Hdd
 import ocelot.desktop.inventory.traits.{ComponentItem, DiskItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
@@ -64,10 +64,11 @@ class HddItem(var hdd: Hdd) extends Item with ComponentItem with PersistableItem
   override def fillRmbMenu(menu: ContextMenu): Unit = {
     hdd match {
       case Hdd.Managed(hdd) =>
-        addSetDirectoryEntry(menu, hdd)
+        addRealPathContextMenuEntries(menu, hdd)
 
       case _ => // unmanaged HDDs don't need any special entries
     }
+
     super.fillRmbMenu(menu)
   }
 
@@ -87,7 +88,7 @@ object HddItem {
 
     override def tier: Option[Tier] = Some(_tier)
 
-    override def icon: IconDef = Icons.HardDiskDrive(_tier)
+    override def icon: IconSource = IconSource.HardDiskDrive(_tier)
 
     override def build(): HddItem = new HddItem(
       if (managed) Hdd(new HDDManaged(_tier)) else Hdd(new HDDUnmanaged(_tier))

src/main/scala/ocelot/desktop/inventory/item/InternetCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.InternetCard
@@ -24,7 +24,7 @@ object InternetCardItem {
 
     override def tier: Option[Tier] = Some(Tier.Two)
 
-    override def icon: IconDef = Icons.InternetCard
+    override def icon: IconSource = IconSource.InternetCard
 
     override def build(): InternetCardItem = new InternetCardItem(new InternetCard)
 

src/main/scala/ocelot/desktop/inventory/item/LinkedCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import ocelot.desktop.ui.widget.TunnelDialog
@@ -22,7 +22,7 @@ class LinkedCardItem(val linkedCard: LinkedCard) extends Item with ComponentItem
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
     menu.addEntry(
-      ContextMenuEntry("Set channel") {
+      ContextMenuEntry("Set channel", IconSource.Antenna) {
         new TunnelDialog(
           tunnel => linkedCard.tunnel = tunnel,
           linkedCard.tunnel,
@@ -45,7 +45,7 @@ object LinkedCardItem {
 
     override def tier: Option[Tier] = Some(Tier.Three)
 
-    override def icon: IconDef = Icons.LinkedCard
+    override def icon: IconSource = IconSource.LinkedCard
 
     override def build(): LinkedCardItem = new LinkedCardItem(new LinkedCard)
 

src/main/scala/ocelot/desktop/inventory/item/MemoryItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.Memory
@@ -24,7 +24,7 @@ object MemoryItem {
 
     override def tier: Option[Tier] = Some(memoryTier.toTier)
 
-    override def icon: IconDef = Icons.Memory(memoryTier)
+    override def icon: IconSource = IconSource.Memory(memoryTier)
 
     override def build(): MemoryItem = new MemoryItem(new Memory(memoryTier))
 

src/main/scala/ocelot/desktop/inventory/item/NetworkCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.NetworkCard
@@ -22,7 +22,7 @@ object NetworkCardItem {
 
     override def name: String = "Network Card"
     override def tier: Option[Tier] = Some(Tier.One)
-    override def icon: IconDef = Icons.NetworkCard
+    override def icon: IconSource = IconSource.NetworkCard
 
     override def build(): NetworkCardItem = new NetworkCardItem(new NetworkCard)
 

src/main/scala/ocelot/desktop/inventory/item/RackMountableItem.scala

@@ -4,7 +4,7 @@ import ocelot.desktop.inventory.Item
 import ocelot.desktop.inventory.traits.ComponentItem
 import ocelot.desktop.node.nodes.RackNode
 import ocelot.desktop.ui.widget.contextmenu.ContextMenu
-import totoro.ocelot.brain.entity.{Rack, result}
+import totoro.ocelot.brain.entity.result
 import totoro.ocelot.brain.entity.traits.{Entity, RackMountable}
 
 trait RackMountableItem

src/main/scala/ocelot/desktop/inventory/item/RedstoneCardItem.scala

@@ -1,39 +1,41 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
-import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem, WindowProvider}
+import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import ocelot.desktop.ui.widget.card.{Redstone1Window, Redstone2Window}
-import ocelot.desktop.ui.widget.contextmenu.ContextMenu
+import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
 import ocelot.desktop.ui.widget.tooltip.ItemTooltip
-import ocelot.desktop.ui.widget.window.Window
+import ocelot.desktop.ui.widget.window.{Window, Windowed}
 import totoro.ocelot.brain.entity.Redstone
 import totoro.ocelot.brain.entity.traits.{Entity, Environment}
 import totoro.ocelot.brain.util.Tier
 import totoro.ocelot.brain.util.Tier.Tier
 
-abstract class RedstoneCardItem extends Item with ComponentItem with PersistableItem with CardItem
+abstract class RedstoneCardItem extends Item with ComponentItem with PersistableItem with CardItem with Windowed {
+  def windowContextMenuEntryName: String
+
+  override def fillRmbMenu(menu: ContextMenu): Unit = {
+    menu.addEntry(ContextMenuEntry(windowContextMenuEntryName, IconSource.Window) {
+      window.get.open()
+    })
+
+    menu.addSeparator()
+
+    super.fillRmbMenu(menu)
+  }
+}
 
 object RedstoneCardItem {
   abstract class Factory extends ItemFactory {
     override def name: String = s"Redstone Card (${tier.get.label})"
 
-    override def icon: IconDef = Icons.RedstoneCard(tier.get)
+    override def icon: IconSource = IconSource.RedstoneCard(tier.get)
   }
 
   class Tier1(val redstoneCard: Redstone.Tier1) extends RedstoneCardItem {
-    private val redstoneIoWindow: WindowProvider = new WindowProvider {
-      override def windowEntryLabel: String = "Redstone I/O"
-
-      override def makeWindow(): Window = new Redstone1Window(redstoneCard)
-    }
-
     override def component: Entity with Environment = redstoneCard
 
-    protected def addWindowEntries(menu: ContextMenu): Unit = {
-      redstoneIoWindow.fillRmbMenu(menu)
-    }
-
     override def fillTooltip(tooltip: ItemTooltip): Unit = {
       super.fillTooltip(tooltip)
 
@@ -42,12 +44,11 @@ object RedstoneCardItem {
       }
     }
 
-    override def fillRmbMenu(menu: ContextMenu): Unit = {
-      addWindowEntries(menu)
-      super.fillRmbMenu(menu)
-    }
-
     override def factory: Factory = RedstoneCardItem.Tier1.Factory
+
+    private lazy val _window = new Redstone1Window(redstoneCard)
+    override def window: Option[Window] = Some(_window)
+    override def windowContextMenuEntryName: String = "Redstone I/O"
   }
 
   object Tier1 {
@@ -65,20 +66,13 @@ object RedstoneCardItem {
   }
 
   class Tier2(override val redstoneCard: Redstone.Tier2) extends RedstoneCardItem.Tier1(redstoneCard) {
-    private val bundledIoWindow: WindowProvider = new WindowProvider {
-      override def windowEntryLabel: String = "Bundled I/O"
-
-      override def makeWindow(): Window = new Redstone2Window(redstoneCard)
-    }
-
     override def component: Entity with Environment = redstoneCard
 
-    override def addWindowEntries(menu: ContextMenu): Unit = {
-      super.addWindowEntries(menu)
-      bundledIoWindow.fillRmbMenu(menu)
-    }
-
     override def factory: Factory = RedstoneCardItem.Tier2.Factory
+
+    private lazy val _window = new Redstone2Window(redstoneCard)
+    override def window: Option[Window] = Some(_window)
+    override def windowContextMenuEntryName: String = "Bundled I/O"
   }
 
   object Tier2 {

src/main/scala/ocelot/desktop/inventory/item/SelfDestructingCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.SelfDestructingCard
@@ -29,7 +29,7 @@ object SelfDestructingCardItem {
 
     override def tier: Option[Tier] = Some(Tier.Two)
 
-    override def icon: IconDef = Icons.SelfDestructingCard
+    override def icon: IconSource = IconSource.SelfDestructingCard
 
     override def build(): SelfDestructingCardItem = new SelfDestructingCardItem(new SelfDestructingCard)
 

src/main/scala/ocelot/desktop/inventory/item/ServerItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.{ItemFactory, ItemRecoverer}
 import ocelot.desktop.ui.widget.slot._
 import ocelot.desktop.util.ComputerAware
@@ -113,7 +113,7 @@ object ServerItem {
 
     override def tier: Option[Tier] = Some(_tier)
 
-    override def icon: IconDef = Icons.Server(_tier)
+    override def icon: IconSource = IconSource.Server(_tier)
 
     override def build(): ServerItem = {
       val item = new ServerItem(new Server(_tier))

src/main/scala/ocelot/desktop/inventory/item/SoundCardItem.scala

@@ -1,27 +1,29 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
-import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem, WindowProvider}
+import ocelot.desktop.inventory.traits.{CardItem, ComponentItem, PersistableItem}
 import ocelot.desktop.inventory.{Item, ItemFactory, ItemRecoverer}
 import ocelot.desktop.ui.widget.card.SoundCardWindow
-import ocelot.desktop.ui.widget.contextmenu.ContextMenu
+import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
-import ocelot.desktop.ui.widget.window.Window
+import ocelot.desktop.ui.widget.window.{Window, Windowed}
 import totoro.ocelot.brain.entity.sound_card.SoundCard
 import totoro.ocelot.brain.entity.traits.{Entity, Environment}
 import totoro.ocelot.brain.util.Tier
 import totoro.ocelot.brain.util.Tier.Tier
 
-class SoundCardItem(val soundCard: SoundCard) extends Item with ComponentItem with PersistableItem with CardItem {
+class SoundCardItem(val soundCard: SoundCard) extends Item with ComponentItem with PersistableItem with CardItem with Windowed {
-  private val window = new WindowProvider {
+  private lazy val _window = new SoundCardWindow(soundCard)
-    override def windowEntryLabel: String = "Open"
+  override def window: Option[Window] = Some(_window)
-
-    override def makeWindow(): Window = new SoundCardWindow(soundCard)
-  }
 
   override def component: Entity with Environment = soundCard
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
-    window.fillRmbMenu(menu)
+    menu.addEntry(ContextMenuEntry("Open card interface", IconSource.Window) {
+      window.get.open()
+    })
+
+    menu.addSeparator()
+
     super.fillRmbMenu(menu)
   }
 
@@ -38,7 +40,7 @@ object SoundCardItem {
 
     override def tier: Option[Tier] = Some(Tier.Two)
 
-    override def icon: IconDef = Icons.SoundCard
+    override def icon: IconSource = IconSource.SoundCard
 
     override def build(): SoundCardItem = new SoundCardItem(new SoundCard)
 

src/main/scala/ocelot/desktop/inventory/item/WirelessNetworkCardItem.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.inventory.item
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.{ItemFactory, ItemRecoverer}
 import totoro.ocelot.brain.entity.WirelessNetworkCard
 import totoro.ocelot.brain.util.Tier
@@ -14,7 +14,7 @@ object WirelessNetworkCardItem {
   abstract class Factory extends ItemFactory {
     override def name: String = s"Wireless Net. Card (${tier.get.label})"
 
-    override def icon: IconDef = Icons.WirelessNetworkCard(tier.get)
+    override def icon: IconSource = IconSource.WirelessNetworkCard(tier.get)
   }
 
   class Tier1(override val card: WirelessNetworkCard.Tier1) extends WirelessNetworkCardItem(card) {

src/main/scala/ocelot/desktop/inventory/traits/ComponentItem.scala

@@ -1,6 +1,7 @@
 package ocelot.desktop.inventory.traits
 
 import ocelot.desktop.OcelotDesktop
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Item
 import ocelot.desktop.ui.UiHandler
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
@@ -58,7 +59,7 @@ trait ComponentItem extends Item with PersistableItem {
   }
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
-    menu.addEntry(ContextMenuEntry("Copy address") {
+    menu.addEntry(ContextMenuEntry("Copy address", IconSource.Copy) {
       UiHandler.clipboard = component.node.address
     })
 

src/main/scala/ocelot/desktop/inventory/traits/CpuLikeItem.scala

@@ -1,8 +1,9 @@
 package ocelot.desktop.inventory.traits
 
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Item
 import ocelot.desktop.inventory.traits.CpuLikeItem.CpuArchitectureChangedNotification
-import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuSubmenu}
+import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuIcon, ContextMenuSubmenu}
 import totoro.ocelot.brain.entity.machine.MachineAPI
 import totoro.ocelot.brain.entity.traits.{Entity, GenericCPU}
 
@@ -13,7 +14,7 @@ trait CpuLikeItem extends ComponentItem {
   override def component: Entity with GenericCPU
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
-    menu.addEntry(new ContextMenuSubmenu("Set architecture") {
+    menu.addEntry(new ContextMenuSubmenu("Set architecture", Some(ContextMenuIcon(IconSource.Microchip))) {
       for (arch <- component.allArchitectures) {
         val name = MachineAPI.getArchitectureName(arch) +
           (if (arch == component.architecture) " (current)" else "")

src/main/scala/ocelot/desktop/inventory/traits/DiskItem.scala

@@ -1,10 +1,11 @@
 package ocelot.desktop.inventory.traits
 
 import ocelot.desktop.OcelotDesktop
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.widget.DiskEditWindow
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
 import ocelot.desktop.ui.widget.tooltip.ItemTooltip
-import ocelot.desktop.ui.widget.window.Window
+import ocelot.desktop.ui.widget.window.{Window, Windowed}
 import totoro.ocelot.brain.entity.traits.{Disk, DiskManaged, DiskUnmanaged, Entity}
 import totoro.ocelot.brain.util.DyeColor
 
@@ -14,7 +15,7 @@ import scala.util.Try
 /**
   * A utility mixin for HDDs and floppies.
   */
-trait DiskItem extends ComponentItem {
+trait DiskItem extends ComponentItem with Windowed {
   override def component: Entity with Disk
 
   def diskKind: String
@@ -35,9 +36,11 @@ trait DiskItem extends ComponentItem {
     component.setLocked(OcelotDesktop.player.nickname)
   }
 
-  protected def addSetDirectoryEntry(menu: ContextMenu, disk: DiskManaged): Unit = {
+  protected def addRealPathContextMenuEntries(menu: ContextMenu, disk: DiskManaged): Unit = {
-    menu.addEntry(
+    menu.addEntry(ContextMenuEntry(
-      ContextMenuEntry("Set directory") {
+      if (disk.customRealPath.isDefined) "Change directory" else "Set directory",
+      IconSource.Folder
+    ) {
       OcelotDesktop.showFileChooserDialog(JFileChooser.OPEN_DIALOG, JFileChooser.DIRECTORIES_ONLY) { dir =>
         Try {
           for (dir <- dir) {
@@ -48,20 +51,29 @@ trait DiskItem extends ComponentItem {
           }
         }
       }
-      }
+    })
-    )
 
-    // TODO: unset directory?????? anyone?
+    if (disk.customRealPath.isDefined) {
+      menu.addEntry( ContextMenuEntry("Reset directory", IconSource.FolderSlash) {
+        reinserting {
+          // trigger component_removed / component_added signals
+          disk.customRealPath = None
+        }
+      })
+    }
   }
 
-  private val editWindow = new WindowProvider {
+  private lazy val _window = new DiskEditWindow(DiskItem.this)
-    override def windowEntryLabel: String = "Edit"
 
-    override def makeWindow(): Window = new DiskEditWindow(DiskItem.this)
+  override def window: Option[Window] = Some(_window)
-  }
 
   override def fillRmbMenu(menu: ContextMenu): Unit = {
-    editWindow.fillRmbMenu(menu)
+    menu.addEntry(ContextMenuEntry("Edit disk", IconSource.Edit) {
+      window.get.open()
+    })
+
+    menu.addSeparator()
+
     super.fillRmbMenu(menu)
   }
 

src/main/scala/ocelot/desktop/inventory/traits/WindowProvider.scala

@@ -1,25 +0,0 @@
-package ocelot.desktop.inventory.traits
-
-import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
-import ocelot.desktop.ui.widget.window.Window
-
-/**
-  * Potentially manages the windows of an [[ocelot.desktop.inventory.Item Item]] that has them (e.g., the sound card).
-  * Though at the moment it just provides a convenient way to add an entry to the item's context menu
-  * for opening a window.
-  */
-trait WindowProvider {
-  def windowEntryLabel: String
-
-  def makeWindow(): Window
-
-  def fillRmbMenu(menu: ContextMenu): Unit = {
-    // TODO: disable the entry while the window is open
-    // TODO: serialize the window
-    menu.addEntry(
-      ContextMenuEntry(windowEntryLabel) {
-        makeWindow().open()
-      },
-    )
-  }
-}

src/main/scala/ocelot/desktop/node/ComputerAwareNode.scala

@@ -9,7 +9,7 @@ import ocelot.desktop.ui.UiHandler
 import ocelot.desktop.ui.event.BrainEvent
 import ocelot.desktop.ui.event.handlers.DiskActivityHandler
 import ocelot.desktop.ui.widget.ComputerErrorMessageLabel
-import ocelot.desktop.util.{Logging, Messages}
+import ocelot.desktop.util.Messages
 import totoro.ocelot.brain.Settings
 import totoro.ocelot.brain.entity.traits.{Entity, Environment, WorkspaceAware}
 import totoro.ocelot.brain.event._

src/main/scala/ocelot/desktop/node/EntityNode.scala

@@ -1,6 +1,7 @@
 package ocelot.desktop.node
 
 import ocelot.desktop.OcelotDesktop
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.UiHandler
 import ocelot.desktop.ui.event.ClickEvent
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
@@ -34,7 +35,7 @@ abstract class EntityNode(val entity: Entity with Environment) extends Node {
   override def setupContextMenu(menu: ContextMenu, event: ClickEvent): Unit = {
     if (exposeAddress && entity.node != null && entity.node.address != null) {
       menu.addEntry(
-        ContextMenuEntry("Copy address") {
+        ContextMenuEntry("Copy address", IconSource.Copy) {
           UiHandler.clipboard = entity.node.address
         }
       )

src/main/scala/ocelot/desktop/node/LabeledNode.scala

@@ -1,7 +1,7 @@
 package ocelot.desktop.node
 
 import ocelot.desktop.color.RGBAColor
-import ocelot.desktop.graphics.Graphics
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.ui.event.ClickEvent
 import ocelot.desktop.ui.widget.InputDialog
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
@@ -26,7 +26,7 @@ trait LabeledNode extends Node {
   }
 
   override def setupContextMenu(menu: ContextMenu, event: ClickEvent): Unit = {
-    menu.addEntry(ContextMenuEntry("Set label") {
+    menu.addEntry(ContextMenuEntry("Set label", IconSource.Label) {
       new InputDialog(
         "Set label",
         text => {

src/main/scala/ocelot/desktop/node/Node.scala

@@ -1,15 +1,15 @@
 package ocelot.desktop.node
 
+import ocelot.desktop.audio.SoundSource
 import ocelot.desktop.color.{Color, RGBAColor}
 import ocelot.desktop.geometry.{Rect2D, Size2D, Vector2D}
-import ocelot.desktop.graphics.Graphics
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.node.Node._
 import ocelot.desktop.ui.event.handlers.{ClickHandler, DragHandler, HoverHandler}
 import ocelot.desktop.ui.event.{ClickEvent, DragEvent, HoverEvent, MouseEvent}
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
 import ocelot.desktop.ui.widget.window.Windowed
 import ocelot.desktop.ui.widget.{Widget, WorkspaceView}
-import ocelot.desktop.util.Disposable
 import ocelot.desktop.util.animation.ColorAnimation
 import org.lwjgl.input.Keyboard
 import totoro.ocelot.brain.nbt.NBTTagCompound
@@ -88,18 +88,14 @@ abstract class Node extends Widget with DragHandler with ClickHandler with Hover
 
   def setupContextMenu(menu: ContextMenu, event: ClickEvent): Unit = {
     if (ports.nonEmpty) {
-      menu.addEntry(
+      menu.addEntry(ContextMenuEntry("Disconnect", IconSource.LinkSlash, SoundSource.InterfaceClickLow) {
-        ContextMenuEntry("Disconnect") {
         disconnectFromAll()
-        }
+      })
-      )
     }
 
-    menu.addEntry(
+    menu.addEntry(ContextMenuEntry("Remove", IconSource.Delete, SoundSource.InterfaceClickLow) {
-      ContextMenuEntry("Delete") {
       destroy()
-      }
+    })
-    )
   }
 
   override def update(): Unit = {
@@ -290,10 +286,10 @@ abstract class Node extends Widget with DragHandler with ClickHandler with Hover
   }
 
   override def dispose(): Unit = {
-    super.dispose()
-
     disconnectFromAll()
     window.foreach(_.closeAndDispose())
+
+    super.dispose()
   }
 }
 

src/main/scala/ocelot/desktop/node/nodes/ComputerNode.scala

@@ -2,18 +2,15 @@ package ocelot.desktop.node.nodes
 
 import ocelot.desktop.color.Color
 import ocelot.desktop.graphics.Graphics
-import ocelot.desktop.inventory.SyncedInventory
 import ocelot.desktop.node.ComputerAwareNode
 import ocelot.desktop.node.Node.HighlightThickness
 import ocelot.desktop.ui.event.ClickEvent
 import ocelot.desktop.ui.widget.contextmenu.ContextMenu
 import ocelot.desktop.ui.widget.slot._
 import ocelot.desktop.util.{ComputerAware, DrawUtils, TierColor}
-import ocelot.desktop.windows.ComputerWindow
 import totoro.ocelot.brain.entity.Case
-import totoro.ocelot.brain.entity.traits.{Computer, Inventory, TieredPersistable}
+import totoro.ocelot.brain.entity.traits.Inventory
 import totoro.ocelot.brain.util.Tier
-import totoro.ocelot.brain.util.Tier.Tier
 
 class ComputerNode(val computerCase: Case)
   extends ComputerAwareNode(computerCase)

src/main/scala/ocelot/desktop/node/nodes/RackNode.scala

@@ -1,9 +1,9 @@
 package ocelot.desktop.node.nodes
 
 import ocelot.desktop.geometry.{Rect2D, Size2D, Vector2D}
-import ocelot.desktop.graphics.{Graphics, Icons}
+import ocelot.desktop.graphics.{Graphics, IconSource}
+import ocelot.desktop.inventory.Item
 import ocelot.desktop.inventory.item.{DiskDriveMountableItem, RackMountableItem, ServerItem}
-import ocelot.desktop.inventory.{Item, SyncedInventory}
 import ocelot.desktop.node.Node.{HighlightThickness, NoHighlightSize, Size, TexelCount}
 import ocelot.desktop.node.{ComputerAwareNode, NodePort}
 import ocelot.desktop.ui.event.ClickEvent
@@ -12,7 +12,7 @@ import ocelot.desktop.ui.widget.window.Window
 import ocelot.desktop.util.DrawUtils
 import ocelot.desktop.windows.RackWindow
 import totoro.ocelot.brain.entity.Rack
-import totoro.ocelot.brain.entity.traits.{ComponentInventory, Environment, Inventory, RackMountable, WorkspaceAware}
+import totoro.ocelot.brain.entity.traits.{ComponentInventory, Environment, Inventory, RackMountable}
 import totoro.ocelot.brain.network
 import totoro.ocelot.brain.util.Direction
 
@@ -108,7 +108,7 @@ class RackNode(val rack: Rack)
   override def dispose(): Unit = {
     for (i <- 0 until 4) {
       Slot(i).get match {
-        case Some(serverItem: ServerItem) => serverItem.dispose()
+        case Some(serverItem: ServerItem) => serverItem.onRemoved()
         case _=>
       }
     }
@@ -174,17 +174,18 @@ object RackNode {
   def addContextMenuEntriesOfMountable(menu: ContextMenu, item: Option[RackMountableItem]): Unit = {
     item match {
       case Some(serverItem: ServerItem) =>
+        menu.addEntry(ContextMenuEntry("Set up", IconSource.Window) {
+          serverItem.window.get.open()
+        })
+
         if (serverItem.isInRack) {
-          serverItem.addPowerContextMenuEntries(menu)
           menu.addSeparator()
+
+          serverItem.addPowerContextMenuEntries(menu)
         }
 
         serverItem.addTierContextMenuEntries(menu)
 
-        menu.addEntry(ContextMenuEntry("Configure server") {
-          serverItem.window.get.open()
-        })
-
         menu.addSeparator()
 
       case Some(diskDriveMountableItem: DiskDriveMountableItem) =>

src/main/scala/ocelot/desktop/node/nodes/ScreenNode.scala

@@ -2,7 +2,7 @@ package ocelot.desktop.node.nodes
 
 import ocelot.desktop.color.{Color, IntColor}
 import ocelot.desktop.geometry.{Rect2D, Size2D}
-import ocelot.desktop.graphics.Graphics
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.node.Node.{HighlightThickness, NoHighlightSize, Size}
 import ocelot.desktop.node.nodes.ScreenNode.{BorderSize, FontHeight, FontWidth}
 import ocelot.desktop.node.{EntityNode, LabeledEntityNode}
@@ -66,11 +66,11 @@ class ScreenNode(val screen: Screen) extends EntityNode(screen) with LabeledEnti
 
   override def setupContextMenu(menu: ContextMenu, event: ClickEvent): Unit = {
     if (screen.getPowerState)
-      menu.addEntry(ContextMenuEntry("Turn off") { screen.setPowerState(false) })
+      menu.addEntry(ContextMenuEntry("Turn off", IconSource.Power) { screen.setPowerState(false) })
     else
-      menu.addEntry(ContextMenuEntry("Turn on") { screen.setPowerState(true) })
+      menu.addEntry(ContextMenuEntry("Turn on", IconSource.Power) { screen.setPowerState(true) })
 
-    menu.addEntry(ContextMenuEntry("Set aspect ratio") {
+    menu.addEntry(ContextMenuEntry("Set aspect ratio", IconSource.AspectRatio) {
       new ScreenAspectRatioDialog(this).show()
     })
 

src/main/scala/ocelot/desktop/ui/UiHandler.scala

@@ -1,6 +1,5 @@
 package ocelot.desktop.ui
 
-import buildinfo.BuildInfo
 import ocelot.desktop.audio.{Audio, SoundBuffers}
 import ocelot.desktop.geometry.{Rect2D, Size2D, Vector2D}
 import ocelot.desktop.graphics.Graphics

src/main/scala/ocelot/desktop/ui/widget/Checkbox.scala

@@ -51,6 +51,7 @@ class Checkbox(val label: String, val initialValue: Boolean = false, val isSmall
     DrawUtils.ring(g, position.x, position.y, boxSize, boxSize, 2, ColorScheme("CheckboxBorder"))
 
     g.background = Color.Transparent
+
     if (checked) {
       g.line(position.x + 1, position.y + boxSize / 2 + 1,
         position.x + boxSize / 4 + 1, position.y + boxSize / 4 * 3 + 1, 3, ColorScheme("CheckboxForeground"))

src/main/scala/ocelot/desktop/ui/widget/DiskEditWindow.scala

@@ -3,14 +3,14 @@ package ocelot.desktop.ui.widget
 import ocelot.desktop.ColorScheme
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.Icons
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.DiskItem
 import ocelot.desktop.ui.layout.{AlignItems, LinearLayout}
-import ocelot.desktop.ui.widget.DiskEditWindow.{ColorNames, Units}
+import ocelot.desktop.ui.widget.DiskEditWindow.Units
 import ocelot.desktop.ui.widget.window.PanelWindow
 import ocelot.desktop.util.FuncUtils.composeN
-import ocelot.desktop.util.Orientation
 import ocelot.desktop.util.animation.ColorAnimation
+import ocelot.desktop.util.{DiskDriveAware, Orientation}
 import totoro.ocelot.brain.entity.traits.{DiskManaged, DiskUnmanaged}
 import totoro.ocelot.brain.util.DyeColor
 
@@ -92,13 +92,13 @@ class DiskEditWindow(item: DiskItem) extends PanelWindow {
             for (dyeColor <- row) {
               def isColorSelected: Boolean = dyeColor == item.color.get
 
-              val floppyIcon = Icons.FloppyDisk(dyeColor).icon
+              val floppyIcon = IconSource.FloppyDisk(dyeColor).path
               children :+= new IconButton(
                 floppyIcon,
                 floppyIcon,
                 mode = IconButton.Mode.Radio,
                 drawBackground = true,
-                tooltip = Some(ColorNames(dyeColor)),
+                tooltip = Some(DiskDriveAware.ColorNames(dyeColor)),
                 padding = 2,
                 sizeMultiplier = 2f,
                 model = IconButton.ReadOnlyModel(isColorSelected),
@@ -174,23 +174,4 @@ object DiskEditWindow {
     4 * 1024 -> "kiB",
     1024 * 1024 -> "MiB",
   )
-
-  private val ColorNames = Map(
-    DyeColor.White -> "White",
-    DyeColor.Orange -> "Orange",
-    DyeColor.Magenta -> "Magenta",
-    DyeColor.LightBlue -> "LightBlue",
-    DyeColor.Yellow -> "Yellow",
-    DyeColor.Lime -> "Lime",
-    DyeColor.Pink -> "Pink",
-    DyeColor.Gray -> "Gray",
-    DyeColor.Silver -> "Silver",
-    DyeColor.Cyan -> "Cyan",
-    DyeColor.Purple -> "Purple",
-    DyeColor.Blue -> "Blue",
-    DyeColor.Brown -> "Brown",
-    DyeColor.Green -> "Green",
-    DyeColor.Red -> "Red",
-    DyeColor.Black -> "Black",
-  )
 }

src/main/scala/ocelot/desktop/ui/widget/Icon.scala

@@ -2,24 +2,24 @@ package ocelot.desktop.ui.widget
 
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.Size2D
-import ocelot.desktop.graphics.{Graphics, IconDef}
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.util.Spritesheet
 
-class Icon(icon: IconDef) extends Widget {
+class Icon(icon: IconSource) extends Widget {
   def this(name: String) {
-    this(IconDef(name))
+    this(IconSource(name))
   }
 
-  def this(name: String, color: Color) {
+  def this(name: String, animation: IconSource.Animation) {
-    this(IconDef(name, color = color))
+    this(IconSource(name, animation = Some(animation)))
   }
 
-  def this(name: String, animation: IconDef.Animation) {
+  def iconColor: Color = Color.White
-    this(IconDef(name, animation = Some(animation)))
+  def iconSize: Size2D = Spritesheet.spriteSize(icon.path)
-  }
 
   override def minimumSize: Size2D = {
-    val size = Spritesheet.spriteSize(icon.icon) * icon.sizeMultiplier
+    val size = iconSize
+
     icon.animation match {
       case None => size
       case Some(_) => size.copy(height = size.width)
@@ -29,6 +29,6 @@ class Icon(icon: IconDef) extends Widget {
   override def maximumSize: Size2D = minimumSize
 
   override def draw(g: Graphics): Unit = {
-    g.sprite(icon.icon, bounds.x, bounds.y, bounds.w, bounds.h, icon.color, icon.animation)
+    g.sprite(icon.path, bounds.x, bounds.y, bounds.w, bounds.h, iconColor, icon.animation)
   }
 }

src/main/scala/ocelot/desktop/ui/widget/MenuBar.scala

@@ -2,7 +2,7 @@ package ocelot.desktop.ui.widget
 
 import ocelot.desktop.audio.SoundSource
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.Graphics
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.ui.event.KeyEvent
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenuEntry, ContextMenuSubmenu}
 import ocelot.desktop.{ColorScheme, OcelotDesktop}
@@ -18,23 +18,25 @@ class MenuBar extends Widget {
   private def addEntry(w: Widget): Unit = entries.children :+= w
 
   addEntry(new MenuBarSubmenu("File", menu => {
-    menu.addEntry(ContextMenuEntry("New") { OcelotDesktop.newWorkspace() })
+    menu.addEntry(ContextMenuEntry("New", IconSource.Plus) { OcelotDesktop.newWorkspace() })
-    menu.addEntry(ContextMenuEntry("Open") { OcelotDesktop.showOpenDialog() })
+    menu.addEntry(ContextMenuEntry("Open", IconSource.Folder) { OcelotDesktop.showOpenDialog() })
-    menu.addEntry(ContextMenuEntry("Save") { OcelotDesktop.save() })
+    menu.addEntry(ContextMenuEntry("Save", IconSource.Save) { OcelotDesktop.save() })
-    menu.addEntry(ContextMenuEntry("Save as…") { OcelotDesktop.saveAs() })
+    menu.addEntry(ContextMenuEntry("Save as", IconSource.SaveAs) { OcelotDesktop.saveAs() })
+
     menu.addSeparator()
-    menu.addEntry(ContextMenuEntry("Exit") { OcelotDesktop.exit() })
+
+    menu.addEntry(ContextMenuEntry("Exit", IconSource.Cross, SoundSource.InterfaceClickLow) { OcelotDesktop.exit() })
   }))
 
   addEntry(new MenuBarSubmenu("Player", menu => {
-    menu.addEntry(ContextMenuEntry("Add...") { OcelotDesktop.showAddPlayerDialog() })
+    menu.addEntry(ContextMenuEntry("Create new", IconSource.Plus) { OcelotDesktop.showAddPlayerDialog() })
     menu.addSeparator()
     OcelotDesktop.players.foreach(player => {
       menu.addEntry(new ContextMenuSubmenu(
-          (if (player == OcelotDesktop.players.head) "● " else "  ") + player.nickname,
+        s"${if (player == OcelotDesktop.players.head) "● " else "  "}${player.nickname}",
-          () => OcelotDesktop.selectPlayer(player.nickname)
+        onClick = () => OcelotDesktop.selectPlayer(player.nickname)
       ) {
-        addEntry(ContextMenuEntry("Remove", sound = SoundSource.InterfaceClickLow) {
+        addEntry(ContextMenuEntry("Remove", IconSource.Delete, SoundSource.InterfaceClickLow) {
           OcelotDesktop.removePlayer(player.nickname)
         })
       })

src/main/scala/ocelot/desktop/ui/widget/component/ComponentSelectorEntry.scala

@@ -3,11 +3,11 @@ package ocelot.desktop.ui.widget.component
 import ocelot.desktop.ColorScheme
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.Padding2D
-import ocelot.desktop.graphics.IconDef
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.layout.{AlignItems, Layout, LinearLayout}
 import ocelot.desktop.ui.widget.{Icon, Label, PaddingBox, Widget}
 
-class ComponentSelectorEntry(label: String, icon: IconDef) extends Widget {
+class ComponentSelectorEntry(label: String, icon: IconSource) extends Widget {
   children :+= new Widget {
     override val layout: Layout = new LinearLayout(this, alignItems = AlignItems.Center)
 

src/main/scala/ocelot/desktop/ui/widget/contextmenu/ContextMenuEntry.scala

@@ -4,7 +4,7 @@ import ocelot.desktop.ColorScheme
 import ocelot.desktop.audio.SoundSource
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.{Graphics, IconDef}
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.ui.event.handlers.{ClickHandler, HoverHandler}
 import ocelot.desktop.ui.event.{ClickEvent, HoverEvent, MouseEvent}
 import ocelot.desktop.ui.layout.{AlignItems, Layout, LinearLayout}
@@ -14,8 +14,8 @@ import ocelot.desktop.util.animation.easing.{EaseInQuad, EaseOutQuad}
 
 class ContextMenuEntry(
   label: String,
+  icon: Option[ContextMenuIcon] = None,
   onClick: () => Unit = () => {},
-                        icon: Option[IconDef] = None,
   sound: SoundSource = SoundSource.InterfaceClick,
   soundDisabled: SoundSource = SoundSource.InterfaceClickLow
 ) extends Widget
@@ -42,16 +42,26 @@ class ContextMenuEntry(
 
       icon match {
         case Some(icon) =>
-          children :+= new PaddingBox(new Icon(icon), Padding2D(left = 8f, right = 6f))
+          children :+= new PaddingBox(
+            new Icon(icon.source) {
+              override def iconColor: Color = icon.color.getOrElse(ColorScheme("ContextMenuIcon"))
+
+              override def iconSize: Size2D = icon.size match {
+                case ContextMenuIconSize.Normal => Size2D(16, 16)
+                case _ => Size2D(32, 32)
+              }
+            },
+            Padding2D(left = 8f, right = 8f)
+          )
         case _ =>
       }
 
       children :+= new PaddingBox(
         new Label {
           override def text: String = label
-
           override def color: Color = ColorScheme("ContextMenuText")
-        }, Padding2D(top = 3f, bottom = 3f)
+        },
+        Padding2D(top = 5f, bottom = 5f)
       )
     }, Padding2D(left = padLeft, right = 16f, top = 2f, bottom = 2f)
   )
@@ -124,15 +134,42 @@ class ContextMenuEntry(
 object ContextMenuEntry {
   def apply(
     label: String,
-             icon: Option[IconDef] = None,
+    icon: Option[ContextMenuIcon] = None
-             sound: SoundSource = SoundSource.InterfaceClick,
-             soundDisabled: SoundSource = SoundSource.InterfaceClickLow
   )(onClick: => Unit): ContextMenuEntry =
     new ContextMenuEntry(
       label,
       onClick = onClick _,
-      icon = icon,
+      icon = icon
+    )
+
+  def apply(
+   label: String
+  )(onClick: => Unit): ContextMenuEntry =
+    new ContextMenuEntry(
+      label,
+      onClick = onClick _,
+      icon = None
+    )
+
+  def apply(
+    label: String,
+    icon: IconSource
+  )(onClick: => Unit): ContextMenuEntry =
+    new ContextMenuEntry(
+      label,
+      Some(ContextMenuIcon(icon)),
+      onClick = onClick _,
+    )
+
+  def apply(
+             label: String,
+             icon: IconSource,
+             sound: SoundSource
+   )(onClick: => Unit): ContextMenuEntry =
+    new ContextMenuEntry(
+      label,
+      Some(ContextMenuIcon(icon)),
       sound = sound,
-      soundDisabled = soundDisabled
+      onClick = onClick _
     )
 }

src/main/scala/ocelot/desktop/ui/widget/contextmenu/ContextMenuIcon.scala

@@ -0,0 +1,10 @@
+package ocelot.desktop.ui.widget.contextmenu
+
+import ocelot.desktop.color.Color
+import ocelot.desktop.graphics.IconSource
+
+case class ContextMenuIcon(
+                            source: IconSource,
+                            size: ContextMenuIconSize.Value = ContextMenuIconSize.Normal,
+                            color: Option[Color] = None
+)

src/main/scala/ocelot/desktop/ui/widget/contextmenu/ContextMenuIconSize.scala

@@ -0,0 +1,5 @@
+package ocelot.desktop.ui.widget.contextmenu
+
+object ContextMenuIconSize extends Enumeration {
+  val Normal, Big = Value
+}

src/main/scala/ocelot/desktop/ui/widget/contextmenu/ContextMenuSubmenu.scala

@@ -3,15 +3,20 @@ package ocelot.desktop.ui.widget.contextmenu
 import ocelot.desktop.ColorScheme
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.Vector2D
-import ocelot.desktop.graphics.{Graphics, IconDef}
+import ocelot.desktop.graphics.Graphics
 import ocelot.desktop.ui.UiHandler
 import ocelot.desktop.ui.event.HoverEvent
 
-class ContextMenuSubmenu(label: String,
+class ContextMenuSubmenu(
-                         onClick: () => Unit = null,
+  label: String,
-                         icon: Option[IconDef] = None)
+  icon: Option[ContextMenuIcon] = None,
-  extends ContextMenuEntry(label + "  ", if (onClick != null) onClick else () => {}, icon)
+  onClick: () => Unit = () => {},
-{
+)
+extends ContextMenuEntry(
+  label + "  ",
+  icon,
+  onClick
+) {
   private val parentEntry = this
   private val submenu = new ContextMenu {
     override def update(): Unit = {

src/main/scala/ocelot/desktop/ui/widget/modal/notification/NotificationDialog.scala

@@ -3,7 +3,7 @@ package ocelot.desktop.ui.widget.modal.notification
 import ocelot.desktop.ColorScheme
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.Padding2D
-import ocelot.desktop.graphics.{Graphics, Icons}
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.ui.layout.LinearLayout
 import ocelot.desktop.ui.widget._
 import ocelot.desktop.ui.widget.modal.ModalDialog
@@ -30,7 +30,7 @@ class NotificationDialog(message: String, notificationType: NotificationType = N
 
       // Icon
       children :+= new PaddingBox(
-        new Icon(Icons.NotificationIcon(notificationType)),
+        new Icon(IconSource.Notification(notificationType)),
         Padding2D.equal(10)
       )
 

src/main/scala/ocelot/desktop/ui/widget/settings/SettingsTab.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.ui.widget.settings
 
-import ocelot.desktop.graphics.IconDef
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.layout.LinearLayout
 import ocelot.desktop.ui.widget.Widget
 import ocelot.desktop.util.Orientation
@@ -8,7 +8,7 @@ import ocelot.desktop.util.Orientation
 trait SettingsTab extends Widget {
   override protected val layout = new LinearLayout(this, orientation = Orientation.Vertical)
 
-  val icon: IconDef
+  val icon: IconSource
   val label: String
 
   /**

src/main/scala/ocelot/desktop/ui/widget/settings/SoundSettingsTab.scala

@@ -2,11 +2,11 @@ package ocelot.desktop.ui.widget.settings
 
 import ocelot.desktop.Settings
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.widget.{PaddingBox, Slider}
 
 class SoundSettingsTab extends SettingsTab {
-  override val icon: IconDef = Icons.SettingsSound
+  override val icon: IconSource = IconSource.SettingsSound
   override val label: String = "Sound"
 
   children :+= new PaddingBox(new Slider(Settings.get.volumeMaster, "Master Volume") {

src/main/scala/ocelot/desktop/ui/widget/settings/UISettingsTab.scala

@@ -2,12 +2,12 @@ package ocelot.desktop.ui.widget.settings
 
 import ocelot.desktop.Settings
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.ui.UiHandler
 import ocelot.desktop.ui.widget.{Checkbox, PaddingBox, Slider}
 
 class UISettingsTab extends SettingsTab {
-  override val icon: IconDef = Icons.SettingsUI
+  override val icon: IconSource = IconSource.SettingsUI
   override val label: String = "UI"
 
   override def applySettings(): Unit = {

src/main/scala/ocelot/desktop/ui/widget/slot/CardSlotWidget.scala

@@ -1,11 +1,11 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
 import ocelot.desktop.inventory.traits.CardItem
 import totoro.ocelot.brain.util.Tier.Tier
 
 class CardSlotWidget(slot: Inventory#Slot, _tier: Tier) extends SlotWidget[CardItem](slot) {
-  override def ghostIcon: Option[IconDef] = Some(Icons.CardIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.CardIcon)
   override def slotTier: Option[Tier] = Some(_tier)
 }

src/main/scala/ocelot/desktop/ui/widget/slot/ComponentBusSlotWidget.scala

@@ -1,6 +1,6 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
 import ocelot.desktop.inventory.item.ComponentBusItem
 import totoro.ocelot.brain.util.Tier.Tier
@@ -8,6 +8,6 @@ import totoro.ocelot.brain.util.Tier.Tier
 class ComponentBusSlotWidget(slot: Inventory#Slot, _tier: Tier)
   extends SlotWidget[ComponentBusItem](slot)
 {
-  override def ghostIcon: Option[IconDef] = Some(Icons.ComponentBusIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.ComponentBusIcon)
   override def slotTier: Option[Tier] = Some(_tier)
 }

src/main/scala/ocelot/desktop/ui/widget/slot/CpuSlotWidget.scala

@@ -1,13 +1,13 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.traits.CpuLikeItem
 import ocelot.desktop.inventory.{Inventory, Item}
 import ocelot.desktop.util.ComputerAware
 import totoro.ocelot.brain.util.Tier.Tier
 
 class CpuSlotWidget(slot: Inventory#Slot, computer: ComputerAware, _tier: Tier) extends SlotWidget[CpuLikeItem](slot) {
-  override def ghostIcon: Option[IconDef] = Some(Icons.CpuIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.CpuIcon)
   override def slotTier: Option[Tier] = Some(_tier)
 
   protected override def onItemNotification(notification: Item.Notification): Unit = {

src/main/scala/ocelot/desktop/ui/widget/slot/EepromSlotWidget.scala

@@ -1,9 +1,9 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
 import ocelot.desktop.inventory.item.EepromItem
 
 class EepromSlotWidget(slot: Inventory#Slot) extends SlotWidget[EepromItem](slot) {
-  override def ghostIcon: Option[IconDef] = Some(Icons.EepromIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.EepromIcon)
 }

src/main/scala/ocelot/desktop/ui/widget/slot/FloppySlotWidget.scala

@@ -1,12 +1,12 @@
 package ocelot.desktop.ui.widget.slot
 
 import ocelot.desktop.audio.{Audio, SoundSource}
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
 import ocelot.desktop.inventory.item.FloppyItem
 
 class FloppySlotWidget(slot: Inventory#Slot) extends SlotWidget[FloppyItem](slot) {
-  override def ghostIcon: Option[IconDef] = Some(Icons.FloppyIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.FloppyIcon)
 
   override def onItemAdded(): Unit = {
     super.onItemAdded()

src/main/scala/ocelot/desktop/ui/widget/slot/HddSlotWidget.scala

@@ -1,11 +1,11 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
 import ocelot.desktop.inventory.item.HddItem
 import totoro.ocelot.brain.util.Tier.Tier
 
 class HddSlotWidget(slot: Inventory#Slot, _tier: Tier) extends SlotWidget[HddItem](slot) {
-  override def ghostIcon: Option[IconDef] = Some(Icons.HddIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.HddIcon)
   override def slotTier: Option[Tier] = Some(_tier)
 }

src/main/scala/ocelot/desktop/ui/widget/slot/ItemChooser.scala

@@ -1,9 +1,9 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.IconDef
+import ocelot.desktop.color.Color
 import ocelot.desktop.inventory.Items.{ArbitraryItemGroup, ExtendedTieredItemGroup, SingletonItemGroup, TieredItemGroup}
 import ocelot.desktop.inventory._
-import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuSubmenu}
+import ocelot.desktop.ui.widget.contextmenu._
 import totoro.ocelot.brain.util.ExtendedTier.ExtendedTier
 import totoro.ocelot.brain.util.Tier.Tier
 
@@ -11,7 +11,10 @@ class ItemChooser[I <: Item](slot: SlotWidget[I]) extends ContextMenu {
   import ItemChooser._
 
   private def makeMenuEntry(factory: ItemFactory, label: String): ContextMenuEntry = {
-    ContextMenuEntry(label, icon = Some(factory.icon)) {
+    ContextMenuEntry(
+      label,
+      Some(ContextMenuIcon(factory.icon, ContextMenuIconSize.Big, Some(Color.White)))
+    ) {
       slot.item = factory.build().asInstanceOf[I]
     }
   }
@@ -19,7 +22,7 @@ class ItemChooser[I <: Item](slot: SlotWidget[I]) extends ContextMenu {
   private def addSubmenu[T: HasLabel](
     name: String,
     factories: Seq[(T, ItemFactory)],
-    icon: Option[IconDef] = None
+    icon: Option[ContextMenuIcon] = None
   ): Unit = {
     val tierLabel = implicitly[HasLabel[T]].label _
 
@@ -27,7 +30,10 @@ class ItemChooser[I <: Item](slot: SlotWidget[I]) extends ContextMenu {
 
     if (acceptedFactories.nonEmpty) {
       addEntry(
-        new ContextMenuSubmenu(name, icon = Some(icon.getOrElse(acceptedFactories.last._2.icon))) {
+        new ContextMenuSubmenu(
+          name,
+          Some(icon.getOrElse(ContextMenuIcon(acceptedFactories.last._2.icon, ContextMenuIconSize.Big, Some(Color.White))))
+        ) {
           for ((tier, factory) <- acceptedFactories) {
             addEntry(makeMenuEntry(factory, tierLabel(tier)))
           }
@@ -47,7 +53,7 @@ class ItemChooser[I <: Item](slot: SlotWidget[I]) extends ContextMenu {
 
       case ExtendedTieredItemGroup(name, factories) => addSubmenu(name, factories)
 
-      case ArbitraryItemGroup(name, icon, factories) => addSubmenu(name, factories, Some(icon))
+      case ArbitraryItemGroup(name, icon, factories) => addSubmenu(name, factories, Some(ContextMenuIcon(icon, ContextMenuIconSize.Big, Some(Color.White))))
     }
   }
 }

src/main/scala/ocelot/desktop/ui/widget/slot/MemorySlotWidget.scala

@@ -1,11 +1,11 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
 import ocelot.desktop.inventory.item.MemoryItem
 import totoro.ocelot.brain.util.Tier.Tier
 
 class MemorySlotWidget(slot: Inventory#Slot, _tier: Tier) extends SlotWidget[MemoryItem](slot) {
-  override def ghostIcon: Option[IconDef] = Some(Icons.MemoryIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.MemoryIcon)
   override def slotTier: Option[Tier] = Some(_tier)
 }

src/main/scala/ocelot/desktop/ui/widget/slot/RackMountableSlotWidget.scala

@@ -1,17 +1,13 @@
 package ocelot.desktop.ui.widget.slot
 
-import ocelot.desktop.graphics.{IconDef, Icons}
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.Inventory
-import ocelot.desktop.inventory.item.{DiskDriveMountableItem, RackMountableItem, ServerItem}
+import ocelot.desktop.inventory.item.{RackMountableItem, ServerItem}
-import ocelot.desktop.node.nodes.RackNode
-import ocelot.desktop.ui.event.sources.KeyEvents
-import ocelot.desktop.ui.widget.contextmenu.ContextMenu
-import org.lwjgl.input.Keyboard
 
 class RackMountableSlotWidget(slot: Inventory#Slot)
   extends SlotWidget[RackMountableItem](slot)
 {
-  override def ghostIcon: Option[IconDef] = Some(Icons.ServerIcon)
+  override def ghostIcon: Option[IconSource] = Some(IconSource.ServerIcon)
 
   override def onItemRemoved(removedItem: RackMountableItem, replacedBy: Option[RackMountableItem]): Unit = {
     super.onItemRemoved(removedItem, replacedBy)

src/main/scala/ocelot/desktop/ui/widget/slot/SlotWidget.scala

@@ -3,7 +3,7 @@ package ocelot.desktop.ui.widget.slot
 import ocelot.desktop.audio.SoundSource
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.{Size2D, Vector2D}
-import ocelot.desktop.graphics.{Graphics, IconDef, Icons}
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.inventory.{Inventory, Item, ItemFactory}
 import ocelot.desktop.ui.event.handlers.{ClickHandler, DragHandler, HoverHandler}
 import ocelot.desktop.ui.event.{ClickEvent, DragEvent, HoverEvent, MouseEvent}
@@ -12,7 +12,6 @@ import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
 import ocelot.desktop.ui.widget.itemdrag.DraggedItem
 import ocelot.desktop.ui.widget.slot.SlotWidget.{HighlightAlpha, HighlightAnimationHideSpeed, HighlightAnimationShowSpeed}
 import ocelot.desktop.ui.widget.tooltip.{ItemTooltip, Tooltip}
-import ocelot.desktop.util.Disposable
 import ocelot.desktop.util.animation.ValueAnimation
 import totoro.ocelot.brain.util.Tier
 import totoro.ocelot.brain.util.Tier.Tier
@@ -58,13 +57,13 @@ class SlotWidget[I <: Item](private val slot: Inventory#Slot)(implicit slotItemT
     disposed = true
   }
 
-  def ghostIcon: Option[IconDef] = None
+  def ghostIcon: Option[IconSource] = None
 
   def slotTier: Option[Tier] = None
 
-  def tierIcon: Option[IconDef] = slotTier.map(Icons.TierIcon)
+  def tierIcon: Option[IconSource] = slotTier.map(IconSource.TierIcon)
 
-  def itemIcon: Option[IconDef] = item.map(_.icon)
+  def itemIcon: Option[IconSource] = item.map(_.icon)
 
   def item: Option[I] = slot.get.filter(_ => !disposed).map(_.asInstanceOf[I])
 
@@ -111,7 +110,7 @@ class SlotWidget[I <: Item](private val slot: Inventory#Slot)(implicit slotItemT
     for (item <- item) {
       item.fillRmbMenu(menu)
       menu.addEntry(
-        ContextMenuEntry("Remove", sound = SoundSource.InterfaceClickLow) {
+        ContextMenuEntry("Remove", IconSource.Delete, SoundSource.InterfaceClickLow) {
           slot.remove()
         }
       )

src/main/scala/ocelot/desktop/ui/widget/statusbar/StatusBar.scala

@@ -2,7 +2,7 @@ package ocelot.desktop.ui.widget.statusbar
 
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.Graphics
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.ui.UiHandler
 import ocelot.desktop.ui.event.handlers.ClickHandler
 import ocelot.desktop.ui.event.{ClickEvent, KeyEvent, MouseEvent}
@@ -55,19 +55,23 @@ class StatusBar extends Widget {
     eventHandlers += {
       case ClickEvent(MouseEvent.Button.Right, pos) =>
         val menu = new ContextMenu
-        menu.addEntry(ContextMenuEntry("Change simulation speed") {
+        menu.addEntry(ContextMenuEntry("Change simulation speed", IconSource.Edit) {
           new ChangeSimulationSpeedDialog().show()
         })
-        menu.addEntry(ContextMenuEntry("Reset simulation speed") {
+
+        menu.addEntry(ContextMenuEntry("Reset simulation speed", IconSource.Restart) {
           OcelotDesktop.ticker.tickInterval = 50.millis
         })
+
         if (OcelotDesktop.tickerIntervalHistory.nonEmpty)
           menu.addSeparator()
+
         for (elem <- OcelotDesktop.tickerIntervalHistory.reverseIterator) {
           menu.addEntry(ContextMenuEntry((1_000_000f / elem.toMicros).toString) {
             OcelotDesktop.ticker.tickInterval = elem
           })
         }
+
         root.get.contextMenus.open(menu, pos)
     }
 

src/main/scala/ocelot/desktop/ui/widget/verticalmenu/VerticalMenuButton.scala

@@ -4,7 +4,7 @@ import ocelot.desktop.ColorScheme
 import ocelot.desktop.audio.SoundSource
 import ocelot.desktop.color.Color
 import ocelot.desktop.geometry.{Padding2D, Size2D}
-import ocelot.desktop.graphics.{Graphics, IconDef}
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.ui.event.handlers.{ClickHandler, HoverHandler}
 import ocelot.desktop.ui.event.{ClickEvent, HoverEvent, MouseEvent}
 import ocelot.desktop.ui.layout.LinearLayout
@@ -12,7 +12,7 @@ import ocelot.desktop.ui.widget._
 import ocelot.desktop.util.Orientation
 import ocelot.desktop.util.animation.ColorAnimation
 
-class VerticalMenuButton(icon: IconDef, label: String, handler: VerticalMenuButton => Unit = _ => {})
+class VerticalMenuButton(icon: IconSource, label: String, handler: VerticalMenuButton => Unit = _ => {})
     extends Widget with ClickHandler with HoverHandler with ClickSoundSource {
   val colorAnimation: ColorAnimation = new ColorAnimation(ColorScheme("VerticalMenuBackground"), 0.6f)
 
@@ -22,7 +22,9 @@ class VerticalMenuButton(icon: IconDef, label: String, handler: VerticalMenuButt
     override val layout = new LinearLayout(this, orientation = Orientation.Horizontal)
 
     children :+= new PaddingBox(
-      new Icon(icon.copy(sizeMultiplier = 1f, color = ColorScheme("VerticalMenuEntryIcon"))),
+      new Icon(icon) {
+        override def iconColor: Color = ColorScheme("VerticalMenuEntryIcon")
+      },
       Padding2D(right = 8)
     )
 

src/main/scala/ocelot/desktop/util/ComputerAware.scala

@@ -1,10 +1,11 @@
 package ocelot.desktop.util
 
 import ocelot.desktop.audio._
+import ocelot.desktop.graphics.IconSource
 import ocelot.desktop.inventory.item._
 import ocelot.desktop.inventory.traits.ComponentItem
 import ocelot.desktop.inventory.{Item, SyncedInventory}
-import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuSubmenu}
+import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry, ContextMenuIcon, ContextMenuSubmenu}
 import ocelot.desktop.ui.widget.slot._
 import ocelot.desktop.ui.widget.window.Windowed
 import ocelot.desktop.windows.ComputerWindow
@@ -62,35 +63,25 @@ trait ComputerAware
 
   def addPowerContextMenuEntries(menu: ContextMenu): Unit = {
     if (computer.machine.isRunning) {
-      menu.addEntry(ContextMenuEntry("Turn off") {
+      menu.addEntry(ContextMenuEntry("Turn off", IconSource.Power) {
         turnOff()
       })
 
-      menu.addEntry(ContextMenuEntry("Reboot") {
+      menu.addEntry(ContextMenuEntry("Reboot", IconSource.Restart) {
         turnOff()
         turnOn()
       })
     }
     else {
-      menu.addEntry(ContextMenuEntry("Turn on") {
+      menu.addEntry(ContextMenuEntry("Turn on", IconSource.Power) {
         turnOn()
       })
     }
-
-    menu.addEntry(
-      new ContextMenuSubmenu("Set tier") {
-        for (tier <- Tier.One to Tier.Creative) {
-          addEntry(ContextMenuEntry(tier.label) {
-            changeTier(tier)
-          })
-        }
-      }
-    )
   }
 
   def addTierContextMenuEntries(menu: ContextMenu): Unit = {
     menu.addEntry(
-      new ContextMenuSubmenu("Set tier") {
+      new ContextMenuSubmenu("Change tier", Some(ContextMenuIcon(IconSource.Tiers))) {
         for (tier <- Tier.One to Tier.Creative) {
           addEntry(ContextMenuEntry(tier.label) {
             changeTier(tier)
@@ -108,6 +99,8 @@ trait ComputerAware
   var diskSlots: Array[HddSlotWidget] = Array.empty
   var floppySlot: Option[FloppySlotWidget] = None
 
+  private var nextSlotIndex = 0
+
   protected def slots: IterableOnce[SlotWidget[I]] = (
     // slots may be null during initialization
     Option(eepromSlot).iterator ++
@@ -119,7 +112,13 @@ trait ComputerAware
     floppySlot.iterator
   ).map(_.asInstanceOf[SlotWidget[I]])
 
-  protected def insertItems(items: IterableOnce[I]): Unit = {
+  private def addSlot(): Slot = {
+    val result = Slot(nextSlotIndex)
+    nextSlotIndex += 1
+    result
+  }
+
+  private def insertItems(items: IterableOnce[I]): Unit = {
     def findBestSlot[A <: I](item: A, candidates: IterableOnce[SlotWidget[A]]): Option[SlotWidget[A]] = {
       candidates.iterator
         .filter(_.item.isEmpty)
@@ -132,14 +131,6 @@ trait ComputerAware
     }
   }
 
-  private var nextSlotIndex = 0
-
-  private def addSlot(): Slot = {
-    val result = Slot(nextSlotIndex)
-    nextSlotIndex += 1
-    result
-  }
-
   protected def addSlotWidget[T <: SlotWidget[_]](factory: Slot => T): T = {
     val slot = addSlot()
     val widget = factory(slot)

src/main/scala/ocelot/desktop/util/DiskDriveAware.scala

@@ -3,12 +3,13 @@ package ocelot.desktop.util
 import ocelot.desktop.audio.{Audio, SoundSource}
 import ocelot.desktop.color._
 import ocelot.desktop.geometry.Rect2D
-import ocelot.desktop.graphics.{Graphics, Icons}
+import ocelot.desktop.graphics.{Graphics, IconSource}
 import ocelot.desktop.inventory.SyncedInventory
 import ocelot.desktop.inventory.item._
 import ocelot.desktop.ui.widget.contextmenu.{ContextMenu, ContextMenuEntry}
 import ocelot.desktop.ui.widget.slot._
 import ocelot.desktop.ui.widget.window.Windowed
+import ocelot.desktop.util.DiskDriveAware.ColorValues
 import ocelot.desktop.windows.DiskDriveWindow
 import totoro.ocelot.brain.entity.FloppyDiskDrive
 import totoro.ocelot.brain.entity.traits.Inventory
@@ -31,7 +32,61 @@ trait DiskDriveAware
     floppySlotWidget.item = new FloppyItem.Factory.Loot(Loot.OpenOsFloppy).build()
   }
 
-  protected val colorMap: Map[DyeColor, Int] = Map(
+  def drawActivityAndFloppy(g: Graphics, bounds: Rect2D, prefix: String): Unit = {
+    if (System.currentTimeMillis() - floppyDiskDrive.lastDiskAccess < 400 && Math.random() > 0.1)
+      g.sprite(s"${prefix}Activity", bounds)
+
+    for (item <- floppySlotWidget.item) {
+      g.sprite(
+        s"${prefix}Floppy",
+        bounds.x,
+        bounds.y,
+        bounds.w,
+        bounds.h,
+        IntColor(ColorValues(item.color.value))
+      )
+    }
+  }
+
+  def isFloppyItemPresent: Boolean = floppySlotWidget.item.isDefined
+
+  def eject(): Unit = {
+    floppySlotWidget.item = None
+
+    if (!Audio.isDisabled)
+      SoundSource.MachineFloppyEject.play()
+  }
+
+  def addDiskDriveMenuEntries(menu: ContextMenu): Unit = {
+    menu.addEntry(ContextMenuEntry("Eject", IconSource.Eject) {
+      eject()
+    })
+  }
+
+  override val window: Option[DiskDriveWindow] = Some(new DiskDriveWindow(this))
+}
+
+object DiskDriveAware {
+  val ColorNames: Map[DyeColor, String] = Map(
+    DyeColor.White -> "White",
+    DyeColor.Orange -> "Orange",
+    DyeColor.Magenta -> "Magenta",
+    DyeColor.LightBlue -> "LightBlue",
+    DyeColor.Yellow -> "Yellow",
+    DyeColor.Lime -> "Lime",
+    DyeColor.Pink -> "Pink",
+    DyeColor.Gray -> "Gray",
+    DyeColor.Silver -> "Silver",
+    DyeColor.Cyan -> "Cyan",
+    DyeColor.Purple -> "Purple",
+    DyeColor.Blue -> "Blue",
+    DyeColor.Brown -> "Brown",
+    DyeColor.Green -> "Green",
+    DyeColor.Red -> "Red",
+    DyeColor.Black -> "Black",
+  )
+
+  val ColorValues: Map[DyeColor, Int] = Map(
     DyeColor.Black -> 0x444444, // 0x1E1B1B
     DyeColor.Red -> 0xB3312C,
     DyeColor.Green -> 0x339911, // 0x3B511A
@@ -49,37 +104,4 @@ trait DiskDriveAware
     DyeColor.Orange -> 0xEB8844,
     DyeColor.White -> 0xF0F0F0
   )
-
-  def drawActivityAndFloppy(g: Graphics, bounds: Rect2D, prefix: String): Unit = {
-    if (System.currentTimeMillis() - floppyDiskDrive.lastDiskAccess < 400 && Math.random() > 0.1)
-      g.sprite(s"${prefix}Activity", bounds)
-
-    for (item <- floppySlotWidget.item) {
-      g.sprite(
-        s"${prefix}Floppy",
-        bounds.x,
-        bounds.y,
-        bounds.w,
-        bounds.h,
-        IntColor(colorMap(item.color.value))
-      )
-    }
-  }
-
-  def isFloppyItemPresent: Boolean = floppySlotWidget.item.isDefined
-
-  def eject(): Unit = {
-    floppySlotWidget.item = None
-
-    if (!Audio.isDisabled)
-      SoundSource.MachineFloppyEject.play()
-  }
-
-  def addDiskDriveMenuEntries(menu: ContextMenu): Unit = {
-    menu.addEntry(ContextMenuEntry("Eject") {
-      eject()
-    })
-  }
-
-  override val window: Option[DiskDriveWindow] = Some(new DiskDriveWindow(this))
 }

src/main/scala/ocelot/desktop/windows/RackWindow.scala

@@ -5,9 +5,9 @@ import ocelot.desktop.graphics.Graphics
 import ocelot.desktop.inventory.item.{NetworkCardItem, ServerItem}
 import ocelot.desktop.node.nodes.RackNode
 import ocelot.desktop.ui.layout.{Layout, LinearLayout}
+import ocelot.desktop.ui.widget._
 import ocelot.desktop.ui.widget.slot.RackMountableSlotWidget
 import ocelot.desktop.ui.widget.window.PanelWindow
-import ocelot.desktop.ui.widget._
 import ocelot.desktop.util.Orientation
 import totoro.ocelot.brain.util.Direction
 import totoro.ocelot.brain.util.Direction.Direction

src/main/scala/ocelot/desktop/windows/ScreenWindow.scala

@@ -84,10 +84,12 @@ class ScreenWindow(screenNode: ScreenNode) extends BasicWindow with Logging {
           if (sentTouchEvent) {
             screen.mouseUp(lastMousePos.x, lastMousePos.y, event.button.id, OcelotDesktop.player)
             sentTouchEvent = false
-          } else if (pinButtonBounds.contains(UiHandler.mousePosition)) {
+          }
+          else if (pinButtonBounds.contains(UiHandler.mousePosition)) {
             if (isPinned) unpin() else pin()
             SoundSource.InterfaceClick.play()
-          } else if (closeButtonBounds.contains(UiHandler.mousePosition)) {
+          }
+          else if (closeButtonBounds.contains(UiHandler.mousePosition)) {
             close()
             SoundSource.InterfaceClick.play()
           }