public function loadUnloadModules(mod:Module,_url:String):void
   {
           current_module            = mod;
           main_module_loader.url    = "";
           module_url                = _url;
  }

This function is accessible to an already loaded module by calling it on : parentApplication.loadUnloadModule etc.  The following code on the login module itself, calls the function residing in the shell application and the login module unloads itself and loads the next module.

protected function authKnockResult_resultHandler(ev:ResultEvent):void
 {
     if ((ev.result as Boolean) == false)
     {
         currentState = "no_access_state";
     }
     else
    {
        parentApplication.loadUnloadModules(this,"MagazineModule.swf");
    }
 }

The php application and the enormous SQL database was written and has been maintained over the past ten years by one, in-house developer at Hafiba. He will be taking this opportunity to rewrite and update much of the server-side php while we create a single Adobe Flex client-side application capable of serving the publisher clients, the print-houses and the staff of Hafiba themselves. For this, we at CIP have proposed a Flex Client-side which loads the appropriate module according to the status and permissions allowed to the user at login. The Shell Flex 4 application will load one of three Flex Modules for the publisher, printer, or pre-press user.

The first task was to find out if and how Flex 3 modules have changed in Flex 4. After which I quickly cobbled together a shell application responsible for automatically  loading the login module, and subsequent modules based on the users login permissions.

The current application offered to clients of Hafiba is a Flash Actionscript 2.0 front-end, released in 2004, built over a php / SQL system that had been in place as the internal production software of the company. Hafiba employees themselves run a much larger version of the same workflowsystem with a front-end built in Adobe SVG. The many print houses associated with Hafiba have a third version of the same system which offers the printer a coherent way of interacting with both the pre-press and the publisher’s process. Our mission is to bring the three applications together under one front-end built in Flex 4 with the new Flash Builder 4 and Adobe CS5 Suite tools.

It seems more difficult than it should, just to be certain we are dealing with the xml url and not the html url, but many addresses do not end in xml   – - I have also found that feeds beginning with feed://etc, work in my Flex HTTPService only if I change the “feed://” to “http://” although this change does not guarantee that the feed will work. In addition to this, none of the feeds will load once the application is deployed to my remote server. A java servlet or php proxy is needed on the CLS domain.

My CLS RSSReader is a simple variation on the recommended use of httpService to populate a data grid. The item element is assigned to an array collection, unless, for some reason, the url does not return an xml in <rss><channel><item> format.

 public function parceRSS(ev:ResultEvent):void
 {
         try  {
               _collection = ev.result.rss.channel.item as ArrayCollection;
         }
         catch (err:Error){
               Alert.show("Feed Not Found at above :::: Cannot Load Feed",feed_url);
       }
 }

Although the original idea simply assigned the data chosen in the Combobox to the feed_url variable and assigned feed_url to the url of the HTTPService call, The Flash Player prevents this direct transfer of data across different domains.

<mx:HTTPService id="_HTTPServiceCall" showBusyCursor="true"

 url= "{feed_url}" result="parceRSS(event)" fault="onFault(event)">

After searching through blogs on proxy solutions and their alternatives, I settled on the ‘Using a PHP Proxy with Flex to talk Cross Domain‘ solution offered on Switch On The Code. Replacing the url= “{feed_url}” with a absolute url pointing to the php proxy on the CLS server, and adding <request> tags to the httpService, as shown in the tutorial I ended up with this:

<mx:HTTPService id=”_HTTPServiceCall” showBusyCursor=”true” method=”POST“

url= “http://cluttered.flvservers.com/proxy.php” result=”parceRSS(event)”

fault=”onFault(event)”>

<mx:request>

<url> {feed_url} </url>

</mx:request>

</mx:HTTPService>

I found other sources on building RSS readers in Flex in the Flex Cookbook, Chad Udell’s VisualRinse, and at Adobe Labs. The quick and dirty Twitter feed reader entry in the Flex Cookbook (may 30, 2009) does not go deep into the Twitter API, and seems to illustrate that from the resulting XMLList which is passed event.result.status, the feed can be looped through with an MXML Repeater, currentItem by currentItem. The resulting xml is in the form:    <statuses type=”array”>  <status>  <user>    Without a loop, the simplest way is to cast the HTTPService result as XML and assign the XML.children() to an XMLList –  xml_list = new XMLList(_xml.children()) for the feeds which have a single child node structure like twitter’s <status>; or the <channel><item> form:

import mx.rpc.events.ResultEvent;

[Bindable]

private var _xml:XML;

[Bindable]

private var xml_list:XMLList;

public function init():void

{

_HTTPServiceCall.send();

}

public function parceRSS(ev:ResultEvent):void

{

//e4x returns XML object

_xml = ev.result as XML;

xml_list = new XMLList(_xml.children());

}

Other solutions on the web use the httpService directly as a dataprovider for a dataGrid: dataProvider=”{myFeed.lastResult.rss.channel.item}” without a variable to hold the arrayCollection. Most feeds work with this, so maybe a feed reader which can distinguish a twitter feed, from atom feeds, from other forms would be useful enough. The app will allow the user to choose from a list of feeds, or enter a url of their own.

