Examples with DownloadManagerState com.biglybt.core.download.DownloadManagerState used on opensource projects

Example 16 with DownloadManagerState

use of com.biglybt.core.download.DownloadManagerState in project BiglyBT by BiglySoftware.

the class TorrentUtil method fillTorrentMenu.

// selected_dl_types -> 0 (determine that automatically), +1 (downloading), +2 (seeding), +3 (mixed - not used by anything yet)
public static void fillTorrentMenu(final Menu menu, final DownloadManager[] dms, final Core core, boolean include_show_details, int selected_dl_types, final TableView tv) {
    // TODO: Build submenus on the fly
    Shell shell = Utils.findAnyShell();
    Shell menu_shell = menu.getShell();
    final boolean isSeedingView;
    switch(selected_dl_types) {
        case 1:
            isSeedingView = false;
            break;
        case 2:
            isSeedingView = true;
            break;
        case 0:
            {
                if (dms.length == 1) {
                    isSeedingView = dms[0].isDownloadComplete(false);
                    break;
                }
            }
        default:
            // I was going to raise an error, but let's not be too hasty. :)
            isSeedingView = false;
    }
    boolean hasSelection = dms.length > 0;
    boolean isSingleSelection = dms.length == 1;
    boolean isTrackerOn = TRTrackerUtils.isTrackerEnabled();
    int userMode = COConfigurationManager.getIntParameter("User Mode");
    // Enable/Disable Logic
    boolean bChangeDir = hasSelection;
    boolean start, stop, pause, changeUrl, barsOpened, forceStart;
    boolean forceStartEnabled, recheck, manualUpdate, fileMove, canSetMOC, canClearMOC, fileExport, fileRescan;
    changeUrl = barsOpened = manualUpdate = fileMove = canSetMOC = fileExport = fileRescan = true;
    forceStart = forceStartEnabled = recheck = start = stop = pause = canClearMOC = false;
    boolean canSetSuperSeed = false;
    boolean superSeedAllYes = true;
    boolean superSeedAllNo = true;
    boolean upSpeedDisabled = false;
    long totalUpSpeed = 0;
    boolean upSpeedUnlimited = false;
    long upSpeedSetMax = 0;
    boolean downSpeedDisabled = false;
    long totalDownSpeed = 0;
    boolean downSpeedUnlimited = false;
    long downSpeedSetMax = 0;
    boolean allScanSelected = true;
    boolean allScanNotSelected = true;
    boolean allStopped = true;
    boolean allResumeIncomplete = true;
    boolean hasClearableLinks = false;
    boolean hasRevertableFiles = false;
    if (hasSelection) {
        for (int i = 0; i < dms.length; i++) {
            DownloadManager dm = (DownloadManager) dms[i];
            try {
                int maxul = dm.getStats().getUploadRateLimitBytesPerSecond();
                if (maxul == 0) {
                    upSpeedUnlimited = true;
                } else {
                    if (maxul > upSpeedSetMax) {
                        upSpeedSetMax = maxul;
                    }
                }
                if (maxul == -1) {
                    maxul = 0;
                    upSpeedDisabled = true;
                }
                totalUpSpeed += maxul;
                int maxdl = dm.getStats().getDownloadRateLimitBytesPerSecond();
                if (maxdl == 0) {
                    downSpeedUnlimited = true;
                } else {
                    if (maxdl > downSpeedSetMax) {
                        downSpeedSetMax = maxdl;
                    }
                }
                if (maxdl == -1) {
                    maxdl = 0;
                    downSpeedDisabled = true;
                }
                totalDownSpeed += maxdl;
            } catch (Exception ex) {
                Debug.printStackTrace(ex);
            }
            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();
            forceStartEnabled = forceStartEnabled || ManagerUtils.isForceStartable(dm);
            forceStart = forceStart || dm.isForceStart();
            boolean stopped = ManagerUtils.isStopped(dm);
            allStopped &= stopped;
            fileMove = fileMove && dm.canMoveDataFiles();
            fileExport = fileExport && dm.canExportDownload();
            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;
                }
            }
            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 {
                    bChangeDir = false;
                }
            }
            boolean incomplete = !dm.isDownloadComplete(true);
            DownloadManagerState dm_state = dm.getDownloadState();
            String moc_dir = dm_state.getAttribute(DownloadManagerState.AT_MOVE_ON_COMPLETE_DIR);
            canSetMOC &= incomplete;
            canClearMOC |= (moc_dir != null && moc_dir.length() > 0);
            boolean scan = dm_state.getFlag(DownloadManagerState.FLAG_SCAN_INCOMPLETE_PIECES);
            // include DND files in incomplete stat, since a recheck may
            // find those files have been completed
            allScanSelected = incomplete && allScanSelected && scan;
            allScanNotSelected = incomplete && allScanNotSelected && !scan;
            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;
            }
            if (dm_state.isResumeDataComplete()) {
                allResumeIncomplete = false;
            }
            if (stopped && !hasClearableLinks) {
                if (dm.getDiskManagerFileInfoSet().nbFiles() > 1) {
                    if (dm_state.getFileLinks().hasLinks()) {
                        hasClearableLinks = true;
                    }
                }
            }
            if (dm_state.getFileLinks().size() > 0) {
                hasRevertableFiles = true;
            }
        }
        fileRescan = allScanSelected || allScanNotSelected;
    } else {
        // empty right-click
        barsOpened = false;
        forceStart = false;
        forceStartEnabled = false;
        start = false;
        stop = false;
        fileMove = false;
        fileExport = false;
        fileRescan = false;
        canSetMOC = false;
        upSpeedDisabled = true;
        downSpeedDisabled = true;
        changeUrl = false;
        recheck = false;
        manualUpdate = false;
    }
    if (bChangeDir) {
        MenuItem menuItemChangeDir = new MenuItem(menu, SWT.PUSH);
        Messages.setLanguageText(menuItemChangeDir, "MyTorrentsView.menu.changeDirectory");
        menuItemChangeDir.addListener(SWT.Selection, new Listener() {

            @Override
            public void handleEvent(Event e) {
                changeDirSelectedTorrents(dms, shell);
            }
        });
    }
    // Open Details
    if (include_show_details) {
        final MenuItem itemDetails = new MenuItem(menu, SWT.PUSH);
        Messages.setLanguageText(itemDetails, "MyTorrentsView.menu.showdetails");
        menu.setDefaultItem(itemDetails);
        Utils.setMenuItemImage(itemDetails, "details");
        itemDetails.addListener(SWT.Selection, 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);
                }
            }
        });
        itemDetails.setEnabled(hasSelection);
    }
    // Open Bar
    final MenuItem itemBar = new MenuItem(menu, SWT.CHECK);
    Messages.setLanguageText(itemBar, "MyTorrentsView.menu.showdownloadbar");
    Utils.setMenuItemImage(itemBar, "downloadBar");
    itemBar.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            if (DownloadBar.getManager().isOpen(dm)) {
                DownloadBar.close(dm);
            } else {
                DownloadBar.open(dm, shell);
            }
        }
    });
    itemBar.setEnabled(hasSelection);
    itemBar.setSelection(barsOpened);
    // ---
    new MenuItem(menu, SWT.SEPARATOR);
    // Run Data File
    final MenuItem itemOpen = new MenuItem(menu, SWT.PUSH);
    Messages.setLanguageText(itemOpen, "MyTorrentsView.menu.open");
    Utils.setMenuItemImage(itemOpen, "run");
    itemOpen.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            runDataSources(dms);
        }
    });
    itemOpen.setEnabled(hasSelection);
    // Explore (or open containing folder)
    final boolean use_open_containing_folder = COConfigurationManager.getBooleanParameter("MyTorrentsView.menu.show_parent_folder_enabled");
    final MenuItem itemExplore = new MenuItem(menu, SWT.PUSH);
    Messages.setLanguageText(itemExplore, "MyTorrentsView.menu." + (use_open_containing_folder ? "open_parent_folder" : "explore"));
    itemExplore.addListener(SWT.Selection, new ListenerDMTask(dms, false) {

        @Override
        public void run(DownloadManager dm) {
            ManagerUtils.open(dm, use_open_containing_folder);
        }
    });
    itemExplore.setEnabled(hasSelection);
    // Open in browser
    final Menu menuBrowse = new Menu(menu_shell, SWT.DROP_DOWN);
    final MenuItem itemBrowse = new MenuItem(menu, SWT.CASCADE);
    Messages.setLanguageText(itemBrowse, "MyTorrentsView.menu.browse");
    itemBrowse.setMenu(menuBrowse);
    final MenuItem itemBrowsePublic = new MenuItem(menuBrowse, SWT.PUSH);
    itemBrowsePublic.setText(MessageText.getString("label.public") + "...");
    itemBrowsePublic.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            ManagerUtils.browse(dm, false, true);
        }
    });
    final MenuItem itemBrowseAnon = new MenuItem(menuBrowse, SWT.PUSH);
    itemBrowseAnon.setText(MessageText.getString("label.anon") + "...");
    itemBrowseAnon.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            ManagerUtils.browse(dm, true, true);
        }
    });
    new MenuItem(menuBrowse, SWT.SEPARATOR);
    final MenuItem itemBrowseURL = new MenuItem(menuBrowse, SWT.PUSH);
    Messages.setLanguageText(itemBrowseURL, "label.copy.url.to.clip");
    itemBrowseURL.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            Utils.getOffOfSWTThread(new AERunnable() {

                @Override
                public void runSupport() {
                    String url = ManagerUtils.browse(dms[0], true, false);
                    if (url != null) {
                        ClipboardCopy.copyToClipBoard(url);
                    }
                }
            });
        }
    });
    itemBrowseURL.setEnabled(isSingleSelection);
    new MenuItem(menuBrowse, SWT.SEPARATOR);
    final MenuItem itemBrowseDir = new MenuItem(menuBrowse, SWT.CHECK);
    Messages.setLanguageText(itemBrowseDir, "library.launch.web.in.browser.dir.list");
    itemBrowseDir.setSelection(COConfigurationManager.getBooleanParameter("Library.LaunchWebsiteInBrowserDirList"));
    itemBrowseDir.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            COConfigurationManager.setParameter("Library.LaunchWebsiteInBrowserDirList", itemBrowseDir.getSelection());
        }
    });
    itemBrowse.setEnabled(hasSelection);
    // === advanced menu ===
    final MenuItem itemAdvanced = new MenuItem(menu, SWT.CASCADE);
    // $NON-NLS-1$
    Messages.setLanguageText(itemAdvanced, "MyTorrentsView.menu.advancedmenu");
    itemAdvanced.setEnabled(hasSelection);
    final Menu menuAdvanced = new Menu(menu_shell, SWT.DROP_DOWN);
    itemAdvanced.setMenu(menuAdvanced);
    // advanced > Download Speed Menu //
    long kInB = DisplayFormatters.getKinB();
    long maxDownload = COConfigurationManager.getIntParameter("Max Download Speed KBs", 0) * kInB;
    long maxUpload = COConfigurationManager.getIntParameter("Max Upload Speed KBs", 0) * kInB;
    ViewUtils.addSpeedMenu(menu_shell, menuAdvanced, true, true, true, hasSelection, downSpeedDisabled, downSpeedUnlimited, totalDownSpeed, downSpeedSetMax, maxDownload, upSpeedDisabled, upSpeedUnlimited, totalUpSpeed, upSpeedSetMax, maxUpload, dms.length, null, new ViewUtils.SpeedAdapter() {

        @Override
        public void setDownSpeed(final int speed) {
            ListenerDMTask task = new ListenerDMTask(dms) {

                @Override
                public void run(DownloadManager dm) {
                    dm.getStats().setDownloadRateLimitBytesPerSecond(speed);
                }
            };
            task.go();
        }

        @Override
        public void setUpSpeed(final int speed) {
            ListenerDMTask task = new ListenerDMTask(dms) {

                @Override
                public void run(DownloadManager dm) {
                    dm.getStats().setUploadRateLimitBytesPerSecond(speed);
                }
            };
            task.go();
        }
    });
    // advanced > Speed Limits
    final Menu speedLimitsMenu = new Menu(menuAdvanced.getShell(), SWT.DROP_DOWN);
    final MenuItem speedLimitsMenuItem = new MenuItem(menuAdvanced, SWT.CASCADE);
    Messages.setLanguageText(speedLimitsMenuItem, IMenuConstants.MENU_ID_SPEED_LIMITS);
    speedLimitsMenuItem.setMenu(speedLimitsMenu);
    MenuBuildUtils.addMaintenanceListenerForMenu(speedLimitsMenu, new MenuBuildUtils.MenuBuilder() {

        @Override
        public void buildMenu(Menu menu, MenuEvent menuEvent) {
            addSpeedLimitsMenu(dms, speedLimitsMenu);
        }
    });
    // advanced > Tracker Menu //
    final Menu menuTracker = new Menu(menu_shell, SWT.DROP_DOWN);
    final MenuItem itemTracker = new MenuItem(menuAdvanced, SWT.CASCADE);
    Messages.setLanguageText(itemTracker, "MyTorrentsView.menu.tracker");
    itemTracker.setMenu(menuTracker);
    itemExplore.setEnabled(hasSelection);
    addTrackerTorrentMenu(menuTracker, dms, changeUrl, manualUpdate, allStopped, use_open_containing_folder, fileMove);
    // advanced > files
    final MenuItem itemFiles = new MenuItem(menuAdvanced, SWT.CASCADE);
    Messages.setLanguageText(itemFiles, "ConfigView.section.files");
    final Menu menuFiles = new Menu(menu_shell, SWT.DROP_DOWN);
    itemFiles.setMenu(menuFiles);
    final MenuItem itemFileMoveData = new MenuItem(menuFiles, SWT.PUSH);
    Messages.setLanguageText(itemFileMoveData, "MyTorrentsView.menu.movedata");
    itemFileMoveData.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            moveDataFiles(shell, dms);
        }
    });
    itemFileMoveData.setEnabled(fileMove);
    final MenuItem itemFileMoveTorrent = new MenuItem(menuFiles, SWT.PUSH);
    Messages.setLanguageText(itemFileMoveTorrent, "MyTorrentsView.menu.movetorrent");
    itemFileMoveTorrent.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            moveTorrentFile(shell, dms);
        }
    });
    itemFileMoveTorrent.setEnabled(fileMove);
    // move on complete
    final Menu moc_menu = new Menu(shell, SWT.DROP_DOWN);
    MenuItem moc_item = new MenuItem(menuFiles, SWT.CASCADE);
    Messages.setLanguageText(moc_item, "label.move.on.comp");
    moc_item.setMenu(moc_menu);
    MenuItem clear_item = new MenuItem(moc_menu, SWT.PUSH);
    Messages.setLanguageText(clear_item, "Button.clear");
    clear_item.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            clearMOC(dms);
        }
    });
    clear_item.setEnabled(canClearMOC);
    MenuItem set_item = new MenuItem(moc_menu, SWT.PUSH);
    Messages.setLanguageText(set_item, "label.set");
    set_item.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            setMOC(shell, dms);
        }
    });
    set_item.setEnabled(canSetMOC);
    moc_item.setEnabled(canClearMOC || canSetMOC);
    // file export
    final MenuItem itemFileExport = new MenuItem(menuFiles, SWT.PUSH);
    Messages.setLanguageText(itemFileExport, "MyTorrentsView.menu.exportdownload");
    itemFileExport.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            exportDownloads(shell, dms);
        }
    });
    itemFileExport.setEnabled(fileExport);
    final MenuItem itemCheckFilesExist = new MenuItem(menuFiles, SWT.PUSH);
    Messages.setLanguageText(itemCheckFilesExist, "MyTorrentsView.menu.checkfilesexist");
    itemCheckFilesExist.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            dm.filesExist(true);
        }
    });
    final MenuItem itemLocateFiles = new MenuItem(menuFiles, SWT.PUSH);
    Messages.setLanguageText(itemLocateFiles, "MyTorrentsView.menu.locatefiles");
    itemLocateFiles.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            ManagerUtils.locateFiles(dms, shell);
        }
    });
    final MenuItem itemFileRescan = new MenuItem(menuFiles, 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);
    // revert
    final MenuItem itemRevertFiles = new MenuItem(menu, SWT.PUSH);
    Messages.setLanguageText(itemRevertFiles, "MyTorrentsView.menu.revertfiles");
    itemRevertFiles.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager[] dms) {
            FilesViewMenuUtil.revertFiles(tv, dms);
        }
    });
    itemRevertFiles.setEnabled(hasRevertableFiles);
    // clear links
    final MenuItem itemClearLinks = new MenuItem(menuFiles, 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);
    // clear allocation
    MenuItem itemFileClearAlloc = new MenuItem(menuFiles, 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(menuFiles, 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(menuFiles, 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);
    // Advanced -> archive
    final List<Download> ar_dms = new ArrayList<>();
    for (DownloadManager dm : dms) {
        Download stub = PluginCoreUtils.wrap(dm);
        if (!stub.canStubbify()) {
            continue;
        }
        ar_dms.add(stub);
    }
    MenuItem itemArchive = new MenuItem(menuAdvanced, SWT.PUSH);
    Messages.setLanguageText(itemArchive, "MyTorrentsView.menu.archive");
    Utils.setMenuItemImage(itemArchive, "archive");
    itemArchive.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            ManagerUtils.moveToArchive(ar_dms, null);
        }
    });
    itemArchive.setEnabled(ar_dms.size() > 0);
    // Advanced - > Rename
    final MenuItem itemRename = new MenuItem(menuAdvanced, SWT.DROP_DOWN);
    Messages.setLanguageText(itemRename, "MyTorrentsView.menu.rename");
    itemRename.setEnabled(hasSelection);
    itemRename.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            for (DownloadManager dm : dms) {
                AdvRenameWindow window = new AdvRenameWindow();
                window.open(dm);
            }
        }
    });
    if (ManagerUtils.canFindMoreLikeThis()) {
        final MenuItem itemFindMore = new MenuItem(menuAdvanced, SWT.PUSH);
        Messages.setLanguageText(itemFindMore, "MyTorrentsView.menu.findmorelikethis");
        itemFindMore.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager[] dms) {
                ManagerUtils.findMoreLikeThis(dms[0], shell);
            }
        });
        itemFindMore.setSelection(isSingleSelection);
    }
    // === advanced > quick view
    final Menu quickViewMenu = new Menu(menuAdvanced.getShell(), SWT.DROP_DOWN);
    final MenuItem quickViewMenuItem = new MenuItem(menuAdvanced, SWT.CASCADE);
    Messages.setLanguageText(quickViewMenuItem, IMenuConstants.MENU_ID_QUICK_VIEW);
    quickViewMenuItem.setMenu(quickViewMenu);
    MenuBuildUtils.addMaintenanceListenerForMenu(quickViewMenu, new MenuBuildUtils.MenuBuilder() {

        @Override
        public void buildMenu(Menu menu, MenuEvent menuEvent) {
            DownloadManager dm = dms[0];
            DiskManagerFileInfo[] files = dm.getDiskManagerFileInfoSet().getFiles();
            int added = 0;
            for (final DiskManagerFileInfo file : files) {
                if (Utils.isQuickViewSupported(file)) {
                    final MenuItem addItem = new MenuItem(menu, SWT.CHECK);
                    addItem.setSelection(Utils.isQuickViewActive(file));
                    addItem.setText(file.getTorrentFile().getRelativePath());
                    addItem.addListener(SWT.Selection, new Listener() {

                        @Override
                        public void handleEvent(Event arg) {
                            Utils.setQuickViewActive(file, addItem.getSelection());
                        }
                    });
                    added++;
                }
            }
            if (added == 0) {
                final MenuItem addItem = new MenuItem(menu, SWT.PUSH);
                addItem.setText(MessageText.getString("quick.view.no.files"));
                addItem.setEnabled(false);
            }
        }
    });
    quickViewMenuItem.setEnabled(isSingleSelection);
    // Alerts
    MenuFactory.addAlertsMenu(menuAdvanced, true, dms);
    if (userMode > 0) {
        final MenuItem itemExport = new MenuItem(menuAdvanced, SWT.CASCADE);
        // $NON-NLS-1$
        Messages.setLanguageText(itemExport, "MyTorrentsView.menu.exportmenu");
        Utils.setMenuItemImage(itemExport, "export");
        itemExport.setEnabled(hasSelection);
        final Menu menuExport = new Menu(menu_shell, SWT.DROP_DOWN);
        itemExport.setMenu(menuExport);
        // Advanced > Export > Export XML
        final MenuItem itemExportXML = new MenuItem(menuExport, SWT.PUSH);
        Messages.setLanguageText(itemExportXML, "MyTorrentsView.menu.export");
        itemExportXML.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager[] dms) {
                // First only.
                DownloadManager dm = dms[0];
                if (dm != null)
                    new ExportTorrentWizard(itemExportXML.getDisplay(), dm);
            }
        });
        // Advanced > Export > Export Torrent
        final MenuItem itemExportTorrent = new MenuItem(menuExport, SWT.PUSH);
        Messages.setLanguageText(itemExportTorrent, "MyTorrentsView.menu.exporttorrent");
        itemExportTorrent.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager[] dms) {
                exportTorrent(dms, shell);
            }
        });
        // end DMTask
        // Advanced > Export > WebSeed URL
        final MenuItem itemWebSeed = new MenuItem(menuExport, SWT.PUSH);
        Messages.setLanguageText(itemWebSeed, "MyTorrentsView.menu.exporthttpseeds");
        itemWebSeed.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager[] dms) {
                exportHTTPSeeds(dms);
            }
        });
    }
    if (userMode > 0) {
        final MenuItem itemExportXML = new MenuItem(menuAdvanced, SWT.PUSH);
        Messages.setLanguageText(itemExportXML, "label.options.and.info");
        itemExportXML.addListener(SWT.Selection, 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) {
        final MenuItem itemPeerSource = new MenuItem(menuAdvanced, SWT.CASCADE);
        // $NON-NLS-1$
        Messages.setLanguageText(itemPeerSource, "MyTorrentsView.menu.peersource");
        final Menu menuPeerSource = new Menu(menu_shell, SWT.DROP_DOWN);
        itemPeerSource.setMenu(menuPeerSource);
        addPeerSourceSubMenu(dms, menuPeerSource);
    }
    // Sequential download
    {
        final MenuItem dl_seq_enable = new MenuItem(menuAdvanced, SWT.CHECK);
        Messages.setLanguageText(dl_seq_enable, "menu.sequential.download");
        dl_seq_enable.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                dm.getDownloadState().setFlag(DownloadManagerState.FLAG_SEQUENTIAL_DOWNLOAD, dl_seq_enable.getSelection());
            }
        });
        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;
        }
        dl_seq_enable.setSelection(bChecked);
    }
    // IP Filter Enable
    if (userMode > 0) {
        final MenuItem ipf_enable = new MenuItem(menuAdvanced, SWT.CHECK);
        Messages.setLanguageText(ipf_enable, "MyTorrentsView.menu.ipf_enable");
        ipf_enable.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                dm.getDownloadState().setFlag(DownloadManagerState.FLAG_DISABLE_IP_FILTER, !ipf_enable.getSelection());
            }
        });
        boolean bEnabled = IpFilterManagerFactory.getSingleton().getIPFilter().isEnabled();
        if (bEnabled) {
            boolean allChecked = true;
            boolean allUnchecked = true;
            for (int j = 0; j < dms.length; j++) {
                DownloadManager dm = (DownloadManager) dms[j];
                boolean b = dm.getDownloadState().getFlag(DownloadManagerState.FLAG_DISABLE_IP_FILTER);
                if (b) {
                    allUnchecked = false;
                } else {
                    allChecked = false;
                }
            }
            boolean bChecked;
            if (allUnchecked) {
                bChecked = true;
            } else if (allChecked) {
                bChecked = false;
            } else {
                bChecked = false;
            }
            ipf_enable.setSelection(bChecked);
        }
        ipf_enable.setEnabled(bEnabled);
    }
    if (userMode > 1) {
        final MenuItem itemNetworks = new MenuItem(menuAdvanced, SWT.CASCADE);
        // $NON-NLS-1$
        Messages.setLanguageText(itemNetworks, "MyTorrentsView.menu.networks");
        final Menu menuNetworks = new Menu(menu_shell, SWT.DROP_DOWN);
        itemNetworks.setMenu(menuNetworks);
        addNetworksSubMenu(dms, menuNetworks);
    }
    // superseed
    if (userMode > 1 && isSeedingView) {
        final MenuItem itemSuperSeed = new MenuItem(menuAdvanced, 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);
                        }
                    }
                }
            });
        }
    }
    // Advanced > Pause For..
    if (userMode > 0) {
        boolean can_pause = false;
        for (int i = 0; i < dms.length; i++) {
            DownloadManager dm = dms[i];
            if (ManagerUtils.isPauseable(dm)) {
                can_pause = true;
                break;
            }
        }
        final MenuItem itemPauseFor = new MenuItem(menuAdvanced, SWT.PUSH);
        itemPauseFor.setEnabled(can_pause);
        Messages.setLanguageText(itemPauseFor, "MainWindow.menu.transfers.pausetransfersfor");
        itemPauseFor.addSelectionListener(new SelectionAdapter() {

            @Override
            public void widgetSelected(SelectionEvent e) {
                pauseDownloadsFor(dms);
            }
        });
    }
    // Advanced > Reposition
    final MenuItem itemPositionManual = new MenuItem(menuAdvanced, SWT.PUSH);
    Messages.setLanguageText(itemPositionManual, "MyTorrentsView.menu.reposition.manual");
    Utils.setMenuItemImage(itemPositionManual, "move");
    itemPositionManual.addSelectionListener(new SelectionAdapter() {

        @Override
        public void widgetSelected(SelectionEvent e) {
            repositionManual(tv, dms, shell, isSeedingView);
        }
    });
    // back to main menu
    if (userMode > 0 && isTrackerOn) {
        // Host
        final MenuItem itemHost = new MenuItem(menu, SWT.PUSH);
        Messages.setLanguageText(itemHost, "MyTorrentsView.menu.host");
        Utils.setMenuItemImage(itemHost, "host");
        itemHost.addListener(SWT.Selection, new Listener() {

            @Override
            public void handleEvent(Event event) {
                hostTorrents(dms);
            }
        });
        // Publish
        final MenuItem itemPublish = new MenuItem(menu, SWT.PUSH);
        Messages.setLanguageText(itemPublish, "MyTorrentsView.menu.publish");
        Utils.setMenuItemImage(itemPublish, "publish");
        itemPublish.addListener(SWT.Selection, new Listener() {

            @Override
            public void handleEvent(Event event) {
                publishTorrents(dms);
            }
        });
        itemHost.setEnabled(hasSelection);
        itemPublish.setEnabled(hasSelection);
    }
    /*  //TODO ensure that all limits combined don't go under the min 5kbs ?
		 //Disable at the end of the list, thus the first item of the array is instanciated last.
		 itemsSpeed[0] = new MenuItem(menuSpeed,SWT.PUSH);
		 Messages.setLanguageText(itemsSpeed[0],"MyTorrentsView.menu.setSpeed.disable");
		 itemsSpeed[0].setData("maxul", new Integer(-1));
		 itemsSpeed[0].addListener(SWT.Selection,itemsSpeedListener);
		 */
    // Category
    Menu menuCategory = new Menu(menu_shell, SWT.DROP_DOWN);
    final MenuItem itemCategory = new MenuItem(menu, SWT.CASCADE);
    // $NON-NLS-1$
    Messages.setLanguageText(itemCategory, "MyTorrentsView.menu.setCategory");
    // itemCategory.setImage(ImageRepository.getImage("speed"));
    itemCategory.setMenu(menuCategory);
    itemCategory.setEnabled(hasSelection);
    addCategorySubMenu(dms, menuCategory);
    // Tags
    Menu menuTags = new Menu(menu_shell, SWT.DROP_DOWN);
    final MenuItem itemTags = new MenuItem(menu, SWT.CASCADE);
    Messages.setLanguageText(itemTags, "label.tags");
    itemTags.setMenu(menuTags);
    itemTags.setEnabled(hasSelection);
    TagUIUtils.addLibraryViewTagsSubMenu(dms, menuTags);
    if (isSeedingView) {
        final MenuItem itemPersonalShare = new MenuItem(menu, SWT.PUSH);
        Messages.setLanguageText(itemPersonalShare, "MyTorrentsView.menu.create_personal_share");
        itemPersonalShare.addListener(SWT.Selection, new ListenerDMTask(dms, false) {

            @Override
            public void run(DownloadManager dm) {
                File file = dm.getSaveLocation();
                Map<String, String> properties = new HashMap<>();
                properties.put(ShareManager.PR_PERSONAL, "true");
                if (file.isFile()) {
                    ShareUtils.shareFile(file.getAbsolutePath(), properties);
                } else if (file.isDirectory()) {
                    ShareUtils.shareDir(file.getAbsolutePath(), properties);
                }
            }
        });
        boolean can_share_pers = dms.length > 0;
        for (DownloadManager dm : dms) {
            File file = dm.getSaveLocation();
            if (!file.exists()) {
                can_share_pers = false;
                break;
            }
        }
        itemPersonalShare.setEnabled(can_share_pers);
    }
    // ---
    new MenuItem(menu, SWT.SEPARATOR);
    // Queue
    final MenuItem itemQueue = new MenuItem(menu, SWT.PUSH);
    // $NON-NLS-1$
    Messages.setLanguageText(itemQueue, "MyTorrentsView.menu.queue");
    Utils.setMenuItemImage(itemQueue, "start");
    itemQueue.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            Utils.getOffOfSWTThread(new AERunnable() {

                @Override
                public void runSupport() {
                    queueDataSources(dms, true);
                }
            });
        }
    });
    itemQueue.setEnabled(start);
    // Force Start
    if (userMode > 0) {
        final MenuItem itemForceStart = new MenuItem(menu, SWT.CHECK);
        Messages.setLanguageText(itemForceStart, "MyTorrentsView.menu.forceStart");
        Utils.setMenuItemImage(itemForceStart, "forcestart");
        itemForceStart.addListener(SWT.Selection, new ListenerDMTask(dms) {

            @Override
            public void run(DownloadManager dm) {
                if (ManagerUtils.isForceStartable(dm)) {
                    dm.setForceStart(itemForceStart.getSelection());
                }
            }
        });
        itemForceStart.setSelection(forceStart);
        itemForceStart.setEnabled(forceStartEnabled);
    }
    // Pause
    if (userMode > 0) {
        final MenuItem itemPause = new MenuItem(menu, SWT.PUSH);
        Messages.setLanguageText(itemPause, "v3.MainWindow.button.pause");
        Utils.setMenuItemImage(itemPause, "pause");
        itemPause.addListener(SWT.Selection, new Listener() {

            @Override
            public void handleEvent(Event event) {
                Utils.getOffOfSWTThread(new AERunnable() {

                    @Override
                    public void runSupport() {
                        pauseDataSources(dms);
                    }
                });
            }
        });
        itemPause.setEnabled(pause);
    }
    // Stop
    final MenuItem itemStop = new MenuItem(menu, SWT.PUSH);
    Messages.setLanguageText(itemStop, "MyTorrentsView.menu.stop");
    Utils.setMenuItemImage(itemStop, "stop");
    itemStop.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            Utils.getOffOfSWTThread(new AERunnable() {

                @Override
                public void runSupport() {
                    stopDataSources(dms);
                }
            });
        }
    });
    itemStop.setEnabled(stop);
    // Force Recheck
    final MenuItem itemRecheck = new MenuItem(menu, SWT.PUSH);
    Messages.setLanguageText(itemRecheck, "MyTorrentsView.menu.recheck");
    Utils.setMenuItemImage(itemRecheck, "recheck");
    itemRecheck.addListener(SWT.Selection, new ListenerDMTask(dms) {

        @Override
        public void run(DownloadManager dm) {
            if (dm.canForceRecheck()) {
                dm.forceRecheck();
            }
        }
    });
    itemRecheck.setEnabled(recheck);
    // Delete
    final MenuItem itemRemove = new MenuItem(menu, SWT.PUSH);
    Messages.setLanguageText(itemRemove, "menu.delete.options");
    Utils.setMenuItemImage(itemRemove, "delete");
    itemRemove.addListener(SWT.Selection, new Listener() {

        @Override
        public void handleEvent(Event event) {
            removeDownloads(dms, null, true);
        }
    });
    itemRemove.setEnabled(hasSelection);
}

