devexpress pdf viewer asp.net mvc : Batch pdf to jpg online control software platform web page windows asp.net web browser Enterprise-Development-with-Flex12-part708

• The Flex 3 SDK class 
mx.core.ClassFactory
can create a factory only for a class; it
can’t create a factory for a class name that is being provided as a 
String
. It can’t
build instances of objects based on a return of a function—a class is required.
• Building UI objects on the fly may require applying dynamic data-driven styles.
Styles are not properties, and 
mx.core.ClassFactory
would not know what to do
with them if you used them in the 
properties
variable.
• If you use UI components as renderers or editors, they may need to process events.
It would be nice if event listeners could be attached by a class factory, and the
created object would dispatch events when properties are changing. The class
mx.core.ClassFactory
doesn’t know how to do it.
In the Flex 4 SDK, 
ClassFactory
allows you to dynamically assign item
renderers to 
List
-based components based on the name of the class
provided in a string variable:
<s:List itemRendererFunction="myRendererFunc">
...
private function myRenderedFunc (item:Object): ClassFactory{
var myRenderer:Class;
switch (item.membershipType){
case "Trial":  myRenderer=TrialMemberRenderer;
break;
case "Basic":
myRenderer=BasicMemberRenderer;
break;
case "Premium":
myRenderer=TrialMemberRenderer;
break;
}
return new ClassFactory(myRenderer);
}
Creating UIStaticClassFactory
This final section offers you a more advanced implementation of the Class Factory
pattern that is specifically created for the UI components, especially item renderers in
List
-based Flex components. Please read the description of this implementation, called
UIStaticClassFactory
, in the code comments of Example 2-22.
Example 2-22. UIStaticClassFactory.as
Class Factory y | | 97
Batch pdf to jpg online - Convert PDF to JPEG images in C#.net, ASP.NET MVC, WinForms, WPF project
How to convert PDF to JPEG using C#.NET PDF to JPEG conversion / converter library control SDK
convert pdf photo to jpg; pdf to jpeg converter
Batch pdf to jpg online - VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.net, ASP.NET MVC, WinForms, WPF project
Online Tutorial for PDF to JPEG (JPG) Conversion in VB.NET Image Application
convert pdf file to jpg format; changing pdf to jpg file
package com.farata.core{
/**
*  properties, styles and event listeners during the object creation.
*  It's implemented as a wrapper for mx.core.ClassFactory and can
*  be used as a class factory not just for classes, but for functions
*  and even strings.
*
*  @see mx.core.IFactory
*/
import flash.utils.describeType;
import flash.utils.getDefinitionByName;
import mx.controls.dataGridClasses.DataGridColumn;
import mx.core.ClassFactory;
import mx.core.IFactory;
import mx.events.FlexEvent;
import mx.styles.StyleProxy;
import mx.logging.Log;
import mx.logging.ILogger;
import mx.logging.LogEventLevel;
public class UIStaticClassFactory implements IFactory{
// A class factory object that serves as a wrapper
// for classes, functions, strings, and even class factories
private var _wrappedClassFactory : ClassFactory;
// A reference to a function if the object instances are
// to be created by a function
private var factoryFunction : Function = null;
// Styles for the UI object to be created
public var styles:Object;
// Event Listeners for the UI object to be created
public var eventListeners:Object;
private static const logger:ILogger =
Log.getLogger ("com.farata.core.UICassFactory");
public function set properties(v:Object):void    {
_wrappedClassFactory.properties = v;
}
public function get properties():* {
return _wrappedClassFactory.properties ;
}
public function get wrappedClassFactory():ClassFactory {
return _wrappedClassFactory;
}
/**
98 | | Chapter 2: Selected Design Patterns
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
software; Support a batch conversion of JPG to PDF with amazingly high speed; Get a compressed PDF file after conversion; Support
reader pdf to jpeg; convert pdf to jpg file
JPG to GIF Converter | Convert JPEG to GIF, Convert GIF to JPG
speed JPEG to GIF Converter, faster than other JPG Converters; when you convert the files in batch; Storing conversion so the user who is not online still can
change from pdf to jpg on; convert pdf file to jpg
* Constructor of UIClassFactory takes four arguments
* cf   -  The object to build. It can be a class name,
        a string containing the class name, a function,
        or another class factory object;
* styles - styles to be applied to the object being built
*/
function UIStaticClassFactory( cf: * , props:Object = null,
if ( cf is UIStaticClassFactory) {
_wrappedClassFactory =
} if ( cf is ClassFactory) {
_wrappedClassFactory = cf;
} else if (cf is Class) {
_wrappedClassFactory = new ClassFactory(Class(cf));
} else if (cf is String) {
className = String(cf);
try {
_wrappedClassFactory = new  ClassFactory(clazz);
} catch (e:Error)     {
}
} else if (cf is Function) {
factoryFunction = cf;
} else {
className = "null";
if (cf!=null)
trace("'" + className + "'" +
}
if (!_wrappedClassFactory) {
_wrappedClassFactory = new ClassFactory(Object);
}
if (styles != null) this.styles = styles;
}
/**
* The implementation of newInstance is required by IFactory
*/
public function newInstance():* {
var obj:*;
if (factoryFunction!=null){
Class Factory y | | 99
JPG to DICOM Converter | Convert JPEG to DICOM, Convert DICOM to
Open JPEG to DICOM Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "DICOM" in
convert pdf to jpg c#; change pdf into jpg
JPG to JBIG2 Converter | Convert JPEG to JBIG2, Convert JBIG2 to
Ability to preserve original images without any affecting; Ability to convert image swiftly between JPG & JBIG2 in single and batch mode;
convert from pdf to jpg; convert pdf file into jpg
// using a function to create an object
obj = factoryFunction();
// Copy the properties to the new object
if (properties != null)  {
for (var p:String in properties) {
obj[p] = properties[p];
}
}
} else
obj = _wrappedClassFactory.newInstance();
// Set the styles on the new object
if (styles != null)  {
for (var s:String in styles) {
obj.setStyle(s,  styles[s]);
}
}
//add event listeners, if any
if (eventListeners != null)  {
for (var e:String in eventListeners) {
obj.addEventListener(e,  eventListeners[e]);
}
}
return obj;
}
}
}
Let’s examine the constructor of this class factory. It has four arguments, described in
the comments. In the first argument, the code of this constructor checks the type of the
object to build the factory for. In particular, if it’s a class, it just instantiates
mx.core.ClassFactory
.
More interestingly, if it finds that the type of the first argument is a 
String
, it’ll load the
class specified in this 
String
and build a factory for this class, too.
One more scenario: if you’d like to specify not a class but just a function for the class
factory, it can accommodate this request as well.
Example 2-23 shows you a test application that uses this class factory to dynamically
build item renderers for a 
DataGrid
not on a per-column basis but on a per-cell basis.
Example 2-23. ClassFactoryDemo.mxml
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
xmlns:fx="http://www.faratasystems.com/2009/components"
layout="vertical" creationComplete="init()">
<mx:HDividedBox width="100%" height="100%">
verticalGridLines="false"  variableRowHeight="true"
preventRendererReuse="columnValue">
100 | | Chapter 2: Selected Design Patterns
JPG to Word Converter | Convert JPEG to Word, Convert Word to JPG
Open JPEG to Word Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "Word" in
convert multi page pdf to single jpg; convert pdf picture to jpg
JPG to JPEG2000 Converter | Convert JPEG to JPEG2000, Convert
Open JPEG to JPEG2000 Converter first; ad JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "JPEG2000" in
convert pdf into jpg online; .pdf to jpg converter online
<fx:columns>
<mx:Array>
<mx:DataGridColumn width="150"    textAlign="left"
dataField="columnValue"   headerText="Value"
wordWrap="true"  rendererIsEditor="true"
return switcher(dg.rendererData)})}"/>
</mx:Array>
</fx:columns>
</fx:DataGrid>
<mx:DataGrid editable="true" dataProvider="{dp}" height="100%" >
</mx:DataGrid>
</mx:HDividedBox>
<mx:Script>
<![CDATA[
import mx.controls.Label;
import mx.collections.ArrayCollection;
import mx.controls.RadioButtonGroup;
import mx.controls.TextInput;
import com.adobe.flex.extras.controls.MaskedTextInput;
import com.farata.core.UIStaticClassFactory;
[Bindable]
private var dp:ArrayCollection;
private function init() :void {
dp= new ArrayCollection ([
new ColumnRecord("First Name: ", "text", "John" ),
new ColumnRecord("Last Name: ", "text", "Smith" ),
new ColumnRecord("SSN#: ", "ssn", "123704523" ),
]);
}
private function switcher(data:Object = null) :*{
if (data == null) return new  Label();
switch(data.columnType) {
case "ssn":
var mi:MaskedTextInput = new MaskedTextInput();
mi.inputMask = "###-##-####";
return mi;
}
return new  TextInput();
}
]]>
</mx:Script>
</mx:Application>
The 
ColumnRecord
in the previous example is just a little DTO (see Example 2-24).
Example 2-24. ColumnRecord.as
package
{
public class ColumnRecord
Class Factory y | | 101
JPG to PNG Converter | Convert JPEG to PNG, Convert PNG to JPG
Open JPEG to PNG Converter first; Load JPG images from local folders in "File" in toolbar Windows Explorer; Select "Batch Conversion" & Choose "PNG" in "Output
convert pdf file into jpg format; convert .pdf to .jpg online
VB.NET Image: PDF to Image Converter, Convert Batch PDF Pages to
VB.NET > Convert PDF to Image. "This online guide content end users to convert PDF and PDF/A documents used commonly in daily life (like tiff, jpg, png, bitmap
convert pdf to jpg 100 dpi; convert pdf to 300 dpi jpg
{
public  var columnLabel:String;
public  var columnType:String;
public  var columnValue:*;
public function ColumnRecord(l:String, t:String, v:*) {
columnLabel=l;
columnType=t;
columnValue=v;
}
}
}
The ClassFactoryDemo application generates the view in Figure 2-7, which at first sight
looks like a form and a 
DataGrid
.
Figure 2-7. A DataGrid with dynamic item renderers
But this is a container with two 
DataGrid
objects pointing to the same data provider—
a simple array that contains both the data (
columnValue
) and the metadata (the label,
and the type of the data).
On the righthand side, it’s a regular 
<mx:DataGrid>
from the Flex framework.
On the left is your 50-line extension of the original data grid, 
<fx:DataGrid>
, which has
a small addition—it cures the limitation of 
<mx:DataGrid>
that reuses the same 
item
Renderer
for the entire column (its source code comes with this book).
Our goal was to create a class factory that would supply different item renderers based
on some criteria:
102 | | Chapter 2: Selected Design Patterns
itemRenderer="{new UIStaticClassFactory(function():*
return switcher(dg.rendererData)})}"/>
The left data grid gives the closure function to 
UIStaticClassFactory
, which calls an-
other function, 
switcher()
, which analyzes the metadata (the column type). If it’s sim-
ple text, it just renders it as a 
Label
, but if the type of the column is 
ssn
, it renders it as
MaskedTextInput
.
Please note that this class factory does not know in advance what to
build, as you don’t use static linkage here.
This example kills two birds with one stone. First, it shows a more advanced class
factory, and second, it illustrates how you can build dynamic forms having a
DataGrid
with dynamic data renderers under the hood.
In general, using components for item renderers and editors may be challenging. When
you use a renderer as an editor, you have at your disposal powerful control with a built-
in mask. In the earlier view, if a user decides to change the value of SSN#, he will be
restricted by the mask 
MaskedTextInput
.
Even though having many different item renderers may be a bit expensive from the
performance view, it brings you a lot of flexibility and a nicer-looking UI.
The authors of this book use item renderers as item editors and have a single point of
customization for controls.
Using class factories allows you to make grids that do not look like grids but rather like
dynamic forms. They can support runtime properties, styles, and other types of plug-
ins either via MXML or—even better—via well-structured ActionScript.
OK, this can’t all be that rosy, and there is a little issue—you can’t declare properties
needed for these custom renderer components on the 
DataGridColumn
tag. When you
write in MXML something like 
itemRenderer="MyClassFactory"
, there is no room for
you to specify properties of the renderer component. You have to use the
<mx:Component>
tag in order to “embed” them into a class.
Creating UIClassFactory
Using the class 
UIStaticClassFactory
with item renderers is a good idea, but let’s have
a little more fun with factories. This new demo application uses another version of class
factory first. The source code of the more advanced 
UIClassFactory
will follow.
This version of the factory shows you how you can create dynamic styles, properties,
and events in a declarative way. The demo application looks like Example 2-25.
Class Factory y | | 103
Example 2-25. ClassFactoryDemo2.mxml
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
xmlns:fx="http://www.faratasystems.com/2009/components"
layout="vertical" creationComplete="init()">
<mx:DataGrid horizontalScrollPolicy="auto" width="100%" id="dg"
editable="true" height="100%">
<mx:columns>
<mx:DataGridColumn dataField="DEPT_ID" editable="false"
<mx:DataGridColumn dataField="PHONE"  rendererIsEditor="true"
<mx:itemRenderer>
<fx:UIClassFactory>
<fx:generator>
{MaskedTextInput}
</fx:generator>
<fx:properties>
<mx:Object inputMask = "###-###-####" />
</fx:properties>
</fx:UIClassFactory>
</mx:itemRenderer>
</mx:DataGridColumn>
<mx:DataGridColumn dataField="STATUS" headerText="Status"
<mx:itemRenderer>
<fx:UIClassFactory>
<fx:generator>
{MaskedTextInput}
</fx:generator>
<fx:properties>
<mx:Object inputMask = "###-##-####" />
</fx:properties>
</fx:UIClassFactory>
</mx:itemRenderer>
</mx:DataGridColumn>
<mx:itemRenderer>
<fx:UIClassFactory>
<fx:generator>
{TextInput}
</fx:generator>
<fx:runtimeStyles>
<mx:Object
fontWeight="{function(d:*):String { return
</fx:runtimeStyles>
104 | | Chapter 2: Selected Design Patterns
</fx:UIClassFactory>
</mx:itemRenderer>
</mx:DataGridColumn>
<mx:DataGridColumn dataField="BENE_HEALTH_INS" editable="false"
<mx:itemRenderer>
<fx:UIClassFactory>
<fx:generator>
{CheckBox}
</fx:generator>
<fx:runtimeProperties>
<mx:Object
selected="{function(d:*):Boolean { return
</fx:runtimeProperties>
<fx:eventListeners>
<mx:Object
click="{function (e:MouseEvent): void {
trace('hello:'+e);
beneHealthClick(e);
}
}"/>
</fx:eventListeners>
</fx:UIClassFactory>
</mx:itemRenderer>
</mx:DataGridColumn>
</mx:columns>
</mx:DataGrid>
<mx:Script>
<![CDATA[
import mx.controls.Label;
import mx.collections.ArrayCollection;
import mx.controls.RadioButtonGroup;
import mx.controls.TextInput;
import com.farata.core.UIClassFactory;
import com.adobe.flex.extras.controls.MaskedTextInput;
import mx.controls.CheckBox;
private function init() :void {
var dp:Array = [
{EMP_ID:1,MANAGER_ID:200,EMP_FNAME:"John",
EMP_LNAME:"Smith",DEPT_ID:100,STREET:"10 Baker Str",
CITY:"New York",STATE:"NY",SALARY:25000,
ZIP_CODE:"10001",PHONE:"2125551111",STATUS:"A",
BENE_HEALTH_INS:"Y",SEX:"M"},
Class Factory y | | 105
{EMP_ID:2,MANAGER_ID:200,EMP_FNAME:"Jane",
EMP_LNAME:"Smith",DEPT_ID:100,STREET:"10 Baker Str",
CITY:"New York",STATE:"NY",SALARY:75000,
ZIP_CODE:"10001",PHONE:"2121115555",STATUS:"A",
BENE_HEALTH_INS:"N",SEX:"F"},
{EMP_ID:3,MANAGER_ID:200,EMP_FNAME:"Count",
EMP_LNAME:"Dracula",DEPT_ID:100,STREET:"10 Baker Str",
CITY:"New York",STATE:"NY",SALARY:175000,
ZIP_CODE:"10001",PHONE:"2121117777",STATUS:"A",
BENE_HEALTH_INS:"Y",SEX:"F"}
];
dg.dataProvider = dp;
}
private function beneHealthClick(e : MouseEvent ) : void {
}
]]>
</mx:Script>
</mx:Application>
If you run this application, you’ll see the window shown in Figure 2-8 with item ren-
derers assigning dynamic properties, styles, and event listeners (as this book is printed
in black, keep in mind that the actual background color of the salary in the first row is
red, and in the other two is green):
Here’s how simple and sweet it is:
<mx:itemRenderer>
<fx:UIClassFactory>
<fx:generator>
{MaskedTextInput}
</fx:generator>
<fx:properties>
<mx:Object inputMask = "###-###-####" />
</fx:properties>
</fx:UIClassFactory>
</mx:itemRenderer>
We declare that this item renderer will use the class factory that should build an instance
of 
MaskedTextInput
, and the 
inputMask
property of this class to be generated is 
“###-
###-####”
.
Now you can assign values to the properties of the instances-to-be of a class factory!
The next code snippet shows you how to dynamically change the 
fontWeight
styles and
background column depending on the value of the 
Salary
in each row:
<fx:runtimeStyles>
<mx:Object
fontWeight="{function(d:*):String { return
106 | | Chapter 2: Selected Design Patterns
Documents you may be interested
Documents you may be interested