Ejemplo n.º 1
0
 def __init__(self):
     assert context.application.action_manager is not None
     self.start_button = 0
     # Interactive buttons (gui stuff)
     self.buttons = {}
     self.clicked_button = None
     gtk.Table.__init__(self, 2, 4)
     self.set_row_spacings(0)
     self.set_col_spacings(5)
     for index, (modifier, label) in enumerate(self.modifier_labels):
         button = InteractiveButton(label)
         button.connect("button-press-event", self.on_interactive_button_press_event)
         self.buttons[modifier] = button
         self.attach(button, index, index+1, 0, 1, xoptions=0, yoptions=0)
         label = gtk.Label("<small>%s</small>" % label)
         label.set_property("use_markup", True)
         self.attach(label, index, index+1, 1, 2, xoptions=0, yoptions=0)
     # Interactive events
     context.application.main.window.connect("key_press_event", self.key_press)
     context.application.main.window.connect("key_release_event", self.key_release)
     main = context.application.main
     main.drawing_area.add_events(
         gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK |
         gtk.gdk.BUTTON_MOTION_MASK | gtk.gdk.POINTER_MOTION_MASK
     )
     main.drawing_area.connect("button_press_event", self.button_press)
     main.drawing_area.connect("motion_notify_event", self.button_motion)
     main.drawing_area.connect("button_release_event", self.button_release)
     # Add interactive groups, and populate a dropdown menu
     self.group_menu = gtk.Menu()
     self.interactive_groups = {}
     groups = context.application.plugins.interactive_groups.values()
     groups.sort(key=(lambda g: g.order))
     for group in groups:
         self.interactive_groups[group.image_name] = group
         if group.initial_mask is not None:
             button = self.buttons[group.initial_mask]
             button.set_interactive_group(group)
         menu_item = gtk.ImageMenuItem()
         image = gtk.Image()
         image.set_from_pixbuf(load_image(group.image_name, (36, 36)))
         menu_item.set_image(image)
         label = gtk.Label(group.description)
         label.set_alignment(0.0, 0.5)
         menu_item.add(label)
         menu_item.connect("activate", self.on_menu_activate, group)
         self.group_menu.append(menu_item)
     self.group_menu.show_all()
     # Load the actions
     actions = [
         action
         for action
         in context.application.plugins.actions.itervalues()
         if action.interactive_info is not None
     ]
     actions.sort(key=(lambda a: a.interactive_info.order))
     for action in actions:
         group = self.interactive_groups[action.interactive_info.image_name]
         group.add_action(action)
Ejemplo n.º 2
0
 def __init__(self, image_name, description, initial_mask=None, order=None, authors=[]):
     # Gui related stuff
     self.image_name = image_name
     self.pixbuf = load_image(image_name, (36, 36))
     self.description = description
     self.initial_mask = initial_mask
     self.order = order
     self.authors = []
     # actions
     self.keyboard_actions = []
     self.mouse_actions = []
     self.handler_id = None
Ejemplo n.º 3
0
 def fill_menu(self,
               menu,
               on_activate,
               on_expose,
               accel_group,
               only_show_applicable=True):
     something_added = False
     for name, item in self.items:
         if isinstance(item, SubMenu):
             new_menu = gtk.Menu()
             former_added = item.fill_menu(new_menu, on_activate, on_expose,
                                           accel_group,
                                           only_show_applicable)
             if not former_added and only_show_applicable:
                 new_menu.destroy()
             else:
                 something_added = True
                 menu_item = gtk.MenuItem(name)
                 menu.append(menu_item)
                 menu_item.set_submenu(new_menu)
         elif issubclass(item, Action):
             if not only_show_applicable or item.cached_analyze_selection():
                 something_added = True
                 if item.menu_info.image_name is not None:
                     if gtk.stock_lookup(
                             item.menu_info.image_name) is not None:
                         menu_item = gtk.ImageMenuItem(
                             item.menu_info.image_name)
                         menu_item.get_child().set_label(name)
                     else:
                         menu_item = gtk.ImageMenuItem(name)
                         menu_item.get_image().set_from_pixbuf(
                             load_image(item.menu_info.image_name,
                                        (18, 18)))
                 else:
                     menu_item = gtk.MenuItem(name)
                 if item.menu_info.accel_key is not None:
                     menu_item.add_accelerator(
                         "activate", accel_group, item.menu_info.accel_key,
                         (gtk.gdk.CONTROL_MASK *
                          item.menu_info.accel_control) |
                         (gtk.gdk.SHIFT_MASK * item.menu_info.accel_shift),
                         gtk.ACCEL_VISIBLE | gtk.ACCEL_LOCKED)
                 menu.append(menu_item)
                 menu_item.connect("activate", on_activate, item)
                 if on_expose is not None:
                     menu_item.connect("expose-event", on_expose, item)
         else:
             raise AssertionError
     return something_added
