Xizhi's Blog

Moving to new site: http://xzis.me/

2011-05-27T19:57:00.000+03:00

Now I got my new site up and working: http://xzis.me/

Hope the domain is easy to remember ;)
Meaning Xizhi Zhu IS ME.

根据国际法 PK 不要拿法律当挡箭牌

2011-05-20T15:27:00.001+03:00

这个是163上的一个新闻。当姜瑜被问及百度公司和中国政府因为网络消息屏蔽被纽约居民起诉时，义正词严的表示：中国政府鼓励和支持互联网发展，依法保障中国公民言论自由。中国政府依法管理互联网符合国际通行做法，属于主权行为，根据国际法，外国法院没有管辖权。

哦，这个时候提及国际法了啊！难道你老人家忘记前不久的至理名言了吗？“不要拿法律当挡箭牌”啊！

看完内容就得看评论嘛！到目前为止，有850人参与，跟贴218条，却仅仅显示了四条回复。这个嘛，这个，这个，这个......

Create Debian and RPM packages using OBS

2011-04-28T20:44:00.000+03:00

Have you ever tried to create both Debian and RPM packages using OBS? Well, a little bit different from the package generation locally, but not that much ;)

Before continuing, you should prepare yourself with basic Debian and RPM packaging knowledge.

First, make a tar-ball for your source code, without any packaging information inside. Name it obs-sample.tar.gz.

Then for Debian packaging, you need the following files.
obs-sample_1.0.dsc: indicating you want to create a Debian package; the Files section is not needed, but the Build-Depends section is necessary.
debian.rules: the rules file for Debianization.
debian.control: the control file for Debianization.
debian.tar.gz: all the other files inside the debian folder.

For RPM packaging, you only need the .spec file as expected.

Finally, here goes the simple sample I created. Happy hacking!

利比亚的故事

2011-03-21T18:45:00.001+02:00

联合国安理会在3月17日通过1973号决议，对利比亚实施禁飞，并授权采取一切必要措施保护平民和平民居住区免受武装袭击的威胁。

3月18日，利比亚外长穆萨·库萨宣布，利比亚接受联合国安理会有关在利比亚设立禁飞区的决议，立即停火并停止所有军事行动。

3月19日，利比亚政府军进攻反对派大本营班加西，卡扎菲则表示联合国安理会的决议无效（这条新闻在国内媒体的报道几乎都是一笔带过，很少提及）。随后，国际社会开始了对利比亚的军事干预。

此后，卡扎菲表示将打开军火库以武装所有民众，打一场持久战。

3月20日，利比亚武装部队发言人法格希宣布，利比亚政府军于当地时间20日晚9时起执行全面停火，并停止在利比亚境内的一切军事行动。

不放回顾一下早些时候卡扎菲的伟大讲话......
2月24日，卡扎菲在电视讲话中表示基地组织是现在利比亚危机的幕后策划者。

3月8日，卡扎菲表示如果西方设立“禁飞区”逼得太紧，他将与基地组织联手。

末了再来对比一下这几条被国内媒体一笔带过或是干脆不报的新闻......
2月22日，卡扎菲援引六四事件为自己辩护，电视讲话中说，北京的学生在天安门抗议了好几天，中国领导人然后派坦克进入，把学生摧毁、铲除。

2月23日，利比亚飞行员不愿屠杀平民，拒绝执行卡扎菲轰炸班加西的命令而弃机跳伞。

3月21日，英国空军因在攻击区域发现有平民存在而放弃了攻击任务。

收费公路养活了多少人？

2011-01-18T17:00:00.000+02:00

368万天价过路费的事我就不多说了，大家心里都明白。和谐，要和谐啊，莫非要像突尼斯人民一样让总统飞不成？当然了，和谐是和谐，自家的糊涂账是得更忽悠一些的，所以交通运输部副部长翁孟勇就出来澄清了嘛：

我们已经在17个省全部取消了政府还贷的二级公路收费站点，撤销站点1723个，总里程9万公里，这其中解决了40万人过去收费和征稽人员的分流安置工作

算一算，光是这么些个二级公路，每个收费站养活了232个人，每公里更是养活了4.4个人，厉害啊！

我最崇拜的人姓刘

2010-12-11T12:57:00.004+02:00

所有内容摘自互联网，感谢各位网友的原创！持续更新中;)

我最崇拜的人姓刘，他获得过国际大奖，他的所作所为激发了国人的斗志，虽然有一段时间他从我们眼前消失了，但是我相信他的精神永存。他的名字叫刘翔。

我最崇拜的人姓刘，他领导过学生闹学运，出过书，得过外国的奖，后来被冤枉做了很多年牢。但我相信，这些都是历史给他的考验，因为他说过，好在历史是人民写的。他的名字是刘少奇。

我最崇拜的人姓刘。他是个博士，他出过书、当过被告。得过西方很多国家的大奖，以及香港台湾等境外组织颁发的奖。他是很多中国人的偶像，他是中国人的自豪和骄傲。他叫刘德华！

我最崇拜的人姓刘，ta面对暴力无所畏惧，坚定信仰自己的理念。尽管ta早早地被强权迫害，但ta的名字直到今天仍在流传。ta是刘胡兰。

我最崇拜的人姓刘，出过书，获得过国际大奖，用多年的拼搏和追求向世界展示国人的无悔青春，虽然有一段时间住过牢，但是我相信特不会为此而向命运屈服。特的名字是刘晓庆。

我最崇拜的人姓刘，他获得了世界性的奖项，因为他的推手技惊全球以至于不得不说：我没有敌人。有时候面对记者会结结巴巴，他一度消失在人们的视野。整个世界都经常默念他的名字：国家的未来栋梁！他的名字叫刘国梁。

我最崇拜的人姓刘，他十几年如一日，忍辱负重，勤奋耕耘，从一个东北土鳖成长为亿万人瞩目的理性楷模。他致力于一个理想化的行动，让自己备受磨难，但人们心里为他树起了一座丰碑，他的名字叫刘老根儿。

我最崇拜的人他姓刘，他一生传奇，80年代就名扬国际，热衷挑战强拳，获得过无数国际大奖。他的一生没有敌人。他就是拳王刘易斯。

我崇拜的人姓刘，从80年代开始就写出了一系列传世佳作，在一代又一代爱好自由的人手中传颂。尽管关于他的作品有一些争议，但好无偏见的说他的文字影响和改变了很多推友。他就是刘欣慈。

我最崇拜的人姓刘，他获得过很多境外组织的奖杯，他的作品流行海内外，他忠厚的面貌总是让人感到亲切，他也很关心缅甸昂山阿姨的情况，他的名字叫刘青云。

