how to convert pdf to image using itextsharp in c# : Create secure pdf online software SDK cloud windows .net wpf class Official%20Python%20Manual%20of%20Python%202.7.6%20320-part1760

To use color, you must call the 
start_color()
function soon after calling 
initscr()
, to
initialize  the  default  color  set  (the 
curses.wrapper.wrapper()
function  does  this
automatically). Once that’s done, the 
has_colors()
function returns TRUE if the terminal
in use can actually display color. (Note: curses uses the American spelling ‘color’, instead
of the Canadian/British spelling ‘colour’. If you’re used to the British spelling, you’ll have to
resign yourself to misspelling it for the sake of these functions.)
The curses library maintains a finite number of color pairs, containing a foreground (or
text) color and a background color. You can get the attribute value corresponding to a
color pair with the 
color_pair()
function; this can be bitwise-OR’ed with other attributes
such  as 
A_REVERSE
, but again, such combinations are not guaranteed to work on all
terminals.
An example, which displays a line of text using color pair 1:
stdscr.addstr("Pretty text", curses.color_pair(1))
stdscr.refresh()
As  I  said  before,  a  color  pair  consists  of  a  foreground  and  background  color.
start_color()
initializes 8 basic colors when it activates color mode. They are: 0:black,
1:red, 2:green, 3:yellow, 4:blue, 5:magenta, 6:cyan, and 7:white. The curses module
defines  named  constants  for  each  of  these  colors: 
curses.COLOR_BLACK
,
curses.COLOR_RED
, and so forth.
The 
init_pair(n, f, b)
function changes the definition of color pair n, to foreground
color f and background color b. Color pair 0 is hard-wired to white on black, and cannot
be changed.
Let’s put all this together. To change color 1 to red text on a white background, you would
call:
curses.init_pair(1, curses.COLOR_RED, curses.COLOR_WHITE)
When you change a color pair, any text already displayed using that color pair will change
to the new colors. You can also display new text in this color with:
stdscr.addstr(0,0"RED ALERT!", curses.color_pair(1))
Very fancy terminals can change the definitions of the actual colors to a given RGB value.
This lets you change color 1, which is usually red, to purple or blue or any other color you
like. Unfortunately, the Linux console doesn’t support this, so I’m unable to try it out, and
can’t provide any examples. You can check if your terminal can do this by calling
Create secure pdf online - 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
creating a secure pdf document; add security to pdf
Create secure pdf online - 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 security password; pdf secure signature
can_change_color()
, which returns TRUE if the capability is there. If you’re lucky enough
to have such a talented terminal, consult your system’s man pages for more information.
User Input
The curses library itself offers only very simple input mechanisms. Python’s support adds
a text-input widget that makes up some of the lack.
The most common way to get input to a window is to use its 
getch()
method. 
getch()
pauses and waits for the user to hit a key, displaying it if 
echo()
has been called earlier.
You can optionally specify a coordinate to which the cursor should be moved before
pausing.
It’s possible to change this behavior with the method 
nodelay()
 After 