Ejemplo n.º 4
0
 def __init__(self,
              image_name,
              description,
              initial_mask=None,
              order=None,
              authors=[]):
     # Gui related stuff
     self.image_name = image_name
     self.pixbuf = load_image(image_name, (36, 36))
     self.description = description
     self.initial_mask = initial_mask
     self.order = order
     self.authors = []
     # actions
     self.keyboard_actions = []
     self.mouse_actions = []
     self.handler_id = None
Ejemplo n.º 5
0
 def fill_menu(self, menu, on_activate, on_expose, accel_group, only_show_applicable=True):
     something_added = False
     for name, item in self.items:
         if isinstance(item, SubMenu):
             new_menu = gtk.Menu()
             former_added = item.fill_menu(new_menu, on_activate, on_expose, accel_group, only_show_applicable)
             if not former_added and only_show_applicable:
                 new_menu.destroy()
             else:
                 something_added = True
                 menu_item = gtk.MenuItem(name)
                 menu.append(menu_item)
                 menu_item.set_submenu(new_menu)
         elif issubclass(item, Action):
             if not only_show_applicable or item.cached_analyze_selection():
                 something_added = True
                 if item.menu_info.image_name is not None:
                     if gtk.stock_lookup(item.menu_info.image_name) is not None:
                         menu_item = gtk.ImageMenuItem(item.menu_info.image_name)
                         menu_item.get_child().set_label(name)
                     else:
                         menu_item = gtk.ImageMenuItem(name)
                         menu_item.get_image().set_from_pixbuf(
                             load_image(item.menu_info.image_name, (18, 18))
                         )
                 else:
                     menu_item = gtk.MenuItem(name)
                 if item.menu_info.accel_key is not None:
                     menu_item.add_accelerator(
                         "activate",
                         accel_group,
                         item.menu_info.accel_key,
                         (gtk.gdk.CONTROL_MASK*item.menu_info.accel_control) | (gtk.gdk.SHIFT_MASK*item.menu_info.accel_shift),
                         gtk.ACCEL_VISIBLE | gtk.ACCEL_LOCKED
                     )
                 menu.append(menu_item)
                 menu_item.connect("activate", on_activate, item)
                 if on_expose is not None:
                     menu_item.connect("expose-event", on_expose, item)
         else:
             raise AssertionError
     return something_added
Ejemplo n.º 6
0
def init_nodes(nodes):
    from reference import Reference, SpatialReference
    from zeobuilder.gui.edit_properties import EditProperties
    from zeobuilder.gui.fields_dialogs import create_tabbed_main_field
    from zeobuilder.gui.fields.mixin import ReadMixin

    dialog_fields = []

    for node in nodes.itervalues():
        node.icon = load_image(node.info.icon_name, (18, 18))
        node.reference_icon = node.icon.copy()
        Reference.overlay_icon.composite(
            node.reference_icon, 0, 0, 18, 18, 0, 0, 1.0, 1.0,
            gtk.gdk.INTERP_BILINEAR, 255
        )
        dialog_fields.extend(node.dialog_fields)

    main_field = create_tabbed_main_field(dialog_fields)
    attribute_names = set([
        dfi.field.attribute_name for dfi in dialog_fields
        if isinstance(dfi.field, ReadMixin)
    ])
    context.application.edit_properties = EditProperties(main_field, attribute_names)
