Software Lab Assignments

To study KDE desktop Environment.

January 20, 2012 by ProjectsGeek Leave a Comment

To study KDE desktop Environment.

AIM: To study KDE desktop Environment.

THEORY:

KDE was founded in 1996 by Matthias Ettrich. KDE is a network transparent contemporary desktop environment for UNIX workstations. KDE seeks to fill the need for an easy to use desktop for Unix workstations, similar to the desktop environments found under the MacOS or Microsoft Windows.

The traditional X11 desktops had many drawbacks:

No easy dialog based desktop configuration
No common application development framework or application help system
Lack of network transparency on the application level
Authoring of X11 applications extremely difficult and tedious

To the user KDE brings among other things:

A good looking contemporary desktop exhibiting complete network transparency.
An integrated help system allowing for convenient, consistent access to help on the use of the KDE desktop and its applications
Consistent look and feel of all KDE applications
Standardized menu and toolbars, key bindings, color-schemes, etc.
Internationalization: KDE is available in more than 50 languages
Centralized consisted dialog driven desktop configuration
A great number of useful KDE applications

The KDE Project has developed a first rate compound document application framework, implementing the latest advances in framework technology and thus positioning itself in direct competition to popular development frameworks.

Leveraging the KDE application development framework a great number of applications have been built for the K Desktop Environment. A selection of those applications is contained in the KDE base distribution. At this moment KDE is developing an office application suite based on KDE’s KParts technology consisting of a spread-sheet, a presentation application, an organizer, a news client and more.

Major KDE applications are Amarok (audio player),K3b (CD and DVD burning), Kate(text editor), Kmail (email client), Konsole (terminal emulator),Kopete (instant messaging), Kword, Kspread, Kplayer and TaskJuggler (Project management software)

KDE FEATURES

KDE can be viewed either as a user desktop or as a development platform for applications.

The Kdesktop Environment

Konqueror Browser
Konqueror is KDE’s next-generation web browser, file manager and document viewer. The standards-compliant Konqueror combines the features and functionality of Internet Explorer/Netscape Communicator and Windows Explorer. Konqueror supports the full gamut of current Internet technologies.
KIO Network Transparency
In addition, KIO’s network transparency offers seamless support for accessing or browsing files on GNU/Linux, NFS shares, MS Windows SMB shares, HTTP pages, FTP directories and LDAP directories. The modular, plug-in nature of KDE’s file architecture makes it simple to add additional protocols.
aRts Multimedia Architecture
KDE 2.0 introduced a new multimedia architecture based on aRts, the Analog Realtime Synthesizer. ARts enables playing multiple audio or video streams concurrently, whether on the desktop or over a network.

The K Development Environment

KDE offers developers a rich set of major technologies. Chief among these are the Desktop COmmunication Protocol (DCOP), the I/O libraries (KIO), the component object model (KParts), an XML-based GUI class, and a standards-compliant HTML rendering engine (KHTML).
DCOP Messaging: DCOP is a client-to-client communications protocol. The protocol supports both message passing and remote procedure calls.
KIO Network Technology: KIO implements application I/O in a separate process to enable a non-blocking GUI without the use of threads. The class is network transparent. Its modular and extensible design permits developers to “drop in” additional protocols.
KParts Components: KParts, KDE’s component object model, allows an application to embed another within itself. The technology handles all aspects of the embedding.This technology is used extensively by the KOffice suite and Konqueror.
XML GUI Builder: The XML GUI employs XML to create and position menus, toolbars and possibly other aspects of the GUI. This technology offers developers and users the advantage of simplified configurability of these user interface elements.
KHTML Rendering Engine: KHTML is an HTML 4.0 compliant rendering and drawing engine. The class supports a full gamut of internet technologies. The KHTML class can easily be used by an application as either a widget or as a component .

CONCLUSION: Here by we have successfully studied the KDE desktop Environment.

Create a simple Paintbrush application using various GDI components.

January 20, 2012 by ProjectsGeek Leave a Comment

Create a simple Paintbrush application using various GDI components.

Aim: Create a simple Paintbrush application using various GDI components.

Theory: GDI is responsible for tasks such as drawing lines and curves, rendering fonts and handling palettes. It is not directly responsible for drawing windows, menus, etc.: that task is reserved for the user subsystem, which resides in user32.dll and is built atop GDI. GDI is similar to Apple’s classic QuickDraw.

