c# convert pdf to image ghostscript : Convert password protected pdf to word online SDK software API .net winforms windows sharepoint e2296131-part809

Flexfields    20-9
For many applications, you would have one combinations form that maintains the key 
flexfield, where the key flexfield is the representation of an entity in your application. 
Then, you would also have one or more forms with foreign key references to the same 
key flexfield. For example, in an Order Entry/Inventory application, you might have a 
combinations form where you define new parts with a key flexfield for the part 
numbers. You would also have a form with foreign key reference where you enter 
orders for parts, using the key flexfield to indicate what parts make up the order. 
Further, you can have another form, a form with a key flexfield range, that you use to 
manipulate ranges of your part numbers. This range flexfield form refers to the same 
key flexfield as both your combinations forms and your foreign key forms, though the 
ranges of segment values (a low value and a high value for each segment) are stored in 
the special range flexfield table that serves as the range form's base table. 
Key Flexfield Range 
A special kind of key flexfield you can include in your application to support low and 
high values for each key segment rather than just single values. Ordinarily, a key 
flexfield range appears on your form as two adjacent flexfields, where the leftmost 
flexfield contains the low values for a range, and the rightmost flexfield contains the 
high values. 
In Oracle Application Object Library, we use a key flexfield range to help you specify 
cross-validation rules for valid combinations. 
Defining Key Flexfield Database Columns 
For each key flexfield you design into your application, you must create a combinations 
table to store the flexfield combinations that your users enter. You can build a special 
form to let them define valid combinations (the combinations form), or you can let 
Oracle Application Object Library dynamically create the combinations when users 
attempt to use a new one (from a form with a foreign key reference). You must have the 
combinations table even if you do not build a combinations form to maintain it. Key 
flexfields provided by Oracle E-Business Suite already have combinations tables 
defined. 
In addition to the combinations table for your key flexfield, you may also have one or 
more tables for forms with foreign key references and for forms with key flexfield 
ranges. 
Combinations table 
Key flexfields support a maximum of 70 segment columns in a combinations table. For 
example, a combinations table includes a column for the unique ID that your key 
flexfield assigns to each valid combination. It also includes a structure defining column, 
in case your end user wants to define multiple structures. If you want to use segment 
qualifiers in your application, your table should include a derived column for each 
segment qualifier you define. 
Convert password protected pdf to word online - C# PDF Password Library: add, remove, edit PDF file password in C#.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
break pdf password; pdf user password
Convert password protected pdf to word online - VB.NET PDF Password Library: add, remove, edit PDF file password in vb.net, ASP.NET, MVC, WinForms, WPF
Help to Improve the Security of Your PDF Document by Setting Password
add password to pdf reader; pdf password protect
20-10    Oracle E-Business Suite Developer's Guide
To create a key flexfield combinations table for your application entity, you must: 
Define an ID column to uniquely identify a row in your database table (type 
NUMBER, length 38, NOT NULL). You should name this column XXX_ID, where 
XXX is the name of your entity (for example, PART_ID). This column holds the 
unique ID number of a particular combination of segment values (also known as a 
code combination). The unique ID number is also known as a code combination ID, 
or CCID. Note that even though this column is a NUMBER(38) column, Oracle 
Application Object Library only supports code combination IDs up to two billion 
(2,000,000,000). 
Define a column for each key segment, SEGMENT1 through SEGMENTn, where n 
is the number of segments you want for your key flexfield (type VARCHAR2, 
length 1 to 60, all columns the same length, NULL ALLOWED). As a rule of thumb, 
you should create about twice as many segment columns as you think your users 
might ever need for a single key flexfield structure. The maximum number of key 
flexfield segment columns that Oracle Application Object Library supports in a 
combinations table is 70. However, for a combinations table that you want to use 
with a form with a foreign key reference, the number of segments is also limited by 
the maximum size of the field that holds the concatenated segment values and 
segment separators. That field is normally 2000 characters, so if you have 40 
segments and 40 separators, each segment could only have an average width of 
about 49 characters. Having more segment columns than you need does not 
significantly impact either space requirements or performance. In fact, since you 
cannot add more segment columns to a flexfield combinations table once you have 
registered your flexfield, you should add at least a few "extra" segment columns to 
your combinations table initially to allow for future needs. 
Define SUMMARY_FLAG and ENABLED_FLAG (type VARCHAR2, length 1, NOT
NULL). 
Define START_DATE_ACTIVE and END_DATE_ACTIVE (type DATE, NULL). 
Define a structure defining column (structure ID column) to allow multiple 
structures (type NUMBER, length 38, NOT NULL). You should name this column 
XXX_STRUCTURE_ID, where XXX is the name of your entity (for example, 
PART_STRUCTURE_ID). This column is optional but strongly recommended. 
Define a unique index on the unique ID column. 
Create an ORACLE sequence for your column with the same grants and synonyms 
as your combinations table (for insert privileges). Name your sequence 
YOUR_TABLE_NAME_S. 
Define the Who columns, LAST_UPDATE_DATE (type DATE, NOT NULL) and 
LAST_UPDATED_BY (type NUMBER, length 15, NOT NULL). All other Who 
columns should have NULL ALLOWED. 
VB.NET PDF Convert to Word SDK: Convert PDF to Word library in vb.
Convert PDF document to DOC and DOCX formats in Visual Basic .NET Create editable Word file online without email. Supports transfer from password protected PDF.
add password to pdf file without acrobat; pdf password remover
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Convert PDF to multiple MS Word formats such as .doc and .docx. Create editable Word file online without email. Password protected PDF file can be printed to
pdf password recovery; add copy protection pdf
Flexfields    20-11
If you want your application to allow dynamic insertion of new valid combinations 
from a form with a foreign key reference, you must not include any mandatory 
application-specific columns in your combinations table. Your combinations table 
contains only the columns you need to define a key flexfield, such as unique ID, 
structure defining, and segment columns. It can, however, include non-mandatory 
application-specific columns and columns for derived segment qualifier values. If you 
include mandatory application-specific columns in your combinations table, you cannot
allow dynamic insertion of new valid combinations from a form with a foreign key 
reference. If your table does not allow dynamic insertion, you must create a 
combinations form, based on your combinations table, for your users to create their 
valid combinations. 
If you do not ever want to allow dynamic insertion of new valid combinations, you 
should develop a single form that allows your end user to directly display, enter, or 
maintain valid combinations in your combinations table (a combinations form). You can
set up your key flexfield to not allow dynamic inserts (on a structure-by-structure basis)
even if dynamic inserts are possible.
Warning: You should never insert records into a code combinations 
table through any mechanism other than Oracle Application Object 
Library flexfield routines. Doing so could lead to serious data 
corruption problems and compromise your applications. 
Table with a foreign key reference 
For each table you use as a base table for a form with a foreign key reference (to a 
combinations table's unique ID column), define one database column with the same 
name as the unique ID column in the corresponding combinations table (type 
NUMBER, length 38, and NULL or NOT NULL depending on your application's 
needs). 
If you have a structure column in your combinations table, you also need to include a 
structure column in your foreign key table (with a corresponding form field), or provide
some other method for passing the structure ID number to the NUM parameter in your 
calls to key flexfield routines. For example, you could store the structure number in a 
profile option and use the option value in the NUM parameter. 
You do not need any SEGMENTn columns or other key flexfield columns for this type 
of table. 
Table for a form with a key flexfield range 
To create a table that supports a key flexfield range instead of a foreign key reference to 
a single combination, define SEGMENTn_LOW and SEGMENTn_HIGH columns, one 
pair for each SEGMENTn column in your combinations table (type VARCHAR2, length
1 to 60, all columns the same length, NULL). 
If you have a structure column in your combinations table, you also need to include a 
C# PDF Convert to Jpeg SDK: Convert PDF to JPEG images in C#.net
NET library to batch convert PDF files to jpg image files. Thumbnails can be created from PDF pages. Password protected PDF document can be converted and changed.
copy protecting pdf files; pdf password encryption
VB.NET PDF Convert to Jpeg SDK: Convert PDF to JPEG images in vb.
VB.NET How-to, VB.NET PDF, VB.NET Word, VB.NET Excel Online VB.NET Tutorial for PDF to JPEG (JPG) Conversion in VB Able to convert password protected PDF document
password protected pdf; pdf passwords
20-12    Oracle E-Business Suite Developer's Guide
structure column in your range table (with a corresponding form field), or provide 
some other method for passing the structure ID number to the NUM parameter in your 
calls to key flexfield routines. For example, you could store the structure number in a 
profile option and use the option value in the NUM parameter. 
You do not need any other flexfield columns for this table. 
Registering Your Key Flexfield Table
After you create your combinations table, you must register your table with Oracle 
Application Object Library using the Table Registration API. 
Registering Your Key Flexfield 
Once your table is successfully registered, you register your key flexfield with Oracle 
Application Object Library. You register your key flexfield using the Key Flexfields 
window. 
When you register a key flexfield, you identify the combinations table in which it 
resides, as well as the names of the unique ID and structure defining columns. Key 
flexfields provided by Oracle E-Business Suite are already registered.
Defining Qualifiers for Key Flexfields 
When you register a key flexfield, you can define flexfield and segment qualifiers for it. 
You should define flexfield qualifiers if you want to ensure your end user customizes 
your key flexfield to include segments your application needs. For example, Oracle 
General Ledger defines account and balancing flexfield qualifiers in the Accounting 
Flexfield to ensure that end users would define account and balancing segments. 
You should define segment qualifiers if your application needs to know semantic 
characteristics of key segment values your end user enters. You assign one or more 
segment qualifiers to each flexfield qualifier. For example, Oracle General Ledger 
assigns a segment qualifier of "account type" to the flexfield qualifier "account" in the 
Accounting Flexfield. As a result, end users can define account value 1000 to mean 
"Cash," and assign it a segment qualifier value of "Asset." 
Note that flexfield qualifiers can be unique or global, and required or not. You describe a 
flexfield qualifier as unique if you want your end user to tie it to one segment only. You 
describe a flexfield qualifier as global if you want it to apply to all segments. You can 
use a global flexfield qualifier as a convenient means for assigning a standard set of 
segment qualifiers to each of your flexfield's segments. You describe a flexfield qualifier
as required if you want your end user to tie it to at least one segment. 
In Oracle General Ledger's Accounting Flexfield, the "Account" flexfield qualifier is 
required and unique because Oracle General Ledger requires one and only one account 
segment. Oracle General Ledger defines a flexfield qualifier as "global" so the segment 
qualifiers "detailed posting allowed" and "detailed budgeting allowed" apply to each 
Accounting Flexfield segment. For more information, see: Oracle General Ledger User's 
Online Convert PDF file to Word. Best free online PDF Conversion
Online PDF to Word Converter. Download Free Trial. Convert a PDF File to Word. Just upload your file by clicking on the blue button
annotate protected pdf; adding password to pdf
Online Convert Word to PDF file. Best free online export docx, doc
Online Word to PDF Converter. Download Free Trial. Convert a Word File to PDF. Just upload your file by clicking on the blue button
a pdf password online; password pdf
Flexfields    20-13
Guide, Oracle E-Business Suite Flexfields Guide.
Derived Column 
A column you include in a combinations table into which your flexfield derives a 
segment qualifier value. You specify the name of a derived column when you define a 
segment qualifier. 
Add Your Flexfield to Your Forms
Once you have the appropriate table columns and your flexfield is registered, you can 
build your flexfield into your application forms.
Implementing Descriptive Flexfields 
You add a descriptive flexfield to provide customizable "expansion space" for your 
entity. For example, suppose you have a retail application that keeps track of customer 
entities. Your entity table, CUSTOMERS, would normally include columns such as 
Name, Address, State, Sex, Customer Number, and so on. However, your table might 
not include extra columns to keep track of a customer's size and color preferences, or 
regular salesperson, since these are attributes of the customer entity that depend on 
how your users use your application. In fact, your users might later identify even more 
customer attributes that they want to keep track of. You add descriptive flexfield 
columns to your entity table (CUSTOMERS) so that your users have the desired 
expansion space. Your users can also take advantage of the fact that descriptive 
flexfields can be context sensitive, where the information your application stores 
depends on other values your users enter in the Customers form. 
To implement a descriptive flexfield you must: 
Define descriptive flexfield columns in your database 
Register your table with Oracle Application Object Library 
Register your descriptive flexfield with Oracle Application Object Library 
Create descriptive flexfield fields in your forms 
Add descriptive flexfield routines to your forms
Planning for Reference Fields
Reference fields are fields from which a descriptive flexfield can get a context field 
value (optional, but recommended). Reference fields must be separate fields from the 
structure defining field (typically ATTRIBUTE_CATEGORY). Frequently, most of the 
existing (non-flexfield) fields in your form can also serve as reference fields. In general, 
Online Convert PDF file to Word. Best free online PDF Conversion
Online Tiff to PDF Converter. Download Free Trial. Convert a Tiff/Tif File to PDF. Just upload your file by clicking on the blue button
a pdf password; change password on pdf file
C# PDF: C#.NET PDF Document Merging & Splitting Control SDK
SDK > C# > Merge and Split Document(s). "This online guide content PDF document merging & splitting toolkit SDK to split password-protected PDF document using
add password to pdf preview; adding a password to a pdf file
20-14    Oracle E-Business Suite Developer's Guide
fields that make good reference fields are those that have a short, fairly static list of 
possible values. You specify fields as reference fields when you register your 
descriptive flexfield in the Register Descriptive Flexfield form. Your users then have the 
option of using a reference field or not when they set up your flexfield.
For example, suppose you have a retail application that keeps track of "customer" 
entities. Your Customers form would normally include fields such as Name, Address, 
State, Sex, Customer Number, and so on. Your end users may want to make the 
descriptive flexfield context-sensitive depending on what a user enters in the State field 
(if the state is Colorado, for example, you may want to keep track of customer 
preferences in ski-wear, while if the state is Florida, you may want to keep track of 
preferences in warm-weather-wear). Alternatively, your end users may want to make 
the descriptive flexfield context-sensitive depending on what a user enters in the Sex 
field (if the customer is female, for example, you may want to keep track of her size 
preferences using standard women's sizes, while if the customer is male, you may want 
to keep track of size preferences using standard men's sizes). By specifying both the 
State field and the Sex field as reference fields when you register your descriptive 
flexfield in the Register Descriptive Flexfield form, you give your users the option to set 
up the flexfield either way. 
Tip: A descriptive flexfield can use only one form field as a reference 
field. You may derive the context field value for a descriptive flexfield 
based on more than one field by concatenating values in multiple fields 
into one form field and using this concatenated form field as the 
reference field. 
Defining Descriptive Flexfield Database Columns 
To make your application very flexible, you should add descriptive flexfield columns to
all of your entity tables. 
Oracle Application Object Library reserves table names that contain the string "_SRS_" 
for the Standard Request Submission feature, so you should not give your descriptive 
flexfield table a name that includes this string. 
To add descriptive flexfield columns into your database table, you: 
Define a column for each descriptive segment, ATTRIBUTE1 through ATTRIBUTEn
(type VARCHAR2, length 1 to 150, all columns the same length, NULL 
ALLOWED). In addition to VARCHAR2 columns, number and date columns are 
supported.
Define a structure defining column (context column) to identify your descriptive 
flexfield structures (type VARCHAR2, length 30, NULL ALLOWED). Although you
can name this column anything you wish, we recommend that you name it 
ATTRIBUTE_CATEGORY. 
You should ensure you initially add enough segment columns to cover any future uses 
Flexfields    20-15
for your descriptive flexfield, since you cannot add extra segment columns to your 
flexfield later. 
You determine the maximum number of segments you can have within a single 
structure when you define your ATTRIBUTEn columns in your table. You can define a 
maximum of 200 ATTRIBUTEn columns in one table. As a rule of thumb, you should 
create about twice as many segment columns as you think your users might ever need 
for a single descriptive flexfield structure. 
Adding a Descriptive Flexfield to a Table with Existing Data 
You can add flexfield columns to a table that has never had any flexfield columns but 
already contains data. However, you must be very careful not to create data 
inconsistencies in your application when you do so. To add your flexfield, you add 
columns, form fields, and invoke descriptive flexfield routines exactly the same as if 
you were creating a descriptive flexfield from the beginning. However, when you 
define your flexfield using the Descriptive Flexfield Segments form, you must consider 
whether any of the segments should use value sets that require values. If none of your 
new segments requires a value, your users will simply see an empty descriptive 
flexfield when they query up existing records. For this case, no further action is 
necessary. 
For the case where one or more of your segments require values, you need to perform 
extra steps to prevent data inconsistencies. The simplest way to do this is to define your 
segment structures completely, navigate to your form with the new descriptive 
flexfield, query up each record in your table, and enter values in the descriptive 
flexfield for each record. Save your changes for each record. This method, while tedious,
ensures that all values go into the correct columns in your entity table, including the 
structure defining (context) column. 
For very large tables, you can add the values to your table directly using SQL*Plus. You
need to update each row in your table to include a context field value (the structure 
defining column) as well as segment values, so you must first determine the 
segment/column correspondences for your structures. Your context (structure) values 
must exactly match your context field values in the Descriptive Flexfield Segments 
form. For example, if your context field value is mixed case, what you put in the 
structure column must match the mixed case. If you put an invalid context value into 
the structure column, a purely context-sensitive flexfield does not pop up at all for that 
record. If you have global segments enabled, the flexfield window will open. If 
Override Allowed is set to Yes, you will see the bad context field value in the context 
field of the window. 
Note that you should never use SQL*Plus to modify data in Oracle Application Object 
Library tables. 
Protected Descriptive Flexfields
In some cases, you may want to create a descriptive flexfield that cannot be 
20-16    Oracle E-Business Suite Developer's Guide
inadvertently changed by an installer or user. This type of flexfield is called a protected 
descriptive flexfield. You build a protected descriptive flexfield the same way you build
a normal descriptive flexfield. The main difference is that you check the Protected check
box in the Descriptive Flexfields form after defining your segment structures. Once a 
descriptive flexfield is protected, you cannot query or change its definition using the 
Descriptive Flexfield Segments form. You should define your descriptive flexfield 
segments before you check the Protected check box in the Descriptive Flexfields form.
In a case where your database table already includes a descriptive flexfield, you need to 
define segment columns that have names other than ATTRIBUTEn. For special purpose 
flexfields such as protected descriptive flexfields, you can name your columns anything 
you want. You explicitly enable these columns as descriptive flexfield segment columns
when you register your descriptive flexfield. Note that you must also create a 
structure-defining column for your second flexfield. Flexfields cannot share a structure 
column.
If your database table contains segment columns with names other than ATTRIBUTEn, 
you create hidden fields corresponding to those columns instead.
Registering Your Descriptive Flexfield Table 
After you add descriptive flexfield columns to your table, you must register your table 
with Oracle Application Object Library using the Table Registration API. 
See: Table Registration API, page 9-11.
Registering Your Descriptive Flexfield 
You must register your descriptive flexfield with Oracle Application Object Library. 
You register your descriptive flexfield using the Register Descriptive Flexfield form. 
When you register a descriptive flexfield, you identify the application table in which it 
resides and the name of the structure defining column. If you have created reference 
fields in your form, you should enter their names as "context fields" when you register 
your flexfield. 
Add Your Flexfield to Your Forms
Once you have the appropriate table columns and your flexfield is registered, you can 
build your flexfield into your application forms.
Adding Flexfields to Your Forms
There are four basic parts to calling a flexfield from an Oracle Forms window. These 
steps assume that your flexfield is already registered and defined in Oracle Application 
Object Library and that the flexfield table and columns already exist. These steps apply 
to both key and descriptive flexfields.
Flexfields    20-17
To code a flexfield into your form:
Create your hidden fields
Create your displayed fields
Create your flexfield definition
Invoke your flexfield definition from several event triggers
Create Your Hidden Fields
In general, you create your hidden flexfield fields as part of creating your default form 
block from the database table (or view). Set the canvas property of the flexfield fields to 
null (so they do not appear on a canvas). 
Your hidden ID (for key flexfields only), structure field, and segment or attribute fields 
must be text items on the null canvas. Note that these must be text items rather than 
display items, and that they should use the TEXT_ITEM property class. Set the field 
query lengths to 255 for most fields, with a query length of 2000 for hidden ID fields.
Important: You should never create logic that writes values to the 
hidden fields directly. Since the flexfield keeps track of whether a 
record is being inserted, updated, etc., putting values in these fields by 
any method other than the flexfield itself (or a query from the database)
may cause errors and data corruption.
In some foreign key forms for key flexfields, you may need to create extra non-database 
fields that represent the segment columns (SEGMENT1 through SEGMENTn) in your 
combinations table. Put your SEGMENT1 through SEGMENTn fields on the null canvas
(field length the same as your SEGMENTn columns). These fields help Oracle 
Application Object Library to create new code combinations from your form with a 
foreign key reference (using dynamic insertion). 
Normally, Oracle Application Object Library can create new code combinations 
(dynamic insertion) from your form with a foreign key reference using only the 
concatenated segment values field. However, if you expect the concatenated length of 
your flexfield to be defined to be larger than 2000 (the sum of the defined segments' 
value set maximum sizes plus segment separators), then you should create these 
non-database fields to support the dynamic creation of new combinations from your 
form. 
If you do not have these fields and your users define a long flexfield (> 2000 characters), 
your users can experience truncation of key flexfield data when trying to create new 
combinations. 
If your key flexfield is registered with Dynamic Inserts Feasible set to No, you do not 
need to add these fields, though they are recommended. If you do not create these 
20-18    Oracle E-Business Suite Developer's Guide
fields, and your users define a long flexfield, your users may see empty flexfield 
segments upon entering the flexfield pop-up window after a query. These blank 
segments do not adversely affect the underlying data, nor do they adversely affect 
flexfield changes if your user updates those segments after querying. 
If you use these fields and you have more than one key flexfield in the same row (in a 
block) of your form, you should also create one extra set of non-database segment fields
per flexfield. So, if you have three foreign-key-reference flexfields in your block, you 
should have four sets of segment fields (for example, SEGMENT1 to SEGMENTn as the 
main set; and SEGMENT1_A to SEGMENTn_A, SEGMENT1_B to SEGMENTn_B, and 
SEGMENT1_C to SEGMENTn_C as the extra sets). In addition, you should use the 
USEDBFLDS="Y" argument for your flexfield definition routine calls. When you do so, 
you must write trigger logic to explicitly copy the appropriate values into or out of 
these fields before your flexfield routine calls. You must copy your values into the main 
set from the appropriate extra set before the WHEN-NEW-ITEM-INSTANCE and the 
PRE-INSERT and PRE-UPDATE flexfield event calls. You must copy your values out of 
the main set into the appropriate extra set after the POST-QUERY, 
WHEN-NEW-ITEM-INSTANCE, WHEN-VALIDATE-ITEM, PRE-INSERT, or 
PRE-UPDATE calls. 
For a descriptive flexfield, it is possible (though not recommended) to create your form 
such that the table containing the descriptive flexfield columns is not the base table (or 
included in the base view) of the form. To do this, you create all the hidden fields (the 
ATTRIBUTEn fields and the structure defining field) as non-database fields on the null 
canvas. Then, code trigger and table handler logic that keeps the data in the two tables 
synchronized. For example, when your form updates your base table, your 
ON_UPDATE table handler should update the ATTRIBUTEn and structure defining 
columns in the descriptive flexfield table. Likewise, when your form inserts new 
records, you should have logic in your ON_INSERT table handler that inserts into the 
descriptive flexfield table. Descriptive flexfields never write directly to a table (base 
table or otherwise); they always write to the hidden segment fields.
Create Your Displayed Fields
Create your concatenated segments field as a 2000 character displayed, non-database 
text item for either key or descriptive flexfields. For a range flexfield, you create two 
non-database fields with the same name but with the suffixes _LOW and _HIGH. 
Use the TEXT_ITEM property class for your key and range flexfields. For a descriptive 
flexfield, use the property class TEXT_ITEM_DESC_FLEX and name the field 
DESC_FLEX.
You must attach the dummy LOV from the TEMPLATE form, ENABLE_LIST_LAMP, 
to the displayed key or descriptive flexfield field. Make sure that "Validate from List" 
property (formerly "Use LOV for Validation") is set to No. This ensures that the List 
lamp works properly for your flexfield. 
If you experience strange LOV behavior (where the LOV provides "null" as the only 
valid choice) or messages that the flexfield cannot be updated and/or has invalid values,
Documents you may be interested
Documents you may be interested