JavaScript窗口功能指南之命名窗口和框架(转)

 

当你创建一个框架结构的文档时,<FRAME>标记的NAME属性定义了每一个框架的名字,如下:

  <FRAMESET>

   <FRAME NAME="left" SRC="toolbar.html">

   <FRAME NAME="right" SRC="index.html">

  </FRAMESET>

  在例子中,文档包含2个框架:left和right。在文档toolbar.html中,链接代码就象下面的一样:

  <A HREF="about.html" TARGET="right">About Us</A>

  <A HREF="feedback.html" TARGET="right">Feedback</A>

  注意, <FORM>标记同样支持TARGET属性,它定义了响应表单的目标窗口。而<BAEE>标记则指明了文档中所有链接的通用默认目标窗口:

  <BASE TARGET="right">

  上面的标记定义了页面中所有元素的目标位置。以下的HTML元素支持target属性:<A>、<AREA>、<FORM>。

  在实际应用中,<BASE>元素必须出现在文档的HEAD标记间,要先于任何指向外部资源的元素前。如果在文档中指定了<BASE>标记,那么链接将不再遵循默认的target位置,而是被明确地指向另外一个不同的target位置:

  <HEAD>

  <BASE TARGET="right">

  </HEAD>

  <BODY>

  <A HREF="table.html" TARGET="_self">Table of Contents</A>

  <A HREF="about.html">About Us</A>

  <A HREF="feedback.html">Feedback</A>

  </BODY>

  如上所见,第1个链接的target是 "_self" (带有一个下划线),这表示当点击这个链接时,新文档会在当前活动的窗口中打开。下表列举了HTML中一些特殊的target位置标识:

Target 含义

_blank 在一个新的空窗口中装载文档,新窗口没有命名。

_parent 在链接所在窗口的直接父窗口中装载文档。

_search 在浏览器的搜索区装载文档,注意,这个功能只在Internet Explorer 5 或者更高版本中适用。

_self 在链接所在的窗口中装载文档。

_top 在最上层窗口中装载文档。

  现在我们了解了框架名字,下面将它们与窗口一起工作。当定义target为 "_blank"时,a一个新窗口就会弹出来。比如,如果想让一个链接在新窗口中打开,请使用下面的代码:

  <A HREF="newpage.html" TARGET="_blank">A New Page</A>

  新窗口没有命名,换言之,它不能被其他元素的 TARGET 属性所引用。但是当我们使用一个标准的target名字时,会发生什么呢?请看下面的定义:

  <A HREF="newtip.html" TARGET="tip">A New Tip</A>

  在这种情况下,我们为新窗口提供了一个特殊的名字。 新窗口的名字为 "tip", 因此任何链接或者表单,只要定义了 TARGET="tip", 就会在同一窗口中装载页面。如果没有框架或者窗口匹配指定的target,那么点击链接后将在新窗口中打开。看看下面的例子:

  <A HREF="http://www.ccidnet.com/" TARGET="_blank">CCIDNET</A>

  <A HREF="http://www.ccidnet.com/tech/" TARGET="_blank">技术天地</A>

  看看产生的效果:

CCIDNET、技术天地

  点击第一个链接,将在新窗口中打开文档。点击第二个链接,也将产生一个新窗口。如果再次点击链接,新窗口仍将打开。如你所见,链接每一次被点击都会产生一个新窗口。让我们再试一试下面的例子:

  <A HREF="http://www.ccidnet.com/" TARGET="main">CCIDNET</A>

  <A HREF="http://www.ccidnet.com/tech/" TARGET="main">技术天地</A>  

  效果如下:

CCIDNET、技术天地

  点击第一个链接时,产生一个新窗口。接着点击第二个链接,新文档将出现在刚刚打开的窗口中。新窗口定义了明确的名字,叫做 "main", 所以任何指定了 TARGET="main" 的链接或者表单都会在那个窗口被装载。

名字的属性

  借助JavaScript,我们能够通过窗口的名字属性发现窗口的名字(适用于IE3+, N2+)。同样,我们能够设置一个框架或者窗口的名字属性(适用于IE3+, N3+)。来看看下面的HTML文档(showname.html):

  <HTML>

  <HEAD><TITLE>Display Name</TITLE></HEAD>

  <BODY>

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  alert('The name of this window is: "' + window.name + '"');

  // -->

  </SCRIPT>

  </BODY>

  </HTML>

  再看看下面的链接:

  <A HREF="showname.html" TARGET="_blank">A New Window</A>

  <A HREF="showname.html" TARGET="first">First Window</A>

  <A HREF="showname.html" TARGET="second">Second Window</A>

  <A HREF="showname.html" TARGET="third">Third Window</A>

  文档showname.html包含了一个脚本程序,它负责在一个alert对话框中显示窗口的名字。

  name 属性属于 window 对象。它可以被任何window对象使用,包括框架。例如,下面的语句设置了一个框架窗口的名字:

  parent.frames[1].name = "right";

  当操作框架时, 访问不同层窗口是很简单的。如果想参阅更多细节,请访问 Window References 。

  HTML不能给当前窗口指派名字。就是说,在当前页面不可能通过HTML代码来设置当前窗口的名字。要实现这个目的,只有一个方法,就是给 window.name 属性分配值。下面来试一试,看看如下的代码,它创建了一个简单按钮,点击后设置当前窗口的名字:

  <FORM>

  <INPUT TYPE="button" VALUE="Set Name to myWin" onClick="window.name = 'myWin'">

  </FORM>

  点击按钮后,当前窗口的名字就改变为 "myWin", 除非指派其他的值,它会一直保持。 我们可以在其他窗口中包含一些链接,并定义他们的target位置为myWin,就是 TARGET="myWin" 。

  如果前面你已经设置了当前窗口的名字为myWin,那么链接将在当前窗口打开。下面是新窗口中的代码:

  <A HREF="http://www.docjs.com/" TARGET="myWin">Home</A>

  <A HREF="http://www.docjs.com/tips/" TARGET="myWin">Recent Tips</A>

  方便起见,我们给出能将当前窗口的名字设置为空""的按钮的源码:

  <form>

    <input onClick="window.name = ''" type=button value="Reset Name" name="button2">

  </form>

  你要注意,不要给2个不同的窗口分配同一个名字。如果2个窗口被分配了同一个名字,那么只有一个窗口被关联,另外一个就将被忽视

JavaScript窗口功能指南之打开一个新窗口

2001年1月21日11:11:13 赛迪网 听风编译

  当你点击一个简单的链接打开一个新窗口时,你没有对新窗口任何控制权。浏览器以默认的功能打开新窗口。此外,你也不能使用JavaScript引用新窗口的window对象,因此你不可能操纵新窗口的属性。看看下面的JavaScript语句:

  window.open("http://www.docjs.com/", "win");

  这条语句打开一个新窗口,显示页面http://www.docjs.com/。 新窗口的名字被赋值为 "win"。window对象的open()方法的基本语法是:

  window.open(sURL, sName);

  2个参数都是可选的,如果不想指定URL或者窗口名称,就使用空字符串("").

  sURL 是一个字符串,它指定了要显示文档的URL。如果不指定URL,就产生一个空窗口。 sName 是定义的窗口名字,这个名字被用于<form>或者<a>标记的 TARGET 属性。在Internet Explorer 5 和以后版本,如果定义这个数值为 "_search",那么就将在浏览器的搜索区打开 sURL 。

  如果带有同一参数sName执行window.open()方法2次,会发生什么呢?就象用HTML产生的窗口一样,如果你定义一个已经存在窗口的名字,那么open()方法将简单地利用存在的窗口,而不是打开一个新的。看看下面的脚本程序:

  window.open("http://www.javascript.com/", "win");

  window.open("http://www.docjs.com/", "win");

  执行上面的语句,浏览器将打开一个名字为“win”的新窗口,并在其中显示页面www.javascript.com。第2条语句替换当前窗口内容为页面www.docjs.com。下面的语句产生2个不同的窗口显示各自的内容:

  window.open("http://www.javascript.com/", "win1");

  window.open("http://www.docjs.com/", "win2");

  如果不指定新窗口的名字,浏览器就自动地产生一个新窗口。这同样适用于“_blank”,但是空字符串是另外一回事。对于Internet Explorer和Navigator,有几个重要的区别,如下:

