best pdf viewer control for asp.net : Enable pdf thumbnails SDK application API .net windows html sharepoint QC2_yf_reviewed52-part973

You also get a LiveCycle ES Administration Console (partially shown in Figure 10-2).
The current version of the Console is an upgrade of the previous HTML-based one,
with a few minor patches coded in Flex. This chapter explains relevant parts of the
Administration Console with regards to importing the sample processes, custom com-
ponents, and advanced user management.
Creating Flex Applications Enabled for LiveCycle Workspace ES
This section explains how to develop Flex subapplications compliant with LiveCycle
Workspace ES. As mentioned, we call these applications Flexlets. The Workspace ac-
tivates Flexlets only when required to do so by the  human-centric process conditions,
which is why this chapter starts with describing the design of a sample process. For
information about configuring human-centric processes, see the LiveCycle Workbench
Help section at http://www.adobe.com/go/learn_lc_workbench and navigate to Creating
Processes → Designing Human-Centric Processes. Further reading on creating the Flex-
lets is available at http://help.adobe.com/en_US/livecycle/es/createflexapps.pdf.
Figure 10-10. The Components panel of the LiveCycle ES Workbench, with the installed
FarataSampleComponent
Creating Flex Applications Enabled for LiveCycle Workspace ES | 501
Enable pdf thumbnails - Draw thumbnail images for PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Thumbnail Generation with Various Options for Quick PDF Navigation
create pdf thumbnail; how to make a thumbnail of a pdf
Enable pdf thumbnails - 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
show pdf thumbnails; thumbnail pdf preview
Form Variable Declaration and Process Instantiation
When a human-centric process requires data entry from the participant, the workflow
software pops up a dialog window. In the case of LiveCycle ES, the dialog is a PDF form
or a Flexlet. From the programmer’s perspective, the outcome of the data entry is a
variable of the XML-based type 
Form
. A 
Form
variable carries the data and can, option-
ally, reference the SWF of the Flexlet that enables end users to pass the form data to
the Workspace. Do not forget that the Workspace passes similar form data to the Flexlet
to initialize it. In other words, the form data travels back and forth between the Flexlet
and the LiveCycle ES process, using the Workspace as a middleman. The Workspace
loads the Flexlet in two use cases:
• As part of interactive process instantiation: when a 
Form
variable pointing to the
SWF file has been declared in the LiveCycle Workbench as the input variable of
the entire process
• As part of the task execution: when a 
Form
variable pointing to the SWF file has
been mapped as input to the user activity (for example, the 
assignTask()
operation
of the 
UserService
service)
Figure 10-11. LiveCycle ES Workbench with the SimpleVacationRequest process diagram
502 | Chapter 10: Developing Flex Applications for LiveCycle ES (Enterprise Suite)
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Embedded page thumbnails. outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; 'create optimizing for Monochrome Image 'to enable dowmsampling for
can't view pdf thumbnails; pdf thumbnail creator
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Embedded page thumbnails. outputFilePath = Program.RootPath + "\\" 3_optimized.pdf"; // create optimizing Monochrome Image -- // to enable downsampling for
enable pdf thumbnails in; pdf reader thumbnails
Figure 10-12. Input Form variable requestData gets declared to force Workspace to interact with the
VacationRequest.swf Flexlet
When you assign a SWF URL to the 
Form
variable in the Workbench, the default setting
keeps the SWF file in the LiveCycle resources repository. Figure 10-12 shows the
requestData Form
variable declared within the LiveCycle Workbench. The variable is
defined as the input variable of the process, and its URL property points to the
VacationRequest.swf file, located under the Farata folder of the repository. Stepping
ahead, the data that this 
Form
variable carries through the process looks similar to the
following XML document:
<vacationRequest>
<requestId>8CE28354-E831-11E8-76EB-4DE38A29F087</requestId>
<decision>approved</decision>
<duration>7</duration>
<isEmployee>true</isEmployee>
<employeeName>Rye Woodard</employeeName>
</vacationRequest>
Once you declare a Flexlet-pointing 
Form
variable as a process input, you should also
add a 
TaskManager
endpoint, using the Administration Console. This enlists the
process for the end users of the Workspace. It also mandates the Workspace to pop up
the Flexlet prior to invoking the actual process instance. In this scenario, the Workspace
Creating Flex Applications Enabled for LiveCycle Workspace ES | 503
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
framework class. An advanced PDF editor enable C# users to edit PDF text, image and pages in Visual Studio .NET project. Support to
enable thumbnail preview for pdf files; program to create thumbnail from pdf
C# HTML5 PDF Viewer SDK deployment on IIS in .NET
and set the “Physical path” to the place where you store XDoc.PDF.HTML5 Viewer Demo. Pool Defaults…" in the right panel, and set the value "Enable 32-Bit
pdf thumbnail generator; how to make a thumbnail from pdf
will start displaying the SimpleVacationRequest process card. A click on that process
card will bring up the Flexlet initialized for the currently logged-in employee.
Flexlet Mapping for User Activity
An employee needs a Flexlet to start the process, and he, as well as the manager, needs
a Flexlet to review the request along the way. Accordingly, you can declare a 
Form
variable as input to the entire process, and you also can declare a 
Form
variable as an
input to the particular user activity (the 
UserService.assignTask()
operation).
Two activities in the process, the Manager’s Review and the Employee’s Review, map
a Flexlet-based 
Form
variable as an input form variable. In fact, both map the one and
only 
Form
variable of our process, the 
requestData
variable. Figure 10-13 shows the
input form variable mapping for the Manager’s Review activity. The initial user selected
for this activity is Alex Pink, who has to approve vacation requests (shown in
Figure 10-9).
Similar to how the process input variable of type 
Form
compels the Workspace to acti-
vate the Flexlet when the process instantiates, the mapping of the 
Form
variable as an
input to the particular user activity triggers the loading and activation of the Flexlet
when the user selects the task from the To Do list. In our scenario, Workspace will
bring up the Flexlet referenced by the 
Form
variable 
requestData
. Surprise: it’s the same
Flexlet assigned to start the process.
Controlling the View State of the Reusable Flexlet from the Process
Whether you base your process on many different Flexlets or reuse one .swf file is up
to you. We find the latter to be a convenient approach, because you can develop Flex
applications to accommodate different process participant roles through different view
states.
The process diagram has two 
SetValue.execute()
activities:
• Prepare a Manager’s Review
• Prepare an Employee’s Review
The value of the 
isEmployee
node of 
requestData
is set to a value of 
false
in Prepare
Manager’s Review and to 
true
in Prepare Employee’s Review. Internally, the code of
the Flexlet displays different views based on the value of the node. Figure 10-14 shows
the assignment of the 
isEmployee
node to Prepare Manager’s Review.
Workspace: Flexlet Conversation Basics
The conversation between the Flexlet and the Workspace that loaded it is entirely event-
based. The Workspace dispatches the following events:
504 | Chapter 10: Developing Flex Applications for LiveCycle ES (Enterprise Suite)
VB.NET PDF - VB.NET HTML5 PDF Viewer Deployment on IIS
and set the “Physical path” to the place where you store XDoc.PDF.HTML5 Viewer Demo. Pool Defaults…" in the right panel, and set the value "Enable 32-Bit
pdf thumbnails in; how to view pdf thumbnails in
C# PDF Page Rotate Library: rotate PDF page permanently in C#.net
Enable batch changing PDF page orientation without other PDF reader control. Support to overwrite PDF and save rotation changes to original PDF file.
print pdf thumbnails; show pdf thumbnails in
formInitialData
This event is being sent in response to the Flexlet signaling to the Workspace that
it has finished loading (see the 
formReady
event in the next list).
formSaveDataRequest
This event is sent when the user clicks Save.
formSubmitDataRequest
This event is sent when the user clicks Complete.
It is mandatory for the Flexlet to handle these events and dispatch the following ones
back to the Workspace:
Figure 10-13. The variable requestData gets mapped as the input Form variable for the Manager’s
Review
Creating Flex Applications Enabled for LiveCycle Workspace ES | 505
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
with XDoc.PDF SDK. Enable C#.NET Users to Create PDF OpenOffice Document (Odt, Ods, Odp) from PDF with .NET PDF Library in C# Class.
.pdf printing in thumbnail size; pdf files thumbnails
VB.NET PDF metadata library: add, remove, update PDF metadata in
VB.NET PDF - Read and Write PDF Metadata in VB.NET. Enable VB.NET Users to Read, Write, Edit, Delete and Update PDF Document Metadata in Visual Basic .NET.
show pdf thumbnail in; view pdf thumbnails
formReady
This event initiates the conversation between the Flexlet and the Workspace. Usu-
ally, it is dispatched as part of the 
creationComplete
handler in the Flexlet.
formSaveData
Using this event, the Flexlet responds to the 
formSaveDataRequest
event and speci-
fies the current state of the form data XML. The Workspace adds the form data to
the user’s To Do list, leaving the Flexlet active.
formSubmitDataInvalid
The Flexlet uses this event to indicate that the data entry is not complete. In return,
the Workspace keeps the Flexlet active.
formSubmitDataValid
This is the final event in the Workspace-Flexlet conversation. Using this event, the
Flexlet responds to 
formSaveDataRequest
and specifies the current state of the form
data XML. The Workspace unloads the Flexlet.
Figure 10-14. Value of isEmployee gets set to false before entering the Manager’s Review
Additionally, a Flexlet may dispatch optional events:
formClean
and 
formDirty
These events specify to the Workspace whether it should prompt the user to save
the form data if the user tries to close the Flexlet.
All of the event types listed are defined in the 
lc.core.events.FormEvents
class, which
is part of the workspace-runtime.swc library. Upon installing LiveCycle ES, you can find
506 | Chapter 10: Developing Flex Applications for LiveCycle ES (Enterprise Suite)
VB.NET PDF Text Extract Library: extract text content from PDF
Enable extracting PDF text to another PDF file, and other formats such as TXT and SVG form. OCR text from scanned PDF by working with XImage.OCR SDK.
pdf thumbnail fix; how to show pdf thumbnails in
C# PDF Text Extract Library: extract text content from PDF file in
Enable extracting PDF text to another PDF file, TXT and SVG formats. Support extracting OCR text from PDF by working with XImage.OCR SDK.
no pdf thumbnails in; enable pdf thumbnail preview
this class in your LiveCycle8.2 installation directory at …\LiveCycle_ES_SDK\misc
\Process_Management\Workspace.
LiveCycle FormConnector
The conversation between a Flexlet and the Workspace happens through a Flash
sharedEvents
object. As a reminder, 
sharedEvents
is an 
EventDispatcher
that is
accessible both by the loading and the loaded SWFs. The loaded application accesses
it as 
systemManager.loaderInfo.sharedEvents
The loading application gets access to the very same 
EventDispatcher
object either as
swfLoader.swfBridge
if the two .swf files belong to the different security sandboxes, or
as 
swfLoader.content.loaderInfo.sharedEvents
if both SWFs are hosted by the same
security sandbox.
Accordingly, the Workspace dispatches its events, such as 
formInitialData
and
formSubmitDataRequest
, to the 
sharedEvents
and listens, on the same object, for the
events 
formReady
and 
formSubmitData
coming from the Flexlet.
Sending  and  receiving 
FormEvents
is  greatly  simplified  by  a  helper  class,
lc.core.FormConnector
. This class, an instance of 
EventDispatcher
, is provided by the
same workspace-runtime.swc library that contains the definition of the Workspace-
Flexlet conversation events. In particular, in the 
creationComplete()
event handler,
FormConnector
translates events intercepted on 
sharedEvents
into ones dispatched on
itself (see Example 10-1).
Example 10-1. FormConnector intercepts events on sharedEvents and redispatches them to itself
public function creationComplete(event:Event):void {
dispatcher = UIComponent(event.target).systemManager.loaderInfo.sharedEvents;
dispatcher.addEventListener(FormEvents.FORM_INITIAL_DATA, dispatchEvent);
dispatcher.addEventListener(FormEvents.FORM_SAVE_DATA_REQUEST, dispatchEvent);
dispatcher.addEventListener(FormEvents.FORM_SUBMIT_DATA_REQUEST, dispatchEvent);
}
As a result, your Flexlet code does not have to listen directly to 
sharedEvents
. As long
as the Flexlet keeps an instance of the 
FormConnector
, it may instead listen to the
FormConnector
's events. Example 10-2 shows how you can do it.
Example 10-2. A Flexlet can utilize the FormConnector to listen to events dispatched by the Workspace
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"
xmlns:lc="http://www.adobe.com/2006/livecycle">
<lc:FormConnector id="formConnector"
formInitialData="onFormInitialData(event)"
formSaveDataRequest="onFormSaveDataRequest(event)"
formSubmitDataRequest="onFormSubmitDataRequest(event)"/>
. . .
</mx:Application>
Creating Flex Applications Enabled for LiveCycle Workspace ES | 507
To facilitate sending events to the Workspace, 
FormConnector
offers methods like
setSubmitData()
, which alleviates the need to explicitly dispatch the 
formSubmitData
event (Example 10-3).
Example 10-3. FormConnector wraps the data-sending event logic into a set of convenient methods
public function setSubmitData(data:XML):void {
trace("form: " + FormEvents.FORM_SUBMIT_DATA + " event dispatched to Workspace");
dispatcher.dispatchEvent(
new DataEvent(FormEvents.FORM_SUBMIT_DATA, false, false, data.toXMLString())
);
}
This  allows  a  Flexlet  to  use  calls  like 
formConnector.setSubmitData(data)
or
formConnector.setSubmitDataInvalid()
instead  of  dispatching the  corresponding
events to 
loaderInfo.sharedEvents
(Example 10-4).
Example 10-4. A Flexlet can use the FormConnector API to simplify sending data events to the
Workspace
private function onFormSubmitDataRequest(event:Event):void   {
if (isDataValid()) {
 .  .
formConnector.setSubmitData(xml);
} else {
formConnector.setSubmitDataInvalid();
}
}
Which data should you trust more: Enterprise data or LiveCycle internal data?
All human-centric processes in LiveCycle are created as long-lived processes. From the
persistence point of view, this means that LiveCycle stores all intermediate data that
needs to be passed between the operations of the process in its internal database (see
the documentation LiveCycle Workbench Help, Creating Processes 
Process concepts
Process execution).
The question is, “How much data really needs to touch the LiveCycle database?” or,
rather, “How much of it should never leave your business database in the first place?”
Let’s look at the SimpleVacationRequest process. Clearly, the start and end dates of the
approved vacation need to be stored in the business database. Example 10-5 presents
the 
CREATE TABLE
statement  that  describes  the  structure  of  the  corresponding
vacationrequest
table from the farata_livecycle_sampledb database.
Example 10-5. Definition of the vacationrequest table from farata_livecycle_sampledb (MySQL)
CREATE TABLE  vacationrequest (
Request_ID varchar(60) NOT NULL,
Description varchar(500) NULL,
Status varchar(30) NOT NULL,
Start_Date datetime NULL,
508 | Chapter 10: Developing Flex Applications for LiveCycle ES (Enterprise Suite)
End_Date datetime NULL,
Employee_ID varchar(100) default NOT NULL,
Employee_Name varchar(120) default NOT NULL,
Vacation_Type varchar(30) NOT NULL,
Decision tinyint(1) default NULL,
Decision_Made_At datetime default NULL,
Employee_Email varchar(100) default NULL,
Department varchar(100) default NULL,
PRIMARY KEY  (Request_ID)
)
Given the 
requestID
, all the table data can be accessed by the Flexlet, through, for
instance, remote calls to Java methods that access the database through a JDBC layer.
Seemingly, the only data that needs to be passed between the process and the Flexlet
is the following:
<vacationRequest>
<requestId>8CE28354-E831-11E8-76EB-4DE38A29F087</requestId>
<isEmployee>true</isEmployee>
</vacationRequest>
In this snippet, 
requestId
is the key to the database record and 
isEmployee
is a view
selector the Flexlet uses to present different UIs to the employee and the approving
manager.
The 
requestData
node has extra nodes: 
decision
employeeName
, and 
duration
, because
it’s not only about a Flexlet, it’s also about the process (see Example 10-6).
For instance, while creating the Task Instructions Template of the Manager’s Review
task, it was convenient to use all these nodes in the template expression.
The bottom line is this: although you should avoid carrying business data in your
process variables, exercise your own judgment.
Example 10-6. Form data XML of the requestData form variable
<vacationRequest>
<requestId>8CE28354-E831-11E8-76EB-4DE38A29F087</requestId>
<decision>approved</decision>
<duration>7</duration>
<isEmployee>true</isEmployee>
<employeeName>Rye Woodard</employeeName>
</vacationRequest>
Flexlet Code Walkthrough
Let’s examine the Flexlet’s namespaces and variables. After doing so, you will learn
how the Flexlet gets the incoming process data that it uses to read more data from the
enterprise data store. Finally, you will learn how the Flexlet writes the data to the
enterprise data store and follows up with submitting the output data back to the
process.
Creating Flex Applications Enabled for LiveCycle Workspace ES | 509
Namespaces and variables
In addition to the traditional http://www.adobe.com/2006/mxml, the Flexlet application
declares two extra namespaces (Example 10-7):
http://www.adobe.com/2006/livecycle
To allow reference of the 
FormConnector
helper from workspace-runtime.swc.
http://www.faratasystems.com/2008/components
To allow references to controls from the clear.swc component library made by
Farata  Systems.  Components  such  as 
DataCollection
DataForm
 and
