Examples with MenuItem com.biglybt.pif.ui.menus.MenuItem used on opensource projects

Example 11 with MenuItem

use of com.biglybt.pif.ui.menus.MenuItem in project BiglyBT by BiglySoftware.

the class MainMDISetup method setupSidebarVuzeUI.

private static void setupSidebarVuzeUI(final MultipleDocumentInterfaceSWT mdi) {
    mdi.setPreferredOrder(preferredOrder);
    setupCatsTags(mdi);
    sb_dashboard = new SB_Dashboard(mdi);
    for (int i = 0; i < preferredOrder.length; i++) {
        String id = preferredOrder[i];
        mdi.registerEntry(id, new MdiEntryCreationListener() {

            @Override
            public MdiEntry createMDiEntry(String id) {
                MdiEntry entry;
                if (id.equals(MultipleDocumentInterface.SIDEBAR_HEADER_DASHBOARD)) {
                    entry = sb_dashboard.setupMDIEntry();
                } else {
                    entry = mdi.createHeader(id, "sidebar." + id, null);
                    if (entry == null) {
                        return (null);
                    }
                    entry.setDefaultExpanded(true);
                    if (id.equals(SIDEBAR_HEADER_PLUGINS)) {
                        // remove header when there are no children
                        entry.addListener((parent, ch, user) -> {
                            if (mdi.getChildrenOf(SIDEBAR_HEADER_PLUGINS).isEmpty()) {
                                mdi.closeEntry(parent, false);
                            }
                        });
                        PluginInterface pi = PluginInitializer.getDefaultInterface();
                        UIManager uim = pi.getUIManager();
                        MenuManager menuManager = uim.getMenuManager();
                        MenuItem menuItem;
                        menuItem = menuManager.addMenuItem("sidebar." + SIDEBAR_HEADER_PLUGINS, "label.plugin.options");
                        menuItem.setDisposeWithUIDetach(UIInstance.UIT_SWT);
                        menuItem.addListener(new MenuItemListener() {

                            @Override
                            public void selected(MenuItem menu, Object target) {
                                UIFunctions uif = UIFunctionsManager.getUIFunctions();
                                if (uif != null) {
                                    uif.getMDI().showEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_CONFIG, "plugins");
                                }
                            }
                        });
                    }
                }
                return entry;
            }
        });
    }
    sb_transfers = new SB_Transfers(mdi, true);
    sb_vuze = new SB_Vuze(mdi);
    new SB_Discovery(mdi);
    mdi.loadEntryByID(MultipleDocumentInterface.SIDEBAR_HEADER_DASHBOARD, false);
    mdi.loadEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_LIBRARY, false);
    if (COConfigurationManager.getBooleanParameter("Show New In Side Bar")) {
        mdi.loadEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_LIBRARY_UNOPENED, false);
    }
    mdi.loadEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_SUBSCRIPTIONS, false);
    mdi.loadEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_DEVICES, false);
    mdi.loadEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_ACTIVITIES, false);
}

Example 12 with MenuItem

use of com.biglybt.pif.ui.menus.MenuItem in project BiglyBT by BiglySoftware.

the class MagnetPlugin method initialize.

