3/19/2015

How to print asp.net panel contents using javascript

How to print asp.net panel contents using javascript



In this article explained how to print the contents of ASP.Net Panel control using JavaScript.
< html xmlns="http://www.w3.org/1999/xhtml">
< head>
< title>< /title >
        < script type = "text/javascript">
        function PrintPanel() {
        var panel = document.getElementById("ctl00_ContentPlaceHolder1_Panel1<%=Panel1.ClientID %>");
        var printWindow = window.open('', '', 'height=400,width=800');
        printWindow.document.write('');
        printWindow.document.write('');
        printWindow.document.write(panel.innerHTML);
        printWindow.document.write('');
        printWindow.document.close();
        setTimeout(function () {
                                                printWindow.print();
                                            }, 500);
        return false;
        }
        < /script>
< /head>
< body>
        < form id="form1" >
        < asp : Panel id="Panel1" >
                < span style="font-size: 10pt; font-weight:bold; font-family: Arial">HI ,
                    This is < span style="color: #18B5F0">EasyWay Programming. < /span>
                    EasywayProgramming.com
                    easywayprogramming.blogspot.in < /span>
        < /asp:Panel>

        < asp:Button ID="btnPrint" Text="Print" OnClientClick = "return PrintPanel();" />
        < /form>
< /body>
< /html>

In the above HTML Markup has an ASP.Net Panel control Panel1 whose contents needs to be printed and an ASP.Net Button btnPrint which has an OnClientClick event which will call the JavaScript method PrintPanel() to print the contents of the Panel

3/18/2015



Storage classes in C Programming


A storage class defines the scope(visibility) and liftime of variables and/or functions within a C program. These specifiers precede the type that they modify. There are following storage classes that can be used in c program.
  • auto
  • register
  • static
  • extern
The auto Storage Class :
        The auto storage class is default storage class of all local variables.
    {
           int sum;
           auto int sum1;
    }
      The example above defines two variables with the same storage class, auto can only be used within functions, i.e., local variables.

The register Storage Class :
        The register storage class is used to define local variables that should be stored in a register instead of RAM. This means that variable has a maximum size equal to the register size(usually one word).
    {
           register int sum;
    }
      The register should only be used for variables that requires quick access such as counters. Is should also be noted that defining 'register' does not mean that the variable will be stored in a register. It means that it MIGHT be stored in register depending on hardware and implementation restrictions.

The static Storage Class :
        The static storage class iinstruct compiler to keep a local variables in existance during the lifetime of the programm istead of creating and destroying it each time it comes into and goes out of scope. Therefore making local variables static allows them to maintain their values between function calls.
The static modifier may also applied to global variables. When this is done, it causes that variable scope to be resricted to the file in which it is declared.

#include
/* function declaration */
void func();
static int count = 5; /* global variable */