我最崇拜的人姓刘，他以人性化的实践，经历和见证了封建小农经济下个人良心的最大发挥。他清白而廉洁，但却历经诬陷，一个好人被钉在耻辱里，体现了专制政权的强横与无耻。然而，他被人传颂为良知的化身和尊严的维护者。他的名字叫刘文彩。

我不崇拜的人姓刘，他某年因为因为被央视现场报道使用幕后黑手欺骗全国人民而一举闻名。他荣获过那个领域的国际大奖，他的成就可以说在中国没有敌人。网上关于他的争议一直很多，不过丝毫不影响他的影响力。他就魔术师刘谦。

我最崇拜的人姓刘，ta是一个东北人，ta于1989年春夏之交正式登上历史舞台，ta在世界上拥有极高的声望，ta就是我国著名游泳运动员刘子歌。

我最崇拜的人姓刘，他为了反抗强权暴政忍辱负重，尽管他有很多先天缺陷，但是仍然不能阻止他成为时代的领袖，他的名字刘邦。

我最崇拜的人姓刘，虽然我没有见过他，但他一直为大家的幸福生活在默默的努力。现在越来越多的人知道他喜欢他的作品，甚至还有人盗版他的东西冒充来卖，这是一件好事，他叫刘一手。

我最崇拜的人姓刘，Ta和Ta的同志们为了自由和人权与专制进行了不懈的斗争，Ta用自身惨痛的牺牲证明了专制的残暴，人们铭记着Ta的事迹，专制却从学校课本里把Ta的名字拿走，Ta的名字叫刘和珍。

我最崇拜的人姓刘，每当我觉得社会太黑暗、生活得太辛苦要放弃时，脑海中出现ta的身影又让我重燃斗志。ta是刘亦菲。

我最崇拜的人姓刘。念过大学，刚正不阿，曾被当权者剥夺工作，中年后又被关入监狱。每个中国人都应该记住他的名字。他叫刘墉！

我最崇拜的人姓刘，ta很早就被黑恶势力打压，登上封面，影响很坏，因此消失了很长时间，但是最近ta又出来了，还获得了很多奖项，跟影帝结合了，ta叫刘嘉玲。

The Beauty of Qt 3: Implicit Sharing

2010-12-07T11:25:00.000+02:00

To maximize resource usage and minimize copying, Qt uses implicit data sharing in many classes, so that the data is copied only when a function writes to it. This trick is also referred to as flyweight pattern sometimes.

Now let's take QByteArray as an example to see how it's implemented. It uses a private struct of Data to track the shared data:

struct Data {

  QBasicAtomicInt ref; // reference count, the operation on it is atomic

  int alloc; // allocated space for the data

  int size; // actual size of the data, not counting the ending '\0' added by QByteArray

  char *data; // point to the data

  char array[1]; // where the data is stored, and the data always end with '\0'

};

Here, we use both the pointer of data and array just because the data might actually be stored in another object. When an object is copied, e.g. through the assignment operator, it only copies the pointer to the shared data:

QByteArray &QByteArray::operator=(const QByteArray & other)

{

  // increase the reference count of the shared data it's supposed to be used

  other.d->ref.ref();



  // decrease the reference count of the share data currently used, and free it if no one else is using

  if (!d->ref.deref())

    qFree(d);



  // point to the shared data

  d = other.d;



  return *this;

}

On the other hand, if it's to be changed by e.g. the resize() function, it copies the data if any other object also shares it:

void QByteArray::resize(int size)

{

  if (size <= 0) {

    // if the target is no bigger than 0, points to an empty data block

    Data *x = &shared_empty;

    x->ref.ref();

    if (!d->ref.deref())

      qFree(d);

    d = x;

  } else if (d == &shared_null) {

    // if currently a null array, just create a new data block

    Data *x = static_cast<data *>(qMalloc(sizeof(Data)+size));

    Q_CHECK_PTR(x);

    x->ref = 1;

    x->alloc = x->size = size;

    x->data = x->array;

    x->array[size] = '\0';

    (void) d->ref.deref();

    d = x;

  } else {

    // if any other object uses this data block, or the current memory is too small or too big

    // reallocate space, and copy the data for it

    // note that this operation might consume some time if the data is huge

    if (d->ref != 1 || size > d->alloc || (size < d->size && size < d->alloc >> 1))

      realloc(qAllocMore(size, sizeof(Data)));

    if (d->alloc >= size) {

      d->size = size;

      if (d->data == d->array) {

        d->array[size] = '\0';

      }

    }

  }

}

With this in mind, let's see how to use QSharedData and QSharedDataPointer to implement our own implicit shared data objects.

// first implement your data object inheriting from QSharedData, which provides the reference count

class SharedData: public QSharedData

{

public:

  SharedData()

    : QSharedData()

    , var(0)

  {}



  SharedData(const SharedData &other)

    : QSharedData(other)

    , var(other.var)

  {}



  int var;

};



// then the data owner

class DataOwner

{

public:

  DataOwner()

  : d(new SharedData)

  {}



  DataOwner(int var)

  : d(new SharedData)

  {

    // for write access, the -> operator will automatically copy the shared data if needed

    d->var = var;

  }



private:

  // this template class hides all the details for implicit sharing

  // therefore, no need to provide copy constructor or assignment operator

  QSharedDataPointer<SharedData> d;

};

Quite simple, right ;) Then just proceed to implement explicit shared data objects using QExplicitlySharedDataPointer yourself.

The Beauty of Qt 2: Meta Object

2010-12-01T13:56:00.001+02:00

Besides the D-pointers, another interesting thing in Qt is the Q_OBJECT macro. It provides the access to meta objects, which enables you to enjoy more features of a QObject, e.g. signals and slots. The meta object provides information about class name, properties and methods of a QObject, which is also known as reflection.

Using QMetaObject, you can print the information of the class name, etc.:

QObject obj;

const QMetaObject *metaObj = obj.metaObject();

qDebug() << "class name: " << metaObj->className();

qDebug() << "class info count: " << metaObj->classInfoCount();

qDebug() << "methods: ";

// starting from QMetaObject::methodOffset() so it won't display the methods inherited

for (int i = metaObj->methodOffset(); i < metaObj->methodCount(); ++i)

  qDebug() << metaObj->method(i).methodType() << " " << metaObj->method(i).signature();

As none of these information is supported in pure C++, Qt uses the Meta Object Compiler (moc) to do all the tricks. It reads each header file, and generates a C++ source file (moc_*.cpp) containing the code for meta-object, if it finds a Q_OBJECT macro used in any class declaration. With the code generation approach, Qt not only gains the flexibility as in e.g. Java, but also keeps the performance and scalability as in C++.

Suppose we have the following simple class:

class MyObject : public QObject

{