window.open("http://www.cnn.com/");

window.open("http://www.usatoday.com/");

Internet Explorer Navigator

打开2个不同的窗口 打开2个不同的窗口

window.open("http://www.cnn.com/", "_blank");

window.open("http://www.usatoday.com/", "_blank");

Internet Explorer Navigator

打开2个不同的窗口 打开2个不同的窗口

window.open("http://www.cnn.com/", "");

window.open("http://www.usatoday.com/", "");

Internet Explorer Navigator

打开2个不同的窗口 只打开一个窗口,名字为空("")

  下面一行不会用到,只是列举出来。如果想命名窗口,就给出一个可以理解的名字(不是"")。如果不想命名,就干脆不指定这个参数,或者使用特殊的target位置"_blank"。

  关于open()方法的一个重要之处是:open ()方法几乎总是以window.open()的形式被调用执行,即使window代表了全局对象从而可以彻底省略。由于document对象也有 open()方法,所以当我们想打开一个新窗口时,指定window对象将会清晰必要。在事件处理中,必须指定window.open(),而不能简单地使用open()。由于JavaScript中静态对象的作用范围限制,没有指定对象名字的open()调用等价于document.open()。比如说,当一个HTML按钮的事件处理发生时,范围就包含了按钮对象、表单对象、文档对象,以及窗口对象。这样,如果那样一个事件处理器引用了open()方法,识别器在文档对象就中止,事件处理器打开一个新的文档,而不是打开一个新的窗口。

返回值

  为了合适地引用子窗口,应该将 window.open()的结果分配给一个变量。如果窗口被成功地创建,window.open()就返回新窗口对象,或者返回null表示创建失败(比如由于内存不足)。如果你的脚本程序需要引用新窗口的元素,返回值就是非常重要的。然而,当新窗口打开后,并没有“父-子”关系存在。看看下面的语句:

  var recentTips = window.open("http://www.docjs.com/tips/", "tips");

  这里,我们分配给新窗口的window对象一个变量值名叫recentTips。如果在函数中调用window.open()方法,记住一定要省略var关键字,因为变量应该是全局的。否则,window 的引用就位于局部变量中,并且当函数执行完毕后就不能被访问。下面的语句在一个alert对话框中显示新窗口的URL:

  alert(recentTips.location.href);

  你也可以通过下面的方法改变新窗口的URL:

  recentTips.location.href = "http://www.usatoday.com/";

  在前面一节中,你已经看到了如何使用HTML链接和表单打开一个新窗口。通过指定target属性或者给window对象的name属性分配一个数值,我们就能够命名窗口。但是怎样才能通过它的html名字来引用存在的窗口呢?答案是简单的。如果你执行了带有空字符串的URL参数以及存在窗口名字的window.open()方法,这个窗口的引用就会被返回。看看下面的链接代码:

  <A HREF="http://www.cnet.com/" TARGET="news">CNET</A>

  当执行下面的语句时,就得到了新窗口的引用:

  var latestNews = window.open("", "news");

让我们再试一试。点击这个链接 CNET,但它装载后,点击下面的按钮:

 

  这个按钮实际上取回了名字叫做“news”的窗口的引用,并且修改了那个窗口的URL。注意,如果在点击按钮前不点击那个链接,一个新的、空的窗口就被装载(因为指定的窗口名字不存在)。记住,不管窗口中的文档是什么,窗口始终保持着它的名字。下面是这个按钮相关的HTML和JavaScript代码:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function changeURL(winName, newURL) {

   win = window.open("", winName);

   win.location.href = newURL;

  }

  // -->

  </SCRIPT>

  <FORM>

  <INPUT TYPE="button" VALUE="Load ZDNet"

  onClick="changeURL('news', 'http://www.zdnet.com/')">

  </FORM>

  前面一段脚本程序表明了如何获取一个存在窗口的引用。如果你仅仅想改变存在窗口的URL,你同样可以直接使用目标页面的URL来调用window.open()方法:

  function changeURL(winName, newURL) {

   win = window.open(newURL, winName);

  }

  在下面一节中,我们将讨论如何定制新窗口的外观。

JavaScript窗口功能指南之定制新窗口

2001年1月21日11:11:7 赛迪网 听风编译

    window.open()方法的基本语法结构是:  

  window.open(sURL, sName);

  然而,你可以通过使用2个附加的参数定制新窗口:

  window.open(sURL, sName[, sFeatures][, bReplace]);

  通过省略这些参数,你可以使用默认特征。让我们先看看bReplace参数,它仅仅被Internet Explorer:4和以后版本所支持。只有当第2个参数命名一个已经存在的窗口时,这个参数才有用。它是一个Boolean型数值,如果为true,就表示第一个参数指定的URL替换当前窗口浏览位置在历史中保存的地址,如果为false,就表示在窗口的浏览历史记录中创建一个新项目(这是默认情况)。由于这个参数只被微软的浏览器所支持,所以显得不很有用。下面让我们看看广为人知的JavaScript窗口设置性质。

  open()方法的第3个参数是一个字符串,包含一个以逗号分隔的选项列表(不要包含任何空格)。在驶入可用功能的海洋前,先让我们看看它们的含义所在。这里有一个例子:

  win = window.open("http://www.docjs.com/", "docjs", "location=1,menubar=1,resizable=1");

  这个语句打开一个可变尺寸的窗口,它带有一个地址栏和一个菜单条,而其他的特征都被关闭。比如,没有指定status特征,新窗口就没有了状态栏。注意,还有几个其他的方法来定义窗口特征。下面是几个和前面语句功能等价的命令:

  win = window.open("http://www.docjs.com/", "docjs", "location,menubar,resizable");

  win = window.open("http://www.docjs.com/", "docjs", "location=yes,menubar=yes,resizable=yes");

  win = window.open("http://www.docjs.com/", "docjs", "location,menubar=1,resizable=yes");

  许多特征可以是yes,或者是no。对于这些特征,你也可以使用1代替yes,0代替no。如果你想激活一个特征,同样可以简单地在sFeatures字符串中列出特征的名字。如果没有列出,就表示屏蔽该功能(titlebar和hotkeys除外)。sFeatures参数是一个以逗号分隔的功能列表,其中不应该包含任何空格或者空白字符。列表中的每一个元素应该包含下面的格式:

  feature[=value]

  分配sFeatures参数一个空字符串与全部省略这个参数之间有一个很大的区别。如果调用open()没有任何参数,那么所有的特征都被设置为默认值。换言之,浏览器将创建一个窗口,它有默认得宽度和高度、标准的菜单、工具栏,以及其他浏览器具备的特征。如果你使用空字符串做为需要功能的列表,浏览器将打开一个窗口,它的所有特征都是被屏蔽的(titlebar和hotkeys除外)。

  window.open()方法的第2个参数sName指定了窗口的名字。如果是一个已经存在窗口的名字,浏览器就在那个窗口中装载指定的URL(sURL)。所以,如果sName指定了存在的窗口,浏览器就将忽视定义的特征列表。

  不是所有的窗口特征都能被所有的浏览器所支持。如果浏览器不能识别指定的特征,它就简单地忽视掉。下面来看看JavaScript中各种窗口特征的定义:

alwaysLowered innerWidth screenY

alwaysRaised left scrollbars

channelmode location status

dependent menubar titlebar

directories outerWidth toolbar

fullscreen outerHeight top

height menubar width

hotkeys resizable z-lock

innerHeight screenX

alwaysLowered

  Internet Explorer:不支持

  Navigator:版本 4+

  指定窗口总是保留在堆栈的最下面。换言之,不管新窗口是否激活,总是其他窗口下。

  window.open("alwayslowered.html", "_blank", "alwaysLowered");