Example 17 with DownloadManagerState

use of com.biglybt.core.download.DownloadManagerState in project BiglyBT by BiglySoftware.

the class UserAlerts method activityFinished.

private void activityFinished(DownloadManager manager, DiskManagerFileInfo dm_file) {
    DownloadManagerState dm_state = manager.getDownloadState();
    if (dm_state.getFlag(DownloadManagerState.FLAG_LOW_NOISE)) {
        return;
    }
    boolean download = dm_file == null;
    Object relatedObject;
    String item_name;
    if (download) {
        relatedObject = manager;
        item_name = manager.getDisplayName();
    } else {
        relatedObject = dm_file.getDiskManager();
        item_name = dm_file.getFile(true).getName();
    }
    final String sound_enabler;
    final String sound_file;
    final String speech_enabler;
    final String speech_text;
    final String popup_enabler;
    final String popup_def_text;
    final String native_enabler;
    final String native_text;
    if (download) {
        sound_enabler = "Play Download Finished";
        sound_file = "Play Download Finished File";
        speech_enabler = "Play Download Finished Announcement";
        speech_text = "Play Download Finished Announcement Text";
        popup_enabler = "Popup Download Finished";
        popup_def_text = "popup.download.finished";
        native_enabler = "Notify Download Finished";
        native_text = "notify.download.finished";
    } else {
        sound_enabler = "Play File Finished";
        sound_file = "Play File Finished File";
        speech_enabler = "Play File Finished Announcement";
        speech_text = "Play File Finished Announcement Text";
        popup_enabler = "Popup File Finished";
        popup_def_text = "popup.file.finished";
        native_enabler = null;
        native_text = null;
    }
    Map dl_file_alerts = dm_state.getMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS);
    String dlf_prefix = download ? "" : (String.valueOf(dm_file.getIndex()) + ".");
    boolean do_popup = COConfigurationManager.getBooleanParameter(popup_enabler) || isDLFEnabled(dl_file_alerts, dlf_prefix, popup_enabler);
    boolean do_speech = Constants.isOSX && (COConfigurationManager.getBooleanParameter(speech_enabler) || isDLFEnabled(dl_file_alerts, dlf_prefix, speech_enabler));
    boolean do_sound = COConfigurationManager.getBooleanParameter(sound_enabler, false) || isDLFEnabled(dl_file_alerts, dlf_prefix, sound_enabler);
    boolean do_native = native_enabler != null && COConfigurationManager.getBooleanParameter(native_enabler);
    doStuff(relatedObject, item_name, do_popup, popup_def_text, false, do_native, native_text, do_speech, speech_text, do_sound, sound_file);
}