  Q_OBJECT

public:

  explicit MyObject(QObject *parent = 0);



  void myFunc();



public slots:

  void mySlot(int myParam);



signals:

  void mySignal(int myParam);

};

The following code / information will be generated by moc, and can be retrieved through pointers defined in the anonymous struct of QMetaObject::d:

// pointed by QMetaObject::d.data, the beginning stored "as" a QMetaObjectPrivate struct

static const uint qt_meta_data_MyObject[] = {

  5,       // revision, the internals have been changed several times

  0,       // classname, offset of qt_meta_stringdata_MyObject



  // the following are defined as (number, index) pair

  0,    0, // classinfo

  2,   14, // we have two methods, starting at index 14 (i.e. the signal)

  0,    0, // properties

  0,    0, // enums/sets

  0,    0, // constructors



  0,       // flags

  1,       // signal counts



  // for signals slots, and properties, the signatures and parameters are offset of qt_meta_stringdata_MyObject

  // signals: signature, parameters, type, tag, flags

  18,   10,    9,    9, 0x05,



  // slots: signature, parameters, type, tag, flags

  32,   10,    9,    9, 0x0a,



  0        // eod

};



// pointed by QMetaObject::d.stringdata

static const char qt_meta_stringdata_MyObject[] = {

  "MyObject\0\0myParam\0mySignal(int)\0"

  "mySlot(int)\0"

};

The above information, as well as the information for its base class, is stored as the static meta object for this class:

const QMetaObject MyObject::staticMetaObject = {

  { &QObject::staticMetaObject, // pointer to its base class, stored at QMetaObject::d.superdata

    qt_meta_stringdata_MyObject, qt_meta_data_MyObject, 0 }

};

In this way, if you want to do type cast for QObject, instead of using the somewhat expensive operator of dynamic_cast, we can use qobject_cast. It exploits the benefits of the meta object system, thus avoiding the runtime type cast:

template <class T> inline T qobject_cast(QObject *object)

{

#if !defined(QT_NO_QOBJECT_CHECK)

  reinterpret_cast(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast(object));

#endif

  return static_cast(reinterpret_cast(0)->staticMetaObject.cast(object));

}

Here, the trick is that the QMetaObject of the target type checks if the object inherits from it:

const QObject *QMetaObject::cast(const QObject *obj) const

{

  if (obj) {

    const QMetaObject *m = obj->metaObject();

    do {

      if (m == this)

        return obj;

    } while ((m = m->d.superdata));

  }

  return 0;

}

Also, moc will generate some code for each signal. Whenever a signal is emitted, this function will be called internally:

void MyObject::mySignal(int _t1)

{

  void *_a[] = { 0, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };

  // it checks all the connected slots, and call each of them based on the connection type

  QMetaObject::activate(this, &staticMetaObject, 0, _a);

}

In the end, the slots are invoked by the generated qt_metacall function:

int MyObject::qt_metacall(QMetaObject::Call _c, int _id, void **_a)

{

  // if this function is called by the super class, just return

  _id = QObject::qt_metacall(_c, _id, _a);

  if (_id < 0)

    return _id;



  // call the function based on its ID

  if (_c == QMetaObject::InvokeMetaMethod) {

    switch (_id) {

    case 0: mySignal((*reinterpret_cast< int(*)>(_a[1]))); break;

    case 1: mySlot((*reinterpret_cast< int(*)>(_a[1]))); break;

    default: ;

    }



    // remove the IDs "consumed" by this class so that in its subclass the ID always starts with 0, and the return value of -1 means already consumed

    _id -= 2;

  }



  return _id;

}

渭南电视台台长街头被杀

2010-11-28T10:31:00.000+02:00

继山西一对住高档住宅区的警察夫妇被杀之后，陕西又出了一起《渭南电视台台长街头被杀》事件。

据渭南市120急救中心工作人员介绍，该中心接到指令后赶到现场，发现一中年男性趴卧在地上，受害者身下有大量血迹，胸部中一刀致命，当时已无生命体征。受害者遗体旁停着一辆墨绿色丰田普拉多越野车，车门开着。

遇害者是渭南市文化新闻出版与广播电视局副局长兼渭南电视台台长安荣。

警方一人士透露，在凶案现场，民警发现受害者身上手机、财物均在，初步分析不可能是劫掠财物。

然后又在网上发现他的简历：

安荣，1962年出生，研究生学历，中共党员，现任渭南市文广局副局长兼渭南电视台台长。1979年至1981年在大荔县工作。1985调任渭南市民政局科长，1997年至今分别出任渭南市广电局纪检组长、副局长兼渭南电视台台长职务。

这哥们17岁开始工作，啥时候拿到的研究生文凭呢？不知道是和太子爷一样的学历，还是西太平洋大学的硕士呢？

The Beauty of Qt 1: D-Pointer / Private Implementation

2010-11-25T21:01:00.000+02:00

I believe many of you who just start reading the source code of Qt will have the question: why Qt uses those private classes? What's the benefit of such a design pattern? Well, the most significant reason is to keep the binary compatibility.

Then what is binary compatibility? The article from KDE TechBase defines it like this:

A library is binary compatible, if a program linked dynamically to a former version of the library continues running with newer versions of the library without the need to recompile.

With this definition in mind, the benefit is easy to see: without it, whenever a library is updated, all the applications rely on it should be recompiled to work. Definitely, it's totally unacceptable for any widely used libraries like Qt. More information on binary compatibility itself can be found on that article from KDE TechBase, and here I only want to share with you how it's used.

Without the usage of D-pointers, we may have a class defined as below:

class MyClass

{

public:

  MyClass();

  ~MyClass();

private:

  int myVar;

};

Obviously, the private member of myVar here is a big enemy of binary compatibility. There fore, we refactor the code into the following:

class MyClassPrivate;

class MyClass

{

public:

  MyClass();

  ~MyClass();

private:

  MyClassPrivate * const d_ptr;

  Q_DECLARE_PRIVATE(MyClass);

};

Here, we use a pointer d_ptr to refer to the private implementation, and the macro of Q_DECLARE_PRIVATE is employed to define some helper functions and friend class:

#define Q_DECLARE_PRIVATE(Class) \

    inline Class##Private* d_func() { return reinterpret_cast<Class##Private *>(qGetPtrHelper(d_ptr)); } \

    inline const Class##Private* d_func() const { return reinterpret_cast<const Class##Private *>(qGetPtrHelper(d_ptr)); } \

    friend class Class##Private;

Then we define the private class as below:

class MyClassPrivate

{

public:

  MyClassPrivate(MyClass *parent);

private:

  MyClass * const q_ptr;

  Q_DECLARE_PUBLIC(MyClass);

  int myVar;

};

