JDesktopPane creates inner frame menuItem actionPerformed does not.

[James Howerton]

Hello could someone help me figure out how to make my menu item work? It calls createFrame() to add an additional inner frame. It runs but nothing is added to the JDesktopPane.

   
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package application1;

import guide.Guide;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import menu.Menu;

/**
 *
 * @author depot
 */
public class DesktopPane extends JFrame {

    JDesktopPane jdp;
    JMenu menu;
    static int openFrameCount = 0;
    public JTabbedPane guideContentPaneObject;
    public JFrame frame;

    public DesktopPane() throws IOException {
        super("Guide DesktopPane");
        int inset = 50;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds(inset, inset, screenSize.width - inset * 2, screenSize.height - inset * 2);
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        jdp = new JDesktopPane();
        createFrame();
        setContentPane(jdp);
        Menu menu = new Menu();
        setJMenuBar(menu.createMenu());
        jdp.putClientProperty("JDesktopPane.dragMode", "outline");
        
    }
    

    //throw new UnsupportedOperationException("Not yet implemented");
    public void createFrame() throws IOException {
        InternalFrame frame=new InternalFrame();
        //Guide g = new Guide();
        //g.setType("guide");//sets what type of tabbedPanel to make
        //g.createGuide();
        //JPanel contentPane = new JPanel(new BorderLayout());
        //SetObjects so = new SetObjects();
        //contentPane.add(so.obj());//sets the JTabbedPane that was created on JPanel
        //frame.setContentPane(contentPane);//puts JPanel on Frame
        
        frame.setVisible(true);
        jdp.add(frame);
        

    }


   

    public class InternalFrame extends JInternalFrame {

        static final int xPosition = 30, yPosition = 30;

        public InternalFrame() throws FileNotFoundException, IOException {
            super("Guide" + (++openFrameCount), true, true, true, true);
            setVisible(true);
            setSize(300, 300);
            setLocation(xPosition * openFrameCount, yPosition * openFrameCount);


        }
    }

      public JTabbedPane getGuideContentPaneObject() {
        return guideContentPaneObject;
    }

    public void setGuideContentPaneObject(JTabbedPane guideContentPaneObject) {
        this.guideContentPaneObject = guideContentPaneObject;
    }
    public static void main(String[] args) throws IOException {
        DesktopPane frame = new DesktopPane();
        frame.setVisible(true);
    }
}

 

[Rok Štelcer]

Your example is almost "the same" as the one from Sun's for internal frames:
- InternalFrameDemo.java
- MyInternalFrame.java

[James Howerton]

Yes, it is. But I can't get it to load more than one internal frame
thanks

[James Howerton]

The only differences are that I have a class tho add to the frame.add() and the JMenu is created in the Menu.java.

I have to do something to the action performed or something because it calls createFrame.
Something is wrong with my menuItem.

It can create how ever many frames I want if I call createFrame over and over in the class
'
I tried the .addActionListener

I tried the

nw.addMouseListener(new java.awt.event.MouseAdaptor(){
public void mousePressed(java.awt.event.MouseEvent evt){
try{
dp=new DesktopPane();
dp.createFrame()

}catch(IOException ex){
ex.printStackTrace();
}
}

});

no new frames
thanks








E

[Michael Dunn]

what do you think this line does? (in mousePressed)

dp=new DesktopPane();

[James Howerton]

the desktop runs from main creating

the first internal frame perfect

it says it created more (too many

infact)

but nothing gets painted to JDesktopPane

is there a way to get the Jmenu to

create one more internalframe?



Desktop class

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package application1;

import guide.Guide;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.beans.PropertyVetoException;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
import menu.Menu;

/**
 *
 * @author depot
 */
public class DesktopPane extends JFrame {

    JDesktopPane jdp;
    JMenu menu;
    public static int openFrameCount = 0;
    public JTabbedPane guideContentPaneObject;
    public JFrame frame;
    public int i;

    public DesktopPane() throws IOException {
        super("Guide DesktopPane");
        int inset = 50;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds(inset, inset, screenSize.width - inset * 2, screenSize.height - inset * 

2);
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        jdp = new JDesktopPane();
       
        createFrame();
       
        setContentPane(jdp);
        Menu menu = new Menu();
        setJMenuBar(menu.createMenu());
        jdp.putClientProperty("JDesktopPane.dragMode", "outline");
        
    }
    

