javascript HTA使用现有窗口

r7knjye2  于 2023-08-02  发布在  Java
关注(0)|答案(2)|浏览(120)

这是一个精简版的代码，一直运行完美，但现在不是在Windows 8/IE10。

<html>
<head>
<HTA:APPLICATION ID = "ICP"
INNERBORDER = "no"
CAPTION = "no"
SHOWINTASKBAR = "no"
Scroll = "no"
navigable = "yes"
WINDOWSTATE = "maximize">
<script>
function firstwindow()
{
window.open("red.htm","mywindow");
}
function secondwindow()
{
window.open("blue.htm","mywindow");
}
</script>
</head>
<body> 
<a onClick = "firstwindow()">OPEN FIRST WINDOW </a>
<a onClick = "secondwindow()">OPEN SECOND WINDOW </a>
</body>
</html>

字符串
运行并打开第一个窗口（red.htm）后，我希望“第二个窗口”在与“第一个窗口”相同的窗口中打开。它过去工作正常，但现在它在一个新窗口中打开“第二个窗口”（blue.htm）。
任何想法将不胜感激。谢啦，谢啦

JavaScript

2条答案

按热度按时间
jyztefdp

jyztefdp1#

根据this article，HTA不信任window.open。
HTAwindow.open规则认为www.example.com命令是不安全的，因此任何以这种方式弹出的新窗口都会有一个地址栏（至少在IE7中）。如果窗口的内容是可信的，那么您可以使用window.showModelessDialog打开一个被认为是可信HTA的一部分的窗口。
使用showModalDialog