Ejemplo n.º 7
0
def init_nodes(nodes):
    from reference import Reference, SpatialReference
    from zeobuilder.gui.edit_properties import EditProperties
    from zeobuilder.gui.fields_dialogs import create_tabbed_main_field
    from zeobuilder.gui.fields.mixin import ReadMixin

    dialog_fields = []

    for node in nodes.itervalues():
        node.icon = load_image(node.info.icon_name, (18, 18))
        node.reference_icon = node.icon.copy()
        Reference.overlay_icon.composite(node.reference_icon, 0, 0, 18, 18, 0,
                                         0, 1.0, 1.0, gtk.gdk.INTERP_BILINEAR,
                                         255)
        dialog_fields.extend(node.dialog_fields)

    main_field = create_tabbed_main_field(dialog_fields)
    attribute_names = set([
        dfi.field.attribute_name for dfi in dialog_fields
        if isinstance(dfi.field, ReadMixin)
    ])
    context.application.edit_properties = EditProperties(
        main_field, attribute_names)
Ejemplo n.º 8
0
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>
#
#--



from matplotlib import rcParams

rcParams["backend"] = "GTKAgg"
rcParams["font.size"] = 9
rcParams["legend.fontsize"] = 8
rcParams["axes.titlesize"] = 9
rcParams["axes.labelsize"] = 9
rcParams["xtick.labelsize"] = 9
rcParams["ytick.labelsize"] = 9
rcParams["figure.facecolor"] = "w"


# UGLY HACK: TODO report this as a bug to the matplotlib project
from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas
import gtk
from zeobuilder.gui import load_image
gtk.window_set_default_icon(load_image("zeobuilder.svg"))
# END UGLY HACK


Ejemplo n.º 9
0
# --


from zeobuilder import context
from zeobuilder.actions.composed import Interactive as InteractiveAction, UserError, CancelException
from zeobuilder.gui import load_image

import gtk.gdk, copy


__all__ = [
    "Interactive", "InteractiveGroup", "InteractiveButton", "InteractiveBar"
]


empty_pixbuf = load_image("no_action.svg", (36, 36))


class InteractiveInfo(object):
    def __init__(self, image_name, mouse=False, keyboard=False, default_position=0, order=None):
        self.image_name = image_name
        self.mouse = mouse
        self.keyboard = keyboard
        self.default_position = default_position
        self.order = order


class InteractiveGroup(object):
    def __init__(self, image_name, description, initial_mask=None, order=None, authors=[]):
        # Gui related stuff
        self.image_name = image_name
Ejemplo n.º 10
0
 def __init__(self):
     BaseDialog.__init__(self, "di_about")
     BaseDialog.init_proxies(self, ["im_logo"])
     self.im_logo.set_from_pixbuf(load_image("zeobuilder.svg", (72, 72)))
Ejemplo n.º 11
0
class Reference(Node):
    info = NodeInfo("SelectTargets")
    overlay_icon = load_image("reference.svg", (20, 20))

    def __init__(self, prefix):
        Node.__init__(self)
        self.target = None
        self.prefix = prefix
        self.icon = self.overlay_icon

    def set_target(self, target):
        if self.target is None and target is not None:
            self.define_target(target)
        elif self.target is not None and target is not None:
            self.undefine_target()
            self.define_target(target)
        elif self.target is not None and target is None:
            self.undefine_target()
        else:
            return

    #
    # Tree
    #

    def get_name(self):
        if self.target is None:
            return "Empty reference. This should never happen. Contact the authors."
        else:
            return self.prefix + ": " + self.target.name

    def set_model(self, model, parent, index):
        Node.set_model(self, model, parent, index)
        if self.target is not None:
            self.target.references.append(self)

    def unset_model(self):
        Node.unset_model(self)
        if self.target is not None:
            self.target.references.remove(self)

    #
    # Targets
    #

    def define_target(self, new_target):
        if self.target is not None:
            raise TargetError("Reference already has a target.")
        if new_target is None:
            raise TargetError("Must assign a target.")
        if not self.check_target(new_target):
            raise TargetError("Target %s not accepted." % new_target)
        self.target = new_target
        if self.model is not None:
            self.target.references.append(self)
        self.icon = self.target.reference_icon
        self.parent.define_target(self, new_target)

    def undefine_target(self):
        if self.target is None:
            raise TargetError("Reference has no target to undefine.")
        old_target = self.target
        if self.model is not None:
            old_target.references.remove(self)
        self.target = None
        self.icon = self.overlay_icon
        self.parent.undefine_target(self, old_target)

    def check_target(self, new_target):
        if isinstance(new_target, Reference): return False
        if self.parent is not None:
            return self.parent.check_target(self, new_target)
        else:
            return True