    //throw new UnsupportedOperationException("Not yet implemented");
    public void createFrame() throws IOException {
        System.out.println("back in the create Frame() number of frames= "+openFrameCount);
        InternalFrame frame=new InternalFrame();       
        JPanel contentPane = new JPanel(new BorderLayout());
        SetObjects so = new SetObjects();
        so.setType("guide");
        so.initComponents();
        contentPane.add(so.obj());//sets the JTabbedPane that was created on JPanel
        frame.add(contentPane);//puts JPanel on Frame
        frame.setVisible(true);
        try {
            frame.setSelected(true);
        } catch (PropertyVetoException ex) {
            ex.printStackTrace();
        }
        

        jdp.add(frame);
    }

    public class InternalFrame extends JInternalFrame {
        static final int xPosition = 30, yPosition = 30;

        public InternalFrame() throws FileNotFoundException, IOException {
            super("Guide" + (++openFrameCount), true, true, true, true);
            System.out.println("internal frame openFrameCount= "+openFrameCount);
            setVisible(true);
            setSize(750, 500);
            setLocation(xPosition * openFrameCount, yPosition * openFrameCount);
        }
    }

      public JTabbedPane getGuideContentPaneObject() {
        return guideContentPaneObject;
    }

    public void setGuideContentPaneObject(JTabbedPane guideContentPaneObject) {
        this.guideContentPaneObject = guideContentPaneObject;
    }
    public static void main(String[] args) throws IOException {
        DesktopPane frame = new DesktopPane();
        frame.setVisible(true);
    }
}

Jmenu actionEvent

 ///////////////////////////////////////////////////////////////////
        ////// file ////////////     new Guide      /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        ng = new JMenuItem();
        ng = (JMenuItem) jMenuFile.add(new JMenuItem("New Guide"));
        jMenuFile.addSeparator();
        ng.setMnemonic('G');
        ng.setActionCommand("New Guide");
        ng.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand() == "New Guide") {
                    MenuActions ma = new MenuActions();
                    try {
                        DesktopPane dp = new DesktopPane();
                        dp.createFrame();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                } else {
                    System.exit(0);
                }

            }
        });

output


back in the create Frame() number of frames= 0
internal frame openFrameCount= 1
start obj() type= guide
createGuideInternalFrame
back in the create Frame() number of frames= 1
internal frame openFrameCount= 2
start obj() type= guide
back in the create Frame() number of frames= 2
internal frame openFrameCount= 3
start obj() type= guide

[Michael Dunn]

read your code

DesktopPane frame = new DesktopPane();
JDesktopPane jdp;
setContentPane(jdp);
...and in createFrame();
InternalFrame frame=new InternalFrame();
jdp.add(frame);

and in your actionListener
DesktopPane dp = new DesktopPane();
dp.createFrame();

how many DesktopPane()'s are shown?
hint: 'new' means another one

[James Howerton]

It looks like in my actionListener I am making a new JDesktopPane which calls createFrame();

I guess I am not sure how to have the actionListener call the createFrame(); without the importing the DeskTopPane class a dp so it knows what the createFrame() is "dp.createFrame();"

[Michael Dunn]

> It looks like in my actionListener I am making a new JDesktopPane which calls createFrame();

actually, you are creating another instance of 'DesktopPane' (a JFrame),
which calls createFrame()

>I guess I am not sure how to have the actionListener call the createFrame();
> without the importing the DeskTopPane class a dp so it knows what the createFrame() is "dp.createFrame();"

usual way is:

DesktopPane.this.createFrame();

[James Howerton]

The only thing I could think of:

My JDesktop.class makes the JDesktop pane
a new internal frame class is called that creates and returned to it and adds it fine.

I used a setter to set the JDesktopPane into This new class

my actionPerformed calls the void method that of this new class and it tries the same thin only it tries to have the JDesktopPane that is now in the class
add the InternalFRame.

JMenu item

