CMT 3315 Advanced Web Technologies: February 2011

Friday, 18 February 2011

lab 15

CMT3315 – Laboratory 15 – 18 February ’11

Friday 4:30 am H104

Quick questions:

The XSL family of languages can use a stylesheet to transform an XML document into an HTML document, which can be displayed by a web browser, with sophisticated formatting that takes account of the special features of the information in the XML document. Some web programmers, however, prefer to use a CSS stylesheet to look after the formatting of the XML document. Why?
Sometimes, you will see an XSL stylesheet whose namespace declaration looks like this:

<xsl:stylesheet version=”1.0”

xmlns:xsl=http://www.w3.org/1999/XSL/Transform>

And sometimes you will see an XSL stylesheet whose namespace declaration looks like this:

<xsl:transform version=”1.0”

xmlns:xsl=http://www.w3.org/1999/XSL/Transform>

What difference does this make to the functioning of the stylesheet?

In XSL, what is the difference between “pull” transformations and “push” transformations?

Longer question:

Consider the following XML document, which is part of a list of staff allocations in a hospital:

<?xml version="1.0"?>

<?xml-stylesheet type="text/xsl" href="stylingXSL.xsl"?>

<staff-roll xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

<name>Joe White</name>

<departmental-jobs>

<duties>heart surgery</duties>

</department>

</departmental-jobs>

</post>

</post>

<name>A. Adeleke</name>

<departmental-jobs>

<duties>general ward nursing

</duties>

</department>

</departmental-jobs>

</post>

<name>D. Borg

</name>

<departmental-jobs>

<duties>general ward nursing</duties>

</department>

<duties>general ward nursing

</duties>

</department>

</departmental-jobs>

</post>

<name>E. Said

</name>

</post>

</staff-roll>

Clearly, it is intended to use an XSL stylesheet called stylingXSL.xsl. Here is a first attempt at this stylesheet:

<?xml version="1.0"?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="/">

<HTML>

<HEAD>

<TITLE>Staff deployment</TITLE>

</HEAD>

<BODY>

<H1> Staff and their departmental duties </H1>

<H2>

Name: <xsl:value-of select="staff-roll/post/name"/>

<br/>

Job title: <xsl:value-of select="staff-roll/post/@type"/>

</H2>

</BODY>

</HTML>

A browser will display this as follows:

</xsl:template>

</xsl:stylesheet>

Extend stylingXSL.xsl so that it displays details of all the staff in the XML document.

Thursday, 17 February 2011

Friday, 4 February 2011

TENTH TASK

Download a free version of XML Spy. What does it do? How well does it do? Write a brief essay (2 to 4 pages) to answer these questions.

Overview

XMLSpy is part of a suite of products from Altova that are aimed at helping you move around in, work with, edit, create and manage XML-based entities. From XML to XSLT to WSDL and even SOAP-based entities, XMLSpy is built to give you all sorts of tools to work with your XML resources. Working with XMLSpy is a very interesting prospect -

With XMLSpy, you have the tools to work in an environment specifically built to work with XML. The entire suite of products runs the range of technologies working with XML. From MapForce to StyleVision to SchemaAgent and even DatabaseSpy, the suite is built to give you gui-based tools to work through your information systems, build out the full range of XML and related documents and schemas and more.

XMLSpy 2011 remains the leading, industry-standard XML development tool thanks to its easy-to-use, intuitive interface and powerful utilities, which simplify and accelerate the XML development process. Below is a list of just some of the robust features available in XMLSpy 2011: which offers both students, and programmers the ablility to use almost everything from validation to well- formedness parsers and etc. because this important as to every code you write is has to be validated and well-formed.

XML design, editing, validation, and well-formedness checking
Schema-aware XSLT 1.0/2.0 editing, debugging, and profiling
Instant transformation of XML documents
Grahical XML Schema and DTD design, editing, and documentation
Modeling and management of schemas and their components across workgroups
XPath 1.0/2.0 Analyzer window and builder
Schema-aware XQuery editing, debugging, and profiling
SOAP client and debugger
Support for all major relational databases
Graphical WSDL editor
Java, C++, C# code generation based on XML Schema
Integration with Microsoft Visual Studio and Eclipse
XML-aware file and directory differencing/merging
Project management capabilities
WebDAV client interface support

