pdf annotation in c# : Add links pdf document Library control component .net web page windows mvc %5BO%60Reilly%5D%20-%20JavaScript.%20The%20Definitive%20Guide,%206th%20ed.%20-%20%5BFlanagan%5D88-part1623

BeforeUnloadEvent object. If you want to require the user to confirm that he really wants to
leave the page, you do not need to, and should not, call the 
Window.confirm()
method. Instead,
return a string from the event handler or set the 
returnValue
of this event object to a string.
The string you return or set will be presented to the user in the confirmation dialog the user
sees.
See also 
Event
and 
Window
.
Properties
string returnValue
A message to be displayed to the user in a confirmation dialog before navigating away
from the page. Leave this property unset if you do not want to display a confirmation
dialog.
Blob
an opaque chunk of data, such as file contents
A Blob is an opaque type used to exchange data between APIs. Blobs may be very large and
may represent binary data, but neither is required. Blobs are often stored in files, but this is
an implementation detail. Blobs expose only their size and, optionally, a MIME type, and
they define a single method for treating a region of a Blob as a Blob.
A number of APIs use Blobs: see 
FileReader
for a way to read the content of a Blob and
BlobBuilder
for a way to create new Blob objects. See 
XMLHttpRequest
for ways to download
and upload Blobs. See §22.6 for discussion of Blobs and the APIs that use them.
Properties
readonly unsigned long size
The length, in bytes, of the Blob.
readonly string type
The MIME type of the Blob, if it has one, or the empty string otherwise.
Methods
Blob slice(unsigned long start, unsigned long length, [string contentType])
Return a new Blob that represents the 
length
bytes of this Blob starting at offset 
start
. If
contentType
is specified, it will be used as the 
type
property of the returned Blob
BlobBuilder
create new Blobs
A BlobBuilder object is used to create new 
Blob
objects out of strings of text and bytes from
ArrayBuffer
objects and other Blobs. To build a Blob, create a BlobBuilder, call 
append()
one
or more times, and then call 
getBlob()
.
BlobBuilder
Client-Side JavaScript Reference | 863
Client-Side
JavaScript
Reference
Add links pdf document - insert, remove PDF links in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Free C# example code is offered for users to edit PDF document hyperlink (url), like inserting and deleting
change link in pdf file; add a link to a pdf
Add links pdf document - VB.NET PDF url edit library: insert, remove PDF links in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Help to Insert a Hyperlink to Specified PDF Document Page
add a link to a pdf in preview; c# read pdf from url
Constructor
new BlobBuilder()
Create a new BlobBuilder by calling the 
BlobBuilder()
constructor with no arguments.
Methods
void append(string text, [string endings])
Appends the specified 
text
, encoded using UTF-8, to the Blob that is being built.
void append(Blob data)
Append the content of the Blob 
data
to the Blob that is being built.
void append(ArrayBuffer data)
Append the bytes of the ArrayBuffer 
data
to the Blob that is being built.
Blob getBlob([string contentType])
Return a Blob that represents all the data that has been appended to this BlobBuilder since it
was created. Each call to this method returns a new Blob. If 
contentType
is specified, it will
be the value of the 
type
property of the returned Blob. If unspecified, the returned Blob will
have the empty string as its 
type
.
Button
an HTML <button>
Node, Element, FormControl
A Button object represents an HTML 
<button>
element. Most of the properties and methods
of Buttons are described in 
FormControl
and 
Element
. When a Button has a 
type
property (see
FormControl
) “submit”, however, the other properties listed here specify form submission
parameters that override similar properties on the Button’s 
form
(see 
FormControl
).
Properties
The following properties are meaningful only when the 
<button>
has a 
type
of “submit”.
string formAction
This property mirrors the 
formaction
HTML attribute. For submit buttons, it overrides
the 
action
property of the form.
string formEnctype
This property mirrors the 
formenctype
HTML attribute. For submit buttons, it overrides
the 
enctype
property of the form and has the same legal values as that property.
string formMethod
This property mirrors the 
formmethod
HTML attribute. For submit buttons, it overrides
the 
method
property of the form.
string formNoValidate
This property mirrors the 
formnovalidate
HTML attribute. For submit buttons, it over-
rides the 
noValidate
property of the form.
Button
864 | Client-Side JavaScript Reference
C# PDF Convert to HTML SDK: Convert PDF to html files in C#.net
converter toolkit SDK, preserves all the original anchors, links, bookmarks and Use C#.NET Demo Code to Convert PDF Document to HTML5 Add necessary references:
add links to pdf acrobat; add hyperlink to pdf acrobat
.NET PDF Document Viewing, Annotation, Conversion & Processing
edit, delete links. Form Process. Fill in form data programmatically. Read form data from PDF form file. Add, Update, Delete form fields programmatically. Document
adding links to pdf document; add email link to pdf
string formTarget
This property mirrors the 
formtarget
HTML attribute. For submit buttons, it overrides
the 
target
property of the form.
Canvas
an HTML element for scripted drawing
Node, Element
The Canvas object represents an HTML canvas element. It has no behavior of its own, but it
defines an API that supports scripted client-side drawing operations. You can specify the
width
and 
height
directly on this object, and you can extract an image from the canvas with
toDataURL()
, but the actual drawing API is implemented by a separate “context” object re-
turned by the 
getContext()
method. See 
CanvasRenderingContext2D
.
Properties
unsigned long height
unsigned long width
These properties mirror the 
width
and 
height
attributes of the 
<canvas>
tag and specify
the dimensions of the canvas coordinate space. The defaults are 300 for 
width
and 150
for 
height
.
If the size of the canvas element is not otherwise specified in a stylesheet or with the inline
style
attribute, these 
width
and 
height
properties also specify the on-screen dimensions
of the canvas element.
Setting either of these properties (even setting it to its current value) clears the canvas to
transparent black and resets all of its graphics attributes to their default values.
Methods
object getContext(string contextId, [any args...])
This method returns an object with which you can draw into the Canvas element. When you
pass the string “2d”, it will return a CanvasRenderingContext2D object for 2D drawing. No
additional 
args
are required in this case.
There is only one CanvasRenderingContext2D object per canvas element, so repeated calls
to 
getContext("2d")
return the same object.
HTML5 standardizes the “2d” argument to this method and defines no other valid arguments.
A separate standard, WebGL, is under development for 3D graphics. In browsers that support
it, you can pass the string “webgl” to this method to obtain an object that allows 3D rendering.
Note, however, that the CanvasRenderingContext2D object is the only drawing context
documented in this book.
string toDataURL([string type], [any args...])
toDataURL()
returns the contents of the canvas bitmap as a 
data://
URL that can easily be
used with an 
<img>
tag or transmitted across the network. For example:
// Copy the content of a canvas into an <img> and append to the document
var canvas = document.getElementById("my_canvas");
Canvas
Client-Side JavaScript Reference | 865
Client-Side
JavaScript
Reference
VB.NET PDF Convert to HTML SDK: Convert PDF to html files in vb.
Turn PDF images to HTML images in VB.NET. Embed PDF hyperlinks to HTML links in VB.NET. Convert PDF to HTML in VB.NET Demo Code. Add necessary references:
convert doc to pdf with hyperlinks; add link to pdf
How to C#: Basic SDK Concept of XDoc.PDF for .NET
You may add PDF document protection functionality into your C# program. to edit hyperlink of PDF document, including editing PDF url links and quick
pdf link to email; change link in pdf
var image = document.createElement("img");
image.src = canvas.toDataURL();
document.body.appendChild(image);
The 
type
argument specifies the MIME type of the image format to use. If this argument is
omitted, the default value is “image/png”. The PNG image format is the only one that im-
plementations are required to support. For image types other than PNG, additional arguments
may be passed to specify encoding details. If 
type
is “image/jpeg”, for example, the second
argument should be a number between 0 and 1 specifying the image quality level. No other
parameter arguments are standardized at the time of this writing.
To prevent cross-origin information leaks, 
toDataURL()
does not work on 
<canvas>
tags that
are not “origin-clean.” A canvas is not origin-clean if it has ever had an image drawn in it
(directly by 
drawImage()
or indirectly through a CanvasPattern) that has a different origin than
the document that contains the canvas. Also, a canvas is not origin-clean if it has ever had
text drawn to it using a web font from a different origin.
CanvasGradient
a color gradient for use in a canvas
A CanvasGradient object represents a color gradient that can be assigned to both the
strokeStyle
and 
fillStyle
properties of a CanvasRenderingContext2D object. The 
create
LinearGradient()
and 
createRadialGradient()
methods of CanvasRenderingContext2D both
return CanvasGradient objects.
Once you have created a CanvasGradient object, use 
addColorStop()
to specify what colors
should appear at what positions within the gradient. Between the positions you specify, colors
are interpolated to create a smooth gradient or fade. If you specify no color stops, the gradient
will be uniform transparent black.
Methods
void addColorStop(double offset, string color)
addColorStop()
specifies fixed colors within a gradient. 
color
is a CSS color string. 
offset
is
a floating-point value in the range 0.0 to 1.0 that represents a fraction between the start and
end points of the gradient. An offset of 0 corresponds to the start point, and an offset of 1
corresponds to the end point.
If you specify two or more color stops, the gradient will smoothly interpolate colors between
the stops. Before the first stop, the gradient will display the color of the first stop. After the
last stop, the gradient will display the color of the last stop. If you specify only a single stop,
the gradient will be one solid color. If you specify no color stops, the gradient will be uniform
transparent black.
CanvasGradient
866 | Client-Side JavaScript Reference
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
the original text style (including font, size, color, links and boldness). C#.NET DLLs and Demo Code: Convert PDF to Word Document in C# Add necessary references
clickable links in pdf from word; add links to pdf in preview
C# Create PDF Library SDK to convert PDF from other file formats
PDF with a blank page, bookmarks, links, signatures, etc. a PDF document in C#.NET using this PDF document creating toolkit, if you need to add some text
add hyperlink to pdf in preview; clickable links in pdf files
CanvasPattern
an image-based pattern for use in a Canvas
A CanvasPattern object is an opaque object returned by the 
createPattern()
method of a
CanvasRenderingContext2D object. A CanvasPattern object can be used as the value of the
strokeStyle
and 
fillStyle
properties of a CanvasRenderingContext2D object.
CanvasRenderingContext2D
the object used for drawing on a canvas
The CanvasRenderingContext2D object provides properties and methods for drawing two-
dimensional graphics. The following sections provide an overview. See §21.4, 
Canvas
,
CanvasGradient
CanvasPattern
ImageData
, and 
TextMetrics
for further details.
Creating and rendering paths
A powerful feature of the canvas is its ability to build shapes up from basic drawing operations,
then either draw their outlines (stroke them) or paint their contents (fill them). The operations
accumulated are collectively referred to as the current path. A canvas maintains a single current
path.
In order to build a connected shape out of multiple segments, a joining point is needed be-
tween drawing operations. For this purpose, the canvas maintains a current position. The
canvas drawing operations implicitly use this as their start point and update it to what is
typically their end point. You can think of this like drawing with a pen on paper: when fin-
ishing a particular line or curve, the current position is where the pen rested after completing
the operation.
You can create a sequence of disconnected shapes in the current path that will be rendered
together with the same drawing parameters. To separate shapes, use the 
moveTo()
method;
this moves the current position to a new location without adding a connecting line. When
you do this, you create a new subpath, which is the canvas term used for a collection of
operations that are connected.
The available path operations are 
lineTo()
for drawing straight lines, 
rect()
for drawing
rectangles, 
arc()
and 
arcTo()
for drawing partial circles, and 
bezierCurveTo()
and 
quadratic
CurveTo()
for drawing curves.
Once the path is complete, you can draw its outline with 
stroke()
, paint its contents with
fill()
, or do both.
In addition to stroking and filling, you can also use the current path to specify the clipping
region the canvas uses when rendering. Pixels inside this region are displayed; those outside
are not. The clipping region is cumulative; calling 
clip()
intersects the current path with the
current clipping region to yield a new region.
If the segments in any of the subpaths do not form a closed shape, 
fill()
and 
clip()
opera-
tions implicitly close them for you by adding a virtual (not visible with a stroke) line segment
CanvasRenderingContext2D
Client-Side JavaScript Reference | 867
Client-Side
JavaScript
Reference
C# Image: Tutorial for Document Management Using C#.NET Imaging
detailed C# tutorials on each part by following the links respectively. are dedicated to provide powerful & profession imaging controls, PDF document, image to
add url link to pdf; add hyperlink to pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
You may add PDF document protection functionality into your VB.NET program. to edit hyperlink of PDF document, including editing PDF url links and quick
pdf link open in new window; add a link to a pdf file
from the start to the end of the subpath. Optionally, you can call 
closePath()
to explicitly
add this line segment.
To test whether a point is inside (or on the boundary of) the current path, use 
isPointIn
Path()
. When a path intersects itself or consists of multiple overlapping subpaths, the defi-
nition of “inside” is based on the nonzero winding rule. If you draw a circle inside another
circle and both circles are drawn in the same direction, everything inside the larger circle is
considered inside the path. If, on the other hand, one circle is drawn clockwise and the other
counterclockwise, you have defined a donut shape and the interior of the smaller circle is
outside of the path. This same definition of insideness is used by the 
fill()
and 
clip()
methods.
Colors, gradients, and patterns
When filling or stroking paths, you can specify how the lines or filled area are rendered using
the 
fillStyle
and 
strokeStyle
properties. Both accept CSS-style color strings, as well as
CanvasGradient and CanvasPattern objects that describe gradients and patterns. To create
a gradient, use the 
createLinearGradient()
or 
createRadialGradient()
methods. To create a
pattern, use 
createPattern()
.
To specify an opaque color using CSS notation, use a string of the form “#RRGGBB”, where
RR, GG, and BB are hexadecimal digits that specify the red, green, and blue components of
the color as values between 00 and FF. For example, bright red is “#FF0000”. To specify a
partially transparent color, use a string of the form “rgba(R,G,B,A)”. In this form, R, G, and
B specify the red, green, and blue components of the color as decimal integers between 0 and
255, and A specifies the alpha (opacity) component as a floating-point value between 0.0 (fully
transparent)  and  1.0  (fully  opaque).  For  example,  half-transparent  bright  red  is
“rgba(255,0,0,0.5)”.
Line width, line caps, and line joins
Canvas defines several properties that specify how lines are stroked. You can specify the width
of the line with the 
lineWidth
property, how the end points of lines are drawn with the
lineCap
property, and how lines are joined using the 
lineJoin
property.
Drawing rectangles
You can outline and fill rectangles with 
strokeRect()
and 
fillRect()
. In addition, you can
clear the area defined by a rectangle with 
clearRect()
.
Drawing images
In the Canvas API, images are specified using Image objects that represent HTML 
<img>
ele-
ments or offscreen images created with the 
Image()
constructor. (See the 
Image
reference page
for details.) A 
<canvas>
element or 
<video>
element can also be used as an image source.
You can draw an image into a canvas with the 
drawImage()
method, which, in its most general
form, allows an arbitrary rectangular region of the source image to be scaled and rendered
into the canvas.
CanvasRenderingContext2D
868 | Client-Side JavaScript Reference
Drawing Text
The 
fillText()
method draws text and the 
strokeText()
method draws outlined text. The
font
property specifies the font to use; the value of this property should be a CSS font speci-
fication string. The 
textAlign
property specifies whether text is left-justified, centered, or
right-justified on the X coordinate you pass, and the 
textBaseline
property specifies where
the text is drawn in relation to the Y coordinate you pass.
Coordinate space and transformations
By default, the coordinate space for a canvas has its origin at 
(0,0)
in the upper left corner of
the canvas, with 
x
values increasing to the right and 
y
values increasing down. The 
width
and
height
attributes of the 
<canvas>
tag specify the maximum X and Y coordinates, and a single
unit in this coordinate space normally translates to a single on-screen pixel.
You can define your own coordinate space and the coordinates you pass to the canvas drawing
methods will automatically be transformed. This is done with the 
translate()
scale()
, and
rotate()
methods, which affect the transformation matrix of the canvas. Because the coordi-
nate space can be transformed like this, the coordinates you pass to methods such as
lineTo()
cannot be measured in pixels and the Canvas API uses floating-point numbers in-
stead of integers.
Shadows
CanvasRenderingContext2D can automatically add a drop shadow to anything you draw.
The color of the shadow is specified with 
shadowColor
, and its offset is changed using
shadowOffsetX
and 
shadowOffsetY
. In addition, the amount of feathering applied to the shad-
ow’s edge can be set with 
shadowBlur
.
Compositing
Usually, when you draw on a canvas, the newly drawn graphics appear on top of the previous
content of the canvas, partially or fully obscuring the old content, depending on the opacity
of the new graphics. The process of combining new pixels with old pixels is called “compo-
siting” and you can alter the way the canvas composites pixels by specifying different values
for the 
globalCompositeOperation
property. For example, you can set this property so that
newly drawn graphics appear underneath the existing content.
The following table lists the allowed property values and their meanings. The word source in
the table refers to the pixels being drawn onto the canvas, and the word destination refers to
the existing pixels on the canvas. The word 
result
refers to the pixels that result from the
combination of the source and destination. In the formulas, the letter 
S
is the source pixel,
D
is the destination pixel, 
R
is the result pixel, α
s
is the alpha channel (the opacity) of the source
pixel, and α
d
is the alpha channel of the destination:
Value
Formula
Meaning
"copy"
R = S
Draws the source pixel, ignoring the destination pixel.
"destination-atop"
R=(1-α
d
)S + α
s
D
Draw the source pixel underneath the destination. If the source
is transparent, the result is also transparent.
CanvasRenderingContext2D
Client-Side JavaScript Reference | 869
Client-Side
JavaScript
Reference
Value
Formula
Meaning
"destination-in"
R = α
s
D
Multiply the destination pixel by the opacity of the source
pixel, but ignore the color of the source.
"destination-out"
R = (1-α
s
)D
The destination pixel is made transparent when the source is
opaque and is left unchanged when the source is transparent.
The color of the source pixel is ignored.
"destination-over"
R = (1-α
d
)S + D
The source pixel appears behind the destination pixel, show-
ing through based on the transparency of the destination.
"lighter"
R = S + D
The color components of the two pixels are simply added
together and clipped if the sum exceeds the maximum value.
"source-atop"
R=α
d
S + (1-α
s
)D
Draw the source pixel on top of the destination but multiply
it by the opacity of the destination. Don’t draw anything over
a transparent destination.
"source-in"
R = α
d
S
Draw the source pixel, but multiply it by the opacity of the
destination. The color of the destination is ignored. If the
destination is transparent, the result is transparent, too.
"source-out"
R = (1-α
d
)S
The result is the source pixel where the destination is trans-
parent and transparent pixels where the destination is opa-
que. The color of the destination is ignored.
"source-over"
R = S + (1-α
s
)D
The source pixel is drawn on top of the destination pixel. If the
source is translucent, the destination pixel contributes to the
result. This is the default value of the
globalCompositeOperation
property.
"xor"
R = (1-α
d
)S + (1-α
s
)D
If the source is transparent, the result is the destination. If the
destination is transparent, the result is the source. If source
and destination are both transparent or both opaque, the
result is transparent.
Saving graphics state
The 
save()
and 
restore()
methods allow you to  save and restore the state of a
CanvasRenderingContext2D object. 
save()
pushes the current state onto a stack, and
restore()
pops the most recently saved state off the top of the stack and sets the current
drawing state based on those stored values.
All properties of the CanvasRenderingContext2D object (except for the 
canvas
property,
which is a constant) are part of the saved state. The transformation matrix and clipping region
are also part of the state, but the current path and current point are not.
Manipulating Pixels
The 
getImageData()
method allows you to query the raw pixels of a canvas, and 
putImage
Data()
allows you to set individual pixels. These can be useful if you want to implement image
processing operations in JavaScript.
CanvasRenderingContext2D
870 | Client-Side JavaScript Reference
Properties
readonly Canvas canvas
The Canvas element upon which this context will draw.
any fillStyle
The current color, pattern, or gradient used for filling paths. This property can be set to
a CSS color string or to a CanvasGradient or CanvasPattern object. The default fill style
is solid black.
string font
The font to be used by text-drawing methods, specified as a string, using the same syntax
as the CSS 
font
attribute. The default is “10px sans-serif”. If the font string uses font size
units like “em” or “ex” or uses relative keywords like “larger”, “smaller”, “bolder”, or
“lighter”, these are interpreted relative to the computed style of the CSS font of the
<canvas>
element.
double globalAlpha
Specifies additional transparency to be added to everything drawn on the canvas. The
alpha value of all pixels drawn on the canvas is multiplied by the value of this property.
The value must be a number between 0.0 (makes everything completely transparent) and
1.0 (the default: adds no additional transparency).
string globalCompositeOperation
This property specifies how source pixels being rendered onto the canvas are combined
(or “composited”) with the destination pixels that already exist in the canvas. This prop-
erty is typically only useful when you are working with partially transparent colors or
have set the 
globalAlpha
property. The default value is "source-over". Other commonly
used values are “destination-over” and “copy”. See the table of legal values above. Note
that at the time of this writing, browsers have differing implementations of certain com-
positing modes: some composite locally and some composite globally. See §21.4.13 for
details.
string lineCap
The 
lineCap
property specifies how lines should be terminated. It matters only when
drawing wide lines. Legal values for this property are listed in the following table. The
default value is “butt”.
Value
Meaning
"butt"
This default value specifies that the line should have no cap. The end of the line is straight and is perpendicular to
the direction of the line. The line is not extended beyond its endpoint.
"round"
This value specifies that lines should be capped with a semicircle whose diameter is equal to the width of the line
and which extends beyond the end of the line by one half the width of the line.
"square"
This value specifies that lines should be capped with a rectangle. This value is like “butt”, but the line is extended
by half of its width.
CanvasRenderingContext2D
Client-Side JavaScript Reference | 871
Client-Side
JavaScript
Reference
string lineJoin
When a path includes vertices where line segments and/or curves meet, the 
lineJoin
property specifies how those vertices are drawn. The effect of this property is apparent
only when drawing with wide lines.
The default value of the property is “miter”, which specifies that the outside edges of the
two line segments are extended until they intersect. When two lines meet at an acute
angle, mitered joins can become quite long. The 
miterLimit
property places an upper
bound on the length of a miter. If a miter would exceed this limit, it is converted to a bevel.
The value “round” specifies that the outside edges of the vertex should be joined with a
filled arc whose diameter is equal to the width of the line. The value “bevel” specifies
that the outside edges of the vertex should be joined with a filled triangle.
double lineWidth
Specifies the line width for stroking (line drawing) operations. The default is 1. Lines are
centered over the path, with half of the line width on each side.
double miterLimit
When lines are drawn with the 
lineJoin
property set to “miter” and two lines meet at an
acute angle, the resulting miter can be quite long. When miters are too long, they become
visually jarring. This 
miterLimit
property places an upper bound on the length of the
miter. This property expresses a ratio of the miter length to half the line width. The default
value is 10, which means that a miter should never be longer than 5 times the line width.
If a miter formed by two lines would be longer than the maximum allowed by
miterLimit
, those two lines will be joined with a bevel instead of a miter.
double shadowBlur
Specifies how much blur shadows should have. The default is 0, which produces crisp-
edged shadows. Larger values produce larger blurs, but note that the units are not meas-
ured in pixels and are not affected by the current transform.
string shadowColor
Specifies the color of shadows as a CSS color string. The default is transparent black.
double shadowOffsetX
double shadowOffsetY
Specify the horizontal and vertical offset of the shadows. Larger values make the shad-
owed object appear to float higher above the background. The default is 0. These values
are in coordinate space units and they are independent of the current transform.
any strokeStyle
Specifies the color, pattern, or gradient used for stroking (drawing) paths. This property
can be a CSS color string or a CanvasGradient or a CanvasPattern object.
string textAlign
Specifies the horizontal alignment of text and the meaning of the X coordinate passed to
fillText()
and 
strokeText()
. Legal values are “left”, “center”, “right”, “start”, and
“end”. The meaning of “start” and “end” depend on the 
dir
(text direction) attribute of
the 
<canvas>
tag. The default is “start”.
CanvasRenderingContext2D
872 | Client-Side JavaScript Reference
Documents you may be interested
Documents you may be interested