wxruby3 0.9.0.pre.beta.2-x64-mingw-ucrt-3.2-3.2.2

data/lib/wx/doc/gen/popup_window.rb

@@ -0,0 +1,93 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  PU_CONTAINS_CONTROLS = 1
+  
+  # A special kind of top level window used for popup menus, combobox popups and such.
+  # === Styles
+  # 
+  # This class supports the following styles:
+  #  
+  # - {Wx::PU_CONTAINS_CONTROLS}: By default in {Wx::MSW}, a popup window will not take focus from its parent window. However many standard controls, including common ones such as {Wx::TextCtrl}, need focus to function correctly and will not work when placed on a default popup. This flag can be used to make the popup take focus and let all controls work but at the price of not allowing the parent window to keep focus while the popup is shown, which can also be sometimes desirable. This style is currently only implemented in MSW and simply does nothing under the other platforms (it's new since wxWidgets 3.1.3). 
+  # 
+  # === 
+  # 
+  # Category:  Managed Windows
+  # @see Wx::Dialog
+  # @see  Wx::Frame 
+  # 
+  # 
+  class PopupWindow < NonOwnedWindow
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [PopupWindow]
+    # @overload initialize(parent, flags=Wx::BORDER_NONE)
+    #   Constructor.
+    #   @param parent [Wx::Window] 
+    #   @param flags [Integer] 
+    #   @return [PopupWindow]
+    def initialize(*args) end
+    
+    # Create method for two-step creation.
+    # @param parent [Wx::Window] 
+    # @param flags [Integer] 
+    # @return [true,false]
+    def create(parent, flags=Wx::BORDER_NONE) end
+    
+    # Move the popup window to the right position, i.e. such that it is entirely visible.
+    # The popup is positioned at ptOrigin + size if it opens below and to the right (default), at ptOrigin - sizePopup if it opens above and to the left etc.
+    # @param ptOrigin [Array(Integer, Integer), Wx::Point]  Must be given in screen coordinates!
+    # @param sizePopup [Array(Integer, Integer), Wx::Size]  The size of the popup window
+    # @return [void]
+    def position(ptOrigin, sizePopup) end
+    
+  end # PopupWindow
+  
+  # A {Wx::PopupWindow} which disappears automatically when the user clicks mouse outside it or if it loses focus in any other way.
+  # This window can be useful for implementing custom combobox-like controls for example.
+  # === 
+  # 
+  # Category:  Managed Windows
+  # @see Wx::PopupWindow 
+  # 
+  # 
+  class PopupTransientWindow < PopupWindow
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   @return [PopupTransientWindow]
+    # @overload initialize(parent, flags=Wx::BORDER_NONE)
+    #   Constructor.
+    #   @param parent [Wx::Window] 
+    #   @param flags [Integer] 
+    #   @return [PopupTransientWindow]
+    def initialize(*args) end
+    
+    # Popup the window (this will show it too).
+    # If focus is non-NULL, it will be kept focused while this window is shown if supported by the current platform, otherwise the popup itself will receive focus. In any case, the popup will disappear automatically if it loses focus because of a user action.
+    # @see Wx::PopupTransientWindow#dismiss 
+    # @param focus [Wx::Window] 
+    # @return [void]
+    def popup(focus=nil) end
+    
+    # Hide the window.
+    # @return [void]
+    def dismiss; end
+    
+    # Called when a mouse is pressed while the popup is shown.
+    # Return true from here to prevent its normal processing by the popup (which consists in dismissing it if the mouse is clicked outside it).
+    # @param event [Wx::MouseEvent] 
+    # @return [true,false]
+    def process_left_down(event) end
+    
+  end # PopupTransientWindow
+  
+
+end

data/lib/wx/doc/gen/progress_dialog.rb

