Skip to main content

Home/ Open Web/ Group items tagged XML

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
Gary Edwards

XML Production Workflows? Start with the Web and XHTML - 1 views

quod.lib.umich.edu/...n-workflows-start-with-the-web

OpenWeb XML XHTML-CSS HTML5-CSS3-JavaScript IDML

shared by Gary Edwards on 01 Nov 13 - No Cached
  • Challenges: Some Ugly Truths The challenges of building—and living with—an XML workflow are clear enough. The return on investment is a long-term proposition. Regardless of the benefits XML may provide, the starting reality is that it represents a very different way of doing things than the one we are familiar with. The Word Processing and Desktop Publishing paradigm, based on the promise of onscreen, WYSIWYG layout, is so dominant as to be practically inescapable. It has proven really hard to get from here to there, no matter how attractive XML might be on paper. A considerable amount of organizational effort and labour must be expended up front in order to realize the benefits. This is why XML is often referred to as an “investment”: you sink a bunch of time and money up front, and realize the benefits—greater flexibility, multiple output options, searching and indexing, and general futureproofing—later, over the long haul. It is not a short-term return proposition. And, of course, the returns you are able to realize from your XML investment are commensurate with what you put in up front: fine-grained, semantically rich tagging is going to give you more potential for searchability and recombination than a looser, more general-purpose approach, but it sure costs more. For instance, the Text Encoding Initiative (TEI) is the grand example of pouring enormous amounts of energy into the up-front tagging, with a very open-ended set of possibilities down the line. TEI helpfully defines a level to which most of us do not have to aspire.[5] But understanding this on a theoretical level is only part of the challenge. There are many practical issues that must be addressed. Software and labour are two of the most critical. How do you get the content into XML in the first place? Unfortunately, despite two decades of people doing SGML and XML, this remains an ugly question.
  • Practical Challenges In 2009, there is still no truly likeable—let alone standard—editing and authoring software for XML. For many (myself included), the high-water mark here was Adobe’s FrameMaker, substantially developed by the late 1990s. With no substantial market for it, it is relegated today mostly to the tech writing industry, unavailable for the Mac, and just far enough afield from the kinds of tools we use today that its adoption represents a significant hurdle. And FrameMaker was the best of the breed; most of the other software in decent circulation are programmers’ tools—the sort of things that, as Michael Tamblyn pointed out, encourage editors to drink at their desks. The labour question represents a stumbling block as well. The skill-sets and mind-sets that effective XML editors need have limited overlap with those needed by literary and more traditional production editors. The need to think of documents as machine-readable databases is not something that comes naturally to folks steeped in literary culture. In combination with the sheer time and effort that rich tagging requires, many publishers simply outsource the tagging to India, drawing a division of labour that spans oceans, to put it mildly. Once you have XML content, then what do you do with it? How do you produce books from it? Presumably, you need to be able to produce print output as well as digital formats. But while the latter are new enough to be generally XML-friendly (e-book formats being largely XML based, for instance), there aren’t any straightforward, standard ways of moving XML content into the kind of print production environments we are used to seeing. This isn’t to say that there aren’t ways of getting print—even very high-quality print—output from XML, just that most of them involve replacing your prepress staff with Java programmers.
  • Why does this have to be so hard? It’s not that XML is new, or immature, or untested. Remember that the basics have been around, and in production, since the early 1980s at least. But we have to take account of a substantial and long-running cultural disconnect between traditional editorial and production processes (the ones most of us know intimately) and the ways computing people have approached things. Interestingly, this cultural divide looked rather different in the 1970s, when publishers were looking at how to move to digital typesetting. Back then, printers and software developers could speak the same language. But that was before the ascendancy of the Desktop Publishing paradigm, which computerized the publishing industry while at the same time isolating it culturally. Those of us who learned how to do things the Quark way or the Adobe way had little in common with people who programmed databases or document-management systems. Desktop publishing technology isolated us in a smooth, self-contained universe of toolbars, grid lines, and laser proofs. So, now that the reasons to get with this program, XML, loom large, how can we bridge this long-standing divide?
  • ...44 more annotations...
  • Using the Web as a Production Platform The answer, I think, is right in front of you. The bridge is the Web, a technology and platform that is fundamentally based on XML, and which many publishers are by now comfortably familiar with. Perhaps not entirely comfortably, but at least most publishers are already working with the Web; they already either know or have on staff people who understand it and can work with it. The foundation of our argument is this: rather than looking at jumping to XML in its full, industrial complexity, which seems to be what the O'Reilly-backed StartWithXML initiative[6] is suggesting, publishers instead leverage existing tools and technologies—starting with the Web—as a means of getting XML workflows in place. This means making small investments and working with known tools rather than spending tens of thousands of dollars on XML software and rarefied consultants. It means re-thinking how the existing pieces of the production toolchain fit together; re-thinking the existing roles of software components already in use. It means, fundamentally, taking the Web seriously as a content platform, rather than thinking of it as something you need to get content out to, somehow. If nothing else, the Web represents an opportunity to think about editorial and production from outside the shrink-wrapped Desktop Publishing paradigm.
  • Is the Web made of Real XML? At this point some predictable objections can be heard: wait a moment, the Web isn’t really made out of XML; the HTML that makes up most of the Web is at best the bastard child of SGML, and it is far too flaky/unstructured/underpowered to be taken seriously. We counter by arguing that although HTML on the Web exists in a staggering array of different incarnations, and that the majority of it is indeed an unstructured mess, this does not undermine the general principle that basic, ubiquitous Web technologies can make a solid platform for content management, editorial process, and production workflow.
  • With the advent of a published XML standard in the late 1990s came the W3C’s adoption of XHTML: the realization of the Web’s native content markup as a proper XML document type. Today, its acceptance is almost ubiquitous, even while the majority of actual content out there may not be strictly conforming. The more important point is that most contemporary Web software, from browsers to authoring tools to content management systems (from blogs to enterprise systems), are capable of working with clean, valid XHTML. Or, to put the argument the other way around, clean, valid XHTML content plays absolutely seamlessly with everything else on the Web.[7]
  • The objection which follows, then, will be that even if we grant that XHTML is a real XML document type, that it is underpowered for “serious” content because it is almost entirely presentation (formatting) oriented; it lacks any semantic depth. In XHTML, a paragraph is a paragraph is a paragraph, as opposed to a section or an epigraph or a summary.
  • n contrast, more “serious” XML document types like DocBook[8] or DITA-derived schemas[9] are capable of making semantic distinctions about content chunks at a fine level of granularity and with a high degree of specificity.
  • So there is an argument for recalling the 80:20 rule here. If XHTML can provide 80% of the value with just 20% of the investment, then what exactly is the business case for spending the other 80% to achieve that last 20% of value? We suspect the ratio is actually quite a bit steeper than 80:20 for most publishers.
  • Furthermore, just to get technical for a moment, XHTML is extensible in a fairly straightforward way, through the common “class” attribute on each element. Web developers have long leveraged this kind of extensibility in the elaboration of “microformats” for semantic-web applications.[10] There is no reason why publishers shouldn’t think to use XHTML’s simple extensibility in a similar way for their own ends.
  • XHTML, on the other hand, is supported by a vast array of quotidian software, starting with the ubiquitous Web browser. For this very reason, XHTML is in fact employed as a component part of several more specialized document types (ONIX and ePub among them).
  • Why re-invent a general-purpose prose representation when XHTML already does the job?
  • It is worth pausing for a moment to consider the role of XHTML in the ePub standard for ebook content. An ePub file is, anatomically, a simply disguised zip archive. Inside the zip archive are a few standard component parts: there are specialized files that declare metadata about the book, and about the format of the book. And then there is the book’s content, represented in XHTML. An ePub book is a Web page in a wrapper.
  • To sum up the general argument: the Web as it already exists presents incredible value to publishers, as a platform for doing XML content management with existing (and often free) tools, and without having to go blindly into the unknown. At this point, we can offer a few design guidelines: prefer existing and/or ubiquitous tools over specialized ones wherever possible; prefer free software over proprietary systems where possible; prefer simple tools controlled and coordinated by human beings over fully automated (and therefore complex) systems; play to our strengths: use Web software for storing and managing content, use layout software for layout, and keep editors and production people in charge of their own domains.
  • Putting the Pieces Together: A Prototype
  • At the SFU Master of Publishing Program, we have been chipping away at this general line of thinking for a few years. Over that time, Web content management systems have been getting more and more sophisticated, all the while getting more streamlined and easier to use. (NB: if you have a blog, you have a Web content management system.) The Web is beginning to be recognized as a writing and editing environment used by millions of people. And the ways in which content is represented, stored, and exchanged online have become increasingly robust and standardized.
  • The missing piece of the puzzle has been print production: how can we move content from its malleable, fluid form on line into the kind of high-quality print production environments we’ve come to expect after two decades of Desktop Publishing?
  • Anyone who has tried to print Web content knows that the existing methods leave much to be desired (hyphenation and justification, for starters). In the absence of decent tools for this, most publishers quite naturally think of producing the print content first, and then think about how to get material onto the Web for various purposes. So we tend to export from Word, or from Adobe, as something of an afterthought.
  • While this sort of works, it isn’t elegant, and it completely ignores the considerable advantages of Web-based content management.
  • Content managed online is stored in one central location, accessible simultaneously to everyone in your firm, available anywhere you have an Internet connection, and usually exists in a much more fluid format than Word files. If only we could manage the editorial flow online, and then go to print formats at the end, instead of the other way around. At SFU, we made several attempts to make this work by way of the supposed “XML import” capabilities of various Desktop Publishing tools, without much success.[12]
  • In the winter of 2009, Adobe solved this part of the problem for us with the introduction of its Creative Suite 4. What CS4 offers is the option of a complete XML representation of an InDesign document: what Adobe calls IDML (InDesign Markup Language).
  • The IDML file format is—like ePub—a simply disguised zip archive that, when unpacked, reveals a cluster of XML files that represent all the different facets of an InDesign document: layout spreads, master pages, defined styles, colours, and of course, the content.
  • IDML is a well thought-out XML standard that achieves two very different goals simultaneously: it preserves all of the information that InDesign needs to do what it does; and it is broken up in a way that makes it possible for mere mortals (or at least our Master of Publishing students) to work with it.
  • What this represented to us in concrete terms was the ability to take Web-based content and move it into InDesign in a straightforward way, thus bridging Web and print production environments using existing tools and skillsets, with a little added help from free software.
  • We would take clean XHTML content, transform it to IDML-marked content, and merge that with nicely designed templates in InDesign.
  • The result is an almost push-button publication workflow, which results in a nice, familiar InDesign document that fits straight into the way publishers actually do production.
  • Tracing the steps To begin with, we worked backwards, moving the book content back to clean XHTML.
  • The simplest method for this conversion—and if you want to create Web content, this is an excellent route—was to use Adobe’s “Export to Digital Editions” option, which creates an ePub file.
  • Recall that ePub is just XHTML in a wrapper, so within the ePub file was a relatively clean XHTML document. It was somewhat cleaner (that is, the XHTML tagging was simpler and less cluttered) than InDesign’s other Web-oriented exports, possibly because Digital Editions is a well understood target, compared with somebody’s website.
  • In order to achieve our target of clean XHTML, we needed to do some editing; the XHTML produced by InDesign’s “Digital Editions” export was presentation-oriented. For instance, bulleted list items were tagged as paragraphs, with a class attribute identifying them as list items. Using the search-and-replace function, we converted such structures to proper XHTML list and list-item elements. Our guiding principle was to make the XHTML as straightforward as possible, not dependent on any particular software to interpret it.
  • We broke the book’s content into individual chapter files; each chapter could then carry its own basic metadata, and the pages conveniently fit our Web content management system (which is actually just a wiki). We assembled a dynamically generated table of contents for the 12 chapters, and created a cover page. Essentially, the book was entirely Web-based at this point.
  • When the book chapters are viewed online, they are formatted via a CSS2 stylesheet that defines a main column for content as well as dedicating screen real estate for navigational elements. We then created a second template to render the content for exporting; this was essentially a bare-bones version of the book with no navigation and minimal styling. Pages (or even the entire book) can be exported (via the “Save As...” function in a Web browser) for use in either print production or ebook conversion. At this point, we required no skills beyond those of any decent Web designer.
  • Integrating with CS4 for Print Adobe’s IDML language defines elements specific to InDesign; there is nothing in the language that looks remotely like XHTML. So a mechanical transformation step is needed to convert the XHTML content into something InDesign can use. This is not as hard as it might seem.
  • Both XHTML and IDML are composed of straightforward, well-documented structures, and so transformation from one to the other is, as they say, “trivial.” We chose to use XSLT (Extensible Stylesheet Language Transforms) to do the work. XSLT is part of the overall XML specification, and thus is very well supported in a wide variety of tools. Our prototype used a scripting engine called xsltproc, a nearly ubiquitous piece of software that we found already installed as part of Mac OS X (contemporary Linux distributions also have this as a standard tool), though any XSLT processor would work.
  • In other words, we don’t need to buy InCopy, because we just replaced it with the Web. Our wiki is now plugged directly into our InDesign layout. It even automatically updates the InDesign document when the content changes. Credit is due at this point to Adobe: this integration is possible because of the open file format in the Creative Suite 4.
  • We wrote an XSLT transformation script[18] that converted the XHTML content from the Web into an InCopy ICML file. The script itself is less than 500 lines long, and was written and debugged over a period of about a week by amateurs (again, the people named at the start of this article). The script runs in a couple of seconds, and the resulting .icml file can then be “placed” directly into an InDesign template. The ICML file references an InDesign stylesheet, so the template file can be set up with a house-styled layout, master pages, and stylesheet definitions for paragraphs and character ranges.
  • Rather than a public-facing website, our system relies on the Web as a content management platform—of course a public face could easily be added.
  • It should be noted that the Book Publishing 1 proof-of-concept was artificially complex; we began with a book laid out in InDesign and ended up with a look-alike book laid out in InDesign. But next time—for instance, when we publish Book Publishing 2—we can begin the process with the content on the Web, and keep it there throughout the editorial process. The book’s content could potentially be written and edited entirely online, as Web content, and then automatically poured into an InDesign template at proof time. “Just in time,” as they say. This represents an entirely new way of thinking of book production. With a Web-first orientation, it makes little sense to think of the book as “in print” or “out of print”—the book is simply available, in the first place online; in the second place in derivative digital formats; and third, but really not much more difficult, in print-ready format, via the usual InDesign CS print production system publishers are already familiar with.
  • Creating Ebook Files Creating electronic versions from XHTML source is vastly simpler than trying to generate these out of the existing print process. The ePub version is extremely easy to generate; so is online marketing copy or excerpts for the Web, since the content begins life Web-native.
  • Since an ePub file is essentially XHTML content in a special wrapper, all that is required is that we properly “wrap” our XHTML content. Ideally, the content in an ePub file is broken into chapters (as ours was) and a table of contents file is generated in order to allow easy navigation within an ebook reader. We used Julian Smart’s free tool eCub[19] to simply and automatically generate the ePub wrapper and the table of contents. The only custom development we did was to create a CSS stylesheet for the ebook so that headings and paragraph indents looked the way we wanted. Starting with XHTML content, creating ePub is almost too easy.
  • today, we are able to put the process together using nothing but standard, relatively ubiquitous Web tools: the Web itself as an editing and content management environment, standard Web scripting tools for the conversion process, and the well-documented IDML file format to integrate the layout tool.
  • Our project demonstrates that Web technologies are indeed good enough to use in an XML-oriented workflow; more specialized and expensive options are not necessarily required. For massive-scale enterprise publishing, this approach may not offer enough flexibility, and the challenge of adding and extracting extra semantic richness may prove more trouble than it's worth.
  • But for smaller firms who are looking at the straightforward benefits of XML-based processes—single source publishing, online content and workflow management, open and accessible archive formats, greater online discoverability—here is a way forward.
  • The result is very simple and easy to use. Our demonstration requires that a production editor run the XSLT transformation script manually, but there is no reason why this couldn’t be built directly into the Web content management system so that exporting the content to print ran the transformation automatically. The resulting file would then be “placed” in InDesign and proofed.
  • The final piece of our puzzle, the ability to integrate print production, was made possible by Adobe's release of InDesign with an open XML file format. Since the Web's XHTML is also XML, is can be easily and confidently transformed to the InDesign format.
  • Such a workflow—beginning with the Web and exporting to print—is surely more in line with the way we will do business in the 21st century, where the Web is the default platform for reaching audiences, developing content, and putting the pieces together. It is time, we suggest, for publishers to re-orient their operations and start with the Web.
  • Using the Web as a Production Platform
  • Gary Edwards on 01 Nov 13
     
    I was looking for an answer to a problem Marbux had presented, and found this interesting article.  The issue was that of the upcoming conversion of the Note Case Pro (NCP) layout engine to the WebKit layout engine, and what to do about the NCP document format. My initial reaction was to encode the legacy NCP document format in XML, and run an XSLT to a universal pivot format like TEI-XML.  From there, the TEI-XML community would provide all the XSLT transformation routines for conversion to ODF, OOXML, XHTML, ePUB and HTML/CSS. Researching the problems one might encounter with this approach, I found this article.  Fascinating stuff. My take away is that TEI-XML would not be as effective a "universal pivot point" as XHTML.  Or perhaps, if NCP really wants to get aggressive; IDML - InDesign Markup Language. As an after thought, i was thinking that an alternative title to this article might have been, "Working with Web as the Center of Everything".
