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

Example 21 with MenuItem

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

the class DateCompletedItem method addMenu.

private void addMenu() {
    TableContextMenuItem menuItem = addContextMenuItem("MyTorrentsView.menu.datecomp.reset");
    menuItem.setHeaderCategory(MenuItem.HEADER_OTHER);
    menuItem.addFillListener(new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object target) {
            boolean enabled = false;
            if (target != null) {
                Object[] o = (Object[]) target;
                for (Object object : o) {
                    if (object instanceof TableRowCore) {
                        object = ((TableRowCore) object).getDataSource(true);
                    }
                    if (object instanceof DownloadManager) {
                        DownloadManager dm = (DownloadManager) object;
                        if (dm.isDownloadComplete(false)) {
                            enabled = true;
                            break;
                        }
                    }
                }
            }
            menuItem.setEnabled(enabled);
        }
    });
    menuItem.addMultiListener(new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            if (target == null) {
                return;
            }
            Object[] o = (Object[]) target;
            Utils.getOffOfSWTThread(() -> {
                for (Object object : o) {
                    if (object instanceof TableRowCore) {
                        TableRowCore row = (TableRowCore) object;
                        object = row.getDataSource(true);
                        if (object instanceof DownloadManager) {
                            DownloadManager dm = (DownloadManager) object;
                            if (dm.isDownloadComplete(false)) {
                                long last_mod = 0;
                                DiskManagerFileInfo[] files = dm.getDiskManagerFileInfoSet().getFiles();
                                for (DiskManagerFileInfo file : files) {
                                    if (!file.isSkipped()) {
                                        File f = file.getFile(true);
                                        if (f.length() == file.getLength()) {
                                            long mod = f.lastModified();
                                            if (mod > last_mod) {
                                                last_mod = mod;
                                            }
                                        }
                                    }
                                }
                                if (last_mod > 0) {
                                    DownloadManagerState dms = dm.getDownloadState();
                                    dms.setLongParameter(DownloadManagerState.PARAM_DOWNLOAD_FILE_COMPLETED_TIME, last_mod);
                                    dms.setLongParameter(DownloadManagerState.PARAM_DOWNLOAD_COMPLETED_TIME, last_mod);
                                    dms.setLongAttribute(DownloadManagerState.AT_COMPLETE_LAST_TIME, last_mod);
                                    row.invalidate(true);
                                    row.refresh(true);
                                }
                            }
                        }
                    }
                }
            });
        }
    });
}

Example 22 with MenuItem

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

the class MenuBuildUtils method addChatMenu.