public void createGuideInternalFrame() throws IOException, FileNotFoundException, PropertyVetoException {
        System.out.println("createGuideInternalFrame");

        try {
           CreateNewGuide cng=new CreateNewGuide();
            cng.CreateNewGuide();
        } catch (IOException ex) {
            ex.printStackTrace();
        }

    }

the new CreateNewGuide.class

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package application1;

import java.awt.BorderLayout;
import java.beans.PropertyVetoException;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;

/**
 *
 * @author depot
 */
public class CreateNewGuide extends JInternalFrame {

    public static int openFrameCount = 0;
    public JTabbedPane guideContentPaneObject;
    public JDesktopPane jdp;
//The JDesktoppane is called by main and JDecktopPane call this and it returns and adds the internal frame
    public JInternalFrame CreateFirstGuide() throws FileNotFoundException, IOException, PropertyVetoException {
        InternalFrame frame = new InternalFrame();
        JPanel contentPane = new JPanel(new BorderLayout());
        SetObjects so = new SetObjects();
        so.setType("guide");
        so.initComponents();
        contentPane.add(so.obj());//sets the JTabbedPane that was created on JPanel
        frame.add(contentPane);//puts JPanel on Frame
        frame.setVisible(true);
        try {
            frame.setSelected(true);
        } catch (PropertyVetoException ex) {
            ex.printStackTrace();
        }
        return frame;
    }
    //The Jmenu Item actionPerfromed calls this and tries to add the new InternalFrame to the original JDesktopPan
     public void CreateNewGuide() throws FileNotFoundException, IOException, PropertyVetoException {
        InternalFrame frame = new InternalFrame();
        JPanel contentPane = new JPanel(new BorderLayout());
        SetObjects so = new SetObjects();
        so.setType("guide");
        so.initComponents();
        contentPane.add(so.obj());//sets the JTabbedPane that was created on JPanel
        frame.add(contentPane);//puts JPanel on Frame
        frame.setVisible(true);
        try {
            frame.setSelected(true);
        } catch (PropertyVetoException ex) {
            ex.printStackTrace();
        }

        jdp.add(frame);
    }

    public class InternalFrame extends JInternalFrame {

        static final int xPosition = 30, yPosition = 30;

        public InternalFrame() throws FileNotFoundException, IOException {
            super("Guide" + (++openFrameCount), true, true, true, true);
            System.out.println("internal frame openFrameCount= " + openFrameCount);
            setVisible(true);
            setSize(750, 500);
            setLocation(xPosition * openFrameCount, yPosition * openFrameCount);
        }
    }

    public JTabbedPane getGuideContentPaneObject() {
        JTabbedPane guideContentPaneObject = null;
        return guideContentPaneObject;
    }

    public void setGuideContentPaneObject(JTabbedPane guideContentPaneObject) {
        this.guideContentPaneObject = guideContentPaneObject;
    }

    public JDesktopPane getJdp() {
        return jdp;
    }

    public void setJdp(JDesktopPane jdp) {
        this.jdp = jdp;
    }
}

the error

Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
        at application1.CreateNewGuide.CreateNewGuide(CreateNewGuide.java:58)
        at menu.MenuActions.createGuideInternalFrame(MenuActions.java:115)
        at menu.Menu$3.actionPerformed(Menu.java:135)
        at javax.swing.AbstractButton.fireActionPerformed(AbstractButton.java:1995)
        at javax.swing.AbstractButton$Handler.actionPerformed(AbstractButton.java:2318)

output

internal frame openFrameCount= 1
 start obj() type= guide
createGuideInternalFrame
internal frame openFrameCount= 2
 start obj() type= guide

[Michael Dunn]