Gary Edwards

Dare Obasanjo aka Carnage4Life - Learning from our Mistakes: The Failure of OpenID, Ato... - 1 views

www.25hoursaday.com/...enIDAtomPubAndXMLOnTheWeb.aspx

XML OpenWeb OpenID Dare-Obasanjo

shared by Gary Edwards on 01 Feb 11 - No Cached
  • Gary Edwards on 01 Feb 11
     
    The Failure of XML on the Web At the turn of the last decade, XML could do no wrong. There was no problem that couldn't be solved by applying XML to it and every technology was going to be replaced by it. XML was going to kill HTML. XML was going to kill CORBA, EJB and DCOM as we moved to web services. XML was a floor wax and a dessert topping. Unfortunately, after over a decade it is clear that XML has not and is unlikely to ever be the dominant way we create markup for consumption by browsers or how applications on the Web communicate.
Gary Edwards

Office to finally fully support ODF, Open XML, and PDF formats | ZDNet - 0 views

www.zdnet.com/xml-and-pdf-formats-7000002696

ODF ODF-interop MSOffice-productivity Cloud-Compound-Document

shared by Gary Edwards on 22 Aug 12 - No Cached
  • Gary Edwards on 22 Aug 12
     
    The king of clicks returns!  No doubt there was a time when the mere mention of ODF and the now legendary XML "document" format wars with Microsoft could drive click counts into the statisphere.  Sorry to say though, those times are long gone. It's still a good story though.  Even if the fate of mankind and the future of the Internet no longer hinges on the outcome.  There is that question that continues defy answer; "Did Microsoft win or lose?"  So the mere announcement of supported formats in MSOffice XX is guaranteed to rev the clicks somewhat. Veteran ODF clickmeister SVN does make an interesting observation though: "The ironic thing is that, while this was as hotly debated am issue in the mid-2000s as are mobile patents and cloud implementation is today, this news was barely noticed. That's a mistake. Updegrove points out, "document interoperability and vendor neutrality matter more now than ever before as paper archives disappear and literally all of human knowledge is entrusted to electronic storage." He concluded, "Only if documents can be easily exchanged and reliably accessed on an ongoing basis will competition in the present be preserved, and the availability of knowledge down through the ages be assured. Without robust, universally adopted document formats, both of those goals will be impossible to attain." Updegrove's right of course. Don't believe me? Go into your office's archives and try to bring up documents your wrote in the 90s in WordPerfect or papers your staff created in the 80s with WordStar. If you don't want to lose your institutional memory, open document standards support is more important than ever. "....................................... Sorry but Updegrove is wrong.  Woefully wrong. The Web is the future.  Sure interoperability matters, but only as far as the Web and the future of Cloud Computing is concerned.  Sadly neither ODF or Open XML are Web ready.  The language of the Web is famously HTML, now HTML5+
