mvc display pdf in view : Extract images from pdf software application dll windows html .net web forms 0131473816_book41-part61

wxString, Characters,and String Literals
wxWidgets has a 
wxChar
type which maps either to 
char
or 
wchar_t
depending
on  the  application  build  configuration  (Unicode  or  ANSI). As  already
mentioned, there is no need for a separate type for 
char
or 
wchar_t
strings
because 
wxString
stores  strings  using  the  appropriate  underlying  C  type.
Whenever  you  work  directly  with  strings  that  you  intend  to  use  with  a
wxWidgets  class, use 
wxChar
instead  of  char  or 
wchar_t
directly. Doing  so
ensures compatibility with both ANSI and Unicode build configuration with-
out complicated preprocessor conditions.
When using wxWidgets with Unicode enabled, standard string literals
are not the correct type: an unmodified string literal is always of type 
char*
.In
order for a string literal to be used in Unicode mode, it must be a wide charac-
ter constant, usually marked with an L. wxWidgets provides the 
wxT
macro
(identical to 
_T
) to wrap string literals for use with or without Unicode. When
Unicode is not enabled,
_T
is an empty macro, but with Unicode enabled, it
adds the necessary L for the string literal to become a wide character string
constant. For example:
wxChar ch = wxT(‘*’);
wxString s = wxT(“Hello, world!”);
wxChar* pChar = wxT(“My string”);
wxString s2 = pChar;
For more details about using Unicode in your applications, please see Chapter
16,“Writing International Applications.”
Basic wxString to C Pointer Conversions
Because there may be times when you need to access a 
wxString
’s data as a C
type for low-level processing, wxWidgets provides several accessors:
mb_str
returns a  C  string  representation of  the string, a 
const  char*
,
regardless of whether Unicode is enabled. In Unicode mode, the string is
converted, and data may be lost.
wc_str
returns a wide character representation of the string, a 
wchar_t
*,
regardless of whether Unicode is enabled. In ANSI mode, the string is
converted to Unicode.
c_str
returns a pointer to the string data (
const  char*
in ANSI mode,
const wchar_t
* in Unicode mode). No conversion takes place.
You can convert between 
std::string
and 
wxString
by means of 
c_str
,as
follows:
std::string str1 = wxT(“hello”);
wxString str2 = str1.c_str();
std::string str3 = str2.c_str();
Strings
375
Extract images from pdf - Select, copy, paste PDF images in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document
extract image from pdf c#; extract photos pdf
Extract images from pdf - VB.NET PDF Image Extract Library: Select, copy, paste PDF images in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support PDF Image Extraction from a Page, a Region on a Page, and PDF Document
extract image from pdf file; extract text from image pdf file
One trap when using 
wxString
is the implicit conversion operator to 
const char
*
.It is advised that you use 
c_str
to indicate clearly when the conversion is
done. The danger of this implicit conversion may be seen in the following code
fragment:
// converts the input string to uppercase, outputs it to the
// screen, and returns the result (buggy)
const char *SayHELLO(const wxString& input)
{
wxString output = input.Upper();
printf(“Hello, %s!\n”, output);
return output;
}
There are two nasty bugs in these four lines. The first is in the call to the
printf
function. The implicit conversion to a C string is automatically applied
by the compiler in the case of functions like 
puts
because the argument of 
puts
is known to be of the type 
const char *
.However, this is not done for 
printf
,
which is a function with a variable number of arguments whose types are
unknown. Such a call to 
printf
might do anything at all (including displaying
the correct string on screen), although  the most likely result is a program
crash.The solution is to use 
c_str
:
printf(wxT(“Hello, %s!\n”), output.c_str());
The second bug is that returning the variable named 
output
doesn’t work.The
implicit cast is used again, so the code compiles, but it returns a pointer to a
buffer belonging to a local variable that is deleted as soon as the function exits.
The solution to this problem is also easy: have the function return a 
wxString
instead of a C string. The corrected code looks like this:
// converts the input string to uppercase, outputs it to the
// screen, and returns the result (corrected)
wxString SayHELLO(const wxString& input)
{
wxString output = input.Upper();
printf(wxT(“Hello, %s!\n”), output.c_str());
return output;
}
Standard C String Functions
Because most programs use character strings, the standard C library provides
quite a few functions to work with them. Unfortunately, some of them have
376
Data Structure Classes Chapter 13
VB.NET PDF Text Extract Library: extract text content from PDF
Extract highlighted text out of PDF document. Image text extraction control provides text extraction from PDF images and image files.
extract pictures pdf; extract vector image from pdf
C# PDF Text Extract Library: extract text content from PDF file in
Ability to extract highlighted text out of PDF document. Image text extraction control provides text extraction from PDF images and image files.
extract images pdf; extract images pdf acrobat
rather counterintuitive behavior  (like 
strncpy,
which doesn’t always termi-
nate the resulting string with a NULL) or are considered unsafe with possible
buffer overflows. Moreover,some very useful functions are not standard at all.
This is why in addition to all 
wxString
functions, there are a few global string
functions that try to correct these problems:
wxIsEmpty
verifies whether the
string is empty (returning 
true
for NULL pointers),
wxStrlen
handles NULLs
correctly and returns 0 for them, and 
wxStricmp
is a platform-independent
version of  the case-insensitive  string  comparison  function known either as
stricmp
or 
strcasecmp
on different platforms.
The “
wx/string.h
”header also defines 
wxSnprintf
and 
wxVsnprintf
func-
tions  that  should  be  used  instead  of  the  inherently  dangerous  standard
sprintf
.The “n” functions use 
snprintf
,which does buffer size checks when-
ever possible. You may also use 
wxString::Printf
without worrying about the
vulnerabilities typically found in 
printf
.
Converting to and from Numbers
Programmers often need to convert between string and numeric representa-
tions of numbers,such as when processing user input or displaying the results
of a calculation.
ToLong(long* val, int base=10)
attempts to convert the string to a signed
integer in base 
base
.It returns 
true
on success, in which case the number is
stored in the location pointed to by 
val
,or 
false
if the string does not repre-
sent a valid number in the given base. The value of 
base
must be between 2
and 36, inclusive, or a special value 0, which means that the usual rules of C
numbers are applied: if the number starts with 0x, it is considered to be in
base 16; if it starts with 0-, it is considered to be in base 8, and in base 10 
otherwise.
ToULong(unsigned long*  val, int base=10)
works identically to 
ToLong
,
except that the string is converted to an unsigned integer.
ToDouble(double* val) 
attempts to convert the string to a floating point
number. It  returns 
true
on  success  (the  number  is  stored  in  the  location
pointed to by 
val
) or 
false
if the string does not represent such a number.
Printf(const wxChar* pszFormat, ...)
is similar to the C standard func-
tion 
sprintf
,enabling you to put information into a 
wxString
using standard C
string formatting. The number of characters written is returned.
static Format(const wxChar* pszFormat, ...)
returns a 
wxString
contain-
ing the results of calling 
Printf
with the passed parameters.The advantage of
Format
over 
Printf
is that 
Format
can be used to add to an existing string:
int n = 10;
wxString s = “Some Stuff”;
s += wxString::Format(wxT(“%d”),n );
operator<<
can be used to append an int, a float, or a double to a 
wxString
.
Strings
377
VB.NET PDF Page Extract Library: copy, paste, cut PDF pages in vb.
VB.NET: Extract All Images from PDF Document. This is an example that you can use it to extract all images from PDF document. ' Get page 3 from the document.
extract images from pdf c#; pdf image extractor
C# Create PDF from images Library to convert Jpeg, png images to
C#.NET Project DLLs for Conversion from Images to PDF in C#.NET Program. C# Example: Convert More than Two Type Images to PDF in C#.NET Application.
how to extract a picture from a pdf; pdf image text extractor
wxStringTokenizer
wxStringTokenizer
helps you to break a string into a number of tokens, replac-
ing and expanding the C function 
strtok
.To use it, create a 
wxStringTokenizer
object and give it the string to tokenize and the delimiters that separate the
tokens. By default,white space characters will be used.Then call 
GetNextToken
repeatedly until 
HasMoreTokens
returns 
false
.
wxStringTokenizer tkz(wxT(“first:second:third:fourth”), wxT(“:”));
while ( tkz.HasMoreTokens() )
{
wxString token = tkz.GetNextToken();
// process token here
}
By default,
wxStringTokenizer
will behave in the same way as 
strtok
if the
delimiters string contains only white space characters. Unlike the standard
functions, however, it will return empty tokens if appropriate for other non-
white space  delimiters. This  is  helpful  for  parsing  strictly formatted  data
where the number of fields is fixed but some of them may be empty, as in the
case of tab- or comma-delimited text files.
wxStringTokenizer
’s behavior is governed by the last constructor parame-
ter, which may be one of the following:
wxTOKEN_DEFAULT
: Default  behavior  as  described  previously; same  as
wxTOKEN_STRTOK
if the delimiter string contains only white space, and same
as 
wxTOKEN_RET_EMPTY
otherwise.
wxTOKEN_RET_EMPTY
:In this mode, the empty tokens in the middle of the
string will be returned. So 
a::b:
will be tokenized into three tokens 
a
,“”,
and 
b
.
wxTOKEN_RET_EMPTY_ALL
:In this mode, empty trailing tokens (after the last
delimiter character)  will  be  returned  as  well.
a::b:
will  contain  four
tokens: the same as 
wxTOKEN_RET_EMPTY
and another empty one as the last
one.
wxTOKEN_RET_DELIMS
:In this mode, the delimiter character after the end of
the current token is appended to the token (except for the last token,
which  has  no  trailing  delimiter). Otherwise, it  is  the  same  mode  as
wxTOKEN_RET_EMPTY
.
wxTOKEN_STRTOK
:In this mode, the class behaves exactly like the standard
strtok
function. Empty tokens are never returned.
wxStringTokenizer
has two other useful accessors:
CountTokens
returns  the  number  of  remaining  tokens  in  the  string,
returning 0 when there are no more tokens.
GetPosition
returns the current position of the tokenizer in the original
string.
378
Data Structure Classes Chapter 13
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Page: Extract, Copy and Paste PDF Pages. Easy to Use C# Code to Extract PDF Pages, Copy Pages from One PDF File and Paste into Others in C#.NET Program.
extract photos from pdf; extract pdf images
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Powerful .NET PDF image edit control, enable users to insert vector images to PDF file. Merge several images into PDF. Insert images into PDF form field.
extract jpeg from pdf; pdf image extractor c#
wxRegEx
wxRegEx
represents a regular expression. This class provides support for regu-
lar expression matching and replacement.
wxRegEx
is either built on top of the
system library (if it is available and has support for POSIX regular expres-
sions, which is the case for most modern Unix variants, including Linux and
Mac OS X) or uses the built-in library by Henry Spencer. Regular expressions,
as defined by POSIX, come in two variations: extended and basic.The built-in
library also adds an advanced mode, which is not available when using the
system library.
On platforms where a system library is available, the default is to use
the built-in library for Unicode builds, and the system library otherwise. Bear
in mind that Unicode is fully supported only by the built-in library. It is possi-
ble to override the default when building wxWidgets. When using the system
library  in  Unicode  mode, the  expressions  and  data  are  translated  to  the
default 8-bit encoding before being passed to the library.
Use 
wxRegEx
as you would use any POSIX regular expression processor.
Due  to  the  advanced  nature  and  specialized  uses  of  regular  expressions,
please see the wxWidgets documentation for a complete discussion and API
reference.
WX
A
RRAY
wxWidgets  provides a  dynamic array structure  using 
wxArray
,similar to C
arrays in that the member access time is constant. However, these arrays are
dynamic in the sense that they will automatically allocate more memory if
there is not enough of it for adding a new element.Adding items to the arrays
is also implemented in more or less constant time—but the price is pre-
allocating  the  memory  in  advance.
wxArray
also  provides  range  checking,
asserting in debug builds or silently returning in release builds (though your
program might get an unexpected value from array operations).
Array Types
wxWidgets has three different kinds of arrays. All derive from 
wxBaseArray,
which  works  with  untyped  data  and  cannot  be  used  directly. The  macros
WX_DEFINE_ARRAY
,
WX_DEFINE_SORTED_ARRAY,
and 
WX_DEFINE_OBJARRAY
are used to
define a new class deriving from it. The classes are referred to as 
wxArray
,
wxSortedArray,
and 
wxObjArray,
but you should keep in mind that no classes
with such names actually exist.
wxArray
is suitable for storing integer types and pointers, which it does
not treat as objects in any way—that is, the element referred to by the pointer
is not deleted when the element is removed from the array. It should be noted
that all of 
wxArray
’s functions are inline, so it costs nothing to define as many
wxArray
379
C# PDF Convert to Images SDK: Convert PDF to png, gif images in C#
Professional .NET library and Visual C# source code for creating high resolution images from PDF in C#.NET class. Cut and paste any areas in PDF pages to images.
extract jpg pdf; how to extract images from pdf in acrobat
VB.NET Create PDF from images Library to convert Jpeg, png images
VB.NET Guide for Converting Raster Images to PDF File Using VB.NET Sample Code. VB.NET Example of More than Two Images to PDF Conversion. This VB.
extract image from pdf acrobat; extract images from pdf files
380
Data Structure Classes Chapter 13
array types as you want (either in terms of the executable size or speed).This
class has one serious limitation: it can only be used for storing integral types
(
bool
,
char
,
short
,
int
,
long
,and their unsigned variants) or pointers (of any
kind). Data of type 
float
or 
double
should not be stored in a 
wxArray
.
wxSortedArray
is a 
wxArray
variant that should be used when you will be
searching the array frequently.
wxSortedArray
requires you to define an addi-
tional function for comparing two elements of the array element type and
always stores its items in the sorted order (according to the sort function).
Assuming that you search the array far less frequently than you add to it,
wxSortedArray
may  lead  to  huge  performance  improvements  compared 
to 
wxArray
.It should be noted that 
wxSortedArray
shares 
wxArray
’s type restric-
tion and should only be used for storing integral types or pointers.
wxObjArray
class treats its elements like objects. It can delete them when
they are removed from the array (invoking the correct destructor), and  it
copies  them  using  the  object’s  copy  constructor. The  definition  of  the
wxObjArray
arrays is split into two parts. First, you should declare the new
wxObjArray
class  using  the 
WX_DECLARE_OBJARRAY
macro. Second, you  must
include  the  file  defining  the  implementation  of  template  type
<wx/arrimpl.cpp>
and  define  the  array  class  with  the 
WX_DEFINE_OBJARRAY
macro from a point where the full declaration of the array elements class is
in scope. This technique will be demonstrated in the array sample code pre-
sented later in this chapter.
wxArrayString
wxArrayString
is an efficient container for storing 
wxString
objects and has the
same features as the other 
wxArray
classes.It is also very compact and doesn’t
take  more  space  than  a  C  array 
wxString[]
type  (
wxArrayString
uses  its
knowledge of internals of 
wxString
class to achieve this). All of the methods
available in the other 
wxArray
types are also available in 
wxArrayString
.
This class is used in the same way as other dynamic arrays, except that
no 
WX_DEFINE_ARRAY
declaration is needed for it—you can use 
wxArrayString
directly.When a string is added or inserted in the array,a copy of the string is
created, so the original string may be safely deleted. In general, there is no
need to worry about string memory management when using this class—it
will always free the memory it uses.
The references returned by 
Item
,
Last,
or 
operator[]
are not constant, so
the array elements may be modified in place:
array.Last().MakeUpper();
There is also a variant of 
wxArrayString
called 
wxSortedArrayString
that has
exactly the same methods as 
wxArrayString
,but always keeps its strings in
alphabetical  order.
wxSortedArrayString
uses binary  search  in  its 
Index,
which makes it much more efficient if you rarely add strings to the array but
search for them often. The 
Insert
and 
Sort
methods should not be used with
wxSortedArrayString
because they are likely to break the order of items.
Array Construction, Destruction, and Memory Management
Array classes are C++ objects and as such have the appropriate copy construc-
tors and assignment  operators. Copying  a 
wxArray
copies  the elements, but
copying a 
wxObjArray
copies the array’s items. However, for the sake of memory
efficiency, neither of these classes has a virtual destructor. It is not very impor-
tant for 
wxArray,
which has a trivial destructor, but it does mean that you
should avoid deleting 
wxObjArray
through a 
wxBaseArray
pointer and that you
should not derive your own classes from the array classes.
Automatic  array  memory  management  is  quite  trivial: the  array
starts  by  pre-allocating  some  minimal  amount  of  memory  (defined  by
WX_ARRAY_DEFAULT_INITIAL_SIZE
). When further new items exhaust previously
allocated  memory, the array reallocates itself, adding 50% of the  currently
allocated  amount, but  no  more  than 
ARRAY_MAXSIZE_INCREMENT
. The 
Shrink
method deallocates any extra memory. The 
Alloc
method can be quite useful if
you know in advance how many items you are going to put in the array, and
using it will prevent the array code from reallocating the memory more often
than needed.
Array Sample Code
The  array  sample  presented  here  shows the  most  complex  case, using  a
wxObjArray
to  store custom  objects. Using  a 
wxArray
for  primitive  types  or
pointers would work identically in terms of syntax and semantics, but the
wxArray
would never take ownership of the objects.
// Our data class to store in the array
class Customer
{
public:
int CustID;
wxString CustName;
};
// this part might be in a header or source (.cpp) file
// declare our array class:
// this macro declares and partly implements CustomerArray class
// (which derives from wxArrayBase)
WX_DECLARE_OBJARRAY(Customer, CustomerArray);
// the only requirement for the rest is to be AFTER the full
// declaration of Customer (for WX_DECLARE_OBJARRAY forward
// declaration is enough), but usually it will be found in the
// source file and not in the header
#include <wx/arrimpl.cpp>
WX_DEFINE_OBJARRAY(CustomerArray);
wxArray
381
382
Data Structure Classes Chapter 13
// Used when sorting to compare objects
int arraycompare(Customer** arg1, Customer** arg2)
{
return ((*arg1)->CustID < (*arg2)->CustID);
}
// Show Array operations
void ArrayTest()
{
// Declare an instance of our array
CustomerArray MyArray;
bool IsEmpty = MyArray.IsEmpty(); // will be true
// Create some customers
Customer CustA;
CustA.CustID = 10;
CustA.CustName = wxT(“Bob”);
Customer CustB;
CustB.CustID = 20;
CustB.CustName = wxT(“Sally”);
Customer* CustC = new Customer();
CustC->CustID = 5;
CustC->CustName = wxT(“Dmitri”);
// Append two customers to the array
MyArray.Add(CustA);
MyArray.Add(CustB);
// Insert last customer into arbitrary place in the array
// The array will not own this CustC object, it will own a copy
MyArray.Insert(*CustC, (size_t)0);
int Count = MyArray.GetCount(); // will be 3
// If not found, wxNOT_FOUND is returned 
int Index = MyArray.Index(CustB); // will be 2
// Process each customer in the array
for (unsigned int i = 0; i < MyArray.GetCount(); i++)
{
Customer Cust = MyArray[i]; // or MyArray.Item(i);
// Process Customer
}
// Sort the customers according to the sort function
MyArray.Sort(arraycompare);
// Remove Customer A from the array, but do not delete
Customer* pCustA = MyArray.Detach(1);
// We must deallocate the object ourself if using Detach
delete pCustA;
// Remove will also delete the Customer object
MyArray.RemoveAt(1);
// Clears the array, deleting all objects
MyArray.Clear();
// The array never owned this object
delete CustC;
}
WX
L
IST AND WX
N
ODE
The 
wxList
class is a doubly linked list that can store data of an arbitrary type.
wxWidgets requires that you explicitly define a new list type for each type of
list data, providing strong type checking for the list’s data type. The 
wxList
class also allows you to optionally specify a key type for primitive lookups (see
the 
wxHashMap
section if you need a structure with fast random access).
The 
wxList
class makes use of an abstract 
wxNode
class.When you define a
new list, a new node type deriving from 
wxNodeBase
is also created, providing
type-safe node operations. The most important methods of the node class are
the self-explanatory 
GetNext
,
GetPrevious,
and 
GetData
,which provide access to
the next node, the previous node, and the current node’s data.
The only remarkable operation for a 
wxList
is data deletion. By default,
removing a  node does  not delete  the  data  being stored by that  node. The
DeleteContents
method allows you to change this behavior and set the data
itself to be deleted along with the nodes. If you want to empty a list of all data
and delete the data, be sure to call 
DeleteContents
with 
true
before calling
Clear
.
Rather than rehash the contents of the manual, a small but comprehen-
sive code example shows the 
wxList
methods as well as how to create and use
your custom list type. Note that the 
WX_DECLARE_LIST
macro would typically
appear in a header file, while the 
WX_DEFINE_LIST
macro would almost always
appear in a source file.
// Our data class to store in the list
class Customer
{
public:
int CustID;
wxString CustName;
};
// this part might be in a header or source file
// declare our list class:
// this macro declares and partly implements CustomerList class
// (which derives from wxListBase)
WX_DECLARE_LIST(Customer, CustomerList);
// the only requirement for the rest is to be AFTER the full
// declaration of Customer (for WX_DECLARE_LIST forward declaration
// is enough), but usually it will be found in the source file and
// not in the header
wxList and wxNode
383
#include <wx/listimpl.cpp>
WX_DEFINE_LIST(CustomerList);
// Used for sorting to compare objects
int listcompare(const Customer** arg1, const Customer** arg2)
{
return ((*arg1)->CustID < (*arg2)->CustID);
}
// Show List operations
void ListTest()
{
// Declare an instance of our list
CustomerList* MyList = new CustomerList();
bool IsEmpty = MyList->IsEmpty(); // will be true
// Create some customers
Customer* CustA = new Customer;
CustA->CustID = 10;
CustA->CustName = wxT(“Bob”);
Customer* CustB = new Customer;
CustB->CustID = 20;
CustB->CustName = wxT(“Sally”);
Customer* CustC = new Customer;
CustC->CustID = 5;
CustC->CustName = wxT(“Dmitri”);
// Append two customers to the list
MyList->Append(CustA);
MyList->Append(CustB);
// Insert last customer into arbitrary place in the list
MyList->Insert((size_t)0, CustC);
int Count = MyList->GetCount(); // will be 3
// If not found, wxNOT_FOUND is returned 
int index = MyList->IndexOf(CustB); // will be 2
// Customized node holds our customized data
CustomerList::Node* node = MyList->GetFirst();
// Traverse the nodes and process the customers
while (node)
{
Customer* Cust = node->GetData();
// Process Customer
node = node->GetNext();
}
// Returns the node at the specified position
node = MyList->Item(0);
// Sort the customers according to the sort function
MyList->Sort(listcompare);
384
Data Structure Classes Chapter 13
Documents you may be interested
Documents you may be interested