Ruby 的桌面应用开发

1. 引言：Ruby 在桌面应用开发领域的潜力

Ruby 是一种动态、面向对象、解释型的编程语言，以其简洁的语法和强大的表达能力而闻名。虽然它在 web 开发（如 Rails 框架）中大放异彩，但在桌面应用开发方面同样具备独特的优势。Ruby 的灵活性和丰富的库生态系统使得开发者能够相对轻松地构建出功能丰富且用户体验良好的桌面应用程序。

2. 开发环境搭建

在开始 Ruby 桌面应用开发之前，需要确保安装了 Ruby 环境。如果尚未安装，可以从 Ruby 官方网站（https://www.ruby-lang.org/）下载适合操作系统的安装包进行安装。安装完成后，通过在终端输入 ruby -v 命令检查 Ruby 是否安装成功以及查看当前版本号。

同时，为了进行桌面应用开发，我们会用到一些重要的库，其中 Tk 和 Qt 是比较常用的。

2.1 使用 Tk 库

Tk 是一个图形工具包，它为 Ruby 提供了创建图形用户界面（GUI）的能力。要使用 Tk，通常 Ruby 安装包中已经包含了 Tk 的支持。如果没有，可以通过 RubyGems 进行安装，在终端输入 gem install tk。

以下是一个简单的 Tk 示例，创建一个包含一个按钮的窗口：

require 'tk'

root = TkRoot.new { title "My First Tk App" }
button = TkButton.new(root) {
  text 'Click Me!'
  command { Tk.messageBox(title: 'Message', message: 'You clicked the button!') }
}
button.pack
Tk.mainloop

在上述代码中，首先通过 require 'tk' 引入 Tk 库。然后创建一个 TkRoot 对象作为主窗口，并设置其标题。接着创建一个 TkButton 对象，设置按钮的文本以及点击按钮时执行的命令，这里点击按钮会弹出一个消息框。最后通过 button.pack 将按钮添加到窗口中，并使用 Tk.mainloop 启动事件循环，使窗口显示并响应用户操作。

2.2 使用 Qt 库

Qt 是一个跨平台的 C++ 应用程序框架，同时也有 Ruby 绑定，即 ruby-qt。要安装 ruby-qt，可以在终端输入 gem install ruby-qt。不过，安装过程可能因操作系统和系统环境而异，在某些情况下可能需要安装额外的系统依赖。

以下是一个简单的 Qt 示例，创建一个包含一个标签的窗口：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
layout = Qt::VBoxLayout.new(window)
label = Qt::Label.new('Hello, Qt from Ruby!', window)
layout.addWidget(label)
window.show
app.exec

在这个代码示例中，首先通过 require 'Qt4' 引入 Qt 库。接着创建一个 Qt::Application 对象，它管理着应用程序的控制流和主要设置。然后创建一个 Qt::Widget 对象作为主窗口，并创建一个垂直布局 Qt::VBoxLayout。创建一个 Qt::Label 对象并设置其文本，将标签添加到布局中，最后通过 window.show 显示窗口，并使用 app.exec 启动应用程序的事件循环。

3. 窗口和布局管理

在桌面应用开发中，窗口的创建和布局管理是关键部分。不同的库提供了不同的方式来实现这些功能。

3.1 Tk 的窗口和布局

Tk 中，TkRoot 类代表主窗口。除了设置标题外，还可以设置窗口的大小、位置等属性。例如：

require 'tk'

root = TkRoot.new {
  title "Window Size and Position"
  geometry '300x200+100+100' # 设置窗口大小为 300x200，位置在屏幕坐标 (100, 100)
}
Tk.mainloop

在布局方面，Tk 提供了几种布局管理器，如 pack、grid 和 place。pack 是一种简单的布局方式，它按照添加的顺序将组件排列在窗口中。例如：

require 'tk'

root = TkRoot.new { title "Pack Layout" }
button1 = TkButton.new(root) { text 'Button 1' }
button2 = TkButton.new(root) { text 'Button 2' }
button1.pack(side: :left)
button2.pack(side: :left)
Tk.mainloop

在上述代码中，两个按钮通过 pack 布局管理器并设置 side: :left 使其水平排列在窗口左侧。

grid 布局管理器允许更精确地控制组件的位置，通过行和列来定位组件。例如：

require 'tk'

