1 /*
2  *
3  * Paros and its related class files.
4  *
5  * Paros is an HTTP/HTTPS proxy for assessing web application security.
6  * Copyright (C) 2003-2004 Chinotec Technologies Company
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the Clarified Artistic License
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * Clarified Artistic License for more details.
16  *
17  * You should have received a copy of the Clarified Artistic License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20  */
21 // ZAP: 2012/03/03 Moved popups to stdmenus extension
22 // ZAP: 2012/04/23 Added @Override annotation to all appropriate methods.
23 // ZAP: 2012/10/17 Issue 393: Added more online links from menu
24 // ZAP: 2013/01/23 Clean up of exception handling/logging.
25 // ZAP: 2013/03/03 Issue 547: Deprecate unused classes and methods
26 // ZAP: 2013/04/16 Issue 638: Persist and snapshot sessions instead of saving them
27 // ZAP: 2013/09/11 Issue 786: Snapshot session menu item not working
28 // ZAP: 2014/01/28 Issue 207: Support keyboard shortcuts
29 // ZAP: 2014/11/11 Issue 1406: Move online menu items to an add-on
30 // ZAP: 2014/12/22 Issue 1476: Display contexts in the Sites tree
31 // ZAP: 2015/02/05 Issue 1524: New Persist Session dialog
32 // ZAP: 2017/05/10 Issue 3460: Add Show Support Info help menuitem
33 // ZAP: 2017/06/27 Issue 2375: Added option to change ZAP mode in edit menu
34 // ZAP: 2017/09/02 Use KeyEvent instead of Event (deprecated in Java 9).
35 // ZAP: 2018/07/17 Use ViewDelegate.getMenuShortcutKeyStroke.
36 // ZAP: 2019/03/15 Issue 3578: Added new menu Import
37 // ZAP: 2019/06/01 Normalise line endings.
38 // ZAP: 2019/06/05 Normalise format/style.
39 // ZAP: 2020/06/07 JavaDoc corrections.
40 // ZAP: 2020/11/26 Use Log4j 2 classes for logging.
41 // ZAP: 2021/04/08 Remove/fix boilerplate javadocs, and un-necessary fully qualified method return
42 // types.
43 // ZAP: 2021/05/14 Remove redundant type arguments.
44 package org.parosproxy.paros.view;
45 
46 import java.awt.event.ActionEvent;
47 import java.awt.event.KeyEvent;
48 import java.util.HashMap;
49 import java.util.Map;
50 import javax.swing.ButtonGroup;
51 import javax.swing.JMenu;
52 import javax.swing.JMenuBar;
53 import javax.swing.JMenuItem;
54 import javax.swing.JOptionPane;
55 import javax.swing.JRadioButtonMenuItem;
56 import javax.swing.SwingUtilities;
57 import org.apache.logging.log4j.LogManager;
58 import org.apache.logging.log4j.Logger;
59 import org.parosproxy.paros.Constant;
60 import org.parosproxy.paros.control.Control;
61 import org.parosproxy.paros.control.Control.Mode;
62 import org.parosproxy.paros.control.MenuFileControl;
63 import org.parosproxy.paros.control.MenuToolsControl;
64 import org.parosproxy.paros.model.Model;
65 import org.parosproxy.paros.model.Session;
66 import org.zaproxy.zap.view.AboutDialog;
67 import org.zaproxy.zap.view.ZapMenuItem;
68 import org.zaproxy.zap.view.ZapSupportDialog;
69 
70 public class MainMenuBar extends JMenuBar {
71 
72     private static final long serialVersionUID = 8580116506279095244L;
73 
74     private static final Logger logger = LogManager.getLogger(MainMenuBar.class);
75 
76     private javax.swing.JMenu menuEdit = null;
77     private javax.swing.JMenu menuTools = null;
78     private javax.swing.JMenu menuView = null;
79     private javax.swing.JMenu menuImport = null;
80     private ZapMenuItem menuToolsOptions = null;
81     private javax.swing.JMenu menuFile = null;
82     private ZapMenuItem menuFileNewSession = null;
83     private ZapMenuItem menuFileOpen = null;
84     private ZapMenuItem menuFileSaveAs = null;
85     private ZapMenuItem menuFileSnapshot = null;
86     private ZapMenuItem menuFileContextExport = null;
87     private ZapMenuItem menuFileContextImport = null;
88     private ZapMenuItem menuFileExit = null;
89     private ZapMenuItem menuFileExitAndDelete = null;
90     private ZapMenuItem menuFileProperties = null;
91     private JMenu menuHelp = null;
92     private ZapMenuItem menuHelpAbout = null;
93     private ZapMenuItem menuHelpSupport = null;
94     private JMenu menuAnalyse = null;
95     private JMenu menuZapMode = null;
96     private ButtonGroup menuZapModeGroup = null;
97     private Map<Mode, JRadioButtonMenuItem> menuZapModeMap = null;
98     // ZAP: Added standard report menu
99     private JMenu menuReport = null;
100     private JMenu menuOnline = null;
101 
MainMenuBar()102     public MainMenuBar() {
103         super();
104         initialize();
105     }
106 
initialize()107     private void initialize() {
108         this.add(getMenuFile());
109         this.add(getMenuEdit());
110         this.add(getMenuView());
111         this.add(getMenuAnalyse());
112         this.add(getMenuReport());
113         this.add(getMenuTools());
114         this.add(getMenuImport());
115         this.add(getMenuOnline());
116         this.add(getMenuHelp());
117     }
118 
119     /**
120      * Gets the Edit menu
121      *
122      * @return the Edit menu
123      */
getMenuEdit()124     public javax.swing.JMenu getMenuEdit() {
125         if (menuEdit == null) {
126             menuEdit = new javax.swing.JMenu();
127             menuEdit.setText(Constant.messages.getString("menu.edit")); // ZAP: i18n
128             menuEdit.setMnemonic(Constant.messages.getChar("menu.edit.mnemonic"));
129             menuEdit.add(getMenuEditZAPMode());
130             menuEdit.addSeparator();
131         }
132         return menuEdit;
133     }
134 
getMenuEditZAPMode()135     private JMenuItem getMenuEditZAPMode() {
136         if (menuZapMode == null) {
137             menuZapMode = new JMenu(Constant.messages.getString("menu.edit.zapmode"));
138             menuZapModeGroup = new ButtonGroup();
139             JRadioButtonMenuItem newButton;
140             menuZapModeMap = new HashMap<>();
141             for (Mode modeType : Mode.values()) {
142                 newButton = addZAPModeMenuItem(modeType);
143                 menuZapModeGroup.add(newButton);
144                 menuZapMode.add(newButton);
145                 menuZapModeMap.put(modeType, newButton);
146             }
147             Mode mode =
148                     Mode.valueOf(Model.getSingleton().getOptionsParam().getViewParam().getMode());
149             setMode(mode);
150         }
151         return menuZapMode;
152     }
153 
addZAPModeMenuItem(final Mode modeType)154     private JRadioButtonMenuItem addZAPModeMenuItem(final Mode modeType) {
155         final JRadioButtonMenuItem modeItem =
156                 new JRadioButtonMenuItem(
157                         Constant.messages.getString(
158                                 "view.toolbar.mode." + modeType.name() + ".select"));
159         modeItem.addActionListener(
160                 new java.awt.event.ActionListener() {
161                     @Override
162                     public void actionPerformed(java.awt.event.ActionEvent evt) {
163                         Control.getSingleton().setMode(modeType);
164                         View.getSingleton().getMainFrame().getMainToolbarPanel().setMode(modeType);
165                     }
166                 });
167         return modeItem;
168     }
169 
setMode(final Mode mode)170     public void setMode(final Mode mode) {
171         SwingUtilities.invokeLater(
172                 new Runnable() {
173                     @Override
174                     public void run() {
175                         menuZapModeMap.get(mode).setSelected(true);
176                     }
177                 });
178     }
179 
180     /**
181      * Gets the Tools menu
182      *
183      * @return the Tools menu
184      */
getMenuTools()185     public JMenu getMenuTools() {
186         if (menuTools == null) {
187             menuTools = new javax.swing.JMenu();
188             menuTools.setText(Constant.messages.getString("menu.tools")); // ZAP: i18n
189             menuTools.setMnemonic(Constant.messages.getChar("menu.tools.mnemonic"));
190             menuTools.addSeparator();
191             menuTools.add(getMenuToolsOptions());
192         }
193         return menuTools;
194     }
195 
196     /**
197      * Gets the View menu
198      *
199      * @return the View menu
200      */
getMenuView()201     public JMenu getMenuView() {
202         if (menuView == null) {
203             menuView = new javax.swing.JMenu();
204             menuView.setText(Constant.messages.getString("menu.view")); // ZAP: i18n
205             menuView.setMnemonic(Constant.messages.getChar("menu.view.mnemonic"));
206         }
207         return menuView;
208     }
209 
210     /**
211      * Gets the Import menu
212      *
213      * @return the Import menu
214      * @since 2.8.0
215      */
getMenuImport()216     public JMenu getMenuImport() {
217         if (menuImport == null) {
218             menuImport = new javax.swing.JMenu();
219             menuImport.setText(Constant.messages.getString("menu.import"));
220             menuImport.setMnemonic(Constant.messages.getChar("menu.import.mnemonic"));
221         }
222         return menuImport;
223     }
224 
getMenuToolsOptions()225     private ZapMenuItem getMenuToolsOptions() {
226         if (menuToolsOptions == null) {
227             menuToolsOptions =
228                     new ZapMenuItem(
229                             "menu.tools.options",
230                             View.getSingleton()
231                                     .getMenuShortcutKeyStroke(
232                                             KeyEvent.VK_O, KeyEvent.ALT_DOWN_MASK, false));
233             menuToolsOptions.addActionListener(
234                     new java.awt.event.ActionListener() {
235                         @Override
236                         public void actionPerformed(java.awt.event.ActionEvent e) {
237 
238                             getMenuToolsControl().options();
239                         }
240                     });
241         }
242         return menuToolsOptions;
243     }
244 
245     /**
246      * Gets the File menu
247      *
248      * @return the File menu
249      */
getMenuFile()250     public JMenu getMenuFile() {
251         if (menuFile == null) {
252             menuFile = new javax.swing.JMenu();
253             menuFile.setText(Constant.messages.getString("menu.file")); // ZAP: i18n
254             menuFile.setMnemonic(Constant.messages.getChar("menu.file.mnemonic"));
255             menuFile.add(getMenuFileNewSession());
256             menuFile.add(getMenuFileOpen());
257             menuFile.addSeparator();
258             menuFile.add(getMenuFileSaveAs());
259             menuFile.add(getMenuFileSnapshot());
260             menuFile.addSeparator();
261             menuFile.add(getMenuFileProperties());
262 
263             menuFile.addSeparator();
264             menuFile.add(getMenuContextImport());
265             menuFile.add(getMenuContextExport());
266 
267             menuFile.addSeparator();
268             menuFile.add(getMenuFileExitAndDelete());
269             menuFile.add(getMenuFileExit());
270         }
271         return menuFile;
272     }
273 
getMenuFileNewSession()274     private JMenuItem getMenuFileNewSession() {
275         if (menuFileNewSession == null) {
276             menuFileNewSession =
277                     new ZapMenuItem(
278                             "menu.file.newSession",
279                             View.getSingleton().getMenuShortcutKeyStroke(KeyEvent.VK_N, 0, false));
280             menuFileNewSession.addActionListener(
281                     new java.awt.event.ActionListener() {
282                         @Override
283                         public void actionPerformed(java.awt.event.ActionEvent e) {
284                             try {
285                                 getMenuFileControl().newSession(true);
286                             } catch (Exception e1) {
287                                 View.getSingleton()
288                                         .showWarningDialog(
289                                                 Constant.messages.getString(
290                                                         "menu.file.newSession.error")); // ZAP: i18n
291                                 logger.error(e1.getMessage(), e1);
292                             }
293                         }
294                     });
295         }
296         return menuFileNewSession;
297     }
298 
getMenuFileOpen()299     private JMenuItem getMenuFileOpen() {
300         if (menuFileOpen == null) {
301             menuFileOpen =
302                     new ZapMenuItem(
303                             "menu.file.openSession",
304                             View.getSingleton().getMenuShortcutKeyStroke(KeyEvent.VK_O, 0, false));
305             menuFileOpen.addActionListener(
306                     new java.awt.event.ActionListener() {
307                         @Override
308                         public void actionPerformed(java.awt.event.ActionEvent e) {
309                             getMenuFileControl().openSession();
310                         }
311                     });
312         }
313         return menuFileOpen;
314     }
315 
getMenuFileSaveAs()316     private JMenuItem getMenuFileSaveAs() {
317         if (menuFileSaveAs == null) {
318             menuFileSaveAs = new ZapMenuItem("menu.file.persistSession");
319             menuFileSaveAs.addActionListener(
320                     new java.awt.event.ActionListener() {
321                         @Override
322                         public void actionPerformed(java.awt.event.ActionEvent e) {
323                             if (Model.getSingleton().getSession().isNewState()) {
324                                 getMenuFileControl().saveAsSession();
325                             } else {
326                                 View.getSingleton()
327                                         .showWarningDialog(
328                                                 Constant.messages.getString(
329                                                         "menu.file.sessionExists.error"));
330                             }
331                         }
332                     });
333         }
334         return menuFileSaveAs;
335     }
336 
getMenuFileSnapshot()337     private JMenuItem getMenuFileSnapshot() {
338         if (menuFileSnapshot == null) {
339             menuFileSnapshot = new ZapMenuItem("menu.file.snapshotSession");
340             menuFileSnapshot.addActionListener(
341                     new java.awt.event.ActionListener() {
342                         @Override
343                         public void actionPerformed(java.awt.event.ActionEvent e) {
344                             if (!Model.getSingleton().getSession().isNewState()) {
345                                 getMenuFileControl().saveSnapshot();
346                             } else {
347                                 View.getSingleton()
348                                         .showWarningDialog(
349                                                 Constant.messages.getString(
350                                                         "menu.file.snapshotSession.error"));
351                             }
352                         }
353                     });
354         }
355         return menuFileSnapshot;
356     }
357 
getMenuFileExit()358     private JMenuItem getMenuFileExit() {
359         if (menuFileExit == null) {
360             menuFileExit = new ZapMenuItem("menu.file.exit");
361             menuFileExit.addActionListener(
362                     new java.awt.event.ActionListener() {
363                         @Override
364                         public void actionPerformed(java.awt.event.ActionEvent e) {
365                             getMenuFileControl().exit();
366                         }
367                     });
368         }
369         return menuFileExit;
370     }
371 
getMenuFileExitAndDelete()372     private javax.swing.JMenuItem getMenuFileExitAndDelete() {
373         if (menuFileExitAndDelete == null) {
374             menuFileExitAndDelete = new ZapMenuItem("menu.file.exit.delete");
375             menuFileExitAndDelete.addActionListener(
376                     new java.awt.event.ActionListener() {
377                         @Override
378                         public void actionPerformed(java.awt.event.ActionEvent e) {
379                             int ans =
380                                     View.getSingleton()
381                                             .showConfirmDialog(
382                                                     Constant.messages.getString(
383                                                             "menu.file.exit.delete.warning"));
384                             if (ans == JOptionPane.OK_OPTION) {
385                                 Control.getSingleton()
386                                         .exitAndDeleteSession(
387                                                 Model.getSingleton().getSession().getFileName());
388                             }
389                         }
390                     });
391         }
392         return menuFileExitAndDelete;
393     }
394 
395     /**
396      * Gets the File Menu Control
397      *
398      * @return the File Menu Control
399      */
getMenuFileControl()400     public MenuFileControl getMenuFileControl() {
401         return Control.getSingleton().getMenuFileControl();
402     }
403 
getMenuToolsControl()404     private MenuToolsControl getMenuToolsControl() {
405         return Control.getSingleton().getMenuToolsControl();
406     }
407 
getMenuFileProperties()408     private ZapMenuItem getMenuFileProperties() {
409         if (menuFileProperties == null) {
410             menuFileProperties =
411                     new ZapMenuItem(
412                             "menu.file.properties",
413                             View.getSingleton()
414                                     .getMenuShortcutKeyStroke(
415                                             KeyEvent.VK_P, KeyEvent.ALT_DOWN_MASK, false));
416             menuFileProperties.setText(
417                     Constant.messages.getString("menu.file.properties")); // ZAP: i18n
418             menuFileProperties.addActionListener(
419                     new java.awt.event.ActionListener() {
420                         @Override
421                         public void actionPerformed(java.awt.event.ActionEvent e) {
422                             getMenuFileControl().properties();
423                         }
424                     });
425         }
426         return menuFileProperties;
427     }
428 
getMenuContextImport()429     private ZapMenuItem getMenuContextImport() {
430         if (menuFileContextImport == null) {
431             menuFileContextImport = new ZapMenuItem("menu.file.context.import");
432             menuFileContextImport.addActionListener(
433                     new java.awt.event.ActionListener() {
434                         @Override
435                         public void actionPerformed(java.awt.event.ActionEvent e) {
436                             getMenuFileControl().importContext();
437                         }
438                     });
439         }
440         return menuFileContextImport;
441     }
442 
getMenuContextExport()443     private ZapMenuItem getMenuContextExport() {
444         if (menuFileContextExport == null) {
445             menuFileContextExport = new ZapMenuItem("menu.file.context.export");
446             menuFileContextExport.addActionListener(
447                     new java.awt.event.ActionListener() {
448                         @Override
449                         public void actionPerformed(ActionEvent e) {
450                             getMenuFileControl().exportContext();
451                         }
452                     });
453         }
454         return menuFileContextExport;
455     }
456 
457     /**
458      * Gets the Help menu
459      *
460      * @return the Help menu
461      */
getMenuHelp()462     public JMenu getMenuHelp() {
463         if (menuHelp == null) {
464             menuHelp = new JMenu();
465             menuHelp.setText(Constant.messages.getString("menu.help")); // ZAP: i18n
466             menuHelp.setMnemonic(Constant.messages.getChar("menu.help.mnemonic"));
467             menuHelp.add(getMenuHelpAbout());
468             menuHelp.add(getMenuHelpSupport());
469         }
470         return menuHelp;
471     }
472 
getMenuOnline()473     public JMenu getMenuOnline() {
474         if (menuOnline == null) {
475             menuOnline = new JMenu();
476             menuOnline.setText(Constant.messages.getString("menu.online"));
477             menuOnline.setMnemonic(Constant.messages.getChar("menu.online.mnemonic"));
478         }
479         return menuOnline;
480     }
481 
482     // ZAP: Added standard report menu
getMenuReport()483     public JMenu getMenuReport() {
484         if (menuReport == null) {
485             menuReport = new JMenu();
486             menuReport.setText(Constant.messages.getString("menu.report")); // ZAP: i18n
487             menuReport.setMnemonic(Constant.messages.getChar("menu.report.mnemonic"));
488         }
489         return menuReport;
490     }
491 
492     /**
493      * Gets the About menu
494      *
495      * @return the 'About' menu item.
496      */
getMenuHelpAbout()497     private ZapMenuItem getMenuHelpAbout() {
498         if (menuHelpAbout == null) {
499             menuHelpAbout = new ZapMenuItem("menu.help.about");
500             menuHelpAbout.addActionListener(
501                     new java.awt.event.ActionListener() {
502                         @Override
503                         public void actionPerformed(java.awt.event.ActionEvent e) {
504                             AboutDialog dialog =
505                                     new AboutDialog(View.getSingleton().getMainFrame(), true);
506                             dialog.setVisible(true);
507                         }
508                     });
509         }
510         return menuHelpAbout;
511     }
512 
getMenuHelpSupport()513     private ZapMenuItem getMenuHelpSupport() {
514         if (menuHelpSupport == null) {
515             menuHelpSupport = new ZapMenuItem("menu.help.zap.support");
516             menuHelpSupport.addActionListener(
517                     new java.awt.event.ActionListener() {
518                         @Override
519                         public void actionPerformed(java.awt.event.ActionEvent e) {
520                             ZapSupportDialog zsd =
521                                     new ZapSupportDialog(View.getSingleton().getMainFrame(), true);
522                             zsd.setVisible(true);
523                         }
524                     });
525         }
526         return menuHelpSupport;
527     }
528 
529     /**
530      * Gets the Analyze menu
531      *
532      * @return the Analyse menu
533      */
getMenuAnalyse()534     public JMenu getMenuAnalyse() {
535         if (menuAnalyse == null) {
536             menuAnalyse = new JMenu();
537             menuAnalyse.setText(Constant.messages.getString("menu.analyse")); // ZAP: i18n
538             menuAnalyse.setMnemonic(Constant.messages.getChar("menu.analyse.mnemonic"));
539         }
540         return menuAnalyse;
541     }
542 
sessionChanged(Session session)543     public void sessionChanged(Session session) {
544         if (session != null) {
545             this.getMenuFileSaveAs().setEnabled(session.isNewState());
546             this.getMenuFileSnapshot().setEnabled(!session.isNewState());
547         }
548     }
549 }
550