I finally settled on the following but have found that it does not work with 20% of the feeds I have tried.

<mx:HBox width=”90%” height=”40“>

<mx:Label text=”Feed Selection” color=”#FFFFFF“/>

<mx:ComboBox id=”feedlist_combo” dataProvider=”{rss_feeds}“

labelField=”name” useHandCursor=”true” editable=”false“

rowCount=”40“ change=

“chooseSiteFeed(ComboBox(event.target).selectedItem.data,

ComboBox(event.target).selectedItem.name)” />

<mx:HBox width=”100%“/> <mx:Spacer width=”200“/>

<mx:TextInput id=”input_field” width=”400” text=”add feed url here“/>

<mx:Button id=”enterurl_btn” label=”Enter URL” click=”addNewFeed()”/>

</mx:HBox>

The addNewFeed function looks like this:

private function addNewFeed():void
  {
      feed_url = input_field.text;
      _HTTPServiceCall.send();
      var temp_item:Object = new Object();
      temp_item.name = "Custom Entry"
      temp_item.url = "";
      rss_feeds.addItemAt(temp_item,0);
      feedlist_combo.selectedIndex = 0;
  }

and the full source code is available by right clicking the application at Cluttered Systems.

After putting together a VideoSetUp class with connection and stream, et al, I came across a blog by Panta at http://blog.oaxoa.com/ who used the Flash FLVPlayback component to build a surprisingly simple video wall. The FLVPlayback component is BitMapDrawable and the VideoScaleMode class with its resize methods allowed a simple translation Matrix to do all the work. Decoupling the rows and columns required a resizeVideo function which divides the width and height by the number of columns if the number of columns is greater the rows, and divides width and height by the number of rows, if the number of rows is greater than columns.

        private function resizeVidScreen():void
        {
            if(numberOfColumns > numberOfRows){
                vid_width        = wall_width / _columns;
                vid_height        = wall_height / _columns;
                video_source.setSize(vid_width,vid_height);

            }else if(numberOfRows > numberOfColumns){
                vid_width        = wall_width / _rows;
                vid_height        = wall_height / _rows;
                video_source.setSize(vid_width,vid_height);

            }else{
                vid_width        = wall_width / _columns;
                vid_height        = wall_height / _rows;
                video_source.setSize(vid_width,vid_height);
            }
            bmp_data.draw(_background);
        }

With this new functionality, I found that the Bitmap.draw redraws only the new columns or rows and leaves the unchanged area as a still image (of the last frame) of the previous size video. For this I created a black background which is redrawn in the case that the col and rows are uncoupled. Unfortunately the otherwise smooth transitions between view changes is interrupted by this black “frame” however brief; that goes on the list of fixes for the next version.

Testing the wall with different sized videos has inspired a few presets for the view size of the video. I decided that if the video is not wider than 220 pixels there is no interest in dividing it along a video wall; if it is between 220 and 320 it will be resized to 320; and anything larger than 320 will show as a video of width 505. The setWallDimensions function covers this.

        private function setWallDimensions():void
        {
            if (wall_width > 319){
                wall_width     = 505;
                wall_height = wall_width / aspect_ratio;
            }else if ((wall_width < 319) && (wall_width > 220)){
                wall_width = 320;
                wall_height = wall_width / aspect_ratio;
            }else if(wall_width < 220){

                 Alert.show("Your video's dimensions are too small");
                 return;
            }
            shift_x        = (540 - wall_width) *0.5;
            shift_y        = (395 - wall_height) * 0.25;
        }

The onEnterFrameHandler contains the translation Matrix which displays the video frame across the columns and rows once every frame of the swf.

        private function onEnterframeHandler(ev:Event):void
        {
            for(var i:uint=0; i<_rows;i++){
                for(var j:uint=0; j<_columns;j++){

                    var _matrix:Matrix    = new Matrix();
                    _matrix.translate(j*vid_width, i*vid_height);
                    bmp_data.draw(video_source,_matrix);
                }
            }
        }

In the mxml a UIcomponent named videowall_container holds the _videowall which is an instance of the VideoWall.as class. The properties numberOfColumns, numberOfRows, shiftX, shiftY, and videoURL are available to the VideoWall.as class. Both NumericSteppers call the columnChange function upon change.

The resulting file can be in the <rss><channel><item> form, or, often, a long page of html tags, apparently an rss to html feed; Twitter feeds return <statuses type=”array”> , other feeds resulted in other tags. One puzzling characteristic of the subscription url is that it often returns the html tags (page) if we look at event.result but returns the rss channel.item if we look at event.result.RDF.item .. . Flex Builder and Flash Builder, allow me to view the returned data in debug mode, in the variables window, of course, but I was expecting the reverse: an XML file beginning with the:  ?xml version=”1.0″  rss version 2.0, etc. , at event.result and maybe an html version if we drill down into the data returned by the feed. (I know, maybe I just don’t get it) but if the return property of the httpService is set to e4x, the xml we trace at event.result is almost always the html page, if we allow the default return in the form of an ArrayCollection, event.result.rdf is null and event.result.rdf.item returns the entire rss feed.