Here, the q_ptr pointer points the public interface, and the Q_DECLARE_PUBLIC macro is used to define some helper functions:

#define Q_DECLARE_PUBLIC(Class) \

    inline Class* q_func() { return static_cast<Class *>(q_ptr); } \

    inline const Class* q_func() const { return static_cast<const Class *>(q_ptr); } \

    friend class Class;

And we can further use the following two macros to ease the access:

#define Q_D(Class) Class##Private * const d = d_func()

#define Q_Q(Class) Class * const q = q_func()

That's all about the usage of D-pointers and private implementations in Qt. Let me use a simple sample to end this post ;)

// myclass.h

#ifndef MYCLASS_H

#define MYCLASS_H



#include <QtCore/QObject>



class MyClassPrivate;

class MyClass: public QObject

{

  Q_OBJECT

public:

  MyClass(QObject *parent = 0);

  virtual ~MyClass();

  void dummyFunc();



signal:

  void dummySignal();



private:

  MyClassPrivate * const d_ptr;

  Q_DECLARE_PRIVATE(MyClass);

  Q_DISABLE_COPY(MyClass);

};



#endif // MYCLASS_H



// myclass.cpp

#include "myclass.h"



class MyClassPrivate

{

public:

  MyClassPrivate(MyClass *parent)

    : q_ptr(parent)

  {

  }



  void foobar()

  {

    Q_Q(MyClass);

    emit q->dummySignal();

  }



private:

  MyClass * const q_ptr;

  Q_DECLARE_PUBLIC(MyClass);

};



MyClass::MyClass(QObject *parent)

  : QObject(parent)

  , d_ptr(new MyClassPrivate(this))

{

}



MyClass::~MyClass()

{

  Q_D(MyClass);

  delete d;

}



void MyClass::dummyFunc()

{

  Q_D(MyClass);

  d->foobar();

}

The Chinese translation is available at: http://blog.csdn.net/zhu_xz/archive/2010/11/25/6035861.aspx

刚收到的一封以“对华援助协会”名义发送的钓鱼邮件

2010-11-24T15:24:00.001+02:00

如题，刚受到钓鱼邮件一封，打开后截图如下：

如果你点击其中的链接，试图打开这个所为的“紧急通知”，就会被重定向到域名为google-mail.dyndns.org上的一个和GMail登录页面完全相同的页面，截图如下：

该钓鱼页面会盗取你的GMail账户密码，并重定向到一个不存在的Google页面，极具迷惑性，请大家小心！！我现在暂时没有时间详细追查下去，晚点会仔细看看，并将结果向告诉大家！

更新
这个钓鱼邮件用到了DynDNS.com的服务，将域名google-mail.dyndns.org指向IP地址115.160.146.163，而发送电子邮件的地址也是这个IP。而根据http://www.ip138.com/的查询结果，该IP地址位于香港。

考虑到对华援助协会的性质，以及针对GMail账户的盗取，有理由认为这个钓鱼是熊猫大叔做的。

彭德怀亲临攀枝花建设工地(14)

2010-11-21T11:28:00.001+02:00

在凤凰网上发现《彭德怀亲临攀枝花建设工地(14)》一文中有如此牛B的一段：

在江耀华逝世二十多年后的全国科技大会上，攀钢的雾化提钒工艺获得了国家科技进步一等奖，当大会念到获奖者的名字时，上台领奖的竟然是一个戴着红领巾的小姑娘--江耀华的女儿。全体代表起立，向这位无法到会的获奖者默哀致意。

请大家自行联想！

洪洞县警察夫妇家中被害

2010-11-17T15:37:00.000+02:00

全文转载《洪洞县警察夫妇家中被害》如下，看点用彩色标明：

楚天金报讯据《新京报》报道 12日，山西临汾市洪洞县城中心地段一高档小区发生凶案，一对警察夫妇在家中遇害。

11月12日上午，山西省临汾市洪洞县警方接到报警称，位于县城中心地段一高档小区内发生凶案，一对夫妻在家中非正常死亡。

知情人称，两名死者均为洪洞县公安局干警，两人系夫妻关系。男子王某，52岁，为洪洞县公安局交警大队公路巡警中队原队长，王妻为洪洞县公安局机关科室干警。

据了解，遇害警察夫妇育有两女一子，均在美国留学，11日晚，子女联系父母，发现手机关机、家中电话无人应答，后找亲属和司机，最后发现在家中遇害。知情人称，死者的宝马车停在车库，楼道有一摊血迹，男子脖子有勒痕，女子身上无明显痕迹。

洪洞一知情人告诉记者，死者王某为人低调，生前曾开办过企业，在当地很有名气。

知情人还称，死者家的大门没有遭到破坏，房间茶几上放着一个茶杯。据悉，山西省、市、县警方已成立专案组，案件正在进一步调查中。

另据网友爆料，洪洞县公安局副局长，交警大队长王建勋被杀，系被狗链勒死，其妻也一并被杀。王为亿万富翁，在洪洞有三个煤矿。

请大家自行联想！

中国人民是不会上当的

2010-11-02T18:58:00.000+02:00

人民网的又一篇雄文，《中国人民是不会上当的》。文章表示：

美国人均石油消耗量是中国的10倍以上，平均1.2—1.3人拥有一辆汽车，这个模式如果搬到中国，中国就要有16亿辆汽车。

这个，这个，中国人也多得离谱了点吧？已经有19.2-20.8亿人了？既然如此，文中的其他观点笑笑也就过去了吧！

New release of Web Runtime for N900

2010-11-01T11:34:00.000+02:00

Finally, I'm happy to push the latest Web Runtime (v1.1.0) for N900 to the extras-devel repository. Please note that this release is only tested against PR 1.3. There's no new features implemented compared to the previous release back in July, but only bug fixes. Personally, this is one of the last duties for me in the WRT project, and let's see what I would play with in the future ;)

What is Web Runtime?
It's a development framework with which you can write applications in standard Web technologies, like HTML, CSS, and JavaScript. Also, a bunch of Device APIs are provided to grant you the access to native resources, e.g. file system, sensors, etc., using JavaScript.

To install WRT on N900, you should first enable the extras-devel repository.

If you have the previous release installed, you should first uninstall:
sudo gainroot
apt-get purge libwrt-experimental1

Then install the new release:
sudo gainroot
apt-get install qtwrt

Have fun and feel free to go to the public forum for more questions ;)

Hybrid application using QML and Qt C++

2010-10-28T19:36:00.000+03:00

Though QML provides a nice way to design user interfaces, and JavaScript is employed there to implement the application logic and works pretty nice in many cases, we might still need Qt C++ in some situations (well, at least JavaScript has limited access outside its sandbox).