alwaysRaised

  Internet Explorer:不支持

  Navigator:版本 4+

  指定窗口总是保留在堆栈的最上面。换言之,不管新窗口是否激活,总是其他窗口上。

  window.open("alwaysraised.html", "_blank", "alwaysRaised");

channelmode

  Internet Explorer:版本 4+

  Navigator:不支持

  指定是否按照剧场模式显示窗口,以及是否显示频道区。

  window.open("channelmode.html", "_blank", "channelmode");

dependent

  Internet Explorer:不支持

  Navigator:版本 4+

  定义是否窗口成为当前打开窗口的依赖子窗口。依赖窗口就是当它的父窗口关闭时,它也随即关闭。在windows平台上,一个依赖窗口不会在任务栏上显示。

  window.open("dependent.html", "_blank", "dependent");

directories

  Internet Explorer:所有版本

  Navigator:所有版本

  指定是否显示目录按钮(比如众所周知的"What's Cool" and "What's New" 按钮)。Internet Explorer将这些目录按钮引用为链接工具栏,Navigator(版本4和以上)称之为个人工具栏。

  window.open("directories.html", "_blank", "directories");

fullscreen

  Internet Explorer:版本 4+

  Navigator:不支持

  定义是否按照全屏方式打开浏览器。请小心使用全屏模式,因为在这种模式下,浏览器的标题栏和菜单都被隐藏,所有你应该提供一个按钮或者其他可视的线索来帮助用户关闭这个窗口。当然,使用热键ALT+F4也能关闭窗口。

  window.open("fullscreen.html", "_blank", "fullscreen");

height

  Internet Explorer:所有版本

  Navigator:所有版本

  以象素pixel为单位定义窗口文档显示区域的高度,最小数值是100。如果仅仅定义高度,Internet Explorer使用给定的高度和默认的宽度。对于Navigator,如果不同时指定width或者innerWidth,那么就将忽略这个属性。

  window.open("height.html", "_blank", "height=200,width=300");

hotkeys

  Internet Explorer:不支持

  Navigator:版本 4+

  如果没有定义(或者为0),那么就屏蔽了没有菜单条的新窗口的大部分热键。但是安全以及退出热键仍然保留。

  window.open("hotkeys.html", "_blank", "hotkeys=0,menubar=0");

innerHeight

  Internet Explorer:不支持

  Navigator:版本 4+

  以象素pixel为单位定义窗口文档显示区域的高度,最小数值是100。在Navigator版本4中,这个特征替换height,为得是保持向后兼容。对于Navigator,如果不同时指定width或者innerWidth,那么就将忽略这个属性。

  window.open("innerheight.html", "_blank", "innerHeight=200,innerWidth=300");

innerWidth

  Internet Explorer:不支持

  Navigator:版本 4+

  以象素pixel为单位定义窗口文档显示区域的宽度,最小数值是100。在Navigator版本4中,这个特征替换width,为得是保持向后兼容。对于Navigator,如果不同时指定height或者innerHeight,那么就将忽略这个属性。

  window.open("innerwidth.html", "_blank", "innerHeight=200,innerWidth=300");

left

  Internet Explorer:版本 4+

  Navigator:不支持

  以象素为单位定义窗口的X左标。

  window.open("left.html", "_blank", "left=20");

location

  Internet Explorer:所有版本

  Navigator:所有版本

  定义是否显示浏览器中供地址URL输入的文本域。

  window.open("location.html", "_blank", "location");

menubar

  Internet Explorer:所有版本

  Navigator:所有版本

  定义是否显示菜单条(菜单条位于窗口顶部,包括“文件”和“编辑”等)。

  window.open("menubar.html", "_blank", "menubar");

outerHeight

  Internet Explorer:不支持

  Navigator:版本 4+

  以象素为单位定义窗口(它的外部边界)的总高度,最小数值比100多一些,因为窗口内容区域的高度必须至少是100。如果没有同时定义outerWidth,Navigator将忽视这个特征。

  window.open("outerheight.html", "_blank", "outerHeight=200,outerWidth=300");

outerWidth

  Internet Explorer:不支持

  Navigator:版本 4+

  以象素为单位定义窗口(它的外部边界)的总宽度,最小数值比100多一些,因为窗口内容区域的宽度必须至少是100。如果没有同时定义outerHeight,Navigator将忽视这个特征。

  window.open("outerwidth.html", "_blank", "outerHeight=200,outerWidth=300");

resizable

  Internet Explorer:所有版本

  Navigator:所有版本

  定义是否窗口可以通过它的边界进行大小缩放控制。依赖于平台不同,用户也许还有其他改变窗口大小的方法。

  window.open("resizable.html", "_blank", "resizable");

screenX

  Internet Explorer:不支持

  Navigator:版本 4+

  以象素为单位定义窗口的X坐标。

  window.open("screenx.html", "_blank", "screenX=20");

screenY

  Internet Explorer:不支持

  Navigator:版本 4+

  以象素为单位定义窗口的Y坐标。

  window.open("screeny.html", "_blank", "screenY=20");

scrollbars

  Internet Explorer:所有版本

  Navigator:所有版本

  定义是否激活水平和垂直滚动条。

  window.open("scrollbars.html", "_blank", "scrollbars");

status

  Internet Explorer:所有版本

  Navigator:所有版本

  定义是否在窗口的下部添加状态栏。

  window.open("status.html", "_blank", "status");

titlebar

  Internet Explorer:Version 5+

  Navigator:版本 4+

  定义是否显示窗口的标题栏。在Internet Explorer中,除非调用者是一个HTML应用程序或者一个可信任的对话框,那么这个特征是被屏蔽的。

  window.open("titlebar.html", "_blank", "titlebar=0");

toolbar

  Internet Explorer:所有版本

  Navigator:所有版本

  定义是否显示浏览器的工具栏(位于窗口的上部,包括“后退”和“向前”)。

  window.open("toolbar.html", "_blank", "toolbar");

top

  Internet Explorer:版本 4+

  Navigator:不支持

  以象素为单位定义窗口的纵坐标。

  window.open("top.html", "_blank", "top=20");

width

  Internet Explorer:所有版本

  Navigator:所有版本

  以象素pixel为单位定义窗口文档显示区域的宽度,最小数值是100。如果仅仅定义宽度,Internet Explorer使用给定的宽度和默认的高度。对于Navigator,如果不同时指定height或者innerHeight,那么就将忽略这个属性。

  window.open("width.html", "_blank", "height=200,width=300");

z-lock

  Internet Explorer:不支持

  Navigator:版本 4+

  定义窗口激活时不在堆栈中浮起,就是说,新窗口当被激活时并不能位于其他窗口之上。

  window.open("zlock.html", "_blank", "z-lock");

JavaScript窗口功能指南之发挥窗口特征

2001年1月21日11:11:4 赛迪网 听风编译

  在前面一节中,我们全面接触了JavaScript提供的窗口特征。许多这些特征是基于特殊浏览器的,就是说它们不可能同时在Internet Explorer和Navigator中工作。在这一节中,我们将探索几个有趣的方面,以及一些有用的技巧。

指定窗口尺度

  我们使用参数height、 width、 innerHeight 以及 innerWidth来定义新窗口的尺度。Internet Explorer支持height和width,Navigator则使用innerHeight和innerWidth。Navigator也支持 outerHeight和outerWidth特征,它们指定了窗口外围边界的尺度,外围边界包括标题栏、滚动条以及其他操作系统元素。在 Internet Explorer中,为达到同样目的,我们使用height、width、innerHeight和innerWidth。每种浏览器都将忽略其他特征,所以当创建新窗口时,就可以定义所有的4个。

  window.open("dimensions.html", "_blank", "height=150,innerHeight=150,width=200,innerWidth=200");

  如果在你的机器上有2种浏览器,你可以比较一下JavaScript的不同窗口尺度特征。

