Uğur Dönmez

OpenGl kodlamadan önce ekran kartımızın ubuntu tarafından tanındığından emin olmamız gerekmetedir. Bunun için glxinfo komutunu kullanıyoruz.

ugur@ugur-laptop:~$ glxinfo
name of display: :0.0
display: :0  screen: 0
direct rendering: Yes

konsolda direct rendering:yes satırını görmemiz ekran kartımızın tanımlı olduğunu gösteririr. Ayrıca glxgears komutu ile de ekran kartı test edilebilir. Daha sonra ubuntuda visual effects lerin kapalı olduğundan emin olmalıyız. A

İlk önce www.netbeans.com adresinden netbeans ın son sürümünü indiriyoruz. İnen dosyanın executable iznini verdikten sonra konsoldan ./dosya_adı şeklinde çalıştırıp netbeans kurulumumuzu tamamlıyoruz. Netbeans i kurduktan sonra OpenGl için gerekli kütüphaneleri synaptic package manager dan indiriyoruz. İndirmemiz gereken dosyalar freeglut3,freeglut3-dbg,freeglut3-dev ve glui-dev dir. Bu dosyaları yükledikten sonra opengl ve glut için gerekli kütüphaneleri kullanabileceğiz.

Şimdi netbeans in build path ine kütüphanelerimizi eklememiz gerekmektedir. Bunun projeye sağ tıklayıp properties->linkers ın altındaki sağ menüde yer alan libraries ın yanındaki … butonundan

/usr/lib/libGLU.a
/usr/lib/libglui.a
/usr/lib/libglut.a

kütüphanelerini ekliyoruz. Artık netbeans de opengl kodlayıp derleyebiliriz.

Uğur Dönmez

1. Overview

JFreeChart is a free chart library for the Java(tm) platform. It is designed for use in applications, applets, servlets and JSP. JFreeChart is distributed with complete source code subject to the terms of the GNU Lesser General Public Licence, which permits JFreeChart to be used in proprietary or free software applications.

2. Features