Perhaps the most significant capability of GDI over more direct methods of accessing the hardware is its scaling capabilities, and abstraction of target devices. Using GDI, it is very easy to draw on multiple devices, such as a screen and a printer, and expect proper reproduction in each case. This capability is at the centre of all WYSIWYG applications for Microsoft Windows.

Simple games which do not require fast graphics rendering, such as Freecell or Minesweeper, use GDI. However, GDI cannot animate properly (no notion of synchronizing with the framebuffer) and lacks rasterization for 3D. Modern games use DirectX or OpenGL, which give programmers access to more hardware capabilities.

In Windows Vista, GDI applications running in the new compositing engine, Desktop Window Manager, will no longer be hardware-accelerated.

With the introduction of Windows XP, GDI was deprecated in favor of its successor, the C++ based GDI+ subsystem. GDI+ is a “next generation” 2D graphics environment, adding advanced features such as anti-aliased 2D graphics, floating point coordinates, alpha blending, gradient shading, more complex path management, intrinsic support for modern graphics-file formats like JPEG and PNG (which were conspicuously absent in GDI), and general support for composition of affine transformations in the 2D view pipeline. Use of these features is apparent in Windows XP’s user interface, and their presence in the basic graphics layer greatly simplifies implementations of vector-graphics systems such as Flash or SVG. The GDI+ dynamic library can be shipped with an application and used under older versions of Windows.

The Microsoft .NET class library provides a managed interface for GDI+ via the System.Drawing namespace.

GDI+ is similar (in purpose and structure) to Apple’s Quartz 2D subsystem, and the open-source libart and Cairo libraries.

Microsoft Windows GDI+ draws lines, rectangles, and other figures on a coordinate system. You can choose from a variety of coordinate systems, but the default coordinate system has the origin in the upper left corner with the x-axis pointing to the right and the y-axis pointing down. The unit of measure in the default coordinate system is the pixel.

default coordinate system

A computer monitor creates its display on a rectangular array of dots called picture elements or pixels. The number of pixels appearing on the screen varies from one monitor to the next, and the number of pixels appearing on an individual monitor can usually be configured to some extent by the user.

rectangular array of pixels

When you use GDI+ to draw a line, rectangle, or curve, you provide certain key information about the item to be drawn. For example, you can specify a line by providing two points, and you can specify a rectangle by providing a point, a height, and a width. GDI+ works in conjunction with the display driver software to determine which pixels must be turned on to show the line, rectangle, or curve. The following illustration shows the pixels that are turned on to display a line from the point (4, 2) to the point (12, 8).

line, as displayed by a rectangular array of pixels

Over time, certain basic building blocks have proven to be the most useful for creating two-dimensional pictures. These building blocks, which are all supported by GDI+, are given in the following list:

* Lines

* Rectangles

* Ellipses

* Arcs

* Polygons

* Cardinal splines

* Bzier splines

The Graphics class in GDI+ provides the following methods for drawing the items in the previous list: DrawLine, DrawRectangle, DrawEllipse, DrawPolygon, DrawArc, DrawCurve (for cardinal splines), and DrawBezier. Each of these methods is overloaded; that is, each method comes in several variations with different parameter lists. For example, one variation of the DrawLine method receives the address of a Pen object and four integers, while another variation of the DrawLine method receives the address of a Pen object and two Point object references.

The methods for drawing lines, rectangles, and Bzier splines have plural companion methods that draw several items in a single call: DrawLines, DrawRectangles, and DrawBeziers. Also, the DrawCurve method has a companion method, DrawClosedCurve, that closes a curve by connecting the ending point of the curve to the starting point.

All the drawing methods of the Graphics class work in conjunction with a Pen object. Thus, in order to draw anything, you must create at least two objects: a Graphics object and a Pen object. The Pen object stores attributes of the item to be drawn, such as line width and color. The address of the Pen object is passed as one of the arguments to the drawing method. For example, one variation of the DrawRectangle method receives the address of a Pen object and four integers as shown in the following code, which draws a rectangle with a width of 100, a height of 50 and an upper-left corner of (20, 10).

myGraphics.DrawRectangle(&myPen, 20, 10, 100, 50);

Conclusion: We have successfully implemented paint brush using GDI.

Study of free and open source software WINE

January 20, 2012 by ProjectsGeek Leave a Comment