Example 18 with DownloadManagerState

use of com.biglybt.core.download.DownloadManagerState in project BiglyBT by BiglySoftware.

the class MenuFactory method addAlertsMenu.

public static void addAlertsMenu(Menu menu, boolean createSubmenu, final DownloadManager[] dms) {
    if (dms.length == 0) {
        return;
    }
    Menu alert_menu;
    if (createSubmenu) {
        alert_menu = new Menu(menu.getShell(), SWT.DROP_DOWN);
        MenuItem alerts_item = new MenuItem(menu, SWT.CASCADE);
        Messages.setLanguageText(alerts_item, "ConfigView.section.interface.alerts");
        alerts_item.setMenu(alert_menu);
    } else {
        alert_menu = menu;
    }
    String[][] alert_keys = { { "Play Download Finished", "playdownloadfinished" }, { "Play Download Finished Announcement", "playdownloadspeech" }, { "Popup Download Finished", "popupdownloadfinished" } };
    boolean[] all_enabled = new boolean[alert_keys.length];
    Arrays.fill(all_enabled, true);
    for (DownloadManager dm : dms) {
        DownloadManagerState state = dm.getDownloadState();
        Map map = state.getMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS);
        if (map == null) {
            Arrays.fill(all_enabled, false);
        } else {
            for (int i = 0; i < alert_keys.length; i++) {
                if (!map.containsKey(alert_keys[i][0])) {
                    all_enabled[i] = false;
                }
            }
        }
    }
    for (int i = 0; i < alert_keys.length; i++) {
        final String[] entry = alert_keys[i];
        if (i != 1 || Constants.isOSX) {
            final MenuItem item = new MenuItem(alert_menu, SWT.CHECK);
            item.setText(MessageText.getString("ConfigView.label." + entry[1]));
            item.setSelection(all_enabled[i]);
            item.addListener(SWT.Selection, new Listener() {

                @Override
                public void handleEvent(Event event) {
                    boolean selected = item.getSelection();
                    for (DownloadManager dm : dms) {
                        DownloadManagerState state = dm.getDownloadState();
                        Map map = state.getMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS);
                        if (map == null) {
                            map = new HashMap();
                        } else {
                            map = new HashMap(map);
                        }
                        if (selected) {
                            map.put(entry[0], "");
                        } else {
                            map.remove(entry[0]);
                        }
                        state.setMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS, map);
                    }
                }
            });
        }
    }
}