JFreeChart can generate pie charts, bar charts (regular and stacked, with an optional 3D-effect), line charts, scatter plots, time series charts (including moving averages, high-low-open-close charts and candlestick plots), Gantt charts, meter charts (dial, compass and thermometer), symbol charts, wind plots, combination charts and more. Additional features include: • data is accessible from any implementation of the defined interfaces; • export to PNG and JPEG image file formats (or you can use Java’s ImageIO library to export to any format supported by ImageIO); • export to any format with a Graphics2D implementation including: – PDF via iText (http://www.lowagie.com/iText/); – SVG via Batik (http://xml.apache.org/batik/); • tool tips; • interactive zooming; • chart mouse events (these can be used for drill-down charts or information pop-ups); • annotations; • HTML image map generation; • works in applications, servlets, JSP (thanks to the Cewolf project1) and applets; • distributed with complete source code subject to the terms of the GNU Lesser General Public License (LGPL).

3. Configuring Eclipse for JFreeChart

To begin with, you need to download the JFreeChart and JCommon distributions, unpack them on your local machine, and generate the API documentation. The following steps are necessary: 1. Download the latest version of the JCommon class library: http://www.jfree.org/jcommon/ …and unpack it to a directory on your computer (almost anywhere is fine). 2. From the ant subdirectory of the just-unpacked JCommon, run ant javadoc to generate the Javadocs locally. If you are unfamiliar with Ant, you can skip this step, but then Eclipse won’t be able to show you the Javadoc popups for JCommon. 3. Download the latest version of the JFreeChart class library: http://www.jfree.org/jfreechart/ …and unpack it to a directory on your computer (again, almost anywhere is fine). 4. From the ant subdirectory of the just-unpacked JFreeChart, run ant javadoc to generate the Javadocs locally. As with step 2, you can skip this step, but then you’ll be missing the API documentation. Now, launch Eclipse, and carry out the following steps to configure JFreeChart and JCommon as user libraries: 5. In Eclipse, select Preferences… from the Window menu, then choose the Java –>Build Path -> User Libraries node in the tree. 6. Click on the New… button and enter JCommon 1.0.12 as the name for a new user library. 7. Ensure that the JCommon 1.0.12 item is selected in the list, then click the Add JARs… button and select the jcommon-1.0.12.jar file from the JCommon directory created back in step 1. 8. Double-click the item that says “Source attachment: (None)”, then click the External folder… button, then select the source directory for JCommon. 9. Double-click the item that says “Javadoc location: (None)”, then click the Browse…button, then select the javadoc directory from JCommon (see step 2). 10. Click on the New… button and enter JFreeChart 1.0.7 as the name for a new user library. 11. Ensure that the JFreeChart 1.0.7 item is selected in the list, then click on the Add JARs… button and select the jfreechart-1.0.7.jar file from the JFreeChart directory (see step 3). 12. Double-click the item that says “Source attachment: (None)”, then click the External folder… button, then select the source directory for JFreeChart. 13. Double-click the item that says “Javadoc location: (None)”, then click the Browse…button, then select the javadoc directory from JFreeChart (see step 4).

4. Creating an Eclipse Project that uses JFreeChart

Now that JFreeChart and JCommon are configured as user libraries, it is straightforward to develop an application that uses these libraries: 1. In Eclipse, select New -> Project… from the File menu, select Java Project from the list and click the Next button. 2. Enter MyAppThatUsesJFreeChart as the project name and click the Finish button. 3. Right-click on the project in the Package Explorer then select Properties from the pop-up menu. In the properties window click on the Add Library… button and select both the JCommon and JFreeChart libraries. Click OK. 4. Create a new source file.

5. Example Codes and Charts

5.1 Bar Chart

Code

import java.awt.Color; import java.awt.Dimension; import org.jfree.chart.ChartFactory; import org.jfree.chart.ChartFrame; import org.jfree.chart.ChartPanel; import org.jfree.chart.JFreeChart; import org.jfree.chart.plot.CategoryPlot; import org.jfree.chart.plot.PlotOrientation; import org.jfree.chart.renderer.category.BarRenderer; import org.jfree.data.category.DefaultCategoryDataset; public class Bar { public static void main3(String [] args){ DefaultCategoryDataset dataset = new DefaultCategoryDataset(); dataset.addValue(1.0, “Row 1″, “Column 1″); dataset.addValue(5.0, “Row 1″, “Column 2″); dataset.addValue(3.0, “Row 1″, “Column 3″); dataset.addValue(2.0, “Row 2″, “Column 1″); dataset.addValue(3.0, “Row 2″, “Column 2″); dataset.addValue(2.0, “Row 2″, “Column 3″); JFreeChart chart = ChartFactory.createBarChart( “Bar Chart Demo”, // chart title “Category”, // domain axis label “Value”, // range axis label dataset, // data PlotOrientation.VERTICAL, // orientation true, // include legend true, // tooltips? false // URLs? ); chart.setBackgroundPaint(Color.white); CategoryPlot plot = (CategoryPlot) chart.getPlot(); plot.setBackgroundPaint(Color.lightGray); plot.setRangeGridlinePaint(Color.white); BarRenderer renderer = (BarRenderer) plot.getRenderer(); renderer.setSeriesPaint(0, Color.gray); renderer.setSeriesPaint(1, Color.orange); renderer.setDrawBarOutline(false); renderer.setItemMargin(0.0); ChartPanel chartPanel = new ChartPanel(chart, false); chartPanel.setPreferredSize(new Dimension(500, 270)); ChartFrame frame = new ChartFrame(“Bar”, chart); frame.pack(); frame.setVisible(true); } }

Chart

5.1 Pie Chart

Code

import java.awt.Color; import org.jfree.chart.ChartFactory; import org.jfree.chart.ChartFrame; import org.jfree.chart.JFreeChart; import org.jfree.chart.plot.PiePlot; import org.jfree.data.general.DefaultPieDataset; public class Pie { public static void main(String [] args){ DefaultPieDataset data = new DefaultPieDataset(); data.setValue(“Category 1″, 43.2); data.setValue(“Category 2″, 27.9); data.setValue(“Category 3″, 79.5); // create a chart… JFreeChart chart = ChartFactory.createPieChart3D( “Sample Pie Chart”, data, true, // legend? true, // tooltips? false // URLs? ); PiePlot plot = (PiePlot) chart.getPlot(); plot.setSectionPaint(“Category 1″, new Color(200, 255, 255)); plot.setSectionPaint(“Category 2″, new Color(200, 200, 255)); plot.setExplodePercent(“Category 2″, 0.30); ChartFrame frame = new ChartFrame(“First”, chart); frame.pack(); frame.setVisible(true); } }

Chart

Eclipse isn’t a huge single java program, but rather a small program which provides the functionality of typical loader called plug-in loader. Eclipse (plug-in loader) is surrounded by hundreds and thousands of plug-ins. Plug-in is nothing but another java program which extends the functionality of Eclipse in some way. Each eclipse plug-in can either consume services provided by other plug-in or can extend its functionality to be consumed by other plug-ins. These plug-in are dynamically loaded by eclipse at run time on demand basis.

Creating a Plug-in
1. Launch Eclipse.
2. From File menu, select New Project. This will open up New Project wizard.
3. Now select Plug-in Project and click on the next button.

4. On next page of the wizard , enter the name of the project "com.myplugin.rmp"

5. Fill in the other fields as shown and then click the Next button. The next wizard page displays options for generating plug-in Java class. Fill all the fields as shown below. Do not fill anything in classpath field – This has been removed in eclipse 3.4. Plug-in Activator is required if we want to do anything on plug-in start up or shut down. For example we want to acquire some resources at plug-in start up and perform clean up when plug-in is shutdown. It is important to note that Eclipse startup does not essentially means that your plug-in is starting up. Plug-ins are loaded/started only when they are demanded or required. So activator is used when plug-in startup/shutdown happens.

6. Click Next, select Plug-in with a view and then click the Next button.

7. Next, Enter the values for this page, and click the Next button.

8. Finally, uncheck all the options. and click Finish button.

After completing New plug-in Project wizard following directory structure will be created.

Four important files to look for are:

RmpPlugin.java – This is the main plug-in class. When plug-in is activated, startup method of this class is called. This class can be used to initialize plugin specific resources. ResourceManagerView.java – This is the View class which gets generated. This class contributes to the UI of our example Resource manager plug-in. MANIFEST.MF – defines runtime information of the plugin Plugin.xml – defines the extension information of the plug-in. </LI>

Manifest Editor – Dependencies Tab

In This section a plug-in must list all the dependent plug-ins which are required so that our plug-in compiles. As you know that we build our plug-ins on top of other plug-ins, so this section essentially declares all those dependencies.
It must be noted that all above plug-in dependencies must be met before plug-in is resolved. It is always good to scan your dependencies from time to time and remove unused dependencies. In order to know unused dependencies use Dependency Analysis section.

Manifest Editor – Runtime Tab

On this page plug-in declares what all it exposes to the outside world. Lets understand this concept with an example. Say you are building Plug-in A. Now if plug-in B wants to extend plug-in A or wants to use plug-in A in any way it will be required that Plug-in A exposes its API’s. It is here that Plug-in A would declare all the packages which it wants to expose to outside world. You can use Add.. button to see all your plug-in packages and then select all Packages which you would like to export.
Another important section on this page is the Classpath. If your plug-in is using some external jars then it is important to add such jars to runtime classpath. Note that simply adding such jars to project classpath will only help you in compiling your source code. In order to make these jars available to runtime environment use Classpath section.

Manifest Editor – Extensions Page

Extensions page is a viewer on top of plugin.xml. This is one of the most frequently used page in plug-in development. This page makes it easy to create extensions as this page is aware of all the extension points. Eclipse provides around 213 extension points where clients can contribute functionality. Extension points are available for virtually every thing for ex: builders, editors, preferences, help contents, markers, views, perspective and so on. Basically we select some extension point and then use these to build our own extensions.

Manifest Editor – Extension Points

This page is also a viewer on top of plugin.xml. This page is used to define our own extension points. Such extension points define a contract which other plug-ins may agree to abide by and extend plug-ins functionality in some way.

Test New Plug-in

There are two ways to test this plug-in. First, we can build a product which will essentially create a plugin bundle, this bundle is then dumped into plug-in folder of eclipse installation. Second, launching new plug-in from within Overview tab of manifest editor. At this time we will take second approach to test this plug-in. This is also the preferable choice when we are developing eclipse plug-ins and need to test them from time to time. In order to test this plug-in click on Overview tab followed by clicking on link Launch an Eclipse Application.

This will launch another instance of eclipse application. However, this new instance will have our plug-in registered with it, So we will be able to see resource manager view. After New Eclipse has started, from the Window menu, select Show View > Other… to open the Show View dialog . In the dialog, expand the Resource Manager Category, select Resource Manager View, and then click the OK button. This causes the Resource Manager view to open.

A hook is a program triggered by some repository event, such as the creation of a new revision or the modification of an unversioned property. Each hook is handed enough information to tell what that event is, what target(s) it’s operating on, and the username of the person who triggered the event. Depending on the hook’s output or return status, the hook program may continue the action, stop it, or suspend it in some way.

The hooks subdirectory is, by default, filled with templates for various repository hooks.

$ ls repos/hooks/
post-commit.tmpl          pre-revprop-change.tmpl
post-revprop-change.tmpl  start-commit.tmpl
pre-commit.tmpl           

There is one template for each hook that the Subversion repository implements, and by examining the contents of those template scripts, you can see what triggers each such script to run and what data is passed to that script. Also present in many of these templates are examples of how one might use that script, in conjunction with other Subversion-supplied programs, to perform common useful tasks. To actually install a working hook, you need only place some executable program or script into the repos/hooks directory which can be executed as the name (like start-commit or post-commit) of the hook.

On Unix platforms, this means supplying a script or program (which could be a shell script, a Python program, a compiled C binary, or any number of other things) named exactly like the name of the hook. Of course, the template files are present for more than just informational purposes—the easiest way to install a hook on Unix platforms is to simply copy the appropriate template file to a new file that lacks the .tmpl extension, customize the hook’s contents, and ensure that the script is executable. Windows, however, uses file extensions to determine whether or not a program is executable, so you would need to supply a program whose basename is the name of the hook, and whose extension is one of the special extensions recognized by Windows for executable programs, such as .exe or .com for programs, and .bat for batch files.

Currently there are five hooks implemented by the Subversion repository:

start-commit

This is run before the commit transaction is even created. It is typically used to decide if the user has commit privileges at all. The repository passes two arguments to this program: the path to the repository, and username which is attempting the commit. If the program returns a non-zero exit value, the commit is stopped before the transaction is even created. If the hook program writes data to stderr, it will be marshalled back to the client.

pre-commit

This is run when the transaction is complete, but before it is committed. Typically, this hook is used to protect against commits that are disallowed due to content or location (for example, your site might require that all commits to a certain branch include a ticket number from the bug tracker, or that the incoming log message is non-empty). The repository passes two arguments to this program: the path to the repository, and the name of the transaction being committed. If the program returns a non-zero exit value, the commit is aborted and the transaction is removed. If the hook program writes data to stderr, it will be marshalled back to the client.

The Subversion distribution includes some access control scripts (located in the tools/hook-scripts directory of the Subversion source tree) that can be called from pre-commit to implement fine-grained write-access control. Another option is to use the mod_authz_svn Apache httpd module, which provides both read and write access control on individual directories . In a future version of Subversion, we plan to implement access control lists (ACLs) directly in the filesystem.

post-commit

This is run after the transaction is committed, and a new revision is created. Most people use this hook to send out descriptive emails about the commit or to make a backup of the repository. The repository passes two arguments to this program: the path to the repository, and the new revision number that was created. The exit code of the program is ignored.

The Subversion distribution includes a commit-email.pl script (located in the tools/hook-scripts/ directory of the Subversion source tree) that can be used to send email with (and/or append to a log file) a description of a given commit. This mail contains a list of the paths that were changed, the log message attached to the commit, the author and date of the commit, as well as a GNU diff-style display of the changes made to the various versioned files as part of the commit.

Another useful tool provided by Subversion is the hot-backup.py script (located in the tools/backup/ directory of the Subversion source tree). This script performs hot backups of your Subversion repository (a feature supported by the Berkeley DB database back-end), and can be used to make a per-commit snapshot of your repository for archival or emergency recovery purposes.

pre-revprop-change

Because Subversion’s revision properties are not versioned, making modifications to such a property (for example, the svn:log commit message property) will overwrite the previous value of that property forever. Since data can be potentially lost here, Subversion supplies this hook (and its counterpart, post-revprop-change) so that repository administrators can keep records of changes to these items using some external means if they so desire. As a precaution against losing unversioned property data, Subversion clients will not be allowed to remotely modify revision properties at all unless this hook is implemented for your repository.

This hook runs just before such a modification is made to the repository. The repository passes four arguments to this hook: the path to the repository, the revision on which the to-be-modified property exists, the authenticated username of the person making the change, and the name of the property itself.

post-revprop-change

As mentioned earlier, this hook is the counterpart of the pre-revprop-change hook. In fact, for the sake of paranoia this script will not run unless the pre-revprop-change hook exists. When both of these hooks are present, the post-revprop-change hook runs just after a revision property has been changed, and is typically used to send an email containing the new value of the changed property. The repository passes four arguments to this hook: the path to the repository, the revision on which the property exists, the authenticated username of the person making the change, and the name of the property itself.

The Subversion distribution includes a propchange-email.pl script (located in the tools/hook-scripts/ directory of the Subversion source tree) that can be used to send email with (and/or append to a log file) the details of a revision property change. This mail contains the revision and name of the changed property, the user who made the change, and the new property value.

Subversion will attempt to execute hooks as the same user who owns the process which is accessing the Subversion repository. In most cases, the repository is being accessed via Apache HTTP server and mod_dav_svn, so this user is the same user that Apache runs as. The hooks themselves will need to be configured with OS-level permissions that allow that user to execute them. Also, this means that any file or programs (including the Subversion repository itself) accessed directly or indirectly by the hook will be accessed as the same user. In other words, be alert to potential permission-related problems that could prevent the hook from performing the tasks you’ve written it to perform.

In the course of working on a project, a developer should work in the following manner. How to perform all of these task is outlined below.

If the project is new, the following is done the first time:

A developer checks in a project for the first time, putting all of the files on the repository.

Other developers check out the project into their workspace. If a developer changes workspaces, the code would need to be checked out again.

In the course of working, a developer should strictly follow these steps:

1. Update their code, to obtain any changes that others made

2. Work on their code

3. Periodically (about every half-hour to an hour), the developer should synchronize, which displays any recent changes to the repository and which local code has been changed (synchronize doesn’t actually do anything, it just tells you what needs to be done).

4. If the developer has changed a file locally, and the files on the repository have been changed since the last update, a merge will need to take place

5. The developer commits his/her changes of the local code to the repository

Adding Subclipse Plug-in to Eclipse

1 Select Help > Software Updates > Find and Install. Select Search for new features to install. Click Next.

2 Click the Add Site button. Give the update site a name, like Subclipse, and type in the following address: http://subclipse.tigris.org/update_1.6.x Click OK. A new update site will be added to the list.

3 Press the + next to your Subclipse update site. Eclipse will connect with the site and list all of the updates available. Select the most recent Subclipse update by checking the box next to the update. Click Install.

4 Check the Subversion feature that you want to install. Click Next.

5 Accept the terms of the license agreement. Click Finish.

Subclipse Perspectives

To change to the Subclipse perspective select Window > Open Perspective > SVN Repository Exploring.

Adding a Repository URL to Subclipse

To add a repository you can right click in the SVN Repository view and select New > SVN Repository, or you can click the add repository button in the toolbar of the SVN Repository view.

1.First you need to fill out the URL for the repository.

2 Provide your user id and password.

3 Click Finish.

Checking Out a Project from the Repository

Switch to the SVN Repository Exploring perspective. Click the + next to your repository. To check out a project right click on any folder/project and select Check Out as Project. If the project that you are checking out already exists in the workspace, the old project will be destroyed and the project from the SVN repository will be created in its place. Otherwise a new project will be created in the workspace. Switch back to the Java or Plug-in Development perspective to modify the code.

Synchronizing and Committing Resources to the Repository

Any resources that you have modified will have a black asterisk in front of the resource name, and any added will have a question mark in front of the name.

It is always a good idea to see what needs to be done before committing files.

To synchronize resources, right click on a project and select Team > Synchronize with Repository …. You will be switched to the Team Synchronizing view. From there you can look at your outgoing changes, and others incoming changes, and synchronize your code before committing to the repository. Double-clicking on a file will open a side-by-side view of the file and its changes.

If a file has a two-way red arrow on it, then there is a conflict. Someone else has changed that file while you were working on it. Double-click the file to get a compare editor, and copy-paste what you need to resolve onto your local copy. When you have the local copy finished, right-click on the file and choose Mark as Merged. Note: PLEASE USE THIS FEATURE RESPONSIBLY!! Think very hard before selecting "Mark as Merged", as it will override what is in the repository. An entire history is kept in case you make a mistake, but always pause and check your work before marking as merged.

Creating The Repository

The first Subversion tool we will use is

. This tool is for administration tasks, like creating repositories, making backup dumps, and the like.

$ svnadmin create svn

Importing Projects

To import a project, first create a directory for it in your repository.

$ svn mkdir file:///home/ugur/svn/myproj

Next, it’s time to import project files. Change the current directory to the project’s directory, and run

:

$ cd /home/ugur/[...]/myproj

$ svn import file:///home/ugur/svn/myproj

Importing Projects From Remote repository

svn checkout svn+ssh://url.of.desktop/home/ugur/svn project

Check out, Modify, Commit

As I said, the repository is stored in the

directory which you won’t deal with. To work on your files, first you need to check a working copy out of the repository. To do so, use

:

$ svn checkout file:///home/ugur/svn

A new directory named myproj will be created containing your project files. You can work and modify them. Once you’re done and you want to store the new revision in your repository, run

in the checked-out myproj directory:

$ svn commit

Working with Revisions

Now let’s make real use of Subversion. While working with revisions, you can:

Check Status

$ svn status [filename]

Compare different Revisions

$ svn compare -r R1:R2 [filename]

(Replace R1 and R2 with actual revision numbers you want to compare)

Revert Local Edits

$ svn revert [filename]

Revert to Previous Revisions

$ svn update -r R

(Replace R with an actual revision number)

[filename] is optional; you can run the previous commands on the current directory if you omit it.

Subversion is a free/open-source version control system. That is, Subversion manages files and directories over time. A tree of files is placed into a central repository. The repository is much like an ordinary file server, except that it remembers every change ever made to your files and directories. This allows you to recover older versions of your data, or examine the history of how your data changed. In this regard, many people think of a version control system as a sort of “time machine”.

Subversion can access its repository across networks, which allows it to be used by people on different computers. At some level, the ability for various people to modify and manage the same set of data from their respective locations fosters collaboration. Progress can occur more quickly without a single conduit through which all modifications must occur. And because the work is versioned, you need not fear that quality is the trade-off for losing that conduit—if some incorrect change is made to the data, just undo that change.

more information: http://svnbook.red-bean.com/en/1.0/svn-book.html

Java is a programming language originally developed by James Gosling at Sun Microsystems and released in 1995 as a core component of Sun Microsystems’ Java platform. The language derives much of its syntax from C and C++ but has a simpler object model and fewer low-level facilities. Java applications are typically compiled to bytecode (class file) that can run on any Java Virtual Machine (JVM) regardless of computer architecture.

The original and reference implementation Java compilers, virtual machines, and class libraries were developed by Sun from 1995. As of May 2007, in compliance with the specifications of the Java Community Process, Sun relicensed most of their Java technologies under the GNU General Public License. Others have also developed alternative implementations of these Sun technologies, such as the GNU Compiler for Java and GNU Classpath.

Eclipse is an open source programme and is designed for the purpose of building integrated development environments, namely IDEs. It could be also described as a multi-language environment that is used in software developments. It consists of IDE and a plug-in system for extension. It might be used in order to create various end-to-end computing solutions for multiple execution environments. Generally, eclipse is written in Java. Besides Java, it could be also written in other languages too, including C, C++, COBOL, Python, Perl, PHP and others.

Eclipse is an open source because the design that it has allows for the easy extension by third parties. It is an integrated development environment that is IDE, because it provides tooling options in order to manage workspaces to build, launch and arrange applications, to share artifacts, and to customize the programming experience easily and properly. In addition to these, eclipse is also a platform due to the fact that it is not a finished application, but it is designed to be extended indefinetely within many sophisticated toolings.

Briefly explaining, eclipse is designed on a mechanism for discovering, integrating and running modules called plug-ins. It mostly focuses on Java and the related technologies; however, its flexible structure allows its usage for many languages. Additionally, within the plug-ins offered, it could be used in many fields by developing its functions.