Ejemplo n.º 12
0
 def __init__(self):
     assert context.application.action_manager is not None
     self.start_button = 0
     # Interactive buttons (gui stuff)
     self.buttons = {}
     self.clicked_button = None
     gtk.Table.__init__(self, 2, 4)
     self.set_row_spacings(0)
     self.set_col_spacings(5)
     for index, (modifier, label) in enumerate(self.modifier_labels):
         button = InteractiveButton(label)
         button.connect("button-press-event",
                        self.on_interactive_button_press_event)
         self.buttons[modifier] = button
         self.attach(button, index, index + 1, 0, 1, xoptions=0, yoptions=0)
         label = gtk.Label("<small>%s</small>" % label)
         label.set_property("use_markup", True)
         self.attach(label, index, index + 1, 1, 2, xoptions=0, yoptions=0)
     # Interactive events
     context.application.main.window.connect("key_press_event",
                                             self.key_press)
     context.application.main.window.connect("key_release_event",
                                             self.key_release)
     main = context.application.main
     main.drawing_area.add_events(gtk.gdk.BUTTON_PRESS_MASK
                                  | gtk.gdk.BUTTON_RELEASE_MASK
                                  | gtk.gdk.BUTTON_MOTION_MASK
                                  | gtk.gdk.POINTER_MOTION_MASK)
     main.drawing_area.connect("button_press_event", self.button_press)
     main.drawing_area.connect("motion_notify_event", self.button_motion)
     main.drawing_area.connect("button_release_event", self.button_release)
     # Add interactive groups, and populate a dropdown menu
     self.group_menu = gtk.Menu()
     self.interactive_groups = {}
     groups = context.application.plugins.interactive_groups.values()
     groups.sort(key=(lambda g: g.order))
     for group in groups:
         self.interactive_groups[group.image_name] = group
         if group.initial_mask is not None:
             button = self.buttons[group.initial_mask]
             button.set_interactive_group(group)
         menu_item = gtk.ImageMenuItem()
         image = gtk.Image()
         image.set_from_pixbuf(load_image(group.image_name, (36, 36)))
         menu_item.set_image(image)
         label = gtk.Label(group.description)
         label.set_alignment(0.0, 0.5)
         menu_item.add(label)
         menu_item.connect("activate", self.on_menu_activate, group)
         self.group_menu.append(menu_item)
     self.group_menu.show_all()
     # Load the actions
     actions = [
         action
         for action in context.application.plugins.actions.itervalues()
         if action.interactive_info is not None
     ]
     actions.sort(key=(lambda a: a.interactive_info.order))
     for action in actions:
         group = self.interactive_groups[action.interactive_info.image_name]
         group.add_action(action)
Ejemplo n.º 13
0
# You should have received a copy of the GNU General Public License
# along with this program; if not, see <http://www.gnu.org/licenses/>
#
#--

from zeobuilder import context
from zeobuilder.actions.composed import Interactive as InteractiveAction, UserError, CancelException
from zeobuilder.gui import load_image

import gtk.gdk

__all__ = [
    "Interactive", "InteractiveGroup", "InteractiveButton", "InteractiveBar"
]

empty_pixbuf = load_image("no_action.svg", (36, 36))


class InteractiveInfo(object):
    def __init__(self,
                 image_name,
                 mouse=False,
                 keyboard=False,
                 default_position=0,
                 order=None):
        self.image_name = image_name
        self.mouse = mouse
        self.keyboard = keyboard
        self.default_position = default_position
        self.order = order
Ejemplo n.º 14
0
 def __init__(self):
     BaseDialog.__init__(self, "di_about")
     BaseDialog.init_proxies(self, ["im_logo"])
     self.im_logo.set_from_pixbuf(load_image("zeobuilder.svg", (72, 72)))