打开一个全屏幕窗口

  Internet Explorer支持fullscreen属性,使用它可以创建一个覆盖全屏的窗口,而不必考虑显示器的实际尺寸。看看下面的例子:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  var str = "left=0,screenX=0,top=0,screenY=0";

  if (window.screen) {

   var ah = screen.availHeight - 30;

   var aw = screen.availWidth - 10;

   str += ",height=" + ah;

   str += ",innerHeight=" + ah;

   str += ",width=" + aw;

   str += ",innerWidth=" + aw;

  } else {

   str += ",resizable"; // so the user can resize the window manually

  }

  function launchFull(url, name) {

   return window.open(url, name, str);

  }

  var win = launchFull("full1.html", "full");

  // -->

  </SCRIPT>

  让我们看看它是怎样工作的。首先,我们给全局变量 str分配一个初始数值,它指定了新窗口位于屏幕的左上角。不要担心这个字符串,在本节稍候将解释它的含义。下一个语句检查浏览器是否支持screen对象。如果不支持,我们就使用resizable特征从而用户可以手工地改变新窗口的大小,最终适应整个屏幕。但是如果浏览器是支持screen对象的,那么就可以充分利用screen.vavilHeight和screen.vavilWidth来决定系统屏幕上工作区域的高度和宽度,包括任何系统元素,比如任务栏。由于height、width、innerHeight以及innerWidth等特征不能精确说明窗口边界,所以必须要减去大概象素的数值。

  如果想充分利用浏览器的fullscreen特征,仅仅加入下面的脚本程序就可以:

  var str = "left=0,screenX=0,top=0,screenY=0,fullscreen";

  我们不需要检查浏览器是否为Internet Explorer,因为当fullscreen特征定义后,其他特征就被忽略。

定义窗口坐标

  我们将使用left、top、screenX和screenY参数来指定新窗口的坐标。Internet Explorer支持left和top,Navigator则使用screenX和screenY。

  window.open("http://www.docjs.com/", "_blank", "left=20,screenX=20,top=40,screenY=40");

  记住,left应该总是与screenX一起定义, top与screenY一起定义。如果你使用过这些特征,你会发现Navigator同样支持left和top。然而,这是一个未公开的操作,所以你不要依赖于此(因为未来的Navigator版本也许不再支持它)。而且,如果对于left和screenX指定了不同的数值,Navigator将使用分配给screenX的数值。同样,如果指定了screenY,Navigator将忽视top。

  记住,这些特征都是以象素为单位的,并且以屏幕的左上角为基点。即使你在框架中调用window.open()方法,指定的值依然以屏幕的边界为准。

  打开一个居中的窗口

  现在你了解了如何放置一个新窗口,下面再添加一些算法。下面的脚本程序打开一个居中的窗口:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function launchCenter(url, name, height, width) {

   var str = "height=" + height + ",innerHeight=" + height;

   str += ",width=" + width + ",innerWidth=" + width;

   if (window.screen) {

    var ah = screen.availHeight - 30;

    var aw = screen.availWidth - 10;

    var xc = (aw - width) / 2;

    var yc = (ah - height) / 2;

    str += ",left=" + xc + ",screenX=" + xc;

    str += ",top=" + yc + ",screenY=" + yc;

   }

   return window.open(url, name, str);

  }

  var win = launchCenter('center.html', 'center', 220, 440);

  // -->

  </SCRIPT>

  这段脚本程序非常类似于全屏幕窗口的脚本程序。它使用了screen.availHeight和screen.availWidth属性,同时加上新窗口的期待尺寸,最终计算出窗口左上角的精确位置。如果你很难理解(aw-width)/2的含义,请看看下面的算式:

  (aw / 2) - (width / 2)

  如你所见,它们是一样的,就是从屏幕的中央减去窗口宽度的一半。同样的算法应用于窗口的垂直坐标。

向后兼容的链接

  当我们编写一个脚本程序时,考虑到那些不能使用JavaScript的用户是非常重要的,这常常发生在用户屏蔽掉浏览器中JavaScript功能的情况下。当这种情况发生时,我们应该仍然能够使用HTML装载一个窗口。看看下面的链接:

  <A HREF="http://www.docjs.com/" TARGET="win">Doc JavaScript</A>

  这打开了一个名为win的窗口,在其中装载定义的URL。下面的链接使用了JavaScript完成同样的目的:

  <A HREF="javascript:void(window.open('http://www.docjs.com/', 'win', 'status'))">Doc JavaScript</A>

  基于JavaScript的链接创建了一个简单的窗口,它有一个状态栏,但是不包括其他默认元素(比如工具栏)。然而前面的HTML链接打开的窗口是一个默认的浏览器窗口。2种方法实现了同样的目的。使用 JavaScript,我们可以控制新窗口的外观,但是如果浏览器不支持JavaScript,这样的链接就没有用了。所以,我们合并这些链接:

  <A HREF="http://www.docjs.com/" TARGET="win" onClick="window.open('http://www.docjs.com/', 'win', 'status'); return false">Doc JavaScript</A>

  如果JavaScript是激活的,在装载HREF属性定义的URL前,浏览器就执行onClick事件处理程序。由于这个事件处理程序返回false,浏览器将忽略HREF属性,就好像用户根本没有点击链接。事实上,语句return false简单地中止了“点击”。如果浏览器不支持JavaScript,那么就不会运行onClick事件处理程序,因此,象其他HTML链接一样,指定的URL被装载。

 

JavaScript窗口功能指南之检查一个窗口是否存在

2001年1月21日11:11:1 赛迪网 听风编译

  当你创建一个新窗口时,给open()方法的返回值分配一个变量非常重要。比如,下面的语句创建一个新窗口,然后立即关闭它:

  win = window.open("http://www.docjs.com/", "js");

  win.close();

Window对象

  每一个浏览器窗口都与一个清楚地window对象对应,所以,当你想引用当前窗口时,你应该使用window对象。下面的语句设置当前窗口的URL:

  window.location.href = "http://www.docjs.com/";

  当你在脚本程序中放置这样一个语句时,你不需要指定window对象,因为当前窗口的存在是默认的:

  location.href = "http://www.docjs.com/";

  注意,self等价于window,所以,self.close()实际上就等于window.close()。

  当你想操纵一个窗口时,你必须确认它是存在的。在为window.open()方法定义一个变量时,要将它定义为全局变量并设置为null。记住,open()方法返回新窗口的window对象。这里是一个例子:

  var win = null;

  function launchWindow() {

   win = window.open();

   // statements that refer to the new window go here

  }

  如果你想对新窗口执行一个操作,你首先应该检查变量win是否为null:

  // if win exists, move the window

  if (win) win.moveTo(0, 0);

  注意,null等于false,同时任何其他合法的对象等价于true。如果win等于true,你就知道了它不是null,这意味着新窗口成功地创建了。

open "属性"

现在你知道了浏览器实际创建了新窗口。但是它仍然存在吗?不是必须的。你需要确认可用的窗口的确拥有一个真正的window对象。既然每个window对象对应于一个open()方法,你就可以通过对象探测检查到这个方法:

  // 如果win.open存在,就移动窗口

  if (win.open) win.moveTo(0, 0);

  变量win对照窗口的window对象,所以win.open对应window的window.open方法。注意,条件表达式是一个函数引用,不是一个函数调用。除非你确认win存在,你不应该试图估计win.open。下面的语句描述了正确的执行方法:

  // if win and win.open exist, move the window

  if (win && win.open) win.moveTo(0, 0);

  由于&&是一个短操作符号,如果第一个参数(win)对应于true,那么结果就取决于第二个数值。如果第二个参数是false,那么整个表达式结果就是false。这是一个很重要的行为,因为如果win不存在,那么表达式win.open就会产生一个错误。