1) integrate QML into Qt C++
Suppose we have a QML file, named "myqml.qml", like this:

// this line should be "import QtQuick 1.0" since Qt 4.7.1

import Qt 4.7



Rectangle {

  id: myRectangle

  width: 800

  height: 480

  color: "lightgray"



  Text {

    id: myText

    text: "I love hybrid application!"

    anchors.centerIn: parent

    font.pointSize: 28

    font.bold: true

  }

}

One easy way to integrate is to use the QDeclarativeView class, which provides a widget to display QML files. You just need the following three lines:

QDeclarativeView view;

view.setSource(QUrl::fromLocalFile("myqml.qml"));

view.show();

However, QDeclarativeView consumes more resources than normal widgets. Fortunately, we can integrate QML into a graphics scene. The following lines shows the basic usage:

// provides an environment for instantiating QML components

QDeclarativeEngine engine;



// encapsulates a QML component definition

QDeclarativeComponent component(&engine, QUrl::fromLocalFile("myqml.qml"));



// creates the graphics item for QML at the engine's root context

QDeclarativeItem *item = qobject_cast<QDeclarativeItem *>(component.create());



scene.addItem(item);

Then with the help of the QDeclarativeItem class, you can easily access the properties of the QML element, e.g.:

qDebug() << item->property("color").typeName();

item->setProperty("color", QColor(255, 255, 255));

2) exposing Qt C++ objects to QML
You can also expose native Qt C++ objects to QML through QDeclarativeContext:

QDeclarativeContext *context = engine->rootContext();

context->setContextProperty("textFromQt", QString("I love hybrid application!"));

Then in QML, you can have e.g. the following line to access them:
text: textFromQt

You can also use QDeclarativePropertyMap to manage the exposed properties:

QDeclarativePropertyMap map;

map.insert("key1", "value1");

map.insert("key2", "value2");

context->setContextProperty("map", &map);

In a QML engine, there could be a couple of contexts, forming a tree structure. The child contexts inherit properties in the parent context. By default, there is only one root context, but you can always add more to give finer control of the exposed data, i.e. different QDeclarativeComponent inside the same context have the same exposed data set.

To expose a self-defined object, we can use the following code:

// define a class with properties

class MyObject: public QObject

{

  Q_OBJECT



  // the NOTIFY signal is needed to inform about changes

  // all properties will be exposed to QML

  Q_PROPERTY(QString text READ text WRITE setText NOTIFY textChanged)

public:

  MyObject(QObject *parent = 0) : QObject(parent), m_text("I love hybrid application!") {}



  QString text() const { return m_text; }

  void setText(QString &text)

  {

    m_text = text;

    emit textChanged();

  }



signals:

  void textChanged();



private:

  QString m_text;

};



// then just expose it so QML can access it through name "myObject"

engine->rootContext()->setContextProperty("myObject", new MyObject());

Moreover, we can create new QML types:

// define the new type

class MyType : public QDeclarativeItem

{

  Q_OBJECT



public:

  MyType(QDeclarativeItem *parent = 0) : QDeclarativeItem(parent)

  {

    setFlag(QGraphicsItem::ItemHasNoContents, false);

  }



  void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)

  {

    QPen pen(QColor(100, 100, 100), 2);

    painter->setPen(pen);

    painter->drawLine(0, 100, 100, 100);

  }

};



// then register to expose it

qmlRegisterType<mychart>("com.blogspot.xizhizhu.mytype", 1, 0, "MyType");

In QML, you can use it like this:

import com.blogspot.xizhizhu.mytype 1.0



MyChart {

 id: myChart

 width: 100

 height: 200

}

Now let's jump to invoke a Qt C++ function from QML. Basically, QML can invoke slots and functions declared with Q_INVOKABLE. Suppose we have the following function in MyObject:

Q_INVOKABLE void showMessage()

{

  QMessageBox::information(NULL, "My Test", "Invoking a native function ;)");

}

Then you can invoke it in QML:
myObject.showMessage();

3) write plugins as QML extension
The benefits for using plugins as QML extensions are similar to using shared libraries, and it can be easily achieved with the help of QDeclarativeExtensionPlugin. Let's reuse the MyType class defined in the previous section. First, we need to create a plugin:

class MyPlugin : public QDeclarativeExtensionPlugin

{

  Q_OBJECT

public:

  void registerTypes(const char *uri)

  {

    qmlRegisterType<MyType>(uri, 1, 0, "MyType");

  }

};



Q_EXPORT_PLUGIN2(myPlugin, MyPlugin);

Then create a file named "qmldir" to define which plugin to load from where (suppose the plugin is called "myplugin):
plugin myplugin /path/to/plugin

Now we can use qmlviewer to launch the QML file:

// no need to import now

MyChart {

 id: myChart

 width: 100

 height: 200

}

4) summary

Use QDeclarativeView or QDeclarativeComponent to integrate a QML file into native Qt C++.

Qt C++ can access the properties of QML elements through QDeclarativeItem.

Expose native objects to QML through QDeclarativeContext.

New QML types can be exported through qmlRegisterType.

The properties of native objects are exported as properties, and the slots or functions declared with Q_INVOKABLE can be invoked in QML.

Create plugins for extension using QDeclarativeExtensionPlugin.

沙祖康给迟浩田颁“世界杰出和谐人物”奖

2010-10-28T17:51:00.001+03:00

中新网报道称《沙祖康给迟浩田颁“世界杰出和谐人物”奖》。文中提到：

中国原国防部长迟浩田将军27日晚从联合国副秘书长沙祖康手中接过世界和谐基金会“和谐奖评选委员会”提名授予的“世界杰出和谐人物”奖杯。
世界和谐奖在联合国65周年启动，奖杯由水晶做成艺术和平鸽，在联合国大厦背景上端栓有世界和谐钟图，象征着联合国和谐为和平的精神。
世界和谐基金会是由一批热爱和平、环保、来自五大洲的联合国前官员、投资家、教育家、科学家、退休将军、学生领袖等不同肤色的有志之士成立的联合国非政府组织，归宿在联合国环境规划署。其宗旨是促进: “促进人与自然的和谐、人与人的和谐、人与社会的和谐、国家之间的和谐、经济之间和谐、宗教之间的和谐、及人体自身的和谐”。

我是从来没有听说过这么个和谐基金会，于是就不和谐了Google了一番。然后就发现了两个名称、logo等相同的和谐基金会网站，一个以.com作为顶级域名，另一个则用.org作为顶级域名。不过根据网站上的介绍，两者应该为同一机构。

根据这个.org网站的介绍，“世界和谐基金会于2005年2月被联合国环境规划署委任以顾问一职，具有联合国非政府组织咨商地位。”我想，这个“顾问”，怎么也不能算是“归宿”吧？