Example 19 with DownloadManagerState

use of com.biglybt.core.download.DownloadManagerState in project BiglyBT by BiglySoftware.

the class MenuFactory method addAlertsMenu.

public static void addAlertsMenu(Menu menu, final DownloadManager dm, final DiskManagerFileInfo[] files) {
    if (files.length == 0) {
        return;
    }
    String[][] alert_keys = { { "Play File Finished", "playfilefinished" }, { "Play File Finished Announcement", "playfilespeech" }, { "Popup File Finished", "popupfilefinished" } };
    Menu alert_menu = new Menu(menu.getShell(), SWT.DROP_DOWN);
    MenuItem alerts_item = new MenuItem(menu, SWT.CASCADE);
    Messages.setLanguageText(alerts_item, "ConfigView.section.interface.alerts");
    alerts_item.setMenu(alert_menu);
    boolean[] all_enabled = new boolean[alert_keys.length];
    DownloadManagerState state = dm.getDownloadState();
    Map map = state.getMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS);
    if (map != null) {
        Arrays.fill(all_enabled, true);
        for (DiskManagerFileInfo file : files) {
            for (int i = 0; i < alert_keys.length; i++) {
                String key = String.valueOf(file.getIndex()) + "." + alert_keys[i][0];
                if (!map.containsKey(key)) {
                    all_enabled[i] = false;
                }
            }
        }
    }
    for (int i = 0; i < alert_keys.length; i++) {
        final String[] entry = alert_keys[i];
        if (i != 1 || Constants.isOSX) {
            final MenuItem item = new MenuItem(alert_menu, SWT.CHECK);
            item.setText(MessageText.getString("ConfigView.label." + entry[1]));
            item.setSelection(all_enabled[i]);
            item.addListener(SWT.Selection, new Listener() {

                @Override
                public void handleEvent(Event event) {
                    DownloadManagerState state = dm.getDownloadState();
                    Map map = state.getMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS);
                    if (map == null) {
                        map = new HashMap();
                    } else {
                        map = new HashMap(map);
                    }
                    boolean selected = item.getSelection();
                    for (DiskManagerFileInfo file : files) {
                        String key = String.valueOf(file.getIndex()) + "." + entry[0];
                        if (selected) {
                            map.put(key, "");
                        } else {
                            map.remove(key);
                        }
                    }
                    state.setMapAttribute(DownloadManagerState.AT_DL_FILE_ALERTS, map);
                }
            });
        }
    }
}