@@ -0,0 +1,106 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # 
+  PD_CAN_ABORT = 1
+  
+  # 
+  PD_APP_MODAL = 2
+  
+  # 
+  PD_AUTO_HIDE = 4
+  
+  # 
+  PD_ELAPSED_TIME = 8
+  
+  # 
+  PD_ESTIMATED_TIME = 16
+  
+  # 
+  PD_SMOOTH = 32
+  
+  # 
+  PD_REMAINING_TIME = 64
+  
+  # 
+  PD_CAN_SKIP = 128
+  
+  # If supported by the platform this class will provide the platform's native progress dialog, else it will simply be the {Wx::GenericProgressDialog}.
+  # 
+  # 
+  class ProgressDialog < Dialog
+  
+    # @param title [String] 
+    # @param message [String] 
+    # @param maximum [Integer] 
+    # @param parent [Wx::Window] 
+    # @param style [Integer] 
+    # @return [ProgressDialog]
+    def initialize(title, message, maximum=100, parent=nil, style=(Wx::PD_APP_MODAL|Wx::PD_AUTO_HIDE)) end
+    
+    # Returns the last value passed to the {Wx::ProgressDialog#update} function or {Wx::NOT_FOUND} if the dialog has no progress bar.
+    # @return [Integer]
+    def get_value; end
+    alias_method :value, :get_value
+    
+    # Returns the maximum value of the progress meter, as passed to the constructor or {Wx::NOT_FOUND} if the dialog has no progress bar.
+    # @return [Integer]
+    def get_range; end
+    alias_method :range, :get_range
+    
+    # Returns the last message passed to the {Wx::ProgressDialog#update} function; if you always passed {Wx::EmptyString} to {Wx::ProgressDialog#update} then the message set through the constructor is returned.
+    # @return [String]
+    def get_message; end
+    alias_method :message, :get_message
+    
+    # Like {Wx::ProgressDialog#update} but makes the gauge control run in indeterminate mode.
+    # In indeterminate mode the remaining and the estimated time labels (if present) are set to "Unknown" or to newmsg (if it's non-empty). Each call to this function moves the progress bar a bit to indicate that some progress was done.
+    # @see Wx::Gauge#pulse
+    # @see  Wx::ProgressDialog#update 
+    # @param newmsg [String] 
+    # @param skip [bool] 
+    # @return [true,false]
+    def pulse(newmsg=Wx::EMPTY_STRING, skip=nil) end
+    
+    # Can be used to continue with the dialog, after the user had clicked the "Abort" button.
+    # @return [void]
+    def resume; end
+    
+    # Changes the maximum value of the progress meter given in the constructor.
+    # This function can only be called (with a positive value) if the value passed in the constructor was positive.
+    # @param maximum [Integer] 
+    # @return [void]
+    def set_range(maximum) end
+    alias_method :range=, :set_range
+    
+    # Returns true if the "Cancel" button was pressed.
+    # Normally a Cancel button press is indicated by {Wx::ProgressDialog#update} returning false but sometimes it may be more convenient to check if the dialog was cancelled from elsewhere in the code and this function allows doing it.
+    # It always returns false if the Cancel button is not shown at all.
+    # @return [true,false]
+    def was_cancelled; end
+    
+    # Returns true if the "Skip" button was pressed.
+    # This is similar to {Wx::ProgressDialog#was_cancelled} but returns true if the "Skip" button was pressed, not the "Cancel" one.
+    # @return [true,false]
+    def was_skipped; end
+    
+    # Updates the dialog, setting the progress bar to the new value and updating the message if new one is specified.
+    # Returns true unless the "Cancel" button has been pressed.
+    # If false is returned, the application can either immediately destroy the dialog or ask the user for the confirmation and if the abort is not confirmed the dialog may be resumed with {Wx::ProgressDialog#resume} function.
+    # If value is the maximum value for the dialog, the behaviour of the function depends on whether {Wx::PD_AUTO_HIDE} was used when the dialog was created. If it was, the dialog is hidden and the function returns immediately. If it was not, the dialog becomes a modal dialog and waits for the user to dismiss it, meaning that this function does not return until this happens.
+    # Notice that if newmsg is longer than the currently shown message, the dialog will be automatically made wider to account for it. However if the new message is shorter than the previous one, the dialog doesn't shrink back to avoid constant resizes if the message is changed often. To do this and fit the dialog to its current contents you may call {Wx::ProgressDialog#fit} explicitly. However the native MSW implementation of this class does make the dialog shorter if the new text has fewer lines of text than the old one, so it is recommended to keep the number of lines of text constant in order to avoid jarring dialog size changes. You may also want to make the initial message, specified when creating the dialog, wide enough to avoid having to resize the dialog later, e.g. by appending a long string of unbreakable spaces ({Wx::String}(L'\u00a0', 100)) to it.
+    # @param value [Integer]  The new value of the progress meter. It should be less than or equal to the maximum value given to the constructor.
+    # @param newmsg [String]  The new messages for the progress dialog text, if it is empty (which is the default) the message is not changed.
+    # @param skip [bool]  If "Skip" button was pressed since last {Wx::ProgressDialog#update} call, this is set to true.
+    # @return [true,false]
+    def update(value, newmsg=Wx::EMPTY_STRING, skip=nil) end
+    
+  end # ProgressDialog
+  
+
+end