Gary Edwards

RuleLab.Net Server: Web system for design, implementation and management of business pr... - 0 views

www.pcworld.com/...description.html

RuleLab.net business-processes

shared by Gary Edwards on 05 Feb 11 - No Cached
  • Gary Edwards on 05 Feb 11
     
    RuleLab.Net is a web-based system for designing and implementing the business rules that operate on an application's XML data. Extend your existing applications by adding Rule building and Business Rules Engine (BRE) capabilities. Consolidate your business logic in an easy to read format, build, test, share, and deploy your Rules using the web browser; and integrate them into your system via the BRE. Intuitive GUI, English-like syntax, and centralized repository empower business users with direct access to the Rules.In the RuleLab.Net system, Business Rules are composed and managed over the Internet or Intranet using the web-based Rules Designer. It allows users to associate an application XML data template with Rules, create a vocabulary of natural terms, graphically build complex logical expressions, test the Rules on data samples, and store the Rules in a database. Features include strong data types, reasoning, rule priorities and dependencies, calculation formulas, looping-data-structure support, and a built-in set of computational, aggregate and other data processing functions. Rules and other system objects are stored in XML files that can be downloaded, modified, and uploaded to the online repository. Rule changes made online can be instantly deployed for runtime use by the applications integrated with the BRE. The forward chaining BRE parses XML application data against the ruleset, updates your data XML document, and returns it back to the application along with the comprehensive state information. Written in .NET, the BRE component can be utilized as a managed assembly, a COM object, or through the Web Service.
