不敢流泪 » DHTML

[临时]测试codeHilight

Sandy — Wed, 05 Aug 2009 17:11:29 +0000

测试代码喽：

codeHilighter by sandy_zc_1 。
应boluor要求拿来替换掉该死的奇慢无比臃肿不堪的syntaxhighlighter。

JS代码：

C++代码：

// Vector implementation (out of line) -*- C++ -*-

// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place – Suite 330, Boston, MA 02111-1307,
// USA.

// As a special exception, you may use this file as part of a free software
// library without restriction. Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License. This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.

/*
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
*
* Copyright (c) 1996
* Silicon Graphics Computer Systems, Inc.
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Silicon Graphics makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*/

/** @file vector.tcc
* This is an internal header file, included by other library headers.
* You should not attempt to use it directly.
*/

#ifndef _VECTOR_TCC
#define _VECTOR_TCC 1

namespace _GLIBCXX_STD
{
  template
   void
   vector<_Tp,_Alloc>::
   reserve(size_type __n)
   {
   if (__n > this->max_size())
    __throw_length_error(__N("vector::reserve"));
   if (this->capacity() < __n)
    {
    const size_type __old_size = size();
    pointer __tmp = _M_allocate_and_copy(__n,
                    this->_M_impl._M_start,
                    this->_M_impl._M_finish);
    std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
    _M_deallocate(this->_M_impl._M_start,
            this->_M_impl._M_end_of_storage – this->_M_impl._M_start);
    this->_M_impl._M_start = __tmp;
    this->_M_impl._M_finish = __tmp + __old_size;
    this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
    }
   }