赞(0）分享  回复(0）举报  2023-08-02
svdrlsy4

svdrlsy42#

<!DOCTYPE html>
<html>
<head>
    <title>File Operations</title>
    <hta:application id="FileOperationsHTA" 
                     applicationname="FileOperationsHTA" 
                     singleinstance="yes" 
                     maximizebutton="no" 
                     minimizebutton="no" 
                     windowstate="normal" 
                     scroll="no" 
                     navigable="yes" 
                     showintaskbar="no" 
                     contextmenu="no" 
                     selection="no"
    />
</head>

<body onload="showFields()">
    <h1>File Operations</h1>
    <label for="operationCombo">Select operation:</label>
    <select id="operationCombo" onchange="showFields()">
        <option value="">Select an operation</option>
        <option value="move">Move</option>
        <option value="copy">Copy</option>
        <option value="delete">Delete</option>
        <option value="newfolder">New Folder</option>
     <option value="rename">Rename</option>
    </select>

    <div id="sourceField" style="display: none;">
        <label for="sourcePath">Source path:</label>
        <input type="text" id="sourcePath" />
    </div>

    <div id="destinationField" style="display: none;">
        <label for="destinationPath">Destination path:</label>
        <input type="text" id="destinationPath" />
    </div>

    <div id="deleteField" style="display: none;">
        <label for="deletePath">File/Folder to delete:</label>
        <input type="text" id="deletePath" />
    </div>

    <div id="newFolderField" style="display: none;">
        <label for="parentPath">Parent path for new folder:</label>
        <input type="text" id="parentPath" />
        <label for="newFolderName">New folder name:</label>
        <input type="text" id="newFolderName" />
    </div>
 <div id="renameField" style="display: none;">
        <label for="sourcePathRename">Source path:</label>
        <input type="text" id="sourcePathRename" />
        <label for="destinationPathRename">Destination path:</label>
        <input type="text" id="destinationPathRename" />
        <label for="newFileName">New filename:</label>
        <input type="text" id="newFileName" />
    </div>

    <button id="executeButton" onclick="executeOperation()">Execute</button>

    <script type="text/javascript">
        function showFields() {

           

            var operation = document.getElementById('operationCombo').value;
            var sourceField = document.getElementById('sourceField');
            var destinationField = document.getElementById('destinationField');
            var deleteField = document.getElementById('deleteField');
            var newFolderField = document.getElementById('newFolderField');
        var renameField = document.getElementById('renameField');
            var executeButton = document.getElementById('executeButton');

            sourceField.style.display = 'none';
            destinationField.style.display = 'none';
            deleteField.style.display = 'none';
            newFolderField.style.display = 'none';
            renameField.style.display = 'none';

           

            switch (operation) {
                case 'move':
                    sourceField.style.display = 'block';
                    destinationField.style.display = 'block';
                    break;
                case 'copy':
                    sourceField.style.display = 'block';
                    destinationField.style.display = 'block';
                    break;
                case 'delete':
                    deleteField.style.display = 'block';
                    break;
                case 'newfolder':
                    newFolderField.style.display = 'block';
                    break;
         case 'rename':
                    renameField.style.display = 'block';
                    document.getElementById('sourcePathRename').disabled = false;
                    document.getElementById('destinationPathRename').disabled = false;
                    document.getElementById('newFileName').disabled = false;
                    break;
            }
        }

       function executeOperation() {
            var operation = document.getElementById('operationCombo').value;
            switch (operation) {
                case 'move':
                    var sourcePath = document.getElementById('sourcePath').value;
                    var destinationPath = document.getElementById('destinationPath').value;
                    moveFilesWithWildcard(sourcePath, destinationPath);
                    break;
                case 'copy':
                    var sourcePath = document.getElementById('sourcePath').value;
                    var destinationPath = document.getElementById('destinationPath').value;
                    copyFilesWithWildcard(sourcePath, destinationPath);
                    break;
                case 'delete':
                    var deletePath = document.getElementById('deletePath').value;
                    deleteFilesWithWildcard(deletePath);
                    break;
                case 'newfolder':
                    var parentPath = document.getElementById('parentPath').value;
                    var newFolderName = document.getElementById('newFolderName').value;
                    createNewFolder(parentPath, newFolderName);
                    break;
         case 'rename':
                    var sourcePathRename = document.getElementById('sourcePathRename').value;
                    var destinationPathRename = document.getElementById('destinationPathRename').value;
                    var newFileName = document.getElementById('newFileName').value;
                    renameFile(sourcePathRename, destinationPathRename, newFileName);
                    break;
            }
        }

function renameFile(sourcePath, destinationPath, newFileName) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            if (fso.FileExists(sourcePath)) {
                try {
                    fso.MoveFile(sourcePath, fso.BuildPath(destinationPath, newFileName));
                    alert('Rename operation executed.\nSource: ' + sourcePath + '\nDestination: ' + destinationPath);
                } catch (e) {
                    alert('Error renaming file: ' + e.message);
                }
            } else {
                alert('Source file not found.');
            }
        }

        function moveFilesWithWildcard(sourcePath, destinationPath) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var parentFolder = fso.GetParentFolderName(sourcePath);
            var wildcard = fso.GetFileName(sourcePath);
            var parentFolderObj = fso.GetFolder(parentFolder);

            if (fso.FolderExists(parentFolder)) {
                try {
                    var files = new Enumerator(parentFolderObj.Files);
                    var subFolders = new Enumerator(parentFolderObj.SubFolders);
                    var regex = new RegExp(wildcard.replace(/\./g, "\\.").replace(/\*/g, ".*"), "i");

                    for (; !files.atEnd(); files.moveNext()) {
                        var file = files.item();
                        if (regex.test(file.Name)) {
                            var sourceFile = fso.BuildPath(parentFolder, file.Name);
                            var destinationFile = fso.BuildPath(destinationPath, file.Name);
                            fso.MoveFile(sourceFile, destinationFile);
                        }
                    }

                    for (; !subFolders.atEnd(); subFolders.moveNext()) {
                        var subFolder = subFolders.item();
                        if (regex.test(subFolder.Name)) {
                            var newDestPath = fso.BuildPath(destinationPath, subFolder.Name);
                            fso.CreateFolder(newDestPath);
                            moveFilesRecursive(subFolder, newDestPath);
                        }
                    }
                } catch (e) {
                    alert('Error moving files/folders with wildcard.');
                }
            } else {
                alert('Parent path not found.');
            }
        }

        function moveFilesRecursive(folder, destinationPath) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var files = new Enumerator(folder.Files);
            var subFolders = new Enumerator(folder.SubFolders);

            for (; !files.atEnd(); files.moveNext()) {
                var file = files.item();
                var destinationFile = fso.BuildPath(destinationPath, file.Name);
                fso.MoveFile(file.Path, destinationFile);
            }

            for (; !subFolders.atEnd(); subFolders.moveNext()) {
                var subFolder = subFolders.item();
                var newDestPath = fso.BuildPath(destinationPath, subFolder.Name);
                fso.CreateFolder(newDestPath);
                moveFilesRecursive(subFolder, newDestPath);
            }
        }

        function copyFiles(sourcePath, destinationPath) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var folder = fso.GetFolder(sourcePath);

            if (fso.FolderExists(destinationPath)) {
                try {
                    copyFilesRecursive(folder, destinationPath);
                    alert('Copy operation executed.\nSource Path: ' + sourcePath + '\nDestination Path: ' + destinationPath);
                } catch (e) {
                    alert('Error copying files/folders.');
                }
            } else {
                alert('Destination path not found.');
            }
        }

        function copyFilesRecursive(folder, destinationPath) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var files = new Enumerator(folder.Files);
            var subFolders = new Enumerator(folder.SubFolders);

            for (; !files.atEnd(); files.moveNext()) {
                var file = files.item();
                fso.CopyFile(file.Path, fso.BuildPath(destinationPath, file.Name), true);
            }

            for (; !subFolders.atEnd(); subFolders.moveNext()) {
                var subFolder = subFolders.item();
                var newDestPath = fso.BuildPath(destinationPath, subFolder.Name);
                fso.CreateFolder(newDestPath);
                copyFilesRecursive(subFolder, newDestPath);
            }
        }

 function moveFilesWithWildcard(sourcePath, destinationPath) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var parentFolder = fso.GetParentFolderName(sourcePath);
            var wildcard = fso.GetFileName(sourcePath);
            var parentFolderObj = fso.GetFolder(parentFolder);

            if (fso.FolderExists(parentFolder)) {
                try {
                    var files = new Enumerator(parentFolderObj.Files);
                    var subFolders = new Enumerator(parentFolderObj.SubFolders);
                    var regex = new RegExp(wildcard.replace(/\./g, "\\.").replace(/\*/g, ".*"), "i");

                    for (; !files.atEnd(); files.moveNext()) {
                        var file = files.item();
                        if (regex.test(file.Name)) {
                            var sourceFile = fso.BuildPath(parentFolder, file.Name);
                            var destinationFile = fso.BuildPath(destinationPath, file.Name);
                            fso.MoveFile(sourceFile, destinationFile);
                        }
                    }

                    for (; !subFolders.atEnd(); subFolders.moveNext()) {
                        var subFolder = subFolders.item();
                        if (regex.test(subFolder.Name)) {
                            var newDestPath = fso.BuildPath(destinationPath, subFolder.Name);
                            fso.CreateFolder(newDestPath);
                            moveFilesRecursive(subFolder, newDestPath);
                        }
                    }
                } catch (e) {
                    alert('Error moving files/folders with wildcard.');
                }
            } else {
                alert('Parent path not found.');
            }
        }

        function moveFilesRecursive(folder, destinationPath) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var files = new Enumerator(folder.Files);
            var subFolders = new Enumerator(folder.SubFolders);

            for (; !files.atEnd(); files.moveNext()) {
                var file = files.item();
                var destinationFile = fso.BuildPath(destinationPath, file.Name);
                fso.MoveFile(file.Path, destinationFile);
            }

            for (; !subFolders.atEnd(); subFolders.moveNext()) {
                var subFolder = subFolders.item();
                var newDestPath = fso.BuildPath(destinationPath, subFolder.Name);
                fso.CreateFolder(newDestPath);
                moveFilesRecursive(subFolder, newDestPath);
            }
        }



    

    function copyFilesWithWildcard(sourcePath, destinationPath) {
        var fso = new ActiveXObject("Scripting.FileSystemObject");

        if (fso.FileExists(sourcePath)) {
            // Source path is a single file
            var sourceFolder = fso.GetParentFolderName(sourcePath);
            var sourceFileName = fso.GetFileName(sourcePath);

            if (fso.FileExists(destinationPath)) {
                // Destination path includes a filename, create a new folder in the destination path
                var destinationParentFolder = fso.GetParentFolderName(destinationPath);
                var newFolderName = fso.GetBaseName(destinationPath);
                destinationPath = fso.BuildPath(destinationParentFolder, newFolderName);
            } else if (!fso.FolderExists(destinationPath)) {
                // Destination folder does not exist, create it
                fso.CreateFolder(destinationPath);
            }

            // Perform the copy operation
            fso.CopyFile(sourcePath, fso.BuildPath(destinationPath, sourceFileName));
            alert('Copy operation executed.\nSource: ' + sourcePath + '\nDestination: ' + destinationPath);
        } else if (fso.FolderExists(sourcePath)) {
            // Source path is a folder
            var parentFolder = fso.GetParentFolderName(sourcePath);
            var wildcard = fso.GetFileName(sourcePath);
            var parentFolderObj = fso.GetFolder(parentFolder);

            if (fso.FolderExists(parentFolder)) {
                try {
                    var files = new Enumerator(parentFolderObj.Files);
                    var subFolders = new Enumerator(parentFolderObj.SubFolders);
                    var regex = new RegExp(wildcard.replace(/\./g, "\\.").replace(/\*/g, ".*"), "i");

                    // Collect files and folders matching the wildcard
                    var filesToCopy = [];
                    var foldersToCopy = [];

                    for (; !files.atEnd(); files.moveNext()) {
                        var file = files.item();
                        if (regex.test(file.Name)) {
                            filesToCopy.push(file);
                        }
                    }

                    for (; !subFolders.atEnd(); subFolders.moveNext()) {
                        var subFolder = subFolders.item();
                        if (regex.test(subFolder.Name)) {
                            foldersToCopy.push(subFolder);
                        }
                    }

                    // Perform the copy operation
                    if (!fso.FolderExists(destinationPath)) {
                        // Destination folder does not exist, create it
                        fso.CreateFolder(destinationPath);
                    }

                    for (var i = 0; i < filesToCopy.length; i++) {
                        var file = filesToCopy[i];
                        file.Copy(fso.BuildPath(destinationPath, file.Name));
                    }

                    for (var i = 0; i < foldersToCopy.length; i++) {
                        var folder = foldersToCopy[i];
                        copyFolderRecursive(folder, fso.BuildPath(destinationPath, folder.Name));
                    }

                    alert('Copy operation executed.\nSource: ' + sourcePath + '\nDestination: ' + destinationPath);
                } catch (e) {
                    alert('Error copying files/folders with wildcard: ' + e.message);
                }
            } else {
                alert('Source parent path not found.');
            }
        } else {
            alert('Source path not found.');
        }
    }

  





  
    function copyFolderRecursive(sourceFolder, destinationFolder) {
        var fso = new ActiveXObject("Scripting.FileSystemObject");
        fso.CreateFolder(destinationFolder);

        var files = new Enumerator(sourceFolder.Files);
        var subFolders = new Enumerator(sourceFolder.SubFolders);

        for (; !files.atEnd(); files.moveNext()) {
            var file = files.item();
            file.Copy(fso.BuildPath(destinationFolder, file.Name));
        }

        for (; !subFolders.atEnd(); subFolders.moveNext()) {
            var subFolder = subFolders.item();
            copyFolderRecursive(subFolder, fso.BuildPath(destinationFolder, subFolder.Name));
        }
    }

 

