seminar projects crazy|
Active In SP
Joined: Dec 2008
13-06-2009, 04:58 PM
Model-view-controller (MVC) is a software architecture that separates an application s data model, user interface, and control logic into three distinct components so that modifications to one component can be made with minimal impact to the others.
MVC is often thought of as a software design pattern. However, MVC encompasses more of the architecture of an application than is typical for a design pattern. Hence the term architectural pattern may be useful (Buschmann, et al 1996), or perhaps an aggregate design pattern.
In broad terms, constructing an application using an MVC architecture involves defining three classes of modules.
Model: The domain-specific representation of the information on which the application operates. The model is another name for the domain layer. Domain logic adds meaning to raw data (e.g. calculating if today is the user s birthday, or the totals, taxes and shipping charges for shopping cart items).
View: Renders the model into a form suitable for interaction, typically a user interface element. MVC is often seen in web applications, where the view is the HTML page and the code which gathers dynamic data for the page.
Controller: Responds to events, typically user actions, and invokes changes on the model and perhaps the view.
Many applications use a persistent storage mechanism (such as a database) to store data. MVC does not specifically mention this data access layer, because it is understood to be underneath or encapsulated by the Model.
Use Search at http://topicideas.net/search.php wisely To Get Information About Project Topic and Seminar ideas with report/source code along pdf and ppt presenaion
Active In SP
Joined: Jul 2009
13-07-2009, 04:36 PM
Joined: Apr 2012
23-05-2012, 03:34 PM
Model View Controller
Controller.rtf (Size: 460.55 KB / Downloads: 26)
Model - View - Controller (MVC) is an architectural pattern used in software engineering.
The MVC pattern is most commonly used to create interfaces for software applications, and, as the name implies, consists of three elements:
• Model: contains the application data and logic to manage the state of the application.
• View: present the user interface.
• Controller: Handles user inputs to change the state on the application
• View tells to controller handle user inputs
• Controller changes the model state
• Model tells view to update itself
• View reads state information from model and updates itself.
Though MVC comes in different flavors, control flow is generally as follows:
The user interacts with the user interface in some way (for example, by pressing a mouse button).
The controller handles the input event from the user interface, often via a registered handler or callback, and converts the event into an appropriate user action, understandable for the model.
The controller notifies the model of the user action, possibly resulting in a change in the model's state. (For example, the controller updates the user's shopping cart).
A view queries the model in order to generate an appropriate user interface (for example the view lists the shopping cart's contents). The view gets its own data from the model. In some implementations, the controller may issue a general instruction to the view to render itself. In others, the view is automatically notified by the model of changes in state (Observer) that require a screen update.
The user interface waits for further user interactions, which restarts the control flow cycle.
• The separation of responsibilities among the model, view and controller elements allows easy substitution of elements without disruptions to the overall application.
• This lets us easily expand applications based on the MVC pattern to meet changing requirements.
Business applications consist of user interface (UI), business logic, and data models.
When UI, business logic and data are collapsed into one object in rich users interface, it can lead to some of the following problems:
• Difficult to use the data outside that object
• Hard to change the UI, when UI and data are locked in the same object.
• Hard to use multiple views of the same data.
• Difficult to synchronize multiple view of the same data.
Swing is the primary Java GUI widget toolkit. It is part of Oracle's Java Foundation Classes (JFC) — an API for providing a graphical user interface (GUI) for Java programs.
Swing is a platform-independent, Model-View-Controller GUI framework for Java. It follows a single-threaded programming model.
Swing is a Graphical User Interface (GUI) API, offering a set of components that can be used to build rich desktop interfaces. This includes basic elements such as windows, buttons, scrollbars, etc., as well as more complex compound objects such as file choosers, color choosers and combo boxes.
Swing components are Java Beans, and are built around the Model-View-Controller (MVC) programming paradigm. This paradigm separates an application's business logic from its user interface so that they can be evolved independently.
JComponent is the core Controller class which coordinates Models and Views to display a final user component. All Swing components are inherited from JComponent. Note that components can have different views represented by different UIs.
The javax.swing.plaf package contains ComponentUI, which is the core class for the View and is a template for other components that inherit from it. ComponentUI is responsible for the ultimate painting of pixels on the screen.
A Model controls the data in components, from simple things such as the state of a check box, to the more complex rows and columns data structures used for a table. ComboBoxModel and TableModel are example model classes.