root = TkRoot.new { title "Grid Layout" }
label1 = TkLabel.new(root) { text 'Label 1' }
label2 = TkLabel.new(root) { text 'Label 2' }
entry1 = TkEntry.new(root)
entry2 = TkEntry.new(root)
label1.grid(row: 0, column: 0)
entry1.grid(row: 0, column: 1)
label2.grid(row: 1, column: 0)
entry2.grid(row: 1, column: 1)
Tk.mainloop

这里通过 grid 布局将标签和输入框按照指定的行和列进行排列。

place 布局管理器则允许通过绝对坐标来放置组件，但这种方式在不同分辨率下可能显示效果不佳，一般较少使用。

3.2 Qt 的窗口和布局

在 Qt 中，Qt::Widget 类可以作为主窗口或其他容器。可以通过 resize 方法设置窗口大小，通过 move 方法设置窗口位置。例如：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
window.resize(300, 200)
window.move(100, 100)
window.show
app.exec

在布局方面，Qt 提供了多种布局类，如 Qt::VBoxLayout（垂直布局）、Qt::HBoxLayout（水平布局）、Qt::GridLayout 等。以 Qt::GridLayout 为例：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
layout = Qt::GridLayout.new(window)
label1 = Qt::Label.new('Label 1', window)
label2 = Qt::Label.new('Label 2', window)
entry1 = Qt::LineEdit.new(window)
entry2 = Qt::LineEdit.new(window)
layout.addWidget(label1, 0, 0)
layout.addWidget(entry1, 0, 1)
layout.addWidget(label2, 1, 0)
layout.addWidget(entry2, 1, 1)
window.show
app.exec

这里通过 Qt::GridLayout 将标签和输入框按照指定的行和列添加到布局中，从而实现精确的位置控制。

4. 交互组件的使用

桌面应用需要与用户进行交互，这就涉及到各种交互组件的使用，如按钮、文本框、下拉框等。

4.1 Tk 的交互组件

• 按钮（TkButton）：前面已经介绍过基本的按钮使用，按钮的 command 选项可以设置点击按钮时执行的代码块。例如，可以在按钮点击时修改标签的文本：

require 'tk'

root = TkRoot.new { title "Button Interaction" }
label = TkLabel.new(root) { text 'Initial Text' }
button = TkButton.new(root) {
  text 'Change Text'
  command { label['text'] = 'Text Changed!' }
}
label.pack
button.pack
Tk.mainloop

• 文本框（TkEntry）：用于用户输入文本。可以获取文本框中的内容，也可以设置初始值。例如：

require 'tk'

root = TkRoot.new { title "Entry Field" }
entry = TkEntry.new(root)
entry.insert(0, 'Enter your name')
button = TkButton.new(root) {
  text 'Get Text'
  command { Tk.messageBox(title: 'Name', message: entry.get) }
}
entry.pack
button.pack
Tk.mainloop

在上述代码中，通过 entry.insert(0, 'Enter your name') 设置了文本框的初始提示文本，点击按钮时通过 entry.get 获取文本框中的内容并弹出消息框显示。

• 下拉框（TkOptionMenu）：可以让用户从一组选项中选择一个。例如：

require 'tk'

root = TkRoot.new { title "Option Menu" }
options = ['Option 1', 'Option 2', 'Option 3']
selected = TkVariable.new(root, options[0])
menu = TkOptionMenu.new(root, selected, *options)
button = TkButton.new(root) {
  text 'Show Selection'
  command { Tk.messageBox(title: 'Selection', message: selected.value) }
}
menu.pack
button.pack
Tk.mainloop

这里创建了一个下拉框，通过 TkVariable 来跟踪用户选择的值，点击按钮时显示用户选择的选项。

4.2 Qt 的交互组件

• 按钮（Qt::PushButton）：与 Tk 类似，通过 clicked 信号连接到相应的槽函数（在 Ruby 中通过块实现）。例如：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
layout = Qt::VBoxLayout.new(window)
label = Qt::Label.new('Initial Text', window)
button = Qt::PushButton.new('Change Text', window)
button.connect(SIGNAL('clicked()')) { label.setText('Text Changed!') }
layout.addWidget(label)
layout.addWidget(button)
window.show
app.exec

• 文本框（Qt::LineEdit）：提供了丰富的文本输入功能。例如：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
layout = Qt::VBoxLayout.new(window)
entry = Qt::LineEdit.new(window)
entry.setText('Enter your name')
button = Qt::PushButton.new('Get Text', window)
button.connect(SIGNAL('clicked()')) { Tk.messageBox(title: 'Name', message: entry.text) }
layout.addWidget(entry)
layout.addWidget(button)
window.show
app.exec

