Design and Development of a Java-Based CAD Environment for Builders and Architects

Using the MVC Pattern

Musa Abdul1, Lawal Dalhatu Eneyemire2. and Abubakar Muhammad3

Department of Building, College of Environmental Studies, Kaduna Polytechnic.

Correspondence concerning this article should be addressed to Musa Abdul, Department of Building,

College of Environmental Studies, Kaduna Polytechnic. Tel: 08066039366. Email:

[email protected]

A Journal Paper Submitted for Publication in the Journal of Environment Management and

Construction Research

of the Berkeley Nigeria Publications

1
Abstract

This research presents the design and development of a Java-based CAD environment specifically

tailored for builders and architects, utilizing the Model-View-Controller (MVC) design pattern. The

proposed CAD environment aims to address the limitations of existing commercial CAD tools, including

high costs, lack of flexibility, and difficulties in integration with existing workflows. The development

process incorporated various features of the Java programming language, including the Java Module

System, Java2D for rendering shapes and applying affine transforms, and Java Swing for constructing the

graphical user interface (GUI). The CAD environment aims to replicate the core functionalities of

established tools like AutoCAD, providing a robust platform for architectural and construction design.

The performance of this Java-based CAD environment was found to be excellent in comparison to

AutoCAD, offering a viable alternative for professionals in the field. However, several enhancements are

recommended for future iterations. Expanding the feature set to include 3D modelling capabilities would

significantly increase its utility. Additionally, transitioning the GUI development from Java Swing to

JavaFX could improve the user experience by leveraging JavaFX's advanced interface features. These

improvements would further establish this CAD environment as a comprehensive tool for architectural

and construction applications.

Keywords: Java-Based CAD, CAD Environment, MVC Pattern, CAD Development, Java Programming

2
Background

In construction and architecture, CAD tools are essential for creating detailed designs, managing

complex projects, and aiding communication among stakeholders. Popular tools like AutoCAD and Revit

dominate the market but have significant drawbacks, including high costs and limited customization,

particularly for small and medium-sized firms. AutoCAD, renowned for its versatility in 2D and 3D

modelling, has high licensing fees and a steep learning curve. Revit, a leader in Building Information

Modelling (BIM), integrates architectural, structural, and MEP systems but is expensive and requires

specialized training. ArchiCAD, another BIM tool, is favoured for its user-friendly interface but shares

similar cost and training barriers. SketchUp is more affordable and easier to use but lacks the technical

depth of AutoCAD and Revit. Microsoft Project, while not a CAD tool, is widely used for project

management but is also expensive and complex for small firms (Ali et al., 2022; Autodesk, 2024; Azhar et

al., 2012; Baj-Rogowska, 2020; Barbash, 2022; Boeykens, 2011; Chopra & Town, 2008; Desai et al., 2023;

Divin, 2020; McMahon & Browne, 1998; Pratisto & Girsang, 2022; Sacks, Eastman , Lee, 2018; Sampaio

et al., 2021; SketchUp, 2019; Song & Jing, 2020; Syed & Manzoor, 2022; Tubielewicz-Michalczuk, 2019;

Waas & Enjellina, 2022; Wale et al., 2015).

Problem Statement

The widespread use of commercial CAD tools is hindered by high costs, limited customization,

and integration challenges. Many of these tools are difficult to update and adapt due to their monolithic

design. There is a need for a flexible, modular, and easy-to-use CAD environment tailored to the specific

needs of professionals in construction and architecture.

Objectives

1. Design and develop a CAD environment for builders and architects using Java.

2. Implement the Model-View-Controller (MVC) design pattern to ensure modularity and

scalability.

3
 3. Evaluate the performance and usability of the developed CAD environment in real-world

applications.

Scope

This paper analyses current CAD tools, explores Java’s potential for CAD development, and

evaluates a newly developed 2D drafting tool. Future iterations may extend the tool to 3D and other

advanced features.

Overview of CAD Tools for Builders and Architects

Popular CAD tools like AutoCAD, Revit, ArchiCAD, SketchUp, and Microsoft Project are

indispensable but pose challenges like high costs and limited customization. AutoCAD excels in 2D

drafting but is costly, while Revit offers robust BIM features but requires significant investment in

training. ArchiCAD is more design-focused but shares similar limitations. SketchUp is easier to use but

lacks advanced capabilities. Microsoft Project is essential for managing project timelines and budgets but