Gary Edwards

Google Wave Operational Transformation (Google Wave Federation Protocol) - 0 views

www.waveprotocol.org/...operational-transform

google-wave operational-transform OT xerox-parc wave-dev OTXML

shared by Gary Edwards on 03 Sep 09 - Cached
  • Wave document operations consist of the following mutation components:skipinsert charactersinsert element startinsert element endinsert anti-element startinsert anti-element enddelete charactersdelete element startdelete element enddelete anti-element startdelete anti-element endset attributesupdate attributescommence annotationconclude annotationThe following is a more complex example document operation.skip 3insert element start with tag "p" and no attributesinsert characters "Hi there!"insert element endskip 5delete characters 4From this, one could see how an entire XML document can be represented as a single document operation. 
  • Wave OperationsWave operations consists of a document operation, for modifying XML documents and other non document operations. Non document operations are for tasks such as adding or removing a participant to a Wavelet. We'll focus on document operations here as they are the most central to Wave.It's worth noting that an XML document in Wave can be regarded as a single document operation that can be applied to the empty document.This section will also cover how Wave operations are particularly efficient even in the face of a large number of transforms.XML Document SupportWave uses a streaming interface for document operations. This is similar to an XMLStreamWriter or a SAX handler. The document operation consists of a sequence of ordered document mutations. The mutations are applied in sequence as you traverse the document linearly. Designing document operations in this manner makes it easier to write transformation function and composition function described later.In Wave, every 16-bit Unicode code unit (as used in javascript, JSON, and Java strings), start tag or end tag in an XML document is called an item. Gaps between items are called positions. Position 0 is before the first item. A document operation can contain mutations that reference positions. For example, a "Skip" mutation specifies how many positions to skip ahead in the XML document before applying the next mutation.Wave document operations also support annotations. An annotation is some meta-data associated with an item range, i.e. a start position and an end position. This is particularly useful for describing text formatting and spelling suggestions, as it does not unecessarily complicate the underlying XML document format.
  • Gary Edwards on 03 Sep 09
     
    Summary: Collaborative document editing means multiple editors being able to edit a shared document at the same time.. Live and concurrent means being able to see the changes another person is making, keystroke by keystroke. Currently, there are already a number of products on the market that offer collaborative document editing. Some offer live concurrent editing, such as EtherPad and SubEthaEdit, but do not offer rich text. There are others that offer rich text, such as Google Docs, but do not offer a seamless live concurrent editing experience, as merge failures can occur. Wave stands as a solution that offers both live concurrent editing and rich text document support.  The result is that Wave allows for a very engaging conversation where you can see what the other person is typing, character by character much like how you would converse in a cafe. This is very much like instant messaging except you can see what the other person is typing, live. Wave also allows for a more productive collaborative document editing experience, where people don't have to worry about stepping on each others toes and still use common word processor functionalities such as bold, italics, bullet points, and headings. Wave is more than just rich text documents. In fact, Wave's core technology allows live concurrent modifications of XML documents which can be used to represent any structured content including system data that is shared between clients and backend systems. To achieve these goals, Wave uses a concurrency control system based on Operational Transformation.
Gary Edwards