just looking at the code, you would need to call this
public void setJdp(JDesktopPane jdp) {
before calling this
CreateNewGuide() ---> jdp.add(frame);
otherwise jdp will be null

curious line this
public void CreateNewGuide() throws FileNotFoundException, IOException, PropertyVetoException {

why have the method name the same as the class name - most will think it should be a constructor, with errant 'void'm included
why all the unrelated throws exceptions

[James Howerton]

I changed the order of jdp creation
it still runs good from main but the
It does not want to deal with jdp.add(frame) in the createNewFrame()
JMenu item

public void createGuideInternalFrame() throws IOException, FileNotFoundException, PropertyVetoException {
        System.out.println("createGuideInternalFrame");

        try {
           CreateNewFrame cnf=new CreateNewGuide();
            cnf.CreateNewGuide();
        } catch (IOException ex) {
            ex.printStackTrace();
        }

    }

the new CreateNewGuide.class

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package application1;

import java.awt.BorderLayout;
import java.beans.PropertyVetoException;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.swing.JDesktopPane;
import javax.swing.JInternalFrame;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;

/**
 *
 * @author depot
 */
public class CreateNewGuide extends JInternalFrame {

    public static int openFrameCount = 0;
    public JTabbedPane guideContentPaneObject;
    public JDesktopPane jdp;
//The JDesktoppane is called by main and JDecktopPane call this and it returns and adds the internal frame
    public JInternalFrame CreateFirstFrame() throws IOException {
        InternalFrame frame = new InternalFrame();
        JPanel contentPane = new JPanel(new BorderLayout());
        SetObjects so = new SetObjects();
        so.setType("guide");
        so.initComponents();
        contentPane.add(so.obj());//sets the JTabbedPane that was created on JPanel
        frame.add(contentPane);//puts JPanel on Frame
        frame.setVisible(true);
        try {
            frame.setSelected(true);
        } catch (PropertyVetoException ex) {
            ex.printStackTrace();
        }
        return frame;
    }
    //The Jmenu Item actionPerfromed calls this and tries to add the new InternalFrame to the original JDesktopPan
     public void CreateNewFrame() throws IOException {
        InternalFrame frame = new InternalFrame();
        JPanel contentPane = new JPanel(new BorderLayout());
        SetObjects so = new SetObjects();
        so.setType("guide");
        so.initComponents();
        contentPane.add(so.obj());//sets the JTabbedPane that was created on JPanel
        frame.add(contentPane);//puts JPanel on Frame
        frame.setVisible(true);
        try {
            frame.setSelected(true);
        } catch (PropertyVetoException ex) {
            ex.printStackTrace();
        }

        jdp.add(frame);
    }

    public class InternalFrame extends JInternalFrame {

        static final int xPosition = 30, yPosition = 30;

        public InternalFrame() throws FileNotFoundException, IOException {
            super("Guide" + (++openFrameCount), true, true, true, true);
            System.out.println("internal frame openFrameCount= " + openFrameCount);
            setVisible(true);
            setSize(750, 500);
            setLocation(xPosition * openFrameCount, yPosition * openFrameCount);
        }
    }

    public JTabbedPane getGuideContentPaneObject() {
        JTabbedPane guideContentPaneObject = null;
        return guideContentPaneObject;
    }

    public void setGuideContentPaneObject(JTabbedPane guideContentPaneObject) {
        this.guideContentPaneObject = guideContentPaneObject;
    }

    public JDesktopPane getJdp() {
        return jdp;
    }

    public void setJdp(JDesktopPane jdp) {
        this.jdp = jdp;
    }
}

the error

Compiling 3 source files to C:\Users\depot\Documents\ceyesumma\java_cache\my_projects\guide1_project\target_guide1\guide1\guide1App\build\classes
compile:
run:
internal frame openFrameCount= 1
 start obj() type= guide
createGuideInternalFrame
internal frame openFrameCount= 2
 start obj() type= guide
Exception in thread "AWT-EventQueue-0" java.lang.NullPointerException
        at application1.CreateNewGuide.CreateNewFrame(CreateNewGuide.java:58)
        at menu.MenuActions.createGuideInternalFrame(MenuActions.java:115)
        at menu.Menu$3.actionPerformed(Menu.java:135)
        at javax.swing.AbstractButton.fireActionPerformed(AbstractButton.java:1995)
        at javax.swing.AbstractButton$Handler.actionPerformed(AbstractButton.java:2318)
        at javax.swing.DefaultButtonModel.fireActionPerformed(DefaultButtonModel.java:387)

Thanks for your time.

[James Howerton]

My getter method had code to Jdp=null I removed that but same error

[Michael Dunn]

you still haven't addressed the problem mentioned in my earlier post

in CreateNewGuide() you have this
public JDesktopPane jdp;

then, when you call cnf.CreateNewGuide(); (assuming [CreateNewFrame] cnf=new CreateNewGuide() is a typo)
includes
jdp.add(frame);

so, jdp has to be null

you can either use a constructor to pass a reference of the desktoppane to jdp, or
CreateNewFrame cnf=new CreateNewGuide();
cnf.setJdp(ref to desktoppane);//<----------------add this line
cnf.CreateNewGuide();

[James Howerton]

since it did not like setting the frame from the InternalFrame class

I tried to set the frame created in the jdp class.

and told the setter to add the frame to jdp.

but there needs to be something in the JDesktopPane class to be waiting for the new frame.

should I be trying a Runnable class?

[Michael Dunn]

> should I be trying a Runnable class?

I can't see how a runnable class would help, you need to pass a reference of the
visible JFrame's desktoppane all the way down the line to where it is used in CreateNewGuide()

It might be worth you starting another project, just to simplify everything
only include the desktoppane and internal frame stuff, along with a single menuitem with actionListener.
if you still can't get it working, you'll have something small and complete to post here.

your code posted so far is very difficult to follow, things like
public class CreateNewGuide extends JInternalFrame

why would it extend JIternalFrame, when it uses an inner class that also extends JInternalFrame

[James Howerton]

My original mission was to make more packages and classes to make more generic classes.

That is why I couldn't call my JDesktopPane from my JMenuBar

I had to move it to my JDesktopPane and it makes sense now.
The menu is for a the window

here is the code it works good. On to the next problem. One problem solved 12 more created.

Thanks again for your help.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package application1;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.beans.PropertyVetoException;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import menu.MenuActions;
import menu.MenuResponse;
import tools.Tools;

/**
 *
 * @author depot
 */
public class DesktopPane extends JFrame {

    JDesktopPane jdp;
    JMenu menu;
    public static int openFrameCount = 0;
    public JTabbedPane guideContentPaneObject;
    public JInternalFrame frame;
    public int rVal;
    public JFileChooser jfc;
    public String newline = "/n";
    public JTextArea log;//for file chooser
    public JScrollPane fileLog;//for file chooser
    public JButton opFile;//for file chooser
    public JButton svFile;//for file chooser
    public SetObjects setObjectsObj;
    public MenuResponse menuResponseObj;
    public JFrame f;
    public JMenuItem op;
    public JMenuItem nw;
    public JMenuItem ex;
    public JMenuItem sva;
    public JMenuItem sv;
    public JMenuItem ps;
    public JMenuItem pr;
    public JMenuItem un;
    public JMenuItem rd;
    public JMenuItem x;
    public JMenuItem c;
    public JMenuItem v;
    public JMenuItem d;
    public JMenuItem h;
    public JMenuItem tl;
    public JMenuItem ab;
    public JPanel content;
    public JMenuItem nwp;
    public JMenuItem pv;
    public JMenuItem pd;
    public JMenuItem ng;
    public String type = "guide";
    public Tools toolsObj;

    public DesktopPane() throws IOException, FileNotFoundException,
            PropertyVetoException {
        super("Guide DesktopPane");
        int inset = 50;
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds(inset, inset, screenSize.width - inset * 2, screenSize.height - inset * 2);
        addWindowListener(new WindowAdapter() {

            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        jdp = new JDesktopPane();
        CreateNewGuide cng = new CreateNewGuide();
        cng.setJdp(jdp);
        setContentPane(cng.getJdp());

        createFrame();


        setContentPane(jdp);
        
        setJMenuBar(createMenuBar());
        jdp.putClientProperty("JDesktopPane.dragMode", "outline");

    }

    protected JMenuBar createMenuBar() {

        //Jmenu File
        JMenu jMenuFile = new JMenu("File");
        JMenu jMenuEdit = new JMenu("Edit");
        JMenu jMenuProject = new JMenu("Project");
        JMenu jMenuHelp = new JMenu("Help");
        JMenuBar jMenuBar = new JMenuBar();
        jMenuBar.add(jMenuFile);
        jMenuBar.add(jMenuEdit);
        jMenuBar.add(jMenuProject);
        jMenuBar.add(jMenuHelp);
        ///////////////////////////////////////////////////////////////////
        ////// file ////////////     new       /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        nw = new JMenuItem();
        nw = (JMenuItem) jMenuFile.add(new JMenuItem("New"));
        jMenuFile.addSeparator();
        nw.setMnemonic('N');
        nw.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == nw) {

                    MenuActions ma = new MenuActions();
                    ma.createProjectSetupFrame();
                }
            }
            /** Returns an ImageIcon, or null if the path was invalid. */
        });
        ///////////////////////////////////////////////////////////////////
        ///// file ////////////// open /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        op = new JMenuItem();
        op = (JMenuItem) jMenuFile.add(new JMenuItem("Open"));

        jMenuFile.addSeparator();
        op.setMnemonic('O');
        op.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == op) {
                    MenuActions ma = new MenuActions();
                    JFileChooser jfc = new JFileChooser();
                    jfc.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
                    //int rVal = jfc.showOpenDialog(Menu);
                }
            }
            /** Returns an ImageIcon, or null if the path was invalid. */
        });
        ///////////////////////////////////////////////////////////////////
        ////// file ////////////     new Guide