Study of free and open source software WINE

WINE

AIM: Study of free and open source software WINE

THEORY: Wine is a project which aims to allow a PC running a UNIX-like operating system and the X-windows system to execute programs originally written for Microsoft Windows. Rather than acting as a full emulator Wine implements a compatibility layer providing alternative implementations of the DLLs that Windows programs call. Windows programs running in Wine act as native programs would, running without the performance or memory usage penalties of an emulator.

winecfg:

winecfg is a GUI configuration utility for Wine. winecfg makes configuring Wine easier by making it unnecessary to edit the registry directly.

WINE Features:

• Loads Windows 9x/NT/2000/XP, Windows 3.x and DOS programs and libraries

• Win32 compatible memory layout, exception handling, threads and processes

• Designed for POSIX compatible operatings systems (eg. Linux and FreeBSD)

• “bug-for-bug” compatibility with Windows

• X11-based graphics allows remote display to any X terminal

• X11, TrueType (.ttf/.ttc) and Windows Bitmap (.fon) Fonts

• DirectX support for games (limited Direct3D support)

• Support for OpenGL based games and applications

• Printing via PostScript driver or legacy native Win16 printer drivers

• Enhanced Metafile (EMF) and Windows Metafile (WMF) driver

• Desktop-in-a-box or mixable windows

• Windows MultiMedia (WinMM) layer support with builtin codecs

• Designed for source and binary compatibility with Win32 code

• Win32 API test suite to ensure compatibility

• Compilable on a wide range of C compilers

• Permits mixing of Win32 and POSIX code

• Win32 compatible header files

• Automatically generated API documentation

• Resource compiler

• Message compiler

• IDL compiler

• Extensive Unicode support

• Internationalization — Wine supports 16 languages

• Built-in debugger and configurable trace messages

Benefits Of WINE:

Wine provides following benefits over Windows right now:

• Wine makes it possible to take advantage of all the Unix strong points (stability, flexibility, remote administration) while still using the Windows applications you depend on.

• Unix has always made it possible to write powerful scripts. Wine makes it possible to call Windows applications from scripts that can also leverage the Unix environment to its full extent.

• Wine makes it possible to access Windows applications remotely, even if they are a few thousand miles away.

• Wine makes it economical to use thin clients: simply install Wine on a Linux server, and voila, you can access these Windows applications from any X terminal.

• Wine can also be used to make existing Windows applications available on the Web by using VNC and its Java client.

• Wine is Open Source Software, so you can extend it to suit your needs or have one of many companies do it for you.

Using WINE

You can simply invoke the wine command to get a small help message:

Wine 20040405

Usage: wine PROGRAM [ARGUMENTS…] Run the specified program

wine –help Display this help and exit

wine –version Output version information and exit

The first argument should be the name of the file you want wine to execute. If the executable is in the Path environment variable, you can simply give the executable file name. However, if the executable is not in Path, you must give the full path to the executable (in Windows format, not UNIX format!). For example, given a Path of the following:

Path=”c:\windows;c:\windows\system;e:\;e:\test;f:\”

You could run the file c:\windows\system\foo.exe with:

$ wine foo.exe

However, you would have to run the file c:\myapps\foo.exe with this command:

$ wine c:\\myapps\\foo.exe

CONCLUSION-Hereby,we have studied the free and open source software,WINE.

To create a window application (WinDIR app/ Drive Tree app.) using different GUI components and Direct view architecture.

January 20, 2012 by ProjectsGeek Leave a Comment

To create a window application (WinDIR app/ Drive Tree app.) using different GUI components and Direct view architecture.

AIM:

To create a window application (WinDIR app/ Drive Tree app.) using different GUI components and Direct view architecture.

THEORY:

Windows is a graphics based multitasking operating system. To help in the development of Windows applications Windows provides numerous built in functions that allow for the easy implementation of pop up menus, scroll bars, dialog boxes, icons and many other features that represent a user friendly interface.

THE LAYOUT OF A WINDOW:

The basic features that are common to all Windows applications are as follows:

Border

Title Bar

Control Icon

System Menu

Minimize Icon

Maximize Icon

Close Window Icon

Vertical Scroll Bar

Horizontal Scroll Bar

Menu Bar

Client Area

CONCLUSION:

Thus we made an application in direct view architecture using above given GUI features of Windows.