main()
{
while(count--)
    {
           func();
    }
}
/* function declaration */
void func()
{
static int i = 5; /* local static variable */
i++;

printf(" i is %d and count is %d\n", i, count);

      When the above code is compiled and executed, it produces the following result:
i is 6 and count is 4
i is 7 and count is 3
i is 8 and count is 2
i is 9 and count is 1
i is 10 and count is 0

The extern Storage Class :
        The extern storage class is used to give reference of global variables that is visible to ALL the program files. When u use 'extern', the variable cannot be initialized as all it does is point the variable name at a storage location that has been previously defined.
When u have multiple files and you define a global variable or function, which will be used in other files also, then extern will be used in another file to give reference of defined variable or function in another file. Example is as below.
    {
           register int sum;
    }
      The register should only be used for variables that requires quick access such as counters. Is should also be noted that defining 'register' does not mean that the variable will be stored in a register. It means that it MIGHT be stored in register depending on hardware and implementation restrictions.

Datatypes in C Programming easyway

Datatypes in C easyway:

C has a concept of 'data types' which are used to define a variable before its use. The definition of a variable will assign storage for the variable and define the type of data that will be held in the location.
The value of a variable can be changed any time. C has the following basic built-in datatypes.
  • int
  • float
  • double
  • char
Please note that there is not a boolean data type. C does not have the traditional view about logical comparison, but thats another story.
int - data type
is used to define integer numbers.
{
    int Count;
    Count = 5;
}
float - data type
float is used to define floating point numbers.
{
    float Miles;
    Miles = 5.6;
}
double - data type
 double is used to define BIG floating point numbers. It reserves twice the storage for the number. On PCs this is likely to be 8 bytes.
{
    double Atoms;
    Atoms = 2500000;
}
char - data type
char defines characters.
{
    char Letter;
    Letter = 'x';
}
Modifiers The data types explained above have the following modifiers.
  • short
  • long
  • signed
  • unsigned
          modifiers define the amount of storage allocated to the variable. The amount of storage allocated is not cast in stone. ANSI has the following rules:    
                    short int <=        int  <= long int
                          float <= double  <= long double
What this means is that a 'short int' should assign less than or the same amount of storage as an 'int' and the 'int' should be less or the same bytes than a 'long int'. What this means in the real world is:

                            Type       Bytes                     Range
---------------------------------------------------------------------

                            short int     2                 -32,768  ->  +32,767                 (32kb)
            unsigned short int      2                           0  ->  +65,535                 (64Kb)
                     unsigned int      4                           0  ->  +4,294,967,295     ( 4Gb)
                                     int     4     - 2,147,483,648  ->  +2,147,483,647    ( 2Gb)
                             long int     4      -2,147,483,648  ->  +2,147,483,647    ( 2Gb)
                      signed char     1                       -128  ->  +127
                  unsigned char     1                            0  ->  +255
                                  float     4
                              double     8
                      long double     12

These figures only apply to todays generation of PCs. Mainframes and midrange machines could use different figures, but would still comply with the rule above.
You can find out how much storage is allocated to a data type by using the sizeof operator discussed in Operator Types Session.
Here is an example to check size of memory taken by various datatypes.
int main()
{
    printf("sizeof(char) == %d\n", sizeof(char));
    printf("sizeof(short) == %d\n", sizeof(short));
    printf("sizeof(int) == %d\n", sizeof(int));
    printf("sizeof(long) == %d\n", sizeof(long));
    printf("sizeof(float) == %d\n", sizeof(float));
    printf("sizeof(double) == %d\n", sizeof(double));
    printf("sizeof(long double) == %d\n", sizeof(long double));
    printf("sizeof(long long) == %d\n", sizeof(long long));

    return 0;
}
Qualifiers
A type qualifier is used to refine the declaration of a variable, a function, and parameters, by specifying whether:
The value of a variable can be changed.
The value of a variable must always be read from memory rather than from a register
Standard C language recognizes the following two qualifiers:
  • const
  • volatile
The const qualifier is used to tell C that the variable value can not change after initialisation.
const float pi=3.14159;
Now pi cannot be changed at a later time within the program.
Another way to define constants is with the #define preprocessor which has the advantage that it does not use any storage
The volatile qualifier declares a data type that can have its value changed in ways outside the control or detection of the compiler (such as a variable updated by the system clock or by another program). This prevents the compiler from optimizing code referring to the object by storing the object's value in a register and re-reading it from there, rather than from memory, where it may have changed. You will use this qualifier once you will become expert in "C". So for now just proceed.

What are Arrays:
We have seen all baisc data types. In C language it is possible to make arrays whose elements are basic types. Thus we can make an array of 10 integers with the declaration.
    int x[10];
The square brackets mean subscripting; parentheses are used only for function references. Array indexes begin at zero, so the elements of x are:
Thus Array are special type of variables which can be used to store multiple values of same data type. Those values are stored and accessed using subscript or index.
Arrays occupy consecutive memory slots in the computer's memory.
    x[0], x[1], x[2], ..., x[9]
If an array has n elements, the largest subscript is n-1.
Multiple-dimension arrays are provided. The declaration and use look like:

    int name[10] [20];
    n = name[i+j] [1] + name[k] [2];

Subscripts can be arbitrary integer expressions. Multi-dimension arrays are stored by row so the rightmost subscript varies fastest. In above example name has 10 rows and 20 columns.

Same way, arrays can be defined for any data type. Text is usually kept as an array of characters. By convention in C, the last character in a character array should be a `\0' because most programs that manipulate character arrays expect it. For example, printf uses the `\0' to detect the end of a character array when printing it out with a `%s'.

Here is a program which reads a line, stores it in a buffer, and prints its length (excluding the newline at the end).

main( ) {
    int n, c;
    char line[100];
    n = 0;
    while( (c=getchar( )) != '\n' ) {
    if( n < 100 )
    line[n] = c;
    n++;
    }
    printf("length = %d\n", n);
}

Array Initialization
As with other declarations, array declarations can include an optional initialization
Scalar variables are initialized with a single value
Arrays are initialized with a list of values
The list is enclosed in curly braces

int array [8] = {2, 4, 6, 8, 10, 12, 14, 16};
The number of initializers cannot be more than the number of elements in the array but it can be less in which case, the remaining elements are initialized to 0.if you like, the array size can be inferred from the number of initializers by leaving the square brackets empty so these are identical declarations:
int array1 [8] = {2, 4, 6, 8, 10, 12, 14, 16};
int array2 [] = {2, 4, 6, 8, 10, 12, 14, 16};
An array of characters ie string can be initialized as follows:
char string[10] = "Hello";

9/27/2012

How to create a jar file of application created in java

 easywayprogramming.com how to create jar file of application in java

Step 1:- Copy all the class files & file & folders required for application in folder

Step 2:- Setting environmental variable
             Open command prompt. Go to folder where your application exists.
             Set environmental variable by executing following command
             set path="c:/program files/ java/ jdk 1.5/ bin"; 
where path string is path of jdk/bin installed in your PC

Step 3:- Creating a jar file:
             Execute following command at command prompt.
             jar cvf application_name.jar *.*
             press enter. Your jar file is created.

Step 4:- Now open that jar file with winrar.
             Open manifest.mf file in notepad. manifest.mf file exists in folder META-INF folder. Write following line in last of file
             Main-Class: Name of first opening frame main class file of your application without .class extension without extension, for example password screen.
             Example, Main-Class: password_screen

             save changes to file.

                Double click on jar file. See what happens.

8/29/2012

Example of Java 2D Graphics

easywayprogramming.com example of 2D graphics in java 

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;

/** An example of drawing/filling shapes with Java 2D in
* Java 1.2 and later.
*/

public class ShapeExample extends JPanel
{
    private Ellipse2D.Double circle =
    new Ellipse2D.Double(10, 10, 350, 350);
    private Rectangle2D.Double square =
    new Rectangle2D.Double(10, 10, 350, 350);

    public void paintComponent(Graphics g)
    {
        //clear(g);
        Graphics2D g2d = (Graphics2D)g;
        g2d.setPaint(Color.black);
        g2d.fill(circle);
        g2d.draw(square);
    }

    /*protected void clear(Graphics g)
    {
        super.paintComponent(g);
    }*/

    protected Ellipse2D.Double getCircle()
    {
        return(circle);
    }

    public static void main(String[] args)
    {
        ShapeExample se=new ShapeExample();
        JFrame frm=new JFrame("Shape");
        Container c=frm.getContentPane();
        c.add(se);
        frm.setContentPane(c);
        frm.setSize(380,400);
        frm.setVisible(true);
    }
}

Java 2D graphics in Java

easywayprogramming.com 2D graphics in java 

public void paintComponent(Graphics g)
{
         // Clear background if opaque
          super.paintComponent(g);

        // Cast Graphics to Graphics2D
         Graphics2D g2d = (Graphics2D)g;

        // Set pen parameters
         g2d.setPaint(fillColorOrPattern);
         g2d.setStroke(penThicknessOrPattern);
         g2d.setComposite(someAlphaComposite);
         g2d.setFont(anyFont);
         g2d.translate(...);
         g2d.rotate(...);
         g2d.scale(...);
         g2d.shear(...);
         g2d.setTransform(someAffineTransform);

        // Allocate a shape
        SomeShape s = new SomeShape(...);

       // Draw shape
        g2d.draw(s); // outline
        g2d.fill(s); // solid
}

Drawing Shapes in 2D Graphics:
            With the AWT, you generally drew a shape by calling the drawXxx or fillXxx
method of the Graphics object. In Java 2D, you generally create a Shape object,
then call either the draw or fill method of the Graphics2D object, supplying the
Shape object as an argument. For example:
public void paintComponent(Graphics g)
{
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        // Assume x, y, and diameter are instance variables.
       Ellipse2D.Double circle = new Ellipse2D.double(x, y, diameter, diameter);
       g2d.fill(circle);
...
}

Most of the Shape classes define both a Shape.Double and a Shape.Float version
of the class. Depending on the version of the class, the coordinate locations are
stored as either double precision numbers (Shape.Double) or single precision
numbers (Shape.Float). The idea is that single precision coordinates might be
slightly faster to manipulate on some platforms. You can still call the familiar
drawXxx methods of the Graphics class if you like; the Graphics2D object inherits
from the Graphics object. This approach is necessary for drawString and
drawImage and possibly is convenient for draw3DRect.
Shape Classes

public Ellipse2D.Float(float left, float top, float width,
float height)
public Ellipse2D.Double(double left, double top,
double width, double height)

These constructors create an ellipse bounded by a rectangle of dimension
width by height. The Ellipse2D class inherits from the Rectangular-
Shape class and contains the same methods as common to Rectangle2D and
RoundRectangle2D.

public GeneralPath()
A GeneralPath is an interesting class because you can define all the line segments
to create a brand-new Shape. This class supports a handful of methods
to add lines and Bézier (cubic) curves to the path: closePath, curveTo,
lineTo, moveTo, and quadTo. Appending a path segment to a General-
Path without first performing an initial moveTo generates an IllegalPath-
StateException. An example of creating a GeneralPath follows:
GeneralPath path = new GeneralPath();
path.moveTo(100,100);
path.lineTo(300,205);
path.quadTo(205,250,340,300);
path.lineTo(340,350);
path.closePath();

public Line2D.Float(float xStart, float yStart, float xEnd,
float yEnd)
public Line2D.Double(double xStart, double yStart,
double xEnd, double yEnd)

These constructors create a Line2D shape representing a line segment from
(xStart, yStart) to (xEnd, yEnd).

public QuadCurve2D.Float(float xStart, float yStart,
float pX, double pY,
float xEnd, float yEnd)
public QuadCurve2D.Double(double xStart, double yStart,
double pX, double pY,
double xEnd, double yEnd)

These constructors create a Shape representing a curve from (xStart,
yStart) to (xEnd, yEnd). The point (pX, pY) represents a control point
impacting the curvature of the line segment connecting the two end points.

public Rectangle2D.Float(float top, float left, float width,
float height)
public Rectangle2D.Double(double top, double left,
double width, double height)

These constructors create a Rectangle2D shape with the upper-left corner
located at (top, left) and a dimension of width by height.

public RoundRectangle2D.Float(float top, float left,
float width, float height,
float arcX, float arcY)
public RoundRectangle2D.Double(double top, double left,
double width, double height,
double arcX, double arcY)

These two constructors create a RectangleShape with rounded corners. The
upper-left corner of the rectangle is located at (top, left), and the dimension
of the rectangle is width by height. The arguments arcX and arcY represent
the distance from the rectangle corners (in the respective x direction and y
direction) at which the rounded curve of the corners start.

Most of the code examples throughout this chapter are presented as Java applications.
To convert the examples to applets, follow the given template:
import java.awt.*;
import javax.swing.*;
public class YourApplet extends JApplet {
public void init() {
JPanel panel = new ChapterExample();
panel.setBackground(Color.white);
getContentPane().add(panel);
}
}


Click here:
Example of java 2D graphics

7/14/2012

How to copy Mysql databse from one Computer to another / backup database using mysqldump

             We can take backup of MySQL database by using musqldump.
             We can transfer a MySQL database from one PC to another PC using mysqldump command. We have to create dump file of database to transfer database from one PC to another PC.
          MySQL databse is not portable database i.e. we cannot transfer it from one PC to another PC by copying and pasting it. We can use following method to transfer database.

1.   Creating a dumpfile from database/ Taking backup of MySQL database:
-  Open command prompt.
-  Execute following commands to change directory
>c:  “press enter”
>cd  program files/MySQL/MySQL Server 5.1/ bin “press enter”
>mysqldump -u root  -p databse_name > database_name.sql  “press enter”
  Enter password: password of MySQL

Copy sql file and paste it in PC where you want to transfer database.

.          2. Dumping sql file into database:-
          - Open MySQL  command line client command prompt.
          - Execute following command to create database.
                 >create database database_name;  “press enter”
Database name is must as that of your database _name.
Copy that sql file into location “c:/program files/MySQL/MySQL Server 5.1/bin”

          - Now open command prompt and execute following commands.
                >C: “press enter”
                >cd program files/MySQL/MySQL Server5.1/bin “press enter”
                >mysql –u root –p database_name < database_name.sql “press enter”

           Your database is created on PC.
           Now in MySQL command prompt check your database.