public static MenuItem addChatMenu(final MenuManager menu_manager, final MenuItem chat_item, final ChatKeyResolver chat_key_resolver) {
    chat_item.setStyle(MenuItem.STYLE_MENU);
    chat_item.addFillListener(new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object data) {
            menu.removeAllChildItems();
            if (chat_key_resolver.canShareMessage()) {
                MenuItem chat_share = menu_manager.addMenuItem(chat_item, "menu.share.download");
                addChatSelectionMenu(menu_manager, chat_share, null, new ChatSelectionListener() {

                    public void chatSelected(Object target, String chat) {
                    }

                    public void chatAvailable(Object target, ChatInstance chat) {
                        chat_key_resolver.shareMessage(target, chat);
                    }
                });
                MenuItem mi = menu_manager.addMenuItem(chat_item, "sep");
                mi.setStyle(MenuItem.STYLE_SEPARATOR);
            }
            MenuItem discuss_menu = menu_manager.addMenuItem(chat_item, chat_key_resolver.getResourceKey());
            discuss_menu.setStyle(MenuItem.STYLE_MENU);
            {
                MenuItem chat_pub = menu_manager.addMenuItem(discuss_menu, "label.public");
                chat_pub.addMultiListener(new MenuItemListener() {

                    @Override
                    public void selected(MenuItem menu, Object target) {
                        Object[] rows = (Object[]) target;
                        if (rows.length > 0) {
                            final AtomicInteger count = new AtomicInteger(rows.length);
                            pub_chat_pending.set(true);
                            for (Object obj : rows) {
                                String chat_key = chat_key_resolver.getChatKey(obj);
                                if (chat_key != null) {
                                    BuddyPluginUtils.createBetaChat(AENetworkClassifier.AT_PUBLIC, chat_key, new BuddyPluginUtils.CreateChatCallback() {

                                        @Override
                                        public void complete(ChatInstance chat) {
                                            if (count.decrementAndGet() == 0) {
                                                pub_chat_pending.set(false);
                                            }
                                        }
                                    });
                                }
                            }
                        }
                    }
                });
                if (pub_chat_pending.get()) {
                    chat_pub.setEnabled(false);
                    chat_pub.setText(chat_pub.getText() + " (" + MessageText.getString("PeersView.state.pending") + ")");
                }
            }
            if (BuddyPluginUtils.isBetaChatAnonAvailable()) {
                MenuItem chat_priv = menu_manager.addMenuItem(discuss_menu, "label.anon");
                chat_priv.addMultiListener(new MenuItemListener() {

                    @Override
                    public void selected(MenuItem menu, Object target) {
                        Object[] rows = (Object[]) target;
                        if (rows.length > 0) {
                            final AtomicInteger count = new AtomicInteger(rows.length);
                            anon_chat_pending.set(true);
                            for (Object obj : rows) {
                                String chat_key = chat_key_resolver.getChatKey(obj);
                                if (chat_key != null) {
                                    BuddyPluginUtils.createBetaChat(AENetworkClassifier.AT_I2P, chat_key, new BuddyPluginUtils.CreateChatCallback() {

                                        @Override
                                        public void complete(ChatInstance chat) {
                                            if (count.decrementAndGet() == 0) {
                                                anon_chat_pending.set(false);
                                            }
                                        }
                                    });
                                }
                            }
                        }
                    }
                });
                if (anon_chat_pending.get()) {
                    chat_priv.setEnabled(false);
                    chat_priv.setText(chat_priv.getText() + " (" + MessageText.getString("PeersView.state.pending") + ")");
                }
            } else {
                MenuItem chat_priv = menu_manager.addMenuItem(chat_item, "label.anon");
                chat_priv.setText(MessageText.getString("label.anon") + "...");
                chat_priv.addMultiListener(new MenuItemListener() {

                    @Override
                    public void selected(MenuItem menu, Object target) {
                        I2PHelpers.installI2PHelper(null, null, null);
                    }
                });
                if (I2PHelpers.isInstallingI2PHelper()) {
                    chat_priv.setEnabled(false);
                    chat_priv.setText(chat_priv.getText() + " (" + MessageText.getString("PeersView.state.pending") + ")");
                }
            }
        }
    });
    return (chat_item);
}

Example 23 with MenuItem

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

the class MenuBuildUtils method addChatSelectionMenu.

public static void addChatSelectionMenu(final MenuManager menu_manager, final MenuItem chat_item, String existing_chat, ChatSelectionListener _listener) {
    ChatSelectionListener listener = new ChatSelectionDelegator(_listener);
    chat_item.setStyle(MenuItem.STYLE_MENU);
    chat_item.addFillListener(new MenuItemFillListener() {

        @Override
        public void menuWillBeShown(MenuItem menu, Object data) {
            menu.removeAllChildItems();
            MenuItem create_menu = menu_manager.addMenuItem(chat_item, "chat.view.create.chat");
            create_menu.setStyle(MenuItem.STYLE_MENU);
            BuddyUIUtils.createChat(menu_manager, create_menu, true, new BuddyUIUtils.ChatCreationListener() {

                @Override
                public void chatCreated(Object target, String name) {
                    listener.chatSelected(target, name);
                }

                @Override
                public void chatAvailable(Object target, ChatInstance chat) {
                    listener.chatAvailable(target, chat);
                }
            });
            MenuItem mi = menu_manager.addMenuItem(chat_item, "sep");
            mi.setStyle(MenuItem.STYLE_SEPARATOR);
            List<ChatInstance> chats = BuddyPluginUtils.getChats();
            for (int i = 0; i < 2; i++) {
                MenuItem chat_menu = menu_manager.addMenuItem(chat_item, i == 0 ? "label.public" : "label.anon");
                chat_menu.setStyle(MenuItem.STYLE_MENU);
                String net = i == 0 ? AENetworkClassifier.AT_PUBLIC : AENetworkClassifier.AT_I2P;
                for (ChatInstance chat : chats) {
                    if (chat.getNetwork() == net) {
                        mi = menu_manager.addMenuItem(chat_menu, "!" + chat.getKey() + "!");
                        mi.addMultiListener(new MenuItemListener() {

                            @Override
                            public void selected(MenuItem menu, Object target) {
                                listener.chatSelected(target, chat.getNetAndKey());
                                listener.chatAvailable(target, chat);
                                try {
                                    BuddyPluginUtils.getBetaPlugin().showChat(chat);
                                } catch (Throwable e) {
                                    Debug.out(e);
                                }
                            }
                        });
                    }
                }
            }
        }
    });
}