Using the System

XML is a big undertaking. There are a lot of different aspects to working with XML effectively. This is precisely why XMLSpy can bring so much to the table in your own installations. Part of the issue with XML is that you want to constantly have properly formed XML documents, from the data elements to the formatting and tags and so-on. With XMLSpy, you get the help you need to stop worrying so much about the framework and more about what you're trying to accomplish.

For example, XMLSpy will analyze your document and make sure, as you work with it, that you're presented with the elements, types, structure and other information you need.

What XMLSpy does so well is to give you the information you need to work with your XML document effectively. Providing this level of visibility - from the enumeration (values) associated with a given element to the data type to the structure of the elements - this visibility will save you huge amounts of time as you work with your documents. Why? Because you won't be guessing at the next element, the structure, the design of your data.

Moving around XMLSpy is at first overwhelming - there are many options and diffrent tools you can use to explore and work with your document. From layout tools to analysis tools, to different ways to simply review and use your documents, there is much that you can do. While it's a lot to digest at first, once you get used to moving around, the fact that the menu options and toolbars activate and deactivate depending on where you are in the application makes it easier to learn.

XMLSpy also includes debugging tools. You can work with your SOAP-based systems, work with XQuery and more. The software has done a good job of figuring out what types of things you'll be working with and doing with XML, then creating a visual tool to work with that data.

XMLSpy also integrates wtih Visual Studio and directly integrates with databases.

There are so many ways to approach XML - everyone uses different standards, different combinations of stylesheets, schemas, etc. XMLSpy does a fantastic job exposing your information using whatever tools and approaches you need. You're not locked in to seeing it in text, you can use the grid view or any of the other tools and options for working with your data. You'll be covered.

Conclusion

I admit it. I was cynical when I started working with XMLSpy. I've always been a "use notepad..." kind of person, or jumping into Visual Studio and working directly with XML there and manually creating the supporting documents, structures and so-on.I'm a convert now, though, I have to tell you. I'm amazed at how quickly you can see, understand and work with an unknown XML document once you've brought it into XMLSpy. By giving you outstanding graphical tools to inspect the data, you can quickly see the element tree and what's happening, without any guess-work.

I'm very impressed with the difference it brings just in providing multiple ways to show you information, let you work with it, validate it and so-on. Clearly applications that touch and use XML benefit directly and immediately from the ability to test the structure, confirm the elements and generally have things working as they should.

Ninth Task

What is XIML and how is it used? Give examples.

DEFINTION

XIML is an XML-based "interface representation language for universal support of functionality across the entire lifecycle of a user interface: design, development, operation, management, organization, and evaluation " (Puerta, 2002).

Abstract

In recent years, there have been a number of industry and academic efforts to standardize the representation of many types of data in order to facilitate the interoperability of applications. There is, however, no comparable effort aimed at interaction data, the data that relates to user interfaces. We introduce XIML (eXtensible Interface Markup Language), a proposed common representation for interaction data. We claim that XIML fulfills the requirements that we have found essential for a language of its type: (1) it supports design, operation, organization, and evaluation functions, (2) it is able to relate the abstract and concrete data elements of an interface, and (3) it enables knowledge-based systems to exploit the captured data. In this paper, we introduce the characteristics of XIML, its scope and validation, and a proposed path for industry adoption.

In May 2008 XIML was selected as a finalist for the following awards:

ZDNet Australia and CeBIT 2008 Emerging Innovation Award.
CeBIT.AU Excellence in New Media Award 2008.
CeBIT.AU Early Innovators Award 2008.
TechRamp 2008 competition, demoed at Transaction 2.0 Conference.

XIML is the easiest way to build interactive website. It is very flexible and fully configurable, any creative idea can be implemented without any limitations. Its markup language is very intuitive and so simple, everyone can understand and use.

