asp.net mvc display pdf : Change font size in pdf file application Library tool html .net web page online Manning%20-%20Code%20Generation%20in%20Action11-part1330

82
CHAPTER 4
B
UILDING
SIMPLE
GENERATORS
replacement sections. Our code does not do this because the example was too
simple. However, there is an advantage to being able to specify global options
embedded in the C file that will affect how the code is generated. These options
would not be replaced during generation; they would only set flags that would
change the style of code that is generated.
• Develop the code replacer—The next step is to build the code replacement regular
expressions. These are the expressions that will find the special markup sections
within the input file.
• Develop the templates from the test code—Once you have found the special
markup, you can spend time building the templates that will build the output
code. In our example code, we didn’t use a template because our generator was
too simple. For more complex generators, you can use a template-based
approach. To create the templates, use the test code that you developed at the
beginning of this process as a basis.
• Develop the output code builder—The last step is to merge the code replacer and
the output code builder. Once this is completed, you will have the finalized out-
put code in memory, and all you need to do is build the output file.
4.3
T
HE
MIXED
-
CODE
GENERATOR
MODEL
The mixed-code generator is a more practical implementation of the inline-code
expansion model. The generator reads the input file, makes some modifications to the
file, and then saves it back into the input file after backing up the original.
The potential uses are similar. Using special markup, the generator builds imple-
mentation code to match the requirements specified in the markup.
The key difference between the two models is the I/O flow. In the mixed-code
generation model, the input file is the output file. Mixed-code generation thus avoids
the debugging problems inherent with inline-code generation.
To demonstrate the difference between the two models, we’ll show the same
example from the inline-code expansion introduction implemented as mixed-code
generation, starting with the input:
void main( int argc, char *argv[] )
{
// sql-select: SELECT first, last FROM names
// sql-select-end
return;
}
Note that the <sql-select: …> syntax has been replaced with specially format-
ted comments.
The output of the generator is:
void main( int argc, char *argv[] )
{
Change font size in pdf file - Compress reduce PDF size in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
C# Code & .NET API to Compress & Decompress PDF Document
pdf page size; adjusting page size in pdf
Change font size in pdf file - VB.NET PDF File Compress Library: Compress reduce PDF size in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET PDF Document Compression and Decompression Control SDK
pdf compress; pdf compression settings
T
HE
MIXED
-
CODE
GENERATOR
MODEL
83
// sql-select: SELECT first, last FROM names
struct {
char *first;
char *last;
} *sql_output_1;
{
db_connection *db = get_connection();
sql_statement *sth = db->prepare( “SELECT first, last FROM names” );
sth->execute();
sql_output_1 = malloc( sizeof( *sql_output_1 ) * sth->count() );
for( long index = 0; index < sth->count(); index++ )
{
// ... marshal data
}
}
// sql-select-end
return;
}
Notice how the comments are maintained but that now the interior is populated with
code. The code that implements the requirements is specified in the comments. The
next time the generator is run, the interior will be removed and updated with newly
generated code.
Mixed-code generation has advantages over inline-code expansion:
• The use of comments avoids any syntax corruption with the surrounding code.
• By using comments in the original file, you can take advantage of special features
of any IDE, such as syntax coloring or code hints.
• You can use a debugger because the input file is the same as the output file. 
• The output code is located right next to the specification, so there is a clear visual
correspondence between what you want and how it is implemented.
4.3.1
Uses and examples
The potential uses for mixed-code generation are similar to those for inline-code
expansion. However, because of the proximity of the markup code to the generated
code you may think of using it for other types of utility coding, such as:
• Building rudimentary get/set methods
• Building marshalling code for user interfaces or dialog boxes
• Building redundant infrastructure code, such as C++ copy constructors or
operator= methods.
As we mentioned earlier, the major difference between inline-code generation and
mixed-code generation is the flow between the input and the output. Figure 4.15
shows the flow for mixed-code generation. As you can see, the generation cycle uses the
source code as both the input and the output. This is the same code that is sent to the
compiler and used as production code.
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
Allow users to add comments online in ASPX webpage. Able to change font size in PDF comment box. Able to save and print sticky notes in PDF file.
adjust size of pdf in preview; change page size pdf acrobat
C# PDF insert text Library: insert text into PDF content in C#.net
existing scanned PDF text. Ability to change text font, color, size and location and output a new PDF document. XDoc.PDF for .NET
change font size in fillable pdf form; can a pdf file be compressed
84
CHAPTER 4
B
UILDING
SIMPLE
GENERATORS
It is the responsibility of the generator to retain a backup of the original code before
replacing it with the newly generated code. When you use this model, make sure that
you manage the backups and have a reliable source code control system.
Our first example of the mixed-code generation type will build print statements.
Here is the input file for our example:
int main( int argc, char *argv[] )
{
// print Hello World
// print-end
return 0;
}
We’ve changed the <…> syntax into comments. There are two reasons for this change.
First, the code is compilable both before and after generation. Second, the comments
are maintained between generation cycles so that the generator knows which parts of
the code to maintain. The output of the generator, which is in the same file as the
input, is shown here:
int main( int argc, char *argv[] )
{
// print Hello World
printf("Hello World");
// print-end
return 0;
}
The original comments are retained and the implementation code has been put in-
between the start and end comments.
Do you need start and end comments? Yes. You need a predictable ending marker
for the regular expression. Otherwise, you would not know which code belonged to
the generator and therefore could be replaced. You could end up replacing the
contents of the file from the starting marker to the end of the file.
Source Code
Mixed-Code
Generator
Source Code
Compiler
Executable
Figure 4.15
The inputs and output flow 
for a mixed-code generator
C# PDF Field Edit Library: insert, delete, update pdf form field
Able to add text field to specified PDF file position in C#.NET class. Support to change font size in PDF form. Able to delete form fields from adobe PDF file.
pdf change font size; reduce pdf file size
C# PDF Text Box Edit Library: add, delete, update PDF text box in
Support to change font color in PDF text box. Ability to change text size in PDF text box. Adding text box is another way to add text to PDF page.
best way to compress pdf files; best way to compress pdf file
T
HE
MIXED
-
CODE
GENERATOR
MODEL
85
Listing 4.13 contains the code that implements our simple mixed-code generator.
require "ftools"
unless ARGV[0]
print "mc1 usage: mc1 file.c\n"
exit
end
fh = File.open( ARGV[0] )                                               
text = fh.read()                                                        
fh.close                                                                
text.gsub!( /(\/\/\s*print\s+)(.*?)\n(.*?)(\/\/\s*print-end\n)/m ) {    
code = "printf(\"#{$2}\");\n"                                         
$1 + $2 + "\n" + code + $4                                            
}
File.copy( ARGV[0], "#{ARGV[0]}.bak" )               
File.open( ARGV[0], "w").write( text )             
q
This regular expression finds the // print … and // print-end markers and all
of the content between the two. The // print text goes into $1; the print specifica-
tion goes into $2. The generated code in the middle, if it is there, goes into $3, and the
// print-end goes into $4.
The regular expression is shown in exploded form in figure 4.16.
w
This creates a printf call from the string that was specified in the comment.
e
This puts the expression back together by adding the code text to the $1,
$2, and $4
groups that we preserved from the regular expression.
Listing 4.13 3 Mixed-code generator 1: building printfs
Reads the 
input file
Returns the replacement code
e
Creates the code
w
Searches for
start and
end markers
q
Backs up the original file
Writes the new file
(\/\/\s*print)(.*?)\n(.*?)(\/\/\s*print-end\n)
Forwardslashes
$1
$2
$4
Zeroormorewhitespacecharacters
The'print'text
Anything
Forwardslashes
Zeroormorewhitespacecharacters
The'print-end'text
Acarriage
return
$3
Acarriagereturn
Figure 4.16 6 The regular expression that finds the special markup comments
C# PDF Annotate Library: Draw, edit PDF annotation, markups in C#.
Able to edit and change PDF annotation properties such as font size or color. Abilities to draw markups on PDF document or stamp on PDF file.
300 dpi pdf file size; .pdf printing in thumbnail size
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
PDF document, keeps the elements (like images, tables and chats) of original PDF file and maintains the original text style (including font, size, color, links
change file size of pdf; pdf file size limit
86
CHAPTER 4
B
UILDING
SIMPLE
GENERATORS
4.3.2
Developing the generator
Figure 4.17 shows a simple development process for building a mixed-code generator.
As you can see, this is very similar to the process for developing an inline-
code expander: 
• Build the test code—First, build the code you want to see come out of the genera-
tor. That means writing some special markup comments and also identifying the
code to be generated.
• Design the generator—Sketch out the code flow for the generator.
• Develop the input parser—If you want to include any options that you can specify
in the input file, this is the time to implement the parsing for that. You need to
develop the code that reads the input file and scans for any options that will be
used to modify the behavior of the generator. Our earlier example doesn’t have
any options, but you could imagine that there might be an option for specifying a
custom procedure instead of printf.
• Develop the code replacer—Next, build the regular expression that will read the
replacement sections. This expression should find the starting and ending blocks,
as well as the arguments and the code in the interior. The example code shows a
typical regular expression for this purpose.
• Develop the templates from the test code—Now that you have identified replace-
ment regions, you need to develop the code that will populate them with the
generated code. The example code is so simple that all you need is to do is some
string formatting to build the printf statement. If the requirements of your
generator are more complex, you may want to use some of the ERb templating
techniques shown in chapter 3, “Code generation tools.”
• Develop the output code builder—The final step is to merge the code replacer with
the output code builder to create the final output code. Then you need to back
up the original file and replace it with the newly generated code.
BuildTestCode
DesignGenerator
DevelopTemplates
FromTestCode
DevelopInputParser
DevelopOutputCode
Builder
DevelopCode
Replacer
Figure 4.17  
The design and implementation steps 
for developing a mixed-code generator
C# PDF File Split Library: Split, seperate PDF into multiple files
RasterEdge.Imaging.Drawing.dll. RasterEdge.Imaging.Font.dll. This C# sample codes explain how to split a PDF file into multiple ones by output PDF file size.
pdf change page size; best way to compress pdf
VB.NET PDF File Split Library: Split, seperate PDF into multiple
RasterEdge.Imaging.Drawing.dll. RasterEdge.Imaging.Font.dll. This VB.NET sample codes explain how to split a PDF file into multiple ones by output PDF file size.
change paper size in pdf; change font size in pdf fillable form
T
HE
PARTIAL
-
CLASS
GENERATOR
MODEL
87
4.4
T
HE
PARTIAL
-
CLASS
GENERATOR
MODEL
The partial-class generation model is the first of the code generators to build code from
an abstract model. The previous generators used executable code (e.g., C, Java, C++,
SQL) as input. This is the first generator to use an abstract definition of the code to
be created as input. Instead of filtering or replacing code fragments, the partial-class
generation model takes a description of the code to be created and builds a full set of
implementation code.
The difference between this model and tier generation is that the output of a partial-
class generator should be used in conjunction with some derived classes that will aug-
ment and override the output. Both the base class and the derived class are required
to create the fully functioning production form. Tier generation requires no such
derived classes because it takes responsibility for building and maintaining all of the
code for the tier.
Partial-class generation is a good starting point for tier generation. The advantage
of building only part of a class is that you have the ability to override the logic in the
generated classes if your business logic has custom requirements that are not covered
by the generator. Then, as you add more functionality to the generator, you can
migrate the custom code from the user-derived classes back into the generated classes.
4.4.1
Uses and examples
Here are some common uses for partial-class generation:
• Building data access classes that you can override to add business logic
• Developing basic data marshalling for user interfaces
• Creating RPC layers that can be overridden to alter behavior
Figure 4.18 shows the I/O flow using a definition file as the source of the base class
structure information.
Definition File
Partial-Class
Generator
Output Base Class
Source Code
Compiler
Executable
Templates
Derived Class Custom
Source Code
Figure 4.18  A partial-class generator using a definition file for input. 
Note that the output of the generator relates to the handwritten code.
88
CHAPTER 4
B
UILDING
SIMPLE
GENERATORS
In a partial-class generation model, your application code should never create
instances of the base classes directly—you should always instantiate the derived classes.
This will allow the partial-class generator to transition to a full-tier generator by
generating the derived classes directly and removing the original base classes from
the project. 
Let’s look an example. This partial-class generator is closely related to code
munger 6. Both generators are building classes for structured storage based on a
defined set of the required fields. The output of the generator is a set of classes based
on the contents of a simple text definition file, shown here: 
Person:first,middle,last
This small test file specifies one class, 
Person
, which has fields named first, middle,
and last. We could have specified more classes by adding extra lines, but just having one
class keeps the example simple.
The output class, Person, is shown here:
public class PersonBase {
protected String _first;
protected String _middle;
protected String _last;
public PersonBase()
_first = new String();
_middle = new String();
_last = new String();
}
public String getFirst() { return _first; }
public void setFirst( String value ) { _first = value; }
public String getMiddle() { return _middle; }
public void setMiddle( String value ) { _middle = value; }
public String getLast() { return _last; }
public void setLast( String value ) { _last = value; }
}
T
HE
PARTIAL
-
CLASS
GENERATOR
MODEL
89
Listing 4.14 shows the code for the generator.
require "erb/erb"
File.open( "fields.txt" ).each_line { |line|   
( class_name, field_text ) = line.split( ":" )                   
fields = field_text.strip.split( "," )                           
erb = ERb.new( File.open( "field_class.template.java" ).read )   
new_code = erb.result( binding )                                 
print "Creating #{class_name}Base.java\n"                        
File.open( "#{class_name}Base.java", "w" ).write( new_code )     
}
q
The split method splits a string into an array on the specified delineator. In this case,
we use the : character as a delineator. The two elements of the string are then put into
the class_name and field_text variables.
w
After you have the 
field_text
, you want to break it up into an array of
fields.
Use the split method again to break up the string, using the comma character as a
delineator.
e
Here you create an ERb object with the contents of the text template. Then, invoke the
template using the result method. Pass in the variables from the current scope using
the binding method.   
The t1.rb generator uses one template, field_class.template.java:
public class <%= class_name %>Base {       
<% fields.each { |field| %>                              
protected String _<%= field %>;<% } %>                 
public <%= class_name %>Base()                         
{ <% fields.each { |field| %>                          
_<%= field %> = new String();<% } %>                 
                                                     
<% fields.each { |field| %>                              
public String get<%= field.capitalize %>() { return _<%= field %>; }
public void set<%= field.capitalize %>( String value ) { _<%= field %> = 
value; }
<% } %>
}
q
Here you iterate through each field and create a String instance variable for the field.
w
In the constructor, this code replaces the class name and then creates calls to new for
each field.
Listing 4.14 4 Partial-class generator: building structure classes from a CSV file
Creates the 
new file
Splits the fields into an array
w
Reads the class name and fields
q
e
Reads each line of the input file
Runs the ERb template
Creates the get and set methods
e
Creates the instance variables
q
Creates the constructor
w
Adds the class name
90
CHAPTER 4
B
UILDING
SIMPLE
GENERATORS
e
Finally, this code iterates through each field to create get and set routines with the right
field name.
4.4.2
Developing the generator
The example process flow shown in figure 4.19 could be used to develop a partial-
class generator.
Let’s examine these steps in detail:
• Build the base class test code—First, design and build the base class you want the
generator to create.
• Build the derived class test code—Next, build the derived class that will use the
base class as a test case. You should also build the definition file that specifies
the base class. The generator will take this file as input.
• Design the generator—After building the input, output, and definition files, you
need to spend some time creating a simple design for the generator.
• Develop the input parser—Your first implementation step is to develop the parser
that will read the definition file and store any elements that are required by
the generator.
• Develop the templates from the test code—The next step is to take your original
base class code and to turn it into an ERb template for use by the generator.
• Develop the output code builder—The final step is to merge the input parser
with the template invocation code and to write the code that will create the out-
put files.
4.5
T
HE
TIER
GENERATOR
MODEL
A tier generator builds all of the code for one tier or section of an application. The most
common example is the constructor of a database access layer tier of a web or client/
server application. In this section, we show several forms of a very basic tier generator.
You can use the code here as the basis for your tier generator.
BuildBaseClassTest
Code
DesignGenerator
DevelopTemplates
FromTestCode
DevelopInputParser
DevelopOutputCode
Builder
BuildDerivedClass
TestCode
Figure 4.19
A set of design and implementation steps 
for building a partial-class generator
T
HE
TIER
GENERATOR
MODEL
91
4.5.1
Uses and examples
Besides building database access layers, there are a number of possible uses for a tier
generator. These include creating:
• The RPC layer of an application that exports a web services interface
• The stub code in a variety of different languages for your RPC layer
• The dialog boxes for a desktop application.
• The stored procedure layer for managing access to your database schema
• Data export, import, or conversion layers
The input to a tier generator is a definition file from which it gathers all of the informa-
tion required to build the complete code for the tier. The basic I/O flow is shown in
figure 4.20.
The generator takes a definition file, which contains enough information to build
all of the classes and functions of the tier. It then uses this information in conjunction
with a reservoir of templates to build the output source code. This output code is pro-
duction ready and waiting for integration into the application.
Our first example of tier generator builds structure classes from XML. It is very
closely related to the partial-class generator example. The only difference is the name
of the classes that it generates and the format of the definition file. At the implemen-
tation level, the two types of generators are very similar—it’s in the roles of the two
types of generators that there is a larger divergence.
The role of the tier generator is to take responsibility for all of the code in the tier.
The partial-class generator model opts instead to take partial responsibility for the tier
and then lets the engineer create the rest of the derived classes that will complete the
functionality for the tier.
This structure generator uses XML to specify the classes and their fields, as opposed
to the simple text file in the partial-class generator version. The XML version of the
same file used in the original generator is shown here:
DefinitionFile
TierGenerator
OutputSourceCode
Compiler
Executable
Templates
Figure 4.20
The input and output flow 
for a tier generator
Documents you may be interested
Documents you may be interested