def get_media_files_panel(media_list_view, add_cb, del_cb, col_changed_cb,
hamburger_launch_pressed, filtering_cb):
# Create buttons and connect signals
add_media_b = Gtk.Button(_("Add"))
del_media_b = Gtk.Button(_("Delete"))
add_media_b.connect("clicked", add_cb, None)
del_media_b.connect("clicked", del_cb, None)
add_media_b.set_tooltip_text(_("Add Media File to Bin"))
del_media_b.set_tooltip_text(_("Delete Media File from Bin"))
hamburger_launcher = guicomponents.HamburgerPressLaunch(
hamburger_launch_pressed)
guiutils.set_margins(hamburger_launcher.widget, 2, 0, 4, 12)
columns_img = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"columns.png")
columns_launcher = guicomponents.PressLaunch(col_changed_cb,
columns_img,
w=22,
h=22)
columns_launcher.surface_y = 6
columns_launcher.widget.set_tooltip_text(
_("Number of Media File columns."))
all_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_all_files.png")
audio_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_audio_files.png")
graphics_pixbuf = cairo.ImageSurface.create_from_png(
respaths.IMAGE_PATH + "show_graphics_files.png")
video_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_video_files.png")
imgseq_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_imgseq_files.png")
pattern_pixbuf = cairo.ImageSurface.create_from_png(
respaths.IMAGE_PATH + "show_pattern_producers.png")
files_filter_launcher = guicomponents.ImageMenuLaunch(
filtering_cb, [
all_pixbuf, video_pixbuf, audio_pixbuf, graphics_pixbuf,
imgseq_pixbuf, pattern_pixbuf
], 24, 22)
files_filter_launcher.surface_x = 3
files_filter_launcher.surface_y = 4
files_filter_launcher.widget.set_tooltip_text(
_("Visible Media File types."))
gui.media_view_filter_selector = files_filter_launcher
buttons_box = Gtk.HBox(False, 1)
buttons_box.pack_start(hamburger_launcher.widget, False, False, 0)
buttons_box.pack_start(guiutils.get_pad_label(4, 4), False, False, 0)
buttons_box.pack_start(columns_launcher.widget, False, False, 0)
buttons_box.pack_start(files_filter_launcher.widget, False, False, 0)
buttons_box.pack_start(Gtk.Label(), True, True, 0)
panel = Gtk.VBox()
panel.pack_start(media_list_view, True, True, 0)
panel.pack_start(buttons_box, False, True, 0)
return panel
def get_media_files_panel(media_list_view, add_cb, del_cb, col_changed_cb,
proxy_cb, filtering_cb):
# Create buttons and connect signals
add_media_b = Gtk.Button(_("Add"))
del_media_b = Gtk.Button(_("Delete"))
add_media_b.connect("clicked", add_cb, None)
del_media_b.connect("clicked", del_cb, None)
add_media_b.set_tooltip_text(_("Add Media File to Bin"))
del_media_b.set_tooltip_text(_("Delete Media File from Bin"))
proxy_b = Gtk.Button()
proxy_b.set_image(
Gtk.Image.new_from_file(respaths.IMAGE_PATH + "proxy_button.png"))
proxy_b.connect("clicked", proxy_cb, None)
proxy_b.set_tooltip_text(_("Render Proxy Files For Selected Media"))
gui.proxy_button = proxy_b
columns_img = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"columns.png")
columns_launcher = guicomponents.PressLaunch(col_changed_cb,
columns_img,
w=22,
h=22)
columns_launcher.surface_y = 9
all_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_all_files.png")
audio_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_audio_files.png")
graphics_pixbuf = cairo.ImageSurface.create_from_png(
respaths.IMAGE_PATH + "show_graphics_files.png")
video_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_video_files.png")
imgseq_pixbuf = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"show_imgseq_files.png")
pattern_pixbuf = cairo.ImageSurface.create_from_png(
respaths.IMAGE_PATH + "show_pattern_producers.png")
files_filter_launcher = guicomponents.ImageMenuLaunch(
filtering_cb, [
all_pixbuf, video_pixbuf, audio_pixbuf, graphics_pixbuf,
imgseq_pixbuf, pattern_pixbuf
], 24, 22)
files_filter_launcher.surface_x = 3
files_filter_launcher.surface_y = 8
gui.media_view_filter_selector = files_filter_launcher
buttons_box = Gtk.HBox(False, 1)
buttons_box.pack_start(add_media_b, True, True, 0)
buttons_box.pack_start(del_media_b, True, True, 0)
buttons_box.pack_start(proxy_b, False, False, 0)
buttons_box.pack_start(guiutils.get_pad_label(4, 4), False, False, 0)
buttons_box.pack_start(columns_launcher.widget, False, False, 0)
buttons_box.pack_start(files_filter_launcher.widget, False, False, 0)
panel = Gtk.VBox()
panel.pack_start(buttons_box, False, True, 0)
panel.pack_start(media_list_view, True, True, 0)
return panel
def get_media_files_panel(media_list_view, add_cb, del_cb, col_changed_cb,
hamburger_launch_pressed, filtering_cb):
# Aug-2019 - SvdB - BB
size_adj = 1
prefs = editorpersistance.prefs
if prefs.double_track_hights:
size_adj = 2
hamburger_launcher = guicomponents.HamburgerPressLaunch(
hamburger_launch_pressed)
guiutils.set_margins(hamburger_launcher.widget, 2, 0, 4, 12)
columns_img = guiutils.get_cairo_image("columns")
columns_launcher = guicomponents.PressLaunch(col_changed_cb,
columns_img,
w=22 * size_adj,
h=22 * size_adj)
columns_launcher.surface_y = 6
columns_launcher.widget.set_tooltip_text(
_("Number of Media File columns."))
all_pixbuf = guiutils.get_cairo_image("show_all_files")
audio_pixbuf = guiutils.get_cairo_image("show_audio_files")
graphics_pixbuf = guiutils.get_cairo_image("show_graphics_files")
video_pixbuf = guiutils.get_cairo_image("show_video_files")
imgseq_pixbuf = guiutils.get_cairo_image("show_imgseq_files")
pattern_pixbuf = guiutils.get_cairo_image("show_pattern_producers")
unused_pixbuf = guiutils.get_cairo_image("show_unused_files")
files_filter_launcher = guicomponents.ImageMenuLaunch(
filtering_cb, [
all_pixbuf, video_pixbuf, audio_pixbuf, graphics_pixbuf,
imgseq_pixbuf, pattern_pixbuf, unused_pixbuf
], 24 * size_adj, 22 * size_adj)
files_filter_launcher.surface_x = 3
files_filter_launcher.surface_y = 4
files_filter_launcher.widget.set_tooltip_text(
_("Visible Media File types."))
gui.media_view_filter_selector = files_filter_launcher
bin_info = guicomponents.BinInfoPanel()
buttons_box = Gtk.HBox(False, 1)
buttons_box.pack_start(hamburger_launcher.widget, False, False, 0)
buttons_box.pack_start(guiutils.get_pad_label(4, 4), False, False, 0)
buttons_box.pack_start(columns_launcher.widget, False, False, 0)
buttons_box.pack_start(files_filter_launcher.widget, False, False, 0)
buttons_box.pack_start(Gtk.Label(), True, True, 0)
buttons_box.pack_start(bin_info, False, False, 0)
#buttons_box.pack_start(Gtk.Label(), True, True, 0)
panel = Gtk.VBox()
panel.pack_start(media_list_view, True, True, 0)
panel.pack_start(buttons_box, False, True, 0)
return (panel, bin_info)
def __init__(self, filter_object, edit_panel, filter_stack):
self.filter_object = filter_object
self.filter_header_row = FilterHeaderRow(filter_object)
self.edit_panel = edit_panel
self.edit_panel_frame = Gtk.Frame()
self.edit_panel_frame.add(edit_panel)
self.edit_panel_frame.set_shadow_type(Gtk.ShadowType.NONE)
self.filter_stack = filter_stack
self.expander = Gtk.Expander()
self.expander.set_label_widget(self.filter_header_row.widget)
self.expander.add(self.edit_panel_frame)
self.expander.set_label_fill(True)
self.expander_frame = Gtk.Frame()
self.expander_frame.add(self.expander)
self.expander_frame.set_shadow_type(Gtk.ShadowType.NONE)
guiutils.set_margins(self.expander_frame, 2, 0, 0, 0)
self.active_check = Gtk.CheckButton()
self.active_check.set_active(self.filter_object.active)
self.active_check.connect("toggled", self.toggle_filter_active)
guiutils.set_margins(self.active_check, 4, 0, 0, 0)
self.active_check_vbox = Gtk.VBox(False, 0)
self.active_check_vbox.pack_start(self.active_check, False, False, 0)
self.active_check_vbox.pack_start(Gtk.Label(), True, True, 0)
surface = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"trash.png")
trash_button = guicomponents.PressLaunch(self.trash_pressed,
surface,
w=22,
h=22)
self.trash_vbox = Gtk.VBox(False, 0)
self.trash_vbox.pack_start(trash_button.widget, False, False, 0)
self.trash_vbox.pack_start(Gtk.Label(), True, True, 0)
self.widget = Gtk.HBox(False, 0)
self.widget.pack_start(self.active_check_vbox, False, False, 0)
self.widget.pack_start(self.expander_frame, True, True, 0)
self.widget.pack_start(self.trash_vbox, False, False, 0)
self.widget.show_all()
def _display_compositor_edit_box():
# This gets called on startup before edit_frame is filled
try:
widgets.value_edit_frame.remove(widgets.value_edit_box)
except:
pass
global keyframe_editor_widgets
keyframe_editor_widgets = []
vbox = Gtk.VBox()
# Case: Empty edit frame
global compositor
if compositor == None:
widgets.empty_label = Gtk.Label(label=_("No Compositor"))
vbox.pack_start(widgets.empty_label, True, True, 0)
vbox.pack_start(Gtk.Label(), True, True, 0)
vbox.show_all()
widgets.value_edit_box = vbox
widgets.value_edit_frame.add(vbox)
return
# Case: Filled frame
compositor_name_label = Gtk.Label(label="<b>" + compositor.name + "</b>")
compositor_name_label.set_use_markup(True)
vbox.pack_start(compositor_name_label, False, False, 0)
vbox.pack_start(guicomponents.EditorSeparator().widget, False, False, 0)
# Track editor
target_combo = guicomponents.get_compositor_track_select_combo(
current_sequence().tracks[compositor.transition.b_track],
current_sequence().tracks[compositor.transition.a_track],
_target_track_changed)
target_row = Gtk.HBox()
target_row.pack_start(guiutils.get_pad_label(5, 3), False, False, 0)
target_row.pack_start(Gtk.Label(label=_("Destination Track:")), False,
False, 0)
target_row.pack_start(guiutils.get_pad_label(5, 3), False, False, 0)
target_row.pack_start(target_combo, False, False, 0)
target_row.pack_start(Gtk.Label(), True, True, 0)
vbox.pack_start(target_row, False, False, 0)
vbox.pack_start(guicomponents.EditorSeparator().widget, False, False, 0)
# Transition editors
t_editable_properties = propertyedit.get_transition_editable_properties(
compositor)
for ep in t_editable_properties:
editor_row = propertyeditorbuilder.get_editor_row(ep)
if editor_row != None: # Some properties don't have editors
vbox.pack_start(editor_row, False, False, 0)
vbox.pack_start(guicomponents.EditorSeparator().widget, False,
False, 0)
# Add keyframe editor widget to be updated for frame changes if such is created.
try:
editor_type = ep.args[propertyeditorbuilder.EDITOR]
except KeyError:
editor_type = propertyeditorbuilder.SLIDER # this is the default value
if ((editor_type == propertyeditorbuilder.KEYFRAME_EDITOR) or
(editor_type == propertyeditorbuilder.KEYFRAME_EDITOR_RELEASE)
or (editor_type == propertyeditorbuilder.KEYFRAME_EDITOR_CLIP)
or (editor_type == propertyeditorbuilder.FADE_LENGTH)
or (editor_type == propertyeditorbuilder.GEOMETRY_EDITOR)):
keyframe_editor_widgets.append(editor_row)
# Extra editors. Editable properties have already been created with "editor=no_editor"
# and will be looked up by editors from clip
editor_rows = propertyeditorbuilder.get_transition_extra_editor_rows(
compositor, t_editable_properties)
for editor_row in editor_rows:
# These are added to keyframe editor based on editor type, not based on EditableProperty type as above
# because one editor sets values for multiple EditableProperty objects
if editor_row.__class__ == keyframeeditor.RotatingGeometryEditor:
keyframe_editor_widgets.append(editor_row)
vbox.pack_start(editor_row, False, False, 0)
vbox.pack_start(guicomponents.EditorSeparator().widget, False, False,
0)
hamburger_launcher_surface = cairo.ImageSurface.create_from_png(
respaths.IMAGE_PATH + "hamburger_big.png")
hamburger_launcher = guicomponents.PressLaunch(_hamburger_launch_pressed,
hamburger_launcher_surface,
24, 24)
sl_row = guiutils.get_right_justified_box([hamburger_launcher.widget])
vbox.pack_start(sl_row, False, False, 0)
vbox.pack_start(Gtk.Label(), True, True, 0)
vbox.show_all()
scroll_window = Gtk.ScrolledWindow()
scroll_window.add_with_viewport(vbox)
scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scroll_window.show_all()
widgets.value_edit_box = scroll_window
widgets.value_edit_frame.add(scroll_window)
def effect_selection_changed():
global keyframe_editor_widgets
# Check we have clip
if clip == None:
keyframe_editor_widgets = []
return
# Check we actually have filters so we can display one.
# If not, clear previous filters from view.
if len(clip.filters) == 0:
vbox = Gtk.VBox(False, 0)
vbox.pack_start(Gtk.Label(), False, False, 0)
widgets.value_edit_frame.remove(widgets.value_edit_box)
widgets.value_edit_frame.add(vbox)
vbox.show_all()
widgets.value_edit_box = vbox
keyframe_editor_widgets = []
return
# "changed" get's called twice when adding filter and selecting last
# so we use this do this only once
if block_changed_update == True:
return
keyframe_editor_widgets = []
# Get selected row which is also index of filter in clip.filters
treeselection = widgets.effect_stack_view.treeview.get_selection()
(model, rows) = treeselection.get_selected_rows()
# If we don't get legal selection select first filter
try:
row = rows[0]
filter_index = max(row)
except:
filter_index = 0
filter_object = clip.filters[filter_index]
global current_filter_index
current_filter_index = filter_index
# Create EditableProperty wrappers for properties
editable_properties = propertyedit.get_filter_editable_properties(
clip, filter_object, filter_index, track, clip_index)
# Get editors and set them displayed
vbox = Gtk.VBox(False, 0)
try:
filter_name = translations.filter_names[filter_object.info.name]
except KeyError:
filter_name = filter_object.info.name
filter_name_label = Gtk.Label(label="<b>" + filter_name + "</b>")
filter_name_label.set_use_markup(True)
vbox.pack_start(filter_name_label, False, False, 0)
vbox.pack_start(guicomponents.EditorSeparator().widget, False, False, 0)
if len(editable_properties) > 0:
# Create editor row for each editable property
for ep in editable_properties:
editor_row = propertyeditorbuilder.get_editor_row(ep)
if editor_row == None:
continue
# Set keyframe editor widget to be updated for frame changes if such is created
try:
editor_type = ep.args[propertyeditorbuilder.EDITOR]
except KeyError:
editor_type = propertyeditorbuilder.SLIDER # this is the default value
if ((editor_type == propertyeditorbuilder.KEYFRAME_EDITOR) or
(editor_type == propertyeditorbuilder.KEYFRAME_EDITOR_RELEASE)
or
(editor_type == propertyeditorbuilder.KEYFRAME_EDITOR_CLIP)):
keyframe_editor_widgets.append(editor_row)
# if slider property is being dedited as keyrame property
if hasattr(editor_row, "is_kf_editor"):
keyframe_editor_widgets.append(editor_row)
vbox.pack_start(editor_row, False, False, 0)
if not hasattr(editor_row, "no_separator"):
vbox.pack_start(guicomponents.EditorSeparator().widget, False,
False, 0)
# Create NonMltEditableProperty wrappers for properties
non_mlteditable_properties = propertyedit.get_non_mlt_editable_properties(
clip, filter_object, filter_index)
# Extra editors. Editable properties may have already been created
# with "editor=no_editor" and now extra editors may be created to edit those
# Non mlt properties are added as these are only need with extraeditors
editable_properties.extend(non_mlteditable_properties)
editor_rows = propertyeditorbuilder.get_filter_extra_editor_rows(
filter_object, editable_properties)
for editor_row in editor_rows:
vbox.pack_start(editor_row, False, False, 0)
if not hasattr(editor_row, "no_separator"):
vbox.pack_start(guicomponents.EditorSeparator().widget, False,
False, 0)
vbox.pack_start(guiutils.pad_label(12, 12), False, False, 0)
hamburger_launcher_surface = cairo.ImageSurface.create_from_png(
respaths.IMAGE_PATH + "hamburger_big.png")
hamburger_launcher = guicomponents.PressLaunch(
_hamburger_launch_pressed, hamburger_launcher_surface, 24, 24)
sl_row = guiutils.get_left_justified_box([hamburger_launcher.widget])
vbox.pack_start(sl_row, False, False, 0)
vbox.pack_start(Gtk.Label(), True, True, 0)
else:
vbox.pack_start(Gtk.Label(label=_("No editable parameters")), True,
True, 0)
vbox.show_all()
scroll_window = Gtk.ScrolledWindow()
scroll_window.add_with_viewport(vbox)
scroll_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scroll_window.show_all()
widgets.value_edit_frame.remove(widgets.value_edit_box)
widgets.value_edit_frame.add(scroll_window)
widgets.value_edit_box = scroll_window
def _create_buttons(editor_window):
IMG_PATH = respaths.IMAGE_PATH
editor_window.big_TC = Gtk.Stack()
tc_disp = guicomponents.BigTCDisplay()
tc_entry = guicomponents.BigTCEntry()
tc_disp.widget.show()
tc_entry.widget.show()
editor_window.big_TC.add_named(tc_disp.widget, "BigTCDisplay")
editor_window.big_TC.add_named(tc_entry.widget, "BigTCEntry")
editor_window.big_TC.set_visible_child_name("BigTCDisplay")
gui.big_tc = editor_window.big_TC
surface = cairo.ImageSurface.create_from_png(IMG_PATH + "workflow.png")
editor_window.worflow_launch = guicomponents.PressLaunch(
workflow.workflow_menu_launched, surface, w=22, h=22)
editor_window.tool_selector = guicomponents.ToolSelector(
editor_window.mode_selector_pressed, m_pixbufs, 40, 22)
if editorpersistance.prefs.buttons_style == 2: # NO_DECORATIONS
no_decorations = True
else:
no_decorations = False
editor_window.zoom_buttons = glassbuttons.GlassButtonsGroup(
38, 23, 2, 8, 5)
editor_window.zoom_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "zoom_in.png"),
updater.zoom_in)
editor_window.zoom_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "zoom_out.png"),
updater.zoom_out)
editor_window.zoom_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "zoom_length.png"),
updater.zoom_project_length)
editor_window.zoom_buttons.widget.set_tooltip_text(
_("Zoom In - Mouse Middle Scroll\n Zoom Out - Mouse Middle Scroll\n Zoom Length - Mouse Middle Click"
))
editor_window.zoom_buttons.no_decorations = no_decorations
editor_window.edit_buttons = glassbuttons.GlassButtonsGroup(
32, 23, 2, 5, 5)
editor_window.edit_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "dissolve.png"),
tlineaction.add_transition_pressed)
editor_window.edit_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "cut.png"),
tlineaction.cut_pressed)
editor_window.edit_buttons.widget.set_tooltip_text(
_("Add Rendered Transition - 2 clips selected\nAdd Rendered Fade - 1 clip selected\nCut - X"
))
editor_window.edit_buttons.no_decorations = no_decorations
editor_window.edit_buttons_3 = glassbuttons.GlassButtonsGroup(
46, 23, 2, 3, 5)
editor_window.edit_buttons_3.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "splice_out.png"),
tlineaction.splice_out_button_pressed)
editor_window.edit_buttons_3.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "ripple_delete.png"),
tlineaction.ripple_delete_button_pressed)
editor_window.edit_buttons_3.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "lift.png"),
tlineaction.lift_button_pressed)
editor_window.edit_buttons_3.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "delete_range.png"),
tlineaction.delete_range_button_pressed)
editor_window.edit_buttons_3.widget.set_tooltip_text(
_("Splice Out - Delete\nRipple Delete\nLift\nDelete Range"))
editor_window.edit_buttons_3.no_decorations = no_decorations
editor_window.edit_buttons_2 = glassbuttons.GlassButtonsGroup(
44, 23, 2, 3, 5)
editor_window.edit_buttons_2.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "resync.png"),
tlineaction.resync_button_pressed)
editor_window.edit_buttons_2.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "split_audio.png"),
tlineaction.split_audio_button_pressed)
editor_window.edit_buttons_2.widget.set_tooltip_text(
_("Resync Selected\nSplit Audio"))
editor_window.edit_buttons_2.no_decorations = no_decorations
editor_window.monitor_insert_buttons = glassbuttons.GlassButtonsGroup(
44, 23, 2, 3, 5)
editor_window.monitor_insert_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "overwrite_range.png"),
tlineaction.range_overwrite_pressed)
editor_window.monitor_insert_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "overwrite_clip.png"),
tlineaction.three_point_overwrite_pressed)
editor_window.monitor_insert_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "insert_clip.png"),
tlineaction.insert_button_pressed)
editor_window.monitor_insert_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "append_clip.png"),
tlineaction.append_button_pressed)
editor_window.monitor_insert_buttons.widget.set_tooltip_text(
_("Overwrite Range\nOverwrite Clip - T\nInsert Clip - Y\nAppend Clip - U"
))
editor_window.monitor_insert_buttons.no_decorations = no_decorations
editor_window.undo_redo = glassbuttons.GlassButtonsGroup(28, 23, 2, 2, 7)
editor_window.undo_redo.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "undo.png"),
undo.do_undo_and_repaint)
editor_window.undo_redo.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "redo.png"),
undo.do_redo_and_repaint)
editor_window.undo_redo.widget.set_tooltip_text(
_("Undo - Ctrl + Z\nRedo - Ctrl + Y"))
editor_window.undo_redo.no_decorations = no_decorations
editor_window.tools_buttons = glassbuttons.GlassButtonsGroup(
30, 23, 2, 14, 7)
editor_window.tools_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "open_mixer.png"),
audiomonitoring.show_audio_monitor)
editor_window.tools_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "open_titler.png"),
titler.show_titler)
editor_window.tools_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "open_gmic.png"),
gmic.launch_gmic)
editor_window.tools_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "open_natron.png"),
toolnatron.launch_natron_animations_tool)
editor_window.tools_buttons.add_button(
cairo.ImageSurface.create_from_png(IMG_PATH + "open_renderqueue.png"),
lambda: batchrendering.launch_batch_rendering())
editor_window.tools_buttons.widget.set_tooltip_text(
_("Audio Mixer\nTitler\nG'Mic Effects\nNatron Animations\nBatch Render Queue"
))
editor_window.tools_buttons.no_decorations = True
if editorstate.audio_monitoring_available == False:
editor_window.tools_buttons.sensitive[0] = False
editor_window.tools_buttons.widget.set_tooltip_text(
_("Audio Mixer(not available)\nTitler"))
def _create_buttons(editor_window):
# Aug-2019 - SvdB - BB
prefs = editorpersistance.prefs
size_adj = 1
if prefs.double_track_hights:
size_adj = 2
editor_window.big_TC = Gtk.Stack()
tc_disp = guicomponents.BigTCDisplay()
tc_entry = guicomponents.BigTCEntry()
tc_disp.widget.show()
tc_entry.widget.show()
editor_window.big_TC.add_named(tc_disp.widget, "BigTCDisplay")
editor_window.big_TC.add_named(tc_entry.widget, "BigTCEntry")
editor_window.big_TC.set_visible_child_name("BigTCDisplay")
gui.big_tc = editor_window.big_TC
surface = guiutils.get_cairo_image("workflow")
editor_window.worflow_launch = guicomponents.PressLaunch(
workflow.workflow_menu_launched,
surface,
w=22 * size_adj,
h=22 * size_adj)
editor_window.tool_selector = guicomponents.ToolSelector(
editor_window.mode_selector_pressed, m_pixbufs, 40 * size_adj,
22 * size_adj)
if editorpersistance.prefs.buttons_style == 2: # NO_DECORATIONS
no_decorations = True
else:
no_decorations = False
# Colorized icons
if prefs.colorized_icons is True:
icon_color = "_color"
else:
icon_color = ""
# End of Colorized icons
editor_window.zoom_buttons = glassbuttons.GlassButtonsGroup(
38 * size_adj, 23 * size_adj, 2 * size_adj, 8 * size_adj, 5 * size_adj)
editor_window.zoom_buttons.add_button(
guiutils.get_cairo_image("zoom_in" + icon_color), updater.zoom_in)
editor_window.zoom_buttons.add_button(
guiutils.get_cairo_image("zoom_out" + icon_color), updater.zoom_out)
editor_window.zoom_buttons.add_button(
guiutils.get_cairo_image("zoom_length" + icon_color),
updater.zoom_project_length)
tooltips = [
_("Zoom In - Mouse Middle Scroll"),
_("Zoom Out - Mouse Middle Scroll"),
_("Zoom Length - Mouse Middle Click")
]
tooltip_runner = glassbuttons.TooltipRunner(editor_window.zoom_buttons,
tooltips)
editor_window.zoom_buttons.no_decorations = no_decorations
editor_window.edit_buttons = glassbuttons.GlassButtonsGroup(
32 * size_adj, 23 * size_adj, 2 * size_adj, 5 * size_adj, 5 * size_adj)
editor_window.edit_buttons.add_button(
guiutils.get_cairo_image("dissolve" + icon_color),
tlineaction.add_transition_pressed)
editor_window.edit_buttons.add_button(
guiutils.get_cairo_image("cut" + icon_color), tlineaction.cut_pressed)
tooltips = [
_("Add Rendered Transition - 2 clips selected\nAdd Rendered Fade - 1 clip selected"
),
_("Cut Active Tracks - X\nCut All Tracks - Shift + X")
]
tooltip_runner = glassbuttons.TooltipRunner(editor_window.edit_buttons,
tooltips)
editor_window.edit_buttons.no_decorations = no_decorations
editor_window.edit_buttons_3 = glassbuttons.GlassButtonsGroup(
46 * size_adj, 23 * size_adj, 2 * size_adj, 3 * size_adj, 5 * size_adj)
editor_window.edit_buttons_3.add_button(
guiutils.get_cairo_image("splice_out" + icon_color),
tlineaction.splice_out_button_pressed)
editor_window.edit_buttons_3.add_button(
guiutils.get_cairo_image("lift" + icon_color),
tlineaction.lift_button_pressed)
editor_window.edit_buttons_3.add_button(
guiutils.get_cairo_image("ripple_delete" + icon_color),
tlineaction.ripple_delete_button_pressed)
editor_window.edit_buttons_3.add_button(
guiutils.get_cairo_image("delete_range" + icon_color),
tlineaction.delete_range_button_pressed)
tooltips = [
_("Splice Out - Delete"),
_("Lift - Control + Delete"),
_("Ripple Delete"),
_("Range Delete")
]
tooltip_runner = glassbuttons.TooltipRunner(editor_window.edit_buttons_3,
tooltips)
editor_window.edit_buttons_3.no_decorations = no_decorations
editor_window.edit_buttons_2 = glassbuttons.GlassButtonsGroup(
44 * size_adj, 23 * size_adj, 2 * size_adj, 3 * size_adj, 5 * size_adj)
editor_window.edit_buttons_2.add_button(
guiutils.get_cairo_image("resync" + icon_color),
tlineaction.resync_button_pressed)
editor_window.edit_buttons_2.add_button(
guiutils.get_cairo_image("split_audio" + icon_color),
tlineaction.split_audio_button_pressed)
tooltips = [_("Resync Selected"), _("Split Audio")]
tooltip_runner = glassbuttons.TooltipRunner(editor_window.edit_buttons_2,
tooltips)
editor_window.edit_buttons_2.no_decorations = no_decorations
editor_window.monitor_insert_buttons = glassbuttons.GlassButtonsGroup(
44 * size_adj, 23 * size_adj, 2 * size_adj, 3 * size_adj, 5 * size_adj)
editor_window.monitor_insert_buttons.add_button(
guiutils.get_cairo_image("overwrite_range" + icon_color),
tlineaction.range_overwrite_pressed)
editor_window.monitor_insert_buttons.add_button(
guiutils.get_cairo_image("overwrite_clip" + icon_color),
tlineaction.three_point_overwrite_pressed)
editor_window.monitor_insert_buttons.add_button(
guiutils.get_cairo_image("insert_clip" + icon_color),
tlineaction.insert_button_pressed)
editor_window.monitor_insert_buttons.add_button(
guiutils.get_cairo_image("append_clip" + icon_color),
tlineaction.append_button_pressed)
tooltips = [
_("Overwrite Range"),
_("Overwrite Clip - T"),
_("Insert Clip - Y"),
_("Append Clip - U")
]
tooltip_runner = glassbuttons.TooltipRunner(
editor_window.monitor_insert_buttons, tooltips)
editor_window.monitor_insert_buttons.no_decorations = no_decorations
editor_window.undo_redo = glassbuttons.GlassButtonsGroup(
28 * size_adj, 23 * size_adj, 2 * size_adj, 2 * size_adj, 7 * size_adj)
editor_window.undo_redo.add_button(
guiutils.get_cairo_image("undo" + icon_color),
undo.do_undo_and_repaint)
editor_window.undo_redo.add_button(
guiutils.get_cairo_image("redo" + icon_color),
undo.do_redo_and_repaint)
tooltips = [_("Undo - Ctrl + Z"), _("Redo - Ctrl + Y")]
tooltip_runner = glassbuttons.TooltipRunner(editor_window.undo_redo,
tooltips)
editor_window.undo_redo.no_decorations = no_decorations
editor_window.tools_buttons = glassbuttons.GlassButtonsGroup(
30 * size_adj, 23 * size_adj, 2 * size_adj, 14 * size_adj,
7 * size_adj)
editor_window.tools_buttons.add_button(
guiutils.get_cairo_image("open_mixer" + icon_color),
audiomonitoring.show_audio_monitor)
editor_window.tools_buttons.add_button(
guiutils.get_cairo_image("open_titler" + icon_color),
titler.show_titler)
editor_window.tools_buttons.add_button(
guiutils.get_cairo_image("open_gmic" + icon_color), gmic.launch_gmic)
editor_window.tools_buttons.add_button(
guiutils.get_cairo_image("open_renderqueue" + icon_color),
lambda: batchrendering.launch_batch_rendering())
tooltips = [
_("Audio Mixer"),
_("Titler"),
_("G'Mic Effects"),
_("Batch Render Queue")
]
tooltip_runner = glassbuttons.TooltipRunner(editor_window.tools_buttons,
tooltips)
editor_window.tools_buttons.no_decorations = True
if editorstate.audio_monitoring_available == False:
editor_window.tools_buttons.sensitive[0] = False
editor_window.tools_buttons.widget.set_tooltip_text(
_("Audio Mixer(not available)\nTitler"))
def get_media_log_events_panel(events_list_view):
global widgets
actions_pixbuf = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"media_log_action.png")
group_actions_menu = guicomponents.PressLaunch(_group_action_pressed,
actions_pixbuf, 38, 22)
star_check = gtk.CheckButton()
star_check.set_active(True)
star_check.connect("clicked", lambda w: media_log_filtering_changed())
widgets.star_check = star_check
star_label = gtk.Image()
star_label.set_from_file(respaths.IMAGE_PATH + "star.png")
star_not_active_check = gtk.CheckButton()
star_not_active_check.set_active(True)
star_not_active_check.connect("clicked",
lambda w: media_log_filtering_changed())
widgets.star_not_active_check = star_not_active_check
star_not_active_label = gtk.Image()
star_not_active_label.set_from_file(respaths.IMAGE_PATH +
"star_not_active.png")
star_button = gtk.Button()
star_button.set_image(
gtk.image_new_from_file(respaths.IMAGE_PATH + "star.png"))
star_button.connect("clicked", lambda w: media_log_star_button_pressed())
no_star_button = gtk.Button()
no_star_button.set_image(
gtk.image_new_from_file(respaths.IMAGE_PATH + "star_not_active.png"))
no_star_button.connect("clicked",
lambda w: media_log_no_star_button_pressed())
widgets.group_box = gtk.HBox()
_create_group_select()
widgets.group_view_select.set_active(0)
row1 = gtk.HBox()
row1.pack_start(guiutils.get_pad_label(6, 12), False, True, 0)
row1.pack_start(group_actions_menu.widget, False, True, 0)
row1.pack_start(guiutils.get_pad_label(6, 12), False, True, 0)
row1.pack_start(widgets.group_box, False, True, 0)
row1.pack_start(guiutils.get_pad_label(6, 12), False, True, 0)
row1.pack_start(star_check, False, True, 0)
row1.pack_start(star_label, False, True, 0)
row1.pack_start(guiutils.get_pad_label(6, 12), False, True, 0)
row1.pack_start(star_not_active_check, False, True, 0)
row1.pack_start(star_not_active_label, False, True, 0)
row1.pack_start(guiutils.pad_label(12, 12), False, False, 0)
row1.pack_start(star_button, False, True, 0)
row1.pack_start(no_star_button, False, True, 0)
row1.pack_start(gtk.Label(), True, True, 0)
widgets.log_range = gtk.Button()
widgets.log_range.set_image(
gtk.image_new_from_file(respaths.IMAGE_PATH + "log_range.png"))
widgets.log_range.set_size_request(80, 30)
widgets.log_range.connect("clicked", lambda w: log_range_clicked())
delete_button = gtk.Button()
delete_button.set_image(
gtk.image_new_from_file(respaths.IMAGE_PATH + "delete_log_range.png"))
delete_button.set_size_request(80, 30)
delete_button.connect("clicked", lambda w: delete_selected())
use_comments_label = gtk.Label(_("Use Comments as Clip Names"))
use_comments_check = gtk.CheckButton()
use_comments_check.set_active(False)
widgets.use_comments_check = use_comments_check
insert_displayed = gtk.Button()
insert_displayed.set_image(
gtk.image_new_from_file(respaths.IMAGE_PATH + "insert_media_log.png"))
insert_displayed.set_size_request(80, 22)
insert_displayed.connect("clicked", lambda w: insert_selected_log_events())
append_displayed = gtk.Button()
append_displayed.set_image(
gtk.image_new_from_file(respaths.IMAGE_PATH + "append_media_log.png"))
append_displayed.set_size_request(80, 22)
append_displayed.connect("clicked", lambda w: append_log_events())
row2 = gtk.HBox()
row2.pack_start(widgets.log_range, False, True, 0)
row2.pack_start(delete_button, False, True, 0)
row2.pack_start(gtk.Label(), True, True, 0)
row2.pack_start(use_comments_label, False, True, 0)
row2.pack_start(use_comments_check, False, True, 0)
row2.pack_start(gtk.Label(), True, True, 0)
row2.pack_start(insert_displayed, False, True, 0)
row2.pack_start(append_displayed, False, True, 0)
panel = gtk.VBox()
panel.pack_start(row1, False, True, 0)
panel.pack_start(events_list_view, True, True, 0)
panel.pack_start(row2, False, True, 0)
panel.set_size_request(400, 200)
star_check.set_tooltip_text(_("Display starred ranges"))
star_not_active_check.set_tooltip_text(_("Display non-starred ranges"))
star_button.set_tooltip_text(_("Set selected ranges starred"))
no_star_button.set_tooltip_text(_("Set selected ranges non-starred"))
widgets.log_range.set_tooltip_text(_("Log current marked range"))
delete_button.set_tooltip_text(_("Delete selected ranges"))
insert_displayed.set_tooltip_text(_("Insert selected ranges on Timeline"))
append_displayed.set_tooltip_text(_("Append displayed ranges on Timeline"))
dnd.connect_range_log(events_list_view.treeview)
return panel
def __init__(self):
global IMG_PATH
IMG_PATH = respaths.IMAGE_PATH
# Read cursors
global INSERTMOVE_CURSOR, OVERWRITE_CURSOR, TWOROLL_CURSOR, ONEROLL_CURSOR, \
ONEROLL_NO_EDIT_CURSOR, TWOROLL_NO_EDIT_CURSOR, SLIDE_CURSOR, SLIDE_NO_EDIT_CURSOR, \
MULTIMOVE_CURSOR, MULTIMOVE_NO_EDIT_CURSOR
INSERTMOVE_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "insertmove_cursor.png")
OVERWRITE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"overwrite_cursor.png")
TWOROLL_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"tworoll_cursor.png")
ONEROLL_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"oneroll_cursor.png")
SLIDE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"slide_cursor.png")
ONEROLL_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "oneroll_noedit_cursor.png")
TWOROLL_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "tworoll_noedit_cursor.png")
SLIDE_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "slide_noedit_cursor.png")
MULTIMOVE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"multimove_cursor.png")
MULTIMOVE_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "multimove_cursor.png")
# Window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_icon_from_file(respaths.IMAGE_PATH +
"flowbladeappicon.png")
self.window.set_border_width(5)
# To ask confirmation for shutdown
self.window.connect("delete-event", lambda w, e: app.shutdown())
# Player consumer has to be stopped and started when window resized
self.window.connect("window-state-event",
lambda w, e: updater.refresh_player())
# Build menubar
# Menubar build resources
menu_actions = [
('FileMenu', None, _('_File')),
('New', None, _('_New...'), '<control>N', None,
lambda a: projectaction.new_project()),
('Open', None, _('_Open...'), '<control>O', None,
lambda a: projectaction.load_project()),
('OpenRecent', None, _('Open Recent')),
('Save', None, _('_Save'), '<control>S', None,
lambda a: projectaction.save_project()),
('Save As', None, _('_Save As...'), None, None,
lambda a: projectaction.save_project_as()),
('SaveSnapshot', None, _('Save Backup Snapshot...'), None, None,
lambda a: projectaction.save_backup_snapshot()),
('ExportMenu', None, _('Export')),
('ExportMeltXML', None, _('MLT XML'), None, None,
lambda a: exporting.MELT_XML_export()),
('ExportEDL', None, _('EDL CMX 3600'), None, None,
lambda a: exporting.EDL_export()),
('ExportScreenshot', None, _('Current Frame'), None, None,
lambda a: exporting.screenshot_export()),
('Close', None, _('_Close'), None, None,
lambda a: projectaction.close_project()),
('Quit', None, _('_Quit'), '<control>Q', None,
lambda a: app.shutdown()), ('EditMenu', None, _('_Edit')),
('Undo', None, _('_Undo'), '<control>Z', None,
undo.do_undo_and_repaint),
('Redo', None, _('_Redo'), '<control>Y', None,
undo.do_redo_and_repaint),
('AddFromMonitor', None, _('Add Monitor Clip')),
('AppendClip', None, _('Append'), None, None,
lambda a: tlineaction.append_button_pressed()),
('InsertClip', None, _('Insert'), None, None,
lambda a: tlineaction.insert_button_pressed()),
('ThreepointOverWriteClip', None, _('Three Point Overwrite'), None,
None, lambda a: tlineaction.three_point_overwrite_pressed()),
('RangeOverWriteClip', None, _('Range Overwrite'), None, None,
lambda a: tlineaction.range_overwrite_pressed()),
('CutClip', None, _('Cut Clip'), None, None,
lambda a: tlineaction.cut_pressed()),
('DeleteClip', None, _('Lift'), None, None,
lambda a: tlineaction.lift_button_pressed()),
('SpliceOutClip', None, _('Splice Out'), None, None,
lambda a: tlineaction.splice_out_button_pressed()),
('ResyncSelected', None, _('Resync'), None, None,
lambda a: tlineaction.resync_button_pressed()),
('SetSyncParent', None, _('Set Sync Parent'), None, None,
lambda a: _this_is_not_used()),
('AddTransition', None, _('Add Single Track Transition'), None,
None, lambda a: tlineaction.add_transition_menu_item_selected()),
('AddFade', None, _('Add Single Track Fade'), None, None,
lambda a: tlineaction.add_fade_menu_item_selected()),
('ClearFilters', None, _('Clear Filters'), None, None,
lambda a: clipmenuaction.clear_filters()),
('ChangeSequenceTracks', None,
_('Change Sequence Tracks Count...'), None, None,
lambda a: projectaction.change_sequence_track_count()),
('Watermark', None, _('Watermark...'), None, None,
lambda a: menuactions.edit_watermark()),
('ProfilesManager', None, _('Profiles Manager'), None, None,
lambda a: menuactions.profiles_manager()),
('Preferences', None, _('Preferences'), None, None,
lambda a: preferenceswindow.preferences_dialog()),
('ViewMenu', None, _('View')), ('ProjectMenu', None, _('Project')),
('AddMediaClip', None, _('Add Media Clip...'), None, None,
lambda a: projectaction.add_media_files()),
('AddImageSequence', None, _('Add Image Sequence...'), None, None,
lambda a: projectaction.add_image_sequence()),
('CreateColorClip', None, _('Create Color Clip...'), None, None,
lambda a: patternproducer.create_color_clip()),
('PatternProducersMenu', None, _('Create Pattern Producer')),
('CreateNoiseClip', None, _('Noise'), None, None,
lambda a: patternproducer.create_noise_clip()),
('CreateBarsClip', None, _('EBU Bars'), None, None,
lambda a: patternproducer.create_bars_clip()),
('CreateIsingClip', None, _('Ising'), None, None,
lambda a: patternproducer.create_icing_clip()),
('CreateColorPulseClip', None, _('Color Pulse'), None, None,
lambda a: patternproducer.create_color_pulse_clip()),
('LogClipRange', None, _('Log Marked Clip Range'), '<control>L',
None, lambda a: medialog.log_range_clicked()),
('RecreateMediaIcons', None, _('Recreate Media Icons...'), None,
None, lambda a: menuactions.recreate_media_file_icons()),
('RemoveUnusedMedia', None, _('Remove Unused Media...'), None,
None, lambda a: projectaction.remove_unused_media()),
('JackAudio', None, _("JACK Audio..."), None, None,
lambda a: menuactions.jack_output_managing()),
('ProxyManager', None, _('Proxy Manager'), None, None,
lambda a: proxyediting.show_proxy_manager_dialog()),
('ProjectType', None, _("Change Project Type..."), None, None,
lambda a: projectaction.change_project_type()),
('ProjectInfo', None, _('Project Info'), None, None,
lambda a: menuactions.show_project_info()),
('RenderMenu', None, _('Render')),
('AddToQueue', None, _('Add To Batch Render Queue...'), None, None,
lambda a: projectaction.add_to_render_queue()),
('BatchRender', None, _('Batch Render Queue'), None, None,
lambda a: batchrendering.launch_batch_rendering()),
('Render', None, _('Render Timeline'), None, None,
lambda a: projectaction.do_rendering()),
('ToolsMenu', None, _('Tools')),
('Titler', None, _('Titler'), None, None,
lambda a: titler.show_titler()),
('AudioMix', None, _('Audio Mixer'), None, None,
lambda a: audiomonitoring.show_audio_monitor()),
('MediaLink', None, _('Media Relinker'), None, None,
lambda a: medialinker.display_linker()),
('HelpMenu', None, _('_Help')),
('QuickReference', None, _('Contents'), None, None,
lambda a: menuactions.quick_reference()),
('Environment', None, _('Runtime Environment'), None, None,
lambda a: menuactions.environment()),
('KeyboardShortcuts', None, _('Keyboard Shortcuts'), None, None,
lambda a: dialogs.keyboard_shortcuts_dialog(self.window)),
('About', None, _('About'), None, None,
lambda a: menuactions.about()),
('InsertMode', None, None, '1', None,
lambda a: _this_is_not_used()),
('OverMode', None, None, '2', None, lambda a: _this_is_not_used()),
('OneRollMode', None, None, '3', None,
lambda a: _this_is_not_used()),
('TwoRollMode', None, None, '4', None,
lambda a: _this_is_not_used()),
('SlideMode', None, None, '5', None,
lambda a: _this_is_not_used()),
('MultiMode', None, None, '6', None, lambda a: _this_is_not_used())
]
menu_string = """<ui>
<menubar name='MenuBar'>
<menu action='FileMenu'>
<menuitem action='New'/>
<menuitem action='Open'/>
<menu action='OpenRecent'/>
<menuitem action='Save'/>
<menuitem action='Save As'/>
<menuitem action='SaveSnapshot'/>
<separator/>
<menu action='ExportMenu'>
<menuitem action='ExportMeltXML'/>
<menuitem action='ExportScreenshot'/>
</menu>
<separator/>
<menuitem action='Close'/>
<menuitem action='Quit'/>
</menu>
<menu action='EditMenu'>
<menuitem action='Undo'/>
<menuitem action='Redo'/>
<separator/>
<menu action='AddFromMonitor'>
<menuitem action='AppendClip'/>
<menuitem action='InsertClip'/>
<menuitem action='ThreepointOverWriteClip'/>
<menuitem action='RangeOverWriteClip'/>
</menu>
<separator/>
<menuitem action='CutClip'/>
<separator/>
<menuitem action='SpliceOutClip'/>
<menuitem action='DeleteClip'/>
<menuitem action='ResyncSelected'/>
<menuitem action='ClearFilters'/>
<separator/>
<menuitem action='AddTransition'/>
<menuitem action='AddFade'/>
<separator/>
<menuitem action='ChangeSequenceTracks'/>
<menuitem action='Watermark'/>
<separator/>
<menuitem action='ProfilesManager'/>
<menuitem action='Preferences'/>
</menu>
<menu action='ViewMenu'>
</menu>
<menu action='ProjectMenu'>
<menuitem action='AddMediaClip'/>
<menuitem action='AddImageSequence'/>
<separator/>
<menuitem action='CreateColorClip'/>
<menu action='PatternProducersMenu'>
<menuitem action='CreateNoiseClip'/>
<menuitem action='CreateColorPulseClip'/>
<menuitem action='CreateIsingClip'/>
<menuitem action='CreateBarsClip'/>
</menu>
<separator/>
<menuitem action='LogClipRange'/>
<separator/>
<menuitem action='RecreateMediaIcons'/>
<menuitem action='RemoveUnusedMedia'/>
<separator/>
<menuitem action='ProxyManager'/>
</menu>
<menu action='RenderMenu'>
<menuitem action='AddToQueue'/>
<menuitem action='BatchRender'/>
<separator/>
<menuitem action='Render'/>
</menu>
<menu action='ToolsMenu'>
<menuitem action='Titler'/>
<menuitem action='AudioMix'/>
<separator/>
<menuitem action='MediaLink'/>
</menu>
<menu action='HelpMenu'>
<menuitem action='QuickReference'/>
<menuitem action='KeyboardShortcuts'/>
<menuitem action='Environment'/>
<separator/>
<menuitem action='About'/>
</menu>
</menubar>
</ui>"""
# Create global action group
action_group = gtk.ActionGroup('WindowActions')
action_group.add_actions(menu_actions, user_data=None)
# Create UIManager and add accelators to window
ui = gtk.UIManager()
ui.insert_action_group(action_group, 0)
ui.add_ui_from_string(menu_string)
accel_group = ui.get_accel_group()
self.window.add_accel_group(accel_group)
# Get menu bar
self.menubar = ui.get_widget('/MenuBar')
# Set reference to UI manager and acclegroup
self.uimanager = ui
self.accel_group = accel_group
# Add recent projects to menu
editorpersistance.fill_recents_menu_widget(
ui.get_widget('/MenuBar/FileMenu/OpenRecent'),
projectaction.open_recent_project)
# Disable audio mixer if not available
if editorstate.audio_monitoring_available == False:
ui.get_widget('/MenuBar/ToolsMenu/AudioMix').set_sensitive(False)
# Menu box
menu_vbox = gtk.VBox(False, 0)
menu_vbox.pack_start(self.menubar, False, True, 0)
# Media manager
self.bin_list_view = guicomponents.BinListView(
projectaction.bin_selection_changed, projectaction.bin_name_edited)
dnd.connect_bin_tree_view(self.bin_list_view.treeview,
projectaction.move_files_to_bin)
self.bin_list_view.set_property("can-focus", True)
bins_panel = panels.get_bins_panel(
self.bin_list_view, lambda w, e: projectaction.add_new_bin(),
lambda w, e: projectaction.delete_selected_bin())
bins_panel.set_size_request(MEDIA_MANAGER_WIDTH, BINS_HEIGHT)
self.media_list_view = guicomponents.MediaPanel(
projectaction.media_file_menu_item_selected,
updater.set_and_display_monitor_media_file)
self.media_scroll_window = gtk.ScrolledWindow()
self.media_scroll_window.add_with_viewport(self.media_list_view.widget)
self.media_scroll_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.media_scroll_window.set_size_request(
guicomponents.MEDIA_OBJECT_WIDGET_WIDTH * 2 + 70,
guicomponents.MEDIA_OBJECT_WIDGET_HEIGHT)
self.media_scroll_window.show_all()
media_panel = panels.get_media_files_panel(
self.media_scroll_window,
lambda w, e: projectaction.add_media_files(),
lambda w, e: projectaction.delete_media_files(),
lambda a: self.media_list_view.columns_changed(a),
lambda w, e: proxyediting.create_proxy_files_pressed(),
projectaction.media_filtering_select_pressed)
self.mm_paned = gtk.HPaned()
self.mm_paned.pack1(bins_panel, resize=True, shrink=True)
self.mm_paned.pack2(media_panel, resize=True, shrink=False)
mm_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
mm_panel.set_padding(2, 2, 6, 2)
mm_panel.add(self.mm_paned)
# Effects
self.effect_select_list_view = guicomponents.FilterListView()
self.effect_select_combo_box = gtk.combo_box_new_text()
self.effect_select_list_view.treeview.connect(
"row-activated",
clipeffectseditor.effect_select_row_double_clicked)
dnd.connect_effects_select_tree_view(
self.effect_select_list_view.treeview)
clip_editor_panel = clipeffectseditor.get_clip_effects_editor_panel(
self.effect_select_combo_box, self.effect_select_list_view)
clipeffectseditor.widgets.effect_stack_view.treeview.connect(
"button-press-event", clipeffectseditor.filter_stack_button_press)
effects_editor_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
effects_editor_panel.set_padding(0, 0, 4, 0)
effects_editor_panel.add(clipeffectseditor.widgets.value_edit_frame)
effects_hbox = gtk.HBox()
effects_hbox.set_border_width(5)
effects_hbox.pack_start(clip_editor_panel, False, False, 0)
effects_hbox.pack_start(effects_editor_panel, True, True, 0)
self.effects_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
self.effects_panel.set_padding(2, 2, 2, 2)
self.effects_panel.add(effects_hbox)
# Compositors
compositor_clip_panel = compositeeditor.get_compositor_clip_panel()
compositor_editor_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
compositor_editor_panel.set_padding(0, 0, 4, 0)
compositor_editor_panel.add(compositeeditor.widgets.value_edit_frame)
compositors_hbox = gtk.HBox()
compositors_hbox.set_border_width(5)
compositors_hbox.pack_start(compositor_clip_panel, False, False, 0)
compositors_hbox.pack_start(compositor_editor_panel, True, True, 0)
self.compositors_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
self.compositors_panel.set_padding(0, 0, 0, 0)
self.compositors_panel.add(compositors_hbox)
# Render
normal_height = True
if appconsts.TOP_ROW_HEIGHT < 500: # small screens have no space to display this
normal_height = False
add_audio_desc = True
if editorstate.SCREEN_HEIGHT < 863:
add_audio_desc = False
try:
render.create_widgets(normal_height)
render_panel_left = rendergui.get_render_panel_left(
render.widgets, add_audio_desc, normal_height)
except IndexError:
print "No rendering options found"
render_panel_left = None
# 'None' here means that no possible rendering options were available
# and creating panel failed. Inform user of this and hide render GUI
if render_panel_left == None:
render_hbox = gtk.VBox(False, 5)
render_hbox.pack_start(gtk.Label("Rendering disabled."), False,
False, 0)
render_hbox.pack_start(
gtk.Label("No available rendering options found."), False,
False, 0)
render_hbox.pack_start(
gtk.Label(
"See Help->Environment->Render Options for details."),
False, False, 0)
render_hbox.pack_start(
gtk.Label("Install codecs to make rendering available."),
False, False, 0)
render_hbox.pack_start(gtk.Label(" "), True, True, 0)
else: # all is good
render_panel_right = rendergui.get_render_panel_right(
render.widgets, lambda w, e: projectaction.do_rendering(),
lambda w, e: projectaction.add_to_render_queue())
render_hbox = gtk.HBox(True, 5)
render_hbox.pack_start(render_panel_left, True, True, 0)
render_hbox.pack_start(render_panel_right, True, True, 0)
render_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
render_panel.set_padding(2, 6, 8, 6)
render_panel.add(render_hbox)
# Media log events List
media_log_events_list_view = medialog.get_media_log_list_view()
events_panel = medialog.get_media_log_events_panel(
media_log_events_list_view)
media_log_vbox = gtk.HBox()
media_log_vbox.pack_start(events_panel, True, True, 0)
media_log_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
media_log_panel.set_padding(6, 6, 6, 6)
media_log_panel.add(media_log_vbox)
self.media_log_events_list_view = media_log_events_list_view
# Sequence list
self.sequence_list_view = guicomponents.SequenceListView(
projectaction.sequence_name_edited)
seq_panel = panels.get_sequences_panel(
self.sequence_list_view,
lambda w, e: projectaction.change_edit_sequence(),
lambda w, e: projectaction.add_new_sequence(),
lambda w, e: projectaction.delete_selected_sequence())
# Project info
project_info_panel = projectinfogui.get_project_info_panel()
# Project vbox and panel
project_vbox = gtk.HBox()
project_vbox.pack_start(project_info_panel, False, True, 0)
project_vbox.pack_start(seq_panel, True, True, 0)
project_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
project_panel.set_padding(0, 2, 6, 2)
project_panel.add(project_vbox)
# Notebook
self.notebook = gtk.Notebook()
self.notebook.set_size_request(appconsts.NOTEBOOK_WIDTH,
appconsts.TOP_ROW_HEIGHT)
self.notebook.append_page(mm_panel, gtk.Label(_("Media")))
self.notebook.append_page(media_log_panel, gtk.Label(_("Range Log")))
self.notebook.append_page(self.effects_panel, gtk.Label(_("Filters")))
self.notebook.append_page(self.compositors_panel,
gtk.Label(_("Compositors")))
self.notebook.append_page(project_panel, gtk.Label(_("Project")))
self.notebook.append_page(render_panel, gtk.Label(_("Render")))
self.notebook.set_tab_pos(gtk.POS_BOTTOM)
# Right notebook, used for Widescreen and Two row layouts
self.right_notebook = gtk.Notebook()
self.right_notebook.set_tab_pos(gtk.POS_BOTTOM)
# Position bar and decorative frame for it
self.pos_bar = PositionBar()
pos_bar_frame = gtk.Frame()
pos_bar_frame.add(self.pos_bar.widget)
pos_bar_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Positionbar vbox
pos_bar_vbox = gtk.VBox(False, 1)
pos_bar_vbox.pack_start(guiutils.get_pad_label(5, 2), False, True, 0)
pos_bar_vbox.pack_start(pos_bar_frame, False, True, 0)
# Play buttons row
self._create_monitor_row_widgets()
self.player_buttons = glassbuttons.PlayerButtons()
self.player_buttons.widget.set_tooltip_text(
_("Prev Frame - Arrow Left\nNext Frame - Arrow Right\nPlay - Space\nStop - Space\nMark In - I\nMark Out - O\nClear Marks\nTo Mark In\nTo Mark Out"
))
self.monitor_source.modify_font(pango.FontDescription("sans bold 8"))
player_buttons_row = gtk.HBox(False, 0)
player_buttons_row.pack_start(self.player_buttons.widget, False, True,
0)
player_buttons_row.pack_start(self.monitor_source, True, True, 0)
# Creates monitor switch buttons
self._create_monitor_buttons()
# Switch button box
switch_hbox = gtk.HBox(True, 1)
switch_hbox.pack_start(self.sequence_editor_b, False, False, 0)
switch_hbox.pack_start(self.clip_editor_b, False, False, 0)
# Switch button box V, for centered buttons
switch_vbox = gtk.VBox(False, 1)
switch_vbox.pack_start(guiutils.get_pad_label(5, 2), False, True, 0)
switch_vbox.pack_start(switch_hbox, False, True, 0)
# Switch / pos bar row
self.view_mode_select = guicomponents.get_monitor_view_select_combo(
lambda w, e: tlineaction.view_mode_menu_lauched(w, e))
sw_pos_hbox = gtk.HBox(False, 1)
sw_pos_hbox.pack_start(switch_vbox, False, True, 0)
sw_pos_hbox.pack_start(pos_bar_vbox, True, True, 0)
sw_pos_hbox.pack_start(self.view_mode_select.widget, False, False, 0)
# Video display
black_box = gtk.EventBox()
black_box.add(gtk.Label())
bg_color = gtk.gdk.Color(red=0.0, green=0.0, blue=0.0)
black_box.modify_bg(gtk.STATE_NORMAL, bg_color)
self.tline_display = black_box # This can be any GTK+ widget (that is not "windowless"), only its XWindow draw rect
# is used to position and scale SDL overlay that actually displays video.
dnd.connect_video_monitor(self.tline_display)
# Monitor
monitor_vbox = gtk.VBox(False, 1)
monitor_vbox.pack_start(self.tline_display, True, True, 0)
monitor_vbox.pack_start(sw_pos_hbox, False, True, 0)
monitor_vbox.pack_start(player_buttons_row, False, True, 0)
monitor_align = gtk.Alignment(xalign=0.0,
yalign=0.0,
xscale=1.0,
yscale=1.0)
monitor_align.add(monitor_vbox)
monitor_align.set_padding(3, 0, 3, 3)
monitor_frame = gtk.Frame()
monitor_frame.add(monitor_align)
monitor_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
monitor_frame.set_size_request(MONITOR_AREA_WIDTH,
appconsts.TOP_ROW_HEIGHT)
# Notebook panel
notebook_vbox = gtk.VBox(False, 1)
notebook_vbox.pack_start(self.notebook, True, True)
# Top row paned
self.top_paned = gtk.HPaned()
self.top_paned.pack1(notebook_vbox, resize=False, shrink=False)
self.top_paned.pack2(monitor_frame, resize=True, shrink=False)
# Top row
self.top_row_hbox = gtk.HBox(False, 0)
self.top_row_hbox.pack_start(self.top_paned, True, True, 0)
self._update_top_row()
# Edit buttons rows
self.edit_buttons_row = self._get_edit_buttons_row()
self.edit_buttons_frame = gtk.Frame()
self.edit_buttons_frame.add(self.edit_buttons_row)
self.edit_buttons_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# Timeline scale
self.tline_scale = tlinewidgets.TimeLineFrameScale(
editevent.insert_move_mode_pressed, updater.mouse_scroll_zoom)
# Timecode display
self.tline_info = gtk.HBox()
info_contents = gtk.Label()
self.tline_info.add(info_contents)
self.tline_info.info_contents = info_contents # this switched and sacved as member of its container
info_h = gtk.HBox()
info_h.pack_start(self.tline_info, False, False, 0)
info_h.pack_start(gtk.Label(), True, True, 0)
info_h.set_size_request(
tlinewidgets.COLUMN_WIDTH - 22 -
22, # - 22, # room for 2 menu launch buttons
tlinewidgets.SCALE_HEIGHT)
marker_pixbuf = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH +
"marker.png")
markers_launcher = guicomponents.get_markers_menu_launcher(
tlineaction.marker_menu_lauch_pressed, marker_pixbuf)
tracks_launcher_pixbuf = gtk.gdk.pixbuf_new_from_file(
respaths.IMAGE_PATH + "track_menu_launch.png")
tracks_launcher = guicomponents.PressLaunch(
trackaction.all_tracks_menu_launch_pressed, tracks_launcher_pixbuf)
# Timeline top row
tline_hbox_1 = gtk.HBox()
tline_hbox_1.pack_start(info_h, False, False, 0)
tline_hbox_1.pack_start(tracks_launcher.widget, False, False, 0)
tline_hbox_1.pack_start(markers_launcher.widget, False, False, 0)
tline_hbox_1.pack_start(self.tline_scale.widget, True, True, 0)
# Timeline column
self.tline_column = tlinewidgets.TimeLineColumn(
trackaction.track_active_switch_pressed,
trackaction.track_center_pressed)
# Timeline editpanel
self.tline_canvas = tlinewidgets.TimeLineCanvas(
editevent.tline_canvas_mouse_pressed,
editevent.tline_canvas_mouse_moved,
editevent.tline_canvas_mouse_released,
editevent.tline_canvas_double_click, updater.mouse_scroll_zoom,
self.tline_cursor_leave, self.tline_cursor_enter)
dnd.connect_tline(self.tline_canvas.widget,
editevent.tline_effect_drop,
editevent.tline_media_drop)
# Timeline middle row
tline_hbox_2 = gtk.HBox()
tline_hbox_2.pack_start(self.tline_column.widget, False, False, 0)
tline_hbox_2.pack_start(self.tline_canvas.widget, True, True, 0)
# Bottom row filler
self.left_corner = guicomponents.TimeLineLeftBottom()
self.left_corner.widget.set_size_request(tlinewidgets.COLUMN_WIDTH, 20)
# Timeline scroller
self.tline_scroller = tlinewidgets.TimeLineScroller(
updater.tline_scrolled)
# Timeline bottom row
tline_hbox_3 = gtk.HBox()
tline_hbox_3.pack_start(self.left_corner.widget, False, False, 0)
tline_hbox_3.pack_start(self.tline_scroller, True, True, 0)
# Timeline hbox
tline_vbox = gtk.VBox()
tline_vbox.pack_start(tline_hbox_1, False, False, 0)
tline_vbox.pack_start(tline_hbox_2, True, True, 0)
tline_vbox.pack_start(tline_hbox_3, False, False, 0)
# Timeline box
self.tline_box = gtk.HBox()
self.tline_box.pack_start(tline_vbox, True, True, 0)
# Timeline pane
tline_pane = gtk.VBox(False, 1)
tline_pane.pack_start(self.edit_buttons_frame, False, True, 0)
tline_pane.pack_start(self.tline_box, True, True, 0)
# VPaned top row / timeline
self.app_v_paned = gtk.VPaned()
self.app_v_paned.pack1(self.top_row_hbox, resize=False, shrink=False)
self.app_v_paned.pack2(tline_pane, resize=True, shrink=False)
# Pane
pane = gtk.VBox(False, 1)
pane.pack_start(menu_vbox, False, True, 0)
pane.pack_start(self.app_v_paned, True, True, 0)
# Tooltips
self._add_tool_tips()
# GUI preferences
self._init_gui_to_prefs()
# Viewmenu initial state
self._init_view_menu(ui.get_widget('/MenuBar/ViewMenu'))
# Set pane and show window
self.window.add(pane)
self.window.set_title("Flowblade")
# Maximize if it seems that we exited maximized, else set size
w, h = editorpersistance.prefs.exit_allocation
if w != 0: # non-existing prefs file causes w and h to be 0
if (float(w) / editorstate.SCREEN_WIDTH >
0.95) and (float(h) / editorstate.SCREEN_HEIGHT > 0.95):
self.window.maximize()
print "maximize"
else:
self.window.resize(w, h)
self.window.set_position(gtk.WIN_POS_CENTER)
else:
self.window.set_position(gtk.WIN_POS_CENTER)
# Show window and all of its components
self.window.show_all()
# Set paned positions
self.mm_paned.set_position(editorpersistance.prefs.mm_paned_position)
self.top_paned.set_position(editorpersistance.prefs.top_paned_position)
self.app_v_paned.set_position(
editorpersistance.prefs.app_v_paned_position)
def __init__(self, filter_object, filter_stack):
self.filter_object = filter_object
self.filter_stack = filter_stack
surface = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"filter_save.png")
save_button = guicomponents.PressLaunch(self.save_pressed,
surface,
w=22,
h=22)
save_button.widget.set_tooltip_markup(_("Save effect values"))
surface = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"filter_load.png")
load_button = guicomponents.PressLaunch(self.load_pressed,
surface,
w=22,
h=22)
load_button.widget.set_tooltip_markup(_("Load effect values"))
surface = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH +
"filter_reset.png")
reset_button = guicomponents.PressLaunch(self.reset_pressed,
surface,
w=22,
h=22)
reset_button.widget.set_tooltip_markup(_("Reset effect values"))
surface = guiutils.get_cairo_image("filters_mask_add")
mask_button = guicomponents.PressLaunch(self.add_mask_pressed,
surface,
w=22,
h=22)
mask_button.widget.set_tooltip_markup(_("Add Filter Mask"))
surface = guiutils.get_cairo_image("filters_move_up")
move_up_button = guicomponents.PressLaunch(self.move_up_pressed,
surface,
w=22,
h=22)
move_up_button.widget.set_tooltip_markup(_("Move Filter Up"))
surface = guiutils.get_cairo_image("filters_move_down")
move_down_button = guicomponents.PressLaunch(self.move_down_pressed,
surface,
w=22,
h=22)
move_down_button.widget.set_tooltip_markup(_("Move Filter Down"))
surface = guiutils.get_cairo_image("filters_move_top")
move_top_button = guicomponents.PressLaunch(self.move_top_pressed,
surface,
w=22,
h=22)
move_top_button.widget.set_tooltip_markup(_("Move Filter To Top"))
surface = guiutils.get_cairo_image("filters_move_bottom")
move_bottom_button = guicomponents.PressLaunch(
self.move_bottom_pressed, surface, w=22, h=22)
move_bottom_button.widget.set_tooltip_markup(
_("Move Filter To Bottom"))
self.widget = Gtk.HBox(False, 0)
self.widget.pack_start(guiutils.pad_label(4, 5), False, False, 0)
self.widget.pack_start(mask_button.widget, False, False, 0)
self.widget.pack_start(guiutils.pad_label(2, 5), False, False, 0)
self.widget.pack_start(reset_button.widget, False, False, 0)
self.widget.pack_start(guiutils.pad_label(12, 5), False, False, 0)
self.widget.pack_start(move_up_button.widget, False, False, 0)
self.widget.pack_start(move_down_button.widget, False, False, 0)
self.widget.pack_start(move_top_button.widget, False, False, 0)
self.widget.pack_start(move_bottom_button.widget, False, False, 0)
self.widget.pack_start(guiutils.pad_label(12, 5), False, False, 0)
self.widget.pack_start(save_button.widget, False, False, 0)
self.widget.pack_start(load_button.widget, False, False, 0)
self.widget.pack_start(Gtk.Label(), True, True, 0)
def __init__(self):
GObject.GObject.__init__(self)
self.connect("delete-event", lambda w, e:_shutdown())
app_icon = GdkPixbuf.Pixbuf.new_from_file(respaths.IMAGE_PATH + "flowbladetoolicon.png")
self.set_icon(app_icon)
#---- LEFT PANEL
hamburger_launcher_surface = cairo.ImageSurface.create_from_png(respaths.IMAGE_PATH + "hamburger.png")
self.hamburger_launcher = guicomponents.PressLaunch(_hamburger_launch_pressed, hamburger_launcher_surface)
guiutils.set_margins(self.hamburger_launcher.widget, 0, 8, 0, 8)
# Animation selector menu launcher row
self.animation_label = Gtk.Label(_animation_instance.info.name)
self.present_event_box = Gtk.EventBox()
self.present_event_box.add(self.animation_label)
self.present_event_box.connect("button-press-event", animations_menu_launched)
self.script_menu = toolguicomponents.PressLaunch(animations_menu_launched)
selector_row = Gtk.HBox(False, 2)
selector_row.pack_start(self.hamburger_launcher.widget, False, False, 0)
selector_row.pack_start(self.present_event_box, False, False, 0)
selector_row.pack_start(self.script_menu.widget, False, False, 0)
selector_row.set_margin_top(2)
# Edit area
self.value_edit_frame = Gtk.Frame()
self.value_edit_frame.set_shadow_type(Gtk.ShadowType.IN)
self.value_edit_frame.set_size_request(EDIT_PANEL_WIDTH+ 10, EDIT_PANEL_HEIGHT + 10)
self.value_edit_box = None
#---- RIGHT PANEL
self.preview_info = Gtk.Label()
self.preview_info.set_markup("<small>" + _("no preview") + "</small>" )
preview_info_row = Gtk.HBox()
preview_info_row.pack_start(self.preview_info, False, False, 0)
preview_info_row.pack_start(Gtk.Label(), True, True, 0)
preview_info_row.set_margin_top(6)
preview_info_row.set_margin_bottom(8)
preview_info_row.set_size_request(200, 10)
# Monitor
self.preview_monitor = cairoarea.CairoDrawableArea2(MONITOR_WIDTH, MONITOR_HEIGHT, self._draw_preview)
# Position control panel
self.pos_bar = positionbar.PositionBar(False)
self.pos_bar.set_listener(self.position_listener)
pos_bar_frame = Gtk.Frame()
pos_bar_frame.add(self.pos_bar.widget)
pos_bar_frame.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
pos_bar_frame.set_margin_top(5)
pos_bar_frame.set_margin_bottom(4)
pos_bar_frame.set_margin_left(6)
pos_bar_frame.set_margin_right(2)
self.preview_button = Gtk.Button(_("Preview Frame"))
self.preview_button.connect("clicked", lambda w: render_preview_frame())
control_panel = Gtk.HBox(False, 2)
control_panel.pack_start(pos_bar_frame, True, True, 0)
control_panel.pack_start(guiutils.pad_label(2, 2), False, False, 0)
control_panel.pack_start(self.preview_button, False, False, 0)
# Range setting
in_label = Gtk.Label(_("Start:"))
self.range_in = Gtk.SpinButton.new_with_range(1, 249, 1)
out_label = Gtk.Label(_("End:"))
self.range_out = Gtk.SpinButton.new_with_range(2, 250, 1)
self.range_in.set_value(1)
self.range_out.set_value(250)
self.range_in.connect("value-changed", self.range_changed)
self.range_out.connect("value-changed", self.range_changed)
pos_label = Gtk.Label(_("Frame:"))
self.pos_info = Gtk.Label(_("1"))
range_row = Gtk.HBox(False, 2)
range_row.pack_start(in_label, False, False, 0)
range_row.pack_start(self.range_in, False, False, 0)
range_row.pack_start(Gtk.Label(), True, True, 0)
range_row.pack_start(pos_label, False, False, 0)
range_row.pack_start(self.pos_info, False, False, 0)
range_row.pack_start(Gtk.Label(), True, True, 0)
range_row.pack_start(out_label, False, False, 0)
range_row.pack_start(self.range_out, False, False, 0)
range_row.set_margin_bottom(24)
range_row.set_margin_left(5)
# Render panel
self.out_folder = Gtk.FileChooserButton(_("Select Folder"))
self.out_folder.set_action(Gtk.FileChooserAction.SELECT_FOLDER)
self.out_folder.connect("selection-changed", self.folder_selection_changed)
self.out_label = Gtk.Label(label=_("Frames Folder:"))
self.frame_name = Gtk.Entry()
self.frame_name.set_text("frame")
self.extension_label = Gtk.Label()
self.extension_label.set_markup("<small>XXXX.png</small>")
out_folder_row = guiutils.get_left_justified_box([self.out_label, guiutils.pad_label(12, 2), \
self.out_folder, guiutils.pad_label(24, 2), self.frame_name, \
guiutils.pad_label(2, 2), self.extension_label])
self.encode_check_label = Gtk.Label(_("Encode Video"))
self.encode_check = Gtk.CheckButton()
self.encode_check.set_active(False)
self.encode_check.connect("toggled", lambda w:self.update_encode_sensitive())
self.encode_settings_button = Gtk.Button(_("Encoding settings"))
self.encode_settings_button.connect("clicked", lambda w:_encode_settings_clicked())
self.encode_desc = Gtk.Label()
self.encode_desc.set_markup("<small>" + _("not set") + "</small>")
self.encode_desc.set_ellipsize(Pango.EllipsizeMode.END)
self.encode_desc.set_max_width_chars(32)
encode_row = Gtk.HBox(False, 2)
encode_row.pack_start(self.encode_check, False, False, 0)
encode_row.pack_start(self.encode_check_label, False, False, 0)
encode_row.pack_start(guiutils.pad_label(48, 12), False, False, 0)
encode_row.pack_start(self.encode_settings_button, False, False, 0)
encode_row.pack_start(guiutils.pad_label(6, 12), False, False, 0)
encode_row.pack_start(self.encode_desc, False, False, 0)
encode_row.pack_start(Gtk.Label(), True, True, 0)
encode_row.set_margin_bottom(6)
format_label = Gtk.Label(_("Natron Render Format:"))
self.format_selector = Gtk.ComboBoxText() # filled later when current sequence known
for format_desc in NATRON_RENDER_FORMATS:
self.format_selector.append_text(format_desc)
self.format_selector.set_active(NATRON_DEFAULT_RENDER_FORMAT)
format_select_row = Gtk.HBox(False, 2)
format_select_row.pack_start(format_label, False, False, 0)
format_select_row.pack_start(guiutils.pad_label(12, 2), False, False, 0)
format_select_row.pack_start(self.format_selector, False, False, 0)
format_select_row.set_margin_top(24)
self.render_percentage = Gtk.Label("")
self.status_no_render = _("Set Frames Folder for valid render")
self.render_status_info = Gtk.Label()
self.render_status_info.set_markup("<small>" + self.status_no_render + "</small>")
render_status_row = Gtk.HBox(False, 2)
render_status_row.pack_start(self.render_percentage, False, False, 0)
render_status_row.pack_start(Gtk.Label(), True, True, 0)
render_status_row.pack_start(self.render_status_info, False, False, 0)
render_status_row.set_margin_bottom(6)
self.render_progress_bar = Gtk.ProgressBar()
self.render_progress_bar.set_valign(Gtk.Align.CENTER)
self.stop_button = guiutils.get_sized_button(_("Stop"), 100, 32)
#self.stop_button.connect("clicked", lambda w:abort_render())
self.render_button = guiutils.get_sized_button(_("Render"), 100, 32)
self.render_button.connect("clicked", lambda w:render_output())
render_row = Gtk.HBox(False, 2)
render_row.pack_start(self.render_progress_bar, True, True, 0)
render_row.pack_start(guiutils.pad_label(12, 2), False, False, 0)
render_row.pack_start(self.stop_button, False, False, 0)
render_row.pack_start(self.render_button, False, False, 0)
render_vbox = Gtk.VBox(False, 2)
render_vbox.pack_start(encode_row, False, False, 0)
render_vbox.pack_start(Gtk.Label(), True, True, 0)
render_vbox.pack_start(out_folder_row, False, False, 0)
render_vbox.pack_start(format_select_row, False, False, 0)
render_vbox.pack_start(Gtk.Label(), True, True, 0)
render_vbox.pack_start(render_status_row, False, False, 0)
render_vbox.pack_start(render_row, False, False, 0)
render_vbox.pack_start(guiutils.pad_label(24, 24), False, False, 0)
render_vbox.set_margin_left(8)
# Bottomrow
self.load_anim = Gtk.Button(_("Load Animation"))
self.load_anim.connect("clicked", lambda w:load_script_dialog(_load_script_dialog_callback))
self.save_anim = Gtk.Button(_("Save Animation"))
self.save_anim.connect("clicked", lambda w:save_script_dialog(_save_script_dialog_callback))
exit_b = guiutils.get_sized_button(_("Close"), 150, 32)
exit_b.connect("clicked", lambda w:_shutdown())
editor_buttons_row = Gtk.HBox()
editor_buttons_row.pack_start(self.load_anim, False, False, 0)
editor_buttons_row.pack_start(self.save_anim, False, False, 0)
editor_buttons_row.pack_start(Gtk.Label(), True, True, 0)
editor_buttons_row.pack_start(exit_b, False, False, 0)
# Build window
left_panel = Gtk.VBox(False, 2)
left_panel.pack_start(selector_row, False, False, 0)
left_panel.pack_start(self.value_edit_frame, True, True, 0)
right_panel = Gtk.VBox(False, 0)
right_panel.pack_start(preview_info_row, False, False, 0)
right_panel.pack_start(self.preview_monitor, False, False, 0)
right_panel.pack_start(control_panel, False, False, 0)
right_panel.pack_start(range_row, False, False, 0)
right_panel.pack_start(render_vbox, True, True, 0)
right_panel.set_margin_left(4)
sides_pane = Gtk.HBox(False, 2)
sides_pane.pack_start(left_panel, False, False, 0)
sides_pane.pack_start(right_panel, False, False, 0)
pane = Gtk.VBox(False, 2)
pane.pack_start(sides_pane, False, False, 0)
pane.pack_start(editor_buttons_row, False, False, 0)
align = guiutils.set_margins(pane, 2, 12, 12, 12)
# Connect global key listener
#self.connect("key-press-event", _global_key_down_listener)
# Set pane and show window
self.add(align)
self.set_title(_("Natron Animations"))
self.set_position(Gtk.WindowPosition.CENTER)
#self.set_widgets_sensitive(False)
self.show_all()
self.set_resizable(False)
#self.set_active_state(False)
self.update_render_status_info()
self.change_animation()