  template
   typename vector<_Tp,_Alloc>::iterator
   vector<_Tp,_Alloc>::
   insert(iterator __position, const value_type& __x)
   {
   size_type __n = __position – begin();
   if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage && __position == end())
   {
   std::_Construct(this->_M_impl._M_finish, __x);
   ++this->_M_impl._M_finish;
   }
   else
   _M_insert_aux(__position, __x);
   return begin() + __n;
   }

  template
   typename vector<_Tp,_Alloc>::iterator
   vector<_Tp,_Alloc>::
   erase(iterator __position)
   {
   if (__position + 1 != end())
   std::copy(__position + 1, end(), __position);
   –this->_M_impl._M_finish;
   std::_Destroy(this->_M_impl._M_finish);
   return __position;
   }

  template
   typename vector<_Tp,_Alloc>::iterator
   vector<_Tp,_Alloc>::
   erase(iterator __first, iterator __last)
   {
   iterator __i(copy(__last, end(), __first));
   std::_Destroy(__i, end());
   this->_M_impl._M_finish = this->_M_impl._M_finish – (__last – __first);
   return __first;
   }

  template
   vector<_Tp,_Alloc>&
   vector<_Tp,_Alloc>::
   operator=(const vector<_Tp,_Alloc>& __x)
   {
   if (&__x != this)
   {
   const size_type __xlen = __x.size();
   if (__xlen > capacity())
   {
   pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), __x.end());
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
   _M_deallocate(this->_M_impl._M_start,
            this->_M_impl._M_end_of_storage – this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
   }
   else if (size() >= __xlen)
   {
   iterator __i(copy(__x.begin(), __x.end(), begin()));
   std::_Destroy(__i, end());
   }
   else
   {
   std::copy(__x.begin(), __x.begin() + size(), this->_M_impl._M_start);
   std::uninitialized_copy(__x.begin() + size(), __x.end(), this->_M_impl._M_finish);
   }
   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
   }
   return *this;
   }

  template
   void
   vector<_Tp,_Alloc>::
   _M_fill_assign(size_t __n, const value_type& __val)
   {
   if (__n > capacity())
   {
   vector __tmp(__n, __val, get_allocator());
   __tmp.swap(*this);
   }
   else if (__n > size())
   {
   std::fill(begin(), end(), __val);
   this->_M_impl._M_finish
    = std::uninitialized_fill_n(this->_M_impl._M_finish, __n – size(), __val);
   }
   else
   erase(fill_n(begin(), __n, __val), end());
   }

  template template
   void
   vector<_Tp,_Alloc>::
   _M_assign_aux(_InputIterator __first, _InputIterator __last, input_iterator_tag)
   {
   iterator __cur(begin());
   for ( ; __first != __last && __cur != end(); ++__cur, ++__first)
   *__cur = *__first;
   if (__first == __last)
   erase(__cur, end());
   else
   insert(end(), __first, __last);
   }

  template template
   void
   vector<_Tp,_Alloc>::
   _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
   forward_iterator_tag)
   {
   size_type __len = std::distance(__first, __last);

   if (__len > capacity())
   {
   pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
   _M_deallocate(this->_M_impl._M_start,
        this->_M_impl._M_end_of_storage – this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_finish = this->_M_impl._M_start + __len;
   }
   else if (size() >= __len)
   {
   iterator __new_finish(copy(__first, __last, this->_M_impl._M_start));
   std::_Destroy(__new_finish, end());
   this->_M_impl._M_finish = __new_finish.base();
   }
   else
   {
   _ForwardIterator __mid = __first;
   std::advance(__mid, size());
   std::copy(__first, __mid, this->_M_impl._M_start);
   this->_M_impl._M_finish = std::uninitialized_copy(__mid, __last, this->_M_impl._M_finish);
   }
   }

  template
   void
   vector<_Tp,_Alloc>::
   _M_insert_aux(iterator __position, const _Tp& __x)
   {
   if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
   std::_Construct(this->_M_impl._M_finish, *(this->_M_impl._M_finish – 1));
   ++this->_M_impl._M_finish;
   _Tp __x_copy = __x;
   std::copy_backward(__position,
            iterator(this->_M_impl._M_finish-2),
            iterator(this->_M_impl._M_finish-1));
   *__position = __x_copy;
   }
   else
   {
   const size_type __old_size = size();
   const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
   iterator __new_start(this->_M_allocate(__len));
   iterator __new_finish(__new_start);
   try
   {
   __new_finish = std::uninitialized_copy(iterator(this->_M_impl._M_start),
                        __position,
                        __new_start);
   std::_Construct(__new_finish.base(), __x);
   ++__new_finish;
   __new_finish = std::uninitialized_copy(__position,
                        iterator(this->_M_impl._M_finish),
                        __new_finish);
   }
   catch(…)
   {
   std::_Destroy(__new_start,__new_finish);
   _M_deallocate(__new_start.base(),__len);
   __throw_exception_again;
   }
   std::_Destroy(begin(), end());
   _M_deallocate(this->_M_impl._M_start,
        this->_M_impl._M_end_of_storage – this->_M_impl._M_start);
   this->_M_impl._M_start = __new_start.base();
   this->_M_impl._M_finish = __new_finish.base();
   this->_M_impl._M_end_of_storage = __new_start.base() + __len;
   }
   }

  template
   void
   vector<_Tp,_Alloc>::
   _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
   {
   if (__n != 0)
   {
   if (size_type(this->_M_impl._M_end_of_storage – this->_M_impl._M_finish) >= __n)
    {
   value_type __x_copy = __x;
    const size_type __elems_after = end() – __position;
    iterator __old_finish(this->_M_impl._M_finish);
    if (__elems_after > __n)
    {
    std::uninitialized_copy(this->_M_impl._M_finish – __n,
                this->_M_impl._M_finish,
                this->_M_impl._M_finish);
    this->_M_impl._M_finish += __n;
    std::copy_backward(__position, __old_finish – __n, __old_finish);
    std::fill(__position, __position + __n, __x_copy);
    }
    else
    {
    std::uninitialized_fill_n(this->_M_impl._M_finish,
                    __n – __elems_after,
                    __x_copy);
    this->_M_impl._M_finish += __n – __elems_after;
    std::uninitialized_copy(__position, __old_finish, this->_M_impl._M_finish);
    this->_M_impl._M_finish += __elems_after;
    std::fill(__position, __old_finish, __x_copy);
    }
    }
   else
    {
    const size_type __old_size = size();
    const size_type __len = __old_size + std::max(__old_size, __n);
    iterator __new_start(this->_M_allocate(__len));
    iterator __new_finish(__new_start);
    try
    {
        __new_finish = std::uninitialized_copy(begin(), __position,
                        __new_start);
        __new_finish = std::uninitialized_fill_n(__new_finish, __n, __x);
        __new_finish = std::uninitialized_copy(__position, end(),
                        __new_finish);
    }
    catch(…)
    {
        std::_Destroy(__new_start,__new_finish);
        _M_deallocate(__new_start.base(),__len);
        __throw_exception_again;
    }
    std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
    _M_deallocate(this->_M_impl._M_start,
            this->_M_impl._M_end_of_storage – this->_M_impl._M_start);
    this->_M_impl._M_start = __new_start.base();
    this->_M_impl._M_finish = __new_finish.base();
    this->_M_impl._M_end_of_storage = __new_start.base() + __len;
    }
   }
   }

  template template
   void
   vector<_Tp,_Alloc>::
   _M_range_insert(iterator __pos,
   _InputIterator __first, _InputIterator __last,
   input_iterator_tag)
   {
   for ( ; __first != __last; ++__first)
   {
   __pos = insert(__pos, *__first);
   ++__pos;
   }
   }

  template template
   void
   vector<_Tp,_Alloc>::
   _M_range_insert(iterator __position,_ForwardIterator __first,
        _ForwardIterator __last, forward_iterator_tag)
   {
   if (__first != __last)
   {
   size_type __n = std::distance(__first, __last);
   if (size_type(this->_M_impl._M_end_of_storage – this->_M_impl._M_finish) >= __n)
   {
   const size_type __elems_after = end() – __position;
   iterator __old_finish(this->_M_impl._M_finish);
   if (__elems_after > __n)
   {
   std::uninitialized_copy(this->_M_impl._M_finish – __n,
                this->_M_impl._M_finish,
                this->_M_impl._M_finish);
   this->_M_impl._M_finish += __n;
   std::copy_backward(__position, __old_finish – __n, __old_finish);
   std::copy(__first, __last, __position);
   }
   else
   {
   _ForwardIterator __mid = __first;
   std::advance(__mid, __elems_after);
   std::uninitialized_copy(__mid, __last, this->_M_impl._M_finish);
   this->_M_impl._M_finish += __n – __elems_after;
   std::uninitialized_copy(__position, __old_finish, this->_M_impl._M_finish);
   this->_M_impl._M_finish += __elems_after;
   std::copy(__first, __mid, __position);
   }
   }
   else
   {
   const size_type __old_size = size();
   const size_type __len = __old_size + std::max(__old_size, __n);
   iterator __new_start(this->_M_allocate(__len));
   iterator __new_finish(__new_start);
   try
   {
   __new_finish = std::uninitialized_copy(iterator(this->_M_impl._M_start),
                        __position, __new_start);
   __new_finish = std::uninitialized_copy(__first, __last,
                        __new_finish);
   __new_finish = std::uninitialized_copy(__position,
                        iterator(this->_M_impl._M_finish),
                        __new_finish);
   }
   catch(…)
   {
   std::_Destroy(__new_start,__new_finish);
   _M_deallocate(__new_start.base(), __len);
   __throw_exception_again;
   }
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish);
   _M_deallocate(this->_M_impl._M_start,
            this->_M_impl._M_end_of_storage – this->_M_impl._M_start);
   this->_M_impl._M_start = __new_start.base();
   this->_M_impl._M_finish = __new_finish.base();
   this->_M_impl._M_end_of_storage = __new_start.base() + __len;
   }
   }
   }
} // namespace std