Example 24 with MenuItem

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

the class TorrentMenuFancy method buildTorrentCustomMenu_Control.

public void buildTorrentCustomMenu_Control(final Composite cParent, final DownloadManager[] dms) {
    final int userMode = COConfigurationManager.getIntParameter("User Mode");
    boolean start = false;
    boolean stop = false;
    boolean pause = false;
    boolean recheck = false;
    boolean barsOpened = true;
    boolean bChangeDir = hasSelection;
    for (int i = 0; i < dms.length; i++) {
        DownloadManager dm = dms[i];
        if (barsOpened && !DownloadBar.getManager().isOpen(dm)) {
            barsOpened = false;
        }
        stop = stop || ManagerUtils.isStopable(dm);
        start = start || ManagerUtils.isStartable(dm);
        pause = pause || ManagerUtils.isPauseable(dm);
        recheck = recheck || dm.canForceRecheck();
        boolean stopped = ManagerUtils.isStopped(dm);
        int state = dm.getState();
        bChangeDir &= (state == DownloadManager.STATE_ERROR || state == DownloadManager.STATE_STOPPED || state == DownloadManager.STATE_QUEUED);
        /**
         * Only perform a test on disk if:
         *    1) We are currently set to allow the "Change Data Directory" option, and
         *    2) We've only got one item selected - otherwise, we may potentially end up checking massive
         *       amounts of files across multiple torrents before we generate a menu.
         */
        if (bChangeDir && dms.length == 1) {
            bChangeDir = dm.isDataAlreadyAllocated();
            if (bChangeDir && state == DownloadManager.STATE_ERROR) {
                // filesExist is way too slow!
                bChangeDir = !dm.filesExist(true);
            } else {
                DiskManagerFileInfo[] files = dm.getDiskManagerFileInfoSet().getFiles();
                bChangeDir = false;
                for (DiskManagerFileInfo info : files) {
                    if (info.isSkipped()) {
                        continue;
                    }
                    bChangeDir = !info.getFile(true).exists();
                    break;
                }
            }
        }
    }
    Composite cQuickCommands = new Composite(cParent, SWT.NONE);
    // cQuickCommands.setBackground(ColorCache.getRandomColor());
    RowLayout rowLayout = new RowLayout(SWT.HORIZONTAL);
    rowLayout.justify = true;
    rowLayout.marginLeft = 0;
    rowLayout.marginRight = 0;
    cQuickCommands.setLayout(rowLayout);
    GridData gd = new GridData();
    gd.grabExcessHorizontalSpace = true;
    gd.horizontalAlignment = SWT.FILL;
    cQuickCommands.setLayoutData(gd);
    // Queue
    createActionButton(dms, cQuickCommands, "MyTorrentsView.menu.queue", "start", start, (ListenerGetOffSWT) event -> TorrentUtil.queueDataSources(dms, false));
    if (TorrentUtil.isForceStartVisible(dms)) {
        boolean forceStart = false;
        boolean forceStartEnabled = false;
        for (int i = 0; i < dms.length; i++) {
            DownloadManager dm = dms[i];
            forceStartEnabled = forceStartEnabled || ManagerUtils.isForceStartable(dm);
            forceStart = forceStart || dm.isForceStart();
        }
        final boolean newForceStart = !forceStart;
        createActionButton(dms, cQuickCommands, "MyTorrentsView.menu.forceStart", "forcestart", forceStartEnabled, !newForceStart, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                if (ManagerUtils.isForceStartable(dm)) {
                    dm.setForceStart(newForceStart);
                }
            }
        });
    }
    // Pause
    if (userMode > 0) {
        createActionButton(dms, cQuickCommands, "v3.MainWindow.button.pause", "pause", pause, (ListenerGetOffSWT) event -> TorrentUtil.pauseDataSources(dms));
    }
    // Stop
    createActionButton(dms, cQuickCommands, "MyTorrentsView.menu.stop", "stop", stop, (ListenerGetOffSWT) event -> TorrentUtil.stopDataSources(dms));
    // Force Recheck
    createActionButton(dms, cQuickCommands, "MyTorrentsView.menu.recheck", "recheck", recheck, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            if (dm.canForceRecheck()) {
                dm.forceRecheck();
            }
        }
    });
    // Delete
    createActionButton(dms, cQuickCommands, "menu.delete.options", "delete", hasSelection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            TorrentUtil.removeDownloads(dms, null, true);
        }
    });
    if (bChangeDir) {
        createRow(cParent, "MyTorrentsView.menu.changeDirectory", null, new Listener() {

            @Override
            public void handleEvent(Event e) {
                TorrentUtil.changeDirSelectedTorrents(dms, parentShell);
            }
        });
    }
    // Open Details
    if (hasSelection) {
        createRow(cParent, "MyTorrentsView.menu.showdetails", "details", new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                UIFunctions uiFunctions = UIFunctionsManager.getUIFunctions();
                if (uiFunctions != null) {
                    uiFunctions.getMDI().showEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_TORRENT_DETAILS, dm);
                }
            }
        });
    }
    // Open Bar
    if (hasSelection) {
        FancyRowInfo row = createRow(cParent, "MyTorrentsView.menu.showdownloadbar", "downloadBar", new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                if (DownloadBar.getManager().isOpen(dm)) {
                    DownloadBar.close(dm);
                } else {
                    DownloadBar.open(dm, parentShell);
                }
            }
        });
        row.setSelection(barsOpened);
    }
    if (hasSelection) {
        FancyRowInfo rowSpeedDL = createRow(cParent, "MyTorrentsView.menu.downSpeedLimit", "image.torrentspeed.down", false, new Listener() {

            @Override
            public void handleEvent(Event e) {
                Event event = new Event();
                event.type = SWT.MouseUp;
                event.widget = e.widget;
                event.stateMask = e.stateMask;
                event.button = e.button;
                e.display.post(event);
                Core core = CoreFactory.getSingleton();
                SelectableSpeedMenu.invokeSlider((Control) event.widget, core, dms, false, shell);
                if (e.display.getActiveShell() != shell) {
                    if (!shell.isDisposed()) {
                        shell.dispose();
                    }
                    return;
                }
                FancyRowInfo rowInfo = findRowInfo(event.widget);
                if (rowInfo != null) {
                    updateRowSpeed(rowInfo, false);
                }
            }
        });
        rowSpeedDL.keepMenu = true;
        updateRowSpeed(rowSpeedDL, false);
    }
    if (hasSelection) {
        FancyRowInfo rowSpeedUL = createRow(cParent, "MyTorrentsView.menu.upSpeedLimit", "image.torrentspeed.up", false, new Listener() {

            @Override
            public void handleEvent(Event e) {
                Event event = new Event();
                event.type = SWT.MouseUp;
                event.widget = e.widget;
                event.stateMask = e.stateMask;
                event.button = e.button;
                e.display.post(event);
                Core core = CoreFactory.getSingleton();
                SelectableSpeedMenu.invokeSlider((Control) e.widget, core, dms, true, shell);
                if (e.display.getActiveShell() != shell) {
                    if (!shell.isDisposed()) {
                        shell.dispose();
                    }
                    return;
                }
                FancyRowInfo rowInfo = findRowInfo(event.widget);
                if (rowInfo != null) {
                    updateRowSpeed(rowInfo, true);
                }
            }
        });
        rowSpeedUL.keepMenu = true;
        updateRowSpeed(rowSpeedUL, true);
    }
    if (hasSelection && userMode > 0) {
        createMenuRow(cParent, "MyTorrentsView.menu.tracker", null, new FancyMenuRowInfoListener() {

            @Override
            public void buildMenu(Menu menu) {
                boolean changeUrl = hasSelection;
                boolean manualUpdate = true;
                boolean allStopped = true;
                boolean canMove = true;
                int userMode = COConfigurationManager.getIntParameter("User Mode");
                final boolean use_open_containing_folder = COConfigurationManager.getBooleanParameter("MyTorrentsView.menu.show_parent_folder_enabled");
                for (DownloadManager dm : dms) {
                    boolean stopped = ManagerUtils.isStopped(dm);
                    allStopped &= stopped;
                    canMove = canMove && dm.canMoveDataFiles();
                    if (userMode < 2) {
                        TRTrackerAnnouncer trackerClient = dm.getTrackerClient();
                        if (trackerClient != null) {
                            boolean update_state = ((SystemTime.getCurrentTime() / 1000 - trackerClient.getLastUpdateTime() >= TRTrackerAnnouncer.REFRESH_MINIMUM_SECS));
                            manualUpdate = manualUpdate & update_state;
                        }
                    }
                }
                TorrentUtil.addTrackerTorrentMenu(menu, dms, changeUrl, manualUpdate, allStopped, use_open_containing_folder, canMove);
            }
        });
    }
    if (hasSelection) {
        Core core = CoreFactory.getSingleton();
        SpeedLimitHandler slh = SpeedLimitHandler.getSingleton(core);
        if (slh.hasAnyProfiles()) {
            createMenuRow(cParent, IMenuConstants.MENU_ID_SPEED_LIMITS, null, new FancyMenuRowInfoListener() {

                @Override
                public void buildMenu(Menu menu) {
                    TorrentUtil.addSpeedLimitsMenu(dms, menu);
                }
            });
        }
    }
    if (userMode > 0 && hasSelection) {
        boolean can_pause_for = false;
        for (int i = 0; i < dms.length; i++) {
            DownloadManager dm = dms[i];
            if (dm.isPaused() || ManagerUtils.isPauseable(dm)) {
                can_pause_for = true;
                break;
            }
        }
        if (can_pause_for) {
            createRow(detailArea, "MainWindow.menu.transfers.pausetransfersfor", null, new Listener() {

                @Override
                public void handleEvent(Event event) {
                    TorrentUtil.pauseDownloadsFor(dms);
                }
            });
        }
    }
    if (userMode > 0 && dms.length > 1) {
        createRow(cParent, "label.options.and.info", null, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager[] dms) {
                UIFunctions uiFunctions = UIFunctionsManager.getUIFunctions();
                if (uiFunctions != null) {
                    uiFunctions.getMDI().showEntryByID(MultipleDocumentInterface.SIDEBAR_SECTION_TORRENT_OPTIONS, dms);
                }
            }
        });
    }
    if (userMode > 0) {
        createMenuRow(cParent, "MyTorrentsView.menu.peersource", null, new FancyMenuRowInfoListener() {

            @Override
            public void buildMenu(Menu menu) {
                TorrentUtil.addPeerSourceSubMenu(dms, menu);
            }
        });
    }
    // Sequential download
    {
        boolean allSeq = true;
        boolean AllNonSeq = true;
        for (int j = 0; j < dms.length; j++) {
            DownloadManager dm = dms[j];
            boolean seq = dm.getDownloadState().getFlag(DownloadManagerState.FLAG_SEQUENTIAL_DOWNLOAD);
            if (seq) {
                AllNonSeq = false;
            } else {
                allSeq = false;
            }
        }
        boolean bChecked;
        if (allSeq) {
            bChecked = true;
        } else if (AllNonSeq) {
            bChecked = false;
        } else {
            bChecked = false;
        }
        final boolean newSeq = !bChecked;
        FancyRowInfo row = createRow(cParent, "menu.sequential.download", null, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                dm.getDownloadState().setFlag(DownloadManagerState.FLAG_SEQUENTIAL_DOWNLOAD, newSeq);
            }
        });
        row.setSelection(bChecked);
    }
    // IP Filter Enable
    if (userMode > 0 && IpFilterManagerFactory.getSingleton().getIPFilter().isEnabled()) {
        boolean allEnabled = true;
        boolean allDisabled = true;
        for (int j = 0; j < dms.length; j++) {
            DownloadManager dm = dms[j];
            boolean filterDisabled = dm.getDownloadState().getFlag(DownloadManagerState.FLAG_DISABLE_IP_FILTER);
            if (filterDisabled) {
                allEnabled = false;
            } else {
                allDisabled = false;
            }
        }
        boolean bChecked;
        if (allEnabled) {
            bChecked = true;
        } else if (allDisabled) {
            bChecked = false;
        } else {
            bChecked = false;
        }
        final boolean newDisable = bChecked;
        FancyRowInfo row = createRow(cParent, "MyTorrentsView.menu.ipf_enable", null, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                dm.getDownloadState().setFlag(DownloadManagerState.FLAG_DISABLE_IP_FILTER, newDisable);
            }
        });
        row.setSelection(bChecked);
    }
    if (userMode > 1) {
        createMenuRow(cParent, "MyTorrentsView.menu.networks", null, new FancyMenuRowInfoListener() {

            @Override
            public void buildMenu(Menu menu) {
                TorrentUtil.addNetworksSubMenu(dms, menu);
            }
        });
    }
    // Advanced menu with stuff I don't know where to put
    if (userMode > 0) {
        createMenuRow(cParent, "MyTorrentsView.menu.advancedmenu", null, new FancyMenuRowInfoListener() {

            @Override
            public void buildMenu(Menu menu) {
                boolean allStopped = true;
                boolean allScanSelected = true;
                boolean allScanNotSelected = true;
                boolean fileMove = true;
                boolean allResumeIncomplete = true;
                boolean hasClearableLinks = false;
                boolean hasRevertableFiles = false;
                boolean lrrecheck = false;
                boolean allAllocatable = true;
                boolean allMaskDC = true;
                for (DownloadManager dm : dms) {
                    boolean stopped = ManagerUtils.isStopped(dm);
                    allStopped &= stopped;
                    fileMove = fileMove && dm.canMoveDataFiles();
                    boolean scan = dm.getDownloadState().getFlag(DownloadManagerState.FLAG_SCAN_INCOMPLETE_PIECES);
                    // include DND files in incomplete stat, since a recheck may
                    // find those files have been completed
                    boolean incomplete = !dm.isDownloadComplete(true);
                    allScanSelected = incomplete && allScanSelected && scan;
                    allScanNotSelected = incomplete && allScanNotSelected && !scan;
                    DownloadManagerState dms = dm.getDownloadState();
                    if (dms.isResumeDataComplete()) {
                        allResumeIncomplete = false;
                    }
                    if (stopped && !hasClearableLinks) {
                        if (dm.getDiskManagerFileInfoSet().nbFiles() > 1) {
                            if (dms.getFileLinks().hasLinks()) {
                                hasClearableLinks = true;
                            }
                        }
                    }
                    if (dm.getDownloadState().getFileLinks().size() > 0) {
                        hasRevertableFiles = true;
                    }
                    lrrecheck = lrrecheck || ManagerUtils.canLowResourceRecheck(dm);
                    allAllocatable &= stopped && !dm.isDataAlreadyAllocated() && !dm.isDownloadComplete(false);
                    allMaskDC = allMaskDC && dms.getBooleanAttribute(DownloadManagerState.AT_MASK_DL_COMP);
                }
                boolean fileRescan = allScanSelected || allScanNotSelected;
                final MenuItem itemFileRescan = new MenuItem(menu, SWT.CHECK);
                Messages.setLanguageText(itemFileRescan, "MyTorrentsView.menu.rescanfile");
                itemFileRescan.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        dm.getDownloadState().setFlag(DownloadManagerState.FLAG_SCAN_INCOMPLETE_PIECES, itemFileRescan.getSelection());
                    }
                });
                itemFileRescan.setSelection(allScanSelected);
                itemFileRescan.setEnabled(fileRescan);
                // low resource recheck
                final MenuItem itemLowResourceRecheck = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemLowResourceRecheck, "MyTorrentsView.menu.lowresourcerecheck");
                itemLowResourceRecheck.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        ManagerUtils.lowResourceRecheck(dm);
                    }
                });
                itemLowResourceRecheck.setEnabled(lrrecheck);
                // revert
                final MenuItem itemRevertFiles = new MenuItem(menu, SWT.PUSH);
                itemRevertFiles.setText(MessageText.getString("MyTorrentsView.menu.revertfiles") + "...");
                itemRevertFiles.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager[] dms) {
                        FilesViewMenuUtil.revertFiles(tv, dms);
                    }
                });
                itemRevertFiles.setEnabled(hasRevertableFiles);
                // view links
                final MenuItem itemViewLinks = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemViewLinks, "menu.view.links");
                itemViewLinks.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager[] dms) {
                        ManagerUtils.viewLinks(dms);
                    }
                });
                // clear links
                final MenuItem itemClearLinks = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemClearLinks, "FilesView.menu.clear.links");
                itemClearLinks.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        if (ManagerUtils.isStopped(dm) && dm.getDownloadState().getFileLinks().hasLinks()) {
                            DiskManagerFileInfoSet fis = dm.getDiskManagerFileInfoSet();
                            if (fis.nbFiles() > 1) {
                                DiskManagerFileInfo[] files = fis.getFiles();
                                for (DiskManagerFileInfo file_info : files) {
                                    File file_link = file_info.getFile(true);
                                    File file_nolink = file_info.getFile(false);
                                    if (!file_nolink.getAbsolutePath().equals(file_link.getAbsolutePath())) {
                                        file_info.setLink(null);
                                    }
                                }
                            }
                        }
                    }
                });
                itemClearLinks.setEnabled(hasClearableLinks);
                // allocate
                MenuItem itemFileAlloc = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemFileAlloc, "label.allocate");
                itemFileAlloc.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        dm.getDownloadState().setLongAttribute(DownloadManagerState.AT_FILE_ALLOC_STRATEGY, DownloadManagerState.FAS_ZERO_NEW_STOP);
                        dm.getDownloadState().setFlag(DownloadManagerState.FLAG_DISABLE_STOP_AFTER_ALLOC, false);
                        ManagerUtils.queue(dm, null);
                    }
                });
                itemFileAlloc.setEnabled(allAllocatable);
                // clear allocation
                MenuItem itemFileClearAlloc = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemFileClearAlloc, "MyTorrentsView.menu.clear_alloc_data");
                itemFileClearAlloc.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        dm.setDataAlreadyAllocated(false);
                    }
                });
                itemFileClearAlloc.setEnabled(allStopped);
                // clear resume
                MenuItem itemFileClearResume = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemFileClearResume, "MyTorrentsView.menu.clear_resume_data");
                itemFileClearResume.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        dm.getDownloadState().clearResumeData();
                    }
                });
                itemFileClearResume.setEnabled(allStopped);
                // set resume complete
                MenuItem itemFileSetResumeComplete = new MenuItem(menu, SWT.PUSH);
                Messages.setLanguageText(itemFileSetResumeComplete, "MyTorrentsView.menu.set.resume.complete");
                itemFileSetResumeComplete.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        TorrentUtils.setResumeDataCompletelyValid(dm.getDownloadState());
                    }
                });
                itemFileSetResumeComplete.setEnabled(allStopped && allResumeIncomplete);
                // mask dl comp
                boolean globalMask = COConfigurationManager.getBooleanParameter(ConfigKeys.Transfer.BCFG_PEERCONTROL_HIDE_PIECE);
                MenuItem itemMaskDLComp = new MenuItem(menu, SWT.CHECK);
                if (dms.length > 0) {
                    itemMaskDLComp.setSelection(globalMask || allMaskDC);
                }
                Messages.setLanguageText(itemMaskDLComp, "ConfigView.label.hap");
                itemMaskDLComp.addListener(SWT.Selection, new ListenerDMTask(dms) {

                    @Override
                    public void run(DownloadManager dm) {
                        dm.getDownloadState().setBooleanAttribute(DownloadManagerState.AT_MASK_DL_COMP, itemMaskDLComp.getSelection());
                    }
                });
                itemMaskDLComp.setEnabled(dms.length > 0 && !globalMask);
                if (userMode > 1 && isSeedingView) {
                    boolean canSetSuperSeed = false;
                    boolean superSeedAllYes = true;
                    boolean superSeedAllNo = true;
                    for (DownloadManager dm : dms) {
                        PEPeerManager pm = dm.getPeerManager();
                        if (pm != null) {
                            if (pm.canToggleSuperSeedMode()) {
                                canSetSuperSeed = true;
                            }
                            if (pm.isSuperSeedMode()) {
                                superSeedAllYes = false;
                            } else {
                                superSeedAllNo = false;
                            }
                        } else {
                            superSeedAllYes = false;
                            superSeedAllNo = false;
                        }
                    }
                    final MenuItem itemSuperSeed = new MenuItem(menu, SWT.CHECK);
                    Messages.setLanguageText(itemSuperSeed, "ManagerItem.superseeding");
                    boolean enabled = canSetSuperSeed && (superSeedAllNo || superSeedAllYes);
                    itemSuperSeed.setEnabled(enabled);
                    final boolean selected = superSeedAllNo;
                    if (enabled) {
                        itemSuperSeed.setSelection(selected);
                        itemSuperSeed.addListener(SWT.Selection, new ListenerDMTask(dms) {

                            @Override
                            public void run(DownloadManager dm) {
                                PEPeerManager pm = dm.getPeerManager();
                                if (pm != null) {
                                    if (pm.isSuperSeedMode() == selected && pm.canToggleSuperSeedMode()) {
                                        pm.setSuperSeedMode(!selected);
                                    }
                                }
                            }
                        });
                    }
                }
            }
        });
    }
}