Thebasic example below is to get the feel for XIML. 4 objects - 4 lines of code. Simple and straightforward:

Features of XIML

Here is the Result(There is quite a problem with the image to be displayed on the blog the anyway picture represents two rectangular squares aligned to together formatted with the use of XIML)

Hello, World!

In a more practical sense, however, it is to be expected that an XIML specification would support a relatively small number of components with one major type of element defined per component. For example, XIML 1.0 predefines five basic interface components, namely task, domain, user, dialog, and presentation. While the first three components can be characterized as abstract, the last two can be described as concrete:

The components predefined in the first version of XIML were selected by studying a large variety of previous efforts in creating interface models. Furthermore, XIML is extensible, so that other components can be added in the future once their presence is justified.

XIML can be used to effectively display a single interface definition on any number of target devices. This is made possible by the strict separation that XIML makes between the definition of the user interface and the rendering of that interface (i.e. the actual display of the interface on a target device).

The structure of XIML

XIML

COMPONENTS RELATIONS ATTRIBUTES

ELEMENTS STATEMENTS DEFINITIONS

References: http://www.crunchbase.com/company/ximl [Accessed on 19/01/2011]

Eighth Task

1. Describe and discuss Graphical XML - SVG

Scalable Vector Graphics

Images on the web began with static bitmap files, which are thousand of rectangles called pixels that make the image. Bitmap images although efficient, the introduction of vector images proved to be more efficient when it came to graphic images or animation on the web. Using XML code it is possible to construct vector image graphics straight on to web pages. Bitmap, PNG and JPEG images are processed through the web browsers whilst SVG images require the web pages to have a plug in, and then they can be processed like the images mentioned.

SVG images are scriptable in which they can be manipulated and referenced by scripting languages. The graphics capabilities are outstanding and applications like Adobe Illustrator, CoralDraw and Photoshop have various editing features for such SVG images. SVG is a XML application created by the W3c, designed for the creation of vector graphics. Created by the W3c and a host of collaborators, a main one being Adobe.