这里通过 entry.setText 设置初始文本，点击按钮时通过 entry.text 获取文本框中的内容。

• 下拉框（Qt::ComboBox）：用于提供多个选项供用户选择。例如：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
layout = Qt::VBoxLayout.new(window)
combo = Qt::ComboBox.new(window)
combo.addItems(['Option 1', 'Option 2', 'Option 3'])
button = Qt::PushButton.new('Show Selection', window)
button.connect(SIGNAL('clicked()')) { Tk.messageBox(title: 'Selection', message: combo.currentText) }
layout.addWidget(combo)
layout.addWidget(button)
window.show
app.exec

通过 combo.addItems 添加选项，点击按钮时通过 combo.currentText 获取当前选中的选项。

5. 菜单和工具栏的创建

一个完整的桌面应用通常需要菜单和工具栏来提供便捷的操作入口。

5.1 Tk 的菜单和工具栏

• 菜单：Tk 中可以通过 TkMenu 类创建菜单。以下是一个简单的主菜单示例，包含一个文件菜单和一个关于菜单：

require 'tk'

root = TkRoot.new { title "Tk Menu" }
menubar = TkMenu.new(root)
root['menu'] = menubar

filemenu = TkMenu.new(menubar) { tearoff 0 }
filemenu.add_command(label: 'Open') { Tk.messageBox(title: 'File', message: 'Open command') }
filemenu.add_command(label: 'Save') { Tk.messageBox(title: 'File', message: 'Save command') }
filemenu.add_separator
filemenu.add_command(label: 'Exit') { root.destroy }
menubar.add_cascade(label: 'File', menu: filemenu)

aboutmenu = TkMenu.new(menubar) { tearoff 0 }
aboutmenu.add_command(label: 'About') { Tk.messageBox(title: 'About', message: 'This is a Tk app') }
menubar.add_cascade(label: 'About', menu: aboutmenu)

Tk.mainloop

在上述代码中，首先创建一个主菜单栏 menubar，并将其设置为根窗口的菜单。然后分别创建文件菜单 filemenu 和关于菜单 aboutmenu，在文件菜单中添加打开、保存、退出等命令，并通过 add_separator 添加分隔线。最后通过 add_cascade 将菜单添加到主菜单栏中。

• 工具栏：Tk 本身没有直接提供工具栏的类，但可以通过组合按钮等组件来模拟工具栏。例如：

require 'tk'

root = TkRoot.new { title "Tk Toolbar" }
toolbar = TkFrame.new(root) { relief :raised; borderwidth 2 }
button1 = TkButton.new(toolbar) { text 'Open'; command { Tk.messageBox(title: 'Tool', message: 'Open tool') } }
button2 = TkButton.new(toolbar) { text 'Save'; command { Tk.messageBox(title: 'Tool', message: 'Save tool') } }
button1.pack(side: :left, padx: 2, pady: 2)
button2.pack(side: :left, padx: 2, pady: 2)
toolbar.pack(side: :top, fill: :x)
Tk.mainloop

这里通过 TkFrame 创建一个类似工具栏的容器，在其中添加按钮并进行布局。

5.2 Qt 的菜单和工具栏

• 菜单：Qt 中通过 Qt::MenuBar 和 Qt::Menu 类来创建菜单。例如：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::MainWindow.new
menubar = window.menuBar
filemenu = menubar.addMenu('File')
open_action = filemenu.addAction('Open')
save_action = filemenu.addAction('Save')
exit_action = filemenu.addAction('Exit')
exit_action.connect(SIGNAL('triggered()')) { app.quit }

aboutmenu = menubar.addMenu('About')
about_action = aboutmenu.addAction('About')
about_action.connect(SIGNAL('triggered()')) { Tk.messageBox(title: 'About', message: 'This is a Qt app') }

window.show
app.exec

在这个示例中，首先获取主窗口的菜单栏 menubar，然后创建文件菜单和关于菜单，并在文件菜单中添加打开、保存、退出等动作，通过 connect 将退出动作与应用程序的退出函数连接起来。

• 工具栏：Qt 提供了 Qt::ToolBar 类来创建工具栏。例如：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::MainWindow.new
toolbar = window.addToolBar('Main Toolbar')
open_icon = Qt::Icon.new('open.png') # 假设存在 open.png 图标文件
open_action = toolbar.addAction(open_icon, 'Open')
save_icon = Qt::Icon.new('save.png')
save_action = toolbar.addAction(save_icon, 'Save')