/////////////////////////////
        ///////////////////////////////////////////////////////////////////
        ng = new JMenuItem();
        ng = (JMenuItem) jMenuFile.add(new JMenuItem("New Guide"));
        jMenuFile.addSeparator();
        ng.setMnemonic('G');
        ng.setActionCommand("New Guide");
        ng.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getActionCommand() == "New Guide") {
                    try {
                        createFrame();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }  catch (PropertyVetoException ex) {
                        ex.printStackTrace();
                    }


                } else {
                    System.exit(0);
                }

            }
            /*
            public void actionPerformed(ActionEvent e) {
            if (e.getActionCommand() == "New Guide") {


            MenuActions ma = new MenuActions();
            try {
            ma.createGuideInternalFrame();
            } catch (IOException ex) {
            ex.printStackTrace();
            }
            }else{
            System.exit(0);
            }

            }
             */
            /** Returns an ImageIcon, or null if the path was invalid. */
        });
        ///////////////////////////////////////////////////////////////////
        //////  file   //////////// save /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        sv = (JMenuItem) jMenuFile.add(new JMenuItem("Save"));
        sv.setMnemonic('S');
        ///////////////////////////////////////////////////////////////////
        //////  file ////////// save as /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        sva = (JMenuItem) jMenuFile.add(new JMenuItem("Save As"));
        jMenuFile.addSeparator();
        sva.setMnemonic('A');
        ///////////////////////////////////////////////////////////////////
        ////  file ////////////// page setup /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        ps = (JMenuItem) jMenuFile.add(new JMenuItem("Page Setup"));
        jMenuFile.addSeparator();
        ps.setMnemonic('E');
        ///////////////////////////////////////////////////////////////////
        //////  file ///////////// print /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        pr = (JMenuItem) jMenuFile.add(new JMenuItem("Print"));
        jMenuFile.addSeparator();
        pr.setMnemonic('P');

        ///////////////////////////////////////////////////////////////////
        /////  file   /////////////// properties /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        tl = new JMenuItem();
        tl = (JMenuItem) jMenuFile.add(new JMenuItem("Properties"));
        jMenuFile.addSeparator();
        pr.setMnemonic('T');
        tl.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                Tools toolsObj = new Tools();//this will add the menu
                try {
                    //this will add the menu
                    toolsObj.createAndShowGUI();
                } catch (FileNotFoundException ex) {
                    ex.printStackTrace();
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        });
        ///////////////////////////////////////////////////////////////////
        /////  file   /////////////// exit /////////////////////////////
        ///////////////////////////////////////////////////////////////////
        ex = new JMenuItem();
        ex = (JMenuItem) jMenuFile.add(new JMenuItem("Exit"));
        ex.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                System.exit(0);
            }
        });
        ///////////////////////////////////////////////////////////////////
        /////  edit ////////////// undo ////////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        un = (JMenuItem) jMenuEdit.add(new JMenuItem("Undo"));
        jMenuFile.addSeparator();
        un.setMnemonic('U');
        ///////////////////////////////////////////////////////////////////
        /////  edit ///////////// redo     ////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        rd = (JMenuItem) jMenuEdit.add(new JMenuItem("Redo"));
        jMenuEdit.addSeparator();
        rd.setMnemonic('R');
        ///////////////////////////////////////////////////////////////////
        ///////  edit  ////////////   cut   //////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        x = (JMenuItem) jMenuEdit.add(new JMenuItem("cut"));
        x.setMnemonic('X');
        ///////////////////////////////////////////////////////////////////
        //////  edit  /////////////  copy   ///////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        c = (JMenuItem) jMenuEdit.add(new JMenuItem("copy"));
        c.setMnemonic('C');
        ///////////////////////////////////////////////////////////////////
        ///////  edit //////////  paste    /////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        v = (JMenuItem) jMenuEdit.add(new JMenuItem("Paste"));
        jMenuEdit.addSeparator();
        v.setMnemonic('V');
        ///////////////////////////////////////////////////////////////////
        ////////  edit  //////////  delete  //////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        d = (JMenuItem) jMenuEdit.add(new JMenuItem("Delete"));
        jMenuEdit.addSeparator();
        d.setMnemonic('D');
        //help menu
        ///////////////////////////////////////////////////////////////////
        ////// project ////////////     new project