closed 属性

  由于JavaScript的第一个版本,浏览器窗口成为一个非常困难的问题。比如,一个window对象的一些方法,例如close(),即使当窗口已经关闭时也能被执行,同时另外一些却不能(比如moveTo())。但是情况会更糟。Internet Explorer和Navigator经常有不同的行为。而且,预测一定操作的结果经常是非常困难的,即使你以前已经做过类似的尝试。我们将告诉你如何克服这些困难,方法就是介绍一个在交叉浏览器中能应用的语句,它将检查一个给定的窗口是否被打开。

  window.closed属性是一个Boolean型数值,它定义了是否窗口已经被关闭。当窗口被关闭时,window对象依然存在,并且它的closed属性已经被设置为true。

  使用closed来判断打开的窗口以及仍能够被引用(从window.open方法返回的数值)的窗口是否仍然打开着。当窗口关闭时,你不应该试图再操纵它。因为window.closed仅仅被Internet Explorer 4、Navigator 3 和高版本所支持,所以你应该注意前面的版本问题。我们将使用下面的代码:

  // if win and win.open exist, and win.closed isn't true, move the window

  if (win && win.open && !win.closed) win.moveTo(0, 0);

  Internet Explorer 3 和 Navigator 2 不支持 closed 方法,所以它在Boolean型表达式中等价于false (就像其他不存在地属性一样,比如 window.tomershiran)。

 

JavaScript窗口功能指南之关闭窗口

2001年1月21日11:10:59 赛迪网 听风编译

  当你创建了一个新窗口时,将open()方法的返回值分配给一个变量非常重要。比如,下面的语句就是创建一个新窗口,然后立即关闭它:

  win = window.open("http://www.docjs.com/", "js");

  win.close();

  每一个浏览器窗口都清楚地与一个window对象对应,所以,当你想引用当前窗口时,你应该使用window对象。下面的语句设置当前窗口的URL:

  window.location.href = "http://www.docjs.com/";

  当你在脚本程序中放置这样一个语句时,你不需要指定window对象,因为当前窗口的存在是默认的:

  location.href = "http://www.docjs.com/";

  注意,self等价于window,所以,self.close()实际上就等于window.close()。

  window.location.href = "http://www.docjs.com/";

关闭窗口

  window.close()关闭指定的浏览器窗口。如果不带窗口引用调用close()函数,JavaScript就关闭当前窗口。在事件处理程序中,你必须指定window.close(),而不能仅仅使用close()。由于JavaScript总静态对象的作用范围,不带对象名字的close()调用等价于document.close()。

  如果你执行close()方法去关闭一个不是由脚本程序打开的窗口,就会出现一个确认对话框让用户选择是否关闭窗口。如果在历史列表中只有当前一个记录,那么在Navigator中就不会出现对话框。然而,如果你使用close()退出最后运行的浏览器实例,确认对话框就会出现。看看下面在2类浏览器中出现的对话框样子:

 

 

  点击下面的链接打开一个新窗口,其中内容是tryclose.html:

  Launch Window (with JavaScript)

  Launch Window (with HTML)

  第1个链接使用JavaScript的window.open()方法来打开一个窗口,第2个链接简单地使用TARGET属性实现同样目的:

  <A HREF="javascript:void(window.open('tryclose.html'))">Launch Window (with JavaScript)</A><BR>

  <A HREF="tryclose.html" TARGET="_blank">Launch Window (with HTML)</A>

  页面tryclose.html显示一个按钮,它负责执行window.close()方法:

  <FORM><INPUT TYPE="button" VALUE="Close Window" onClick="window.close()"></FORM>

  当你点击第1个链接打开新窗口后,浏览器就“记住”了它是由一个脚本程序生成的。所以,当你点击按钮时,新窗口不用再确认操作就被关闭。第2个链接是另外一回事了,它不使用任何JavaScript打开一个新窗口,当你点击按钮时,Internet Explorer将显示一个确认对话框。然而,Navigator立即关闭这个窗口,因为,新窗口在会话历史中没有任何文档。

  JavaScript允许你在其他的窗口使用一段脚本程序关闭另外一个窗口。

点击后关闭的窗口

  许多标准的应用程序都有一个About对话框,当用户在其中任何地方点击一次鼠标时,窗口就被关闭。下面就对窗口使用JavaScript来实现同样的效果。首先,请看看打开新窗口的代码:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function launchAbout() {

   about = window.open("about.html", "about", "height=75,width=250");

   return false;

  }

  // -->

  </SCRIPT>

  <A HREF="about.html" onClick="return launchAbout()">About</A>

  点击链接后,生成一个新窗口。然后,你可以在其中点击任何地方,就关闭那个窗口。在文件about.html的HEAD区域,添加下面的脚本程序:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function closeWin() {

   window.close();

  }

  if (window.Event) document.captureEvents(Event.ONCLICK);

  document.onclick = closeWin;

  // -->

  </SCRIPT>

依赖性窗口

  窗口的依赖性特征定义了是否窗口应该是一个当前窗口的依赖性子窗口。依赖窗口就是当它的父窗口关闭时,它也随即关闭。dependent特征仅仅在Navigator 4和以上版本被支持。然而,我们可以使用一小段JavaScript程序来处理交叉浏览器。让我们使用下面的函数来打开一个依赖性窗口:

  function openDep() {

   win = window.open("depwin.html", "dep", "height=200,width=400");

  }

  如果当前窗口关闭时,或者调入一个新的URL时,我们将使用onUnload事件处理程序来关闭依赖性窗口:

  <BODY onUnload="closeDep()">

  注意,当前文档被卸载时,新窗口将关闭,即使当前窗口仍然打开。下面是closeDep()函数的代码:

  function closeDep() {

   if (win && win.open && !win.closed) win.close();

  }

  注意,在试图关闭前,我们必须检查窗口是否存在。

JavaScript窗口功能指南之操纵窗口

2001年1月21日11:10:57 赛迪网 听风编译

  一旦你得到了表示窗口的变量,你就能通过各种方法来操纵它。在前面的介绍中,我们讨论过close()方法:

  win = window.open("http://www.docjs.com/", "js");

  win.close();

  JavaScript提供了许多方法与属性,我们可以使用它们来控制窗口。

  移动、滚动、改变大小

  下面的方法(N4+,IE4+)负责个定窗口的移动、滚动以及大小改变操作:

  // 移动窗口的屏幕位置到指定的偏移x 、y(绝对移动)

  window.moveTo(iX, iY)

  // 移动窗口的屏幕位置到指定的偏移x 、y(相对移动)

  window.moveBy(iX, iY)

  // 滚动窗口的屏幕位置到指定的偏移x 、y(绝对滚动)

  window.scrollTo(iX, iY)

  // 滚动窗口的屏幕位置到指定的偏移x 、y(相对滚动)

  window.scrollBy(iX, iY)

  // 改变窗口大小到指定的高度与宽度(绝对改变大小)

  window.resizeTo(iWidth, iHeight)

  // 改变窗口大小到指定的高度与宽度(相对改变大小)

  window.resizeBy(iX, iY)

  注意,这些方法都属于window对象,所以它们智能在当前窗口或者其他可以引用的窗口被执行。如果你想动态设置窗口的位置和尺寸,就可以在窗口创建后使用move和resize方法。

  注意,控制一个包含其他服务器页面的窗口是不可能的。

最大化窗口

  我们现在来介绍如何制作一个点击后可最大化窗口的按钮。

  下面看看有关这个按钮的HTML和JavaScript代码:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function maximizeWin() {

   if (window.screen) {

    var aw = screen.availWidth;

    var ah = screen.availHeight;

    window.moveTo(0, 0);

    window.resizeTo(aw, ah);

   }

  }

  // -->

  </SCRIPT>

  <FORM><INPUT TYPE="button" VALUE="Maximize" onClick="maximizeWin()"></FORM>

  注意,resizeTo()方法引用整个窗口的尺寸。