window.show
app.exec

这里通过 window.addToolBar 创建一个工具栏，并添加带有图标的打开和保存动作。

6. 事件处理

桌面应用需要处理各种用户事件，如鼠标点击、键盘输入等。

6.1 Tk 的事件处理

Tk 中的组件可以绑定各种事件。例如，为按钮绑定鼠标进入和离开事件：

require 'tk'

root = TkRoot.new { title "Tk Event Handling" }
button = TkButton.new(root) { text 'Hover Me' }
button.bind('<Enter>') { button['bg'] = 'lightblue' }
button.bind('<Leave>') { button['bg'] = 'white' }
button.pack
Tk.mainloop

在上述代码中，通过 bind 方法为按钮绑定了 <Enter>（鼠标进入）和 <Leave>（鼠标离开）事件，当事件发生时，分别改变按钮的背景颜色。

对于键盘事件，例如监听回车键按下：

require 'tk'

root = TkRoot.new { title "Tk Keyboard Event" }
entry = TkEntry.new(root)
entry.bind('<Return>') { Tk.messageBox(title: 'Input', message: entry.get) }
entry.pack
Tk.mainloop

这里为文本框绑定了 <Return>（回车键）事件，当用户在文本框中按下回车键时，弹出消息框显示文本框中的内容。

6.2 Qt 的事件处理

Qt 通过信号和槽机制来处理事件。例如，为按钮的点击事件绑定处理函数：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
button = Qt::PushButton.new('Click Me', window)
button.connect(SIGNAL('clicked()')) { Tk.messageBox(title: 'Click', message: 'Button clicked') }
button.show
app.exec

这里通过 connect 方法将按钮的 clicked 信号连接到一个块，当按钮被点击时，执行块中的代码弹出消息框。

对于键盘事件，可以重写窗口的 keyPressEvent 方法。例如：

require 'Qt4'

class MyWindow < Qt::Widget
  def keyPressEvent(event)
    if event.key == Qt::Key_Return
      Tk.messageBox(title: 'Input', message: 'Enter key pressed')
    end
    super(event)
  end
end

app = Qt::Application.new(ARGV)
window = MyWindow.new
window.show
app.exec

在上述代码中，定义了一个继承自 Qt::Widget 的 MyWindow 类，重写了 keyPressEvent 方法，当检测到回车键按下时，弹出消息框。

7. 与系统的交互

桌面应用有时需要与操作系统进行交互，如访问文件系统、调用系统命令等。

7.1 Tk 与系统交互

在 Tk 中，可以使用 Ruby 的标准库来实现与系统的交互。例如，使用 File 类来操作文件：

require 'tk'
require 'fileutils'

root = TkRoot.new { title "Tk File Interaction" }
button = TkButton.new(root) {
  text 'Create File'
  command {
    FileUtils.touch('test.txt')
    Tk.messageBox(title: 'File', message: 'File created')
  }
}
button.pack
Tk.mainloop

这里通过 FileUtils.touch 方法创建一个新文件，并在按钮点击时弹出消息框提示文件创建成功。

调用系统命令可以使用 system 方法。例如：

require 'tk'

root = TkRoot.new { title "Tk System Command" }
button = TkButton.new(root) {
  text 'Open Notepad'
  command { system('notepad.exe') if RUBY_PLATFORM =~ /win32/ }
}
button.pack
Tk.mainloop

上述代码在 Windows 系统下点击按钮会调用系统的记事本程序。

7.2 Qt 与系统交互

Qt 提供了 QProcess 类来执行外部程序和与系统交互。例如，创建文件：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
button = Qt::PushButton.new('Create File', window)
button.connect(SIGNAL('clicked()')) {
  process = Qt::Process.new
  process.start('touch', ['test.txt'])
  process.waitForFinished
  Tk.messageBox(title: 'File', message: 'File created')
}
button.show
app.exec

这里通过 Qt::Process 类调用 touch 命令创建文件（在类 Unix 系统下），并等待命令执行完成后弹出消息框。

调用系统命令打开默认浏览器：

require 'Qt4'