nodelay(1)
,
getch()
for the window becomes non-blocking and returns 
curses.ERR
(a value of -1)
when no input is ready. There’s also a 
halfdelay()
function, which can be used to (in
effect) set a timer on each 
getch()
; if no input becomes available within a specified delay
(measured in tenths of a second), curses raises an exception.
The 
getch()
method returns an integer; if it’s between 0 and 255, it represents the ASCII
code of the key pressed. Values greater than 255 are special keys such as Page Up,
Home, or the cursor keys. You can compare the value returned to constants such as
curses.KEY_PPAGE
curses.KEY_HOME
, or 
curses.KEY_LEFT
. Usually the main loop of your
program will look something like this:
while 1:
= stdscr.getch()
if c == ord('p'):
PrintDocument()
elif c == ord('q'):
break # Exit the while()
elif c == curses.KEY_HOME:
= y = 0
The 
curses.ascii
module supplies ASCII class membership functions that take either
integer or 1-character-string arguments; these may be useful in writing more readable
tests for your command interpreters. It also supplies conversion functions that take either
integer  or  1-character-string  arguments  and  return  the  same  type. For  example,
curses.ascii.ctrl()
returns the control character corresponding to its argument.
There’s also a method to retrieve an entire string, 
getstr()
. It isn’t used very often,
because its functionality is quite limited; the only editing keys available are the backspace
key and the Enter key, which terminates the string. It can optionally be limited to a fixed
C# Create PDF Library SDK to convert PDF from other file formats
PDF document file creating library control, RasterEdge XDoc.PDF SDK for a reliable and quick approach for C# developers to create a highly-secure and industry
decrypt pdf password; decrypt pdf online
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
PDF Viewer enable users to view create PDF from multiple PDF Editor also provides C#.NET users secure solutions for to set a password to PDF online directly in
create secure pdf; change pdf document security
number of characters.
curses.echo() # Enable echoing of characters
# Get a 15-character string, with the cursor on the top line
= stdscr.getstr(0,0, 15)
The Python 
curses.textpad
module supplies something better. With it, you can turn a
window into a text box that supports an Emacs-like set of keybindings. Various methods
of 
Textbox
class support editing with input validation and gathering the edit results either
with or without trailing spaces. See the library documentation on 
curses.textpad
for the
details.
For More Information
This HOWTO didn’t cover some advanced topics, such as screen-scraping or capturing
mouse events from an xterm instance. But the Python library page for the curses
modules is now pretty complete. You should browse it next.
If you’re in doubt about the detailed behavior of any of the ncurses entry points, consult
the manual pages for your curses implementation, whether it’s ncurses or a proprietary
Unix vendor’s. The manual pages will document any quirks, and provide complete lists of
all the functions, attributes, and 
ACS_*
characters available to you.
Because the curses API is so large, some functions aren’t supported in the Python
interface, not because they’re difficult to implement, but because no one has needed
them yet. Feel free to add them and then submit a patch. Also, we don’t yet have support
for the menu library associated with ncurses; feel free to add that.
If you write an interesting little program, feel free to contribute it as another demo. We
can always use more of them!
The ncurses FAQ: http://invisible-island.net/ncurses/ncurses.faq.html
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » Python HOWTOs »
© Copyright
1990-2013, Python Software Foundation. 
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Nov 10, 2013. Found a bug
Created using Sphinx
1.0.7.
C# PDF Library SDK to view, edit, convert, process PDF file for C#
XDoc.PDF SDK provides users secure methods to protect PDF added to a specific location on PDF file page. In addition, you can easily create, modify, and delete
decrypt pdf without password; create secure pdf online
C# Word - Word Creating in C#.NET
Word SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
copy text from encrypted pdf; convert locked pdf to word doc
index
modules |
next |
previous |
Descriptor HowTo Guide
Author:
Raymond Hettinger
Contact:
<python at rcn dot com>
Contents
Descriptor HowTo Guide
Abstract
Definition and Introduction
Descriptor Protocol
Invoking Descriptors
Descriptor Example
Properties
Functions and Methods
Static Methods and Class Methods
Abstract
Defines descriptors, summarizes the protocol, and shows how descriptors are called.
Examines a custom descriptor and several built-in python descriptors including functions,
properties, static methods, and class methods. Shows how each works by giving a pure
Python equivalent and a sample application.
Learning about descriptors not only provides access to a larger toolset, it creates a
deeper understanding of how Python works and an appreciation for the elegance of its
design.
Definition and Introduction
In general, a descriptor is an object attribute with “binding behavior”, one whose attribute
access has been overridden by methods in the descriptor protocol. Those methods are
__get__()
__set__()
, and 
__delete__()
. If any of those methods are defined for an
object, it is said to be a descriptor.
The default behavior for attribute access is to get, set, or delete the attribute from an
object’s dictionary. For instance, 
a.x
has a lookup chain starting with 
a.__dict__['x']
,
then 
type(a).__dict__['x']
,  and  continuing  through  the  base  classes  of 
type(a)
Python » Python v2.7.6 documentation » Python HOWTOs »
C# PowerPoint - PowerPoint Creating in C#.NET
SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
add security to pdf file; change pdf security settings
C# Word - Word Create or Build in C#.NET
& thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry Create Word From PDF.
change security on pdf; decrypt pdf password online
excluding metaclasses. If the looked-up value is an object defining one of the descriptor
methods, then Python may override the default behavior and invoke the descriptor
method instead. Where this occurs in the precedence chain depends on which descriptor
methods were defined. Note that descriptors are only invoked for new style objects or
classes (a class is new style if it inherits from 
object
or 
type
).
Descriptors are a powerful, general purpose protocol. They are the mechanism behind
properties,  methods,  static  methods,  class  methods,  and 
super()
. They are used
throughout Python itself to implement the new style classes introduced in version 2.2.
Descriptors simplify the underlying C-code and offer a flexible set of new tools for
everyday Python programs.
Descriptor Protocol
descr.__get__(self, obj, type=None) --> value
descr.__set__(self, obj, value) --> None
descr.__delete__(self, obj) --> None
That is all there is to it. Define any of these methods and an object is considered a
descriptor and can override default behavior upon being looked up as an attribute.
If an object defines both 
__get__()
and 
__set__()
, it is considered a data descriptor.
Descriptors that only define 
__get__()
are called non-data descriptors (they are typically
used for methods but other uses are possible).
Data and non-data descriptors differ in how overrides are calculated with respect to
entries in an instance’s dictionary. If an instance’s dictionary has an entry with the same
name as a data descriptor, the data descriptor takes precedence. If an instance’s
dictionary has an entry with the same name as a non-data descriptor, the dictionary entry
takes precedence.
To make a read-only data descriptor, define both 
__get__()
and 
__set__()
with the
__set__()
raising an 
AttributeError
when called. Defining the 
__set__()
method with
an exception raising placeholder is enough to make it a data descriptor.
Invoking Descriptors
A descriptor can be called directly by its method name. For example, 
d.__get__(obj)
.
Alternatively, it is more common for a descriptor to be invoked automatically upon
RasterEdge.com General FAQs for Products
please copy and email the secure download link via the email which RasterEdge's online store sends. powerful & profession imaging controls, PDF document, image
decrypt pdf with password; pdf file security
XDoc.HTML5 Viewer for .NET, All Mature Features Introductions
be achieved through clicking "Open an online document" button search text-based documents, like PDF, Microsoft Office text selecting in order to secure your web
convert secure pdf to word; decrypt pdf
attribute access. For example, 
obj.d
looks up 
d
in the dictionary of 
obj
. If 
d
defines the
method 
__get__()
, then 
d.__get__(obj)
is invoked according to the precedence rules
listed below.
The details of invocation depend on whether 
obj
is an object or a class. Either way,
descriptors only work for new style objects and classes. A class is new style if it is a
subclass of 
object
.
For objects, the machinery is in 
object.__getattribute__()
which transforms 
b.x
into
type(b).__dict__['x'].__get__(b, type(b))
. The implementation works  through  a
precedence chain that gives data descriptors priority over instance variables, instance
variables priority over non-data descriptors, and assigns lowest priority to 
__getattr__()
if  provided. The full C implementation can be found in 
PyObject_GenericGetAttr()
in
Objects/object.c.
For classes, the machinery is in 
type.__getattribute__()
which transforms 
B.x
into
B.__dict__['x'].__get__(None, B)
. In pure Python, it looks like:
def __getattribute__(self, key):
"Emulate type_getattro() in Objects/typeobject.c"
= object.__getattribute__(self, key)
if hasattr(v, '__get__'):
return v.__get__(Noneself)
return v
The important points to remember are:
descriptors are invoked by the 
__getattribute__()
method
overriding 
__getattribute__()
prevents automatic descriptor calls
__getattribute__()
is only available with new style classes and objects
object.__getattribute__()
and 
type.__getattribute__()
make different calls to
__get__()
.
data descriptors always override instance dictionaries.
non-data descriptors may be overridden by instance dictionaries.
The object returned by 
super()
also has a custom 
__getattribute__()
method for
invoking descriptors. The call 
super(B, obj).m()
searches 
obj.__class__.__mro__
for
the 
base 
class 
A
immediately 
following 
B
and 
then 
returns
A.__dict__['m'].__get__(obj, B)
. If not a descriptor, 
m
is returned unchanged. If not in
the dictionary, 
m
reverts to a search using 
object.__getattribute__()
.
Note, in Python 2.2, 
super(B, obj).m()
would only invoke 
__get__()
if 
m
was a data
VB.NET Word: VB Tutorial to Convert Word to Other Formats in .NET
Word converting assembly toolkit also allows developers to create a fully platforms, then converting Word to a more secure document format PDF will be
pdf password security; copy locked pdf
C# Image: Zoom Image and Document Page in C#.NET Web Viewer
offers outstanding high performance and delivers secure & customizable bmp (bitmap), tiff / multi-page tiff, PDF, etc NET: Zoom In Image & Document Page Online.
decrypt password protected pdf; pdf security remover
descriptor. In Python 2.3, non-data descriptors also get invoked unless an old-style class
is involved. The implementation details are in 
super_getattro()
in Objects/typeobject.c
and a pure Python equivalent can be found in Guido’s Tutorial.
The details above show that the mechanism  for descriptors  is  embedded in the
__getattribute__()
methods  for 
object
type
 and 