data/lib/wx/doc/gen/property_sheet_dialog.rb

@@ -0,0 +1,185 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx
+
+  # Values used by {Wx::PropertySheetDialog#set_sheet_style}.
+  # 
+  # 
+  # 
+  class PropertySheetDialogFlags < Wx::Enum
+  
+    # Uses the default look and feel for the controller window, normally a notebook except on Smartphone where a choice control is used.
+    # 
+    PROPSHEET_DEFAULT = Wx::PropertySheetDialogFlags.new(1)
+    
+    # Uses a notebook for the controller window.
+    # 
+    PROPSHEET_NOTEBOOK = Wx::PropertySheetDialogFlags.new(2)
+    
+    # Uses a toolbook for the controller window.
+    # 
+    PROPSHEET_TOOLBOOK = Wx::PropertySheetDialogFlags.new(4)
+    
+    # Uses a choicebook for the controller window.
+    # 
+    PROPSHEET_CHOICEBOOK = Wx::PropertySheetDialogFlags.new(8)
+    
+    # Uses a listbook for the controller window.
+    # 
+    PROPSHEET_LISTBOOK = Wx::PropertySheetDialogFlags.new(16)
+    
+    # Uses a button toolbox for the controller window.
+    # 
+    PROPSHEET_BUTTONTOOLBOOK = Wx::PropertySheetDialogFlags.new(32)
+    
+    # Uses a treebook for the controller window.
+    # 
+    PROPSHEET_TREEBOOK = Wx::PropertySheetDialogFlags.new(64)
+    
+    # Shrinks the dialog window to fit the currently selected page (common behaviour for property sheets on macOS).
+    # 
+    PROPSHEET_SHRINKTOFIT = Wx::PropertySheetDialogFlags.new(256)
+    
+  end # PropertySheetDialogFlags
+  
+  # This class represents a property sheet dialog: a tabbed dialog for showing settings.
+  # It is optimized to show flat tabs on PocketPC devices, and can be customized to use different controllers instead of the default notebook style.
+  # To use this class, call {Wx::PropertySheetDialog#create} from your own Create function. Then call {Wx::PropertySheetDialog#create_buttons}, and create pages, adding them to the book control. Finally call {Wx::PropertySheetDialog#layout_dialog}.
+  # For example:
+  # 
+  #   bool MyPropertySheetDialog::Create(...)
+  #   {
+  #       if (!wxPropertySheetDialog::Create(...))
+  #           return false;
+  #   
+  #       CreateButtons(wxOK|wxCANCEL|wxHELP);
+  #   
+  #       // Add page
+  #       wxPanel* panel = new wxPanel(GetBookCtrl(), ...);
+  #       GetBookCtrl()->AddPage(panel, "General");
+  #   
+  #       LayoutDialog();
+  #       return true;
+  #   }
+  # 
+  # If necessary, override {Wx::PropertySheetDialog#create_book_ctrl} and {Wx::PropertySheetDialog#add_book_ctrl} to create and add a different kind of book control. You will then need to use two-step construction for the dialog or change the style of the book control by calling {Wx::PropertySheetDialog#set_sheet_style} before calling {Wx::PropertySheetDialog#create}.
+  # The Dialogs Sample shows this class being used with notebook and toolbook controllers (for Windows-style and Mac-style settings dialogs).
+  # To make pages of the dialog scroll when the display is too small to fit the whole dialog, you can switch layout adaptation on globally with {Wx::Dialog.enable_layout_adaptation} or per dialog with {Wx::Dialog#set_layout_adaptation_mode}.
+  # For more about layout adaptation, see Automatic Scrolled Dialogs.
+  # === 
+  # 
+  # Category:  Managed Windows
+  # 
+  class PropertySheetDialog < Dialog
+  
+    # @overload initialize()
+    #   Default constructor.
+    #   Call Create if using this form of constructor.
+    #   @return [PropertySheetDialog]
+    # @overload initialize(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_DIALOG_STYLE, name=Wx::DIALOG_NAME_STR)
+    #   Constructor.
+    #   @param parent [Wx::Window] 
+    #   @param id [Integer] 
+    #   @param title [String] 
+    #   @param pos [Array(Integer, Integer), Wx::Point] 
+    #   @param size [Array(Integer, Integer), Wx::Size] 
+    #   @param style [Integer] 
+    #   @param name [String] 
+    #   @return [PropertySheetDialog]
+    def initialize(*args) end
+    
+    # Override this if you wish to add the book control in a way different from the standard way (for example, using different spacing).
+    # @param sizer [Wx::Sizer] 
+    # @return [void]
+    def add_book_ctrl(sizer) end
+    
+    # Call this from your own Create function, before adding buttons and pages.
+    # @param parent [Wx::Window] 
+    # @param id [Integer] 
+    # @param title [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [true,false]
+    def create(parent, id, title, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_DIALOG_STYLE, name=Wx::DIALOG_NAME_STR) end
+    
+    # Call this to create the buttons for the dialog.
+    # This calls {Wx::Dialog#create_button_sizer}, and the flags are the same.
+    # On PocketPC, no buttons are created.
+    # @param flags [Integer] 
+    # @return [void]
+    def create_buttons(flags=(Wx::OK|Wx::CANCEL)) end
+    
+    # Returns the book control that will contain your settings pages.
+    # @return [Wx::BookCtrlBase]
+    def get_book_ctrl; end
+    alias_method :book_ctrl, :get_book_ctrl
+    
+    # Returns the inner sizer that contains the book control and button sizer.
+    # @return [Wx::Sizer]
+    def get_inner_sizer; end
+    alias_method :inner_sizer, :get_inner_sizer
+    
+    # Set the inner sizer that contains the book control and button sizer.
+    # @param sizer [Wx::Sizer] 
+    # @return [void]
+    def set_inner_sizer(sizer) end
+    alias_method :inner_sizer=, :set_inner_sizer
+    
+    # Returns the sheet style.
+    # See {Wx::PropertySheetDialog#set_sheet_style} for allowed values.
+    # @return [Integer]
+    def get_sheet_style; end
+    alias_method :sheet_style, :get_sheet_style
+    
+    # Call this to lay out the dialog.
+    # On PocketPC, this does nothing, since the dialog will be shown full-screen, and the layout will be done when the dialog receives a size event.
+    # @param centreFlags [Integer] 
+    # @return [void]
+    def layout_dialog(centreFlags=Wx::BOTH) end
+    
+    # Sets the book control used for the dialog.
+    # You will normally not need to use this.
+    # @param bookCtrl [Wx::BookCtrlBase] 
+    # @return [void]
+    def set_book_ctrl(bookCtrl) end
+    alias_method :book_ctrl=, :set_book_ctrl
+    
+    # You can customize the look and feel of the dialog by setting the sheet style.
+    # It is a bit list of the {Wx::PropertySheetDialogFlags} values.
+    # @param style [Integer] 
+    # @return [void]
+    def set_sheet_style(style) end
+    alias_method :sheet_style=, :set_sheet_style
+    
+    # Set the border around the whole dialog.
+    # @param border [Integer] 
+    # @return [void]
+    def set_sheet_outer_border(border) end
+    alias_method :sheet_outer_border=, :set_sheet_outer_border
+    
+    # Returns the border around the whole dialog.
+    # @return [Integer]
+    def get_sheet_outer_border; end
+    alias_method :sheet_outer_border, :get_sheet_outer_border
+    
+    # Set the border around the book control only.
+    # @param border [Integer] 
+    # @return [void]
+    def set_sheet_inner_border(border) end
+    alias_method :sheet_inner_border=, :set_sheet_inner_border
+    
+    # Returns the border around the book control only.
+    # @return [Integer]
+    def get_sheet_inner_border; end
+    alias_method :sheet_inner_border, :get_sheet_inner_border
+    
+  end # PropertySheetDialog
+  
+
+end