Example 20 with DownloadManagerState

use of com.biglybt.core.download.DownloadManagerState in project BiglyBT by BiglySoftware.

the class TorrentOpener method addTorrent.

/**
 * @param torrentOptions
 * @return
 * @since 5.0.0.1
 *
 * @TODO: Remove SWT UI parts (use UIFunctions) and move out of SWT tree
 */
public static final boolean addTorrent(final TorrentOpenOptions torrentOptions) {
    try {
        if (torrentOptions.getTorrent() == null) {
            return false;
        }
        final DownloadManagerInitialisationAdapter dmia = new DownloadManagerInitialisationAdapter() {

            @Override
            public int getActions() {
                return (ACT_ASSIGNS_TAGS);
            }

            @Override
            public void initialised(DownloadManager dm, boolean for_seeding) {
                DiskManagerFileInfoSet file_info_set = dm.getDiskManagerFileInfoSet();
                DiskManagerFileInfo[] fileInfos = file_info_set.getFiles();
                boolean reorder_mode = COConfigurationManager.getBooleanParameter("Enable reorder storage mode");
                int reorder_mode_min_mb = COConfigurationManager.getIntParameter("Reorder storage mode min MB");
                try {
                    dm.getDownloadState().suppressStateSave(true);
                    boolean[] toSkip = new boolean[fileInfos.length];
                    boolean[] toCompact = new boolean[fileInfos.length];
                    boolean[] toReorderCompact = new boolean[fileInfos.length];
                    int[] priorities = null;
                    int comp_num = 0;
                    int reorder_comp_num = 0;
                    final TorrentOpenFileOptions[] files = torrentOptions.getFiles();
                    for (int iIndex = 0; iIndex < fileInfos.length; iIndex++) {
                        DiskManagerFileInfo fileInfo = fileInfos[iIndex];
                        if (iIndex >= 0 && iIndex < files.length && files[iIndex].lSize == fileInfo.getLength()) {
                            // Always pull destination file from fileInfo and not from
                            // TorrentFileInfo because the destination may have changed
                            // by magic code elsewhere
                            File fDest = fileInfo.getFile(true);
                            if (files[iIndex].isLinked()) {
                                fDest = files[iIndex].getDestFileFullName();
                                // Can't use fileInfo.setLink(fDest) as it renames
                                // the existing file if there is one
                                dm.getDownloadState().setFileLink(iIndex, fileInfo.getFile(false), fDest);
                            }
                            if (files[iIndex].isToDownload()) {
                                int priority = files[iIndex].getPriority();
                                if (priority != 0) {
                                    if (priorities == null) {
                                        priorities = new int[fileInfos.length];
                                    }
                                    priorities[iIndex] = priority;
                                }
                            } else {
                                toSkip[iIndex] = true;
                                if (!fDest.exists()) {
                                    if (reorder_mode && (fileInfo.getLength() / (1024 * 1024)) >= reorder_mode_min_mb) {
                                        toReorderCompact[iIndex] = true;
                                        reorder_comp_num++;
                                    } else {
                                        toCompact[iIndex] = true;
                                        comp_num++;
                                    }
                                }
                            }
                        }
                    }
                    if (files.length == 1) {
                        TorrentOpenFileOptions file = files[0];
                        if (file.isManualRename()) {
                            String fileRename = file.getDestFileName();
                            if (fileRename != null && fileRename.length() > 0) {
                                dm.getDownloadState().setDisplayName(fileRename);
                            }
                        }
                    } else {
                        String folderRename = torrentOptions.getManualRename();
                        if (folderRename != null && folderRename.length() > 0) {
                            dm.getDownloadState().setDisplayName(folderRename);
                        }
                    }
                    if (comp_num > 0) {
                        file_info_set.setStorageTypes(toCompact, DiskManagerFileInfo.ST_COMPACT);
                    }
                    if (reorder_comp_num > 0) {
                        file_info_set.setStorageTypes(toReorderCompact, DiskManagerFileInfo.ST_REORDER_COMPACT);
                    }
                    file_info_set.setSkipped(toSkip, true);
                    if (priorities != null) {
                        file_info_set.setPriority(priorities);
                    }
                    int maxUp = torrentOptions.getMaxUploadSpeed();
                    int kInB = DisplayFormatters.getKinB();
                    if (maxUp > 0) {
                        dm.getStats().setUploadRateLimitBytesPerSecond(maxUp * kInB);
                    }
                    int maxDown = torrentOptions.getMaxDownloadSpeed();
                    if (maxDown > 0) {
                        dm.getStats().setDownloadRateLimitBytesPerSecond(maxDown * kInB);
                    }
                    DownloadManagerState dm_state = dm.getDownloadState();
                    if (torrentOptions.disableIPFilter) {
                        dm_state.setFlag(DownloadManagerState.FLAG_DISABLE_IP_FILTER, true);
                    }
                    if (torrentOptions.peerSource != null) {
                        for (String peerSource : torrentOptions.peerSource.keySet()) {
                            boolean enable = torrentOptions.peerSource.get(peerSource);
                            dm_state.setPeerSourceEnabled(peerSource, enable);
                        }
                    }
                    Map<String, Boolean> enabledNetworks = torrentOptions.getEnabledNetworks();
                    if (enabledNetworks != null) {
                        if (!dm_state.getFlag(DownloadManagerState.FLAG_INITIAL_NETWORKS_SET)) {
                            for (String net : enabledNetworks.keySet()) {
                                boolean enable = enabledNetworks.get(net);
                                dm_state.setNetworkEnabled(net, enable);
                            }
                        }
                    }
                    List<Tag> initialTags = torrentOptions.getInitialTags();
                    for (Tag t : initialTags) {
                        t.addTaggable(dm);
                    }
                    List<List<String>> trackers = torrentOptions.getTrackers(true);
                    if (trackers != null) {
                        TOTorrent torrent = dm.getTorrent();
                        TorrentUtils.listToAnnounceGroups(trackers, torrent);
                        try {
                            TorrentUtils.writeToFile(torrent);
                        } catch (Throwable e2) {
                            Debug.printStackTrace(e2);
                        }
                    }
                    if (torrentOptions.bSequentialDownload) {
                        dm_state.setFlag(DownloadManagerState.FLAG_SEQUENTIAL_DOWNLOAD, true);
                    }
                    File moc = torrentOptions.getMoveOnComplete();
                    if (moc != null) {
                        dm_state.setAttribute(DownloadManagerState.AT_MOVE_ON_COMPLETE_DIR, moc.getAbsolutePath());
                    }
                } finally {
                    dm.getDownloadState().suppressStateSave(false);
                }
            }
        };
        CoreFactory.addCoreRunningListener(new CoreRunningListener() {

            @Override
            public void coreRunning(Core core) {
                TOTorrent torrent = torrentOptions.getTorrent();
                byte[] hash = null;
                try {
                    hash = torrent.getHash();
                } catch (TOTorrentException e1) {
                }
                int iStartState = (torrentOptions.getStartMode() == TorrentOpenOptions.STARTMODE_STOPPED) ? DownloadManager.STATE_STOPPED : DownloadManager.STATE_QUEUED;
                GlobalManager gm = core.getGlobalManager();
                DownloadManager dm = gm.addDownloadManager(torrentOptions.sFileName, hash, torrentOptions.getParentDir(), torrentOptions.getSubDir(), iStartState, true, torrentOptions.getStartMode() == TorrentOpenOptions.STARTMODE_SEEDING, dmia);
                // since gm.addDown.. will handle it.
                if (dm == null) {
                    return;
                }
                if (torrentOptions.iQueueLocation == TorrentOpenOptions.QUEUELOCATION_TOP) {
                    gm.moveTop(new DownloadManager[] { dm });
                }
                if (torrentOptions.getStartMode() == TorrentOpenOptions.STARTMODE_FORCESTARTED) {
                    dm.setForceStart(true);
                }
            }
        });
    } catch (Exception e) {
        UIFunctions uif = UIFunctionsManager.getUIFunctions();
        if (uif != null) {
            uif.showErrorMessage("OpenTorrentWindow.mb.openError", Debug.getStackTrace(e), new String[] { torrentOptions.sOriginatingLocation, e.getMessage() });
        }
        return false;
    }
    return true;
}