home *** CD-ROM | disk | FTP | other *** search
/ tusportal.tus.k12.pa.us / tusportal.tus.k12.pa.us.tar / tusportal.tus.k12.pa.us / Wyse / latest-image.raw / 0.img / usr / lib / pygtk / 2.0 / demos / changedisplay.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2010-05-11  |  15KB  |  372 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. '''Change Display
  5.  
  6. Demonstrates migrating a window between different displays and
  7. screens. A display is a mouse and keyboard with some number of
  8. associated monitors. A screen is a set of monitors grouped
  9. into a single physical work area. The neat thing about having
  10. multiple displays is that they can be on a completely separate
  11. computers, as long as there is a network connection to the
  12. computer where the application is running.
  13.  
  14. Only some of the windowing systems where GTK+ runs have the
  15. concept of multiple displays and screens. (The X Window System
  16. is the main example.) Other windowing systems can only
  17. handle one keyboard and mouse, and combine all monitors into
  18. a single screen.
  19.  
  20. This is a moderately complex example, and demonstrates:
  21.  
  22. - Tracking the currently open displays and screens
  23. - Changing the screen for a window
  24. - Letting the user choose a window by clicking on it
  25. - Using GtkListStore and GtkTreeView
  26. - Using GtkDialog
  27. '''
  28. import gtk
  29. import gobject
  30. (DISPLAY_COLUMN_NAME, DISPLAY_COLUMN_DISPLAY, DISPLAY_NUM_COLUMNS) = range(3)
  31. (SCREEN_COLUMN_NUMBER, SCREEN_COLUMN_SCREEN, SCREEN_NUM_COLUMNS) = range(3)
  32.  
  33. def find_toplevel_at_pointer(display):
  34.     ''' Finds the toplevel window under the mouse pointer, if any.
  35.     '''
  36.     pointer_window = display.get_window_at_pointer()[0]
  37.     if pointer_window:
  38.         widget = pointer_window.get_user_data()
  39.     
  40.     if not widget or widget.get_toplevel():
  41.         pass
  42.  
  43.  
  44. class QueryForToplevel(gtk.Window):
  45.     ''' Asks the user to click on a window, then waits for them click
  46.         the mouse. When the mouse is released, returns the toplevel
  47.         window under the pointer, or NULL, if there is none.
  48.     '''
  49.     
  50.     def __init__(self, screen, prompt):
  51.         gtk.Window.__init__(self, gtk.WINDOW_POPUP)
  52.         self.set_screen(screen)
  53.         self.set_modal(True)
  54.         self.set_position(gtk.WIN_POS_CENTER)
  55.         frame = gtk.Frame()
  56.         frame.set_shadow_type(gtk.SHADOW_OUT)
  57.         self.add(frame)
  58.         label = gtk.Label(prompt)
  59.         label.set_padding(10, 10)
  60.         frame.add(label)
  61.         self.show_all()
  62.  
  63.     
  64.     def run(self):
  65.         display = self.get_screen().get_display()
  66.         cursor = gtk.gdk.Cursor(display, gtk.gdk.CROSSHAIR)
  67.         main_context = gobject.main_context_default()
  68.         if gtk.gdk.pointer_grab(self.window, False, gtk.gdk.BUTTON_RELEASE_MASK, None, cursor) == gtk.gdk.GRAB_SUCCESS:
  69.             self.query_clicked = False
  70.             self.connect('button-release-event', self.button_release_event_cb)
  71.             while self.query_clicked is False:
  72.                 main_context.iteration(True)
  73.             toplevel = find_toplevel_at_pointer(display)
  74.             if toplevel == self:
  75.                 toplevel = None
  76.             
  77.         
  78.         self.destroy()
  79.         gtk.gdk.flush()
  80.         return toplevel
  81.  
  82.     
  83.     def button_release_event_cb(self, winref, event):
  84.         self.query_clicked = True
  85.         return True
  86.  
  87.  
  88.  
  89. class LeftAlignButton(gtk.Button):
  90.     ''' If we have a stack of buttons, it often looks better if their contents
  91.         are left-aligned, rather than centered. This class creates a button
  92.         and left-aligns it contents.
  93.     '''
  94.     
  95.     def __init__(self, label):
  96.         gtk.Button.__init__(self, label)
  97.         child = self.get_children()[0]
  98.         child.set_alignment(0, 0.5)
  99.  
  100.  
  101.  
  102. class ChangeDisplayDemo(gtk.Dialog):
  103.     size_group = None
  104.     display_model = None
  105.     screen_model = None
  106.     screen_selection = None
  107.     current_display = None
  108.     current_screen = None
  109.     
  110.     def __init__(self, parent = None):
  111.         gtk.Dialog.__init__(self, 'Change Screen or display', parent, gtk.DIALOG_NO_SEPARATOR, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE, 'Change', gtk.RESPONSE_OK))
  112.         self.set_default_size(300, 400)
  113.         
  114.         try:
  115.             self.set_screen(parent.get_screen())
  116.         except AttributeError:
  117.             self.connect('destroy', (lambda : gtk.main_quit()))
  118.  
  119.         self.connect('response', self.response_cb)
  120.         self.connect('destroy', self.destroy_cb)
  121.         vbox = gtk.VBox(False, 5)
  122.         vbox.set_border_width(8)
  123.         self.vbox.pack_start(vbox, True, True, 0)
  124.         frame = self._ChangeDisplayDemo__create_display_frame()
  125.         vbox.pack_start(frame, True, True, 0)
  126.         frame = self._ChangeDisplayDemo__create_screen_frame()
  127.         vbox.pack_start(frame, True, True, 0)
  128.         self._ChangeDisplayDemo__initialize_displays()
  129.         self.show_all()
  130.  
  131.     
  132.     def __initialize_displays(self):
  133.         """ Adds all currently open displays to our list of displays,
  134.             and set up a signal connection so that we'll be notified
  135.             when displays are opened in the future as well.
  136.         """
  137.         manager = gtk.gdk.display_manager_get()
  138.         displays = manager.list_displays()
  139.         for item in displays:
  140.             self.add_display(item)
  141.         
  142.         id = manager.connect('display_opened', self.display_opened_cb)
  143.         manager.set_data('user-callback', id)
  144.  
  145.     
  146.     def __create_frame(self, title):
  147.         ''' This function is used both for creating the "Display" and
  148.             "Screen" frames, since they have a similar structure. The
  149.             caller hooks up the right context for the value returned
  150.             in tree_view, and packs any relevant buttons into button_vbox.
  151.         '''
  152.         frame = gtk.Frame(title)
  153.         hbox = gtk.HBox(False, 8)
  154.         hbox.set_border_width(8)
  155.         frame.add(hbox)
  156.         scrollwin = gtk.ScrolledWindow()
  157.         scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
  158.         scrollwin.set_shadow_type(gtk.SHADOW_IN)
  159.         hbox.pack_start(scrollwin, True, True, 0)
  160.         tree_view = gtk.TreeView()
  161.         tree_view.set_headers_visible(False)
  162.         scrollwin.add(tree_view)
  163.         selection = tree_view.get_selection()
  164.         selection.set_mode(gtk.SELECTION_BROWSE)
  165.         button_vbox = gtk.VBox(False, 5)
  166.         hbox.pack_start(button_vbox, False, False, 0)
  167.         if self.size_group is None:
  168.             self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
  169.         
  170.         self.size_group.add_widget(button_vbox)
  171.         return (frame, tree_view, button_vbox)
  172.  
  173.     
  174.     def __create_display_frame(self):
  175.         ''' Creates the "Display" frame in the main window.
  176.         '''
  177.         (frame, tree_view, button_vbox) = self._ChangeDisplayDemo__create_frame('Display')
  178.         button = LeftAlignButton('_Open...')
  179.         button.connect('clicked', self.open_display_cb)
  180.         button_vbox.pack_start(button, False, False, 0)
  181.         button = LeftAlignButton('_Close')
  182.         button.connect('clicked', self.close_display_cb)
  183.         button_vbox.pack_start(button, False, False, 0)
  184.         self.display_model = gtk.ListStore(str, object)
  185.         tree_view.set_model(self.display_model)
  186.         column = gtk.TreeViewColumn('Name', gtk.CellRendererText(), text = DISPLAY_COLUMN_NAME)
  187.         tree_view.append_column(column)
  188.         selection = tree_view.get_selection()
  189.         selection.connect('changed', self.display_changed_cb)
  190.         return frame
  191.  
  192.     
  193.     def __create_screen_frame(self):
  194.         ''' Creates the "Screen" frame in the main window.
  195.         '''
  196.         (frame, tree_view, button_vbox) = self._ChangeDisplayDemo__create_frame('Screen')
  197.         self.screen_model = gtk.ListStore(int, object)
  198.         tree_view.set_model(self.screen_model)
  199.         column = gtk.TreeViewColumn('Number', gtk.CellRendererText(), text = SCREEN_COLUMN_NUMBER)
  200.         tree_view.append_column(column)
  201.         self.screen_selection = tree_view.get_selection()
  202.         self.screen_selection.connect('changed', self.screen_changed_cb)
  203.         return frame
  204.  
  205.     
  206.     def query_change_display(self):
  207.         ''' Prompts the user for a toplevel window to move, and then moves
  208.             that window to the currently selected display
  209.         '''
  210.         screen = self.window.get_screen()
  211.         toplevel = QueryForToplevel(screen, 'Please select the toplevel\nto move to the new screen').run()
  212.         if toplevel is not None:
  213.             toplevel.set_screen(self.current_screen)
  214.         else:
  215.             screen.get_display().beep()
  216.  
  217.     
  218.     def response_cb(self, dialog, response_id):
  219.         ''' Called when the user clicks on a button in our dialog or
  220.             closes the dialog through the window manager. Unless the
  221.             "Change" button was clicked, we destroy the dialog.
  222.         '''
  223.         if response_id == gtk.RESPONSE_OK:
  224.             self.query_change_display()
  225.         else:
  226.             dialog.destroy()
  227.  
  228.     
  229.     def open_display_cb(self, button):
  230.         ''' Called when the user clicks on "Open..." in the display
  231.             frame. Prompts for a new display, and then opens a connection
  232.             to that display.
  233.         '''
  234.         dialog = gtk.Dialog('Open Display', self, gtk.DIALOG_MODAL, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
  235.         dialog.set_default_response(gtk.RESPONSE_OK)
  236.         display_entry = gtk.Entry()
  237.         display_entry.set_activates_default(True)
  238.         dialog_label = gtk.Label('Please enter the name of\nthe new display\n')
  239.         dialog.vbox.add(dialog_label)
  240.         dialog.vbox.add(display_entry)
  241.         display_entry.grab_focus()
  242.         dialog.show_all()
  243.         result = None
  244.         while result is None:
  245.             response_id = dialog.run()
  246.             if response_id != gtk.RESPONSE_OK:
  247.                 break
  248.             
  249.             new_screen_name = display_entry.get_chars(0, -1)
  250.             print new_screen_name
  251.             if new_screen_name != '':
  252.                 result = gtk.gdk.Display(new_screen_name)
  253.                 if result is None:
  254.                     error_msg = "Can't open display :\n\t%s\nplease try another one\n" % (new_screen_name,)
  255.                     dialog_label.set_text(error_msg)
  256.                 
  257.             result is None
  258.         dialog.destroy()
  259.  
  260.     
  261.     def close_display_cb(self, button):
  262.         ''' Called when the user clicks on the "Close" button in the
  263.             "Display" frame. Closes the selected display.
  264.         '''
  265.         if self.current_display:
  266.             self.current_display.close()
  267.         
  268.  
  269.     
  270.     def display_changed_cb(self, selection):
  271.         ''' Called when the selected row in the display list changes.
  272.             Updates info.current_display, then refills the list of
  273.             screens.
  274.         '''
  275.         (model, iter) = selection.get_selected()
  276.         if iter is not None:
  277.             self.current_display = model.get_value(iter, DISPLAY_COLUMN_DISPLAY)
  278.         else:
  279.             self.current_display = None
  280.         self.fill_screens()
  281.  
  282.     
  283.     def screen_changed_cb(self, selection):
  284.         ''' Called when the selected row in the sceen list changes.
  285.             Updates info->current_screen.
  286.         '''
  287.         (model, iter) = selection.get_selected()
  288.         if iter:
  289.             self.current_screen = model.get(iter, SCREEN_COLUMN_SCREEN)[0]
  290.         else:
  291.             self.current_screen = None
  292.  
  293.     
  294.     def destroy_cb(self, parent):
  295.         self.destroy_info()
  296.         if parent is None:
  297.             gtk.main_quit()
  298.         
  299.  
  300.     
  301.     def fill_screens(self):
  302.         ''' Fills in the screen list based on the current display
  303.         '''
  304.         self.screen_model.clear()
  305.         if self.current_display is not None:
  306.             n_screens = self.current_display.get_n_screens()
  307.             for i in range(n_screens):
  308.                 screen = self.current_display.get_screen(i)
  309.                 iter = self.screen_model.append()
  310.                 self.screen_model.set(iter, SCREEN_COLUMN_NUMBER, i, SCREEN_COLUMN_SCREEN, screen)
  311.                 if i == 0:
  312.                     self.screen_selection.select_iter(iter)
  313.                     continue
  314.             
  315.         
  316.  
  317.     
  318.     def display_closed_cb(self, display, is_error, info):
  319.         ''' Called when one of the currently open displays is closed.
  320.             Remove it from our list of displays.
  321.         '''
  322.         iter = self.display_model.get_iter_first()
  323.         while iter:
  324.             tmp_display = self.display_model.get_value(iter, DISPLAY_COLUMN_DISPLAY)
  325.             if tmp_display == display:
  326.                 info.display_model.remove(iter)
  327.                 break
  328.             
  329.             iter = info.display_model.iter_next()
  330.  
  331.     
  332.     def add_display(self, display):
  333.         ''' Adds a new display to our list of displays, and connects
  334.             to the "closed" signal so that we can remove it from the
  335.             list of displays again.
  336.         '''
  337.         name = display.get_name()
  338.         iter = self.display_model.append()
  339.         self.display_model.set(iter, DISPLAY_COLUMN_NAME, name, DISPLAY_COLUMN_DISPLAY, display)
  340.         id = display.connect('closed', self.display_closed_cb)
  341.         display.set_data('user-callback', id)
  342.  
  343.     
  344.     def display_opened_cb(self, manager, display):
  345.         ''' Called when a new display is opened
  346.         '''
  347.         self.add_display(display)
  348.  
  349.     
  350.     def destroy_info(self):
  351.         ''' Cleans up when the toplevel is destroyed; we remove the
  352.             connections we use to track currently open displays.
  353.         '''
  354.         manager = gtk.gdk.display_manager_get()
  355.         displays = manager.list_displays()
  356.         id = manager.get_data('user-callback')
  357.         manager.disconnect(id)
  358.         for tmp_list in displays:
  359.             id = tmp_list.get_data('user-callback')
  360.             tmp_list.disconnect(id)
  361.         
  362.  
  363.  
  364.  
  365. def main():
  366.     ChangeDisplayDemo()
  367.     gtk.main()
  368.  
  369. if __name__ == '__main__':
  370.     main()
  371.  
  372.