super()
 Classes  inherit  this
machinery when they derive from 
object
or if they have a meta-class providing similar
functionality.  Likewise,  classes  can  turn-off  descriptor  invocation  by  overriding
__getattribute__()
.
Descriptor Example
The following code creates a class whose objects are data descriptors which print a
message for each get or set. Overriding 
__getattribute__()
is alternate approach that
could do this for every attribute. However, this descriptor is useful for monitoring just a
few chosen attributes:
class RevealAccess(object):
"""A data descriptor that sets and returns values
normally and prints a message logging their access.
"""
def __init__(self, initval=None, name='var'):
self.val = initval
self.name = name
def __get__(self, obj, objtype):
print 'Retrieving', self.name
return self.val
def __set__(self, obj, val):
print 'Updating' , self.name
self.val = val
>>> class MyClass(object):
x = RevealAccess(10, 'var "x"')
y = 5
>>> m = MyClass()
>>> m.x
Retrieving var "x"
10
>>> m.x = 20
Updating var "x"
>>> m.x
Retrieving var "x"
20
>>> m.y
5
The protocol is simple and offers exciting possibilities. Several use cases are so common
that they have been packaged into individual function calls. Properties, bound and
unbound methods, static methods, and class methods are all based on the descriptor
protocol.
Properties
Calling 
property()
is a succinct way of building a data descriptor that triggers function
calls upon access to an attribute. Its signature is:
property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
The documentation shows a typical use to define a managed attribute 
x
:
class C(object):
def getx(self): return self.__x
def setx(self, value): self.__x = value
def delx(self): del self.__x
= property(getx, setx, delx, "I'm the 'x' property.")
To see how 
property()
is implemented in terms of the descriptor protocol, here is a pure
Python equivalent:
class Property(object):
"Emulate PyProperty_Type() in Objects/descrobject.c"
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
if doc is None and fget is not None:
doc = fget.__doc__
self.__doc__ = doc
def __get__(self, obj, objtype=None):
if obj is None:
return self
if self.fget is None:
raise AttributeError("unreadable attribute")
return self.fget(obj)
def __set__(self, obj, value):
if self.fset is None:
raise AttributeError("can't set attribute")
self.fset(obj, value)
def __delete__(self, obj):
if self.fdel is None:
raise AttributeError("can't delete attribute")
self.fdel(obj)
def getter(self, fget):
return type(self)(fget, self.fset, self.fdel, self.__doc__)
def setter(self, fset):
return type(self)(self.fget, fset, self.fdel, self.__doc__)
def deleter(self, fdel):
return type(self)(self.fget, self.fset, fdel, self.__doc__)
The 
property()
builtin helps whenever a user interface has granted attribute access and
then subsequent changes require the intervention of a method.
For  instance,  a  spreadsheet  class  may  grant  access  to  a  cell  value  through
Cell('b10').value
. Subsequent improvements to the program require the cell to be
recalculated on every access; however, the programmer does not want to affect existing
client code accessing the attribute directly. The solution is to wrap access to the value
attribute in a property data descriptor:
class Cell(object):
. . .
def getvalue(self, obj):
"Recalculate cell before returning value"
self.recalc()
return obj._value
value = property(getvalue)
Functions and Methods
Python’s object oriented features are built upon a function based environment. Using non-
data descriptors, the two are merged seamlessly.
Class dictionaries store methods as functions. In a class definition, methods are written
using 
def
and 
lambda
, the usual tools for creating functions. The only difference from
regular functions is that the first argument is reserved for the object instance. By Python
convention, the instance reference is called self but may be called this or any other
variable name.
To support method calls, functions include the 
__get__()
method for binding methods
during attribute access. This means that all functions are non-data descriptors which
return bound or unbound methods depending whether they are invoked from an object or
a class. In pure python, it works like this:
class Function(object):
. . .
def __get__(self, obj, objtype=None):
"Simulate func_descr_get() in Objects/funcobject.c"
return types.MethodType(self, obj, objtype)
Running the interpreter shows how the function descriptor works in practice:
>>> class D(object):
def f(self, x):
return x
>>> = D()
>>> D.__dict__['f'# Stored internally as a function
<function f at 0x00C45070>
>>> D.# Get from a class becomes an unbound method
<unbound method D.f>
>>> d.# Get from an instance becomes a bound method
<bound method D.f of <__main__.D object at 0x00B18C90>>
The output suggests that bound and unbound methods are two different types. While
they  could  have  been  implemented  that  way,  the  actual  C  implementation  of
PyMethod_Type
in Objects/classobject.c  is  a  single  object  with  two  different
representations  depending  on  whether  the 
im_self
field  is  set or  is NULL (the C
equivalent of None).
Likewise, the effects of calling a method object depend on the 
im_self
field. If set
(meaning bound), the original function (stored in the 
im_func
field) is called as expected
with the first argument set to the instance. If unbound, all of the arguments are passed
unchanged  to  the  original  function.  The  actual  C  implementation  of
instancemethod_call()
is only slightly more complex in that it includes some type
checking.
Documents you may be interested
Documents you may be interested