Method for invoking UOML instructions - Patent application - Embodiments of the present... - 1 views

www.faqs.org/...20090187927

shared by Gary Edwards on 24 Aug 10 - Cached
  • Gary Edwards on 24 Aug 10
     
    Patent application filed on OASIS UOML access by API. 0002]The present invention relates to electronic document processing technologies, and particularly to a method for encapsulating Unstructured Operation Markup Language (UOML) into an Application Programming Interface (API).  BACKGROUND OF THE INVENTION  [0003]The UOML standard includes a series of docbase management system instructions defined according to a format of "action+object" in Extensible Markup Language (XML), which has been explained in detail in an UOML Standard published by of the Organization for the Advancement of Structured Information Standards (OASIS ). Since XML works across different platforms and with different languages, the UOML standard can enable the docbase management system instructions to be exchanged across the different platforms in the different languages. However, in practical applications, operations on a docbase are usually controlled by using programs written in programming languages, hence the programs need to parse and process UOML XML texts. If every application developer designs his/her own way of parsing and processing UOML XML texts in his/her programs, the workload of coding will increase significantly and the efficiency of coding will drop sharply.  SUMMARY OF THE INVENTION  [0004]The objective of the present invention is to provide a method for encapsulating Unstructured Operation Markup Language (UOML) into an Application Programming Interface (API) of a programming language so as to improve the development efficiency of docbase management system application developers.  [0005]The method provided by the present invention for encapsulating UOML into an API includes:  Read more: http://www.faqs.org/patents/app/20090187927#ixzz0xVS2ZUSr
Gary Edwards

Content Controls- A Complete Summary « Ankush's Blog - 0 views

ankushbhatia.wordpress.com/...nt-controls-a-complete-summary

MSOffice content-controls

shared by Gary Edwards on 15 Apr 11 - No Cached
  • Gary Edwards on 15 Apr 11
     
    Content controls are bounded and potentially labeled regions in a document that serve as containers for specific types of content. Individual content controls can contain content such as dates, lists, or paragraphs of formatted text. In some cases, content controls might remind you of forms. However, they are much more powerful, flexible, and useful because they enable you to create rich, structured blocks of content. Content controls also build on the custom XML support introduced in Microsoft Office Word 2003. Content controls enable you to author templates that insert well-defined blocks into your documents. Content controls enable you to: * Specify structured regions in a template. Each structured region has its own unique ID so that you can read from and write to it. Examples of types of structured regions (or content controls) are combo boxes, pictures, text blocks, and calendars. * Determine the behavior of content controls. Each content control takes up a portion of a document and, as the template author, you can specify what each region does. For example, if you want a region of your template to be a calendar, you insert a calendar content control in that area of the document, which automatically determines what that block of content does. Similarly, if you want a section of a template to display an image, create a picture content control in that area. In this way, you can build a template with predefined block types. * Restrict the content of content controls. Each content control can be restricted, so that it cannot be deleted or edited. This is useful if, for example, you have copyright information in a template that the user should be able to read but not edit. You can also lock a template's content so that a user does not accidentally delete portions of it. This makes templates more robust than in previous versions. * Map the contents of a content control to data in a custom XML part that is stored with the document. For example, if you i
Gary Edwards

XSL-FO | XML To PDF, Postscript & AFP documents. We Can Do It All! - 0 views

www.ecrion.com

ecrion XSL-FO XML-SVG XML-PDF

shared by Gary Edwards on 04 Apr 11 - No Cached
  • Gary Edwards on 04 Apr 11
     
    XML Template Designer - Document Layout Designer, uses XF "XEP" Rendering engine.  XML to PDF, XSLFO Designer, Document Layout, compatible with Word and Powerpoint documents and templates.
Paul Merrell

Thinking XML: The XML flavor of HTML5 - 1 views

www.ibm.com/...index.html

html5 xml conversions

shared by Paul Merrell on 08 Jul 10 - Cached
  • 6 recommendations for developers using the next generation of the web's native language
  • In this article, I shall provide a practical guide that illustrates the state of play when it comes to XML in the HTML5 world. The article is written for what I call the desperate web hacker: someone who is not a W3C standards guru, but interested in either generating XHTML5 on the web, or consuming it in a simple way (that is, to consume information, rather than worrying about the enormous complexity of rendering). I'll admit that some of my recommendations will be painful for me to make, as a long-time advocate for processing XML the right way. Remember that HTML5 is still a W3C working draft, and it might be a while before it becomes a full recommendation. Many of its features are stable, though, and already well-implemented on the web.
Gary Edwards

Gray Matter : Open XML and the SharePoint Conference - 0 views

blogs.technet.com/...the-sharepoint-conference.aspx

Open-Web MSOffice ge

shared by Gary Edwards on 17 Oct 09 - Cached
  • Gary Edwards on 17 Oct 09
     
    excerpt: The trend in Office development is the migration of solutions away from in-application scripted processing toward more data-centric development. Of course this is a primary purpose of Open XML, and it is great to see the amount of activity in this area. We've seen customers scripting Word in a server environment to batch process / print documents or for other automation tasks. In reality Word isn't built to do that on a large scale, it is better to work directly against the document rather than via the application whenever possible. The Open XML SDK unlocks a "whole nuther" environment for document processing, and gets you out of the business of scripting client apps on servers to do the work of a true server application (not to mention the licensing problems created by installing Office on a server). comment:  Gray makes a very important point here.  The dominance of the desktop based MSOffice Productivity Environment was largely based the embedded logic driving "in-process" documents that was application and platform (Win32 API) specific.  Tear open any of these workgroup-workflow oriented compound documents and you find application specific scripts, macros, OLE, data bindings, security settings and other application specific settings.  These internal components are certain to break whenever these highly interactive and "live" compound documents are converted to another format, or application use.  This is how MSOffice documents and the business processes they represent become "bound" to the MSOffice Productivity Environment. What Gray is pointing to here is that Microsoft is moving the legacy Productivity Environment to an MSWeb based center where OpenXML, Silverlight, CAML, XAML and a number of other .NET-WPF technologies become the workgroup drivers.  The key applications for the MS WebStack are Exchange/SharePoint/SQL Server.  To make this move, documents had to be separated from the legacy desktop Productivity Environment settings. Note th
Gary Edwards

Free CloudOn app puts your iPad to work | How To - CNET - 0 views