To study various components of Mailman and the installation of the same package.

January 20, 2012 by ProjectsGeek Leave a Comment

To study various components of Mailman and the installation of the same package.

Mailman

Aim : To study various components of Mailman and the installation of the same package.

Theory: GNU Mailman is a GNU package for managing electronic mailing lists. It is free software, distributed freely under the GNU General Public License. Mailman’s chief distinction is its easy-to-use web interface for list administration.
Mailman is written in the Python programming language. It can work with any common Unix mail server software, including Postfix,Sendmail and gmail.
The integration with the free mail server software exim (which is used by the Debian GNU/Linux by default) is probably best: Using special configuration rules, exim knows which addresses are used by Mailman and automatically forwards all mails which are handled by Mailman to Mailman, without having to set customized aliases for each individual mailing list, as it is custom with most or all other mail servers.
User features include the Web interface, built-in archiving of messages, automatic processing of bounce messages, digest mode, and spam filtering.
By default, Mailman sends out a reminder message on the first of the month (local time) to all subscribers, causing many netizens to proclaim the first of the month to be “Mailman Day” as the messages start trickling in from all around the globe
What is a mailing list?
A mailing list is simply a list of addresses to which the same information is being sent. If you were a magazine publisher, you would have a list of the mailing addresses of all the subscribers to the magazine. In the case of an electronic mailing list, we use a list of email addresses from people interested in hearing about or discussing a given topic.
Two common types of email mailing lists are announcement lists and discussion lists.
Announcement lists are used so that one person or group can send announcements to a group of people, much like a magazine publisher’s mailing list is used to send out magazines. For example, a band may use an announcement mailing list to let their fan base know about their upcoming concerts.
A discussion list allows a group of people to discuss topics amongst themselves, with everyone able to send mail to the list and have it distributed to everyone in the group. This discussion may also be moderated, so only selected posts are sent on to the group as a whole, or only certain people are allowed to send to the group. For example, a group of model plane enthusiasts might use a discussion mailing list to share tips about model construction and flying.
Some common terms:

A “post” typically denotes a message sent to a mailing list. (Think of posting a message on a bulletin board.)
People who are part of an electronic mailing list are usually called the list’s “members” or “subscribers.”
“List administrators” are the people in charge of maintaining that one list. Lists may have one or more administrators.
A list may also have people in charge of reading posts and deciding if they should be sent on to all subscribers. These people are called list moderators.
Often more than one electronic mailing list will be run using the same piece of software. The person who maintains the software which runs the lists is called the “site administrator.” Often the site administrator also administrates individual lists.

Conclusion: We have successfully studied and learnt to install ‘MAILMAN’ and its various components.

Creation of activex document dll using visual basic and register it.

January 20, 2012 by ProjectsGeek Leave a Comment

Creation of activex document dll using visual basic and register it.

Aim : Creation of activex document dll using visual basic and register it.

Theory:

Activex document :

General definition :

The easiest way to describe an ActiveX document is to call it a Visual Basic form that appears within a browser. Though not technically accurate – it does allow you to picture what is going on with ActiveX documents.

Technical defintion:

To be more technically accurate, an ActiveX document is a structured storage file that is displayed by an ActiveX component. The structured storage file is the VBD file you may have heard about and the ActiveX component is the ActiveX Document EXE or ActiveX Document DLL that you build when you define the ActiveX document project.

.Exe versus .dll:

Visual Basic offers you the choice of creating your ActiveX document project as an .EXE or a DLL. The differences between these lie in speed and safety. An .EXE runs “out of process” with respect to its container (the browser), which means that it has its own memory space. Communication between separate processes is slower, but because the .EXE runs in its own memory space, it can crash without causing the container to crash. A DLL runs “in process,” sharing the same memory space as the container. Intra-process communication is a lot faster, but a bug in the DLL can crash the container. Functionally, there is no difference between .EXE and DLLÑyou select one or the other depending on whether utmost speed or crash protection is more important to you.

Creation of Activex document:

An ActiveX document project is made up of a document that contains the data, and a server, or application, that provides the functionality. After compilation, the document is contained in a Visual Basic Document file (.VBD) and the server is contained in either an .EXE or .DLL file. During development, the project is in a .DOB file, which is a plain text file containing the definitions of the project’s controls, source code, and so on. If an ActiveX document project contains graphical elements that cannot be stored in text format, they will be kept in a .DOX file. The .DOB and .DOX files in an ActiveX document project are parallel to the .FRM and .FRX files of a regular Visual Basic executable project.