本来还想继续深挖，结果一不小心找到北青网在年初的一篇打假报道《“联合国和谐城市”调查》，上面提到：

联合国环境规划署中国办事处官员张文娟对《北京科技报》表示：自己从来没有听说过“世界和谐基金会”这个组织，也没有听说过环境规划署方面与该组织进行合作的消息。

不知道这么个组织怎么邀请到“好五倍”的沙祖康的呢？

深圳市高层次专业人才住房补贴

2010-10-27T09:29:00.000+03:00

10月12日，深圳市人力资源和社会保障局发布《深圳市高层次专业人才2010年第三季度住房补贴拟发放及拟中止发放人员名单》。这样的大名单，自然少不了大名鼎鼎的腾讯公司老板马化腾，编号为314，以地方级领军人才身份赫然上榜。当然榜单中也少不了其他诸如华为公司的众多大佬，就不一一列举了。

遗憾的是，我没能在网上找到这个补贴发放的依据《深圳市高层次专业人才住房补贴发放规程》（深人发[2008]89号）。不过找到一个同年由深圳市政府发布的《深圳市高层次专业人才住房解决办法（试行）》（深府〔2008〕204号），应该具有一定参考价值吧？这份文件明确提及：

第五条高层次专业人才享受住房补贴（包括购房补贴、购房贴息、租房补贴）的，按照以下建筑面积标准计算：
（一）两院院士200平方米，其他国家级领军人才150平方米。
（二）地方级领军人才100平方米。
（三）后备级人才80平方米。

莫非马大佬的住房不足100平米？？

我国公民享有言论出版自由是不争的事实

2010-10-26T12:50:00.001+03:00

话说人民日报又发表了雄文一篇，叫做《我国公民享有言论出版自由是不争的事实》。

好吧，看原文：

据统计，目前我国境内网站已达279万个，网民人数达到4.2亿，互联网普及率达到31.8%，超过世界平均水平；各家网站都十分注重为网民提供发表言论的服务，约80%的网站提供电子公告服务；我国现有上百万个论坛、2.31亿个博客用户，每天人们通过论坛、新闻评论、博客等渠道发表的言论达300多万条；超过66%的中国网民经常在网上发表言论，就各种话题进行讨论，表达思想观点。

小学计算题......4.2亿网民，66%经常发表言论，算下来就是2.7亿网民经常发表言论。然后每天竟有高达300多万条言论通过各种渠道被发表！相当于说：
如果这些活跃网民每日一条言论，相当于每天有98.5%的言论被删除。
如果这些活跃网民每十天才发表一条言论，相当于每天有85.2%的言论被删除。
如果这些活跃网民每月才发表一条言论，相当于每天有55.6%的言论被删除。

还需要做评论吗？

Unofficial Qt Web Runtime tutorial 2: Menu API

2010-09-10T22:23:00.004+03:00

If there is no API, Qt WRT is merely nothing but a naive web browser. Then what APIs are supported other than standard HTML and JavaScript now? You can first get a list of features already supported, or to be supported in the near future here.

As a summary, we have already supported the APIs of menus, widget object, URI schemes, web inspector, console log, some Device APIs, as well as some HTML 5 features and standard JavaScript from Qt WebKit. Let's start with the menu API.

1 view menu
You can create the menu items to the chrome's menu bar (we call it view menu) with the following JavaScript code:

var menuItem = new nokia.device.MenuItem("Menu item", changeTitle);

nokia.device.menu.addMenuItem(menuItem);

function changeTitle()

{                                            

  nokia.device.menu.title = "New title";                          

}

Here, you have created a menu item named "Menu item" and added it to the menu bar. When it's triggered, the function changeTitle() will be called to set the menu's title to "New title".

Note that since on the device the menu's title is also the same as the window's title, it actually changes the window's title too.

2 context menu
The context menu can be created with the following piece of code:

var contextMenu = new nokia.device.ContextMenu("contextMenuArea");

var changeTitleItem = new nokia.device.MenuItem("Change Title");

changeTitleItem.onselect = changeTitle;

contextMenu.addMenuItem(changeTitleItem);

Here, a context menu is created and an item named "Change Title" is added to the menu. When you long tap on the HTML element with id "contextMenuArea", this context menu will pop up. Then if you select the "Change Title" item, the changeTitle() function will be called.

Of course, only the widgets in the windowed or fullscreen mode could have context menus; and only the widgets in the windowed mode can have view menus.

Note that there's a known bug (already fixed for the next release) that if you long tap on the area where no context menu is defined, an empty context menu is popped-up.

3 sample
Only the HTML file this time ;)

<html>

<header>

  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

  <title>Menu sample</title>

  <script type="text/javascript">

    function changeTitle()

    {

      if (nokia.device.menu.title == "Title 1")

        nokia.device.menu.title = "Title 2";

      else

        nokia.device.menu.title = "Title 1";

    }



    function init()

    {

      var menuItem = new nokia.device.MenuItem("item", changeTitle);

      nokia.device.menu.addMenuItem(menuItem);



      var contextMenu = new nokia.device.ContextMenu("contextMenuArea");

      contextMenu.addMenuItem(menuItem);

    }

  </script>

</header>

<body onload="init()">

  <div id="contextMenuArea">There is a context menu.</div>

</body>

</html>

As you can see, one menu item can be added to multiple menus, exactly the same as native Qt apps. Here goes some screenshots:

The first one shows the simple sample when launched. The second and third one show the view menu and the context menu, respectively, while the last one shows that the title has been updated after you tap on the menu. More screenshots can be found here, while the sample code is available here.

Unofficial QtWRT tutorial 1: Hello, view modes!

2010-08-18T23:07:00.010+03:00

Almost one month ago, we announced Qt Web Runtime, and released some snapshot for N900. Basically, QtWRT is a framework, using which you can write "native" application with standard web technology, e.g. HTML, CSS, and JavaScript. As a good starting point, you should take a look at this article.

Note that we're still working on it, and it's now just in the technology preview state ;)

1 install QtWRT
You should enable the extras-devel repository on your Rover and install the qtwrt-experimental package from there. Then, you can find in your Application Manager that Qt Web Runtime Technology Preview for N900 installed.

2 config.xml
To write your own web applications, besides the normal HTML pages, you also need a config.xml file to define e.g. the starting file, icon, features you need (i.e. access to Device APIs), as well as author's information, etc. More details and default values are defined here.

The following piece shows a minimum sample:

<?xml version="1.0" encoding="UTF-8"?>

<widget xmlns = "http://www.w3.org/ns/widgets">

</widget>

You can also define the name and icon (only PNG files supported) of the web app in config.xml:

<?xml version="1.0" encoding="UTF-8"?>

<widget xmlns = "http://www.w3.org/ns/widgets">

  <name>A sample web app</name>

  <icon src="app_icon.png" />

</widget>

The name and icon will be appeared in the Application Grid or the Desktop menu --> Add widget based on the view mode the web app supports (see below).

3 view modes
View modes define the visual presentation of web applications. The W3C spec has defined five different view modes, but we only support three of them in this snapshot:
windowed - The default view mode. You can find / launch web apps in this mode from the Application Grid. It also supports the native chromes and user-defined menus.
fullscreen - It can also be found / launched from the Application Grid. No need to say what is full screen, right ;)
minimized - It equals to the native widgets on the Home Screen.

The following piece defines the view modes in config.xml:

<?xml version="1.0" encoding="UTF-8"?>

<widget xmlns = "http://www.w3.org/ns/widgets"

    viewmodes = "someviewmode fullscreen minimized" >

</widget>

The unknown view mode "someviewmode" is ignored. It supports both "fullscreen" and "minimized" mode in this case. If no supported view mode is defined, "windowed" mode is used.

You can get the current view mode through the widget.viewMode interface in JavaScript.

Also, the transfer among different view modes is supported, with the exception from windowed / fullscreen to minimized, e.g.:
<a href="javascript:widget.viewMode='windowed'">Go to windowed mode</a>

With the following code, you can handle the view mode change event in the viewModeChanged function:

widget.onviewmodechange = viewModeChanged;

function viewModeChanged(mode)

{

  if (mode == "windowed") {

    // going to windowed mode

  } else if (mode == "minimized") {

    // going to minimized mode

  } else if (mode == "fullscreen") {

    // going to full screen mode

  }

}

4 package your application and install it
Well, I just assume you have enough knowledge to write whatever HTML page you like, and have renamed it to index.htm (the default starting file name).

Now just zip all your HTML files together with the config.xml file. Note that the config.xml file should be at the top level of the zip, and the name is case sensitive.

Then please rename it to *.wgt and copy it to your Rover. To make it like a native application, you can install it from the File Manager, and you can find your installed web applications in Application Manager!

Eh, I'm talking about some details during the installation here. You can skip this if not interested.

When you tap on the wgt file in File Manager, widgetinstaller is launched. It does some sanity checking of it, e.g. whether it's a valid zip file, if the config.xml is valid, etc., then convert it to a Debian file, and use the Application Manager to install the generated Debian file.

If you are interested in the generated Debian file, you can use the "--no-install" option of the widgetinstaller to have it copied to the current directory.

5 a sample
First, let's write the config.xml file.

<?xml version="1.0" encoding="UTF-8"?>

<widget xmlns="http://www.w3.org/ns/widgets"

    id="http://xizhizhu.blogspot.com/qtwrt/view-modes-sample"

    viewmodes="minimized fullscreen windowed">

  <name>View Modes Sample</name>

  <description>

    Well, it shows how the view modes work.

  </description>

  <author href="http://xizhizhu.blogspot.com/" email="xizhi.zhu@gmail.com">Xizhi Zhu</author>

  <license>In the public domain without any warranty.</license>

</widget>

Then the HTML file.

<html>

<header>

  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

  <title>View Modes</title>

  <script type="text/javascript">

    function init()

    {

      output = document.getElementById("viewmode");

      output.innerHTML = widget.viewMode;



      widget.onviewmodechange = changeViewMode;

    }



    function changeViewMode(mode)

    {

      output.innerHTML = widget.viewMode;

    }

  </script>

</header>



<body onload="init()">

  <div id="viewmode"></div><br />

  <a href="javascript:widget.viewMode='minimized'">minimized</a><br />

  <a href="javascript:widget.viewMode='windowed'">windowed</a><br />

  <a href="javascript:widget.viewMode='fullscreen'">fullscreen</a>

</body>

</html>

Now let's zip the file, send it to N900 and install it from the File Manager. You can find it installed in the Application Manager and already launched in the home screen.

You may ask, why the last line of "fullscreen" is not shown there? Well, that's due to the fixed size in the minimized mode, 312x82. Also, in the minimized mode, you can't actually interact with it, but only tap on it and open the windowed or fullscreen mode if supported. In the minimized mode, it's the same as native widgets that you can move it around, close it and add it back, as well as the transparent background by default.

Then you can tap the links to toggle between windowed and fullscreen mode. And for sure you'll find another "limitation" that you can't go back to minimized mode from the link. The only way is to close the window. Well, that's exactly what is expected.

Another thing is, in the fullscreen mode, it automatically shows the "go back to windowed" button if windowed mode is supported, otherwise the "close" button. Emm, the same as the browser, right?

Updated on 19.8.2010
Screenshots added into the posts ;)

Basic samples for SSL communication over Qt

2010-08-16T22:13:00.000+03:00

1) client

class SSLClient: public QObject

{

  Q_OBJECT



public:

  SSLClient(QObject* parent = NULL)

    : QObject(parent)

  {

    connect(&client, SIGNAL(encrypted()),

            this, SLOT(connectionEstablished()));

    connect(&client, SIGNAL(sslErrors(const QList<QSslError> &)),

            this, SLOT(errorOccured(const QList<QSslError> &)));

  }



  void start(QString hostName, quint16 port)

  {

    client.setProtocol(QSsl::TlsV1);

    client.connectToHostEncrypted(hostName, port);

  }



public slots:

  // handle the signal of QSslSocket.encrypted()

  void connectionEstablished()

  {

    // get the peer's certificate

    QSslCertificate cert = client.peerCertificate();



    // write on the SSL connection

    client.write("hello, world", 13);

  }



  // handle the signal of QSslSocket.sslErrors()

  void errorOccured(const QList<QSslError> &error)

  {

    // simply ignore the errors

    // it should be very careful when ignoring errors

    client.ignoreSslErrors();

  }



private:

  QSslSocket client;

};





int main(int argc, char** argv)

{

  QApplication app(argc, argv);



  SSLClient client;

  client.start("127.0.0.1", 8888);



  return app.exec();

}

2) server

class SSLServer: public QTcpServer

{

  Q_OBJECT



public:

  SSLServer(QObject* parent = NULL)

    : QTcpServer(parent)

  {

  }



  void start(QString certPath, QString keyPath, quint16 port)

  {

    listen(QHostAddress::Any, port);

    this->certPath = certPath;

    this->keyPath = keyPath;

  }



public slots:

  void readyToRead()

  {

    qDebug() << serverSocket->readAll();

  }



  void errorOccured(const QList &)

  {

    serverSocket->ignoreSslErrors();

  }



protected:

  void incomingConnection(int socketDescriptor)