Example 25 with MenuItem

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

the class DeviceManagerUI method addTagSubMenu.

private static void addTagSubMenu(MenuManager menu_manager, MenuItem menu, final DeviceMediaRenderer device) {
    menu.removeAllChildItems();
    TagManager tm = TagManagerFactory.getTagManager();
    List<Tag> tags = tm.getTagType(TagType.TT_DOWNLOAD_MANUAL).getTags();
    tags = TagUtils.sortTags(tags);
    long tag_id = device.getAutoShareToTagID();
    Tag assigned_tag = tm.lookupTagByUID(tag_id);
    MenuItem m = menu_manager.addMenuItem(menu, "label.no.tag");
    m.setStyle(MenuItem.STYLE_RADIO);
    m.setData(Boolean.valueOf(assigned_tag == null));
    m.addListener(new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            device.setAutoShareToTagID(-1);
        }
    });
    m = menu_manager.addMenuItem(menu, "sep1");
    m.setStyle(MenuItem.STYLE_SEPARATOR);
    List<String> menu_names = new ArrayList<>();
    Map<String, Tag> menu_name_map = new IdentityHashMap<>();
    for (Tag t : tags) {
        if (!t.isTagAuto()[0]) {
            String name = t.getTagName(true);
            menu_names.add(name);
            menu_name_map.put(name, t);
        }
    }
    List<Object> menu_structure = MenuBuildUtils.splitLongMenuListIntoHierarchy(menu_names, TagUIUtils.MAX_TOP_LEVEL_TAGS_IN_MENU);
    for (Object obj : menu_structure) {
        List<Tag> bucket_tags = new ArrayList<>();
        MenuItem parent_menu;
        if (obj instanceof String) {
            parent_menu = menu;
            bucket_tags.add(menu_name_map.get((String) obj));
        } else {
            Object[] entry = (Object[]) obj;
            List<String> tag_names = (List<String>) entry[1];
            boolean has_selected = false;
            for (String name : tag_names) {
                Tag tag = menu_name_map.get(name);
                bucket_tags.add(tag);
                if (assigned_tag == tag) {
                    has_selected = true;
                }
            }
            parent_menu = menu_manager.addMenuItem(menu, "!" + (String) entry[0] + (has_selected ? " (*)" : "") + "!");
            parent_menu.setStyle(MenuItem.STYLE_MENU);
        }
        for (final Tag tag : bucket_tags) {
            m = menu_manager.addMenuItem(parent_menu, tag.getTagName(false));
            m.setStyle(MenuItem.STYLE_RADIO);
            m.setData(Boolean.valueOf(assigned_tag == tag));
            TagUIUtils.setMenuIcon(m, tag);
            m.addListener(new MenuItemListener() {

                @Override
                public void selected(MenuItem menu, Object target) {
                    device.setAutoShareToTagID(tag.getTagUID());
                }
            });
        }
    }
    m = menu_manager.addMenuItem(menu, "sep2");
    m.setStyle(MenuItem.STYLE_SEPARATOR);
    m = menu_manager.addMenuItem(menu, "label.add.tag");
    m.addListener(new MenuItemListener() {

        @Override
        public void selected(MenuItem menu, Object target) {
            TagUIUtils.createManualTag(new UIFunctions.TagReturner() {

                @Override
                public void returnedTags(Tag[] tags) {
                    if (tags != null) {
                        for (Tag new_tag : tags) {
                            device.setAutoShareToTagID(new_tag.getTagUID());
                        }
                    }
                }
            });
        }
    });
}