menufactory.java

java 文件下载器。可自定义

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space 
// Source File Name:   MenuFactory.java

package org.gudy.azureus2.ui.swt.mainwindow;

import com.aelitis.azureus.core.AzureusCore;
import com.aelitis.azureus.core.AzureusCoreFactory;
import com.aelitis.azureus.core.vuzefile.VuzeFileHandler;
import com.aelitis.azureus.ui.UIFunctions;
import com.aelitis.azureus.ui.UIFunctionsManager;
import com.aelitis.azureus.ui.swt.UIFunctionsManagerSWT;
import com.aelitis.azureus.ui.swt.UIFunctionsSWT;
import java.util.Iterator;
import org.eclipse.swt.events.*;
import org.eclipse.swt.widgets.*;
import org.gudy.azureus2.core3.config.COConfigurationManager;
import org.gudy.azureus2.core3.config.ParameterListener;
import org.gudy.azureus2.core3.download.DownloadManager;
import org.gudy.azureus2.core3.global.GlobalManager;
import org.gudy.azureus2.core3.internat.MessageText;
import org.gudy.azureus2.core3.logging.*;
import org.gudy.azureus2.core3.util.*;
import org.gudy.azureus2.plugins.ui.tables.*;
import org.gudy.azureus2.plugins.update.UpdateCheckInstance;
import org.gudy.azureus2.plugins.update.UpdateCheckInstanceListener;
import org.gudy.azureus2.pluginsimpl.local.download.DownloadManagerImpl;
import org.gudy.azureus2.ui.common.util.MenuItemManager;
import org.gudy.azureus2.ui.swt.*;
import org.gudy.azureus2.ui.swt.components.shell.ShellManager;
import org.gudy.azureus2.ui.swt.config.wizard.ConfigureWizard;
import org.gudy.azureus2.ui.swt.debug.UIDebugGenerator;
import org.gudy.azureus2.ui.swt.donations.DonationWindow;
import org.gudy.azureus2.ui.swt.exporttorrent.wizard.ExportTorrentWizard;
import org.gudy.azureus2.ui.swt.help.AboutWindow;
import org.gudy.azureus2.ui.swt.help.HealthHelpWindow;
import org.gudy.azureus2.ui.swt.importtorrent.wizard.ImportTorrentWizard;
import org.gudy.azureus2.ui.swt.maketorrent.NewTorrentWizard;
import org.gudy.azureus2.ui.swt.minibar.AllTransfersBar;
import org.gudy.azureus2.ui.swt.minibar.MiniBarManager;
import org.gudy.azureus2.ui.swt.nat.NatTestWindow;
import org.gudy.azureus2.ui.swt.pluginsinstaller.InstallPluginWizard;
import org.gudy.azureus2.ui.swt.pluginsuninstaller.UnInstallPluginWizard;
import org.gudy.azureus2.ui.swt.sharing.ShareUtils;
import org.gudy.azureus2.ui.swt.speedtest.SpeedTestWizard;
import org.gudy.azureus2.ui.swt.update.UpdateMonitor;
import org.gudy.azureus2.ui.swt.views.table.TableViewSWT;
import org.gudy.azureus2.ui.swt.views.table.utils.TableContextMenuManager;
import org.gudy.azureus2.ui.swt.views.utils.ManagerUtils;
import org.gudy.azureus2.ui.swt.welcome.WelcomeWindow;

// Referenced classes of package org.gudy.azureus2.ui.swt.mainwindow:
//			IMenuConstants, SWTThread, MainWindow, PluginsMenuHelper, 
//			IMainWindow, TorrentOpener

