c# pdf viewer open source : How to move pages in pdf acrobat control application system web page azure asp.net console World%20of%20Warcraft%20Programming%20(2nd%20Edition)21-part1818

Chapter 9
Working with Frames, Widgets, and Other Graphical Elements 169
<Texture file=“Interface\BankFrame\UI-BankFrame-TopRight“>
<Anchors>
<Anchor point=“TOPRIGHT“/>
</Anchors>
</Texture>
<Texture file=“Interface\BankFrame\UI-BankFrame-BotLeft“>
<Anchors>
<Anchor point=“BOTTOMLEFT“/>
</Anchors>
</Texture>
<Texture file=“Interface\BankFrame\UI-BankFrame-BotRight“>
<Anchors>
<Anchor point=“BOTTOMRIGHT“/>
</Anchors>
</Texture>
</Layer>
</Layers>
<Scripts>
<OnLoad function=“BagBuddy_OnLoad“/>
</Scripts>
</Frame>
</Ui>
How to move pages in pdf acrobat - re-order PDF pages in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Support Customizing Page Order of PDF Document in C# Project
rearrange pdf pages online; reorder pdf pages reader
How to move pages in pdf acrobat - VB.NET PDF Page Move Library: re-order PDF pages in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sort PDF Document Pages Using VB.NET Demo Code
how to move pdf pages around; change page order pdf acrobat
C# PDF Converter Library SDK to convert PDF to other file formats
manipulate & convert standard PDF documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat.
how to move pages around in pdf file; rearrange pages in pdf document
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. PowerPoint to PDF Conversion.
pdf reverse page order online; how to move pages in pdf
CH A P T E R
10
Saving Time with Frame
Templates
Chapter9 introducedtheconcept of usingframetemplates to save time.Rather
than specifying the same attributes and elements overandover again,youcan
create a single template and later inherit from it when creating new frames. In
this chapter you’ll create a frame template for the item slots in BagBuddy and
then create frames dynamically from the template.
Understanding Templates
Templates provide developers with an easy way to define common sets
of attributes and elements and then create multiple frames that utilize the
template,inheriting all of that setup. Say, for example, that you need to create
arow of three 16×16 buttons that contain a single texture. Without templates,
the code might look something like this:
<Button name=“Button1“>
<Size x=“16“ y=“16“/>
<Layers>
<Layer level=“BACKGROUND“>
<Texture name=“$parentIcon“ parentKey=“icon“>
<Color r=“1.0“ g=“1.0“ b=“1.0“/>
</Texture>
</Layer>
</Layers>
</Button>
<Button name=“Button2“>
<Size x=“16“ y=“16“/>
<Anchors>
<Anchor point=“TOPLEFT“ relativePoint=“TOPRIGHT“ relativeTo=“Button2“/>
171
C# Word - Word Conversion in C#.NET
Word documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Word to PDF Conversion.
reverse pdf page order online; change pdf page order online
C# Excel - Excel Conversion & Rendering in C#.NET
Excel documents in .NET class applications independently, without using other external third-party dependencies like Adobe Acrobat. Excel to PDF Conversion.
rearrange pdf pages in reader; pdf rearrange pages
172
Part II
Programming in World of Warcraft
</Anchors>
<Layers>
<Layer level=“BACKGROUND“>
<Texture name=“$parentIcon“ parentKey=“icon“>
<Color r=“1.0“ g=“1.0“ b=“1.0“/>
</Texture>
</Layer>
</Layers>
</Button>
<Button name=“Button3“>
<Size x=“16“ y=“16“/>
<Anchors>
<Anchor point=“TOPLEFT“ relativePoint=“TOPRIGHT“ relativeTo=“Button2“/>
</Anchors>
<Layers>
<Layer level=“BACKGROUND“>
<Texture name=“$parentIcon“ parentKey=“icon“>
<Color r=“1.0“ g=“1.0“ b=“1.0“/>
</Texture>
</Layer>
</Layers>
</Button>
Using frame templates, you could instead write the following:
<Button name=“MyButtonTemplate“ virtual=“true“>
<Size x=“16“ y=“16“/>
<Layers>
<Layer level=“BACKGROUND“>
<Texture name=“$parentIcon“ parentKey=“icon“>
<Color r=“1.0“ g=“1.0“ b=“1.0“/>
</Texture>
</Layer>
</Layers>
</Button>
<Button name=“Button1“ inherits=“MyButtonTemplate“/>
<Button name=“Button2“ inherits=“MyButtonTemplate“>
<Anchors>
<Anchor point=“TOPLEFT“ relativePoint=“TOPRIGHT“ relativeTo=“Button2“/>
</Anchors>
</Button>
<Button name=“Button3“ inherits=“MyButtonTemplate“>
<Anchors>
<Anchor point=“TOPLEFT“ relativePoint=“TOPRIGHT“ relativeTo=“Button2“/>
</Anchors>
</Button>
</Ui>
Usinga templateinthiscaseonlysaves 13lines,butimagineifyouneededto
create a row of eight buttons instead of three! You can use the
CreateFrame()
function to create new frames, saving yourself quite a bit of code.
Chapter 10
Saving Time with Frame Templates 173
Templates can be created and inherited for the following type of elements:
Frames
Font strings
Textures
Animations
Animation groups
In addition,the template systemis overloaded to work with fontdefinitions
and font strings. A font string can, of course, inherit from a font string
template and inherit the attributes and elements, but may also inherit from a
font definition. When this happens, the font string does not really inherit the
attributes, but rather links itself to the font definition. If the font definition
were to later change, the font string would change along with it.
Throughout thischapter,font definitions are referredtoas a distinct concept
from templates.
Advantages of Using Templates
The primary advantage of using templates is the capability to create complex
elements repeatedly without needing to retype them for each instance. To
accomplish this, templates take advantage of the means to automatically
name elements using
$parent
,and make sub-elements accessible using the
parentKey
attribute.
Naming Elements Using $parent
Using the string
$parent
in an element’s name in order to include the parent’s
name becomes very important when working with templates, to ensure that
frames are consistently named. Prior to the 3.0 patch, this was the primary
method used to name frames in the default user interface.
Many of the default templates, such as the dropdown menu template,
require a frame to have a name for them to function properly. They make
heavy use of parent-named textures and sub-frames in the code that manages
them. In the future, these templates might be converted to use the
parentKey
attribute instead, so the naming required might be removed, but there have
been no moves in that direction yet.
In the preceding example, the textures created in the template will be
accessible as
Button1Icon
,
Button2Icon
,and
Button3Icon
.Programmatically,
code might find the icon of such a button using the following code (assuming
that the variable
self
is set to one of the three buttons):
_G[self:GetName() .. “Icon“]:SetTexture(1, 0, 0)
This code fetches the name of the frame, concatenates the string
Icon
on
the end, and looks that key up in the global environment. It then calls the
174
Part II
Programming in World of Warcraft
SetTexture
of the resulting texture, to color it red. Although accesses such as
this are better handled using the
parentKey
attribute, naming frames is still
very important. As shown at the end of Chapter 9, users and developers can
use the
/framestack
command to determine what frames are on screen at a
given point in time. If you make lots of unnamed frames, it is very difficult to
distinguish among them. For thatreason, you are encouraged to create named
frames in addition to utilizing the
parentKey
attribute where appropriate.
Setting Keys Using the parentKey Attribute
In addition tobeinguseful in normal framedefinitions,the
parentKey
attribute
can be used in template definitions to make textures, font strings, and
sub-frames accessible. Rather than perform a name lookup, you could set
the texture of a button’s icon using the following code (assuming that the
variable
self
is set to one of the three buttons):
self.icon:SetTexture(1, 0, 0)
In addition to being more efficient, this method is easier to read and
doesn’t require the code to know whether or not frames are named. Although
the majority of the templates in the default user interface do not yet take
advantage of this feature, it’s a nice and easy way to define and access the
elements of a frame.
Creating a Template for BagBuddy’s Item Buttons
Each item slot in BagBuddywill show theitem’s icon and thenumberof items
of a given type in your inventory. In addition, there will be a colored border
around each itemshowing its rarity (that is, purple for epic,blue for rare, and
so on). The default user interface already has a template that contains all of
these elements, called
ItemButtonTemplate
.
In fact, you could inherit directly from
ItemButtonTemplate
, but that
wouldn’t be a very good example. In addition, if Blizzard makes any changes
to its template, your addon might break. Instead you will copy the code from
theFrameXML definition andadapt ittoyour own needs.Open
BagBuddy.xml
and add the following at the topof the file, inside the
<Ui>
element:
<Button name=“BagBuddyItemTemplate“ virtual=“true“>
<Size>
<AbsDimension x=“37“ y=“37“/>
</Size>
<Layers>
<Layer level=“BORDER“>
<Texture name=“$parentIconTexture“ parentKey=“icon“/>
Chapter 10
Saving Time with Frame Templates 175
<FontString name=“$parentCount“ parentKey=“count“
inherits=“NumberFontNormal“ justifyH=“RIGHT“ hidden=“true“>
<Anchors>
<Anchor point=“BOTTOMRIGHT“>
<Offset>
<AbsDimension x=“-5“ y=“2“/>
</Offset>
</Anchor>
</Anchors>
</FontString>
</Layer>
<Layer level=“OVERLAY“>
<Texture name=“$parentGlow“ parentKey=“glow“ alphaMode=“ADD“
file=“Interface\Buttons\UI-ActionButton-Border“>
<Size x=“70“ y=“70“/>
<Anchors>
<Anchor point=“CENTER“/>
</Anchors>
<Color r=“1.0“ g=“1.0“ b=“1.0“ a=“0.6“/>
</Texture>
</Layer>
</Layers>
</Button>
This template is named
BagBuddyItemTemplate
.Because the names of tem-
platesareglobal,youshouldensurethatyournamewon’t conflictwith another
template. The easiest way to do this is to prefix it with some text and use a
meaningful name.Yougive the frame a size,and define a single graphics layer
on the
BORDER
level. Inside this group, you create an icon texture and a single
font string to display the item count.
Setting Button Textures
Each buttonin WorldofWarcraftcan haveafewdifferenttypesoftexturesthat
aredisplayedin differentstates.The
NormalTexture
is shown when the button
is in a resting state. When the user clicks the button, the
PushedTexture
is
displayed. Finally the
HighlightTexture
appears when the mouse is hovering
over the button. Define these in
BagBuddyItemTemplate
,after the
</Layers>
tag but before the
</Button>
tag:
<NormalTexture name=“$parentNormalTexture“ file=“Interface\Buttons\UI- i
Quickslot2“>
<Size>
<AbsDimension x=“64“ y=“64“/>
</Size>
<Anchors>
<Anchor point=“CENTER“>
176
Part II
Programming in World of Warcraft
<Offset>
<AbsDimension x=“0“ y=“-1“/>
</Offset>
</Anchor>
</Anchors>
</NormalTexture>
<PushedTexture file=“Interface\Buttons\UI-Quickslot-Depress“/>
<HighlightTexture file=“Interface\Buttons\ButtonHilight-Square“
alphaMode=“ADD“/>
The pushed and highlight textures inherit the size and the placement of the
normal texture, because the game just changes the image file being displayed.
You can see a new texture attribute that is used in the highlight texture, called
alphaMode
.This attribute has five different options:
DISABLE
—Ignores the alpha channel completely when rendering the
texture.
BLEND
—Uses the alpha channel with a normal blending overlay.
ALPHAKEY
—Interprets the alpha with any black value being transparent,
and any non-black value being opaque.
ADD
—Uses the alpha channel with an additive blending overlay.
MOD
—Ignores the alpha channel, multiplying the image against the back-
ground.
The template uses the
ADD
alpha mode to achieve its particular highlight
effect.
Creating New Frames with Your Template
Now thatyou’vedefinedthe template,youneedto actuallycreatesomeframes
using it. Although you could do this in XML, you would need to create 24
different frames and set anchors on each of them individually. Instead you
will do it using Lua, which is much shorter. Open
BagBuddy.lua
and add the
following inside the
BagBuddy_OnLoad
function:
-- Create the item slots
self.items = {}
for idx = 1, 24 do
local item = CreateFrame(“Button“, “BagBuddy_Item“ .. idx, self, i
“BagBuddyItemTemplate“)
self.items[idx] = item
if idx == 1 then
item:SetPoint(“TOPLEFT“, 40, -73)
elseif idx == 7 or idx == 13 or idx == 19 then
Chapter 10
Saving Time with Frame Templates 177
item:SetPoint(“TOPLEFT“, self.items[idx-6], “BOTTOMLEFT“, 0, -7)
else
item:SetPoint(“TOPLEFT“, self.items[idx-1], “TOPRIGHT“, 12, 0)
end
end
You first create a table that will be used to store the individual buttons.
This will make it easier to iterate over the buttons when displaying items. For
each index you create a new button from the template you created. Then you
programmatically set the anchors:
If you’re creating the first button, anchor it to the frame itself in the first
button slot.
When creating the first button in any subsequent row, anchor the new
button to the first column of the prior row.
For all other buttons, anchor the new button to the previous button on
the row.
By contrast, accomplishing the same thing in XML would require 3 to 5
lines for each button fora total of somewhere between 70 and 250 lines. When
creating just a few instances of a template, I tend to include them in the XML,
but whenever I’m doing something very repetitive like this I prefer to create
the frames in Lua.
As you move your mouse over the item buttons you can see the highlight
texture appear. This allows you to easily see which button you are currently
hovering over.
Exploring Font Definitions
Font definitions are a bit of an exception when itcomes to the templatesystem
in World of Warcraft. Although they use the same inheritance mechanism,
they work quite differently. This section looks at a specific font definition to
provide an understanding of how they work. You can find the definition of
GameFontNormalSmall
in
FontStyles.xml
,which can be extracted using the
Blizzard Interface Toolkit, introduced in Chapter 8. The code for the template
is as follows:
<Font name=“GameFontNormalSmall“ inherits=“SystemFont_Shadow_Small“ “ i
virtual=“true“>
<Color r=“1.0“ g=“0.82“ b=“0“/>
</Font>
Thefontdefinitionincludes the
virtual
attribute,butit’sessentiallyignored.
Remember,youarecreatingafontdefinition (whichis anactualin-gameobject)
178
Part II
Programming in World of Warcraft
rather than just creating a template. This particular definition inherits from
another template called
SystemFont_Shadow_Small
,defined in
Fonts.xml
:
<Font name=“SystemFont_Shadow_Small“ font=“Fonts\FRIZQT
.TTF“
virtual=“true“>
<Shadow>
<Offset>
<AbsDimension x=“1“ y=“-1“/>
</Offset>
<Color r=“0“ g=“0“ b=“0“/>
</Shadow>
<FontHeight>
<AbsValue val=“10“/>
</FontHeight>
</Font>
This template doesn’t inherit from any other template, and actually defines
the font file that is used to display text, along with a drop shadow and the
height of the text. The font used is called Friz Quadrata and is included in
the game files. The font template defines a drop shadow to the bottom right
of the text with an offset of 1 pixel in each direction. The color of the shadow
is set to black, and the height of the font is set to 10 pixels.
When the
GameFontNormalSmall
font definition inherits from
SystemFont
_Shadow_Small
,it links itself to the original font. Any changes made to the
parent font will be reflected in the inheriting font. The only change the new
templatemakes is to setthe colorto gold,butany of the attributes orelements
defined in a font definition can be overridden while inheriting.
Altering a Font Definition
The major difference between templates and font definitions is that font
definitions can be altered once you are in-game, and the changes will trickle
down the inheritance tree. For example, you can run the following code to
change the height of
SystemFont_Shadow_Small
from 10 to 13:
/run SystemFont_Shadow_Small:SetFont(“Fonts\\FRIZQT
.TTF“, 13)
Figure 10-1 shows the player unit frame and the social panel at the default
font size, and after running the code.
As you can see,only those elements that inheritedfrom
SystemFont_Shadow
_Small
(and by inheritance
GameFontNormalSmall
)are changed. The color and
shadow definitions remain set, butthe font size has been changed. In thesame
way, you could actually replace the font file that is being used to display
some text, and it will immediately be reflected in-game throughout the font
inheritance tree.
Documents you may be interested
Documents you may be interested