Java程序员们可能会经常遇到Windows下的UI问题,Java程序总是和Windows的外观统一不起来,特别是Vista,难度更高.
而现在,微软微软宣布它将为Eclipse基金会提供了标准的widget工具,这意味着Java将与Windows Presentation Foundation实现互通,允许应用程序原生采用Windows VIsta的外观.

这也是微软未来开放计划的一部分,微软认为一个日益开放,透明的方式正在出现.之前,微软还成立了Linux的互操作性实验室,并与JBoss,Zend Technologies等公司实现了技术合作.

package com.glnpu.jruby;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.jruby.Ruby;
import org.jruby.javasupport.JavaEmbedUtils;
import org.jruby.runtime.builtin.IRubyObject;

public class RunJRUBY extends Shell {

    private RunJRUBY run;
    private Text text;
    /**
     * Launch the application
     * @param args
     */
    public static void main(String args[]) {
        try {
            Display display = Display.getDefault();
            RunJRUBY shell = new RunJRUBY(display, SWT.SHELL_TRIM);
            shell.open();
            shell.layout();
            while (!shell.isDisposed()) {
                if (!display.readAndDispatch())
                    display.sleep();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Create the shell
     * @param display
     * @param style
     */
    public RunJRUBY(Display display, int style) {
        super(display, style);
        run = this;
        createContents();
    }

    /**
     * Create contents of the window
     */
    protected void createContents() {
        setText("SWT Application");
        setSize(500, 375);

        text = new Text(this, SWT.V_SCROLL | SWT.BORDER | SWT.WRAP | SWT.H_SCROLL);
        text.setBounds(0, 0, 492, 312);

        final Button button = new Button(this, SWT.NONE);
        button.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(final SelectionEvent e) {
                Ruby runtime = Ruby.getDefaultInstance();
                try {
                    //允许传对象，作为参数给JRuby
                    IRubyObject rootRubyObject = JavaEmbedUtils.newRuntimeAdapter().eval( runtime, text.getText() );
                    JavaEmbedUtils.invokeMethod( runtime, rootRubyObject, "run", new Object[] {run}, null );
                    //不传对象，直接运行JRbuy
                    //runtime.evalScriptlet(text.getText());
                } catch (Exception e1) {
                    System.err.println(e1.toString());
                    e1.printStackTrace();
                }
            }
        });
        button.setText("button");
        button.setBounds(335, 326, 48, 22);
        //
    }

    @Override
    protected void checkSubclass() {
        // Disable the check that prevents subclassing of SWT components
    }

}

require 'java'
module SWTTest
  include_package 'org.eclipse.swt'
  include_package 'org.eclipse.swt.layout'
  include_package 'org.eclipse.swt.widgets'
  include_package 'org.eclipse.swt.events'
end
    class TestDialog < SWTTest::Dialog
      @shell
      @parentShell
      def initialize shell
          super(shell, SWTTest::SWT::NONE)
          @parentShell = shell
          open
      end
      def open
          createContents()
          @shell.open();
          @shell.layout();       
      end
      def createContents
          @shell = SWTTest::Shell.new(@parentShell, SWTTest::SWT::DIALOG_TRIM | SWTTest::SWT::APPLICATION_MODAL)
          @shell.setSize(500, 375);
          @shell.setText("SWT Dialog");
          button = SWTTest::Button.new(@shell, SWTTest::SWT::PUSH)
          button.setText("Test Button 1")    
          button.setBounds(147, 116, 48, 22);
      end
    end
  class TestMain
      def run shell
          TestDialog.new shell
      end
  end
  TestMain.new

随时睁大雪亮的眼睛，看看是不是有个悬而未决的问题，一定要有个人(或是由主管自己)来负责研究到底哪里出错，也许这种研究既花时间又无聊，但总比灾难发生之后再来花好几个星期收拾残局要好得多。

如果您能很清楚告诉别人，您想要的究竟是什么，这样别人才能给您真正需要的帮助，而不是做一些似是而非的虚工。

“我已完成Faxmangler 的搜寻与取代功能。Frank”
主管应该看一下结果，然后回一个：
“我检查过F a x m a n g l e r的搜寻与取代，不太顺畅，请再修改。Hubie”
或是：
“很好，继续加油！Hubie”
想想看，如果大家经常收送这类正面的e - m a i l，一定会觉得充满干劲，这和可恨的进度报告多么不同！程序设计师会很乐意看见这类的好消息，当自己送出完成工作的信息时，也会很有成就感；没有人会觉得这是很讨厌的报告。

当某位程序设计师觉得自己可能要落后了，我会和他谈，研究将来如何避免这种事情。是我们在制定进程时疏漏了某一个重要环节吗？或是时间表定得太乐观了？是不是有个错虫( b u g )在作祟，害得程序很难写或无法测试？不论问题是什么，我们一定想办法解决掉，并且预防它将来再发生。

排出一个优先级表：

• 体积大小(size)
• 速度(speed)
• 坚固性(robustness)
• 安全性(safety)
• 可测试性(testability)
• 容易维护(maintainability)
• 简洁(simplicity)
• 再用性(reusability)
• 可移植性(portability)

在开发的过程就立即除虫，可以让您早些学到经验，然后就不会再犯同样的错误；相反地，如果到了项目后期才发现，您可能已经犯过多次同样的错误而不自知。

发现错虫而立即除错是一种缓冲器，提醒那些讲求快速而不够谨慎的程序设计师，以后多加小心。

若能保持没有任何错虫，您就能比较准确估出项目的完成时间。

要求错虫随时发现随时改，等于是在开发过程中引进一个小小的质量管理机制，多方的防微杜渐，保护产品的正确性。

有什么事情是我今天能做，而且可以帮助项目在未来几个月内顺利进行的？

button.addSelectionListener(new SelectionAdapter() {
            private boolean stopFlag;// 停止标志

            private void go() {
                for (int i = 0; i < 10; i++) {// 循环10次，每次间隔一秒
                    System.out.println("第" + (i + 1) + "个任务执行完毕");
                    if (stopFlag) {// 监控是否要让停止后台任务
                        System.out.println("被中断了");
                        return;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Throwable t) {}
                }
                stopFlag = true;// 执行完毕后把标志位设为停止，好通知给进度框
                System.out.println("全部任务执行完毕");
            }

            public void widgetSelected(SelectionEvent e) {
                stopFlag = false;// 每次都设初值为false
                new Thread() {// 把后台任务放到一个新开线程里执行
                    public void run() {
                        go();
                    }
                }.start();
                showProgressDialog();// 打开一个进度框
            }

            private void showProgressDialog() {
                IRunnableWithProgress runnable = new IRunnableWithProgress() {
                    public void run(IProgressMonitor monitor) {
                        monitor.beginTask("正在执行中......", 30);
                        int i = 0;
                        while (true) {
                            // 监听是否单击了进度框的“取消”按钮，stopFlag则是监听后台任务是否停止
                            if (monitor.isCanceled() || stopFlag) {
                                stopFlag = true; // 单击了“取消”按钮要设标志位为停止，好通知后台任务中断执行
                                break;// 中断处理
                            }
                            // i到30后清零。并将进度条重新来过
                            if ((++i) == 30) {
                                i = 0;
                                monitor.beginTask("正在执行中......", 30);
                            }
                            // 进度条每前进一步体息一会，不用太长或太短，时间可任意设。
                            try {
                                Thread.sleep(99);
                            } catch (Throwable t) {}
                            monitor.worked(1);// 进度条前进一步
                        }
                        monitor.done();// 进度条前进到完成
                    }
                };
                try {
                    new ProgressMonitorDialog(s).run(true, true, runnable);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

This implementation of IRunnableContext#run(boolean, boolean, IRunnableWithProgress) runs the given IRunnableWithProgress using the progress monitor for this progress dialog and blocks until the runnable has been run, regardless of the value of fork. The dialog is opened before the runnable is run, and closed after it completes. It is recommended that fork is set to true in most cases. If fork is set to false, the runnable will run in the UI thread and it is the runnable's responsibility to call Display.readAndDispatch() to ensure UI responsiveness.