如何基于PostScript开发基础GUI应用？已获相关工具求指导

Hey Vasanth, let's walk through how to build a basic PostScript (PS) GUI app starting from where you are right now. First, let's tackle the ImageMagick issue since you already have it installed, then move to selecting tools and building your app.

ImageMagick relies on Ghostscript to handle PostScript files—chances are that's why it's not running correctly. Here's how to troubleshoot:

• Run convert -version in your terminal. Look for a line like Delegates (built-in): ... gs ...—if Ghostscript isn't listed, you need to install it first.
• Once Ghostscript is installed, test ImageMagick with a simple PS command: convert input.ps output.png. If this works, you can use it for PS rendering/export in your GUI later.

From the tools you found, Cairo or Pslib are your best bets for building a GUI app:

• Cairo: A cross-platform 2D graphics library that natively supports generating PostScript. It integrates seamlessly with most GUI frameworks (GTK, Qt, etc.) and has bindings for languages like Python, C++, and Rust. This is the most flexible option for combining GUI rendering with PS generation.
• Pslib: A lightweight library specifically designed for creating PostScript files. It's great if you need fine-grained control over PS elements, but you'll need to handle GUI rendering separately (e.g., using a framework to display the generated PS).

To wrap your PS logic in a GUI, pick a framework that works with your chosen library:

• If you go with Cairo:
  • For Python: Use PyQt/PySide or PyGTK—both have direct bindings for Cairo (Pycairo) and let you render PS content directly in window widgets.
  • For C++: Use GTK+ (Cairo is its default renderer) or Qt (with QtCairo integration).
• If you go with Pslib:
  • You'll need a framework that can display PS files (e.g., using ImageMagick/Ghostscript to convert PS to a bitmap for preview, or embedding a PS viewer component).

Let's use Python + PyQt + Pycairo for a quick prototype—it's easy to iterate with:

1. First, install dependencies:

   pip install pyqt5 pycairo
   

2. Here's a simple app that generates a PS file and previews it in a window:

   import cairo
   from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget
   from PyQt5.QtGui import QImage, QPainter
   from PyQt5.QtCore import Qt
   
   class PSApp(QMainWindow):
       def __init__(self):
           super().__init__()
           self.setWindowTitle("Basic PS GUI Tool")
           self.setGeometry(100, 100, 800, 600)
           self.render_area = QWidget()
           self.setCentralWidget(self.render_area)
           
           # Generate a sample PS file and render it to the GUI
           self.create_and_render_ps()
   
       def create_and_render_ps(self):
           # Create a PostScript surface (A4 size: 595x842 points)
           ps_surface = cairo.PSSurface("sample_output.ps", 595, 842)
           ctx = cairo.Context(ps_surface)
   
           # Draw basic shapes/text in PS
           ctx.set_source_rgb(0.2, 0.6, 0.8)
           ctx.rectangle(100, 100, 300, 200)
           ctx.fill()
   
           ctx.set_source_rgb(1, 1, 1)
           ctx.select_font_face("Sans", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_BOLD)
           ctx.set_font_size(32)
           ctx.move_to(150, 220)
           ctx.show_text("My First PS GUI!")
   
           ps_surface.finish()  # Save the PS file
   
           # Render the PS content to an image surface for GUI preview
           self.image_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 800, 600)
           img_ctx = cairo.Context(self.image_surface)
           img_ctx.set_source_rgb(1, 1, 1)
           img_ctx.paint()
           img_ctx.scale(1.35, 1.35)  # Scale to fit the window
           img_ctx.set_source_surface(ps_surface, 0, 0)
           img_ctx.paint()
   
       def paintEvent(self, event):
           painter = QPainter(self.render_area)
           painter.setRenderHint(QPainter.Antialiasing)
           # Convert Cairo surface to QImage for Qt rendering
           q_img = QImage(
               self.image_surface.get_data(),
               self.image_surface.get_width(),
               self.image_surface.get_height(),
               QImage.Format_ARGB32
           )
           painter.drawImage(0, 0, q_img)
   
   if __name__ == "__main__":
       app = QApplication([])
       window = PSApp()
       window.show()
       app.exec_()
   

3. Run this script—you'll get a window showing your PS content, plus a sample_output.ps file saved locally.

If you want to add features like converting ASCII text to PS, you can call GNU Enscript or a2ps from your app using Python's subprocess module:

import subprocess

def convert_text_to_ps(input_text_path, output_ps_path):
    # Use Enscript to convert ASCII to PS
    subprocess.run(["enscript", input_text_path, "-o", output_ps_path])

You can add a file picker in your GUI to let users select text files, then call this function to generate PS.

• To validate your generated PS files, use Ghostscript: gs -dNOPAUSE -dBATCH -sDEVICE=nullpage your_file.ps—if there are no errors, the PS is valid.
• For more advanced PS features (like fonts or vector graphics), refer to the Cairo or Pslib documentation—they have detailed guides for working with PostScript elements.

内容的提问来源于stack exchange，提问作者vasanth