data/lib/wx/doc/gen/prt/event_list.rb

@@ -0,0 +1,13 @@
+# ----------------------------------------------------------------------------
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# ----------------------------------------------------------------------------
+
+
+class Wx::EvtHandler
+
+  # @!group PRT Event handler methods
+  
+  # @!endgroup
+
+end

data/lib/wx/doc/gen/prt/page_setup_dialog.rb

@@ -0,0 +1,38 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::PRT
+
+  # This class represents the page setup common dialog.
+  # The page setup dialog contains controls for paper size (letter, A4, A5 etc.), orientation (landscape or portrait), and, only under Windows currently, controls for setting left, top, right and bottom margin sizes in millimetres.
+  # The exact appearance of this dialog varies among the platforms as a native dialog is used when available (currently the case for all major platforms).
+  # When the dialog has been closed, you need to query the {Wx::PRT::PageSetupDialogData} object associated with the dialog.
+  # Note that the OK and Cancel buttons do not destroy the dialog; this must be done by the application.
+  # === 
+  # 
+  # Category:  Printing Framework
+  # @see Printing Framework Overview
+  # @see  Wx::PRT::PrintDialog
+  # @see  Wx::PRT::PageSetupDialogData 
+  # 
+  # 
+  class PageSetupDialog < Object
+  
+    # Constructor.
+    # Pass a parent window, and optionally a pointer to a block of page setup data, which will be copied to the print dialog's internal data.
+    # @param parent [Wx::Window] 
+    # @param data [Wx::PageSetupDialogData] 
+    # @return [PageSetupDialog]
+    def initialize(parent, data=nil) end
+    
+    # Shows the dialog, returning {Wx::StandardID::ID_OK} if the user pressed OK, and {Wx::StandardID::ID_CANCEL} otherwise.
+    # @return [Integer]
+    def show_modal; end
+    
+  end # PageSetupDialog
+  
+
+end

