</fx:PortalCanvas>
<mx:Script>
<![CDATA[
import mx.managers.PopUpManager;PopUpManager;
import PortletInfo;PortletInfo;
]]>
</mx:Script>
</mx:Application>
A click on the Show Chart button loads Chart1 or Chart2 into a sibling domain and
flips the portlet’s content. Each portlet allows you to send messages to the portal, and
from the portal itself you can broadcast a text message to all active portlets, shown in
Figure 7-21.
Figure 7-21. SamplePortal
Integrating Flex into Legacy JEE Portals
If you are an owner of the legacy Web 1.0 portal, you can consider integrating Flex
applications into your portal space in an entirely different way.
Integrating Flex into Legacy JEE Portals | 381
Pdf thumbnail - Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
pdf preview thumbnail; pdf file thumbnail preview
Pdf thumbnail - VB.NET PDF Thumbnail Create SDK: Draw thumbnail images for PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
generate pdf thumbnail c#; show pdf thumbnail in html
The good news is that any Flex .swf file is valid content for a generic Flex portlet pre-
written by Adobe. Open the resources/wsrp/lib folder from the root of the installed
LiveCycle Data Services; you will find flex-portal.jar with flex.portal.GenericFlexPort-
let inside. Add the .jar to the class path of your web application (WebContent/lib) and
also copy the resources/wsrp/wsrp-jsp folder to the deployment root of your project
(WebContent).
Now take the portlet.xml of your legacy portal, and inject Example 7-47’s code to in-
stantly add the 
YahooFinancialNews
portlet.
Example 7-47. Registering a Flex application as a portlet via flex.portal.GenericFlexPortlet
<?xml version="1.0" encoding="UTF-8"?>
<portlet-app version="1.0"
xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
. . . .
<!-Descriptor of Flex portlet YahooFinancialNews -->
<portlet>
<portlet-name>YahooFinancialNews</portlet-name>
<portlet-class>flex.portal.GenericFlexPortlet</portlet-class>
<init-param><name>wsrp_folder</name><value>/Portal</value></init-param>
<supports>
<mime-type>text/html</mime-type>
<portlet-mode>view</portlet-mode>
</supports>
<portlet-info><title>Yahoo Financial News</title></portlet-info>
<portlet-preferences>
<preference>
<name>app_uri</name>
<value>/Portal/YahooFinancialNews</value>
</preference>
<preference>
<name>norm_width</name>
<value>400</value>
</preference>
<preference>
<name>norm_height</name>
<value>400</value>
</preference>
</portlet-preferences>
</portlet>
<portlet>
</portlet-app>
The preference 
app_uri
points to the URL of the YahooFinancialNews.swf, stripped of
the “.swf” and the parameter 
wsrp_folder
points to the parent URL of the wsrp-jsp.
That’s all it takes to have your Flex application running inside a Web 1.0 portal! Because
YahooFinancialNews
has been compiled to communicate with the 
MessageBroker
of the
Feeds web application, however, you do have to make sure that Feeds is deployed in
the same domain.
382 | Chapter 7: Modules, Libraries, Applications, and Portals
How to C#: Generate Thumbnail for Word
As you see, you are allowed to define and control the size of thumbnail. DOCXDocument pdf = new DOCXDocument(@"C:\1.docx"); BasePage page = pdf.GetPage(0
thumbnail pdf preview; create thumbnail jpeg from pdf
How to C#: Set Image Thumbnail in C#.NET
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB.NET Imaging, VB.NET OCR, VB How to C#: Set Image Thumbnail in C#.NET.
how to make a thumbnail of a pdf; enable pdf thumbnail preview
But don’t get carried away. First of all, you can’t flexibly control the real estate dedicated
to your portlet. Look at the rigid layout of Figure 7-22, which illustrates a BEA
WebLogic portal with the mixture of two instances of 
GenericFlexPortlet
(running
YahooFinancialNews
and 
GoogleFinancialNews
), 
SingleVideoPortlet
, and 
ShowTimePor
tet
(you can download the second two from Portlet Repository Downloads, at https://
portlet-repository.dev.java.net/public/Download.html). The Flex applications appear
squeezed and cumbersome to use.
Second, and even more important, mixing Web 2.0 portlets based on Flash or AJAX
with Web 1.0 ones (such as 
ShowTimePortlet
in the example) is outright dangerous, if
you consider that Flex applications and Web 2.0 portlets maintain state on the client,
but rerendering of the Web 1.0 ones eliminates the entire HTML page.
All in all, if you have several Flex portlets on a page, it may range from inconvenient to
impossible. As a result, the only way to integrate a Flex application in your legacy portal
may be to run a single application per page.
Figure 7-22. A Flex application’s ad portlets in a WebLogic Portal 10.2
Integrating Flex into Legacy JEE Portals | 383
How to C#: Generate Thumbnail for PowerPoint
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB.NET Imaging, VB.NET OCR, VB How to C#: Generate Thumbnail for PowerPoint
generate pdf thumbnails; pdf first page thumbnail
VB.NET Image: Program for Creating Thumbnail from Documents and
language. It empowers VB developers to create thumbnail from multiple document and image formats, such as PDF, TIFF, GIF, BMP, etc. It
pdf thumbnail preview; show pdf thumbnails
Summary
Understanding of how Flex loaders work, combined with the knowledge of different
ways of linking modules and libraries to your main application, is crucial for creation
of Flex portals. Even if you are not concerned with portals, the chances are high that
your application size will increase, and sooner or later you’ll need to decide how to cut
it into pieces. The sooner you start planning for modularizing your application, the
better.
384 | Chapter 7: Modules, Libraries, Applications, and Portals
How to C#: Generate Thumbnail for Raster
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel, VB.NET PowerPoint, VB.NET Tiff, VB.NET Imaging, VB.NET OCR, VB How to C#: Generate Thumbnail for Raster.
can't see pdf thumbnails; view pdf image thumbnail
Create Thumbnail in Web Image Viewer | Online Tutorials
or Images; Create Thumbnail; Generate Barcodes on Your Documents; Read Barcodes from Your Documents. Multi-page Tiff Processing; RasterEdge OCR Engine; PDF Reading
how to view pdf thumbnails in; cannot view pdf thumbnails in
CHAPTER 8
Performance Improvement: Selected
Topics
We have to stop optimizing for programmers and start
optimizing for users.
—Jeff Atwood
The greatest performance improvement of all is when a
system goes from not working to working.
—John Ousterhout
People consider your web application fast for one of two reasons: either it’s actually
fast or it gives an impression of being fast. Ideally, you should do your best to create
an RIA that is very responsive, but if you hit the ceiling imposed by a technology you’re
using, at least try to improve the perceived performance of the system. To draw an
analogy with weather reports, the temperature may be cool, but “feels like” freezing.
No matter how slow your RIA is, it should never feel like freezing.
In this chapter, you’ll learn how to use application preloaders to make the first page of
your RIA appear on the display as soon as possible while loading the rest of the appli-
cation in the background.
Once loaded on the user’s machine, your application should use its memory efficiently.
To help you identify trouble spots, we’ll discuss possible drains on performance, such
as memory leaks, garbage collectors, complex containers, event listeners, and closures.
For example, if your application experiences memory leaks, Flash Builder’s profiler
may help. With it, you can monitor the number of object instances to ensure that you
don’t have memory leaks. The monitoring of your application performance must be
done continuously from the start of your project.
In Chapter 7, you learned that cutting a monolithic application into modules, libraries,
and subapplications can substantially minimize the initial download time of an RIA.
In this chapter, we’ll build on that technique. Specifically, you’ll learn how you can use
385
Create Thumbnail Winforms | Online Tutorials
Create Thumbnail; Generate Barcodes on Your Documents; Read Barcodes from Your Documents. Multi-page Tiff Processing; RasterEdge OCR Engine; PDF Reading; Encode
pdf thumbnail html; pdf reader thumbnails
How to C#: Overview of Using XImage.Raster
Empower to navigate image(s) content quickly via thumbnail. Able to support text extract with OCR. You may edit the tiff document easily. Create Thumbnail.
view pdf thumbnails; pdf thumbnail creator
small Flash modules and link application libraries that are made with the same version
of the Flex SDK. You’ll also investigate the advantages of Resource Shared Libraries
(s), including how to use them with modules and how to optimize them.
Planning for Modularization
After deciding to use the module and library approach, carefully review all resources
besides the ActionScript or MXML code, namely images, sound, and movies (.swf files)
to decide whether you really need to embed them. The rule of thumb is that unless the
image must be displayed on the first page, it should not be embedded. It is almost never
worthwhile to embed any sizable sound or .swf in the Flex application, as they can use
streaming and provide much better control of the execution by starting to play when
just enough data is loaded.
Embedded images required in your RIA should be located in a separate
Flash Builder project and loaded as RSLs.
The next part is to separate stylesheets and skins into modules. Doing so offers three
advantages: first, it separates the work of the designers from the application developers.
Second, removing stylesheets and skins from the compilation process significantly re-
duces rebuild time during development, because the cost of resource transcoding (com-
pilation of fonts and styles) is high. Third, keeping skins and stylesheets outside of the
modules simplifies initialization and eliminates unnecessary reloading and reapplying
of CSS, thus making module initialization faster and safer.
Precompile CSS into a SWF file (right-click on the file to see this option) and then load
it from the main application using the 
StyleManager
class.
RSLs do introduce performance issues, however. They are loaded one by one and thus
impose a “round-trip” effect. Breaking a monolithic application into 10 RSLs results in
additional round-trip requests to the server and as a result slightly increases the initial
load time. A solution to this problem is to use smarter loading of multiple RSLs by
modifying the source code of the 
RSLListLoader
class available in the SDK and placing
it in your application (we’ll cover this later in this chapter). Special care has to be taken
in that case to ensure that framework libraries that other elements depend upon are
loaded first.
Another rule of thumb for large applications is to make the first page as light and free
of dependencies as possible. In other words, keep the first page super small. Once all
of the system and CSS RSLs are loaded and the application enters the preinitialize event,
you can start loading the rest of the application code. We recommend that you use the
portal approach discussed in Chapter 7 as a starting point for any large application, as
386 | Chapter 8: Performance Improvement: Selected Topics
it provides a clean break between applications. We’ll cover this topic in the section
“Optimizing RSL Loading” on page 417.
It Takes Two to Perform
Fast applications are your goal, but how do you get there? On one hand, the RIA de-
ployed on the server should consist of a number of relatively small .swf, .swc, and asset
files. On the other, ideally, the end users should use fast and reliable network connec-
tions. First, let’s define how fast your RIA should appear, and then we’ll look at how
quickly the data arrives to the user’s machine.
The major difference between an internal enterprise and a consumer-facing RIA is that
the former runs on fast and reliable networks with predictable speed and the latter runs
in a Wild West with unknown bandwidth. You have to set the proper expectations of
your RIA download speed from the very start. To do that you need an SLA.
SLA stands for Service Level Agreement, and the stakeholders of your project should
agree and sign off on an agreement that states the acceptable delivery speed of your
application and data. If your application will run on, say, a 15 Mbps intranet, the main
page of the application should appear in less than about 7 seconds. If yours is a con-
sumer-facing application, you can reasonably expect that the users have a network
connection with 1 Mbps bandwidth. To put yourself into their shoes, run special tests
emulating such a slow speed; for example, you could use the HTTP proxy and monitor
Charles (see the sidebar “Troubleshooting with Charles” on page 203 in Chapter 4) or
a hardware network emulator. To keep initial response time for the application, you
need to make sure that the initially downloadable portion of your application is smaller
than 1 MB.
After an enterprise application is downloaded, often it starts bringing some serious
amounts of data from the server. The data should arrive quickly, and safe and sound.
RIA applications are extremely susceptible to network problems. Even a small proba-
bility of lost or misdelivered packages becomes significant when multiplied by the sheer
number of the small data packages involved. Lost, duplicate, and reordered packages,
combined with high latency and low bandwidth, cause significant issues for applica-
tions fully tested only on reliable intranets and then released in the wild of unreliable
WAN communications.
The authors of this book use several Linux boxes (both virtual and
physical ones) to simulate WAN problems. The setup of a testing envi-
ronment can be tedious, and you might want to consider using a simple
portable appliance that will turn the simulation of a slow environment
into a trivial task. One of such portable, inexpensive, and easy-to-use
network simulators is called Mini Maxwell.
It Takes Two to Perform | 387
Purposely increasing (with software or hardware) the simulated latency up to a realistic
200 ms and the package loss to an unrealistic 10 percent will quickly expose the prob-
lems in error-handling code. It will also give you quick feel for robustness of the code.
Then you should check to see whether duplicate or out-of-sequence packages affect
your application as described in Chapter 5.
While consulting one of our customers, a foreign exchange trading company, we had
to enhance the endpoints in the RTMP protocols to ensure that out-of-sequence mes-
sages and network congestions were dealt with properly. But the remedies depend on
the communication protocols used by RIA.
Obviously, with SOAP web services and similar high-level protocols, you have very
loosely bound communications, making implementation of a QoS layer impossible. As
the number of simultaneous 
HTTPRequest
s per domain is limited by the web browsers,
the latency can cause performance slowdown and timeouts. Missing communication
packages escalate the connection-starving issue even further.
LCDS 3.0 introduced QoS improvements at the protocol level. To learn
more, get familiar with new parameters in the Data Management con-
figuration files.
If you use one of the AMF implementations for data-intensive applications, they will
perform a lot faster (the .swf arrival time remains the same). With AMF, the latency is
less of a problem, as Flex would automatically batch server requests together. Imple-
menting symmetrical checkpoints on both client and server endpoints allows the pro-
cessing of lost and duplicate packages. The lost packages remain a problem, as they
cause request timeouts.
Robustness of an RIA improves if you move from HTTP/SOAP/REST to either RTMP
or BlazeDS long-polling connected protocols. Keeping open connections and two-way
sockets is ideal for high performance and reliable protocols. Comparing these to
HTTPRequest
s is like comparing a highway with multiple lanes going in each direction
to a single-lane dirt road.
More and more enterprise applications are built using always-connected protocols for
tasks ranging from regular RPC to modules loading implementing streaming (the same
thing as movie streaming). As these protocols evolve, you’ll see more open source
products that provide transparent implementations using a mixture of protocols.
Meanwhile, we can mix protocols using such Flex techniques as configuring the fall-
back channels.
388 | Chapter 8: Performance Improvement: Selected Topics
Application Startup and Preloaders
Perceived performance is as important as actual performance. While a large Flex ap-
plication loads, users may experience unpleasant delays. Rather than frustrate them
with inactivity, give the users something productive to work on. This can be a main
window of your application or just a logon view. The point is that this very first view
should be extremely lightweight and arrive on the user’s machine even before the Flex
frameworks and the rest of the application code starts downloading. Giving users the
ability to start working quickly with partially loaded code gives a perception that your
application loads faster.
In this section, you’ll learn how to create and load a rapidly arriving logon screen to
keep the user occupied immediately. Here are the four challenges you face:
• The logon screen has to be very lightweight. It must be under 50 Kb, so using classes
from the Flex framework is out of the question.
• The application shouldn’t be able to remove the logon window upon load, as the
user must log in first.
• If the user completes logging in before the application finishes its load, the standard
progress bar has to appear.
• The application should be able to reuse the same lightweight logon window if the
user decides to log out at any time during the session.
What Happens in Flash Player Before the Flex Application Is Loaded
The 
SystemManager
is a main manager that controls the application window; creates
and parents the 
Application
instance, pop ups, and cursors; manages the classes in the
ApplicationDomain
container (see the Flex language reference at http://livedocs.adobe
.com/flex/gumbo/langref/), and more. The 
SystemManager
is the first class that is instan-
tiated by Flash Player in the first frame of your application (modules and subapplica-
tions have their own 
SystemManager
classes). 
SystemManger
is responsible for loading all
RSL libraries, which will be discussed later in this chapter.
Hanging off of a 
stage
object, 
SystemManger
stores the size and position of the main
application window, and keeps track of its children, such as floating pop ups and modal
windows. Using the 
SystemManager
, you can access embedded fonts, styles, and the
document object. 
SystemManager
also controls application domains, which are used to
partition classes by security domains.
If you’re developing custom visual components (descendants of the 
UIComponent
class),
keep in mind that initially such components are not connected to any display list and
the 
SystemManager=null
. Only after the first call of 
addChild()
is 
SystemManager
assigned
to them. You should not access 
SystemManager
from the constructor of your component,
because at this point in time it can still be 
null
.
In general, when the 
Application
object is created, the process is:
Application Startup and Preloaders | 389
1. The 
Application
object instantiates.
2. Its property 
Application.systemManager
initializes.
3. The 
Application
dispatches the 
FlexEvent.PREINITIALIZE
event at the beginning
of the initialization process.
4. Flash Player calls the method 
createChildren()
on the 
Application
. At this point,
each of the 
application
’s components is constructed, and each component’s
createChildren()
is also called.
5. The 
Application
dispatches the 
FlexEvent.INITIALIZE
event, which indicates that
all of the application’s components have been initialized.
6. Flash Player dispatches 
FlexEvent.CREATION_COMPLETE
.
7. Flash Player adds the 
Application
object to the display list, and the 
Preloader
object gets removed.
8. Flash Player dispatches the 
FlexEvent.APPLICATION_COMPLETE
event.
In  most cases, you should use  the MXML tag 
<mx:Application>
to create the
Application
object, but if you need to write it in ActionScript, do not create components
in the constructor. Instead, override 
createChildren()
, which is a bit more efficient.
As opposed to Flash movies that consist of multiple frames being displayed over a
timeline, Flex .swf files utilize only two frames.  The 
SystemManager
Preloader
,
DownloadProgressBar
, and a handful of other helper classes live in the first frame. The
rest of the Flex framework, your application code, and embedded assets like fonts and
images reside in the second frame.
When Flash Player initially starts downloading your .swf, as soon as enough bytes come
for the first frame, it instantiates a 
SystemManager
, which creates an instance of the
Preloader
, which is monitoring the process of the application download and initiali-
zation and in turn creates a 
DownloadProgressBar
.
When  all  bytes  for  the  first  frame  are  in, 
SystemManager
sends  the
FlexEvent.ENTER_FRAME
for the second frame, and then renders other events.
Dissecting LightweightPreloader.swf
The sample application that will demonstrate how these challenges are resolved is lo-
cated in the Eclipse Dynamic Web Project and is called lightweight-preloader. This
application is deployed under the server. Note that the interactive login window (Fig-
ure 8-1) arrives from the server very fast, even though the large application .swf file
continues downloading, and this process may or may not be complete by the time the
user enters her credentials and clicks the Login button.
This view was created in Photoshop and then saved as an image. Figure 8-2 depicts the
directory structure of the Flash Builder project lightweight-preloader. In particular, the
assets directory has the image file logon.psd created in Photoshop and saved as a lighter
logon.png. At this point, any Flash developer can open this file in Flash Professional
390 | Chapter 8: Performance Improvement: Selected Topics
Documents you may be interested
Documents you may be interested