app = Qt::Application.new(ARGV)
window = Qt::Widget.new
button = Qt::PushButton.new('Open Browser', window)
button.connect(SIGNAL('clicked()')) {
  url = Qt::Url.new('https://www.example.com')
  Qt::DesktopServices.openUrl(url)
}
button.show
app.exec

通过 Qt::DesktopServices.openUrl 方法可以调用系统默认浏览器打开指定的 URL。

8. 打包和分发

完成桌面应用开发后，需要将其打包并分发给用户。

8.1 使用 Tk 应用的打包

对于 Tk 应用，可以使用 dmgbuild（在 macOS 上）或 Inno Setup（在 Windows 上）等工具进行打包。

在 macOS 上，首先确保安装了 dmgbuild，可以通过 pip install dmgbuild 安装。假设应用程序的主文件为 app.rb，可以创建一个配置文件 setup.py：

from dmgbuild import *
import plistlib

# 应用程序路径
app_path = os.path.join('dist', 'MyApp.app')

# 配置 DMG 元数据
DMG_TITLE = 'My Tk App'
DMG_FORMAT = 'UDZO'
DMG_SIZE = None
DMG_VOLUME_NAME = 'MyTkApp'

# 配置 DMG 内容
contents = [
    ('/Applications', os.path.join('..', 'Applications')),
    (app_path, os.path.basename(app_path))
]

# 配置 DMG 图标位置
icon_locations = {
    os.path.basename(app_path): (100, 150),
    os.path.join('..', 'Applications'): (300, 150)
}

# 构建 DMG
build_dmg('dist/MyTkApp.dmg', DMG_TITLE, app_path,
          format=DMG_FORMAT, size=DMG_SIZE,
          volume_name=DMG_VOLUME_NAME,
          contents=contents, icon_locations=icon_locations)

然后在终端中运行 python setup.py 来生成 DMG 安装包。

在 Windows 上，使用 Inno Setup，需要先安装 Inno Setup 软件。创建一个脚本文件 setup.iss：

[Setup]
AppName=My Tk App
AppVersion=1.0
DefaultDirName={pf}\My Tk App
OutputDir=dist
OutputBaseFilename=MyTkAppSetup
SetupIconFile=icon.ico ; 假设存在 icon.ico 图标文件

[Files]
Source: "app.rb"; DestDir: "{app}"; Flags: ignoreversion
Source: "ruby.exe"; DestDir: "{app}"; Flags: ignoreversion ; 假设 ruby.exe 在同一目录
Source: "tk.dll"; DestDir: "{app}"; Flags: ignoreversion ; 如果需要 tk.dll

[Icons]
Name: "{group}\My Tk App"; Filename: "{app}\ruby.exe"; Parameters: "app.rb"

然后在 Inno Setup 中打开这个脚本文件并编译，生成 Windows 安装包。

8.2 使用 Qt 应用的打包

对于 Qt 应用，在 macOS 上，可以使用 macdeployqt 工具。假设应用程序的可执行文件为 MyApp，在终端中运行 macdeployqt MyApp.app，该工具会自动将应用程序所需的 Qt 库和资源复制到应用程序包中，生成一个可分发的 .app 文件。

在 Windows 上，可以使用 windeployqt 工具。同样假设应用程序的可执行文件为 MyApp.exe，在终端中运行 windeployqt MyApp.exe，它会将所需的 Qt 库和资源复制到应用程序目录，然后可以使用工具如 Inno Setup 进一步打包成安装程序。例如，创建一个 setup.iss 脚本文件：

[Setup]
AppName=My Qt App
AppVersion=1.0
DefaultDirName={pf}\My Qt App
OutputDir=dist
OutputBaseFilename=MyQtAppSetup
SetupIconFile=icon.ico ; 假设存在 icon.ico 图标文件

[Files]
Source: "MyApp.exe"; DestDir: "{app}"; Flags: ignoreversion
Source: "*.dll"; DestDir: "{app}"; Flags: ignoreversion ; 复制所有 DLL 文件
Source: "resources.qrc"; DestDir: "{app}"; Flags: ignoreversion ; 如果有资源文件

[Icons]
Name: "{group}\My Qt App"; Filename: "{app}\MyApp.exe"

然后在 Inno Setup 中编译这个脚本文件，生成 Windows 安装包。

通过以上步骤，我们可以使用 Ruby 及其相关库来开发功能丰富、用户友好的桌面应用程序，并将其打包分发给用户。无论是使用 Tk 还是 Qt，Ruby 都为桌面应用开发提供了一种高效且灵活的方式。