  {

    serverSocket = new QSslSocket;

    if (serverSocket->setSocketDescriptor(socketDescriptor)) {

      connect(serverSocket, SIGNAL(readyRead()), this, SLOT(readyToRead()));

      connect(serverSocket, SIGNAL(sslErrors(const QList &)),

              this, SLOT(errorOccured(const QList &)));

      serverSocket->setProtocol(QSsl::TlsV1);

      serverSocket->setPrivateKey(keyPath);

      serverSocket->setLocalCertificate(certPath);

      serverSocket->startServerEncryption();

    } else {

      delete serverSocket;

    }

  }



private:

  QSslSocket *serverSocket;

  QString certPath;

  QString keyPath;

};



int main(int argc, char** argv)

{

  QApplication app(argc, argv);



  SSLServer server;

  server.start("ca.cer", "ca.key", 8888);



  return app.exec();

}

JavaScript benchmarking on N900 PR1.2

2010-05-30T14:40:00.000+03:00

Two months earlier, I did my JavaScript benchmarking on N900 PR1.1, and compare it with other platforms. Now, as N900 PR1.2 got released, Opera has released a preview for Maemo, and Chrome is ported to N900 by Jacekowski, I did another round of benchmarking.

	V8	SunSpider	Peacekeeper
MicroB (default browser)	21.2	35.12	128
FireFox	21.4	15.84	141
Opera	49.5	24.41	119
Qt 4.6.2	105	12.04	238
QtWebKit 2.0	104	9.36	286
Chrome	113	8.84	344

For V8 and Peacemaker, the higher the score, the better performance it has. For Sunspider, it's the lower the better.

Chrome is really fast as a result of its excellent V8 JavaScript engine and frequent release cycle.

Qt 4.6.2 is still quite good, especially considering the fact that the WebKit integrated is quite old. Note that QtWebKit will be released separately from Qt, meaning we could enjoy more about the latest WebKit technology then.

However, both Opera and FireFox (MicroB uses FireFox's Gecko JavaScript engine) have quite a long way to go. Moreover, when running V8 and Peacekeeper, both MicroB and FireFox complained about unresponsive JavaScript.

这位评论真的用过N900吗？！

2010-05-15T22:43:00.003+03:00

刚看了一篇谈论手机杯具的文章，说的是N900。不过很怀疑这位老兄是否真的用过N900......

文章说：N900最大的尴尬在于它那被消极淡化的通话功能。
话说Nokia对Maemo/MeeGo系列的定义是“移动电脑”（mobile computer）吧！打开N900的官方首页，上面就写得非常清楚：Nokia N900 mobile computer。本来定位就不是智能手机，所以通话功能被“淡化”不正常吗？或者说你见过哪部PDA会“强化”电话功能的？好吧，你会说我这样强词夺理了，那我们接着看......

然后文章对N900的“消极淡化通话功能”列出了几个“铁证”：
1，机身正面没有任何拨号快捷键，哪怕是触控按键都没有。
2，默认桌面菜单也没有任何与通话相关的快捷方式。
3，QWERTY全键盘采用了三排式的布局，因此并没有单独的数字键。也就是说，打开侧滑盖还是没法直接拨号。
4，没有竖屏模式，也就是说诺基亚设计它的初衷就是让你始终横着拿它。横着打电话？有难度吧。。。

好吧，我们看图说话：

这是我N900上四个桌面之一，上面可以任意摆设各种Widget、快捷方式和联系人，也可以自行调整其放置的位置。标号为1的红圈就是联系人的快捷方式，标号为2的红圈是最近通话和拨号功能的快捷方式，标号为3的红圈则是放在单个联系人的快捷方式。当然单个联系人也是可以自定义头像的，只不过考虑到隐私我暂时删除罢了。

当然了，默认情况下，桌面也是有联系人和最近通话的快捷方式的，好像也有邮件或者短信息的快捷方式......我就不刷机证明了啊;)

当然了，既然有如此方便的软键盘拨号，为何还要打开侧滑盖呢？

然后我们再看看“没有竖屏模式”的笑话！你点开最近通话和拨号功能，然后看下图：

我觉得这个应该叫做“竖屏模式”了吧？！而且通话功能的竖屏模式是默认开启的......

我想，我只能说这位搞评论的朋友没有用过N900吧！

PS 这三张照片都是用另一部N900的相机在晚上10点左右拍摄的，外界光线不好，室内也没开灯:)

JavaScript benchmarking on N900 and my laptop

2010-03-20T15:11:00.027+02:00

I just ran some JavaScript benchmark tests of V8 version 5, SunSpider v0.9.1 and Peacekeeper on my laptop. My laptop is HP EliteBook 6930p, which has Intel Core 2 Duo CPU P8600 @ 2.40GHz, 4 GB RAM, running KUbuntu 9.10 with kernel 2.6.31-20-generic. Also, I ran it on my N900 PR1.1 with Qt 4.6.2, and collected some results for iPhone 3GS, Droid and Nexus One, and HTC Desire.

The following scores are from V8, the higher the better.
FireFox for Ubuntu 3.5.8 - 248
Qt 4.6.2 – 910
Chrome 5.0.307.11 Beta – 4155
QtWebKit 2.0 – 2816
N900 - 105
iPhone 3GS - no results
Droid - 39.5
Nexus One - 63.5
HTC Desire - 66.1

Then I found some results of iPhone 3GS for V8 version 3:
N900 - 103
iPhone 3GS - 53

The following scores are from SunSpider, the lower the better.
FireFox for Ubuntu 3.5.8 – 2484.7
Qt 4.6.2 – 1136.0
Chrome 5.0.307.11 Beta – 462.1
QtWebKit 2.0 – 635.6
N900 - 12.5
iPhone 3GS - 16.7
Droid - 34.2
Nexus One - 14.7
HTC Desire - 12.02

The following scores are from Peacekeeper, the higher the better.
FireFox for Ubuntu 3.5.8 – 1510
Qt 4.6.2 – 3261
Chrome 5.0.307.11 Beta – 4324
QtWebKit 2.0 – 4288
N900 - 244

Chrome’s V8 engine is really fast, and WebKit still has a long way to go!

Also, N900 performs much better than iPhone 3GS, Droid and Nexus. Considering HTC Desire, N900 wins easily on V8, but lost a little on SunSpider. However, if you consider MicroB, the default browser on N900, it’s a disaster due to the slow engine of Gecko and N900 even used a pretty old version.

Then the ACID3 test.
FireFox for Ubuntu 3.5.8 – 93
Qt 4.6.2 – 100
Chrome 5.0.307.11 Beta – 100
QtWebKit 2.0 – 100

* The test for QtWebKit 2.0 is done with the revision number of 56441.