/////////////////////////////
        ///////////////////////////////////////////////////////////////////
        nwp = new JMenuItem();
        nwp = (JMenuItem) jMenuProject.add(new JMenuItem("New Project"));
        //nwp.addActionListener(this);
        jMenuFile.addSeparator();
        nwp.setMnemonic('R');
        nwp.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == nwp) {
                    MenuActions ma = new MenuActions();
                    ma.createProjectSetupFrame();
                }
            }
            /** Returns an ImageIcon, or null if the path was invalid. */
        });
        ///////////////////////////////////////////////////////////////////
        ////// project ////////////     save project
/////////////////////////////
        ///////////////////////////////////////////////////////////////////
        pv = new JMenuItem();
        pv = (JMenuItem) jMenuProject.add(new JMenuItem("Save Project"));

        jMenuFile.addSeparator();
        pv.setMnemonic('y');
        pv.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == pv) {
                    MenuActions ma = new MenuActions();
                    ma.createProjectSetupFrame();
                }
            }
            /** Returns an ImageIcon, or null if the path was invalid. */
        });
        ///////////////////////////////////////////////////////////////////
        ////// project ////////////     delete
/////////////////////////////
        ///////////////////////////////////////////////////////////////////
        pd = new JMenuItem();
        pd = (JMenuItem) jMenuProject.add(new JMenuItem("Delete Project"));

        jMenuFile.addSeparator();
        pd.setMnemonic('L');
        pd.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                if (e.getSource() == pd) {
                    MenuActions ma = new MenuActions();
                    ma.createProjectSetupFrame();
                }
            }
            /** Returns an ImageIcon, or null if the path was invalid. */
        });
        ///////////////////////////////////////////////////////////////////
        ////////  Help  /////////////   help   //////////////////////////////
        ///////////////////////////////////////////////////////////////////
        h = (JMenuItem) jMenuHelp.add(new JMenuItem("Help Contents"));
        jMenuHelp.addSeparator();
        h.setMnemonic('H');
        ///////////////////////////////////////////////////////////////////
        ////////  help/////////////  about    /////////////////////////////////
        ///////////////////////////////////////////////////////////////////
        ab = (JMenuItem) jMenuHelp.add(new JMenuItem("About"));
        ab.setMnemonic('A');
        return jMenuBar;
    }

    //throw new UnsupportedOperationException("Not yet implemented");
    public void createFrame() throws IOException, FileNotFoundException,
            PropertyVetoException {

        CreateNewGuide cng = new CreateNewGuide();
        jdp.add(cng.CreateFirstFrame());

    }

    public JInternalFrame getFrame() {
        return frame;
    }

    public void setFrame(JInternalFrame frame) {
        this.frame = frame;
    }

    public static void main(String[] args) throws IOException,
            FileNotFoundException, PropertyVetoException {
        DesktopPane frame = new DesktopPane();
        frame.setVisible(true);

    }
}