how to convert pdf to jpg in c# windows application : Copy text from locked pdf application software tool html windows azure online javanotes6-linked25-part293

CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
237
content.add(displayPanel, BorderLayout.CENTER);
content.add(changeMessageButton, BorderLayout.SOUTH);
setContentPane(content);
}
}
You should compare this class withHelloWorldGUI2.javafrom the previous section. One
subtle difference that you will notice is that the member variables and nested classes in this
example are non-static. Remember that an applet is an object. A single class can be used to
make several applets, and each of those applets will need its own copy of the applet data, so
the member variables in which the data are stored must be non-static instance variables. Since
the variables are non-static, the two nested classes, which use those variables, must also be
non-static. (Static nested classes cannot access non-static member variables in the containing
class; seeSubsection5.7.2.) Remember the basic rule for deciding whether to make a nested
class static: If it needs access to any instance variable or instance method in the containing
class, the nested class must be non-static; otherwise, it can be declared to be static.
(By the way, JApplet is a subclass of a more basic class, named Applet and found in the
package java.applet. JApplet is part of the Swing GUI framework Applet is part of the older
AWT and is no longer commonly used directly for writing applets.)
6.2.2 Reusing Your JPanels
Both applets and frames can be programmed in the same way: Design a JPanel, and use it to
replace the default content pane in the applet or frame. This makes it very easy to write two
versions of a program, one which runs as an applet and one which runs as a frame. The idea is
to create a subclass of JPanel that represents the content pane for your program; all the hard
programming work is done in this panel class. An object of this class can then be used as the
content pane either in a frame or in an applet—or both. Only a very simple main() program
is needed to show your panel in a frame, and only a very simple applet class is needed to show
your panel in an applet, so it’s easy to make both versions.
As an example, we can rewrite HelloWorldApplet by writing a subclass of JPanel. That class
can then be reused to make a frame in a standalone application. This class is very similar to
HelloWorldApplet, but now the initialization is done in a constructor instead of in an init()
method:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class HelloWorldPanel extends JPanel {
private String currentMessage = "Hello World!"; // Currently displayed message.
private MessageDisplay displayPanel; // The panel where the message is displayed.
private class MessageDisplay extends JPanel {
// Defines the display panel.
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.drawString(currentMessage, 20, 30);
}
}
private class ButtonHandler implements ActionListener { // The event listener.
Copy text from locked pdf - 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
change pdf security settings reader; copy from locked pdf
Copy text from locked pdf - 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
change security settings pdf reader; add security to pdf
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
238
public void actionPerformed(ActionEvent e) {
if (currentMessage.equals("Hello World!"))
currentMessage = "Goodbye World!";
else
currentMessage = "Hello World!";
displayPanel.repaint(); // Paint display panel with new message.
}
}
/**
* The constructor creates the components that will be contained inside this
* panel, and then adds those components to this panel.
*/
public HelloWorldPanel() {
displayPanel = new MessageDisplay(); // Create the display subpanel.
JButton changeMessageButton = new JButton("Change Message"); // The button.
ButtonHandler listener = new ButtonHandler();
changeMessageButton.addActionListener(listener);
setLayout(new BorderLayout()); // Set the layout manager for this panel.
add(displayPanel, BorderLayout.CENTER); // Add the display panel.
add(changeMessageButton, BorderLayout.SOUTH); // Add the button.
}
}
Once this class exists, it can be used in an applet. The applet class only has to create an object
of type HelloWorldPanel and use that object as its content pane:
import javax.swing.JApplet;
public class HelloWorldApplet2 extends JApplet {
public void init() {
HelloWorldPanel content = new HelloWorldPanel();
setContentPane(content);
}
}
Similarly, it’s easy to make a frame that uses an object of type HelloWorldPanel as its content
pane:
import javax.swing.JFrame;
public class HelloWorldGUI3 {
public static void main(String[] args) {
JFrame window = new JFrame("GUI Test");
HelloWorldPanel content = new HelloWorldPanel();
window.setContentPane(content);
window.setSize(250,100);
window.setLocation(100,100);
window.setDefaultCloseOperation( JFrame.EXIT
ON
CLOSE );
window.setVisible(true);
}
}
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Ability to copy selected PDF pages and paste into another Besides, the capacity to be locked against editing or processing by others makes PDF file become
pdf password unlock; secure pdf remove
C# PowerPoint - Extract or Copy PowerPoint Pages from PowerPoint
read PDF, VB.NET convert PDF to text, VB.NET Extract/Copy PowerPoint Pages of PowerPoint Document in C# Besides, the capacity to be locked against editing or
secure pdf; decrypt pdf
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
239
One new feature of this example is the line
window.setDefaultCloseOperation( JFrame.EXIT
ON
CLOSE );
This says that when the user closes the window by clicking the close box in the title bar of the
window, the program should be terminated. This is necessary because no other way is provided
to end the program. Without this line, the default close operation of the window would simply
hide the window when the user clicks the close box, leaving the program running even though
nothing is visible on the screen. This brings up one of the difficulties of reusing the same panel
class both in an applet and in a frame: There are some things that a stand-alone application
can do that an applet can’t do. Terminating the program is one of those things. If an applet
calls System.exit(), it has no effect except to generate an error.
Nevertheless, in spite of occasional minor difficulties, many of the GUI examples in this
book will be written as subclasses of JPanel that can be used either in an applet or in a frame.
6.2.3 Basic HTML
Before you can actually use an applet that you have written, you need to create a Web page
on which to place the applet. Such pages are themselves written in a language called HTML
(HyperText Markup Language). An HTML document describes the contents of a page. A Web
browser interprets the HTML code to determine what to display on the page. The HTML code
doesn’t look much like the resulting page that appears in the browser. The HTML document
does contain all the text that appears on the page, but that text is “marked up” with commands
that determine the structure and appearance of the text and determine what will appear on
the page in addition to the text.
HTML has become a rather complicated language, and it is only one of the languages that
you need to be familiar with if you want to write sophisticated modern web pages. Many
aspects of the visual style of a page can be controlled using a language called CSS (cascading
style sheets). Webpages canbe dynamic and interactive, andtheir behavior can be programmed
using a programming language called JavaScript (which is only very distantly related to Java).
Furthermore, interactive web pages often work with programs that run on the Web server,
which can be written in Java or in several other languages. Programming for the web has
become very complicated indeed!
Nevertheless,it’s fairly easy towrite basic web pages using only plain HTML.In this section,
Iwill cover just the most basic aspects of the language. You can easily find more information
on the Web, if you want to learn more. Although there are many Web-authoring programs
that make it possible to create Web pages without ever looking at the underlying HTML code,
it is possible to write an HTML page using an ordinary text editor, typing in all the mark-up
commands by hand, and it is worthwhile to learn how to create at least simple pages in this
way.
There is a strict syntax for HTML documents (although in practice Web browsers will do
their best to display a page even if it does not follow the syntax strictly). Leaving out optional
features, an HTML document has the form:
<html>
<head>
<title>document-title</title>
</head>
<body>
document-content
C# Word - Extract or Copy Pages from Word File in C#.NET
C#.NET rotate PDF pages, C#.NET search text in PDF, C# Extract/Copy Pages of Word Document in C# Project. Besides, the capacity to be locked against editing or
decrypt pdf with password; decrypt pdf password online
C# Excel - Extract or Copy Excel Pages to Excel File in C#.NET
NET rotate PDF pages, C#.NET search text in PDF Extract/Copy Excel Pages of Excel Document in C# Project. Besides, the capacity to be locked against editing or
decrypt pdf online; pdf security options
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
240
</body>
</html>
The document-title is text that will appear in the title bar of the Web browser window when
the page is displayed. The document-content is what is displayed on the page itself. The rest
of this section describes some of the things that can go into the document-content section of
an HTML document.
∗ ∗ ∗
The mark-up commands used by HTML are called tags. Examples include <html> and
<title> in the document outline given above. An HTML tag takes the form
<tag-name optional-modifiers>
where the tag-name is a word that specifies the command, and the optional-modifiers, if
present, are used to provide additional information for the command (much like parameters in
subroutines). A modifier takes the form
modifier-name = value
Usually, the value is enclosed in quotes, and it must be if it is more than one word long or if
it contains certain special characters. There are a few modifiers which have no value, in which
case only the name of the modifier is present. HTML is case insensitive, which means that
you can use upper case and lower case letters interchangeably in tags and modifiers. (However,
lower case is generally used because XHTML, a successor language to HTML, requires lower
case.)
Asimple example of a tag is <hr>, which draws a line—also called a “horizontal rule”—
across the page. The hr tag can take several possible modifiers such as width and align. For
example, a horizontal line that extends halfway across the page could be generated with the
tag:
<hr width="50%">
The width here is specified as 50% of the available space, meaning a line that extends halfway
across the page. The width could also be given as a fixed number of pixels.
Many tags require matching closing tags, which take the form
</tag-name>
For example, the <html> tag at the beginning of an HTML document must be matched
by a closing </html> tag at the end of the document. As another example, the tag <pre>
must always have a matching closing tag </pre> later in the document. An opening/closing
tag pair applies to everything that comes between the opening tag and the closing tag. The
<pre> tag tells a Web browser to display everything between the <pre> and the </pre> just as
it is formatted in the original HTML source code, including all the spaces and carriage returns.
(But tags between <pre> and </pre> are still interpreted by the browser.) “Pre” stands for
preformatted text. All of the sample programs in the on-line version of this book are formatted
using the <pre> command.
It is important for you to understand that when you don’t use <pre>, the computer will
completely ignore the formatting of the text in the HTML source code. The only thing it pays
attention to is the tags. Five blank lines in the source code have no more effect than one blank
line or even a single blank space. Outside of <pre>, if you want to force a new line on the
Web page, you can use the tag <br>, which stands for “break”. For example, I might give my
address as:
VB.NET Word: Extract Text from Microsoft Word Document in VB.NET
time and effort compared with traditional copy and paste Word documents are often locked as static images and the in VB.NET. Apart from extracting text from Word
creating secure pdf files; pdf password unlock
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
241
David Eck<br>
Department of Mathematics and Computer Science<br>
Hobart and William Smith Colleges<br>
Geneva, NY 14456<br>
If you want extra vertical space in your web page, you can use several <br>’s in a row.
Similarly, you need a tag to indicate how the text should be broken up into paragraphs.
This is done with the <p> tag, which should be placed at the beginning of every paragraph.
The <p> tag has a matching </p>, which should be placed at the end of each paragraph. The
closing </p> is technically optional, but it is considered good form to use it. If you want all the
lines of the paragraph to be shoved over to the right, you can use <p align=right> instead of
<p>. (This is mostly useful when used with one short line, or when used with <br> to make
several short lines.) You can also use <p align=center> for centered lines.
By the way, if tags like <p> and <hr> have special meanings in HTML, you might wonder
how to get them to appear literally on a web page. To get certain special characters to appear
on the page, you have to use an entity name in the HTML source code. The entity name
for < is &lt;, and the entity name for > is &gt;. Entity names begin with & and end with
asemicolon. The character & is itself a special character whose entity name is &amp;. There
are also entity names for nonstandard characters such as an accented “e”, which has the entity
name &eacute; and the Greek letter π, which is written as &pi;.
There are several useful tags that change the appearance of text. To get italic text, enclose
the text between <i> and </i>. For example,
<i>Introduction to Programming using Java</i>
in an HTML document gives Introduction to Programming using Java in italics when the
document is displayed as a Web page. The tags <b>, <u>, and <tt> can be used in a similar
way for bold, underlined
,and typewriter-style (“monospace”) text.
Aheadline, with very large text, can be made by placing the text between <h1> and </h1>.
Headlines with smaller text can be made using <h2> or <h3> instead of <h1>. Note that these
headline tags standontheir own; they are not used inside paragraphs. Youcan add the modifier
align=center to center the headline, and you can right-justify it with align=right. You can
include break tags (<br>) in a headline to break it up into multiple lines. For example, the
following HTML code will produce a medium–sized, centered, two-line headline:
<h2 align=center>Chapter 6:<br>Introduction to GUI Programming</h2>
∗ ∗ ∗
The most distinctive feature of HTML is that documents can contain links to other docu-
ments. The user can follow links from page to page and in the process visit pages from all over
the Internet.
The <a> tag is used to create a link. The text between the <a> and its matching </a>
appears on the page as the text of the link; the user can follow the link by clicking on this
text. The <a> tag uses the modifier href to say which document the link should connect to.
The value for href must be a URL (Uniform Resource Locator). A URL is a coded set of
instructions for finding a document on the Internet. For example, the URL for my own “home
page” is
http://math.hws.edu/eck/
To make a link to this page, I would use the HTML source code
<a href="http://math.hws.edu/eck/">David’s Home Page</a>
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
242
The best place to find URLs is on existing Web pages. Web browsers display the URL for the
page you are currently viewing, and many browsers will display the URL of a link if you point
to the link with the mouse.
If you are writing an HTML document and you want to make a link to another document
that is in the same directory, you canuse a relative URL. The relative URLconsists of just the
name of the file. For example, to create a link to a file named “s1.html” in the same directory
as the HTML document that you are writing, you could use
<a href="s1.html">Section 1</a>
There are also relative URLs for linking to files that are in other directories. Using relative
URLs is a good idea, since if you use them, you can move a whole collection of files without
changing any of the links between them (as long as you don’t change the relative locations of
the files).
When you type a URL into a Web browser, you can omit the “http://” at the beginning of
the URL. However, in an <a> tag in an HTML document, the “http://” can only be omitted if
the URL is a relative URL. For a normal URL, it is required.
∗ ∗ ∗
You can add images to a Web page with the <img> tag. (This is a tag that has no matching
closing tag.) The actual image must be stored in a separate file from the HTML document.
The <img> tag has a required modifier, named src, to specify the URL of the image file. For
most browsers, the image should be in one of the formats PNG (with a file name ending in
“.png”), JPEG (with a file name ending in “.jpeg” or “.jpg”), or GIF (with a file name ending
in “.gif”). Usually, the image is stored in the same place as the HTML document, and a relative
URL—that is, just the name of the file—is used to specify the image file.
The <img> tag also has several optional modifiers. It’s a good idea to always include the
height and width modifiers, which specify the size of the image in pixels. Some browsers
handle images better if they know in advance how big they are. The align modifier can be
used to affect the placement of the image: “align=right” will shove the image to the right edge
of the page, and the text on the page will flow around the image; “align=left” works similarly.
(Unfortunately, “align=center” doesn’t have the meaning you would expect. Browsers treat
images as if they are just big characters. Images can occur inside paragraphs, links, and
headings, for example. Alignment values of center, top, and bottom are used to specify how
the image should line up with other characters in a line of text: Should the baseline of the text
be at the center, the top, or the bottom of the image? Alignment values of right and left
were added to HTML later, but they are the most useful values. If you want an image centered
on the page, put it inside a <p align=center> tag.)
For example, here is HTML code that will place an image from a file named figure1.png on
the page.
<img src="figure1.png" align=right height=150 width=100>
The image is 100 pixels wide and 150 pixels high, and it will appear on the right edge of the
page.
6.2.4 Applets on Web Pages
The main point of this whole discussion of HTML is to learn how to use applets on the Web.
The <applet> tag can be used to add a Java applet to a Web page. This tag must have a
matching </applet>. A required modifier named code gives the name of the compiled class
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
243
file that contains the applet class. The modifiers height and width are required to specify the
size of the applet, in pixels. If you want the applet to be centered on the page, you can put the
applet in a paragraph with center alignment. So, an applet tag to display an applet named
HelloWorldApplet centered on a Web page would look like this:
<p align=center>
<applet code="HelloWorldApplet.class" height=100 width=250>
</applet>
</p>
This assumes that the file HelloWorldApplet.class is located in the same directory with
the HTML document. If this is not the case, you can use another modifier, codebase, to give
the URL of the directory that contains the class file. The value of code itself is always just a
class, not a URL.
If the applet uses other classes in addition to the applet class itself, then those class files
must be in the same directory as the applet class (always assuming that your classes are all in
the “default package”; seeSubsection2.6.4; if not, they must be in subdirectories). If an applet
requires more than one or two class files, it’s a good idea to collect all the class files into a single
jar file. Jar files are “archive files” which hold a number of smaller files. If your class files are
in a jar archive, then you have to specify the name of the jar file in an archive modifier in the
<applet> tag, as in
<applet code="HelloWorldApplet.class" archive="HelloWorld.jar" height=50...
Iwill have more to say about creating and using jar files at the end of this chapter.
Applets can use applet parameters to customize their behavior. Applet parameters are
specified by using <param> tags, which can only occur between an <applet> tag and the closing
</applet>. The param tag has required modifiers named name and value, and it takes the
form
<param name="param-name" value="param-value">
The parameters are available to the applet when it runs. An applet uses the predefined method
getParameter() to check for parameters specifiedinparam tags. The getParameter() method
has the following interface:
String getParameter(String paramName)
The parameter paramName corresponds to the param-name in a param tag. If the specified
paramName actually occurs in one of the param tags, then getParameter(paramName) returns
the associated param-value. If the specified paramName does not occur in any param tag, then
getParameter(paramName) returns the value null. Parameter names are case-sensitive, so you
cannot use “size” in the param tag and ask for “Size” in getParameter. The getParameter()
method is often called in the applet’s init() method. It will not work correctly in the applet’s
constructor, since it depends on informationabout the applet’s environment that is not available
when the constructor is called.
Here is an example of an applet tag with several params:
<applet code="ShowMessage.class" width=200 height=50>
<param name="message" value="Goodbye World!">
<param name="font" value="Serif">
<param name="size" value="36">
</applet>
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
244
The ShowMessage applet would presumably read these parameters in its init() method,
which could go something like this:
String message; // Instance variable: message to be displayed.
String fontName; // Instance variable: font to use for display.
int fontSize;
// Instance variable: size of the display font.
public void init() {
String value;
value = getParameter("message"); // Get message param, if any.
if (value == null)
message = "Hello World!"; // Default value, if no param is present.
else
message = value; // Value from PARAM tag.
value = getParameter("font");
if (value == null)
fontName = "SansSerif"; // Default value, if no param is present.
else
fontName = value;
value = getParameter("size");
try {
fontSize = Integer.parseInt(value); // Convert string to number.
}
catch (NumberFormatException e) {
fontSize = 20; // Default value, if no param is present, or if
}
//
the parameter value is not a legal integer.
.
.
.
Elsewhere in the applet, the instance variables message, fontName, and fontSize would be
used to determine the message displayed by the applet and the appearance of that message.
Note that the value returned by getParameter() is always a String. If the param represents
anumerical value, the string must be converted into a number, as is done here for the size
parameter.
6.3 Graphics and Painting
E
verything you see on a computer screen has to be drawn there, even the text. The
(online)
Java API includes a range of classes and methods that are devoted to drawing. In this section,
I’ll look at some of the most basic of these.
The physical structure of a GUI is built of components. The term component refers to a
visual element in a GUI, including buttons, menus, text-input boxes, scroll bars, check boxes,
and so on. In Java, GUI components are represented by objects belonging to subclasses of the
class java.awt.Component. Most components in the Swing GUI—although not top-level com-
ponents like JApplet and JFrame—belong to subclasses of the class javax.swing.JComponent,
which is itself a subclass of java.awt.Component. Every component is responsible for drawing
itself. If youwant to use a standardcomponent, you only have to add it to your applet or frame.
You don’t have to worry about painting it on the screen. That will happen automatically, since
it already knows how to draw itself.
Sometimes, however, you do want to draw on a component. You will have to do this
whenever you want to display something that is not included among the standard, pre-defined
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
245
component classes. When you want to do this, you have to define your own component class
and provide a method in that class for drawing the component. I will always use a subclass
of JPanel when I need a drawing surface of this kind, as I did for the MessageDisplay class in
the exampleHelloWorldApplet.javain the previous section. A JPanel, like any JComponent,
draws its content in the method
public void paintComponent(Graphics g)
To create a drawing surface, you should define a subclass of JPanel and provide a custom
paintComponent() method. Create an object belonging to this class and use it in your applet
or frame. When the time comes for your component to be drawn on the screen, the system
will call its paintComponent() to do the drawing. That is, the code that you put into the
paintComponent() method will be executed whenever the panel needs to be drawn on the
screen; by writing this method, you determine the picture that will be displayed in the panel.
Note that the paintComponent() method has a parameter of type Graphics. The Graphics
object will be provided by the system when it calls your method. You need this object to
do the actual drawing. To do any drawing at all in Java, you need a graphics context. A
graphics context is an object belonging to the class java.awt.Graphics. Instance methods
are provided in this class for drawing shapes, text, and images. Any given Graphics object
can draw to only one location. In this chapter, that location will always be a GUI component
belonging to some subclass of JPanel. The Graphics class is an abstract class, which means
that it is impossible to create a graphics context directly, with a constructor. There are actually
two ways to get a graphics context for drawing on a component: First of all, of course, when
the paintComponent() method of a component is called by the system, the parameter to that
method is a graphics context for drawing on the component. Second, every component has
an instance method called getGraphics(). This method is a function that returns a graphics
context that can be used for drawing on the component outside its paintComponent() method.
The official line is that you should not do this, and I will almost always avoid it. But I have
found it convenient to use getGraphics() in a few examples.
The paintComponent() method in the JPanel class simply fills the panel with the panel’s
background color. When defining a subclass of JPanel for use as a drawing surface, you will
usually want to fill the panel with the background color before drawing other content onto
the panel (although it is not necessary to do this if the drawing commands in the method
cover the background of the component completely). This is traditionally done with a call to
super.paintComponent(g), so most paintComponent() methods that you write will have the
form:
public void paintComponent(g) {
super.paintComponent(g);
. . . // Draw the content of the component.
}
∗ ∗ ∗
Most components do, infact, do alldrawingoperations intheir paintComponent() methods.
What happens if, in the middle of some other method, you realize that the content of the
component needs to be changed? You should not call paintComponent() directly to make the
change; this method is meant to be called only by the system. Instead, you have to inform
the system that the component needs to be redrawn, and let the system do its job by calling
paintComponent(). You do this by calling the component’s repaint() method. The method
public void repaint();
CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING
246
is defined in the Component class, and so can be used with any component. You should call
repaint() to inform the system that the component needs to be redrawn. It is important to
understand that the repaint() method returns immediately, without doing any painting itself.
The system will call the component’s paintComponent() method later, as soon as it gets a
chance to do so, after processing other pending events if there are any.
Note that the system can also call paintComponent() for other reasons. It is called when
the component first appears on the screen. It will also be called if the size of the component
changes, which can happen when the user resizes the window that contains the component. In
versions of Java earlier than Java 6, paintComponent() is also called if the component is covered
up and then uncovered, since the system did not automatically save a copy of the content. (And
even in Java 6, the content is not automatically saved if is drawnwitha graphics context created
by getGraphics(), as I will do in some examples.) In any case, paintComponent() should be
capable of redrawing the content of the component on demand. As you will see, however, some
of our early examples will not be able to do this correctly.
This means that, to work properly, the paintComponent() method must be smart enough
to correctly redraw the component at any time. To make this possible, a program should store
data in its instance variables about the state of the component. These variables should contain
all the information necessary to redraw the component completely. The paintComponent()
method should use the data in these variables to decide what to draw. When the program
wants to change the content of the component, it should not simply draw the new content. It
should change the values of the relevant variables and call repaint(). When the system calls
paintComponent(), that method will use the new values of the variables and will draw the
component with the desired modifications. This might seem a roundabout way of doing things.
Why not just draw the modifications directly? There are at least two reasons. First of all, it
really does turn out to be easier to get things right if all drawing is done in one method. Second,
even if you do make modifications directly, you still have to make the paintComponent()
method aware of them in some way so that it will be able to redraw the component correctly
on demand.
You will see how all this works in practice as we work through examples in the rest of this
chapter. For now, we will spend the rest of this section looking at how to get some actual
drawing done.
6.3.1 Coordinates
The screen of a computer is a grid of little squares called pixels. The color of each pixel can be
set individually, and drawing on the screen just means setting the colors of individual pixels.
x = 0
y = 0
y = height
x = width
Documents you may be interested
Documents you may be interested