convert pdf to jpg c# codeproject : Add security to pdf document software control cloud windows web page .net class OOME_3_023-part1989

10. Universal Network Objects
The internals of OpenOffice.org are based on Universal Network Objects (UNO). This chapter introduces 
the subroutines and functions supported by OpenOffice.org Basic that are related to UNO. This chapter 
covers methods that create and inspect objects that are vital to the internals of OpenOffice.org.
Up to this point, I have mostly dealt with simple single value things such as string and integer. An object,  
however, usually contains many values and it also has methods; for example, you can access a document as 
a variable and access information about the document (data or properties), and call methods that manipulate 
the document.
In this chapter, I begin to discuss things related to the actual implementation of OOo — things that allow 
you to exploit the internal capabilities of OOo. You’ll also begin to see more details about how OOo is 
implemented — which you need to build the really cool stuff.
Are you a programmer or a highly technical person? If not, skip this paragraph and go directly to the tip. 
Still reading? Great, so UNO is:
The interface based component model for OOo. 
Enables interoperability between programming languages, object models and hardware architectures,
either in process or over process boundaries, as well as in the intranet or the Internet.
New languages are supported by adding a language binding. This is also stated as adding a “bridge” 
or “adapter”. This paradigm makes it easier to support multiple languages.
UNO components may be implemented in, and accessed from, any programming language with a 
complete language binding.
TIP
You can write powerful macros without fully understand Universal Network Objects. Just think of a UNO 
as any object that is used internally by OOo.
Stated more simply: The internal parts of OOo are used as Universal Network Objects. By using UNOs, it is 
possible to access an instance of OOo running on a different computer and operating system. A vague 
understanding of Universal Network Objects is important because most of the internals of OpenOffice.org 
are implemented using UNO. 
Table 88 lists the OOo Basic functions used to deal with UNO.
228
Add security to pdf document - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
pdf security remover; copy from locked pdf
Add security to pdf document - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
pdf password security; pdf password encryption
Table 88. Functions related to Universal Network Objects in OOo Basic.
Function
Description
BasicLibraries
Access Basic libraries stored in a document.
CreateObject(obj_type)
Able to create any standard type, more flexible than 
CreateUnoStruct and CreateUnoService.
CreateUnoDialog()
Create an existing dialog.
CreateUnoListener()
Create a listener.
CreateUnoService() 
Create a Universal Network Object Service.
CreateUnoStruct()
Create a Universal Network Object Structure.
CreateUnoValue()
Create a Universal Network Object value.
DialogLibraries
Access dialog libraries stored in a document.
EqualUNOObjects()
Determine if two UNO objects reference the same 
instance.
FindObject()
Find a named object; do not use.
FindPropertyObject()
Find object property based on name; do not use.
GetDefaultContext()
Get a copy of the default context.
GetProcessServiceManager()
Get service manager.
GlobalScope
Application-level libraries.
HasUnoInterfaces()
Does an object support specified interfaces?
IsUnoStruct()
Is this variable a Universal Network Object?
StarDesktop
Special variable representing the desktop object.
ThisComponent
Special variable representing the current document.
10.1. Base types and structures
Most of the internal data used by OOo is based on standard types such as strings and numbers. These types 
are combined into structures (called structs), which act like user-defined data types. The structures are 
combined to form more complex UNO objects. A struct supports properties but not methods. 
A structure provides a method of placing more than one value into a single variable. You access the values in
a structure based on a name that is decided when the struct type is designed by a programmer. A commonly 
used struct is the PropertyValue, whose primary purpose is to hold a string name and a variant value. The 
following listing demonstrates creating a PropertyValue structure and then setting the name and the value. 
The contained properties are accessed by placing a period between the variable and the property name. 
Listing 203. Use Dim As New to create a UNO structure.
Dim aProp As New com.sun.star.beans.PropertyValue
aProp.Name = "FirstName"       'Set the Name property
aProp.Value = "Paterton"       'Set the Value property
TIP
OOo objects have long names such as com.sun.star.beans.PropertyValue; in the text I usually abbreviate the
name and simply write PropertyValue, but your macros must use the full name.
229
VB.NET PDF Password Library: add, remove, edit PDF file password
On this page, we will illustrate how to protect PDF document via password by using simple VB.NET demo code. Add password to PDF. Set PDF security level.
pdf file security; add security to pdf document
C# PDF Password Library: add, remove, edit PDF file password in C#
To help protect your PDF document in C# project, XDoc.PDF provides some PDF security settings. Add necessary references: RasterEdge.Imaging.Basic.dll.
creating secure pdf files; secure pdf file
You must create (or obtain) a UNO structure before you can use it. The most common method to create a 
UNO structure is to use Dim As New (see Listing 203). You can also use Dim to create an array of 
structures.
Listing 204. Use Dim As New to create an array of UNO structures.
Dim aProp(4) As New com.sun.star.beans.PropertyValue
aProp(0).Name  = "FirstName"   'Set the Name property
aProp(0).Value = "Clyde"       'Set the Value property
Use the CreateUnoStruct function to create a UNO structure when it is needed rather than declare it ahead of
time. Dynamically creating a UNO structure allows the name of the structure to be provided at run time 
rather than compile time. Providing a name at run time is shown in Listing 205 and Listing 208. Providing a 
name at compile time is shown in Listing 203.
Listing 205. Use CreateUnoStruct to create a UNO structure.
Dim aProp
aProp = CreateUnoStruct("com.sun.star.beans.PropertyValue")
aProp.Name = "FirstName"       'Set the Name property
aProp.Value = "Andrew"         'Set the Value property
The With statement simplifies the process of setting the properties of a structure.
Listing 206. Use With to simplify setting properties on structures.
Dim aProp(4) As New com.sun.star.beans.PropertyValue
With aProp(0)
.Name = "FirstName"       'Set the Name property
.Value = "Paterton"       'Set the Value property
End With
The function CreateUnoStruct used to be the only method to create a UNO structure. It is used less since the 
introduction of the “Dim As New” syntax. The CreateObject function is a more general function than 
CreateUnoStruct. It is able to create instances of all types supported by the Basic internal factory 
mechanism. This includes user-defined types.
Listing 207. Create a user-defined type with CreateObject or Dim As.
Type PersonType
FirstName As String
LastName As String
End Type
Sub ExampleCreateNewType
Dim Person As PersonType
Person.FirstName = "Andrew"
Person.LastName  = "Pitonyak"
PrintPerson(Person)
Dim Me As Object
Me = CreateObject("PersonType")
Me.FirstName = "Andy"
Me.LastName  = "Pitonyak"
PrintPerson(Me)
End Sub
Sub PrintPerson(x)
Print "Person = " & x.FirstName & " " & x.LastName
End Sub
230
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PDF
How to improve PDF document security. If you need to add your own signatures such as logo to PDF document, you and load and save it to current PDF file.
change security settings pdf; pdf unlock
C# HTML5 Viewer: Deployment on AzureCloudService
RasterEdge.XDoc.PDF.HTML5Editor.dll. 2. Add fill extension such as validateIntegratedModeConfiguration="false"/> <security> <requestFiltering
creating a secure pdf document; create secure pdf online
TIP
For a user-defined type, “Dim As New” and “Dim As” both work. For a UNO struct, however, you must 
use “Dim As New”.
The CreateObject function accepts the same arguments as CreateUnoStruct, but it works for all supported 
types, whereas CreateUnoStruct works only for UNO structures. Therefore, there is no reason to use 
CreateUnoStruct rather than CreateObject.
Listing 208. Use CreateObject to create a UNO structure.
Dim aProp
aProp = CreateObject("com.sun.star.beans.PropertyValue")
aProp.Name = "FirstName"       'Set the Name property
aProp.Value = "Paterton"       'Set the Value property
TIP
CreateObject offers more flexibility than CreateUnoStruct to dynamically create objects based on a name.
I wrote a small test program that created 20000 structs. CreateUnoStruct and CreateObject took about the 
same amount of time. Using Dim As New, however, used 500 clock ticks less, which is useful if you want to
make a macro run as fast as possible.
The TypeName function indicates that a UNO structure is an object. Use the IsUnoStruct function to 
determine if a variable is a UNO structure.
Listing 209. Use IsUnoStruct to check if an object is an UNO Struct.
Dim aProp As New com.sun.star.beans.PropertyValue
Print TypeName(aProp)     'Object
Print IsUnoStruct(aProp)  'True
10.2. UNO interface
An interface defines how something interacts with its environment. A UNO interface resembles a group of 
subroutine and function declarations; arguments and return types are specified along with functionality. 
You can use the interface to retrieve data from an object, set data in an object, or tell an object to do 
something. The interface indicates how an object can be used, but it says nothing about the implementation. 
For example, if an interface contains the method GetHeight that returns an integer, it’s natural to assume that
the object contains an integer property named Height. It’s possible, however, that the height is derived or 
calculated from other properties. The interface does not specify how the height is obtained, just that it is 
available. A UNO structure, however, contains properties that are accessed directly; the internal 
representation is not hidden.
TIP
UNO interface names start with the capital letter X.
When you want to know what methods are supported by an object, check the interfaces.
UNO interface names start with the capital letter X, which makes it easy to recognize an interface; for 
example, the interface com.sun.star.text.XTextRange specifies a section of text with both a start and end 
position. Objects that support the XTextRange interface are also used to identify an object’s position in text 
document. The start and end positions may be the same. The XTextRange interface defines the methods in
Table 89.
231
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
Security PDF component download. This .NET PDF Document Add-On integrates mature PDF document page processing functions, including extracting one or more page(s
convert secure webpage to pdf; pdf password unlock
VB.NET PDF Library SDK to view, edit, convert, process PDF file
PDF Document Protection. XDoc.PDF SDK allows users to perform PDF document security settings in VB.NET program. Password, digital
advanced pdf encryption remover; change pdf document security
Table 89. Methods defined by the com.sun.star.text.XTextRange interface.
Method
Description
getText()
Return the com.sun.star.text.XText interface that contains this XTextRange.
getStart()
Return a com.sun.star.text.XTextRange that references only the start position.
getEnd()
Return a com.sun.star.text.XTextRange that references only the end position.
getString()
Return a string that includes the text inside this text range.
setString(str)
Set the string for this text range, replacing existing text and clearing all styles.
TIP
A UNO interface may be derived from another. Every UNO interface is required to be derived from 
com.sun.star.uno.XInterface.
A new UNO interface may be derived from another. This is not something that you do, but rather it’s 
something that is done by the designer of the interface. The derived interface supports all of the methods 
defined in the interface from which it is derived. For example, the com.sun.star.text.XTextCursor extends 
the XTextRange interface to allow it to change the range, which makes sense if you think about what you do 
with a cursor. Any object that implements the XTextCursor interface, supports the methods in Table 89 and 
the new methods introduced by the XTextCursor interface. 
The main points regarding interfaces (so far) are:
1) An interface defines methods. In other words, an interface defines what an object can do; including 
getting and setting internal properties.
2) An interface may be derived from another interface.
3) The last portion of an interface name begins with an X.
In UNO, objects are accessed by their interface. Many of the programming languages, such as Java and C++,
force you to perform a little UNO magic and extract the correct interface before you can call the methods 
defined in the interface. OOo Basic hides these details for you so that you can directly call methods and 
access properties directly.
TIP
OOo Basic hides many of the complicated details, so, for most things, it is easier to write an OOo Basic 
program than to write a Java script.
10.3. UNO service
A service abstractly defines an object by combining interfaces and properties to encapsulate some useful 
functionality. A UNO interface defines how an object interacts with the outside world; a UNO structure 
defines a collection of data; and a UNO service combines them together. Like a UNO interface, a UNO 
service does not specify the implementation. It only specifies how to interact with the object. 
Almost every UNO object is defined by a service, so UNO objects are called services. Strictly speaking, 
however, “a service” is the object definition. The UNO object is the actual object created as defined by the 
service. A service may include multiple services and interfaces. An interface usually defines a single aspect 
of a service and therefore is usually smaller in scope.
Many services have a name similar to an interface name; for example, one of the interfaces exported by the 
TextCursor service is the XTextCursor interface. An interface or property may be declared as optional for a 
service. The XWordCursor interface is marked as optional for the TextCursor service. The implication is that
232
C# Image: C# Code to Upload TIFF File to Remote Database by Using
save the ImageUploadService file, add a web using System.Security.Cryptography; private void tsbUpload_Click profession imaging controls, PDF document, image to
convert locked pdf to word doc; change security on pdf
VB.NET PDF - VB.NET HTML5 PDF Viewer Deployment on IIS
place where you store XDoc.PDF.HTML5 Viewer correspond site-> Edit Permissions -> Security -> Group or user names -> Edit -> Add -> Add Everyone usersgiven
change pdf security settings; pdf security options
not all text cursors support the word cursor interface. In practice, you learn which text cursors support which
interfaces and then simply use them.
There are two typical methods for obtaining a service. 
Get a reference to an existing object; for example, retrieving the first text table in the current 
document.
Ask a service factory to create an instance of an object; for example, if I want to insert a new text 
table into a document, I ask the document to give me a new empty table, which I then configure and 
insert into the document.
A service factory returns objects based on the name. The process service manager is the main object factory 
for OpenOffice.org. The factory is given the service name, and the factory decides what to return. A factory 
may return a brand new instance of an object, or, it may return an existing instance. Use 
GetProcessServiceManager() to obtain a reference to the process service manager. Use CreateInstance to 
create a service from the process service manager as shown in Listing 210. 
Listing 210. Use process service manager to create a service.
Sub ManagerCreatesAService
Dim vFileAccess
Dim s As String
Dim vManager
vManager = GetProcessServiceManager()
vFileAccess = vManager.CreateInstance("com.sun.star.ucb.SimpleFileAccess")
s = vFileAccess.getContentType("http://www.pitonyak.org/AndrewMacro.odt")
Print s
End Sub
The code in Listing 210 obtains the process service manager, creates an instance of the SimpleFileAccess 
service, and then uses the created service. The CreateUnoService function is a shortcut for creating a UNO 
service (see Listing 211). The purpose of Listing 211 is to demonstrate the CreateUnoService function, 
showing that it’s simpler than creating a service manager. Listing 211 also demonstrates some useful 
functionality, using a dialog to choose a file.
Listing 211.  Select a file on disk.
Function ChooseAFileName() As String
Dim vFileDialog         'FilePicker service instance
Dim vFileAccess         'SimpleFileAccess service instance
Dim iAccept as Integer  'Response to the FilePicker
Dim sInitPath as String 'Hold the initial path
'Note: The following services MUST be called in the following order
'or Basic will not remove the FileDialog Service
vFileDialog = CreateUnoService("com.sun.star.ui.dialogs.FilePicker")
vFileAccess = CreateUnoService("com.sun.star.ucb.SimpleFileAccess")
'Set the initial path here!
sInitPath = ConvertToUrl(CurDir)
If vFileAccess.Exists(sInitPath) Then
vFileDialog.SetDisplayDirectory(sInitPath)
End If
iAccept = vFileDialog.Execute()       'Run the file chooser dialog
If iAccept = 1 Then                   'What was the return value?
ChooseAFileName = vFileDialog.Files(0) 'Set file name if it was not canceled
233
End If
vFileDialog.Dispose()                 'Dispose of the dialog
End Function
A directory can be chosen similarly.
Listing 212.  Select a directory.
REM sInPath specifies the initial directory. If the initial directory
REM is not specified, then the user's default work directory is used.
REM The selected directory is returned as a URL.
Function ChooseADirectory(Optional sInPath$) As String
Dim oDialog As Object
Dim oSFA As Object
Dim s As String
Dim  oPathSettings
oDialog = CreateUnoService("com.sun.star.ui.dialogs.FolderPicker")
'oDialog = CreateUnoService("com.sun.star.ui.dialogs.OfficeFolderPicker")
oSFA = createUnoService("com.sun.star.ucb.SimpleFileAccess")
If IsMissing(sInPath) Then
oPathSettings = CreateUnoService("com.sun.star.util.PathSettings")
oDialog.setDisplayDirectory(oPathSettings.Work)
ElseIf oSFA.Exists(sInPath) Then
oDialog.setDisplayDirectory(sInPath)
Else
s = "Directory '" & sInPath & "' Does not exist"
If MsgBox(s, 33, "Error") = 2 Then Exit Function
End If
If oDialog.Execute() = 1 Then
ChooseADirectory() = oDialog.getDirectory()
End If
End Function
TIP
The file picker and folder picker dialogs can use either the operating system supplied default dialogs, or 
OOo specific dialogs. The operating system specific dialogs provide less functionality; for example, you 
cannot set the initial displayed directory. Use Tools > Options > OpenOffice.org > General and place a 
check next to "Use OpenOffice.org dialogs".
The code in Listing 211 creates two UNO services by using the function CreateUnoService. There are times,
however, when the service manager is required. For example, the service manager has methods to create a 
service with arguments, CreateInstanceWithArguments, and to obtain a list of all supported services, 
getAvailableServiceNames(). The code in Listing 213 obtains a list of the supported service names; there are
1003 services on my computer using OOo version 3.2.1; up from 562 with OOo version 1.
Listing 213. Service manager supports services.
Sub HowManyServicesSupported
Dim oDoc          ' Document created to hold the service names.
Dim oText         ' Document text object.
Dim oSD           ' SortDescriptor created for the document.
Dim oCursor       ' Text cursor used for sorting.
Dim i%            ' Index Variable.
Dim sServices
234
sServices = GetProcessServiceManager().getAvailableServiceNames()
Print "Service manager supports ";UBound(sServices);" services"
' Create a Writer document.
oDoc = StarDesktop.loadComponentFromURL( "private:factory/swriter", "_blank", 0, Array() )
oText = oDoc.getText()
' Print the service names into a Writer document.
For i = LBound( sServices ) To UBound( sServices )
oText.insertString( oText.getEnd(), sServices(i), False )
' Do not insert a blank line at the end.
oText.insertControlCharacter( oText.getEnd(), _
com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK, False )
Next
oCursor = oDoc.Text.CreateTextCursorByRange(oDoc.Text)
oSD = oCursor.createSortDescriptor()
oCursor.sort(oSD)
oText.insertString( oText.getStart(), _
"Service manager supports "&UBound(sServices)&" services", False )
End Sub
It is useful to look at the list of supported services. This provides insight into available functionality that you
can explore. A great example of this is shown Listing 214. An object inserted into a document must be 
created by that document. Using the methods of Listing 213, you can check to see what types of objects the 
document can create. 
Listing 214. What objects can a document create.
REM Print the object / service types that a document can create.
REM If the document (oDoc) is missing, the current document is used.
REM If nameFilter is included, then service names that contain
REM the string are printed; based on a case insensitive compare.
REM The service names are stored in a newly created Write document.
Sub TypesDocCanCreate(Optional oDoc, Optional nameFilter$)
Dim allNames   ' List of all the names.
Dim oWriteDoc  ' Newly created Write document to contain the names.
Dim oText      ' Document text object.
Dim s : s = "private:factory/swriter"
' Find out what this document can create.  
If IsMissing(oDoc) Then
allNames = ThisComponent.getAvailableServiceNames()
Else
allNames = oDoc.getAvailableServiceNames()
End If
' Create a new Write document to contain the list.
oWriteDoc = StarDesktop.loadComponentFromURL(s"_blank"0, Array())
oText = oWriteDoc.getText()
If IsMissing(nameFilter) Then
oText.insertString ( oText.End, Join(allNames, CHR$(13)), False )
235
Else
Dim i%
For i = LBound(allNames) To UBound(allNames)
If (InStr(allNames(i), nameFilter) > 0) Then
' Insert the text.
oText.insertString ( oText.End, allNames(i), False )
' Insert a new paragraph.
oText.InsertControlCharacter(oText.getEnd(),_
com.sun.star.text.ControlCharacter.APPEND_PARAGRAPHFalse)
End If
Next
End If
End Sub 
10.3.1. Setting a Read-Only Value
Some values can be set only once, so changing the value requires creating a new object. As an example, 
consdier:
A Calc sheet with combox controls (com.sun.star.awt.UnoControlComboBoxModel).
The controls are anchored to cells.
Each control bound to a cell.
Write a macro that finds each combobox and bind it to the cell in which it is anchored.
The obvious way to change the bound cell is to access and change the bound cell doing something like the 
following code that fails because ValueBinding is read-only:
' BoundCell is a struct, so copy the value out, change it and write it back.
oBoundCell = oControlDataModel.ValueBinding.BoundCell
oBoundCell.Column = 6
oBoundCell.Row = 6
oBoundCell.Sheet = 0
oControlDataModel.ValueBinding.BoundCell = oBoundCell
If you create a new value binding object and try to set the BoundCell property, this still fails. The value 
binding object must be initialized with the bound cell value, and it cannot be changed again:
Dim arg(0) as new com.sun.star.beans.NamedValue 'not a PropertyValue, a Named Value.
Dim oCellAddress As new com.sun.star.table.CellAddress
oCellAddress.Column = 6
oCellAddress.Row=13
oCellAddress.Sheet=0
arg(0).Name = "BoundCell"
arg(0).Value = oCellAddress
oService = oDoc.createInstanceWithArguments("com.sun.star.table.CellValueBinding", arg)
oControlDataModel.ValueBinding = oService
Using CreateInstanceWithArguments allows the service to be created and values be set when the object is 
initialized. You can accomplish the same thing in two steps (instead of one) by creating the instance without 
arguments and calling the initialize method after creating the object.
236
10.4. Context
OpenOffice has “things” that are available by name. For example, the type description manager and the 
service manager. A context is a collection of name-value pairs that you can use to get these “things” by 
name. OOo maintains a default context that is available with the function GetDefaultContext. Although a 
context is required when a service is created, OOo Basic automatically uses the default context when calling 
CreateUnoService; yet another reason why OOo Basic is easier to use than other languages. 
Listing 215. View context element names.
MsgBox Join(GetDefaultContext().getElementNames(), CHR$(10)) 
10.5. Inspecting Universal Network Objects
While writing an OOo Basic macro, I don’t always understand the values returned from internal OOo 
functions — for example, inspecting the value returned by GetDefaultContext. I write test code to examine 
the return values so that I can make appropriate decisions. I then frequently add more test code to further 
inspect the returned object. The initial inspection uses routines that you probably know (see Table 90).
Table 90. Initial inspection routines.
Routine
Comment
IsMissing(obj)
Use this for optional arguments to see if they are missing.
IsNull(obj)
You cannot inspect a null object, but you know that it is null.
IsEmpty(obj)
You cannot inspect an empty object, but you know that it is empty.
IsArray(obj)
Use array-inspection methods to learn more about the array.
TypeName(obj)
Determine if this is a simple type such as a String or an Integer. If this is an 
Object, it is probably a UNO structure or a UNO service.
IsUnoStruct(obj)
Determine if this is a UNO structure.
The code in Listing 216 demonstrates an initial use of the functions in Table 90. 
Listing 216. Inspect the TextTables object on the current document.
Dim v
v = Thiscomponent.getTextTables()
Print IsObject(v)      'True
Print IsNull(v)        'False
Print IsEmpty(v)       'False
Print IsArray(v)       'False
Print IsUnoStruct(v)   'False
Print TypeName(v)      'Object
MsgBox v.dbg_methods   'This property is discussed later
If the returned object has a type name of Object and it isn’t a UNO structure, it is probably a UNO service. 
Use the HasUnoInterfaces function to determine if a UNO object supports a set of interfaces. The first 
argument is the object to test. The arguments following the first are a list of interface names. If all of the 
listed interfaces are supported, the function returns True, otherwise it returns False. More than one interface 
may be checked at the same time.
HasUnoInterfaces(obj, interface1)
HasUnoInterfaces(obj, interface1[, interface2[, interface3[, ...]]])
To distinguish between a UNO structure, an arbitrary object, and a UNO service, first check to see if the 
variable is an object. This is easily done using the TypeName function. If the TypeName contains the word 
237
Documents you may be interested
Documents you may be interested