data/lib/wx/doc/gen/prt/post_script_dc.rb

@@ -0,0 +1,32 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::PRT
+
+  # This defines the wxWidgets Encapsulated PostScript device context, which can write PostScript files on any platform.
+  # See {Wx::DC} for descriptions of the member functions.
+  # 
+  # == Starting a document
+  # 
+  # Document should be started with call to {Wx::PRT::PostScriptDC#start_doc} prior to calling any function to execute a drawing operation. However, some functions, like {Wx::PRT::PostScriptDC#set_font}, may be legitimately called even before {Wx::PRT::PostScriptDC#start_doc}.
+  # === 
+  # 
+  # Category:  Device Contexts
+  # 
+  class PostScriptDC < DC
+  
+    # @overload initialize()
+    #   @return [PostScriptDC]
+    # @overload initialize(printData)
+    #   Constructs a PostScript printer device context from a {Wx::PRT::PrintData} object.
+    #   @param printData [Wx::PrintData] 
+    #   @return [PostScriptDC]
+    def initialize(*args) end
+    
+  end # PostScriptDC
+  
+
+end

data/lib/wx/doc/gen/prt/preview_frame.rb

@@ -0,0 +1,39 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::PRT
+
+  # This class provides the default method of managing the print preview interface.
+  # Member functions may be overridden to replace functionality, or the class may be used without derivation.
+  # === 
+  # 
+  # Category:  Printing Framework
+  # @see Wx::PreviewCanvas
+  # @see  Wx::PreviewControlBar
+  # @see  Wx::PRT::PrintPreview 
+  # 
+  # 
+  class PreviewFrame < Frame
+  
+    # Initializes the frame elements and prepares for showing it.
+    # Calling this method is equivalent to calling {Wx::PRT::PreviewFrame#initialize_with_modality} with {Wx::PRT::PreviewFrameModalityKind::PreviewFrame_AppModal} argument, please see its documentation for more details.
+    # Please notice that this function is virtual mostly for backwards compatibility only, there is no real need to override it as it's never called by wxWidgets itself.
+    # @return [void]
+    def init; end
+    
+    # Initializes the frame elements and prepares for showing it with the given modality kind.
+    # This method creates the frame elements by calling {Wx::PRT::PreviewFrame#create_canvas} and {Wx::PRT::PreviewFrame#create_control_bar} methods (which may be overridden to customize them) and prepares to show the frame according to the value of kind parameter:
+    # - If it is {Wx::PRT::PreviewFrameModalityKind::PreviewFrame_AppModal}, all the other application windows will be disabled when this frame is shown. This is the same behaviour as that of simple {Wx::PRT::PreviewFrame#initialize}.- If it is {Wx::PRT::PreviewFrameModalityKind::PreviewFrame_WindowModal}, only the parent window of the preview frame will be disabled when it is shown.- And if it is {Wx::PRT::PreviewFrameModalityKind::PreviewFrame_NonModal}, no windows at all will be disabled while the preview is shown.
+    # 
+    # Notice that this function (or {Wx::PRT::PreviewFrame#initialize}) must be called by the application prior to showing the frame but you still must call <code>Show(true)</code> to actually show it afterwards.
+    # @param kind [PreviewFrameModalityKind]  The modality kind of preview frame.
+    # @return [void]
+    def initialize_with_modality(kind) end
+    
+  end # PreviewFrame
+  
+
+end