Deployment of activex document:

What are the logistics of deploying an ActiveX document? A deployment consists of one .VBD file for each document in the project, plus a compressed CAB file containing the compiled DLL or .EXE file. The CAB file may also contain the Visual Basic runtime and support files, or you can specify that these be downloaded directly from Microsoft’s site. This latter option reduces the size of your deployment but does not remove the requirement that the Visual Basic runtime and support files must be downloaded—only once, however—unless the user already has these files on the local system. This requirement for support-file download is another reason why ActiveX documents are more suitable for specific Web-based applications and are less suitable for a general “public” Web page.

Navigation of activex Document :

When a user navigates to an ActiveX document for the first time, here’s what happens:

1. The CAB file is downloaded.

2. The .EXE or DLL that contains the server is extracted from the CAB file and installed on the system.

3. If required, the Visual Basic runtime and support files are installed, either from the CAB or from the Microsoft download site.

4. The VBD file is either downloaded to the local computer or, more often, opened from the remote location.

Registration of .dll/.exe/.ocx :

REGSVR32 is a command-line tool that has a simple set of options

REGSVR32 command-line options.

Option description:

/u Unregister the specified COM server

/s Register the COM server silently (with no visible output)

/c Register the COM server with output to the console

The REGSVR32 tool is used with the following command-line syntax:

regsvr32 filename.xxx

Algorithm:

Listing 1. GetPathFromFullFileName

Public Function GetPathFromFullFileName(FullFileName As String) _
As String
' Passed a fully qualified filename, removes
' the filename part and returns the path information.
' Returns a blank string if there is no path information.

b>Strip any spaces.
FullFileName = Trim(FullFileName)
' Check for empty argument.
If Len(FullFileName) = 0 Then
GetPathFromFullFileName = ""
Exit Function
End If

c> Look for last / or \.

If Mid$(FullFileName, idx, 1) = "\" Or _
Mid$(FullFileName, idx, 1) = "/" GetPathFromFullFileName = Left$(FullFileName, idx)

Listing 2. Code in UserDocument1

a>

Private Sub UserDocument_InitProperties()
' Initialize the document's two data items.
End Sub
b> path = GetPathFromFullFileName(UserDocument.Parent.LocationURL)

Hyperlink.NavigateTo path & "UserDocument2.vbd"
d>

Private Sub txtUserName_Change()
' Tell the container than a property has changed.
PropertyChanged "UserName"
e>

'Tell the container that a property has been changed.
PropertyChanged "UserComment"

f> UserDocument_ReadProperties(PropBag As PropertyBag)
' Read the document's two data items from the property bag.
txtUserName.Text = PropBag.ReadProperty("UserName", "")
UserComment = PropBag.ReadProperty("UserComment", "")

UserDocument_WriteProperties(PropBag As PropertyBag)
' Write the document's two data items to the property bag.
PropBag.WriteProperty "UserComment", UserComment
PropBag.WriteProperty "UserName", txtUserName.Text

Listing 3. Code in UserDocument2

Private Sub cmdGoBack_Click()
Hyperlink.GoBack
End Sub

Conclusion:

finally , we have implemented the assignment successfully with understanding of basic features of acitvex document dll & creation of it using visual basic and at the last we register it.

To study KDE desktop Environment.

The Kdesktop Environment

The K Development Environment

Create a simple Paintbrush application using various GDI components.

Study of free and open source software WINE

To create a window application (WinDIR app/ Drive Tree app.) using different GUI components and Direct view architecture.

To study various components of Mailman and the installation of the same package.

Creation of activex document dll using visual basic and register it.

Download Java Project

Download Visual Basic Projects

Download .Net Projects

Download VB Projects

Download C++ Projects

Download NodeJs Projects

Download School Projects

Download School Projects

Ask Questions - Forum

Latest Projects Ideas

Assembly Codes

Datastructure Assignments

Computer Graphics Lab

Operating system Lab

Software Lab Assignments

The Kdesktop Environment

The K Development Environment

Other Projects to Try:

Other Projects to Try:

Other Projects to Try:

Other Projects to Try:

Other Projects to Try:

Other Projects to Try:

Footer