howto.cnet.com/...301-11310_39-57452038-285.html

MSOffice Cloud-Productivity CloudON QuickOffice

shared by Gary Edwards on 13 Jun 12 - No Cached
  • Gary Edwards on 13 Jun 12
     
    The free CloudON app for iPAD provides a very nice ribbon interface for viewing and editing MSOffice XML documents.  Supports important workgroup features like "change tracking", show or hide markup, make and view comments, restrict editing, and compare and combine versions.  Very cool. Lacks support for custom add-ons, templates, auto-correct settings, and other advanced features may limit the program's usefulness.  Time to do some testing.  Hope Florian catches this post :) excerpt: Support for Office XML file types, and a ribbon to boot ...... Speculation continues as to whether -- most say when -- Microsoft will release a version of Office for the iPad. (CNET blogger Zack Whittaker cites sources predicting a November arrival.) It's not like you have to wait months to create and edit Word, Excel, and PowerPoint files on your iPad. Last June I described how to use Google Docs and Google Cloud Connect to edit Word and Excel files on an iPad for free. The end of that story noted the likely arrival of iPad apps supporting Office file formats. One of the most popular of these is the $15 Quickoffice, a program that was recently acquired by Google. But before you shell out for an Office alternative, check out the free CloudOn app, which now connects to Google Drive and Box accounts as well as Dropbox accounts. Other new features in the latest release let you send files as e-mail attachments and open PDFs. (See Lance Whitney's post on the Internet & Media blog for more on the program's PDF features.) CloudOn's ribbon is a big departure from the Quickoffice interface, which look nothing like Office. (Of course, many people will prefer the clean, clutter-free look of Quickoffice.) None of the Office extras, but all the essentials: In a group setting CloudOn's lack of support for custom add-ons, templates, auto-correct settings, and other advanced features may limit the program's usefulness. Still, the word processor lets you track and accept changes, show or
Gary Edwards

Stephen Peront : Custom Document Format Interoperability - bound business processes - 0 views

blogs.msdn.com/...9553717.aspx

bound-business-processes .net stephen-peront

shared by Gary Edwards on 24 Jul 09 - Cached
  • Gary Edwards on 24 Jul 09
     
    Custom Document Format Interoperability You may have heard that Office 2007 SP2 will now support editing files in the OpenDocument 1.1 (ODF) format. This document format was added to Office's long list of supported documents formats to give customers more choices for the format they use to save their documents. In addition to allowing you to edit the ODF 1.1 format within Office 2007, SP2 also supports a new External File Format API that can be used to edit other document formats as well. With this API, users can choose to save their documents in any format they want. In this post we will explore how to use the API to enable Office 2007 to edit our own custom document format. We will then use Office 2007 to save our custom format as DOCX, ODT and HTML. Our Custom Document Format For the purpose of this article, we have a company who needs to manage their sales pipeline information. The data is available as XML, but they do not want to spend the money to build a custom editor. They just want to let their users edit the pipeline data in Word, as a table. They give these files an extension of SPLX (i.e. Sales PipeLine Xml) The sales pipeline information is made up of a series of SalesItem tags, each with a unique id that represents the index of the item. They track the name of the customer (CustomerName), how much the deal represents (DealValue) and a percent that represents how confident they are that the sales opportunity will close (ConfidencePercent).
Gary Edwards

RealObjects: Next Generation HTML-CSS Online Editor - 1 views

www.realobjects.com

HTML5-CSS3 XHTML XML PDF Tagged-PDF Sursen Visual-Document

shared by Gary Edwards on 09 Nov 10 - Cached
  • Gary Edwards on 09 Nov 10
     
    Advanced XML, HTML5, XHTML CSS3 editing with conversion to PDF, PDF/A and SVG.  Excellent stuff.  Good Case Studies.  Lots of tools and document source code examples.
Gary Edwards

ODF Plugfest: Making office tools interoperable [LWN.net] - 0 views

lwn.net/410387

webodf ODF1.2 ODF HTML+ WebKit Gecko QTWebKit

shared by Gary Edwards on 10 Nov 10 - No Cached
  • ODF on the web An especially interesting project that was presented is WebODF, which wants to bring ODF to the web. Jos van den Oever started from the observation that a lot of office suites are moving into the "cloud". Examples are Microsoft Live Office, Google Docs, and Zoho. But where are the free software alternatives for the cloud? For OpenOffice.org, KOffice, AbiWord, and Gnumeric, there are none that have a cloud version with ODF support. That was the motivation for Jos to start a project to fill in this gap and let users view and edit ODF documents on the web without losing control of the document into some company's servers. The strategy Jos followed was to use just HTML and JavaScript for the web application. The application then loads the XML stream of the ODF document as is into the HTML document and puts it into the DOM tree. Styling is done by applying CSS rules that are directly derived from the <office:styles> and <office:automatic-styles> elements in the ODF document. That is how WebODF was born; it is a project with the initial goal of creating a simple ODF viewer and editor for offline and online use, implemented in HTML5. The small code base consists of one HTML5 file and eight JavaScript files, each of which is a few hundred lines of code. The most interesting part is that it doesn't need server-side code execution: the JavaScript code is executed in the user's browser and saving the document to the web server is done using WebDAV. It supports both the Gecko and WebKit HTML engines. There is also an implementation on top of QtWebKit, which is for better desktop integration, and an ODFKit implementation. This means that WebODF is an easy way to add ODF support to almost any application, be it in HTML, Gtk, or QML. KO GmbH has received funding from NLnet to improve the current WebODF prototype and see how far the idea goes. Interested readers can try the online demo.
  • Gary Edwards on 10 Nov 10
     
    Notification of this article also appeared in the Diigo Document Wars Group..... WebODF...   An especially interesting project that was presented is WebODF, which wants to bring ODF to the web. Jos van den Oever started from the observation that a lot of office suites are moving into the "cloud". Examples are Microsoft Live Office, Google Docs, and Zoho. But where are the free software alternatives for the cloud? For OpenOffice.org, KOffice, AbiWord, and Gnumeric, there are none that have a cloud version with ODF support. That was the motivation for Jos to start a project to fill in this gap and let users view and edit ODF documents on the web without losing control of the document into some company's servers. The strategy Jos followed was to use just HTML and JavaScript for the web application. The application then loads the XML stream of the ODF document as is into the HTML document and puts it into the DOM tree. Styling is done by applying CSS rules that are directly derived from the and elements in the ODF document. That is how WebODF was born; it is a project with the initial goal of creating a simple ODF viewer and editor for offline and online use, implemented in HTML5. The small code base consists of one HTML5 file and eight JavaScript files, each of which is a few hundred lines of code. The most interesting part is that it doesn't need server-side code execution: the JavaScript code is executed in the user's browser and saving the document to the web server is done using WebDAV. It supports both the Gecko and WebKit HTML engines. There is also an implementation on top of QtWebKit, which is for better desktop integration, and an ODFKit implementation. This means that WebODF is an easy way to add ODF support to almost any application, be it in HTML, Gtk, or QML. KO GmbH has received funding from NLnet to improve the current WebODF prototype and see how far the idea goes. Interested readers can try the online demo