public class MenuFactory
	implements IMenuConstants
{

	public static boolean isAZ3_ADV = COConfigurationManager.getBooleanParameter("v3.Start Advanced");
	private static boolean isAZ3 = "az3".equalsIgnoreCase(COConfigurationManager.getStringParameter("ui"));
	private static final boolean DEBUG_SET_FOREGROUND = System.getProperty("debug.setforeground") != null;

	public MenuFactory()
	{
	}

	public static MenuItem createFileMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.file");
	}

	public static MenuItem createTransfersMenuItem(Menu menuParent)
	{
		MenuItem transferMenuItem = createTopLevelMenuItem(menuParent, "MainWindow.menu.transfers");
		Menu transferMenu = transferMenuItem.getMenu();
		addStartAllMenuItem(transferMenu);
		addStopAllMenuItem(transferMenu);
		MenuItem itemPause = addPauseMenuItem(transferMenu);
		MenuItem itemResume = addResumeMenuItem(transferMenu);
		transferMenu.addMenuListener(new MenuListener(itemPause, itemResume) {

			final MenuItem val$itemPause;
			final MenuItem val$itemResume;

			public void menuShown(MenuEvent menu)
			{
				itemPause.setEnabled(MenuFactory.getCore().getGlobalManager().canPauseDownloads());
				itemResume.setEnabled(MenuFactory.getCore().getGlobalManager().canResumeDownloads());
			}

			public void menuHidden(MenuEvent menuevent)
			{
			}

			
			{
				itemPause = menuitem;
				itemResume = menuitem1;
				super();
			}
		});
		return transferMenuItem;
	}

	public static MenuItem createViewMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.view");
	}

	public static MenuItem createPublishMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "v3.MainWindow.menu.publish");
	}

	public static MenuItem createAdvancedMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "v3.MainWindow.tab.advanced");
	}

	public static MenuItem createTorrentMenuItem(Menu menuParent)
	{
		MenuItem torrentItem = createTopLevelMenuItem(menuParent, "MainWindow.menu.torrent");
		MenuBuildUtils.addMaintenanceListenerForMenu(torrentItem.getMenu(), new org.gudy.azureus2.ui.swt.MenuBuildUtils.MenuBuilder(torrentItem, menuParent) {

			final MenuItem val$torrentItem;
			final Menu val$menuParent;

			public void buildMenu(Menu menu)
			{
				DownloadManager current_dls[] = (DownloadManager[])(DownloadManager[])torrentItem.getData("downloads");
				if (current_dls == null)
					return;
				boolean is_detailed_view = ((Boolean)torrentItem.getData("is_detailed_view")).booleanValue();
				TableViewSWT tv = (TableViewSWT)torrentItem.getData("TableView");
				TorrentUtil.fillTorrentMenu(menu, current_dls, MenuFactory.getCore(), menuParent.getShell(), !is_detailed_view, 0, tv);
				org.gudy.azureus2.plugins.ui.menus.MenuItem menu_items[] = MenuItemManager.getInstance().getAllAsArray(new String[] {
					"torrentmenu", "download_context"
				});
				Object plugin_dls[] = DownloadManagerImpl.getDownloadStatic(current_dls);
				if (menu_items.length > 0)
				{
					MenuFactory.addSeparatorMenuItem(menu);
					MenuBuildUtils.addPluginMenuItems(menuParent.getShell(), menu_items, menu, true, true, new org.gudy.azureus2.ui.swt.MenuBuildUtils.MenuItemPluginMenuControllerImpl(plugin_dls));
				}
				menu_items = null;
				String table_to_use = null;
				int i = 0;
				do
				{
					if (i >= current_dls.length)
						break;
					String table_name = current_dls[i].isDownloadComplete(false) ? "MySeeders" : "MyTorrents";
					if (table_to_use == null || table_to_use.equals(table_name))
					{
						table_to_use = table_name;
					} else
					{
						table_to_use = null;
						break;
					}
					i++;
				} while (true);
				if (table_to_use != null)
					menu_items = TableContextMenuManager.getInstance().getAllAsArray(table_to_use);
				if (menu_items != null)
				{
					MenuFactory.addSeparatorMenuItem(menu);
					TableRow dls_as_rows[] = null;
					dls_as_rows = new TableRow[plugin_dls.length];
					for (int i = 0; i < plugin_dls.length; i++)
						dls_as_rows[i] = MenuFactory.wrapAsRow(plugin_dls[i], table_to_use);

					MenuBuildUtils.addPluginMenuItems(menuParent.getShell(), menu_items, menu, true, true, new org.gudy.azureus2.ui.swt.MenuBuildUtils.MenuItemPluginMenuControllerImpl(dls_as_rows));
				}
			}

			
			{
				torrentItem = menuitem;
				menuParent = menu;
				super();
			}
		});
		return torrentItem;
	}

	public static MenuItem createToolsMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.tools");
	}

	public static MenuItem createPluginsMenuItem(Menu menuParent, boolean includeGetPluginsMenu)
	{
		MenuItem pluginsMenuItem = createTopLevelMenuItem(menuParent, "MainWindow.menu.view.plugins");
		MenuBuildUtils.addMaintenanceListenerForMenu(pluginsMenuItem.getMenu(), new org.gudy.azureus2.ui.swt.MenuBuildUtils.MenuBuilder(menuParent, includeGetPluginsMenu) {

			final Menu val$menuParent;
			final boolean val$includeGetPluginsMenu;

			public void buildMenu(Menu menu)
			{
				PluginsMenuHelper.getInstance().buildPluginMenu(menu, menuParent.getShell(), includeGetPluginsMenu);
			}

			
			{
				menuParent = menu;
				includeGetPluginsMenu = flag;
				super();
			}
		});
		return pluginsMenuItem;
	}

	public static MenuItem createWindowMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.window");
	}

	public static MenuItem createHelpMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.help");
	}

	public static MenuItem addCreateMenuItem(Menu menuParent)
	{
		MenuItem file_create = addMenuItem(menuParent, "MainWindow.menu.file.create", new Listener() {

			public void handleEvent(Event e)
			{
				new NewTorrentWizard(MenuFactory.getCore(), MenuFactory.getDisplay());
			}

		});
		return file_create;
	}

	public static MenuItem createOpenMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.file.open");
	}

	public static MenuItem addLogsViewMenuItem(Menu menuParent)
	{
		return createTopLevelMenuItem(menuParent, "MainWindow.menu.view.plugins.logViews");
	}

	public static MenuItem addOpenTorrentMenuItem(Menu menuParent)
	{
		return addMenuItem(menuParent, "MainWindow.menu.file.open.torrent", new Listener() {

			public void handleEvent(Event e)
			{
				TorrentOpener.openTorrentWindow();
			}

		});
	}

	public static MenuItem addOpenTorrentForTrackingMenuItem(Menu menuParent)
	{
		MenuItem file_new_torrent_for_tracking = addMenuItem(menuParent, "MainWindow.menu.file.open.torrentfortracking", new Listener() {

			public void handleEvent(Event e)
			{
				TorrentOpener.openTorrentTrackingOnly();
			}

		});
		return file_new_torrent_for_tracking;
	}

	public static MenuItem addOpenVuzeFileMenuItem(Menu menuParent)
	{
		return addMenuItem(menuParent, "MainWindow.menu.file.open.vuze", new Listener(menuParent) {

			final Menu val$menuParent;

			public void handleEvent(Event e)
			{
				Display display = menuParent.getDisplay();
				display.asyncExec(new AERunnable() {

					final 7 this$0;

					public void runSupport()
					{
						FileDialog dialog = new FileDialog(menuParent.getShell(), 0x21000);
						dialog.setFilterPath(TorrentOpener.getFilterPathData());
						dialog.setText(MessageText.getString("MainWindow.dialog.select.vuze.file"));
						dialog.setFilterExtensions(new String[] {
							"*.vuze", "*.vuz", Constants.FILE_WILDCARD
						});
						dialog.setFilterNames(new String[] {
							"*.vuze", "*.vuz", Constants.FILE_WILDCARD
						});
						String path = TorrentOpener.setFilterPathData(dialog.open());
						if (path != null)
						{
							VuzeFileHandler vfh = VuzeFileHandler.getSingleton();
							if (vfh.loadAndHandleVuzeFile(path, 0) == null)
								TorrentOpener.openTorrent(path);
						}
					}

					
					{
						this$0 = 7.this;
						super();
					}
				});
			}

			
			{
				menuParent = menu;
				super();
			}
		});
	}

	public static MenuItem createShareMenuItem(Menu menuParent)
	{
		MenuItem file_share = createTopLevelMenuItem(menuParent, "MainWindow.menu.file.share");
		return file_share;
	}

	public static MenuItem addShareFileMenuItem(Menu menuParent)
	{
		MenuItem file_share_file = addMenuItem(menuParent, "MainWindow.menu.file.share.file", new Listener(menuParent) {

			final Menu val$menuParent;

			public void handleEvent(Event e)
			{
				ShareUtils.shareFile(MenuFactory.getCore(), menuParent.getShell());
			}

			
			{
				menuParent = menu;
				super();
			}
		});
		return file_share_file;
	}

	public static MenuItem addShareFolderMenuItem(Menu menuParent)
	{
		MenuItem file_share_dir = addMenuItem(menuParent, "MainWindow.menu.file.share.dir", new Listener(menuParent) {

			final Menu val$menuParent;

			public void handleEvent(Event e)
			{
				ShareUtils.shareDir(MenuFactory.getCore(), menuParent.getShell());
			}

			
			{
				menuParent = menu;
				super();
			}
		});
		return file_share_dir;
	}

	public static MenuItem addShareFolderContentMenuItem(Menu menuParent)
	{
		MenuItem file_share_dircontents = addMenuItem(menuParent, "MainWindow.menu.file.share.dircontents", new Listener(menuParent) {

			final Menu val$menuParent;

			public void handleEvent(Event e)
			{
				ShareUtils.shareDirContents(MenuFactory.getCore(), menuParent.getShell(), false);
			}

			
			{
				menuParent = menu;
				super();
			}
		});
		return file_share_dircontents;
	}

	public static MenuItem addShareFolderContentRecursiveMenuItem(Menu menuParent)
	{
		MenuItem file_share_dircontents_rec = addMenuItem(menuParent, "MainWindow.menu.file.share.dircontentsrecursive", new Listener(menuParent) {

			final Menu val$menuParent;

			public void handleEvent(Event e)
			{
				ShareUtils.shareDirContents(MenuFactory.getCore(), menuParent.getShell(), true);
			}

			
			{
				menuParent = menu;
				super();
			}
		});
		return file_share_dircontents_rec;
	}

	public static MenuItem addImportMenuItem(Menu menuParent)
	{
		MenuItem file_import = addMenuItem(menuParent, "MainWindow.menu.file.import", new Listener() {

			public void handleEvent(Event e)
			{
				new ImportTorrentWizard(MenuFactory.getCore(), MenuFactory.getDisplay());
			}

		});
		return file_import;
	}

	public static MenuItem addExportMenuItem(Menu menuParent)
	{
		MenuItem file_export = addMenuItem(menuParent, "MainWindow.menu.file.export", new Listener() {

			public void handleEvent(Event e)
			{
				new ExportTorrentWizard(MenuFactory.getCore(), MenuFactory.getDisplay());
			}

		});
		return file_export;
	}

	public static MenuItem addCloseWindowMenuItem(Menu menuParent)
	{
		MenuItem closeWindow = addMenuItem(menuParent, "MainWindow.menu.file.closewindow", new Listener(menuParent) {

			final Menu val$menuParent;

			public void handleEvent(Event event)
			{
				Shell shell = menuParent.getShell();
				if (shell != null && !shell.isDisposed())
					menuParent.getShell().close();
			}

			
			{
				menuParent = menu;
				super();
			}
		});
		return closeWindow;
	}

	public static MenuItem addCloseTabMenuItem(Menu menu, MainWindow mainWindow)
	{
		return addMenuItem(menu, "MainWindow.menu.file.closetab", new Listener(mainWindow) {

			final MainWindow val$mainWindow;

			public void handleEvent(Event event)
			{
				if (MainWindow.isAlreadyDead)
				{
					return;
				} else
				{
					mainWindow.closeViewOrWindow();
					return;
				}
			}

			
			{
				mainWindow = mainwindow;
				super();
			}
		});
	}

	public static MenuItem addCloseDetailsMenuItem(Menu menu)
	{
		MenuItem item = addMenuItem(menu, "MainWindow.menu.closealldetails", new Listener() {

			public void handleEvent(Event e)
			{
				UIFunctionsManagerSWT.getUIFunctionsSWT().closeAllDetails();
			}

		});
		Listener enableHandler = new Listener(item) {

			final MenuItem val$item;

			public void handleEvent(Event event)
			{
				if (MenuFactory.isEnabledForCurrentMode(item) && !item.isDisposed() && !event.widget.isDisposed())
				{
					boolean hasDetails = UIFunctionsManagerSWT.getUIFunctionsSWT().hasDetailViews();
					item.setEnabled(hasDetails);
				}
			}

			
			{
				item = menuitem;
				super();
			}
		};
		menu.addListener(22, enableHandler);
		return item;
	}

	public static MenuItem addCloseDownloadBarsToMenu(Menu menu)
	{
		MenuItem item = addMenuItem(menu, "MainWindow.menu.closealldownloadbars", new Listener() {

			public void handleEvent(Event e)
			{
				MiniBarManager.getManager().closeAll();
			}

		});
		Listener enableHandler = new Listener(item) {

			final MenuItem val$item;

			public void handleEvent(Event event)
			{
				if (!item.isDisposed())
					item.setEnabled(!MiniBarManager.getManager().getShellManager().isEmpty());
			}

			
			{
				item = menuitem;
				super();
			}
		};
		menu.addListener(22, enableHandler);
		return item;
	}

	public static MenuItem addRestartMenuItem(Menu menuParent)
	{
		MenuItem file_restart = new MenuItem(menuParent, 0);
		Messages.setLanguageText(file_restart, "MainWindow.menu.file.restart");
		file_restart.addListener(13, new Listener() {

			public void handleEvent(Event event)
			{
				UIFunctionsManagerSWT.getUIFunctionsSWT().dispose(true, false);
			}

		});
		return file_restart;
	}

	public static MenuItem addExitMenuItem(Menu menuParent)