#endif /* _VECTOR_TCC */

int a;

↑该死的syntaxhighlighter，还得留个它的小尾巴（因为目前codehilight的css依附于它的css中。。）
(boluor注：现在不需要了，我已经将syntaxhighlighter给禁掉了。在本篇文章中调用了css。)

yeah，看来效果还不错。可惜因为还没做成插件，因此使用麻烦些，boluor先将就一下，之后可以将其做成wp插件。

ok，Sandy收工，boluor，该你上场了～～！

html页面离开时提示

boluor — Mon, 27 Jul 2009 16:10:40 +0000

早上用WEBQQ时，离开页面时它提示说：“你确定要离开吗？”好奇这个怎么做出来的。查了些资料，到现在竟然花了一天的时间。
在IE下实现很简单，因为有个window.event全局变量。在onbeforeunload事件中调用函数，对window.event.returnValue赋值，即可实现。其returnValue有默认值是不可以改变的。

<html>
<head>
<script language="javascript" type="text/javascript">
 
function closePrompt(event1)
{
        window.event.returnValue = "navigation leave test";
}
</script>
</head>
<body onbeforeunload="closePrompt(event)">
<a href="http://www.boluor.com">Click here to navigate to
www.boluor.com</a>
</body>
</html>

但是上述代码在Firefox下却没有出现提示。查了下才知道，firefox并没有window.event这个全局变量。FF在事件触发的时候才会创建event对象。所以上面的closePrompt函数需要修改传参数并且修改为：

function closePrompt(event1)
{
	event1 =event1 || window.event;    //FF下window.event为空，IE下不传参数所以event1为空。
	event1.returnValue = "navigation leave test";
}