Status
- SVG specification 1. 1
- Adobe Viewer Plug-in 3.0 (numerous updates to resolve issues have been released

SVG's key information

-They posses four different Document type definitions (DTD)

The DTD for version 1.1 is as follows:

<DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">

*The four differnt DTDs are not identical and should not be written as if they are

-To be able to use elements and attributes its a necessities to use a namespace, shown below the DTD

- SVG documents begin with a root element the svg element

- image/svg+xml is the MIME type (allows SVGs from a web-server to be placed on web browser)

- SVG drawing surface are non dimensional local units

- SVG use mathematics, coordinates and measurement's

-SVG documents can be created in an XML editor or an alternative text editor or graphics application

Three fundamental types of graphical objects
Vector Text
External Bitmap Images
Primitive Vector Shapes

Drawing a simple line in SVG

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">

<svg xmlns="http://www.w3.org/2000/svg">
<title>Simple Line</title>
<line x1="55" y1="55" x2="260" y2="140"
style="stroke:purple; stroke width:6"/>
</svg>

The above code would show a purple diagonal line with a fairly thick width

Related SVG
SVG Tiny (SVGT) and SVG Basic (SVGB) are W3c recommendations developed to allow SVG support to smaller, or basic processor devices, like model phones, pda's, handheld games etc.

2. What is the Document Object Model? Describe its purpose and use

The Docuement Object Model was discussed in another task, for this question and answer it will delve into information that may have been brief or information that was not relevant to that task but relevant to this one.

A standard method for showing the elements in a document as a data structure/hierarchly tree developed by the W3c. This a standard method that can show data structures for various programming languages. Accessed is provided to show pieces and parts of a XML document or webpage by the DOM. The data structure is provided by the use of a DOM parser, a program that is able to read the XML document into a file and outputs the data structure

The DOM's Current Levels:

DOM Level 0 : The original Netscape/ IE Functionalities
                           Not a W3C Recommendation, but was used as a basis

DOM Level 1 : (Latest edition September 2000) Fundamental DOM Objects (not fully
                           backward compatible with Level 0!)
DOM Level 2 : (November 2000) Access to stylesheets, handling namespaces; also
                           includes an event model

DOM Level 3 : (In preparation) Handling XML schemes (including on-the-fly validation),
                           X Path - based selections

http://www.w3.org/Consortium/Offices/Presentations/XMLFamilyOverview/13.html

The DOM is often described as being a collection of programming interfaces and that is just what it is. When discussing an XML document DOM represent this as a hierarchical tree, made up of various interfaces called node. Each of these interfaces have their own methods and properties.

DOM Interfaces

Each interface in a DOM is associated with a particular node from within the DOM tree. There are numerous types of interfaces, but I will only mention the common ones.

The Node Interface

All interfaces are actually derived from the node interface, if elements and attributes are shared by everything in a DOM tree they are shown by the node interface. The elements and attributes have to monitor the parents, siblings and children of the interface node. Attributes belong to nodes that contain the same name and value, they also have a pointer which points to the document associated with the node.

The Document Interface

The root node of the DOM tree, and one level above the root element of an XML document is the Document interface. Attributes in document nodes are associated with the document, reason why the XML document has one level less than the hierarchy in a DOM tree.

The Element Interface

All elements in an XML document are represented by the element interface, the tag name is the only attribute to be linked with an element node. The attribute of a standard node are whats inherited from the element node, which includes methods that allows the adding, removing and retrieving of attributes from the element interface.

The Attr Interface

This interface represents an attribute of an element, they are not nodes on a DOM tree but do inherit the node interface. They are part of an element and are not children of a element like some of the other nodes on the DOM tree. As they are attributes they do not contain methods and they are unable to fetch the parents, siblings and children of an attribute.

The NodeList Interface

The only interface that is different to the ones mentioned, simple terms it allows the DOM implementations to handle a collection of nodes. The attribute of this interface is the size of the collection, and this interface can perform plenty of repeative functions.

3. Evaluate SAX ( the XML API)

Simple API for XML

A programming interface for event driven parsing of XML files. Similar but different to the DOM as it takes a different parsing approach. The SAX parser however does nothing to data it has parserd unlike some other parsers, all it does is trigger events.

A SAX doc describes the standards a SAX parser must be written to and the events supported by the SAX parser. SAX 1.0 is the first version which has now been upgraded and somewhat replaced by SAX 2.0, athough some programs and applications still support SAX 1.0, its recommended to use 2.0 for new applications.

SAX 1.0
Concerned with the standard content in an XML document , it provides support for the triggered events. SAX 1.0 has the responsiblitity of managing the elements or attributes in which they provide through its interface at the startElement () method see below.

A Sax.10 parser must adhere to a set of methods that are automatically invoked during the parsing of a document and events occur during the parsing. Methods such as:

- characters () - returns all characters within an element
- ignorableWhitespace () - triggers an event when whitespace is found between elements
- processingInstruction () - triggers an event when processing instruction is found within a document
- startElement () - triggers an event when an opening tag for an element is found
- endElemet () - triggers an event when the closing tag of an element is found
- endDocument() - triggers an event when the the document parsing is finished

SAX 1.0 does not support namespaces

SAX 2.0

SAX 2.0 an extension of 1.o and provides support for namespaces unlike SAX 1.0. The parser within a SAX 2.0 program must adhere to the use of the following methods:

- startPrefixMapping () - triggers event when a prefix mapping is found
- skippedEntity () - triggers when a event discovers a skipped entity
- endPrefixMapping () - triggers event when a prefix mapping is closed

Example of the output of a SAX parser

start document.
Received processing instruction:
Target: xml-stylesheet
Data: href ="favmusic.xsl" type="text/xsl"
Start element: Cd's
Start element: Cd
Start element: Genre
Received characters: RnB
End of element: Genre
Start Element: Artist
Start Element: Language
Received characters: English
End of Elements: Language
......
......
End of Document reached.

SEVENTH TASK

1. Discuss how XSL can be used to generate XHTML?

XSL stands for Extensible Style Sheet Language which defines the presentation and transformation of a XML document.XSL was designed specifically for XML and although it is similar to CSS, it is able to manipulate structure in XML documents much better than CSS. The processing of an XSL style sheet, being applied to an XML document, has to be begin with a XML processor. The processor reads the documents and processes it into important information which is called nodes.

XSL consists of 3 fundamental technologies

XSLT - The only component that is supported by current web browsers, and allows the transformation of XML documents using style sheet code from language to another.

XSLO-FO - This language focuses on the styling and formatting of XML documents. Although not a great option for XML documents that are for web browsers due to the support issue, it is effective in the styling of XML documents for printing. A good use for this is that you can convert an XML document into a PDF file Adobe Acrobat.

XPath - This is an expression language that is used to navigate through parts of an XML document, and is very different to its counterparts as it isn't implemented as an XML language.

HTML the hyper text markup language is not a XML based language therefore does not meet the standards of XML. A stricter version of HTML was introduced that adheres to the standards of XML called XHTML.

To be able to transform XML into XHTML it can be done so by using XSLT, I started with using one of my previously created XML documents which lists my top ten CD’s. I then went on to create a XSL style sheet with both docs, it’s important to use the correct declarations. This was inserted in my XSL file at the very top.

<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

I then went on to create the style sheet, which some of my code is as follows:

<xsl:template match="/">
  <html>
  <body>
  <h2>My Top Ten CD's</h2>

  <table border="4">

    <tr bgcolor="#green">
      <th>Album</th>
      <th>Artist</th>
    </tr>
    <xsl:for-each select="MUSICDATABASE/CD">
    <tr>
      <td><xsl:value-of select="ALBUM"/></td>
      <td><xsl:value-of select="ARTIST"/></td>
    </tr>
    </xsl:for-each>
  </table>

To round things off I linked the style sheet to my XML document using the below code. It worked successfully as when I opened my XML document with Internet Explorer a table was shown with the selected formatting I created in the XSLT Style sheet. As shown the xls is a file extension, and is its own separate text file that has to be linked to the XML document

2. How can XML be styled using CSS? What are the strength and weaknesses of using CSS?

XML can be styled using CSS, Cascading Style Sheets and it is often a good idea due to its compatibility with web browsers. However this is only a good idea if the task at hand is to solely display content rather than control features like XSLT is able to do to an XML document. When used with XML, CSS allows the control of formatting and positioning and does not concern itself with transforming and processing XML code.

CSS files are stored in seperated text files and have the extension .css, therefore in order for a CSS to function with the XML document it must be connected to that document. The processing instruction is shown to the left.

<----------------------------

Example CSS text file

favmusic
{
display:block;
color: red
background-color: black;
text-align:left;
}

CD
{
font-family: Georgia;
font-size:14pt;
}
ALBUM
{
font-family: Comic Sans;
font-size: 12pt;
}
SONG
{
font-family: Comic Sans;
font-size:12pt;
}

.................................

Example XML document

<?xml version="1.0"?>
<?xml-stylesheet type="text/css" href="favmusic.css"?>
<!DOCTYPE favmusic SYSTEM "favmusic.dtd">

<favmusic>
<CD>
<ALBUM>Unthinkable</ALBUM>
<SONG>Sleeping With a Broken Heart</SONG>
............................................................
............................................................
</CD>
</MUSICDATABASE>

The product of this when viewed in a web browser would be a black background with the red text and different font size's according to what is marked on the CSS. Such a CSS could be altered numerous times to a person's desire eg. adding borders, tables, layout properties etc...

Strengths of CSS

- Powerful

- Web browser compatible
- Code is simple to understand

- The ability to reuse existing code

- Flexibility in determining the appearance of the XML document

Weaknesses of CSS

- Printing issues of XML documents

- Limited to only styling documents

- Security issues, as they can easily be overridden

3. How can XML be styled using XSLT style sheets? What are the strengths and weaknesses of using XSLT style sheets?

Extensible Stylesheet Language Transformation XSLT is an XML based styles heet soley designed for the use with XML documents. It is an XML based markup language with contains its own attributes and elements that are used yo create the XSLT style sheets. XSLT style sheets can be used to do simple transformations such as sorting content into a desired order to the transformation of content into a different XML language. XSLT style sheets have two types of information that they are classed by instructions and literals.

Instructions - These are the elements and attributes of the XSLT that describe how the XML content is to be transformed

Literals - These are static pieces of information that are not processed and are placed directly in the output document

The output document will be the instructions which delivers the content and the literals are placed throughout the XML document.

Example Code:

Having a root template, controls the way in which other templates are displayed :<xsl:template match="/">
This line of code is used to merge the content into the style sheet by the use of literals <td><xsl:value-of select="ALBUM"/></td>

Strengths
- Powerful
- XML data can be merged easily
- In XML databases queries can be returned
- Resilient to changes as it is template based

Weaknesses
- Values of variables cannot be altered
- Complicated business rules are difficult to implement
- Memory issues can lead to Performance issues

4. How can XSLT be used (a) to transform an XML structure and (b) to sort the contents of an XML document?

Continuing from the above Post....

XSLT is ideal when XML documents need to be changed into different formats to be compatible with different applications and devices. This is common in use with web browsers or the need to change XML into XHTML for the benefit of a web browser or application.
XSLT can be extremely useful when XML's structure prevents an application accepting the XMLs structure data. The necessary data may be there, however the XML structure may not be permitted by the application, the solution is XSLT to alter the structure in a way that the application understands.

The Transformation process

A parsed document is loaded into a DOM tree structure. The XML document structure is then taken from an XSLT processor who matches the nodes against the template

XSLT Template

Templates in XSLT are used to process and create the structure that is to be outputted. In creating a template its necessary to use the xls:template element and the match attribute <xls:template match= "/">.A set of nodes are attained by the match attribute being assigned to a pattern or expression. From the example above the value is nothing but a forward slash, this is the default for identifying the documents root node .

As mentioned in the question three's answer the root node can be included if there is a desire to manage the content of more than one template, if this is not the case, then a root node is not necessary and the XLS processor will still apply the style sheet. Specific portions of a XML document can be transformed by the use of multiple style sheets. Nodes can be specified in more detail using XPath which deals with the addressing of portions of data in an XML document and allows advanced node selections. Nodes are processed in XSLT using several pre defined elements. These elements can be used to sort content before displaying, the sorting element is shown as xsl:sort, allowing the sorting of nodes to a specified criteria, following a key, the key is a pattern or expression highlighting the information in the set.

A useful link that details the name and descriptions of XSLT elements :

http://www.xmlfiles.com/articles/sample_chapters/sams_xmlforaspnet/default.asp

5. Discuss the notion of Xlink. What is its purpose and how do you use it?

To be able to carry out advanced linking between XML documents, Xlink is a great collection of technologies to do this. Xlinks allows data to be embedded in a Document and allows a wide range of data at that, however it is not as popular as W3C intended it to be. Two resources can be connected to a link in one document by the use of links with Xlink which is very useful. These are out of line links, and is useful when you are unable to edit target docs and the source. This will introduce link repositories which is a database of links describing connections of use between resources on the web, making this a practical necessity.

The other linking element supported in XLink is an inline link, which allows its content to serve as one of the links included resources. The content serves as the source for the desired link. XPointer and XPath makes XML links possible and is compulsory as without them its not possible.

Xlinks Attributes

These are the standard attributes used to establish linked elements in XML docs

These are used to create linked elements: (the functions are self explanatory)

Each attribute can have numerous value, example the show element holds three main values new, replace and embed

How to use an Xlink

<?xml version="1.0"?>

<Hip Hop xlink:type="simple" xlink:href="http://www.hiphopworld.com"> ” Number one choice for all the latest news in Hip Hop“</ Hip Hop >

</homepage>

CMT 3315 Advanced Web Technologies

Friday, 18 February 2011

lab 15

Thursday, 17 February 2011

xpath3

xpath2

xpath

Friday, 4 February 2011

TENTH TASK

Ninth Task

What is XIML and how is it used? Give examples.

Eighth Task

SEVENTH TASK