<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet type="text/css" 
href="http://www.germane-software.com/svn/repos/documentation/documentation.css"
?>
<?xml-stylesheet type="text/css"
href="file:/home/ser/Work/documentation/documentation.css"
?>
<?xml-stylesheet type="text/xsl"
href="http://www.germane-software.com/svn/repos/documentation/paged.xsl"
?>
<!DOCTYPE documentation SYSTEM 
	"http://www.germane-software.com/svn/repos/documentation/documentation.dtd">
<documentation>
  <head>
    <title>Rouge</title>

		<version>0.0.1</version>

		<date>+2003/035</date>

    <home>http://www.germane-software.com/software/Rouge</home>

    <base>Rouge</base>

    <language>ruby</language>

    <author email="ser@germane-software.com" jabber="ser@jabber.com"
    href="http://www.germane-software.com/~ser">Sean Russell</author>
  </head>

  <overview>
    <purpose lang="en">
			<p>
				Rouge is a high level GUI toolkit.  It interprets a XUL-like XML GUI 
				description language, as well as providing native Ruby API.  Rouge
				is designed to be a front-end for multiple back-ends, allowing users
				to choose from a number of native GUI toolkit implementations to match
				their own tastes.
			</p>

      <p>This software is distribute under the <link href="LICENSE.txt">Ruby
      license</link>.</p>
    </purpose>

    <general>
			<p>
				Every once in a while, someone starts a discussion in comp.lang.ruby
				about how they'd like to see a GUI toolkit that really follows the
				Ruby Way of ease of use.  They then begin talking about what sorts
				of features they'd like to see, how it should work, what they don't
				like about current toolkits, and generally end with a call to arms to
				build such a beast.  Inevitably, this sparks a huge thread about what
				a Ruby GUI toolkit would look like, filled with arguments about the
				relative merits of abstracted GUIs vs. purely native GUIs, speed
				issues, and the occasional ass saying 
				"Give it up; use TK like the rest of us."<footnote>The people in this 
					latter category, in my mind, are of the same class of people who 
					said "Get over it; use chipped bits of stone like the rest of us."
				</footnote>
			</p>

			<p>
				I, too, once started one of these threads.  Frustrated with the state
				of the Ruby GUI, I launched into a rhapsodic account of what my
				personal vision of Ruby GUI heaven looked like.  This resulted in the
				formation of a mailing list and a Wiki page, which saw a lot of
				traffic, some really nice ideas, and some test code by various people.
				I'm not sure what happened, but traffic stopped rather suddenly, and
				things sort of ran to a halt.  I think a major holiday was responsible,
				along with the fact that I lost my cushy job and (ironically) no 
				longer had time to work on the project or tend to the mailing list.
				I'm also pretty sure that around that time our server, which was
				hosting the mailing list, lost a hard drive, and in the process of
				upgrading the machine, the mailing list broke.
			</p>

			<p>
				The forces of Evil, it seems, were determined to keep us from entering
				Ruby GUI heaven.
			</p>

			<p>
				Well, hold on to your carbuncles, because we're back.  Rouge is alive.
			</p>
    </general>

    <features lang="en">
      <item>Partial implementation of XUL</item>

			<item>Simple native Ruby API.</item>

			<item>FXRuby backend</item>
    </features>
  </overview>

  <operation lang="en">
		<subsection title='README'>
			<p>
				This is very beta!  Be warned!  In fact, stop reading now and go
				read the README.
			</p>
		</subsection>

		<subsection title='Architecture'>
			<p>
				Check out the architecture 
				<link href='diagrams/rouge.svgz'>diagram</link>.  This was put together
				by the folks on the Rouge mailing list, and it is still a great
				architecture.  In this diagram, Rouge (this project) is the Alpha
				and Delta layers.  It is an API; it interprets the GUI layout and the 
				bindings that the developer specifies (the Alpha layer), and 
				translates these into a generic GUI language (the Delta layer).  
				Various native bindings are employed to actually render the GUI (the
				Omega layer).
			</p>

			<p>
				Please keep in mind that this is all experimental.  I have, and will,
				drop anything that becomes as unwieldy as any GUI toolkit that 
				currently exists for Ruby.  I've already thrown out two other stabs
				at the API.  Feedback is very important, but the mailing list has
				had a huge amount of discussion about design and implementation that
				I'm not going to repeat here.  Someday, someone will cull the mailing
				list and create a document that describes the philosophy and goals,
				and describes the architecture and reasons for the design choices.
				Until then, please submit your questions to the Rouge mailing list.
			</p>
		</subsection>

    <subsection title="Requirements">
			<p>
				Currently, only the FXRuby native binding is available.  This is only
				because I'm a busy person, and only have so much time.  If you wait
				long enough, eventually other Omega layers will emerge... or, you could
				make a stab at writing your own.  They're pretty easy, and one of 
				my goals is to keep the implementation of Omegas as simple as possible.
			</p>

			<p>
				The other requirement is REXML.  This is for the XUL interpreter.
			</p>
    </subsection>

		<subsection title='Technical discussions'>
			<p>
				FXRuby is in the works.  TK should be next, and I'd like at least one
				other, to prove the concept.  The biggest obsticle to implementing an
				Omega layer is a lack of layout managers.  With sufficient layout
				manager support, the back-ends are easy.
			</p>

			<p>
				I'm fairly certain that if I work on any Gamma layer, it'll be an
				SVG based GUI.  Either this, or SDL, but I'm leaning toward SVG.
				librsvg is a starting point.
			</p>

			<p>
				My first priority is to get XUL mostly supported; with this comes the
				native Ruby API, as a gimme.  I need people using this and giving me
				feedback before I can move forward, and I really need people 
				contributing input, direction, and bits of code -- and Omega layers.
				Unlike REXML, this (I'm of the opinion) must be a community project.
			</p>

			<p>
				XForms.  Boy, the coup-de-grace would be an Alpha layer that interpreted
				XForms.  We'll see.
			</p>
		</subsection>
  </operation>

  <status>
		<subsection title="Widgets implemented">
			<p>
				SECTION INCOMPLETE
			</p>
    </subsection>

    <subsection title="Mailing list">
			<p>There is a mailing list dedicated to Rouge.  Sometimes it has a lot
				of traffic, sometimes it has none.
			</p>
		
			<p>
				To subscribe, send an empty email to <link
      href="mailto:rouge-subscribe@germane-software.com">rouge-subscribe@germane-software.com</link>.
      This list is more or less spam proof. To unsubscribe, similarly send a
      message to <link
				href="mailto:rouge-unsubscribe@germane-software.com">rouge-unsubscribe@germane-software.com</link>.</p>
    </subsection>

    <subsection title="RSS">
      <p>An <link
      href="http://www.germane-software.com/software/Rouge/rss.xml">RSS file</link>
      http://www.germane-software.com/software/Rouge/rss.xml</p>
    </subsection>

    <changelog>
			<item version='0.0.1'>Initial release</item>
    </changelog>

    <bugs lang="en">
    </bugs>

    <todo lang="en">
    </todo>
  </status>

  <faq>
  </faq>

  <credits>
		<p>The Rouge mailing list, of course.</p>
  </credits>
</documentation>