@Override
public void initialize(PluginInterface _plugin_interface) {
    plugin_interface = _plugin_interface;
    MagnetURIHandler uri_handler = MagnetURIHandler.getSingleton();
    final LocaleUtilities lu = plugin_interface.getUtilities().getLocaleUtilities();
    lu.addListener(new LocaleListener() {

        @Override
        public void localeChanged(Locale l) {
            updateLocale(lu);
        }
    });
    updateLocale(lu);
    BasicPluginConfigModel config = plugin_interface.getUIManager().createBasicPluginConfigModel(ConfigSection.SECTION_PLUGINS, PLUGIN_CONFIGSECTION_ID);
    config.addInfoParameter2("MagnetPlugin.current.port", String.valueOf(uri_handler.getPort()));
    md_lookup = config.addBooleanParameter2("MagnetPlugin.use.md.download", "MagnetPlugin.use.md.download", true);
    md_lookup_delay = config.addIntParameter2("MagnetPlugin.use.md.download.delay", "MagnetPlugin.use.md.download.delay", MD_LOOKUP_DELAY_SECS_DEFAULT);
    String et_default = "";
    for (String etd : MD_EXTRA_TRACKERS) {
        et_default += (et_default.isEmpty() ? "" : "\n") + etd;
    }
    md_extra_trackers = config.addStringParameter2("MagnetPlugin.md.extra.trackers", "MagnetPlugin.md.extra.trackers", et_default);
    md_extra_trackers.setMultiLine(3);
    md_lookup.addEnabledOnSelection(md_lookup_delay);
    md_lookup.addEnabledOnSelection(md_extra_trackers);
    timeout_param = config.addIntParameter2("MagnetPlugin.timeout.secs", "MagnetPlugin.timeout.secs", PLUGIN_DOWNLOAD_TIMEOUT_SECS_DEFAULT);
    sources_param = config.addStringListParameter2("MagnetPlugin.add.sources", "MagnetPlugin.add.sources", SOURCE_VALUES, SOURCE_STRINGS, SOURCE_VALUES[1]);
    sources_extra_param = config.addIntParameter2("MagnetPlugin.add.sources.extra", "MagnetPlugin.add.sources.extra", 0);
    magnet_recovery = config.addBooleanParameter2("MagnetPlugin.recover.magnets", "MagnetPlugin.recover.magnets", true);
    magnet_recovery_concurrency = config.addIntParameter2("MagnetPlugin.recover.magnets.conc", "MagnetPlugin.recover.magnets.conc", 32, 8, 512);
    magnet_recovery_concurrency.setIndent(1, true);
    magnet_recovery.addEnabledOnSelection(magnet_recovery_concurrency);
    BooleanParameter rename = config.addBooleanParameter2("MagnetPlugin.rename.using.dn", "MagnetPlugin.rename.using.dn", false);
    BooleanParameter rename_ext = config.addBooleanParameter2("MagnetPlugin.rename.using.dn.only.with.ext", "MagnetPlugin.rename.using.dn.only.with.ext", false);
    rename_ext.setIndent(1, true);
    rename.addEnabledOnSelection(rename_ext);
    Parameter[] nps = new Parameter[AENetworkClassifier.AT_NETWORKS.length];
    for (int i = 0; i < nps.length; i++) {
        String nn = AENetworkClassifier.AT_NETWORKS[i];
        String config_name = "Network Selection Default." + nn;
        String msg_text = "ConfigView.section.connection.networks." + nn;
        final BooleanParameter param = config.addBooleanParameter2(config_name, msg_text, COConfigurationManager.getBooleanParameter(config_name));
        COConfigurationManager.addParameterListener(config_name, new com.biglybt.core.config.ParameterListener() {

            @Override
            public void parameterChanged(String name) {
                param.setDefaultValue(COConfigurationManager.getBooleanParameter(name));
            }
        });
        nps[i] = param;
        net_params.put(nn, param);
    }
    config.createGroup("label.default.nets", nps);
    MenuItemListener listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem _menu, Object _target) {
            TableRow[] rows = (TableRow[]) _target;
            String cb_all_data = "";
            for (TableRow row : rows) {
                Torrent torrent;
                String name;
                Object ds = row.getDataSource();
                Download download = null;
                ShareResource share = null;
                if (ds instanceof ShareResourceFile) {
                    ShareResourceFile sf = (ShareResourceFile) ds;
                    try {
                        torrent = sf.getItem().getTorrent();
                    } catch (ShareException e) {
                        continue;
                    }
                    name = sf.getName();
                    share = sf;
                } else if (ds instanceof ShareResourceDir) {
                    ShareResourceDir sd = (ShareResourceDir) ds;
                    try {
                        torrent = sd.getItem().getTorrent();
                    } catch (ShareException e) {
                        continue;
                    }
                    name = sd.getName();
                    share = sd;
                } else if (ds instanceof Download) {
                    download = (Download) ds;
                    torrent = download.getTorrent();
                    name = download.getName();
                } else {
                    continue;
                }
                boolean is_share = false;
                Set<String> networks = new HashSet<>();
                if (share != null) {
                    is_share = true;
                    Map<String, String> properties = share.getProperties();
                    if (properties != null) {
                        String nets = properties.get(ShareManager.PR_NETWORKS);
                        if (nets != null) {
                            String[] bits = nets.split(",");
                            for (String bit : bits) {
                                bit = AENetworkClassifier.internalise(bit.trim());
                                if (bit != null) {
                                    networks.add(bit);
                                }
                            }
                        }
                    }
                }
                if (download != null) {
                    TorrentAttribute ta = plugin_interface.getTorrentManager().getAttribute(TorrentAttribute.TA_NETWORKS);
                    String[] nets = download.getListAttribute(ta);
                    networks.addAll(Arrays.asList(nets));
                    try {
                        byte[] hash = download.getTorrentHash();
                        if (plugin_interface.getShareManager().lookupShare(hash) != null) {
                            is_share = true;
                        }
                    } catch (Throwable e) {
                    }
                }
                String cb_data = download == null ? UrlUtils.getMagnetURI(name, torrent) : UrlUtils.getMagnetURI(download);
                if (download != null) {
                    List<Tag> tags = TagManagerFactory.getTagManager().getTagsForTaggable(TagType.TT_DOWNLOAD_MANUAL, PluginCoreUtils.unwrap(download));
                    for (Tag tag : tags) {
                        if (tag.isPublic()) {
                            if (!tag.isTagAuto()[0]) {
                                cb_data += "&tag=" + UrlUtils.encode(tag.getTagName(true));
                            }
                        }
                    }
                }
                String sources = sources_param.getValue();
                boolean add_sources = sources.equals("2") || (sources.equals("1") && is_share);
                if (add_sources) {
                    if (networks.isEmpty()) {
                        for (String net : AENetworkClassifier.AT_NETWORKS) {
                            if (isNetworkEnabled(net)) {
                                networks.add(net);
                            }
                        }
                    }
                    if (networks.contains(AENetworkClassifier.AT_PUBLIC) && !cb_data.contains("xsource=")) {
                        DownloadManager dm = download == null ? null : PluginCoreUtils.unwrap(download);
                        InetAddress ip = NetworkAdmin.getSingleton().getDefaultPublicAddress();
                        InetAddress ip_v6 = NetworkAdmin.getSingleton().getDefaultPublicAddressV6();
                        int port = dm == null ? TCPNetworkManager.getSingleton().getDefaultTCPListeningPortNumber() : dm.getTCPListeningPortNumber();
                        if (ip != null && port > 0) {
                            cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(ip, port));
                        }
                        if (ip_v6 != null && port > 0) {
                            cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(ip_v6, port));
                        }
                        int extra = sources_extra_param.getValue();
                        if (extra > 0) {
                            if (download == null) {
                                if (torrent != null) {
                                    download = plugin_interface.getDownloadManager().getDownload(torrent);
                                }
                            }
                            if (download != null) {
                                Set<String> added = new HashSet<>();
                                PEPeerManager pm = dm.getPeerManager();
                                if (pm != null) {
                                    List<PEPeer> peers = pm.getPeers();
                                    for (PEPeer peer : peers) {
                                        String peer_ip = peer.getIp();
                                        if (AENetworkClassifier.categoriseAddress(peer_ip) == AENetworkClassifier.AT_PUBLIC) {
                                            int peer_port = peer.getTCPListenPort();
                                            if (peer_port > 0) {
                                                cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(peer_ip, peer_port));
                                                added.add(peer_ip);
                                                extra--;
                                                if (extra == 0) {
                                                    break;
                                                }
                                            }
                                        }
                                    }
                                }
                                if (extra > 0) {
                                    Map response_cache = dm.getDownloadState().getTrackerResponseCache();
                                    if (response_cache != null) {
                                        List<TRTrackerAnnouncerResponsePeer> peers = TRTrackerAnnouncerFactory.getCachedPeers(response_cache);
                                        for (TRTrackerAnnouncerResponsePeer peer : peers) {
                                            String peer_ip = peer.getAddress();
                                            if (AENetworkClassifier.categoriseAddress(peer_ip) == AENetworkClassifier.AT_PUBLIC) {
                                                if (!added.contains(peer_ip)) {
                                                    int peer_port = peer.getPort();
                                                    if (peer_port > 0) {
                                                        cb_data += "&xsource=" + UrlUtils.encode(UrlUtils.getURLForm(peer_ip, peer_port));
                                                        added.add(peer_ip);
                                                        extra--;
                                                        if (extra == 0) {
                                                            break;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                // removed this as well - nothing wrong with allowing magnet copy
                // for private torrents - they still can't be tracked if you don't
                // have permission
                /*if ( torrent.isPrivate()){

							cb_data = getMessageText( "private_torrent" );

						}else if ( torrent.isDecentralised()){
						*/
                // ok
                /* relaxed this as we allow such torrents to be downloaded via magnet links
							 * (as opposed to tracked in the DHT)

						}else if ( torrent.isDecentralisedBackupEnabled()){

							TorrentAttribute ta_peer_sources 	= plugin_interface.getTorrentManager().getAttribute( TorrentAttribute.TA_PEER_SOURCES );

							String[]	sources = download.getListAttribute( ta_peer_sources );

							boolean	ok = false;

							for (int i=0;i<sources.length;i++){

								if ( sources[i].equalsIgnoreCase( "DHT")){

									ok	= true;

									break;
								}
							}

							if ( !ok ){

								cb_data = getMessageText( "decentral_disabled" );
							}
						}else{

							cb_data = getMessageText( "decentral_backup_disabled" );
							*/
                // }
                // System.out.println( "MagnetPlugin: export = " + url );
                cb_all_data += (cb_all_data.length() == 0 ? "" : "\n") + cb_data;
            }
            try {
                plugin_interface.getUIManager().copyToClipBoard(cb_all_data);
            } catch (Throwable e) {
                e.printStackTrace();
            }
        }
    };
    List<TableContextMenuItem> menus = new ArrayList<>();
    for (String table : TableManager.TABLE_MYTORRENTS_ALL) {
        TableContextMenuItem menu = plugin_interface.getUIManager().getTableManager().addContextMenuItem(table, "MagnetPlugin.contextmenu.exporturi");
        menu.addMultiListener(listener);
        menu.setHeaderCategory(MenuItem.HEADER_SOCIAL);
        menus.add(menu);
    }
    uri_handler.addListener(new MagnetURIHandlerListener() {

        @Override
        public byte[] badge() {
            InputStream is = getClass().getClassLoader().getResourceAsStream("com/biglybt/plugin/magnet/Magnet.gif");
            if (is == null) {
                return (null);
            }
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                try {
                    byte[] buffer = new byte[8192];
                    while (true) {
                        int len = is.read(buffer);
                        if (len <= 0) {
                            break;
                        }
                        baos.write(buffer, 0, len);
                    }
                } finally {
                    is.close();
                }
                return (baos.toByteArray());
            } catch (Throwable e) {
                Debug.printStackTrace(e);
                return (null);
            }
        }

        @Override
        public byte[] download(MagnetURIHandlerProgressListener muh_listener, byte[] hash, String args, InetSocketAddress[] sources, long timeout) throws MagnetURIHandlerException {
            try {
                Download dl = plugin_interface.getDownloadManager().getDownload(hash);
                if (dl != null) {
                    // might just be an existing metadata download
                    com.biglybt.core.download.DownloadManager core_dm = PluginCoreUtils.unwrap(dl);
                    if (!core_dm.getDownloadState().getFlag(DownloadManagerState.FLAG_METADATA_DOWNLOAD)) {
                        Torrent torrent = dl.getTorrent();
                        if (torrent != null) {
                            byte[] torrent_data = torrent.writeToBEncodedData();
                            torrent_data = addTrackersAndWebSeedsEtc(torrent_data, args, new HashSet<String>(), Collections.emptyList(), Collections.emptyMap());
                            return (torrent_data);
                        }
                    }
                }
            } catch (Throwable e) {
                Debug.printStackTrace(e);
            }
            Object[] result = { null };
            AESemaphore sem = new AESemaphore("dlwait");
            DownloadAsyncListener dl_listener = new DownloadAsyncListener() {

                @Override
                public void failed(MagnetURIHandlerException error) {
                    synchronized (result) {
                        result[0] = error;
                    }
                    sem.release();
                }

                @Override
                public void complete(byte[] torrent_data) {
                    synchronized (result) {
                        result[0] = torrent_data;
                    }
                    sem.release();
                }
            };
            recoverableDownload(muh_listener, hash, args, sources, Collections.emptyList(), Collections.emptyMap(), timeout, SystemTime.getCurrentTime(), false, dl_listener);
            sem.reserve();
            synchronized (result) {
                Object r = result[0];
                if (r instanceof MagnetURIHandlerException) {
                    throw ((MagnetURIHandlerException) r);
                } else {
                    return ((byte[]) r);
                }
            }
        }

        @Override
        public boolean download(URL url) throws MagnetURIHandlerException {
            try {
                plugin_interface.getDownloadManager().addDownload(url, false);
                return (true);
            } catch (DownloadException e) {
                throw (new MagnetURIHandlerException("Operation failed", e));
            }
        }

        @Override
        public boolean set(String name, Map values) {
            List l = listeners.getList();
            for (int i = 0; i < l.size(); i++) {
                if (((MagnetPluginListener) l.get(i)).set(name, values)) {
                    return (true);
                }
            }
            return (false);
        }

        @Override
        public int get(String name, Map values) {
            List l = listeners.getList();
            for (int i = 0; i < l.size(); i++) {
                int res = ((MagnetPluginListener) l.get(i)).get(name, values);
                if (res != Integer.MIN_VALUE) {
                    return (res);
                }
            }
            return (Integer.MIN_VALUE);
        }
    });
    plugin_interface.getUIManager().addUIListener(new UIManagerListener() {

        @Override
        public void UIAttached(UIInstance instance) {
            if (instance.getUIType().equals(UIInstance.UIT_SWT)) {
                try {
                    Class.forName("com.biglybt.plugin.magnet.swt.MagnetPluginUISWT").getConstructor(new Class[] { UIInstance.class, TableContextMenuItem[].class }).newInstance(new Object[] { instance, menus.toArray(new TableContextMenuItem[menus.size()]) });
                } catch (Throwable e) {
                    e.printStackTrace();
                }
            }
        }

        @Override
        public void UIDetached(UIInstance instance) {
        }
    });
    final List<Download> to_delete = new ArrayList<>();
    Download[] downloads = plugin_interface.getDownloadManager().getDownloads();
    for (Download download : downloads) {
        if (download.getFlag(Download.FLAG_METADATA_DOWNLOAD)) {
            to_delete.add(download);
        }
    }
    final AESemaphore delete_done = new AESemaphore("delete waiter");
    if (to_delete.size() > 0) {
        AEThread2 t = new AEThread2("MagnetPlugin:delmds", true) {

            @Override
            public void run() {
                try {
                    for (Download download : to_delete) {
                        try {
                            download.stopAndRemove(true, true);
                        } catch (Throwable e) {
                            Debug.out(e);
                        }
                    }
                } finally {
                    delete_done.release();
                }
            }
        };
        t.start();
    } else {
        delete_done.release();
    }
    plugin_interface.addListener(new PluginListener() {

        @Override
        public void initializationComplete() {
            // make sure DDB is initialised as we need it to register its
            // transfer types
            AEThread2 t = new AEThread2("MagnetPlugin:init", true) {

                @Override
                public void run() {
                    delete_done.reserve();
                    recoverDownloads();
                    try {
                        DistributedDatabase db = plugin_interface.getDistributedDatabase();
                        synchronized (db_holder) {
                            db_holder[0] = db;
                        }
                    } catch (Throwable e) {
                        Debug.out(e);
                    } finally {
                        db_waiter.releaseForever();
                    }
                }
            };
            t.start();
        }

        @Override
        public void closedownInitiated() {
            updateRecoverableDownloads();
        }

        @Override
        public void closedownComplete() {
        }
    });
}

Example 13 with MenuItem

use of com.biglybt.pif.ui.menus.MenuItem in project BiglyBT by BiglySoftware.

the class StartStopRulesDefaultPlugin method reloadConfigParams.

private void reloadConfigParams() {
    try {
        this_mon.enter();
        int iNewRankType = plugin_config.getUnsafeIntParameter("StartStopManager_iRankType");
        minSpeedForActiveSeeding = plugin_config.getUnsafeIntParameter("StartStopManager_iMinSpeedForActiveSeeding");
        if (minSpeedForActiveSeeding == 0) {
            maxStalledSeeding = 0;
            stalledSeedingIgnoreZP = false;
        } else {
            maxStalledSeeding = plugin_config.getUnsafeIntParameter("StartStopManager_iMaxStalledSeeding");
            if (maxStalledSeeding <= 0) {
                // insanity :)
                maxStalledSeeding = 999;
            }
            stalledSeedingIgnoreZP = plugin_config.getUnsafeBooleanParameter("StartStopManager_bMaxStalledSeedingIgnoreZP");
        }
        _maxActive = plugin_config.getUnsafeIntParameter("max active torrents");
        _maxActiveWhenSeedingEnabled = plugin_config.getUnsafeBooleanParameter("StartStopManager_bMaxActiveTorrentsWhenSeedingEnabled");
        _maxActiveWhenSeeding = plugin_config.getUnsafeIntParameter("StartStopManager_iMaxActiveTorrentsWhenSeeding");
        maxConfiguredDownloads = plugin_config.getUnsafeIntParameter("max downloads");
        boolean min_eq_max = plugin_config.getUnsafeBooleanParameter("StartStopManager_bMaxMinDLLinked");
        if (min_eq_max) {
            minDownloads = maxConfiguredDownloads;
        } else {
            minDownloads = plugin_config.getUnsafeIntParameter("min downloads");
        }
        bMaxDownloadIgnoreChecking = plugin_config.getUnsafeBooleanParameter("StartStopManager_bMaxDownloadIgnoreChecking");
        bAutoReposition = plugin_config.getUnsafeBooleanParameter("StartStopManager_bAutoReposition");
        minTimeAlive = plugin_config.getUnsafeIntParameter("StartStopManager_iMinSeedingTime") * 1000;
        bDebugLog = plugin_config.getUnsafeBooleanParameter("StartStopManager_bDebugLog");
        bAutoStart0Peers = plugin_config.getUnsafeBooleanParameter("StartStopManager_bAutoStart0Peers");
        globalDownloadLimit = plugin_config.getUnsafeIntParameter("Max Download Speed KBs", 0);
        globalUploadLimit = plugin_config.getUnsafeIntParameter("Max Upload Speed KBs", 0);
        globalUploadWhenSeedingLimit = plugin_config.getUnsafeBooleanParameter("enable.seedingonly.upload.rate") ? plugin_config.getUnsafeIntParameter("Max Upload Speed Seeding KBs", 0) : globalUploadLimit;
        bStopOnceBandwidthMet = plugin_config.getUnsafeBooleanParameter("StartStopManager_bStopOnceBandwidthMet");
        bStartNoMoreSeedsWhenUpLimitMet = plugin_config.getUnsafeBooleanParameter("StartStopManager_bStartNoMoreSeedsWhenUpLimitMet");
        bStartNoMoreSeedsWhenUpLimitMetPercent = plugin_config.getUnsafeBooleanParameter("StartStopManager_bStartNoMoreSeedsWhenUpLimitMetPercent");
        bStartNoMoreSeedsWhenUpLimitMetSlack = plugin_config.getUnsafeIntParameter("StartStopManager_bStartNoMoreSeedsWhenUpLimitMetSlack");
        boolean move_top = plugin_config.getUnsafeBooleanParameter("StartStopManager_bNewSeedsMoveTop");
        plugin_config.setCoreBooleanParameter(PluginConfig.CORE_PARAM_BOOLEAN_NEW_SEEDS_START_AT_TOP, move_top);
        if (iNewRankType != iRankType) {
            iRankType = iNewRankType;
            // shorten recalc for timed rank type, since the calculation is fast and we want to stop on the second
            if (iRankType == RANK_TIMED) {
                if (recalcSeedingRanksTask == null) {
                    recalcAllSeedingRanks();
                    recalcSeedingRanksTask = new RecalcSeedingRanksTask();
                    SimpleTimer.addPeriodicEvent("StartStop:recalcSR", 1000, recalcSeedingRanksTask);
                }
            } else if (recalcSeedingRanksTask != null) {
                recalcSeedingRanksTask.cancel();
                recalcSeedingRanksTask = null;
            }
        }
        iDownloadSortType = plugin_config.getUnsafeIntParameter("StartStopManager_Downloading_iSortType", -1);
        // migrate from old boolean setting
        if (iDownloadSortType == -1) {
            boolean bDownloadAutoReposition = plugin_config.getUnsafeBooleanParameter("StartStopManager_Downloading_bAutoReposition");
            iDownloadSortType = bDownloadAutoReposition ? DefaultRankCalculator.DOWNLOAD_ORDER_SPEED : DefaultRankCalculator.DOWNLOAD_ORDER_INDEX;
            plugin_config.setCoreIntParameter("StartStopManager_Downloading_iSortType", iDownloadSortType);
        }
        iDownloadTestTimeMillis = plugin_config.getUnsafeIntParameter("StartStopManager_Downloading_iTestTimeSecs") * 1000;
        iDownloadReTestMillis = plugin_config.getUnsafeIntParameter("StartStopManager_Downloading_iRetestTimeMins") * 60 * 1000;
        bDownloadTestActive = plugin_config.getUnsafeBooleanParameter("StartStopManager_Downloading_bTestActive");
        bTagFirstPriority = plugin_config.getUnsafeBooleanParameter("StartStopManager_bTagFirstPriority");
        if (bTagFirstPriority) {
            TagManager tag_manager = TagManagerFactory.getTagManager();
            if (tag_manager != null && tag_manager.isEnabled()) {
                TagType tt = tag_manager.getTagType(TagType.TT_DOWNLOAD_MANUAL);
                if (fp_tag == null) {
                    fp_tag = tt.getTag("First Priority", true);
                    if (fp_tag == null) {
                        try {
                            fp_tag = tt.createTag("First Priority", true);
                            fp_tag.setPublic(false);
                        } catch (Throwable e) {
                            Debug.out(e);
                        }
                    }
                }
                Tag not_fp_tag = tt.getTag("Not First Priority", true);
                if (not_fp_tag == null) {
                    try {
                        not_fp_tag = tt.createTag("Not First Priority", true);
                        not_fp_tag.setPublic(false);
                    } catch (Throwable e) {
                        Debug.out(e);
                    }
                }
                if (not_fp_tag != null) {
                    TagProperty constraint = ((TagFeatureProperties) not_fp_tag).getProperty(TagFeatureProperties.PR_CONSTRAINT);
                    constraint.setStringList(new String[] { "isComplete() && !hasTag( \"First Priority\" )" });
                }
            }
        }
        maxOverLimitSeeding = plugin_config.getUnsafeIntParameter("Flexible Seed Slots");
        int numslots = plugin_config.getUnsafeIntParameter("Light Seed Slots Reserved");
        int diff = numslots - numReservedSeedingSlots;
        numReservedSeedingSlots = numslots;
        if (diff > 0) {
            for (int i = 0; i < diff; i++) {
                RankCalculatorSlotReserver slot = new RankCalculatorSlotReserver();
                reservedSlots.add(slot);
                synchronized (rankCalculatorMap) {
                    rankCalculatorMap.put(slot, slot);
                    sortedArrayCache = null;
                }
            }
        } else if (diff < 0) {
            for (int i = -diff; i > 0 && !reservedSlots.isEmpty(); i--) {
                RankCalculatorSlotReserver slot = reservedSlots.removeFirst();
                synchronized (rankCalculatorMap) {
                    rankCalculatorMap.remove(slot);
                    sortedArrayCache = null;
                }
            }
        }
        /*
			 // limit _maxActive and maxDownloads based on TheColonel's specs

			 // maxActive = max_upload_speed / (slots_per_torrent * min_speed_per_peer)
			 if (_maxActive > 0) {
			 int iSlotsPerTorrent = plugin_config.getUnsafeIntParameter("Max Uploads");
			 // TODO: Track upload speed, storing the max upload speed over a minute
			 //        and use that for "unlimited" setting, or huge settings (like 200)
			 if (iSlotsPerTorrent > 0) {
			 int iMinSpeedPerPeer = 3; // for now.  TODO: config value
			 int _maxActiveLimit = iMaxUploadSpeed / (iSlotsPerTorrent * iMinSpeedPerPeer);
			 if (_maxActive > _maxActiveLimit) {
			 _maxActive = _maxActiveLimit;
			 plugin_config.setCoreIntParameter(PluginConfig.CORE_PARAM_INT_MAX_ACTIVE, _maxActive);
			 }
			 }

			 if (maxDownloads > _maxActive) {
			 maxDownloads = _maxActive;
			 plugin_config.setCoreIntParameter(PluginConfig.CORE_PARAM_INT_MAX_DOWNLOADS, maxDownloads);
			 }
			 }
			 */
        // force a recalc on all downloads by setting SR to 0, scheduling
        // a recalc on next process, and requsting a process cycle
        Collection<DefaultRankCalculator> allDownloads = rankCalculatorMap.values();
        try {
            ranksToRecalc_mon.enter();
            synchronized (rankCalculatorMap) {
                ranksToRecalc.addAll(allDownloads);
            }
        } finally {
            ranksToRecalc_mon.exit();
        }
        requestProcessCycle(null);
        if (bDebugLog) {
            log.log(LoggerChannel.LT_INFORMATION, "somethingChanged: config reload");
            try {
                if (debugMenuItem == null) {
                    final String DEBUG_MENU_ID = "StartStopRules.menu.viewDebug";
                    MenuItemListener menuListener = new MenuItemListener() {

                        @Override
                        public void selected(MenuItem menu, Object target) {
                            if (!(target instanceof TableRow))
                                return;
                            TableRow tr = (TableRow) target;
                            Object ds = tr.getDataSource();
                            if (!(ds instanceof Download))
                                return;
                            DefaultRankCalculator dlData = rankCalculatorMap.get(ds);
                            if (dlData != null) {
                                if (swt_ui != null)
                                    swt_ui.openDebugWindow(dlData);
                                else
                                    pi.getUIManager().showTextMessage(null, null, "FP:\n" + dlData.getExplainFP() + "\n" + "SR:" + dlData.getExplainSR() + "\n" + "TRACE:\n" + dlData.getTrace());
                            }
                        }
                    };
                    TableManager tm = pi.getUIManager().getTableManager();
                    debugMenuItem = tm.addContextMenuItem(TableManager.TABLE_MYTORRENTS_COMPLETE, DEBUG_MENU_ID);
                    debugMenuItem.setHeaderCategory(MenuItem.HEADER_CONTROL);
                    debugMenuItem.addListener(menuListener);
                    debugMenuItem = tm.addContextMenuItem(TableManager.TABLE_MYTORRENTS_INCOMPLETE, DEBUG_MENU_ID);
                    debugMenuItem.setHeaderCategory(MenuItem.HEADER_CONTROL);
                    debugMenuItem.addListener(menuListener);
                }
            } catch (Throwable t) {
                Debug.printStackTrace(t);
            }
        }
    } finally {
        this_mon.exit();
    }
}

Example 14 with MenuItem

use of com.biglybt.pif.ui.menus.MenuItem in project BiglyBT by BiglySoftware.

the class DeviceManagerUI method setupMenuListeners.

protected void setupMenuListeners() {
    properties_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                Device device = (Device) info.getDatasource();
                showProperties(device);
            }
        }
    };
    hide_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                Device device = (Device) info.getDatasource();
                device.setHidden(true);
            }
        }
    };
    will_tag_listener = new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object targets) {
            Object[] rows;
            if (targets instanceof Object[]) {
                rows = (Object[]) targets;
            } else {
                rows = new Object[] { targets };
            }
            if (rows.length > 0 && rows[0] instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) rows[0];
                Device device = (Device) info.getDatasource();
                menu.setData(device.isTagged());
            } else {
                menu.setEnabled(false);
            }
        }
    };
    tag_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                Device device = (Device) info.getDatasource();
                device.setTagged(!device.isTagged());
            }
        }
    };
    rename_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                final Device device = (Device) info.getDatasource();
                UISWTInputReceiver entry = (UISWTInputReceiver) swt_ui.getInputReceiver();
                entry.setPreenteredText(device.getName(), false);
                entry.maintainWhitespace(false);
                entry.allowEmptyInput(false);
                entry.setLocalisedTitle(MessageText.getString("label.rename", new String[] { device.getName() }));
                entry.prompt(new UIInputReceiverListener() {

                    @Override
                    public void UIInputReceiverClosed(UIInputReceiver entry) {
                        if (!entry.hasSubmittedInput()) {
                            return;
                        }
                        String input = entry.getSubmittedInput().trim();
                        if (input.length() > 0) {
                            device.setName(input, false);
                        }
                    }
                });
            }
        }
    };
    export_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                Device device = (Device) info.getDatasource();
                export(device);
            }
        }
    };
    will_remove_listener = new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object targets) {
            Object[] rows;
            if (targets instanceof Object[]) {
                rows = (Object[]) targets;
            } else {
                rows = new Object[] { targets };
            }
            if (rows.length > 0 && rows[0] instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) rows[0];
                Device device = (Device) info.getDatasource();
                menu.setEnabled(device.canRemove());
            } else {
                menu.setEnabled(false);
            }
        }
    };
    remove_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                Device device = (Device) info.getDatasource();
                device.remove();
            }
        }
    };
    will_browse_listener = new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object targets) {
            menu.removeAllChildItems();
            boolean enabled = false;
            Object[] rows;
            if (targets instanceof Object[]) {
                rows = (Object[]) targets;
            } else {
                rows = new Object[] { targets };
            }
            if (rows.length > 0 && rows[0] instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) rows[0];
                Device device = (Device) info.getDatasource();
                Device.browseLocation[] locs = device.getBrowseLocations();
                enabled = locs != null && locs.length > 0;
                if (enabled) {
                    MenuManager menuManager = ui_manager.getMenuManager();
                    for (final Device.browseLocation loc : locs) {
                        MenuItem loc_menu = menuManager.addMenuItem(menu, loc.getName());
                        loc_menu.addListener(new MenuItemListener() {

                            @Override
                            public void selected(MenuItem menu, Object target) {
                                Utils.launch(loc.getURL().toExternalForm());
                            }
                        });
                    }
                }
            }
            menu.setEnabled(enabled);
        }
    };
    show_listener = new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target instanceof MdiEntry) {
                MdiEntry info = (MdiEntry) target;
                Object ds = info.getDatasource();
                if (ds instanceof Device) {
                    // shouldn't get here really as its hidden :)
                    Device device = (Device) ds;
                    device.setHidden(true);
                } else {
                    int category_type = ds == null ? Device.DT_UNKNOWN : (Integer) ds;
                    Device[] devices = device_manager.getDevices();
                    for (Device device : devices) {
                        if (category_type == Device.DT_UNKNOWN || device.getType() == category_type && device.isHidden()) {
                            device.setHidden(false);
                        }
                    }
                }
            }
        }
    };
    show_fill_listener = new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object targets) {
            boolean enabled = false;
            Object[] rows;
            if (targets instanceof Object[]) {
                rows = (Object[]) targets;
            } else {
                rows = new Object[] { targets };
            }
            for (Object row : rows) {
                if (row instanceof MdiEntry) {
                    MdiEntry info = (MdiEntry) row;
                    Object ds = info.getDatasource();
                    if (ds instanceof Device) {
                    } else {
                        int category_type = ds == null ? Device.DT_UNKNOWN : (Integer) ds;
                        Device[] devices = device_manager.getDevices();
                        for (Device device : devices) {
                            if (category_type == Device.DT_UNKNOWN || device.getType() == category_type && device.isHidden()) {
                                if (device.isHidden()) {
                                    enabled = true;
                                }
                            }
                        }
                    }
                }
            }
            menu.setEnabled(enabled);
        }
    };
}