Paul Merrell

Cover Pages: XML Daily Newslink: Friday, 12 November 2010 - 0 views

xml.coverpages.org/...news2010-11-12.html

IETF memento HTTP time-based access to resource states

shared by Paul Merrell on 14 Nov 10 - No Cached
  • HTTP Framework for Time-Based Access to Resource States: Memento Herbert Van de Sompel, Michael Nelson, Robert Sanderson; IETF I-D Representatives of Los Alamos National Laboratory and Old Dominion University have published a first IETF Working Draft of HTTP Framework for Time-Based Access to Resource States: Memento. According to the editor's iMinds blog: "While the days of human time travel as described in many a science fiction novel are yet to come, time travel on the Web has recently become a reality thanks to the Memento project. In essence, Memento adds a time dimension to the Web: enter the Web address of a resource in your browser and set a time slider to a desired moment in the Web's past, and see what the resource looked like around that time... Technically, Memento achieves this by: (a) Leveraging systems that host archival Web content, including Web archives, content management systems, and software versioning systems; (b) Extending the Web's most commonly used protocol (HTTP) with the capability to specify a datetime in protocol requests, and by applying an existing HTTP capability (content negotiation) in a new dimension: 'time'. The result is a Web in which navigating the past is as seamless as navigating the present... The Memento concepts have attracted significant international attention since they were first published in November 2009, and compliant tools are already emerging. For example, at the client side there is the MementoFox add-on for FireFox, and a Memento app for Android; at the server side, there is a plug-in for MediaWiki servers, and the Wayback software that is widely used by Web archives, worldwide, was recently enhanced with Memento support..."
Paul Merrell

Cover Pages: Content Management Interoperability Services (CMIS) - 0 views

xml.coverpages.org/cmis.html

interop CMIS ECM emerging standards web app glue

shared by Paul Merrell on 28 Apr 10 - Cached
  • On October 06, 2008, OASIS issued a public call for participation in a new technical committee chartered to define specifications for use of Web services and Web 2.0 interfaces to enable information sharing across content management repositories from different vendors. The OASIS Content Management Interoperability Services (CMIS) TC will build upon existing specifications to "define a domain model and bindings that are designed to be layered on top of existing Content Management systems and their existing programmatic interfaces. The TC will not prescribe how specific features should be implemented within those Enterprise Content Management (ECM) systems. Rather it will seek to define a generic/universal set of capabilities provided by an ECM system and a set of services for working with those capabilities." As of February 17, 2010, the CMIS technical work had received broad support through TC participation, industry analyst opinion, and declarations of interest from major companies. Some of these include Adobe, Adullact, AIIM, Alfresco, Amdocs, Anakeen, ASG Software Solutions, Booz Allen Hamilton, Capgemini, Citytech, Content Technologies, Day Software, dotCMS, Ektron, EMC, EntropySoft, ESoCE-NET, Exalead, FatWire, Fidelity, Flatirons, fme AG, Genus Technologies, Greenbytes GmbH, Harris, IBM, ISIS Papyrus, KnowledgeTree, Lexmark, Liferay, Magnolia, Mekon, Microsoft, Middle East Technical University, Nuxeo, Open Text, Oracle, Pearson, Quark, RSD, SAP, Saperion, Structured Software Systems (3SL), Sun Microsystems, Tanner AG, TIBCO Software, Vamosa, Vignette, and WeWebU Software. Early commentary from industry analysts and software engineers is positive about the value proposition in standardizing an enterprise content-centric management specification. The OASIS announcement of November 17, 2008 includes endorsements. Principal use cases motivating the CMIS technical work include collaborative content applications, portals leveraging content management repositories, mashups, and searching a content repository.
  • Paul Merrell on 28 Apr 10
     
    I should have posted before about CMIS, an emerging standard with a very lot of buy-in by vendors large and small. I've been watching the buzz grow via Robin Cover's Daily XML links service. IIt's now on my "need to watch" list. 
Gary Edwards

The Real Meaning Of Google Wave - Forbes.com - 0 views

www.forbes.com/...nology-cio-network-google.html

wave wave-maker google-wave

shared by Gary Edwards on 09 Sep 09 - No Cached
  • Wave is a new way to build distributed applications, and it will open the door to an explosion of innovation.
  • So, if Wave is not just the demo application, what is it? Google Wave is a platform for creating distributed applications. Each Wave server can be involved in a number of conversations involving Wavelets, what most people would think of as a document. Wavelets are actually a much more powerful and general because they are based on XML, which means you can have lots of depth of content, like headings and subheadings of a book, but on steroids. Adding a document repository to XMPP is just revolutionary.
  • The XMPP protocol manages the communication between the Wave servers so that all the Wavelets can synchronize as they are changed. Then Google finished the job by making Wavelets tag-able, searchable and versioned, so you can play back changes. But Google Wave goes beyond just managing the content--it also manages the programs that act on the content. At any level, a program can be assigned to a Wavelet to render it, that is, show it to a user and help manage the conversation. Google Wave also manages the distribution and management of these programs. The idea of a platform that combines management of the data and the code is really powerful.
  • Gary Edwards on 09 Sep 09
     
    Good article.  One of the first to go beyond the demo, recognizing that Wave is application platform - a wrapper for the convergence of communications and content. Excerpt: Wave is a new way to build distributed applications, and it will open the door to an explosion of innovation. What the Wave demo showed is support for a continuum from the shortest messages to longer and longer forms of content. All of it can be shared with precise control, tagged, searched. The version history is kept. No more mailing around a document. This takes the beauty of e-mail and wikis and extends it in a more flexible way to a much larger audience. Google Wave is a platform for creating distributed applications. Each Wave server can be involved in a number of conversations involving Wavelets, what most people would think of as a document. Wavelets are actually a much more powerful and general because they are based on XML, which means you can have lots of depth of content, like headings and subheadings of a book, but on steroids. Adding a document repository to XMPP is just revolutionary. The XMPP protocol manages the communication between the Wave servers so that all the Wavelets can synchronize as they are changed. Then Google finished the job by making Wavelets tag-able, searchable and versioned, so you can play back changes. But Google Wave goes beyond just managing the content--it also manages the programs that act on the content. At any level, a program can be assigned to a Wavelet to render it, that is, show it to a user and help manage the conversation. Google Wave also manages the distribution and management of these programs. The idea of a platform that combines management of the data and the code is really powerful.