function createNewFolder(parentPath, newFolderName) {
            var fso = new ActiveXObject("Scripting.FileSystemObject");
            var fullPath = fso.BuildPath(parentPath, newFolderName);

            try {
                fso.CreateFolder(fullPath);
                alert('New folder created successfully.\nPath: ' + fullPath);
            } catch (e) {
                alert('Error creating new folder: ' + e.message);
            }
        }




    function deleteFilesWithWildcard(deletePath) {
        var fso = new ActiveXObject("Scripting.FileSystemObject");
        var parentFolder = fso.GetParentFolderName(deletePath);
        var wildcard = fso.GetFileName(deletePath);
        var parentFolderObj = fso.GetFolder(parentFolder);

        if (fso.FolderExists(parentFolder)) {
            try {
                var files = new Enumerator(parentFolderObj.Files);
                var subFolders = new Enumerator(parentFolderObj.SubFolders);
                var regex = new RegExp(wildcard.replace(/\./g, "\\.").replace(/\*/g, ".*"), "i");

                // Collect files and folders matching the wildcard
                var filesToDelete = [];
                var foldersToDelete = [];

                for (; !files.atEnd(); files.moveNext()) {
                    var file = files.item();
                    if (regex.test(file.Name)) {
                        filesToDelete.push(file);
                    }
                }

                for (; !subFolders.atEnd(); subFolders.moveNext()) {
                    var subFolder = subFolders.item();
                    if (regex.test(subFolder.Name)) {
                        foldersToDelete.push(subFolder);
                    }
                }

                // Delete files
                for (var i = 0; i < filesToDelete.length; i++) {
                    filesToDelete[i].Delete();
                }

                // Delete folders
                for (var i = 0; i < foldersToDelete.length; i++) {
                    deleteFolderRecursive(foldersToDelete[i]);
                }

                alert('Delete operation executed.\nPath: ' + deletePath);
            } catch (e) {
                alert('Error deleting files/folders with wildcard: ' + e.message);
            }
        } else {
            alert('Parent path not found.');
        }
    }

    function deleteFolderRecursive(folder) {
        var fso = new ActiveXObject("Scripting.FileSystemObject");
        var subFolders = new Enumerator(folder.SubFolders);

        for (; !subFolders.atEnd(); subFolders.moveNext()) {
            var subFolder = subFolders.item();
            deleteFolderRecursive(subFolder);
        }

        fso.DeleteFolder(folder.Path);
    }



    </script>
</body>
</html>

字符串

赞(0）分享  回复(0）举报  2023-08-02
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com