Example 15 with MenuItem

use of com.biglybt.pif.ui.menus.MenuItem in project BiglyBT by BiglySoftware.

the class BuddyPluginView method buildMenu.

private void buildMenu(final Set<ChatInstance> current_instances) {
    if (menu_items.size() == 0 || !menu_latest_instances.equals(current_instances)) {
        for (MenuItem mi : menu_items) {
            mi.remove();
        }
        menu_items.clear();
        final MenuManager menu_manager = plugin.getPluginInterface().getUIManager().getMenuManager();
        MenuContext mc = beta_status.getMenuContext();
        for (final ChatInstance chat : sortChats(current_instances)) {
            String short_name = chat.getShortName();
            MenuItem mi = menu_manager.addMenuItem(mc, "!" + short_name + "!");
            mi.addListener(new MenuItemListener() {

                @Override
                public void selected(MenuItem menu, Object target) {
                    try {
                        openChat(chat.getClone());
                    } catch (Throwable e) {
                        Debug.out(e);
                    }
                }
            });
            menu_items.add(mi);
        }
        boolean need_sep = true;
        if (current_instances.size() > 1) {
            MenuItem mi = menu_manager.addMenuItem(mc, "sep1");
            need_sep = false;
            mi.setStyle(MenuItem.STYLE_SEPARATOR);
            menu_items.add(mi);
            mi = menu_manager.addMenuItem(mc, "label.open.all");
            mi.addListener(new MenuItemListener() {

                @Override
                public void selected(MenuItem menu, Object target) {
                    for (ChatInstance chat : current_instances) {
                        try {
                            openChat(chat.getClone());
                        } catch (Throwable e) {
                            Debug.out(e);
                        }
                    }
                }
            });
            menu_items.add(mi);
        }
        if (need_sep) {
            MenuItem mi = menu_manager.addMenuItem(mc, "sep2");
            mi.setStyle(MenuItem.STYLE_SEPARATOR);
            menu_items.add(mi);
        }
        // create channel
        MenuItem mi = menu_manager.addMenuItem(mc, "chat.view.create.chat");
        mi.setStyle(MenuItem.STYLE_MENU);
        menu_items.add(mi);
        mi.addFillListener(new com.biglybt.pif.ui.menus.MenuItemFillListener() {

            @Override
            public void menuWillBeShown(MenuItem menu, Object data) {
                menu.removeAllChildItems();
                MenuItem mi = menu_manager.addMenuItem(menu, "!" + MessageText.getString("label.public") + "...!");
                mi.addListener(new MenuItemListener() {

                    @Override
                    public void selected(MenuItem menu, Object target) {
                        SimpleTextEntryWindow entryWindow = new SimpleTextEntryWindow("chat.view.enter.key.title", "chat.view.enter.key.msg");
                        entryWindow.prompt(new UIInputReceiverListener() {

                            @Override
                            public void UIInputReceiverClosed(UIInputReceiver receiver) {
                                if (!receiver.hasSubmittedInput()) {
                                    return;
                                }
                                String key = receiver.getSubmittedInput().trim();
                                BuddyPluginUtils.createBetaChat(AENetworkClassifier.AT_PUBLIC, key, null);
                            }
                        });
                    }
                });
                mi = menu_manager.addMenuItem(menu, "!" + MessageText.getString("label.anon") + "...!");
                mi.addListener(new MenuItemListener() {

                    @Override
                    public void selected(MenuItem menu, Object target) {
                        if (plugin.getBeta().isI2PAvailable()) {
                            SimpleTextEntryWindow entryWindow = new SimpleTextEntryWindow("chat.view.enter.key.title", "chat.view.enter.key.msg");
                            entryWindow.prompt(new UIInputReceiverListener() {

                                @Override
                                public void UIInputReceiverClosed(UIInputReceiver receiver) {
                                    if (!receiver.hasSubmittedInput()) {
                                        return;
                                    }
                                    String key = receiver.getSubmittedInput().trim();
                                    BuddyPluginUtils.createBetaChat(AENetworkClassifier.AT_I2P, key, null);
                                }
                            });
                        } else {
                            I2PHelpers.installI2PHelper(null, null, null);
                        }
                    }
                });
                if (I2PHelpers.isInstallingI2PHelper()) {
                    mi.setEnabled(false);
                    mi.setText(mi.getText() + " (" + MessageText.getString("PeersView.state.pending") + ")");
                }
            }
        });
        // chat overview
        mi = menu_manager.addMenuItem(mc, "!" + MessageText.getString("chats.view.heading") + "...!");
        mi.addListener(new MenuItemListener() {

            @Override
            public void selected(MenuItem menu, Object target) {
                UIFunctions uif = UIFunctionsManager.getUIFunctions();
                if (uif != null) {
                    uif.getMDI().showEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_CHAT);
                }
            }
        });
        menu_items.add(mi);
        mi = menu_manager.addMenuItem(mc, "sep3");
        mi.setStyle(MenuItem.STYLE_SEPARATOR);
        menu_items.add(mi);
        // options
        mi = menu_manager.addMenuItem(mc, "MainWindow.menu.view.configuration");
        mi.addListener(new MenuItemListener() {

            @Override
            public void selected(MenuItem menu, Object target) {
                ui_instance.openView(UISWTInstance.VIEW_MAIN, VIEW_ID, null);
            }
        });
        menu_items.add(mi);
        menu_latest_instances = current_instances;
    }
}