mvc open pdf file in new window : How to extract text from pdf image file application SDK tool html .net windows online 0131473816_book45-part65

Creating and Copying Drawing Objects
Drawing objects, such as 
wxBrush
,
wxPen
,
wxColour
,
wxBitmap
,and 
wxImage
,can be
created on the stack or on the heap. Drawing code will often create such tem-
porary objects on the stack.These objects are reference-counted, which means
that you can use these objects (not pointers to them) with very little overhead:
when you assign a brush object to another brush variable, only a reference to
the internal data is copied, not  all the data itself. This behavior can  have
slightly unexpected side effects, though, when altering one object also alters
another. To avoid such an association between objects, create the copy using a
suitable constructor and explicitly assign the properties of the source object to
the copy. Here are some examples of reference-counted and “genuine” copying.
// Reference-counted copy
wxBitmap newBitmap = oldBitmap;
// Genuine copy
wxBitmap newBitmap = oldBitmap.GetSubBitmap(
wxRect(0, 0, oldBitmap.GetWidth(), oldBitmap.GetHeight()));
// Reference-counted copy
wxFont newFont = oldFont;
// Genuine copy
wxFont newFont(oldFont.GetPointSize(), oldFont.GetFamily(),
oldFont.GetStyle(), oldFont.GetWeight(),
oldFont.GetUnderlined(), oldFont.GetFaceName());
Initializing Your Application Object
Because your application object may be created before wxWidgets has initial-
ized all its internal objects, such as its color database and default fonts, take
care not to rely on such wxWidgets objects within your application constructor.
Instead, let these data members take a default value in the constructor and
initialize them in 
OnInit
.For example:
MyApp::MyApp()
{
// Do not set at this point
// m_font = *wxNORMAL_FONT;
}
bool MyApp::OnInit()
{
m_font = *wxNORMAL_FONT;
...
return true;
}
Memory Management Basics
415
How to extract text from pdf image file - 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
pdf image extractor online; extract image from pdf using
How to extract text from pdf image file - 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 photos pdf; some pdf image extract
Cleaning Up Your Application
You can override 
wxApp::OnExit
and place much of your cleanup code here. This
function is called after all application windows have been destroyed but just
before wxWidgets cleans up its own objects. However, some cleanup may need
to be done in your main window’s close handler, such as killing a process that
might try to write to a window.
D
ETECTING
M
EMORY
L
EAKS AND
O
THER
E
RRORS
Ideally, when your application exits, all objects will be cleaned up either by
your application or by wxWidgets itself, and no allocated memory will be left
for the operating system to clean up automatically.Although it may be tempt-
ing simply not to bother with some cleanup, you really should take care to
clean everything up yourself. Often such memory leaks are symptomatic of a
problem with your code that could lead to large amounts of memory being
wasted during a session. It’s much harder to go back and figure out where
leaks  are coming from after you have  moved on to another  aspect of your
application, so try to have zero tolerance for leaks.
So  how  do  you  know  whether  your  application  is  leaking  memory?
Various third-party memory-checking tools are available to do this and more,
and wxWidgets has a simple built-in memory checker. To use this checker for
your debug configuration, you need to set some switches in 
setup.h
(Windows)
or 
configure
(other platforms or GCC on Windows).
On Windows, these are:
#define wxUSE_DEBUG_CONTEXT 1
#define wxUSE_MEMORY_TRACING 1
#define wxUSE_GLOBAL_MEMORY_OPERATORS 1
#define wxUSE_DEBUG_NEW_ALWAYS 1
For configure, pass these switches:
--enable-debug --enable-mem_tracing --enable-debug_cntxt
There  are some restrictions to  this  system: it  doesn’t work  for MinGW or
Cygwin (at the time of writing), and you cannot use 
wxUSE_DEBUG_NEW_ALWAYS
if
you are using STL in your application or the CodeWarrior compiler.
If 
wxUSE_DEBUG_NEW_ALWAYS
is on, then all instances of the 
new
operator in
wxWidgets and your code will be defined to be 
new(__TFILE__,__LINE__)
,which
has been reimplemented to use custom memory allocation and deletion rou-
tines.To use this version of 
new
explicitly, without defining 
new
,use 
WXDEBUG_NEW
where you would normally write 
new
.
416
Memory Management, Debugging, and Error Checking Chapter 15
C# PDF Text Extract Library: extract text content from PDF file in
PDF file. Ability to extract highlighted text out of PDF document. Supports text extraction from scanned PDF by using XDoc.PDF for .NET Pro. Image text extraction
extract image from pdf c#; extract images from pdf files without using copy and paste
VB.NET PDF Text Extract Library: extract text content from PDF
Extract and get partial and all text content from PDF file. Extract highlighted text out of PDF document. Image text extraction control provides text extraction
how to extract images from pdf in acrobat; extract images from pdf files
The easiest way to use the memory checking system is to do nothing spe-
cial at all: just run your application in the debugger, quit the application, and
see if any memory leaks are reported. Here’s an example of a report:
There were memory leaks.
——- Memory dump ——-
.\memcheck.cpp(89): wxBrush at 0xBE44B8, size 12
..\..\src\msw\brush.cpp(233): non-object data at 0xBE55A8, size 44
.\memcheck.cpp(90): wxBitmap at 0xBE5088, size 12
..\..\src\msw\bitmap.cpp(524): non-object data at 0xBE6FB8, size 52
.\memcheck.cpp(93): non-object data at 0xBB8410, size 1000
.\memcheck.cpp(95): non-object data at 0xBE6F58, size 4
.\memcheck.cpp(98): non-object data at 0xBE6EF8, size 8
——- Memory statistics ——-
1 objects of class wxBitmap, total size 12
5 objects of class nonobject, total size 1108
1 objects of class wxBrush, total size 12
Number of object items: 2
Number of non-object items: 5
Total allocated size: 1132
This example tells us that a 
wxBrush
and a 
wxBitmap
were allocated but not
freed, along with some other objects whose class is unknown because they do
not have wxWidgets type information. In some IDEs, you can double-click on
the line with the error and see the source line at which the object was allo-
cated.This functionality is a very good first step in tracking down the cause of
the memory leak. For best results, add run-time type information (RTTI) to
any classes that are descendants of 
wxObject
.Add 
DECLARE_CLASS(class)
in your
class declaration and 
IMPLEMENT_CLASS(class, parentClass)
somewhere in your
implementation file.
The memory checking system also tries to catch memory overwrite and
double-deletion bugs. The allocation routines write a special signature for a
“good” block  of  memory  and  another  signature for  deleted  memory. If  the
application tries to delete a block without the signature, the problem will be
reported, as  will  a  deletion  that  occurs  when  the  block  has  already  been
deleted. This will make it easier to catch the kind of memory bugs that only
cause problems some time after the real error has occurred.
Using static members of the 
wxDebugContext
class, you can get a listing of
the current objects in the system with 
PrintClasses
or show a count of objects
and  non-objects  (those  without  wxWidgets  RTTI  information)  with
PrintStatistics
.Using 
SetCheckpoint,
you can tell 
wxDebugContext
to only show
statistics  from  the  checkpoint  onwards, ignoring  memory  allocations  done
prior to this point.For more details,see 
samples/memcheck
and the reference for
wxDebugContext
.
Detecting Memory Leaks and Other Errors
417
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Create high resolution PDF file without image quality losing in ASP.NET application. Add multiple images to multipage PDF document in .NET WinForms.
how to extract images from pdf; extract photos from pdf
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively.
extract image from pdf java; extract images from pdf online
Instead of using the basic system in wxWidgets, you may want to use a
commercial tool such as BoundsChecker, Purify, or AQtime, or a free alterna-
tive  such  as  StackWalker, ValGrind, Electric  Fence, or  MMGR  from  Fluid
Studios. If you are using Visual C++, wxWidgets uses the compiler’s standard
leak detection, which doesn’t report class names but gives you the line num-
bers. For best results, make sure 
wxUSE_DEBUG_NEW_ALWAYS
is set to
1
in 
setup.h
.
Because it redefines new, you might need to disable it if it causes problems
with other libraries.
F
ACILITIES FOR
D
EFENSIVE
P
ROGRAMMING
Often a bug will only surface some time after the logic error actually occurs. If
an inconsistent or invalid value isn’t detected early, the program can execute
thousands of lines of code before it crashes or you get mysterious results. You
can spend a lot of time trying to figure out the real cause of the error. However,
if you  add  regular  checks  to your code—for example, to  detect bad values
passed to functions—your code will end up being much more robust, and you
will save yourself (and your users) a potentially huge amount of trouble. This
technique is called defensive programming,and your classes and functions can
defend themselves both against improper use by other code and against inter-
nal logic  errors. Because most of  these checks  are compiled out  in release
builds, there is no overhead.
As you would expect, wxWidgets does a lot of error checking internally,
and you can use the same macros and functions in your own code. There are
three main families of  macros: variations of 
wxASSERT
,
wxFAIL,
and 
wxCHECK
.
wxASSERT
macros show an error message if the argument doesn’t evaluate to
true
;the checks only occur in debug builds.
wxFAIL
will always generate an
error  message and is  equivalent  to 
wxASSERT(false)
. These  checks  are  also
removed in the release build.
wxCHECK
checks that the condition is 
true
and
returns a given value if not. Unlike the others, occurrences of 
wxCHECK
remain
(but do not display a message) in release builds. These macros have variations
that let you display a custom error message in the assertion message box.
Here are some examples of using these macros.
// Add two positive numbers under 100
int AddPositive(int a, int b)
{
// Check if a is positive
wxASSERT(a > 0);
// Check if b is positive, with custom error message
wxASSERT_MSG(b > 0, wxT(“The second number must be positive!”));
int c = a + b;
418
Memory Management, Debugging, and Error Checking Chapter 15
VB.NET PDF insert image library: insert images into PDF in vb.net
VB.NET code to add an image to the inputFilePath As String = Program.RootPath + "\\" 1.pdf" Dim doc New PDFDocument(inputFilePath) ' Get a text manager from
extract pdf pages to jpg; pdf image extractor c#
C# PDF File Split Library: Split, seperate PDF into multiple files
Application. Best and professional adobe PDF file splitting SDK for Visual Studio .NET. outputOps); Divide PDF File into Two Using C#.
extract jpg pdf; extract text from image pdf file
// Return -1 if the result was not positive
wxCHECK_MSG(c > 0, -1, wxT(“Result must be positive!”));
return c;
}
You can also use 
wxCHECK2
and 
wxCHECK2_MSG
to execute an arbitrary operation if
the check failed instead of just returning a value.
wxCHECK_RET
can be used in
void
functions and returns no value. For less frequently used macros, such as
wxCOMPILE_TIME_ASSERT
and 
wxASSERT_MIN_BITSIZE
,please refer to the reference
manual.
Figure 15-1 shows the assertion dialog that appears when an assertion
condition has evaluated to 
false
.The user can stop the program (Yes), ignore
the warning (No), or ignore all further warnings (Cancel). If the program is
running under a debugger, stopping the program will cause a break in the
debugger, and you can navigate the call stack to see exactly where the problem
was and the values of variables at that point.
Error Reporting
419
Figure 15-1 Assertion alert
E
RROR
R
EPORTING
Sometimes you need to display messages on the console or in a dialog to help
with debugging, or when an error occurs that would not normally be detected
by application code. wxWidgets provides a range of logging functions for the
different ways in which you might want to use logging. For example, if alloca-
tion fails when trying to create a very large 
wxBitmap
,an error will be reported
in a dialog box using
wxLogError
(see Figure 15-2). Or if you simply want to
print the values of a function’s arguments on the debugger window, you can
use 
wxLogDebug
.Where the error actually appears (in a dialog, on the debugger
window, or on the standard error stream) depends on the name of the logging
function  used  and  also  on  the 
wxLog
“target” that  is  currently  active, as
described later.
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively.
extract jpeg from pdf; extract image from pdf file
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
When you have downloaded the RasterEdge Image SDK for also provided you with detailed PDF processing demo Imaging.Demo directory with the file name RasterEdge
pdf image text extractor; extract pictures pdf
420
Memory Management, Debugging, and Error Checking Chapter 15
All logging functions have the same syntax as 
printf
or 
vprintf
—that
is, they take the format string as the first argument and a variable number of
arguments or a variable argument list pointer. For example:
wxString name(wxT(“Calculation”));
int nGoes = 3;
wxLogError(wxT(“%s does not compute! You have %d more goes.”),
name.c_str(), nGoes);
The logging functions are as follows.
wxLogError
is the function to use for error messages that must be shown
to the user. The default behavior is to pop up a message box to inform the
user about the error. Why not just  use 
wxMessageBox
? Well, messages that
come from 
wxLogError
can be suppressed by creating an object of 
wxLogNull
and log errors are also queued up and shown in idle time in a single dialog.
So if a series of errors happens, the user won’t have to click on OK for each
and every error.
wxLogFatalError
is like 
wxLogError
,but it also terminates the program
with exit code 3 (using the standard 
abort
function). Unlike all the other log-
ging  functions, this  function  can’t  be  overridden  by  changing  the  log 
target.
wxLogWarning
is like 
wxLogError
,but the information is presented as a
warning, not an error.
wxLogMessage
is for all normal,informational messages.They also appear
in a message box by default.
wxLogVerbose
is  for  verbose output. Normally, the  messages  are sup-
pressed, but they can be activated by calling 
wxLog::SetVerbose
if the user
wants to know more details about the program’s progress.
wxLogStatus
is for status messages, which will be displayed in the status
bar of the active or specified 
wxFrame
,if it has one.
Figure 15-2 Log dialog
wxLogSysError
is mostly used by wxWidgets itself. It logs the specified
message  text as well as the  last system  error code  (
errno
or  the result  of
GetLastError
depending on the  platform)  and the corresponding  error mes-
sage. The second form of this function takes the error code explicitly as the
first argument.
wxLogDebug
is the function to use for debug output. It only displays the
message in debug mode (when the preprocessor symbol 
__WXDEBUG__
is defined)
and expands to nothing in release mode. Under Windows, you must either run
the  program  under  a  debugger  or  use  a  third-party  program  such  as
DebugView  from 
http://www.sysinternals.com
to  actually  see  the  debug 
output.
wxLogTrace
only does anything in debug builds, like 
wxLogDebug
.The rea-
son for making it a separate function is that usually there are a lot of trace
messages, so it makes sense to separate them from other debug messages.
Moreover, the second version of this function takes a trace mask as the first
argument, which enables you to further restrict the number of messages gen-
erated. For example, wxWidgets uses the 
mousecapture
mask internally. If you
add this string to the trace masks via 
wxLog::AddTraceMask
,you will see trace
messages when the mouse is captured.
void wxWindowBase::CaptureMouse()
{
wxLogTrace(wxT(“mousecapture”), wxT(“CaptureMouse(%p) “), this);
...
}
void MyApp::OnInit()
{
// Add mousecapture to the list of trace masks
wxLog::AddTraceMask(wxT(“mousecapture”));
...
}
You may be wondering, why not use C standard input/output functions or C++
streams? The short answer is that they’re good generic mechanisms, but they
are not really adapted for wxWidgets, whereas the log classes are. There are
three main advantages.
First,
wxLog
is portable. It is a common practice to use 
printf
statements
or 
cout
and 
cerr
C++ streams for writing information. Although this works
just fine under Unix, these messages go nowhere under Windows, where the
stdout
of graphical applications is not assigned to anything. Thus, you might
view 
wxLogMessage
as a simple substitute for 
printf
.
You can also redirect logging calls to 
cout
by writing:
wxLog *logger=new wxLogStream(&cout);
wxLog::SetActiveTarget(logger);
Error Reporting
421
422
Memory Management, Debugging, and Error Checking Chapter 15
There is also the possibility to redirect the output sent to 
cout
to a 
wxTextCtrl
by using the 
wxStreamToTextRedirector
class.
Second,
wxLog
is more flexible. The output of 
wxLog
functions can be redi-
rected  or  suppressed  entirely  based  on  their  importance, which  is  either
impossible or difficult to do with traditional methods. For example, only error
messages or only error messages and warnings might be logged, filtering out
all informational messages.
Third,
wxLog
is more complete. Usually, an error message should be pre-
sented to the user when some operation fails. Let’s take the simple but com-
mon case of a file error:suppose that you’re writing your data file on disk and
there is not enough space. The actual error might have been detected inside
wxWidgets code (say, in 
wxFile::Write
), so the calling function doesn’t really
know the exact reason of the failure; it only knows that the data file couldn’t
be written to the disk. However, as wxWidgets uses 
wxLogError
in this situa-
tion, the exact error code and the corresponding error message will be given to
the user.
Now we’ll describe how logging works, in case you need to use more than
the default behavior.
wxWidgets has the notion of a log target: it is just a class derived from
wxLog
.It implements the virtual functions of the base class, which are called
when a message is logged. Only one log target is active at any moment—the
one used by logging functions. The normal usage of a log object is to install it
as the active target with a call to 
wxLog::SetActiveTarget
,and it will be used
automatically by all subsequent calls to logging functions.
To create a new log target class,you only need to derive it from 
wxLog
and
implement one (or both) of 
DoLog
and 
DoLogString
.Implementing 
DoLogString
is  enough  if  you’re  happy  with  the  standard 
wxLog
message  formatting
(prepending 
Error
:or 
Warning
:and time-stamping) but just want to send the
messages somewhere else. You can override 
DoLog
to do whatever you want,
but you have to distinguish between the different message types yourself. See
src/common/log.cpp
for how wxWidgets does it.
There are some predefined classes deriving from 
wxLog
that you can use
without change, and looking at these classes might be helpful to show you
how to create a new log target class.
wxLogStderr
logs messages to the file pointer argument (
FILE*)
, using
stderr
if no argument was supplied.
wxLogStream
has the same functionality as
wxLogStderr
but uses 
ostream
and 
cerr
instead of 
FILE*
and 
stderr
.
wxLogGui
is the standard log target for wxWidgets applications and is
used by default. It provides the most reasonable handling of all types of mes-
sages for a given platform.
wxLogWindow
provides a “log console,” which collects all messages gener-
ated by the application and also passes them to the previously active log tar-
get. The log window frame has a menu that lets the user clear the log, close it
completely, or save all messages to a file.
wxLogNull
may be  used  to temporarily  suppress  output of  the logging
functions. As an example, trying to open a non-existent file will usually pro-
voke an error message, but if for some reason this is unwanted, just create an
instance of 
wxLogNull
on the stack. While the object is in scope, no errors will
be reported. You can use an extra pair of braces  to  create  the appropriate
scope. For example:
wxFile file;
// wxFile.Open() normally complains if file can’t be opened;
// we don’t want it to
{
wxLogNull logNo;
if ( !file.Open(“bar”) )
... process error ourselves ...
} // ~wxLogNull called, old log target restored
wxLogMessage(“...”); // ok
Log targets can also be combined: for example, you might want to redirect the
messages somewhere else (perhaps to a file) but also to process them as usual.
For this, you can use 
wxLogChain
and 
wxLogPassThrough
.For example:
// This implicitly sets the active log target
wxLogChain *logChain = new wxLogChain(new wxLogStderr);
// all the log messages are sent to stderr and also processed
// as usual
// don’t delete logChain directly as this would leave a dangling
// pointer as active log target; use SetActiveTarget instead
delete wxLog::SetActiveTarget(new wxLogGui); 
wxMessageOutputVersus wxLog
Sometimes,
wxLog
is not the most appropriate class to use,with its higher-level
functionality  such  as  time-stamping  and  delayed  log  messages. The
wxMessageOutput
class and its derivatives offer a low-level 
printf
replacement
that you can use in console and GUI applications.Use 
wxMessageOutput::Printf
where you would normally use 
printf
;for example, to write to standard error:
#include “wx/msgout.h”
wxMessageOutputStderr err;
err.Printf(wxT(“Error in app %s.\n”), appName.c_str());
You can also use 
wxMessageOutputDebug
to write to the debugger’s console or
standard error, depending on platform and whether the program is being run
Error Reporting
423
in the debugger. Unlike 
wxLogDebug
,these calls are not stripped out in release
mode. GUI  applications  can  use 
wxMessageOutputMessageBox
to  immediately
show the message in a dialog, not collating and delaying the messages as 
wxLog
does. There  is  also  a 
wxMessageOutputLog
class, which  passes  messages  to
wxLogMessage
.
As with 
wxLog
,
wxMessageOutput
has the concept of a current target, set
with 
wxMessageOutput::Set
and retrieved with 
wxMessageOutput::Get
.This tar-
get is set with an appropriate object when wxWidgets initializes: an instance
of 
wxMessageOutputStderr
for 
console 
applications,
and 
a
wxMessageOutputMessageBox
for GUI applications. wxWidgets makes use of this
object internally, for example in 
wxCmdLineParser
,as follows:
wxMessageOutput* msgOut = wxMessageOutput::Get();
if ( msgOut )
{
wxString usage = GetUsageString();
msgOut->Printf( wxT(“%s%s”), usage.c_str(), errorMsg.c_str() );
}
else
{
wxFAIL_MSG( _T(“no wxMessageOutput object?”) );
}
P
ROVIDING
R
UN
-T
IME
T
YPE
I
NFORMATION
In common  with  most  frameworks, wxWidgets provides  methods  to define
more RTTI than C++’s own RTTI.This is useful for making run-time decisions
based on an object’s type and for error reporting as we have seen in the last
section, and it also enables you to create objects dynamically simply by provid-
ing a string containing the name of the class. Only classes that have 
wxObject
as an ancestor class can have wxWidgets RTTI.
If  you  don’t  need  the  dynamic  creation  ability, use  the  macro
DECLARE_CLASS(class)
in the class declaration and 
IMPLEMENT_CLASS(class, base
Class)
in  the class  implementation file. If you  need dynamic creation, use
DECLARE_DYNAMIC_CLASS(class)
in the class declaration and 
IMPLEMENT_DYNAMIC_
CLASS(class, baseClass)
in the class implementation file. In the dynamic case,
you will also need to make sure there is a default constructor for the class; oth-
erwise  the compiler  will  complain when it comes  across  the  function  that
wxWidgets generates to create an object of this class.
Here’s an example of using RTTI to allow dynamic creation of objects.
class MyRecord: public wxObject
{
DECLARE_DYNAMIC_CLASS(MyRecord)
public:
424
Memory Management, Debugging, and Error Checking Chapter 15
Documents you may be interested
Documents you may be interested