DataFormItem
were described in Chapter 3.
Example 10-7. Namespaces of the SimpleVacationRequest.swf Flexlet
<mx:Application width="100%" height="100%" layout="absolute"
xmlns:mx="http://www.adobe.com/2006/mxml"
xmlns:lc="http://www.adobe.com/2006/livecycle"
xmlns:fx="http://www.faratasystems.com/2008/components"
creationComplete="onCreationComplete()"
>
As explained earlier, 
FormConnector
facilitates exchange of the data events with the
Workspace. In addition, our Flexlet conducts independent data exchange with the
farata_livecycle_sampledb database. This is done using the 
requestsCollection
varia-
ble, which is a 
DataCollection
object (see Chapter 3) capable of talking to the database
through its 
fill()
and 
sync()
methods, as shown in Example 10-8.
Example 10-8. DataCollection variable: requestsCollection encapsulates data exchange between the
Flexlet and the database
import com.theriabook.collections.DataCollection;
private var requestsCollection:DataCollection = new DataCollection();
 .  .
// Invoke remote method to retrieve the existing vacation request record
var token:AsyncToken = requestsCollection.fill(requestId);
 .  .
// Invoke remote method to the database with the current state of
// the vacation request
var token:AsyncToken = requestsCollection.sync();
The Flexlet also declares a bindable variable, 
vacationRequestDTO
, that is used as the
dataProvider
for the 
DataForm
(see Chapter 3). As a reminder, 
DataForm
provides the
same convenience in regards to binding as 
DataGrid
. As soon as the user modifies a
property of the 
vacationRequestDTO
, the corresponding input control is updated and
vice versa (Example 10-9).
510 | Chapter 10: Developing Flex Applications for LiveCycle ES (Enterprise Suite)
Documents you may be interested
Documents you may be interested