data/lib/wx/doc/gen/prt/print_abort_dialog.rb

@@ -0,0 +1,127 @@
+# :stopdoc:
+# This file is automatically generated by the WXRuby3 documentation 
+# generator. Do not alter this file.
+# :startdoc:
+
+
+module Wx::PRT
+
+  # 
+  PREVIEW_PRINT = 1
+  
+  # 
+  PREVIEW_PREVIOUS = 2
+  
+  # 
+  PREVIEW_NEXT = 4
+  
+  # 
+  PREVIEW_ZOOM = 8
+  
+  # 
+  PREVIEW_FIRST = 16
+  
+  # 
+  PREVIEW_LAST = 32
+  
+  # 
+  PREVIEW_GOTO = 64
+  
+  # 
+  PREVIEW_DEFAULT = 126
+  
+  # 
+  ID_PREVIEW_CLOSE = 1
+  
+  # 
+  ID_PREVIEW_NEXT = 2
+  
+  # 
+  ID_PREVIEW_PREVIOUS = 3
+  
+  # 
+  ID_PREVIEW_PRINT = 4
+  
+  # 
+  ID_PREVIEW_ZOOM = 5
+  
+  # 
+  ID_PREVIEW_FIRST = 6
+  
+  # 
+  ID_PREVIEW_LAST = 7
+  
+  # 
+  ID_PREVIEW_GOTO = 8
+  
+  # 
+  ID_PREVIEW_ZOOM_IN = 9
+  
+  # 
+  ID_PREVIEW_ZOOM_OUT = 10
+  
+  # 
+  # 
+  # 
+  # 
+  class PrinterError < Wx::Enum
+  
+    # 
+    # 
+    PRINTER_NO_ERROR = Wx::PRT::PrinterError.new(0)
+    
+    # 
+    # 
+    PRINTER_CANCELLED = Wx::PRT::PrinterError.new(1)
+    
+    # 
+    # 
+    PRINTER_ERROR = Wx::PRT::PrinterError.new(2)
+    
+  end # PrinterError
+  
+  # Preview frame modality kind.
+  # 
+  # The elements of this enum can be used with {Wx::PRT::PreviewFrame#initialize} to indicate how should the preview frame be shown.
+  # 
+  class PreviewFrameModalityKind < Wx::Enum
+  
+    # Disable all the other top level windows while the preview frame is shown.
+    # 
+    PreviewFrame_AppModal = Wx::PRT::PreviewFrameModalityKind.new(0)
+    
+    # Disable only the parent window while the preview frame is shown.
+    # 
+    PreviewFrame_WindowModal = Wx::PRT::PreviewFrameModalityKind.new(1)
+    
+    # Show the preview frame non-modally and don't disable any other windows.
+    # 
+    PreviewFrame_NonModal = Wx::PRT::PreviewFrameModalityKind.new(2)
+    
+  end # PreviewFrameModalityKind
+  
+  # The dialog created by default by the print framework that enables aborting the printing process.
+  # 
+  # 
+  class PrintAbortDialog < Dialog
+  
+    # @param parent [Wx::Window] 
+    # @param documentTitle [String] 
+    # @param pos [Array(Integer, Integer), Wx::Point] 
+    # @param size [Array(Integer, Integer), Wx::Size] 
+    # @param style [Integer] 
+    # @param name [String] 
+    # @return [PrintAbortDialog]
+    def initialize(parent, documentTitle, pos=Wx::DEFAULT_POSITION, size=Wx::DEFAULT_SIZE, style=Wx::DEFAULT_DIALOG_STYLE, name=("Wx::DIALOG")) end
+    
+    # @param currentPage [Integer] 
+    # @param totalPages [Integer] 
+    # @param currentCopy [Integer] 
+    # @param totalCopies [Integer] 
+    # @return [void]
+    def set_progress(currentPage, totalPages, currentCopy, totalCopies) end
+    
+  end # PrintAbortDialog
+  
+
+end