is expensive and complex (Ahmed & Al-Zubaydi, 2013; Ali et al., 2022; Autodesk, 2024; Baj-Rogowska,

2020; Barbash, 2022; Chopra & Town, 2008; Desai et al., 2023; Divin, 2020; Eastman, C., Teicholz, P.

Sacks, 2018; Li et al., 2024; Pratisto & Girsang, 2022; Sampaio et al., 2023; SketchUp, 2019; Song & Jing,

2020; Syed & Manzoor, 2022; Waas & Enjellina, 2022; Wale et al., 2015).

Java Programming Language in CAD Development

Java, known for its cross-platform portability and robust performance, is ideal for CAD

development. Java2D and JavaFX are suited for rendering 2D graphics and building user interfaces, while

Java’s modular system allows for creating flexible and maintainable applications. Swing remains useful

for GUI development, though JavaFX offers more modern features. Java2D supports advanced 2D

graphics essential for CAD tools, and Java3D allows for 3D modelling but is less commonly used.

JavaFX, with its modern design and multimedia capabilities, is a strong alternative to Swing (Bellotti et

al., 2001; Bergmann, 2017; Bloch, 2018; Burrows & England, 2002; Calçada & Bernardino, 2022; Chin et

al., 2021; Deitel, 2017; Deitel & Deitel, 2018; Fischer & El Saddik, 1999; Franklin, 2024; Horstmann, 2022;

4
Jackson, 2017; Jecan, 2017; Juneau et al., 2012; Liguori & Liguori, 2017; Mak & Bakker, 2017; Oracle,

2024; Rowe et al., 2019; Schmid et al., 2010; Sharan & Späth, 2022; Vlachkova & Boikova, 2012).

Model-View-Controller (MVC) Design Pattern in Software Engineering

The MVC design pattern divides an application into three components: the Model (data), the

View (user interface), and the Controller (user input). In CAD development, MVC separates the graphical

rendering from the underlying data structures, enhancing modularity and flexibility. This pattern allows

for independent updates to different components and promotes reusability, making it easier to add features

and customize the application for various users (Arcos-Medina et al., 2018; Dewan, 2005; Gamma et al.,

1998; Larman, 2004; Lyon & Weiman, 2007; Pinandito et al., 2017).

Gaps in the Literature

While CAD tools are well-researched, open-source, customizable environments using modern

programming paradigms like MVC are underdeveloped. The potential of Java for CAD applications in

construction and architecture also remains underexplored.

Methodology

Research Design

This research employs a design science methodology, focusing on the creation and evaluation of

an artifact: a CAD environment for builders and architects. The development process follows an iterative

approach, including cycles of requirements gathering, design, implementation, testing, and refinement.

Development Process

The development process begins with gathering requirements from existing CAD Applications

such as AutoCAD and industry professionals to ensure that the CAD environment meets the specific

needs of builders and architects. The system is then designed using Java, with the MVC pattern applied to

ensure modularity. The implementation phase involves coding the tool's core functionalities, such as 2D

drafting and layer management, while the testing phase includes performance benchmarking and user

evaluations.

5
Implementation of MVC Design Pattern

The MVC pattern is implemented by dividing the system into three main components: the Model,

which includes data structures for storing geometric shapes and project information; the View, which

displays the CAD elements for drawing and editing and the Controller which provides the graphical user

interface (GUI), which manages user inputs and updates the Model which in turn notifies the View to

modify the display accordingly. This separation allows for independent development and testing of each

component, enhancing the overall maintainability of the system.

The MVC pattern is implement using java’s observable class and observer interface. The Model

is the Observable class, while the View and the Controller both implemented the Observer interface. The

Model, registers the View and the Controller as Observers, so that when changes occur in the Model, it

will notify the registered Observers and the Observers will effect the changes in turn. The View will

automatically update its display, reflecting the changes, while the Controller will update its change flag,

so that, when attempted is made to close the working file, it will prompt users to save the file, before

closing.

Evaluation and Testing

The CAD environment is evaluated through a combination of performance metrics, such as

rendering speed and memory usage, and qualitative feedback from users. Testing scenarios include typical

tasks performed by builders and architects, such as creating floor plans, annotating designs, and managing

project layers. User feedback can be gathered through surveys and interviews, focusing on usability,

functionality, and satisfaction with the customization options.

System Architecture

The system architecture is based on the MVC pattern, with clearly defined roles for each