一个悬浮的广告

  在网站上,通过移动广告窗口,能够吸引浏览者的注意力。我们可以通过调用下面的函数来实现让窗口左右移动的效果:

  function makeAd() {

   window.open("adpage.html", "ad", "width=468,innerWidth=468,height=80,innerHeight=80,left=0,top=0");

  }

  下面是页面adpage.html的代码:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function startAd() {

   if (window.screen) {

    pos = 0;

    aw = screen.availWidth;

    window.moveTo(pos, 0);

    timerID = setInterval("moveAd()", 50);

   }

  }

  function moveAd() {

   if (pos <= 0) inc = 5;

   // 5 - so it doesn't pass the right edge

   // 10 - accounts for the window chrome

   if (pos + 468 + 10 + 5 > aw) inc = -5;

   pos += inc;

   window.moveTo(pos, 0);

  }

  window.onload = startAd;

  // -->

  </SCRIPT>

  当页面adpage.html装载后,函数startAD()被执行。如果用户的浏览器支持window.screen对象,窗口才能移动,因为我们需要使用window.screen来计算屏幕的宽度。窗口在屏幕的上边界滑动,从左上角(pos=0)一直到右上角。

  通过内建的setInterval()函数,每隔50毫秒移动广告窗口5个象素。如果点击了“stop”按钮,就将执行下面的语句:

  clearInterval(timerID);

震动的窗口

  如你所见,move方法能帮助你吸引用户的注意力。如果你想让访问者更加震撼,你也许想加入下面的效果:

  <SCRIPT LANGUAGE="JavaScript1.2">

  <!--

  var quakeID = 0;

  var totalX = 0;

  var totalY = 0;

  // max pixels in each movement

  var maxShift = 10;

  // min movements in each quake

  var minJumps = 10;

  // max movements in each quake

  var maxJumps = 40;

  // min milliseconds between two quakes

  var minBetweenQuakes = 1000;

  // max milliseconds between two quakes

  var maxBetweenQuakes = 4000;

  function jump() { // -maxShift to maxShift

   with (Math)

    return (maxShift + 1 - ceil(random() * (maxShift * 2 + 1)));

  }

  function winShake() {

   for (var i = 0; i < (minJumps + (Math.random() * (maxJumps - minJumps))); i++) {

    dX = jump();

    dY = jump();

    window.moveBy(dX, dY);

    totalX -= dX;

    totalY -= dY;

   }

   window.moveBy(totalX, totalY);

   totalX = 0;

   totalY = 0;

   quakeID = setTimeout("winShake()", Math.ceil(Math.random() *

    (maxBetweenQuakes - minBetweenQuakes)) + minBetweenQuakes);

  }

  window.onload = winShake;

  //-->

  </SCRIPT>

  这段脚本程序产生一系列的地震效果。当页面被转载时(window.onload),就开始产生效果。

  jump()方法返回一个随机整数,范围从-maxShift到maxShift。下面的代码段负责一个单一震动:

  for (var i = 0; i < (minJumps + (Math.random() * (maxJumps - minJumps))); i++) {

   dX = jump();

   dY = jump();

   window.moveBy(dX, dY);

   totalX -= dX;

   totalY -= dY;

  }

  由于我们没有办法得知窗口的初始位置,我们就必须跟踪每一次位置调整后的尺寸。totalX和totalY变量中保持了窗口相对于初始位置的数值。当震动效果完毕后,窗口移动回到初始位置。

  window.moveBy(totalX, totalY);

  totalX = 0;

  totalY = 0;

  在一个任意位置暂停后,winShake()函数再次被调用:

  quakeID = setTimeout("winShake()", Math.ceil(Math.random() *

   (maxBetweenQuakes - minBetweenQuakes)) + minBetweenQuakes);

JavaScript窗口功能指南之在窗口中书写内容

2001年1月21日11:10:54 赛迪网 听风编译

  window.open()方法打开一个新窗口,document.open()方法打开一个新文档,在其中可以使用write()或者writeln()方法书写内容,它的语法是:

  oNewDoc = document.open(sMimeType[, sReplace]);

  sMineType是一个字符串,它定义了MIME类型。Navigator支持几种不同的MIME类型,但是Internet Explorer当前仅仅支持“text/html”。sMineType参数是可选的。第2个参数也是一个字符串,它定义了被书写的新文档是否要替换当前文档在历史记录中的位置。如果想达到替换目的,就使用字符串“replace”。

  “replace”基本上使用于拥有空文档或者 “about:blank”URL的窗口。定义了“replace”后,write()方法就可以在这个窗口中创建HTML内容,并且替换当前URL在历史记录中的位置。如果没有定义“replace”,建立的HTML就有它自己的历史位置,用户可以点击后退按钮向前直到空为止。

  看看下面的脚本程序段:

  var oNewDoc = document.open("text/html", "replace");

  var sMarkup = "<HTML><HEAD><TITLE>New Document</TITLE></HEAD>";

  sMarkup += "<BODY>Hello, world!<BR><A HREF='write.html'>Return</A></BODY></HTML>";

  oNewDoc.write(sMarkup);

  oNewDoc.close();

  如你所见,我们在新文档中包含了一个链接,所以你就可以返回这个页面。如果你点击了浏览器的后退按钮,浏览器就返回到这个页面之前的页面。因为我们使用了“replace”参数,新文档(被书写的文档)替换了当前文档在历史记录中的位置,所以点击后退按钮不会返回到当前页面(包含脚本程序的页面)。下面的按钮执行同样的脚本程序,但是没有 “replace”参数,所以,你可以通过点击浏览器的后退按钮返回到这个页面。

  以下是这个按钮的源代码:

  <script language=JavaScript>

  <!--

  function writeDocBack() {

   var oNewDoc = document.open("text/html");

   var sMarkup = "<HTML><HEAD><TITLE>New Document</TITLE></HEAD>";

   sMarkup += "<BODY>Hello, world!</BODY></HTML>";

   oNewDoc.write(sMarkup);

   oNewDoc.close();

  }

  // -->

  </script>

  <form><input onClick=writeDocBack() type=button value="Write Document" name="button2"></form>

  正如你在上面2个例子中看到的,最后一个语句关闭了输出流:

  oNewDoc.close();

  通常,document.close()方法关闭输出流,并且强迫发送的数据显示出去。