这种写法在小程序中没什么，但是如果在一个大程序中，很多事件都需要获得event对象，那这种传来传去的写法就不好了。
然后去搜索webqq页面源代码，竟然没搜到onbeforeunload和onunload关键字。只好一个个的去把js代码下下来，搜索webqq离开时提示的那句话。终于在main.js中找到了，但是这个又调用了util.js，里面有WEBQQ namespace。。。看不下去了。不过搜到了一款很好的js代码格式化工具Javascript Code Improver ，不用像我第一次研究baidu首页代码时一行一行地对齐了。。。

textContent与innerText的不同

Sandy — Sat, 20 Jun 2009 16:20:04 +0000

textContent与innerText的不同

by Sandy_zc_1 :因为发现网络上很少有这方面的内容，因此就把自己私有blog上的这篇文章搬出来到Boluor的公开blog，方便其它人查阅。

————————————————————————————————————————

以下是正文 ↓↓↓

textContent与innerText的不同

IE下有个innerText属性，FF下有个textContent属性。很多以前给IE写脚本的，在FF下找不到innerText属性，于是网上搜到的建议是用textContent来替代。反之给FF写脚本的也一样。

但是实际上，这里有个误解。网上很多文章说“FF下等效于innerText属性的属性是textContent”————但是事实上并非如此。innerText与textContent有几点很重要的不同，导致它们在一些情况下不能直接互换使用。

前些日子写了个代码高亮JS插件，在IE下工作完全正常，而在FF下就不对头。在IE下使用的是innerText属性，而在FF下使用的则是textContent属性。在进行字符串处理的时候二者的不同导致了完全不一样的结果。于是就专门写了点东西来测试二者的不同。

根据测试的结果表明：
innerText：它的内容实际上就是你在浏览器看到的内容。它的值是经过浏览器解释过的结果：它将元素的innerHTML换码、解释，最终显示出来，然后去除各种格式信息留下的纯文本。它会把
换成换行符，会将多个空格并成一个空格对待，而本来的换行符却并不会引起换行，IE会将其当作一个普通的单词边界（一般是空格）。再说的形象点，一个元素的innerText属性的值，和你将这个元素内容复制粘贴到记事本里的内容一致。

textContent：它的内容则是innerHTML去除所有标签后的内容（我怀疑这个是从XMLDOM中照搬过来的属性，特性完全一致）。它会将innerHTML中的转义字符（<、什么的）进行换码，但是不对任何html标签进行解释，而是直接剔除它们。它也不会对innerHTML中的文本按照HTML的方式进行格式转换，比如多个空格还会原原本本地保留，不会合并为一个空格，换行符仍然存在（相反
却不会导致换行）。

更加简练的总结：IE中的innerText是需要对innerHTML的值进行：
1、HTML转义（等同于XML转义，对<、&等转义字符进行处理）；
2、经过HTML解释和CSS样式解释；
3、之后又剔除格式信息
之后留下的纯文本。
而FF中的textContent没有2、3步，在经过了HTML转义之后直接剔除所有html标签后得到的纯文本。

一个例子：

ABCD
EFG HIJ
KLM N
OPQ
RS
T
T

这个id为T1的div，
在IE中的innerText属性的值为：

ABCD EFG HIJ
KLM N OPQ
RS
T T

而在FF中的textContent的属性的值为：

(这里有个换行)
ABCD
EFG HIJKLM N
OPQRST
T

注意那个div中还嵌套了个div，而这个更能反映IE的innerText和FF的textContent各自的处理方式的不同：
div是块（block）元素，默认会独占一行，因此，在IE中的innerText反映为上述div中的RS独占一行，而FF的textContent完全不理会HTML格式，因此其textContent中的RS是和其它字符连在一起的，不会独占一行。

如果想更进一步，看看这个有趣的结果：
假如给里面那个div加一个style=”float:left;”，那么这个div就会由块元素变化为行元素，不再独占一行，因此IE的innerText属性中RS便不再独占一行，而与其它字符连在一起，而在FF中由于textContent不理会标签更不会理会CSS，因此它的textContent属性的值不会有任何变化。

这么看来，很多网上说的“让FF支持innerText属性”云云，其实都是多多少少有问题的。要实现IE的innerText，远没有想象中的那么简单，你若要使用JavaScript让FF拥有和innerText完全一样的效果，得自己把html标签属性全部parse一遍，解释它们，甚至还需要去解释css……
（不过根据原理，貌似通过剪贴板的复制和取回操作可以在FF下模拟innerText效果（这个未测试），但是1有副作用，2FF下的剪贴板操作也很麻烦。）

不过还好，大多数时候我们并不需要那么精确，使用innerHTML做点简单的处理即可达到比较接近的效果了。

注：以上代码均在IE6和FF3下完成测试。