component. The Model handles data structures related to geometric entities (e.g., lines, circles, polygons)

and project metadata (e.g., layer information, annotations). The View component renders these entities on

6
the screen, providing tools for drawing, editing, and navigating. The Controller mediates between the user

inputs and the Model, ensuring that the appropriate updates are reflected in the View.

Key Features of the CAD Environment

Key features of the CAD environment include 2D drafting capabilities, layer management, object

snapping, and customizable toolbars. Advanced features such as parametric modelling and the ability to

import/export project files in various formats are planned for future iterations. The tool is designed to be

extendable, allowing users to add new functionalities as plugins or modules. The CAD Environment is

implemented using the java module system. Basically, four modules were defined as follows: application

module (com.abdul.cad.app), model module (com.abdul.cad.model), view model(com.abdul.cad.view)

and controller module (com.abdul.cad.controller). Modules in java are saved with unique name as

module-info.java. module-info.java for the CAD Environment modules are defined as follows:

Application Module (com.abdul.cad.app)

The class responsible for running the application is defined in package com.abdul.cad.app in the

module com.abdul.cad.app. The class is named KadPolyCAD.

The module is defined as follows:

module com.abdul.cad.app {

requires java.desktop;

requires com.abdul.cad.model;

requires com.abdul.cad.view;

requires com.abdul.cad.controller;

Model Module (com.abdul.cad.model)

The Model class is defined in package com.abdul.cad.model in the module com.abdul.cad.model.

The class is named CAD_Model. This will comprise of the different drawing elements of the CAD.

Therefore, the Element class will also be defined in the same package with the Model class.

The module is defined as follows:

module com.abdul.cad.model {

exports com.abdul.cad.model;

7
 }

View Module (com.abdul.cad.view)

The View class is defined in package com.abdul.cad.view in the module com.abdul.cad.view. The

class is named CAD_View.

The module is defined as follows:

module com.abdul.cad.view {
exports com.abdul.cad.view;
requires java.desktop;
requires com.abdul.cad.model;
}

Controller Module (com.abdu.cad.controller)

The Controller class is defined in package com.abdul.cad.controller in the module

com.abdul.cad.controller. The class is named CAD_Controller.

The module is defined as follows:

module com.abdul.cad.controller {
exports com.abdul.cad.controller;
requires java.desktop;
requires com.abdul.cad.model;
requires com.abdul.cad.view;
}

Model, View, Controller Classes Implementation

The implementation only shows the classes names and methods signatures. The detail attributes

declaration and code implementation details were omitted, due to pages requirement limitation.

The Model

The model, named CAD_Model, is implemented as an observable class. Observable class is in

java.util package in java.base module. Anytime the Model changes, the affected elements notifies

registered Observers.

CAD_Model Implementation

package com.abdul.cad.model
public class CAD_Model extends Observable implements Serializable{
public Model() {
}
List<Element> elementList = new LinkedList<>();
public boolean remove(Element element) {
}
public boolean removeAll(List<Element> elements){
}
public void add(Element element) {

8
 elementList.add(element);
setChanged();
notifyObservers(element.getBounds());
}
public boolean addAll(List<Element> elements){
boolean added = elementList.addAll(elements);
if(added){
setChanged();
for(Element ele : elements)
notifyObservers(ele.getBounds());
}
return added;
}
}

Element Class Implementation

The Element class is implemented as an abstract class, to serve as a parent class or super class, so

that all Elements will inherit from it. The ensures, all the different elements: line, rectangle, circle, etc. are

treated as the parent class, Element. This is Polymorphism. The main methods are implemented as

abstract methods in the Element class. Their implementations are left to the concrete classes: Line,

Rectangle, Circle, etc.

package com.abdul.cad.model;
public abstract class Element implements Serializable, Shape {
public Element(){ }
public Element(Color color) { }
public abstract void modify(Point start, Point last);
public abstract void draw(Graphics2D g2D);
public abstract java.awt.Rectangle getBounds();
public abstract Rectangle2D getBounds2D();
public abstract void setOutline();
public abstract boolean contains(Point p);
public abstract Element copy(Point base, Point next);
public abstract Element offset(double distance, Point side);
public static class Line extends Element {
private Line2D.Double line;
public int x1, x2, y1, y2;
public Line(){ }
public Line(Point start, Point end, Color color){ }
public Line(Line line){ }
public Point getPosition(){ }
public double calcAng(Line2D.Double lin, Point start, Point last){ }
public void draw(Graphics2D g2D) { }
public void setOutline(){ }
public Element offset(double distance, Point side){ }
public Element copy(Point base, Point next){ }
public boolean contains(Point p) { }
public java.awt.Rectangle getBounds() { }
public Rectangle2D getBounds2D() { }
private void writeObject(ObjectOutputStream out) throws IOException { }
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException { }
}
public static class Rectangle extends Element{
private Rectangle2D.Double rectangle;
…
}
public static class Circle extends Element{
private Ellipse2D.Double circle;
…
}

9
 public static class Arc extends Element{
private Arc2D.Double arc;
…
}
public static class Polygon extends Element{
private GeneralPath polygon;
…
}
public static class Ellipse extends Element{
private Ellipse2D.Double ellipse;
…
}
public static class Beam extends Element{ … }
public static class Column extends Element{ … }
public static class Frame extends Element{ }
public static class Loading extends Element{ … }
public static class Support extends Element{ … }
}

The View

The View Class is implemented as a drawing container and also as an Observer, for observing

changes in the Model and updating the View to reflect the changes as appropriate. The drawing container

used for this purpose, is the java’s JPanel. When the View is notified of changes, it will automatically

request for such changes, by calling the method named update, which will in turn, update the display

reflecting the changes. The display is implemented in the method, paintComponent as shown. The View,

redraws the elements that changes with the new updates.

View Class Implementation

package com.abdul.cad.view;
import com.abdul.cad.model.*;
public class CAD_View extends javax.swing.JPanel implements Observer{
public View() { }
public View(KadPolyCAD theApp){ }
public static void setUnit(String unt){ }
public static String getUnit(){ }
public void paintComponent(Graphics g) {
super.paintComponent(g);
Graphics2D g2D = (Graphics2D)g;
AffineTransform at = g2D.getTransform();
Iterator<Element> elements = theApp.getModel().getIterator();
Element element;
while(elements.hasNext()){
elements.next().draw(g2D);
}
}
public void zoomRealtime(int val){ }
public void setZoomScale(double val){ }
public double getZoomScale(){ }
public void moveCursor(Graphics2D g){ }
public void update(Observable o, Object rectangle){
if(rectangle == null)
repaint();
else
repaint((Rectangle)rectangle);
}
public void setZoom(boolean val){ }
public boolean isZoomOn(){ }

10
 Private class MouseHandler extends MouseInputAdapter {
public void mousePressed(MouseEvent e) { }
public void mouseEntered(MouseEvent e){ }
public void mouseExited(MouseEvent e){ }
public void mouseDragged(MouseEvent e) { }
public void mouseReleased(MouseEvent e) { }
public void mouseClicked(MouseEvent e) { }
public void mouseMoved(MouseEvent e) { }
}
}

The Controller

The Controller is basically the graphical user interface (GUI), for displaying the View and also

for interacting with the model. The Controller is implemented as a JFrame, with View display, menus,

toolbars and command prompt. The user interface (UI) is designed with simplicity and efficiency in mind.

It includes a canvas for displaying the View, toolbars, menus and command prompt for accessing common

functions, and context menus for quick actions. The UI is customizable, enabling users to rearrange

toolbars, create shortcuts, and adjust preferences to suit their workflow. Interaction is primarily through

mouse and keyboard inputs, with support for touchscreens and graphic tablets planned for future updates.

The Controller is also implemented as an Observer, so that changes to file can be monitored, and prompt

users to save file, while window is being closed.

Controller Class Implementation

package com.abdul.cad.controller;
import com.abdul.cad.app.KadPolyCAD;
import com.abdul.cad.view.View;
import com.abdul.cad.model.*;
public class CAD_Controller extends JFrame implements Observer{
public Controller() { … }
public Controller(String title, KadPolyCAD theApp){ … }
public void setView(javax.swing.JPanel component) { … }
public void update(java.util.Observable o, Object obj){
isFileChanged = true;
}
public void createActions(){
setNewFileAction();
setSaveAction();
setDrawLineAction();
…
}
public void createCommandActions() { … }
public void createMenu(){
setFileMenu();
setEditMenu();
setViewMenu();
setZoomMenu();
…
}
public void createToolbars(){
setStandardToolbar();
setDrawingToolbar();
setModifyDrawingToolbar();

11
 setLayerToolbar();
…
}
}

Performance Analysis

The performance analysis demonstrates that the CAD environment is capable of handling typical

design tasks with efficiency. Rendering times for complex drawings are competitive with commercial

tools, and memory usage remains within acceptable limits, even for large projects. The modular design,

facilitated by the MVC pattern, allows for smooth updates and expansions without significant impact on

performance.

Comparison with Existing CAD Tools

When compared to existing CAD tools, the developed environment offers several advantages,

including lower costs, greater flexibility, and enhanced customization options. However, it lacks some of

the advanced features found in commercial tools, such as 3D modelling and advanced rendering. These

limitations are acknowledged, with plans for future development to address them.

User Feedback

User feedback highlights the tool's ease of use, particularly its intuitive interface and the ability to

customize workflows. Builders and architects appreciate the modularity of the system, which allows them

to add or remove features as needed. Even though advanced features such as 3D modelling capabilities

are missing, the tool’s potential for expansion in this area are recognised.

Summary of Contributions

This paper presents the design and development of a Java-based CAD environment for builders

and architects, utilizing the MVC design pattern. The tool offers a flexible, scalable, and user-friendly

alternative to existing CAD tools, addressing the specific needs of professionals in the building and

architecture sectors. The modular architecture enables easy customization and maintenance, making the

tool a valuable asset for small to medium-sized firms.

Implications for Practice

12
 The developed CAD environment has the potential to significantly improve the workflows of

builders and architects, offering a cost-effective and adaptable solution. Its modular design allows for

continuous updates and expansions, ensuring that the tool can evolve with the needs of its users.

Limitations

The primary limitations of the tool include its current focus on 2D drafting and the absence of

advanced 3D modelling capabilities. Additionally, while Java provides many benefits, its performance

may be less optimal when handling extremely large datasets or highly complex models.

Future Research Directions

Future research should explore the integration of 3D modelling capabilities into the CAD

environment, as well as the development of plugins for specific industry needs. Additionally, investigating

the use of machine learning and artificial intelligence in automating design tasks within the environment

could provide significant advancements.

13
References

Ahmed, O., & Al-Zubaydi, T. (2013). Building Models Design And Energy Simulation With Google
Sketchup And. Journal of Advanced Science and Engineering Research, 3(4).

Ali, S. B. M., Mehdipoor, A., Samsina Johari, N., Hasanuzzaman, M., & Rahim, N. A. (2022). Modeling and
Performance Analysis for High-Rise Building Using ArchiCAD: Initiatives towards Energy-Efficient
Building. Sustainability (Switzerland), 14(15). https://doi.org/10.3390/su14159780

Arcos-Medina, G., Menéndez, J., & Vallejo, J. (2018). Comparative Study of Performance and Productivity
of MVC and MVVM design patterns. KnE Engineering, 1(2). https://doi.org/10.18502/keg.v1i2.1498

Autodesk. (2024). Revit API Developers Guide. Autodesk Inc.

Azhar, S., Khalfan, M., & Maqsood, T. (2012). Building information modeling (BIM): Now and beyond.
Australasian Journal of Construction Economics and Building, 12(4).
https://doi.org/10.5130/ajceb.v12i4.3032

Baj-Rogowska, A. (2020). AutoCAD: Examination of factors influencing user adoption. Engineering

Management in Production and Services, 12(1), 45–56. https://doi.org/10.2478/emj-2020-0004

Barbash, М. (2022). ARCHICAD IN ENGINEERING AND CONSTRUCTION GRAPHICS OF BUILDERS AND

ARCHITECTS. Technical Sciences and Technologies, 4(30), 187–194. https://doi.org/10.25140/2411-
5363-2022-4(30)-187-194

Bellotti, F., Berta, R., De Gloria, A., & Poggi, A. (2001). DirectJ: Java APIs for optimized 2D graphics.
Software - Practice and Experience, 31(3). https://doi.org/10.1002/spe.365

Bergmann, S. (2017). Introduction to Computer Science with Java Programming. In Introduction to

Computer Science with Java Programming. https://doi.org/10.31986/issn.2689-0690_rdw.oer.1000

Bloch, J. (2018). Effective Java Third Edition (3rd ed.). Addison-Wesley.

Boeykens, S. (2011). Using 3D design software, BIM and game engines for architectural historical
reconstruction. Designing Together: CAADFutures 2011 - Proceedings of the 14th International
Conference on Computer Aided Architectural Design.

Burrows, A. L., & England, D. (2002). Java 3D, 3D graphical environments and behaviour. Software -
Practice and Experience, 32(4). https://doi.org/10.1002/spe.441

Calçada, A., & Bernardino, J. (2022). Experimental Evaluation of Low Code development, Java Swing and
JavaScript programming. ACM International Conference Proceeding Series.
https://doi.org/10.1145/3548785.3548792

14
Chin, S., Vos, J., Weaver, J., Anderson, G., Anderson, P., Borges, B., Epple, A., Gao, W., Giles, J., Pereda, J.,
Reimers, S., Ryzhikov, E., & Siqueira, W. A. (2021). The Definitive Guide to Modern Java Clients with
JavaFX 17: Cross-Platform Mobile and Cloud Development, Second Edition. In The Definitive Guide
to Modern Java Clients with JavaFX 17: Cross-Platform Mobile and Cloud Development, Second
Edition. https://doi.org/10.1007/978-1-4842-7268-8

Chopra, A., & Town, L. (2008). Introduction to Google SketchUp. Wiley Pathways.

Deitel, P. (2017, September). Understanding Java 9 Modules.

Https://Www.Oracle.Com/Ng/Corporate/Features/Understanding-Java-9-Modules.Html.

Deitel, P., & Deitel, H. (2018). Java How to Program Early Objects Eleventh Edition (11th ed.). Pearson
Education Limited.

Desai, N. V., Yadav, N. B., & Malaviya, N. N. (2023). Increasing the potential application of Microsoft
project and Primavera P6 for project management: A comparative analysis of the residential
project. Materials Today: Proceedings, 77. https://doi.org/10.1016/j.matpr.2022.11.485

Dewan, P. (2005). Teaching inter-object design patterns to freshmen.

https://doi.org/10.1145/1047344.1047498

Divin, N. V. (2020). BIM by using Revit API and Dynamo. A review. AlfaBuild, 14(2).

Eastman, C., Teicholz, P. Sacks, R. and G. L. (2018). BIM Handbook - A Guide to Building Information
Modelling for Owners, Designers, Engineers, Contractors, and Facility Managers. In Wiley and Sons.

Fischer, S., & El Saddik, A. (1999). Java-Swing. In Open Java. https://doi.org/10.1007/978-3-642-58396-

4_8

Franklin, C. (2024, January 17). A Guide to Java Modularity. Https://Www.Baeldung.Com/Java-

Modularity.

Gamma, E., Vlissides, J., Johnson, R., & Helm, R. (1998). Design Patterns CD: Elements of Reusable
Object-Oriented Software, (CD-ROM). Design Patterns CD: Elements of Reusable Object-Oriented
Software, (CD-ROM.

Horstmann, C. S. (2022). Core Java, Volume II Advanced Features (12th ed., Vol. 2). Oracle Press.

Jackson, W. (2017). Pro Java 9 Games Development: Leveraging the JavaFX APIs. In Pro Java 9 Games
Development: Leveraging the JavaFX APIs. https://doi.org/10.1007/978-1-4842-0973-8

Jecan, A. (2017). Java 9 Modularity Revealed: Project Jigsaw and Scalable Java Applications. In Java 9
Modularity Revealed: Project Jigsaw and Scalable Java Applications. https://doi.org/10.1007/978-1-
4842-2713-8

Juneau, J., Dea, C., Guime, F., & O’Conner, J. (2012). Java 2D Graphics. In Java 7 Recipes.
https://doi.org/10.1007/978-1-4302-4057-0_12

Larman, C. (2004). Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design
and Iterative Development. In Analysis.

15
Li, B., Pang, H., & Tian, H. (2024). Digital Intelligent Design of Interior Solutions: Exploring Embedded
Systems for SketchUp Modeling. Computer-Aided Design and Applications, 21(S8).
https://doi.org/10.14733/cadaps.2024.S8.146-165

Liguori, R., & Liguori, P. (2017). Java Pocket Guide. In Program (Issue January).

Lyon, D. A., & Weiman, C. (2007). Observer-conditioned-observable design pattern. Journal of Object
Technology, 6(4). https://doi.org/10.5381/jot.2007.6.4.c2

Mak, S., & Bakker, P. (2017). Java 9 modularity: patterns and practices for developing maintainable
applications. O’Reilly Media, Inc.

McMahon, C., & Browne, J. (1998). CADCAM: Principles, Practice, and Manufacturing Management.
Addison-Wesley. https://books.google.com.ng/books?id=d2NnQgAACAAJ

Oracle. (2024). Java® Platform, Standard Edition & Java Development Kit Version 22 API Specification.
Https://Docs.Oracle.Com/En/Java/Javase/22/Docs/Api/Index.Html.

Pinandito, A., Permana, F. B. P., & Perdana, R. S. (2017). Framework Design for Modular Web-based
Application Using Model-CollectionService-Controller-Presenter (MCCP) Pattern. Journal of
Information Technology and Computer Science, 2(1). https://doi.org/10.25126/jitecs.20172120

Pratisto, D., & Girsang, H. (2022). Scheduling with Microsoft Project Professional and Oracle Primavera
P6:(Case Study: Hotel Development Project of Soekarno-Hatta Airport Terminal 3 Ultimate). World
Journal of Innovation and Technology, 3(1).

Rowe, S. P., Solnes, L. B., Yin, Y., Kitchen, G., Lodge, M. A., Karakatsanis, N. A., Rahmim, A., Pomper, M. G.,
& Leal, J. P. (2019). Imager-4D: New Software for Viewing Dynamic PET Scans and Extracting
Radiomic Parameters from PET Data. Journal of Digital Imaging, 32(6).
https://doi.org/10.1007/s10278-019-00255-7

Sacks, Eastman , Lee, T. (2018). BIM handbook : a guide to building information modeling for owners,
designers, engineers, contractors, and facility managers / by Rafael Sacks, Charles Eastman, Ghang
Lee, Paul Teicholz. Description: In ACS Applied Materials & Interfaces (Vol. 11, Issue 19).

Sampaio, A. Z., Azevedo, G., & Gomes, A. (2023). BIM Manager Role in the Integration and Coordination
of Construction Projects. Buildings, 13(8). https://doi.org/10.3390/buildings13082101

Sampaio, A. Z., Gomes, A. M., & Farinha, T. (2021). BIM Methodology Applied in Structural Design:
Analysis of Interoperability in ArchiCAD/ETABS Process. Journal of Software Engineering and
Applications, 14(06). https://doi.org/10.4236/jsea.2021.146012

Schmid, B., Schindelin, J., Cardona, A., Longair, M., & Heisenberg, M. (2010). A high-level 3D visualization
API for Java and ImageJ. BMC Bioinformatics, 11. https://doi.org/10.1186/1471-2105-11-274

Sharan, K., & Späth, P. (2022). Learn JavaFX 17: Building User Experience and Interfaces with Java. In
Learn JavaFX 17: Building User Experience and Interfaces with Java. https://doi.org/10.1007/978-1-
4842-7848-2

SketchUp, G. (2019). 3D Design Software 3D Modeling on the Web SketchUp. SketchUp.

16
Song, Y., & Jing, Y. (2020). Urban planning and design based on autocad to expand gis function.
Computer-Aided Design and Applications, 17(Special Issue 2).
https://doi.org/10.14733/cadaps.2020.S2.11-21

Syed, E. U., & Manzoor, K. M. (2022). Analysis and design of buildings using Revit and ETABS software.
Materials Today: Proceedings, 65. https://doi.org/10.1016/j.matpr.2022.04.463

Tubielewicz-Michalczuk, M. (2019). Fence Designs with ArchiCAD Software. IOP Conference Series:
Materials Science and Engineering, 471(8). https://doi.org/10.1088/1757-899X/471/8/082001

Vlachkova, K., & Boikova, M. (2012). Interactive 3D Visualization of Bézier Curves using Java Open
Graphics Library (JOGL). Serdica Journal of Computing, 5(4).
https://doi.org/10.55630/sjc.2011.5.323-332

Waas, L., & Enjellina. (2022). Review of BIM-Based Software in Architectural Design: Graphisoft Archicad
VS Autodesk Revit. Journal of Artificial Intelligence in Architecture, 1(2).
https://doi.org/10.24002/jarina.v1i2.6016

Wale, P. M., Jain, N. D., Godhani, N. R., Beniwal, S. R., & Mir, A. A. (2015). Planning and Scheduling of
Project using Microsoft Project (Case Study of a building in India). IOSR Journal of Mechanical and
Civil Engineering Ver. III, 12(3).

17