text: """
  Skeleton example of a Ginga local plugin called 'MyLocalPlugin'
  
  To enable it, run ginga with the command
      $ ginga --plugins=MyLocalPlugin
  
  it will then be available from the "Operations" button.
  
  """
  
  from ginga import GingaPlugin
  from ginga.misc import Widgets
  
  # import any other modules you want here--it's a python world!
  
  class MyLocalPlugin(GingaPlugin.LocalPlugin):
  
      def __init__(self, fv, fitsimage):
          """
          This method is called when the plugin is loaded for the  first
          time.  ``fv`` is a reference to the Ginga (reference viewer) shell
          and ``fitsimage`` is a reference to the specific ImageViewCanvas
          object associated with the channel on which the plugin is being
          invoked.
          You need to call the superclass initializer and then do any local
          initialization.
          """
          super(MyLocalPlugin, self).__init__(fv, fitsimage)
  
          # your local state and initialization code goes here
  
      def build_gui(self, container):
          """
          This method is called when the plugin is invoked.  It builds the
          GUI used by the plugin into the widget layout passed as
          ``container``.
          This method may be called many times as the plugin is opened and
          closed for modal operations.  The method may be omitted if there
          is no GUI for the plugin.
  
          This specific example uses the GUI widget set agnostic wrappers
          to build the GUI, but you can also just as easily use explicit
          toolkit calls here if you only want to support one widget set.
          """
          top = Widgets.VBox()
          top.set_border_width(4)
  
          # this is a little trick for making plugins that work either in
          # a vertical or horizontal orientation.  It returns a box container,
          # a scroll widget and an orientation ('vertical', 'horizontal')
          vbox, sw, orientation = Widgets.get_oriented_box(container)
          vbox.set_border_width(4)
          vbox.set_spacing(2)
  
          # Take a text widget to show some instructions
          self.msgFont = self.fv.getFont("sansFont", 12)
          tw = Widgets.TextArea(wrap=True, editable=False)
          tw.set_font(self.msgFont)
          self.tw = tw
  
          # Frame for instructions and add the text widget with another
          # blank widget to stretch as needed to fill emp
          fr = Widgets.Frame("Instructions")
          vbox2 = Widgets.VBox()
          vbox2.add_widget(tw)
          vbox2.add_widget(Widgets.Label(''), stretch=1)
          fr.set_widget(vbox2)
          vbox.add_widget(fr, stretch=0)
  
          # Add a spacer to stretch the rest of the way to the end of the
          # plugin space
          spacer = Widgets.Label('')
          vbox.add_widget(spacer, stretch=1)
  
          # scroll bars will allow lots of content to be accessed
          top.add_widget(sw, stretch=1)
  
          # A button box that is always visible at the bottom
          btns = Widgets.HBox()
          btns.set_spacing(3)
  
          # Add a close button for the convenience of the user
          btn = Widgets.Button("Close")
          btn.add_callback('activated', lambda w: self.close())
          btns.add_widget(btn, stretch=0)
          btns.add_widget(Widgets.Label(''), stretch=1)
          top.add_widget(btns, stretch=0)
  
          # Add our GUI to the container
          container.add_widget(top, stretch=1)
          # NOTE: if you are building a GUI using a specific widget toolkit
          # (e.g. Qt) GUI calls, you need to extract the widget or layout
          # from the non-toolkit specific container wrapper and call on that
          # to pack your widget, e.g.:
          #cw = container.get_widget()
          #cw.addWidget(widget, stretch=1)
  
      def close(self):
          """
          Example close method.  You can use this method and attach it as a
          callback to a button that you place in your GUI to close the plugin
          as a convenience to the user.
          """
          chname = self.fv.get_channelName(self.fitsimage)
          self.fv.stop_local_plugin(chname, str(self))
          return True
          
      def start(self):
          """
          This method is called just after ``build_gui()`` when the plugin
          is invoked.  This method may be called many times as the plugin is
          opened and closed for modal operations.  This method may be omitted
          in many cases.
          """
          self.tw.set_text("""This plugin doesn't do anything interesting.""")
          self.resume()
  
      def pause(self):
          """
          This method is called when the plugin loses focus.
          It should take any actions necessary to stop handling user
          interaction events that were initiated in ``start()`` or
          ``resume()``.
          This method may be called many times as the plugin is focused
          or defocused.  It may be omitted if there is no user event handling
          to disable.
          """
          pass
  
      def resume(self):
          """
          This method is called when the plugin gets focus. 
          It should take any actions necessary to start handling user
          interaction events for the operations that it does.
          This method may be called many times as the plugin is focused or
          defocused.  The method may be omitted if there is no user event
          handling to enable. 
          """
          pass
          
      def stop(self):
          """
          This method is called when the plugin is stopped. 
          It should perform any special clean up necessary to terminate
          the operation.  The GUI will be destroyed by the plugin manager
          so there is no need for the stop method to do that.
          This method may be called many  times as the plugin is opened and
          closed for modal operations, and may be omitted if there is no
          special cleanup required when stopping.
          """
          pass
          
      def redo(self):
          """
          This method is called when the plugin is active and a new
          image is loaded into the associated channel.  It can optionally
          redo the current operation on the new image.  This method may be
          called many times as new images are loaded while the plugin is
          active.  This method may be omitted.
          """
          pass
      
      def __str__(self):
          """
          This method should be provided and should return the lower case
          name of the plugin.
          """
          return 'mylocalplugin'
  
  