Ronoix and CSS

Ronoix and CSS are both interesting technologies. Here, we have tried to best integrate the two, while maintaining the syntax, format, and development process for the two, while allowing tight integration with the CSS and Ronoix interfaces.

Syntax

Ronoix provides a simple and direct method for integrating CSS into a document. (Note that CSS is only compatible with Ronoix data types, and not encapsulated data types)

This document, when ULS points to a CSS file, can be styled easily and with no problems. Here is an example of the CSS that can style the above Ronoix document.

This simple amount of code will produce something along the lines of:

Support

Support for the CSS and CSS2 specifications varies. Here is a list of the currently supported features:

Selectors

1. Standard type selectors: type
2. Standard class selectors: .class
3. Type and class selectors: type.class
4. Grouped selectors: selector,selector,selector
5. Selectors with IDs: type #ID; .class #ID; etc.
6. Multiple classes: type.class.class...
7. Descendant elements: selector selector selector... (Note: Support is limited to only one ID)
8. Child elements: selector > selector...

Units of Measurement

1. Inches
2. Centimeters
3. Millimeters
4. Points
5. Picas
6. Pixels

Proposed Units of Measure

1. EX: the 'x-height' of the font of the object being referenced
2. EM: the 'font-size' of the object being referenced; already in place for fonts only
3. Percentages: Based off of the inherited value of the type being referenced

Shorthand

1. padding
2. margin*
3. font

Font Properties

1. color
2. font-size*
3. font-weight**
4. font-family
5. font-style

CSS Extensions

In order to make our algorithms compatible with the CSS2 selectors and inheritance, we have implemented a number of features that provide readability and easy formatting to selectors in CSS. Note that we have not tested these methods to work with other CSS parsing algorithms, nor do we intend to. These modifications are designed to work strictly within Ronoix code, and will most likely *NOT* work in other parsing systems.

1. Selector Fishing:
   
   Selector fishing is the process of using various prefixes to modify the behavior of the heirs of an element. For example:
   content > text {}
   and
   content !text {}
   will work the same. Here is a list of what can be replaced:
   
   
   • Descendants:
     
     Note that this method does not make any changes to the CSS specification, but remains the shorthand method for descendant elements.
     content text {}
   • Children:
     
     These elements must be directly linked, where one is contained within the second.
     content !text {}
   • Adjacent Elements:
     
     These elements must have the same parent, and be directly adjacent to each other in the Ronoix code.
     content +text {}
2. Quoted Values:
   
   By default, CSS2 (as well as CSS) bans the use of quoting values. For example, under the current CSS/CSS2 specifications, the following CSS is invalid:
   h1 {color: "red"}
   The correct syntax would be:
   h1 {color: red}
   Our CSS parser is specifically designed to accept this, even though it is invalid. Regardless, quotes are stripped from the ends of the values by default, eliminating this problem.
3. Underline Compatibility
   
   Because Ronoix uses WinForms to render pages, there may at times be data types that you need to modify that are automatically generated, and are not documented in Ronoix. To access these, simply find out what the true Type.ToString is for that object, and reference it as follows:
   
   Suppose you are modifying a divider. You would replace all '.'s in the divider type.tostring with '_'s and place that as a type descriptor in your CSS. Ex.:
   lookleft1_divider #menu {...}
   Because this method would automatically erase all underscores in the type, we highly recommend that you do not introduce any underscores into type descriptors that describe non-Ronoix objects.

HTML Conformance

Selectors

• BODY/HTML BODY
  Our parser is fully able to apply the described selectors to the <contents> element.
• Classes
  HTML is a form of XML, and thus can include multiple descriptors of specific elements (ex. class, id, etc.). Unfortunately, WinForms supports only one descriptor per control. In order to compensate, the following items serve as replacements:
  
  
  • ID: Name
  • Class: Tag
  • Type: {control type}

Extensions

HTML has been extended hundreds, if not thousands of times, making it more complex for everyone overall. Ronoix, because it is compatible with XML, is freely extensible. Thus, the CSS involved describes XML, not a dependant language such as HTML.

Shortcomings

• Note that the value of 'oblique' for 'font-style' will return the same result as 'italic'.
• The font-size attribute
• It is recommended that when using the 'inherited' value for 'font-style', all other font formatting is placed after. ALL of the parent's formatting will be inherited with this property, including italic, weight, strikeout, and underline.
• When the universal selector is used in either of these contexts:
  selector * selector {}
  selector > * > selector {}
  or any similar situation in which 'selector' is used to describe an ancestor, the universal selector automatically matches the first descendant or child of the first selector and searches that item. The expected result would be to find a node that contains the second selector as a descendant or child that is a descendent or child of the first selector.
  
  For example, the following CSS will not find the 'final' element because it recognizes the <wrong> node as the placeholder for the universal selector:
  root * final {}
  <root>
      <wrong></wrong>
      <right>
          <final />
      </right>
  </root>
• The font-size property only accepts EM size units. Other values such as 'x-small' are not supported.
• Under the shorthand for the 'font' series, the specialized elements (ex: caption, icon, etc.) are ignored.
• Due to lack of demand, the values 'cursive' and 'fantasy' under 'font-family' is ignored.
• The following descriptors are not supported at all:
  • font-stretch
  • font-size-adjust
  • font-variant (minimally supported under shorthand, not yet ported to standalone)
  • line-height
  • background (shorthand)
  • background-position
  • background-attachment
  • text-shadow
  • letter-spacing
  • word-spacing
  Unsupported properties are simply ignored.
• Due to the complicated code involved, section 15.3 and all subsections involved with secion 15.3 of the CSS2 specification are not supported.
• The 'inherit' value for most descriptors is unavailable at the time.
• Colors may only be supplied in either rgb(), argb() or #RRGGBB format. Any other format is ignored as black.
• The 'background-repeat' descriptor only supports the values 'repeat' and 'no-repeat' that are specified in the CSS2 specification, but add the values 'stretch', 'center', 'inherit', and 'zoom'; each performing their respective functions.
• 'text-indent' simply modifies the padding based off of the current text alignment.
• Percentage-based values are not supported at all.
• 'text-indent' only supports pixel based values.
• 'text-decoration' does not support 'overline' and 'blink'. Setting it to 'none' or 'inherit' also erases any 'font-style' that may be set. If you want to set it to none, set it to none before you specify a value for 'font-style'.
• 'word-wrap' works only when whitespaces are implemented directly within the viewable Ronoix document.

Notices

• 'text-transform' applies effects directly to the text. Thus, it cannot be undone by setting the value to 'none'. However, it cannot be inherited, and it cannot be forcefully inherited, either. Thus, it is void to set its value to 'none'.
• The 'text-transform' descriptor uses the TextInfo.ToTitleCase() function of .Net. This may produce undesirable results. It does not implement a language-specific feature, so languages like Dutch may become undesirably capitalized.
• Our CSS parsers require more than two properties to work properly. If there are not two or more properties, the system will freeze.