在新窗口中书写内容

  看看下面的脚本程序:

  var win = window.open("", "win", "width=300,height=200"); // a window object

  win.document.open("text/html", "replace");

  win.document.write("<HTML><HEAD><TITLE>New Document</TITLE></HEAD>

   <BODY>Hello, world!</BODY></HTML>");

  win.document.close();

  第1个语句打开一个新窗口,它使用了一个空文档参数(“”),返回值分配给变量win。然后,我们使用新窗口的文档对象win.document,在其中书写一些HTML。定义“replace”是非常必要的,因为我们不想让一个空白页面在历史记录中占有一项。

  因为我们处理同样的document对象,也许也要分配给它另外一个变量:

  var win = window.open("", "win", "width=300,height=200"); // a window object

  var doc = win.document;

  doc.open("text/html", "replace");

  doc.write("<HTML><HEAD><TITLE>New Document</TITLE></HEAD><BODY>Hello,

   world!</BODY></HTML>");

  doc.close();

  我们也可以使用with语句:

  var win = window.open("", "win", "width=300,height=200"); // a window object

  with (win.document) {

   open("text/html", "replace");

   write("<HTML><HEAD><TITLE>New Document</TITLE></HEAD><BODY>Hello,

     world!</BODY></HTML>");

   close();

  }

 

JavaScript窗口功能指南之引用已打开的窗口

2001年1月21日11:10:51 赛迪网 听风编译

  如果你想关联一个指定的窗口,你可以使用< A >标记的TARGET属性。除非你分配,一个浏览器窗口不会有一个名字。当你使用TARGET属性通过一个链接打开一个新窗口时,你就分配给它了一个清晰的名字:

  <A HREF="http://www.intel.com/" TARGET="review">Intel</A>

  前面的链接打开一个新窗口,名叫review。下面的链接通过JavaScript产生同样的效果:

  <A HREF="http://www.intel.com/"

   onClick="window.open('http://www.intel.com/', 'review'); return false">Intel</A>

  如你所见,给一个新窗口分配一个名字是非常简单的事情。但是,给一个存在的窗口命名,或者给一个用户产生的窗口命名,又会怎样呢?

  window对象的name属性可以让你通过JavaScript设置任何窗口的名字。如果你想建立一个新窗口,它可以关联父窗口的链接和表单,就一定要分配给打开者一个名字:

  window.name = "main";

  var map = window.open("newpage.html", "map");

  如果在newpage.html中包含了下面的链接,就会在父窗口中装载下面的页面:

  <A HREF="http://www.docjs.com/" TARGET="main">Doc JavaScript</A>

打开者的属性

  opener属性设置或者取回创建当前窗口的那个窗口的引用。当调用open()方法在目标窗口打开一个源文档时,opener属性(隶属于目标窗口的window对象)就定义了源文档所在的窗口。这个属性在打开的窗口中一直存在,所以即使新窗口中的URL改变时,它仍旧可以访问。

  opener属性是父窗口window对象的引用,所以你就可以充分利用这个属性,通过脚本程序,在新窗口中执行对打开窗口的任何操作。比如,在目标文档中使用下面的脚本程序去修改打开窗口的背景色彩:

  window.opener.document.bgColor = "beige";

  呵呵,如果你目光敏锐,你也许注意到上面这个语句的错误。我们必须检查是否打开窗口仍然存在,然后才能决定去修改它的相关属性。下面是正确的代码:

  if (window.opener && !window.opener.closed)

   window.opener.document.bgColor = "beige";

  opener属性非常有用,因为它建立了打开窗口与被打开窗口之间的双向联系。

  让我们给出个实际的例子,看看它是如果工作的,下面是出现在主页面上表单的HTML代码:

  <FORM NAME="stockForm">Enter your favorite tech stock:

  <INPUT TYPE="text" NAME="stockBox" SIZE="10" VALUE="">

  <INPUT TYPE="button" VALUE="list" onClick="showList()">

  </FORM>

  注意,表单的名字是stockForm,文本域的名字是stockBox,“list”按钮激活showList()函数。同时,在文档的

  < Body >标记中设置onUnload事件处理程序,它将执行remLink()函数。下面是这2个函数的代码:

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function showList() {

   sList = window.open("stocklist.html", "list", "width=150,height=210");

  }

  function remLink() {

   if (window.sList && window.sList.open && !window.sList.closed)

    window.sList.opener = null;

  }

  // -->

  </SCRIPT>

  当前文档被卸载时,remLink()函数设置子窗口的opener属性为null。新窗口中的脚本程序在分配文本域数值前检查opener属性。我们必须使用这个函数,因为如果一个不同文档在新窗口中被装载,这个窗口的脚本程序就不能访问文本框。

  下面是stocklist.html的代码:

  <HTML>

  <HEAD>

  <TITLE>Stock List</TITLE>

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function pick(symbol) {

   if (window.opener && !window.opener.closed)

    window.opener.document.stockForm.stockBox.value = symbol;

   window.close();

  }

  // -->

  </SCRIPT>

  </HEAD>

  <BODY>

  <TABLE BORDER="1" CELLSPACING="0" CELLPADDING="5">

  <TR BGCOLOR="#cccccc"><TD><B>NYSE</B></TD><TD><B>NASDAQ</B></TD></TR>

  <TR><TD><A HREF="javascript:pick('AOL')">AOL</A></TD>

  <TD><A HREF="javascript:pick('CSCO')">CSCO</A></TD></TR>

  <TR><TD><A HREF="javascript:pick('CPQ')">CPQ</A></TD>

  <TD><A HREF="javascript:pick('INTC')">INTC</A></TD></TR>

  <TR><TD><A HREF="javascript:pick('NOK')">NOK</A></TD>

  <TD><A HREF="javascript:pick('SUNW')">SUNW</A></TD></TR>

  <TR><TD><A HREF="javascript:pick('LU')">LU</A></TD>

  <TD><A HREF="javascript:pick('AMZN')">AMZN</A></TD></TR>

  <TR><TD><A HREF="javascript:pick('T')">T</A></TD>

  <TD><A HREF="javascript:pick('MSFT')">MSFT</A></TD></TR>

  </TABLE>

  </BODY>

  </HTML>

 

JavaScript窗口功能指南之创建对话框

2001年1月21日11:10:47 赛迪网 听风编译

  JavaScript支持几种内建的对话框: window.alert()、window.confirm()以及window.prompt()。当弹出一个对话框时,用户就不可以再聚焦到初始页面,除非对话框操作结束。换言之,对话框永远是被聚焦的。Internet Explorer支持一些方法,使用它们能让你在任何新窗口上应用它们:

  showModalDialog() (Internet Explorer 4 和以上版本)

  showModelessDialog() (Internet Explorer 5 和以上版本)

  以下是这些方法的语法:

  vReturnValue = window.showModalDialog(sURL[, vArguments][, sFeatures]);

  vReturnValue = window.showModelessDialog(sURL[, vArguments][, sFeatures]);

  第1个参数是一个字符串,它指定了在新窗口中装载并显示的文档URL。第2个参数,vArguments,是一个variant,它指定了显示文档的命令。使用这个参数时,可以传递任意类型的数组或者数值。对话框能够从window对象的dialogArguments属性中将数值传递给调用者。

  当通过其中一个方法打开一个新窗口时,新窗口(对话框)的window对象特写了dialogArguments属性,它包含了分配给调用方法的vArguments参数的数值。来看看下面的语句:

  window.showModalDialog("modalurl.html", window);

  注意,第2个命令参数实际上是当前浏览器窗口的window对象。下面是文件modalurl.html的代码:

  <HTML>

  <HEAD>

  <TITLE>Change the URL</TITLE>

  <SCRIPT LANGUAGE="JavaScript">

  <!--

  function load(menu) {

   if (window.dialogArguments && dialogArguments.location) {

    dialogArguments.location.href = menu.options[menu.selectedIndex].value;

    window.close();

   }

  }

  // -->

  </SCRIPT>

  </HEAD>

  <BODY>

  Pick your favorite investment site:<P>

  <FORM><SELECT NAME="menu">

  <OPTION VALUE="http://www.fool.com/">Fool.com (The Motley Fool)

  <OPTION VALUE="http://www.investor.com/">MoneyCentral Investor

  <OPTION VALUE="http://www.thestreet.com/">TheStreet.com

  </SELECT>

  <INPUT TYPE="button" VALUE="Load" onClick="load(this.form.menu)"></FORM>

  </BODY>

  </HTML>

  当用户在对话框中点击“Load”按钮,打开者窗口的URL就变为选择的数值。为了数值窗口文档的URL,我们必须分配一个数值给需要window对象的location.href属性。在这里,我们指定调用者的window对象做为showModalDialog()方法的第2个参数,所以,新窗口(对话框)中dialogArguments属性就对应于调用者的window对象。

  注意函数开始的对象检测程序段。因为 dialogArguments属性只存在于由showModalDialog()和showModelessDialog()方法创建的窗口中,所以,我们必须确认在使用它们前这个属性是否存在。而且,我们需要查找一个location.href属性来确认dialogArguments属性真正地对应于一个合法的window对象。

  load()函数的最后语句关闭对话框,从而指定的文档能够在原始窗口被装载。注意,如果我们使用showModelessDialog()方法替代showModalDialog()方法,我们就不需要特别地关闭窗口,因为,即使对话框仍然打开时,新的URL依然会在下面的窗口(打开者)被装载。在这里,当调用者的URL改变时(调用新页面),对话框自动关闭。  当在Internet Explorer 5中执行showModelessDialog()时,出现一个对话框,它位于浏览器窗口前面。用户仍旧可以操纵下面的窗口,但是对话框会始终在上面。对话框与打开它的浏览器窗口相关联,所以,如果用户产生了一个不同的窗口,对话框与它的产生者一同被隐藏在后面。注意,一个modeless对话框实际上连接到一个包含产生它的脚本的文档,所以,如果用户在打开者窗口中装载另一个不同的URL,对话框将自动关闭。

  Internet Explorer 4 中的showModalDialog()方法就完全不同。它建立一个modal对话框,并一直保持焦点直到被关闭。用户根本不能访问到打开者窗口。一个 modal对话框与打开它的浏览器窗口相关联,所以,如果用户产生一个不同的浏览器窗口,对话框就与它的原始窗口一起被隐藏在活动窗口的下面。

  现在是回来讨论showModalDialog()和showModelessDialog()方法的参数的时候了。第3个参数,sFeatures,是一个字符串,它指定了对话框窗口的修饰特征,具体就是使用下面的一个或者多个以逗号分隔的数值:

  dialogHeight: iHeight

  设置对话框窗口的高度。尽管用户能够手工地调整一个对话框的高度为一个较小数值(要求产生的对话框是大小可变的),但是你可以指定的最小dialogHeight是100象素(pixels)。注意,在Internet Explorer 4.0中dialogHeight和dialogWidth的默认测量单位“em”,而在Internet Explorer 5中则是px(象素)。为了保持一致性,当设计modal对话框时,请以象素为单位指定dialogHeight和dialogWidth。

  dialogWidth: iWidth

  设置对话框窗口的宽度。

  dialogLeft: iXPos

  设置对话框窗口相对于桌面左上角的left位置。

  dialogTop: iYPos

  设置对话框窗口相对于桌面左上角的top位置。

  center: {yes | no | 1 | 0 }

  指定是否将对话框在桌面上居中,默认值是“yes”。为了避免居中,你可以设定为dialogLeft或者dialogTop。

  help: {yes | no | 1 | 0 }

  指定对话框窗口中是否显示上下文敏感的帮助图标。默认值是“yes”。

  resizable: {yes | no | 1 | 0 } (Internet Explorer 5 and above)

  指定是否对话框窗口大小可变。默认值是“no”。

  status: {yes | no | 1 | 0 } (Internet Explorer 5 和以上版本)

  指定对话框窗口是否显示状态栏。对于非依赖对话框窗口,默认值是“yes”;对于依赖对话框窗口,默认值是 “no”。

对象检测

  showModalDialog() 和 showModelessDialog() 方法并非被所有支持JavaScript的浏览器所支持。在调用任何一个方法之前,我们必须确认它们的有效性:

  if (window.showModalDialog) {

   ...

  }

  if (window.showModelessDialog) {

   ...

  }

  如果用户的浏览器不能支持需要的方法,你也许希望考虑一个可供选择的行为,这可以通过调用window.open()方法来实现:

  if (window.showModalDialog) {

   win = window.showModalDialog("mydialog.html", ...);

  } else {

   win = window.open("mydialog.html", ...);

  }

一个交叉浏览器Modal对话框

  看看下面的定义 (Navigator适用):

  <BODY onBlur="window.focus()">

  如果你在< body >标记中使用上面的事件处理程序,那么包含文档的窗口就会被聚焦,直到用户关闭它。在这个仅Navigator适用的技术与Internet Explorer的showModalDialog()方法之间,有些区别。被聚焦的窗口没有与指定的窗口或者文档相关联。就是说,用户不能调上来其它浏览器窗口,即使不是打开对话框的窗口。

JavaScript窗口功能指南之创建弹出窗口

2001年1月21日11:10:45 赛迪网 听风编译

  Internet Explorer 5.5支持一个新的window对象的方法:creatPopup()。你可以向下面一样创建一个弹出窗口:

  var popupObj = window.createPopup();

  当你创建了这个对象后,弹出窗口并不显示。你必须要调用它的show方法:

  popupObj.show(yOffset, xOffset, width, height, referenceObj)

  在这里:

  yOffset 是弹出窗口距离屏幕左上角的水平偏移。

  xOffset 是弹出窗口距离屏幕左上角的垂直偏移。

  width 是弹出窗口的宽度。

  height 是弹出窗口的高度。

  referenceObj 是一个可选参数,它替代屏幕左上角做为引用yOffset 和 xOffset 的参照。

  让我们示范一下新的弹出窗口的用处。如果你点击下面的链接,一个所有这个教程的菜单就会弹出来。注意,当菜单弹出时,页面就滚动回到它的顶部。我们怎么样执行这个弹出窗口呢?首先,你需要定义一个可见菜单,它随后会被转载进弹出菜单。为了实现隐藏链接,可以将菜单放置到一个隐藏的位置。我们选择位置(-1000,-1000),并在菜单的style标记中定义它(在HEAD段的某个地方):

  <STYLE>

   .menu {position: absolute; top: -1000; left: -1000}

  </STYLE>

  我们执行菜单做为表格的链接:

  <TABLE CLASS=menuID=submenu>

   <TR><TD NOWRAP>

    <A HREF="names.html" TARGET="CONTENT">How to name your windows and frames</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="open.html">How to open a new window</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="features.html">How to specify the features of a new window</A>

   </TD></TR>

    <TR><TD NOWRAP>

    <A HREF="utilize.html">How to utilize the window features</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="exist.html">How to check if a window exists</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="reference.html">How to close a window</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="manipulate.html">How to manipulate a window</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="write.html">How to write content to a window</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="opener.html">How to reference the opener</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="dialog.html">How to create a dialog box</A>

   </TD></TR>

   <TR><TD NOWRAP>

    <A HREF="popup.html">How to create a pop-up window</A>

   </TD></TR>

   <TR><TD></TD></TR>

  </TABLE>

  链接本身(教程的页面)不会改变URL,但是当被点击时,就调用showMenu()函数:

  <A HREF='#' ONCLICK='showMenu(this, submenu)'>Tutorial's Pages</A>

  showMenu()函数有2个参数,一个是链接对象,它调用函数,另一个是菜单的ID。我们要采取的第一个行为是分配弹出窗口的body对象:

  var popupBodyObj = popupObj.document.body;

  然后,设置边界为1象素,紫色,固体样式:

  popupBodyObj.style.border = "1px purple solid";

  填充弹出窗口的内容绝不是一个琐碎的工作,实现的一个方法就是使用innerHTML和outerHTML:

  popupBodyObj.innerHTML = menuID.outerHTML;

  接着,我们需要对页面的所有链接指派onClick事件处理程序,定义这个事件的响应函数为doclick。

  for (var i = 0; i < popupBodyObj.all.length; i++) {

   if (popupBodyObj.all[i].tagName == "A")

         popupBodyObj.all[i].onclick = doClick;

  }

  下面是showMenu()函数的全部代码:

  function showMenu(linkObj, menuID) {

   var popupObj = window.createPopup();

   var popupBodyObj = popupObj.document.body;

   popupBodyObj.style.border = "1px purple solid";

   popupBodyObj.innerHTML = menuID.outerHTML;

   for (var i = 0; i < popupBodyObj.all.length; i++) {

    if (popupBodyObj.all[i].tagName == "A")

     popupBodyObj.all[i].onclick = doClick;

   }

   popupObj.show(0, linkObj.offsetHeight, menuID.offsetWidth, menuID.offsetHeight, linkObj);

  }

  函数的最后一条语句是显示弹出窗口。我们将弹出窗口放置于调用它的链接linkObj旁边。如果你省略了这个引用,弹出窗口将参照屏幕左上角被放置。水平偏移是0。为了避免窗口弹出时链接被隐藏,我们要设置对于链接高度的垂直偏移,linkObj.offsetHeight。很自然,我们设置窗口的宽度和高度为初始菜单的宽度 (menuID.offsetWidth)和高度(menuID.offsetHeight)。

  函数doClick()是一个2行代码的程序,它修改当前窗口的URL(parent.href)为点击链接的URL(this):

  function doClick() {

   parent.location = this.href;

   return false;

  }

总结

  在这个教程中,我们试图覆盖JavaScript有关窗口相关特征的大多数内容。我们给你展示了如何根据你的要求打开一个新窗口,怎样在窗口中写内容,操纵它,关闭它。同时,我们介绍了如何引用打开窗口的父窗口。最后,我们接触到2个特殊类型的窗口:对话框和弹出窗口。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页