Gary Edwards

Microsoft Office to get a dose of OpenDocument - CNET News - 0 views

news.cnet.com/...2100-1013_3-6069188.html

ODF daVinci MSOffice-productivity

shared by Gary Edwards on 04 May 13 - No Cached
  • Gary Edwards on 04 May 13
     
    While trying to help a friend understand the issues involved with exchanging MSOffice documnets between the many different versions of MSOffice, I stumbled on this oldy but goody ......... "A group of software developers have created a program to make Microsoft Office work with files in the OpenDocument format, a move that would bridge currently incompatible desktop applications. Gary Edwards, an engineer involved in the open-source OpenOffice.org project and founder of the OpenDocument Foundation, on Thursday discussed the software plug-in on the Web site Groklaw. The new program, which has been under development for about year and finished initial testing last week, is designed to let Microsoft Office manipulate OpenDocument format (ODF) files, Edwards said. "The ODF Plugin installs on the file menu as a natural and transparent part of the 'open,' 'save,' and 'save as' sequences. As far as end users and other application add-ons are concerned, ODF Plugin renders ODF documents as if (they) were native to MS Office," according to Edwards. If the software, which is not yet available, works as described, it will be a significant twist to an ongoing contest between Microsoft and the backers of OpenDocument, a document format gaining more interest lately, particularly among governments. Microsoft will not natively support OpenDocument in Office 2007, which will come out later this year. Company executives have said that there is not sufficient demand and OpenDocument is less functional that its own Office formats. Having a third-party product to save OpenDocument files from Office could give OpenDocument-based products a bump in the marketplace, said Stephen O'Grady, a RedMonk analyst. OpenDocument is the native format for the OpenOffice open-source desktop productivity suite and is supported in others, including KOffice, Sun Microsystems' StarOffice and IBM's Workplace. "To the extent that you get people authoring documents in a format that is natively compatible with
Gary Edwards

Overview of apps for Office 2013 - 0 views

msdn.microsoft.com/...jj220082(v=office.15)

MSOffice-Web-Apps MSCloud-Developer

shared by Gary Edwards on 25 Aug 12 - No Cached
  • Gary Edwards on 25 Aug 12
     
    MSOffice is now "Web ready".  The Office apps are capable of running HTML5-JavaScript apps based on a simple Web page model.  Think of this as the Office apps being fitted with a browser, and developers writing extensions to run in that browser using HTML5 and JavaScript.  Microsoft provides an Office.js library and, a developer "Web App/Page Creator"  Visual Basic toolset called "Napa" Office 365 Development Tools.  Lots of project templates. Key MSOffice apps are Word, Excel, PowerPoint and Outlook.  Develop for Office or SharePoint.  Apps can be hosted on any Web Server. excerpt: Microsoft Office 2013 Developer Environment with HTML5, XML and JavaScript.  Office.js library. "his documentation is preliminary and is subject to change. Published: July 16, 2012 Learn how to use apps for Office to extend your Office 2013 Preview applications. This new Office solution type, apps for Office, built on web technologies like HTML, CSS, JavaScript, REST, OData, and OAuth. It provides new experiences within Office applications by surfacing web technologies and cloud services right within Office documents, email messages, meeting requests, and appointments. Applies to:  Excel Web App Preview | Exchange 2013 Preview | Outlook 2013 Preview | Outlook Web App Preview | Project Professional 2013 Preview | Word 2013 Preview | Excel 2013 Preview  In this article What is an app for Office? Anatomy of an app for Office Types of apps for Office What can an app for Office do? Understanding the runtime Development basics Create your first app for Office Publishing basics Scenarios Components of an app for Office solution Software requirements"
Gary Edwards

Kindle Format 8 Overview - 0 views

www.amazon.com/...feature.html

KF8 compound-documents Cloud-Productivity-Platform Cloud-Compound-Document

shared by Gary Edwards on 13 Jan 12 - No Cached
  • Gary Edwards on 13 Jan 12
     
    Amazon releases a new version of the KF8 Format, with greatly improved HTML5-CSS3 capabilities.  Details of the KF8 spec can be found here: http://goo.gl/XY39v A couple of things i'm wondering about here.  One is, the KindleGen conversion tool can convert HTML, XHTML and EPUB to KF8.  Has anyone tried to push a OpenOffice XHTML compound document through this latest KF8 version of  KGen?  I'm thinking that perhaps the OOo HTML problem could be solved in this way? There is no doubt in my mind that HTML5 will continue to grow, and eventually replace the desktop XML "compound document" formats. The great transition from desktop client/server business productivity environments, where legacy compound documents rule the roost and fuel the engines of all business systems, to a Cloud Productivity Platform, will require an HTML5 compound document format model.  Also needed will be HTML5 capable applications participating in the production of Cloud ready compound documents.  Is KF8 a reasonable starting place? excerpt: Kindle Format 8 is Amazon's next generation file format offering a wide range of new features and enhancements - including HTML5 and CSS3 support that publishers can use to create all types of books. KF8 adds over 150 new formatting capabilities, including drop caps, numbered lists, fixed layouts, nested tables, callouts, sidebars and Scalable Vector Graphics - opening up more opportunities to create Kindle books that readers will love. Kindle Fire is the first Kindle device to support KF8 - in the coming months KF8 will be rolled out to our latest generation Kindle e-ink devices as well as our free Kindle reading apps.
1 - 20 of 41 Next › Last »
Showing 20▼ items per page