def __init__(self, app):
gtk.VBox.__init__(self)
Plugin.__init__(self)
self.app = app
self.dir = os.path.dirname(__file__)
self.status = STATUS_STOP
fname = os.path.join(self.dir, 'vehicle.glade')
self._glade = glade.XML(fname, 'vehicle_info_box')
main_vbox = self._glade.get_widget('vehicle_info_box')
self.pack_start(main_vbox)
main_vbox.show_all()
self._vehicle_name = self._glade.get_widget('vehicle_name_data')
self._vehicle_plate = self._glade.get_widget('vehicle_plate_data')
self._vehicle_make = self._glade.get_widget('vehicle_make_data')
self._vehicle_model = self._glade.get_widget('vehicle_model_data')
self._vehicle_year = self._glade.get_widget('vehicle_year_data')
self._vehicle_vin = self._glade.get_widget('vehicle_vin_data')
self._vehicle_engine = self._glade.get_widget('vehicle_engine_data')
self._vehicle_fuel = self._glade.get_widget('vehicle_fuel_data')
self._vehicle_obd = self._glade.get_widget('vehicle_obd_data')
self._vehicle_last_connect = self._glade.get_widget(
'vehicle_last_connect_data')
alignment = gtk.Alignment(0, 0, 0, 0)
self.layout = gtk.Layout()
alignment.add(self.layout)
self.pack_start(alignment, True, True)
self.show_all()
self._reset_cbid = app.connect("reset", self._on_reset)
self._switch_cbid = app.notebook.connect('switch-page',
self._notebook_page_change_cb)
def __init__(self):
super(App, self).__init__()
self.set_title("Layout Container App")
self.set_size_request(640, 360)
self.set_position(gtk.WIN_POS_CENTER)
# membuat object scrolled_window
scrolled_window = gtk.ScrolledWindow()
# membuat layout container dengan ukuran 400x400
layout_container = gtk.Layout()
layout_container.set_size(400, 400)
btn = gtk.Button("Klik saya")
# tambahkan button ke dalam layout pada posisi 125,200
layout_container.put(btn, 125, 200)
# tambahkan layout ke dalam scrolled_window
scrolled_window.add(layout_container)
# tambahkan scrolled_window ke dalam window utama
self.add(scrolled_window)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self):
window = gtk.Window()
layout = gtk.Layout()
img1 = DragImage('soccerball.gif', layout)
img2 = DragImage('image2.jpg', layout)
window.add(layout)
window.show_all()
def __init__(self, orientation=VERTICAL):
gtk.Viewport.__init__(self)
Signalizable.__init__(self)
self.orientation = orientation
self.x = 0
self.y = 0
self.offset = 0
self.tags = list()
self.zoom = 1.0
self.show_position = True
self.layout = gtk.Layout()
self.add(self.layout)
size = 25
if self.orientation == HORIZONTAL:
self.set_size_request(-1, size)
elif self.orientation == VERTICAL:
self.set_size_request(size, -1)
self.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.layout.add_events(gtk.gdk.EXPOSURE_MASK)
self.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.connect("motion-notify-event", self.motion, False)
self.connect("button-release-event", self.release)
self.connect("button-press-event", self.press)
self.layout.connect("expose-event", self.expose)
self.install_signal("append-tag")
self.install_signal("move-tag")
def __init__(self):
gtk.Window.__init__(self)
self.set_default_size(800, 600)
button1 = gtk.Button("Button 1")
button2 = gtk.Button("Button 2")
layout = gtk.Layout()
layout.set_size(800, 1200)
layout.put(button1, 20, 20)
layout.put(button2, 700, 350)
vadjust = layout.get_vadjustment()
hadjust = layout.get_hadjustment()
self.vscroll = gtk.VScrollbar(vadjust)
self.vscroll.connect("change-value", self.vscroll_changed)
self.hscroll = gtk.HScrollbar(hadjust)
self.hscroll.connect("change-value", self.hscroll_changed)
table = gtk.Table(2, 2, False)
table.attach(layout, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND)
table.attach(self.vscroll, 1, 2, 0, 1, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK)
table.attach(self.hscroll, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK)
self.add(table)
self.show_all()
self.connect("destroy", lambda w: gtk.main_quit())
def __init__(self, stream, dec, myhostname, cam, decorate=1, normalise=0):
if stream in ["rtcPxlBuf", "rtcCalPxlBuf"]:
self.dim = 2
else:
self.dim = 1
self.win = gtk.Window()
#self.win.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_SPLASHSCREEN)
self.win.set_default_size(300, 300)
self.w = self.h = 300
self.win.set_decorated(decorate) #remove the window frame
self.cam = cam
self.normalise = normalise
self.img = gtk.Image()
#self.img.set_alignment(0,0)
#self.img.set_padding(0,0)
self.pixbufImg = None
#self.event=gtk.EventBox()
#self.event.connect("button-press-event",self.click)
#self.event.connect("button-release-event",self.unclick)
#self.event.connect("motion-notify-event",self.motion)
#self.event.connect("expose-event",self.expose)
#box = gtk.ScrolledWindow()
#box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
#box.add_with_viewport(self.img)
#v=box
lay = gtk.Layout()
lay.put(self.img, 0, 0)
v = lay
#v=gtk.Viewport()
#v.add(self.img)
#box.set_resize_mode(gtk.RESIZE_PARENT)
if self.dim == 2:
#if cam==None:
# self.pixbuf=gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,512,512)
#else:
# self.pixbuf=gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB,False,8,256,256)
self.pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8,
self.w - 50, self.h - 50)
else:
self.pixbuf = None
self.c = controlCorba.controlClient(debug=0)
self.r = self.c.GetStreamBlock(stream,
-1,
callback=self.recvdata,
myhostname=myhostname,
decimate=dec)
self.queue = 0
#vbox.pack_start(self.event)
self.win.add(v) #self.img)
self.win.connect("delete-event", self.quit)
lay.connect("size-allocate", self.changeSize, "size allocate")
#self.img.connect("size-allocate",self.changeSize,"size allocate img")
#self.img.connect("expose-event",self.reSize,"size allocate img")
if self.dim == 2:
self.img.set_from_pixbuf(self.pixbuf)
self.img.queue_draw()
self.win.show_all()
def _setup_gui(self):
alignment = gtk.Alignment(0.5, 0.5, 1.0, 1.0)
self.layout = gtk.Layout()
alignment.add(self.layout)
self.pack_start(alignment, True, True)
self.layout.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse(self._background))
self.show_all()
def __init__(self, sim_manager, controller):
""" Sets up frame. Creates controller panel, GTK window,
layout canvas, GTK timer and event boxes.
"""
self.sim_manager = sim_manager
self.controller = controller
self.vbox = gtk.VBox(False, 0)
self.playing = False
self.press = None
self.resize = False
self.resize_info = None
self.resize_boxes = {}
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_default_size(settings.VISUALIZER_WIDTH,
settings.VISUALIZER_HEIGHT)
self.window.set_title(settings.MAIN_FRAME_TITLE)
self.window.connect("delete_event", self.on_quit)
self.input_panel = Input_Panel(self)
self.controller_panel = Controller_Panel(self)
self.menu_bar = Menu_Bar(self, controller)
self.layout_event_box = gtk.EventBox()
self.canvas_layout = gtk.Layout()
self.layout_event_box.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("#ffffff"))
self.layout_event_box.connect("button_release_event",
controller.on_layout_button_release)
# Used to control frame rate for redrawing graph components
# rate at which we call sim.step()
self.sim_rate = settings.SIMULATOR_DEFAULT_SIM_RATE
self.framerate = settings.SIMULATOR_FRAME_RATE
self.next_gcomponent_redraw = 0
# set up timer
self.timer = TimerGTK3(interval=settings.VISUALIZER_TIMER_INTERVAL)
self.timer.add_callback(self.step)
self.timer.single_shot = True
self.vbox.pack_start(self.menu_bar, False, False, 0)
self.vbox.pack_start(self.controller_panel, False, False, 0)
self.layout_event_box.add(self.canvas_layout)
self.vbox.pack_start(self.layout_event_box, True, True, 0)
self.window.add(self.vbox)
self.window.show_all()
self.controller_panel.toggle_play(False)
def __init__(self,
style='standard',
title="New Window",
movable=1,
closable=1,
hidable=None,
resizable=1,
zoomable=1,
**kwds):
self._all_menus = []
modal = style in _modal_styles
if hidable is None:
hidable = not modal
self._resizable = resizable
gtk_win = gtk.Window(gtk.WINDOW_TOPLEVEL)
gtk_win.set_gravity(gdk.GRAVITY_STATIC)
gtk_win.set_decorated(style <> 'fullscreen'
and (movable or closable or hidable or zoomable))
gtk_win.set_resizable(resizable)
gtk_win.set_modal(style in _modal_styles)
gtk_content = gtk.Layout()
gtk_content.show()
if style in _dialog_styles:
gtk_win.set_type_hint(gdk.WINDOW_TYPE_HINT_DIALOG)
gtk_win.add(gtk_content)
else:
self._gtk_create_menubar()
gtk_box = gtk.VBox()
gtk_box.show()
gtk_box.pack_start(self._gtk_menubar, expand=0, fill=0)
gtk_box.pack_end(gtk_content, expand=1, fill=1)
gtk_win.add(gtk_box)
self._need_menubar_update = 1
self._gtk_connect(gtk_win, 'configure-event',
self._gtk_configure_event)
self._gtk_connect(gtk_win, 'key-press-event',
self._gtk_key_press_event)
self._gtk_connect(gtk_win, 'delete-event', self._gtk_delete_event)
GWindow.__init__(self,
_gtk_outer=gtk_win,
_gtk_inner=gtk_content,
_gtk_focus=gtk_content,
_gtk_input=gtk_content,
style=style,
title=title,
closable=closable)
if style == 'fullscreen':
size = (gdk.screen_width(), gdk.screen_height())
else:
size = (_default_width, _default_height)
self.set_size(size)
self.set(**kwds)
self.become_target()
def __init__(self, _gtk_outer = None, **kwds):
gtk_layout = gtk.Layout()
gtk_layout.add_events(gdk.EXPOSURE_MASK)
gtk_layout.show()
self._gtk_connect(gtk_layout, 'expose-event',
self._gtk_expose_event_signal)
if _gtk_outer:
_gtk_outer.add(gtk_layout)
else:
_gtk_outer = gtk_layout
GDrawableContainer.__init__(self, _gtk_outer = _gtk_outer, _gtk_inner = gtk_layout,
_gtk_focus = gtk_layout, _gtk_input = gtk_layout)
self.set(**kwds)
def __init__(self, shell, prefs):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
#
self._shell = shell
self._prefs = prefs
self._running = False
self._drag_base = -1
self._start_time = datetime.datetime.now()
self._lyrics = None
self._timestamp = [0, sys.maxint]
self._firstline = gtk.Label(_('RBLyrics'))
self._lastline = self._firstline
self._update_source = None
self._scroll = 0
self._font = pango.FontDescription(prefs.get('display.roller.font'))
self._varfont = self._font.copy()
self._varfont.set_weight(pango.WEIGHT_BOLD)
self._foreground = gtk.gdk.Color(prefs.get('display.roller.foreground'))
self._highlight = gtk.gdk.Color(prefs.get('display.roller.highlight'))
#
self._firstline.modify_fg(gtk.STATE_NORMAL, self._highlight)
self._firstline.modify_font(self._font)
self._vbox = gtk.VBox(True)
self._vbox.pack_start(self._firstline)
self._layout = gtk.Layout()
self._layout.add_events(gtk.gdk.BUTTON_RELEASE_MASK|gtk.gdk.BUTTON2_MOTION_MASK|gtk.gdk.POINTER_MOTION_HINT_MASK)
bgcolor = gtk.gdk.Color(prefs.get('display.roller.background'))
self._layout.modify_bg(gtk.STATE_NORMAL, bgcolor)
self._layout.put(self._vbox, 0, 0)
container = gtk.HBox()
container.pack_start(self._layout)
container.show_all()
self.add(container)
self.modify_bg(gtk.STATE_NORMAL, bgcolor)
self.set_decorated(False)
self.set_keep_above(True)
self.stick()
self.set_skip_taskbar_hint(True)
self.set_opacity(float(prefs.get('display.roller.opacity'))/100)
x,y,w,h = map(int, prefs.get('display.roller.window').split(','))
self._layout.realize()
self.realize()
self.set_default_size(w, h)
self.move(x, y)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self._prefs.watcher.append(self)
self._layout.connect('motion-notify-event', self._on_motion_notify)
self.connect('configure-event', self._on_configure)
self.connect('button-press-event', self._on_button_press)
self._layout.connect('button-release-event', self._on_button_release)
return
def __init__(self):
super(PyApp, self).__init__()
self.set_title("layout")
self.set_size_request(300,200)
self.set_position(gtk.WIN_POS_CENTER)
sc = gtk.ScrolledWindow()
lo = gtk.Layout()
lo.set_size(400,400)
button = gtk.Button("Press Me")
lo.put(button, 125,200)
sc.add(lo)
self.add(sc)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self, frame, name, title):
super(HandsetPage, self).__init__(frame, name, title)
self.queueName = 'launcher'
self.tm_queueName = 'launcher'
self.paused = False
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_border_width(2)
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
lw = gtk.Layout()
lw.set_size(420, 340)
scrolled_window.add(lw)
lw.show()
scrolled_window.show()
frame.pack_start(scrolled_window, expand=True, fill=True)
self.lw = lw
self.btn_cancel = gtk.Button("Cancel")
self.btn_cancel.connect("clicked", lambda w: self.cancel())
self.btn_cancel.modify_bg(gtk.STATE_NORMAL,
common.launcher_colors['cancelbtn'])
self.btn_cancel.show()
self.leftbtns.pack_end(self.btn_cancel)
## menu = self.add_menu()
## self.add_close()
menu = self.add_pulldownmenu("Page")
# Add items to the menu
item = gtk.MenuItem(label="Reset")
menu.append(item)
item.connect_object("activate", lambda w: self.reset(), "menu.Reset")
item.show()
#self.add_close(side=Page.LEFT)
#self.add_close()
item = gtk.MenuItem(label="Close")
menu.append(item)
item.connect_object("activate", lambda w: self.close(), "menu.Close")
item.show()
self.build_handset()
def main(args):
win = gtk.Window()
win.set_border_width(5)
win.set_title('Widget test')
win.connect('delete-event', gtk.main_quit)
frame = gtk.Layout()
win.add(frame)
w = PyGtkWidget(TEXT)
frame.add(w)
win.show_all()
gtk.main()
def __init__(self):
cpokerinterface.init(
callback=self.event,
glade="../pokerclient2d/data/interface/interface2d.glade",
# gtkrc = "../pokerclient2d/data/Aero/gtkrc",
verbose=3)
window = gtk.Window()
window.set_default_size(1024, 768)
window.set_title("Poker Interface")
window.set_name("lobby_window_root")
self.screen = gtk.Layout()
self.screen.set_size(1024, 768)
self.screen.set_name("screen")
window.add(self.screen)
window.show_all()
def widgetSetUp(self):
"""
Arrange for self.resize() to be called whenever the user
interactively resizes the window.
"""
if not self.widget:
self.create()
if not hasattr(self, '_gtk_container'):
self._gtk_container = gtk.Layout()
self.widget.add(self._gtk_container)
self._gtk_container.show()
if not self.connected:
self.widget.connect('size_allocate', self.resizeHandler)
self.widget.connect('destroy', self.close)
self.connected = 1
def __init__(self):
window = gtk.Window()
window.connect("destroy", lambda w: gtk.main_quit())
layout = gtk.Layout()
Compoent(layout,70,70,"one");
Compoent(layout,90,70,"two");
Compoent(layout,40,70,"three");
Compoent(layout,20,70,"four");
window.add(layout)
window.show_all()
def __init__(self):
# create the top level window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title("Layout Example")
window.set_default_size(300, 300)
window.connect("delete-event", self.WindowDeleteEvent)
window.connect("destroy", self.WindowDestroy)
# create the table and pack into the window
table = gtk.Table(2, 2, False)
window.add(table)
# create the layout widget and pack into the table
self.layout = gtk.Layout(None, None)
self.layout.set_size(600, 600)
table.attach(self.layout, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
# create the scrollbars and pack into the table
vScrollbar = gtk.VScrollbar(None)
table.attach(vScrollbar, 1, 2, 0, 1, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
hScrollbar = gtk.HScrollbar(None)
table.attach(hScrollbar, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
# tell the scrollbars to use the layout widget's adjustments
vAdjust = self.layout.get_vadjustment()
vScrollbar.set_adjustment(vAdjust)
hAdjust = self.layout.get_hadjustment()
hScrollbar.set_adjustment(hAdjust)
# create 3 buttons and put them into the layout widget
button = gtk.Button("Press Me")
button.connect("clicked", self.ButtonClicked)
self.layout.put(button, 0, 0)
button = gtk.Button("Press Me")
button.connect("clicked", self.ButtonClicked)
self.layout.put(button, 100, 0)
button = gtk.Button("Press Me")
button.connect("clicked", self.ButtonClicked)
self.layout.put(button, 200, 0)
# show all the widgets
window.show_all()
def makeLayout(self):
self.lwidth = self.WIDTH
self.lheight = self.HEIGHT
box = gtk.VBox(False,0)
box.show()
table = gtk.Table(2, 2, False)
table.show()
box.pack_start(table, True, True, 0)
layout = gtk.Layout()
self.layout = layout
layout.set_size(self.lwidth, self.lheight)
layout.connect("size-allocate", self.layout_resize)
layout.show()
table.attach(layout, 0, 1, 0, 1, gtk.FILL|gtk.EXPAND,
gtk.FILL|gtk.EXPAND, 0, 0)
# create the scrollbars and pack into the table
vScrollbar = gtk.VScrollbar(None)
vScrollbar.show()
table.attach(vScrollbar, 1, 2, 0, 1, gtk.FILL|gtk.SHRINK,
gtk.FILL|gtk.SHRINK, 0, 0)
hScrollbar = gtk.HScrollbar(None)
hScrollbar.show()
table.attach(hScrollbar, 0, 1, 1, 2, gtk.FILL|gtk.SHRINK,
gtk.FILL|gtk.SHRINK,
0, 0)
# tell the scrollbars to use the layout widget's adjustments
vAdjust = layout.get_vadjustment()
vScrollbar.set_adjustment(vAdjust)
hAdjust = layout.get_hadjustment()
hScrollbar.set_adjustment(hAdjust)
layout.connect("drag_data_received", self.receiveCallback)
layout.drag_dest_set(gtk.DEST_DEFAULT_MOTION |
gtk.DEST_DEFAULT_HIGHLIGHT |
gtk.DEST_DEFAULT_DROP,
self.toCanvas, gtk.gdk.ACTION_COPY)
self.addImage(gtkxpm.gtk_xpm, 0, 0)
button = gtk.Button("Text Target")
button.show()
button.connect("drag_data_received", self.receiveCallback)
button.drag_dest_set(gtk.DEST_DEFAULT_MOTION |
gtk.DEST_DEFAULT_HIGHLIGHT |
gtk.DEST_DEFAULT_DROP,
self.toButton, gtk.gdk.ACTION_COPY)
box.pack_start(button, False, False, 0)
return box
def __init__(self, session):
gtk.HBox.__init__(self)
self.session = session
self.ft = extension.get_default('filetransfer widget')
self.set_spacing(3)
self.hbox = gtk.HBox()
self.hbox.set_spacing(3)
self.layout = gtk.Layout()
self.layout.put(self.hbox, 0, 0)
self.layout.set_size(self.hbox.get_allocation().width, \
self.hbox.get_allocation().height + 100)
self.current = 0
self.speed = 5
self.page = 0
self.twidth = 150
self.num_transfers = 0
self.dest = 0
self.div = 0
self.new_transfer_bar = None
self.transfers = {}
arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_IN)
arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_IN)
self.b_go_left = gtk.Button()
self.b_go_left.add(arrow_left)
self.b_go_left.set_sensitive(False)
self.b_go_left.set_relief(gtk.RELIEF_NONE)
self.b_go_left.connect('clicked', self._on_left_button_clicked)
self.b_go_right = gtk.Button()
self.b_go_right.add(arrow_right)
self.b_go_right.set_sensitive(False)
self.b_go_right.set_relief(gtk.RELIEF_NONE)
self.b_go_right.connect('clicked', self._on_right_button_clicked)
self.pack_start(self.b_go_left, False, False)
self.pack_start(self.layout)
self.pack_start(self.b_go_right, False, False)
def __init__(self, controller, parentUI, parentConversation):
gtk.HBox.__init__(self)
self.set_spacing(3)
self.controller = controller
self.parentUI = parentUI
self.parentConversation = parentConversation
self.hbox = gtk.HBox()
self.hbox.set_spacing(3)
self.layout = gtk.Layout()
self.layout.put(self.hbox, 0, 0)
self.layout.set_size(self.hbox.get_allocation().width, \
self.hbox.get_allocation().height + 100)
self.current = 0
self.speed = 5
self.page = 0
self.twidth = 150
self.num_transfers = 0
arrowLeft = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_IN)
arrowRight = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_IN)
self.btnLeft = gtk.Button()
self.btnLeft.add(arrowLeft)
self.btnLeft.set_sensitive(False)
self.btnLeft.set_relief(gtk.RELIEF_NONE)
self.btnLeft.connect("clicked", self.onbtnLeft)
self.btnRight = gtk.Button()
self.btnRight.add(arrowRight)
self.btnRight.set_sensitive(False)
self.btnRight.set_relief(gtk.RELIEF_NONE)
self.btnRight.connect("clicked", self.onbtnRight)
self.pack_start(self.btnLeft, False, False)
self.pack_start(self.layout)
self.pack_start(self.btnRight, False, False)
def __init__(self, window):
gtk.HBox.__init__(self, False, 0)
self._window = window
self._loaded = False
self._load_task = None
self._height = 0
self._liststore = gtk.ListStore(gtk.gdk.Pixbuf)
self._treeview = gtk.TreeView(self._liststore)
self._treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
[('text/uri-list', 0, 0)],
gtk.gdk.ACTION_COPY)
self._column = gtk.TreeViewColumn(None)
cellrenderer = gtk.CellRendererPixbuf()
self._layout = gtk.Layout()
self._layout.put(self._treeview, 0, 0)
self._column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self._treeview.append_column(self._column)
self._column.pack_start(cellrenderer, True)
self._column.set_attributes(cellrenderer, pixbuf=0)
self._column.set_fixed_width(prefs['thumbnail size'] + 7)
self._layout.set_size_request(prefs['thumbnail size'] + 7, 0)
self._treeview.set_headers_visible(False)
self._vadjust = self._layout.get_vadjustment()
self._vadjust.step_increment = 15
self._vadjust.page_increment = 1
self._scroll = gtk.VScrollbar(None)
self._scroll.set_adjustment(self._vadjust)
self._selection = self._treeview.get_selection()
self.pack_start(self._layout)
self.pack_start(self._scroll)
self._treeview.connect_after('drag_begin', self._drag_begin)
self._treeview.connect('drag_data_get', self._drag_data_get)
self._selection.connect('changed', self._selection_event)
self._layout.connect('scroll_event', self._scroll_event)
def __init__(self, settings):
PokerInterface.__init__(self)
self.verbose = settings.headerGetInt("/settings/@verbose")
datadir = settings.headerGet("/settings/data/@path")
_pokerinterface.init(callback = self.event,
datadir = datadir,
glade = datadir + "/interface/interface2d.glade",
verbose = self.verbose,
)
self.width = settings.headerGetInt("/settings/screen/@width")
self.height = settings.headerGetInt("/settings/screen/@height")
window = gtk.Window()
self.window = window
window.set_default_size(self.width, self.height)
window.set_title("Poker")
window.set_name("lobby_window_root")
window.set_icon_from_file(datadir + "/interface/pixmaps/poker2D_16.png")
self.screen = gtk.Layout()
self.screen.set_size(self.width, self.height)
self.screen.set_name("screen")
window.add(self.screen)
window.show_all()
def __init__(self,
moving_callback=None,
color_callback=None,
gradient=None):
"""
moving_callback - callback function to be called when changing position of the selected color(for spin widget)
gradient - editable gradient
"""
gtk.Viewport.__init__(self)
self.set_size_request(-1, 70)
self.set_shadow_type(gtk.SHADOW_NONE)
self.width = 0
self.height = 0
self._motion = False
self.selected = -1
self.x = 0
self.move = False
self.gradient = gradient
self.gradient.change_size(0, 0, 1, 0)
self.moving_callback = moving_callback
self.color_callback = color_callback
self.layout = gtk.Layout()
self.add(self.layout)
self.layout.set_events(0)
self.layout.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.layout.connect("button-press-event", self.press)
self.layout.add_events(gtk.gdk.EXPOSURE_MASK)
self.layout.connect("expose-event", self.expose)
self.layout.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.layout.connect("button-release-event", self.release)
self.layout.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.layout.connect("motion-notify-event", self.motion)
self.layout.add_events(gtk.gdk.ENTER_NOTIFY_MASK)
self.layout.connect("enter-notify-event", self.enter)
self.layout.add_events(gtk.gdk.LEAVE_NOTIFY_MASK)
self.layout.connect("leave-notify-event", self.leave)
def __init__(self,
animate_gifs=False,
fullscreen=False,
show_library=False,
open_path=None,
open_page=1):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
# ----------------------------------------------------------------
# Attributes
# ----------------------------------------------------------------
self.is_fullscreen = False
self.is_double_page = False
self.is_manga_mode = False
self.is_virtual_double_page = False # I.e. a wide image is displayed
self.zoom_mode = preferences.ZOOM_MODE_BEST
self.width = None
self.height = None
self._manual_zoom = 100 # In percent of original image size
self._waiting_for_redraw = False
self.file_handler = filehandler.FileHandler(self)
self.thumbnailsidebar = thumbbar.ThumbnailSidebar(self)
self.statusbar = status.Statusbar()
self.slideshow = slideshow.Slideshow(self)
self.cursor_handler = cursor.CursorHandler(self)
self.enhancer = enhance.ImageEnhancer(self)
self.glass = lens.MagnifyingGlass(self)
self.ui_manager = ui.MainUI(self)
self.menubar = self.ui_manager.get_widget('/Menu')
self.toolbar = self.ui_manager.get_widget('/Tool')
self.popup = self.ui_manager.get_widget('/Popup')
self.actiongroup = self.ui_manager.get_action_groups()[0]
self.left_image = gtk.Image()
self.right_image = gtk.Image()
self._image_box = gtk.HBox(False, 2)
self._main_layout = gtk.Layout()
self._event_handler = event.EventHandler(self)
self._vadjust = self._main_layout.get_vadjustment()
self._hadjust = self._main_layout.get_hadjustment()
self._vscroll = gtk.VScrollbar(self._vadjust)
self._hscroll = gtk.HScrollbar(self._hadjust)
# ----------------------------------------------------------------
# Setup
# ----------------------------------------------------------------
self.set_title('Comix')
self.set_size_request(300, 300) # Avoid making the window *too* small
self.resize(prefs['window width'], prefs['window height'])
# This is a hack to get the focus away from the toolbar so that
# we don't activate it with space or some other key (alternative?)
self.toolbar.set_focus_child(
self.ui_manager.get_widget('/Tool/expander'))
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
self.toolbar.set_icon_size(gtk.ICON_SIZE_LARGE_TOOLBAR)
self._image_box.add(self.left_image)
self._image_box.add(self.right_image)
self._image_box.show_all()
self._main_layout.put(self._image_box, 0, 0)
self.set_bg_colour(prefs['bg colour'])
self._vadjust.step_increment = 15
self._vadjust.page_increment = 1
self._hadjust.step_increment = 15
self._hadjust.page_increment = 1
table = gtk.Table(2, 2, False)
table.attach(self.thumbnailsidebar, 0, 1, 2, 5, gtk.FILL,
gtk.FILL | gtk.EXPAND, 0, 0)
table.attach(self._main_layout, 1, 2, 2, 3, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
table.attach(self._vscroll, 2, 3, 2, 3, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
table.attach(self._hscroll, 1, 2, 4, 5, gtk.FILL | gtk.SHRINK,
gtk.FILL, 0, 0)
table.attach(self.menubar, 0, 3, 0, 1, gtk.FILL | gtk.SHRINK, gtk.FILL,
0, 0)
table.attach(self.toolbar, 0, 3, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL,
0, 0)
table.attach(self.statusbar, 0, 3, 5, 6, gtk.FILL | gtk.SHRINK,
gtk.FILL, 0, 0)
if prefs['default double page']:
self.actiongroup.get_action('double_page').activate()
if prefs['default fullscreen'] or fullscreen:
self.actiongroup.get_action('fullscreen').activate()
if prefs['default manga mode']:
self.actiongroup.get_action('manga_mode').activate()
if prefs['default zoom mode'] == preferences.ZOOM_MODE_BEST:
self.actiongroup.get_action('best_fit_mode').activate()
elif prefs['default zoom mode'] == preferences.ZOOM_MODE_WIDTH:
self.actiongroup.get_action('fit_width_mode').activate()
elif prefs['default zoom mode'] == preferences.ZOOM_MODE_HEIGHT:
self.actiongroup.get_action('fit_height_mode').activate()
elif prefs['default zoom mode'] == preferences.ZOOM_MODE_MANUAL:
# This little ugly hack is to get the activate call on
# 'fit_manual_mode' to actually create an event (and callback).
# Since manual mode is the default selected radio button action
# it won't send an event if we activate it when it is already
# the selected one.
self.actiongroup.get_action('best_fit_mode').activate()
self.actiongroup.get_action('fit_manual_mode').activate()
if prefs['show toolbar']:
prefs['show toolbar'] = False
self.actiongroup.get_action('toolbar').activate()
if prefs['show menubar']:
prefs['show menubar'] = False
self.actiongroup.get_action('menubar').activate()
if prefs['show statusbar']:
prefs['show statusbar'] = False
self.actiongroup.get_action('statusbar').activate()
if prefs['show scrollbar']:
prefs['show scrollbar'] = False
self.actiongroup.get_action('scrollbar').activate()
if prefs['show thumbnails']:
prefs['show thumbnails'] = False
self.actiongroup.get_action('thumbnails').activate()
if prefs['hide all']:
prefs['hide all'] = False
self.actiongroup.get_action('hide all').activate()
if prefs['keep transformation']:
prefs['keep transformation'] = False
self.actiongroup.get_action('keep_transformation').activate()
else:
prefs['rotation'] = 0
prefs['vertical flip'] = False
prefs['horizontal flip'] = False
prefs['animate'] = animate_gifs
self.add(table)
table.show()
self._main_layout.show()
self._display_active_widgets()
self._main_layout.set_events(gtk.gdk.BUTTON1_MOTION_MASK
| gtk.gdk.BUTTON2_MOTION_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self._main_layout.drag_dest_set(
gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 0)],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self.connect('delete_event', self.terminate_program)
self.connect('key_press_event', self._event_handler.key_press_event)
self.connect('configure_event', self._event_handler.resize_event)
self._main_layout.connect('button_release_event',
self._event_handler.mouse_release_event)
self._main_layout.connect('scroll_event',
self._event_handler.scroll_wheel_event)
self._main_layout.connect('button_press_event',
self._event_handler.mouse_press_event)
self._main_layout.connect('motion_notify_event',
self._event_handler.mouse_move_event)
self._main_layout.connect('drag_data_received',
self._event_handler.drag_n_drop_event)
self.ui_manager.set_sensitivities()
self.show()
if open_path is not None:
self.file_handler.open_file(open_path, open_page)
if show_library:
self.actiongroup.get_action('library').activate()
def create_control_window(self):
self.option_groups = []
dialog = gtk.Dialog("Advanced Settings", None,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
self.advanced_settings_dialog = dialog #gtk.Window()
close_button = dialog.get_widget_for_response(gtk.RESPONSE_CLOSE)
close_button.connect("clicked",
self.advancedSettingsDialogHideCallback, None)
# The dialog's main area will contain a notebook
# with one page for each "group" as returned by SANE.
notebook = gtk.Notebook()
#dialog.vbox.pack_start(notebook)
self.notebook = notebook
self.advanced_settings_dialog.add(notebook)
self.advanced_settings_dialog.set_title("Advanced Settings")
latest_pane = None
latest_pane_label = None
y_offset = -20
for x in self.options_as_list:
y_offset += 30
# New pane for each new group
if x[4] == sane.TYPE_GROUP:
self.option_groups.append(x)
if latest_pane is not None:
notebook.append_page(latest_pane,
gtk.Label(latest_pane_label))
latest_pane = gtk.ScrolledWindow()
latest_pane.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS)
latest_pane.set_size_request(400, 100)
latest_layout = gtk.Layout()
#latest_layout.set_size(300,1000)
latest_pane.add(latest_layout)
latest_pane.show()
latest_layout.show()
latest_pane_label = x[1]
y_offset = -20
elif x[4] == sane.TYPE_BUTTON:
pass
else:
opt = self.device.opt[x[1].replace("-", "_")]
label = gtk.Label()
label.set_text(opt.desc)
latest_layout.put(label, 0, y_offset)
label.show()
y_offset += 30
if sane_types[opt.type] == 'BOOL':
check = gtk.CheckButton(x[1])
check.show()
check.set_sensitive(opt.is_active() and opt.is_settable())
# determine the option's current value, and set the widget accordingly
try:
cur_value = repr(getattr(self.device, opt.py_name))
except AttributeError:
cur_value = "***Inactive option*** %s" % (
opt.py_name, )
try:
check.set_active(int(cur_value))
except ValueError:
pass
# set up callback for check, with the option name as data to the callback
check.connect("toggled", self.check_toggled, opt.py_name)
latest_layout.put(check, 20, y_offset)
else:
hbox = gtk.HBox()
label = gtk.Label(x[1])
entry = gtk.Entry(20)
entry.set_sensitive(opt.is_active() and opt.is_settable())
# determine the option's current value,
#set the widget accordingly
try:
cur_value = repr(getattr(self.device, opt.py_name))
except AttributeError:
cur_value = "***Inactive option*** %s" % (
opt.py_name, )
entry.set_text(str(cur_value).strip("'"))
# set up callback for entry, with the option name as data to the callback
entry.connect("activate", self.entry_activated,
opt.py_name)
hbox.pack_start(label)
hbox.pack_start(entry)
latest_layout.put(hbox, 20, y_offset)
hbox.show()
label.show()
entry.show()
print "Output type must be %s, unit %s is active %s is settable %s" % (
sane_types[opt.type], sane_units[opt.unit],
opt.is_active(), opt.is_settable())
if type(opt.constraint) == type([]):
print "Build options for option menu %s" % (
opt.constraint, )
if type(opt.constraint) == type(()):
print "Min %s max %s step %s" % (opt.constraint[0],
opt.constraint[1],
opt.constraint[2])
if latest_pane is not None:
notebook.append_page(latest_pane, gtk.Label(latest_pane_label))
self.advanced_settings_dialog.vbox.pack_start(notebook)
self.notebook.show()
self.advanced_settings_dialog.show()
return self.advanced_settings_dialog
def __init__(self, window):
gtk.HBox.__init__(self, False, 0)
self._window = window
# Cache/thumbnail load status
self._loaded = False
self._is_loading = False
self._stop_cacheing = False
# Caching threads
self._cache_threads = None
self._currently_selected_page = 0
self._selection_is_forced = False
# models - contains data
self._thumbnail_liststore = gtk.ListStore(gobject.TYPE_INT, gtk.gdk.Pixbuf)
# view - responsible for laying out the columns
self._treeview = gtk.TreeView(self._thumbnail_liststore)
# enable drag and dropping of images from thumbnail bar to some file
# manager
self._treeview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
[('text/uri-list', 0, 0)], gtk.gdk.ACTION_COPY)
self._thumbnail_page_treeviewcolumn = gtk.TreeViewColumn(None)
self._thumbnail_image_treeviewcolumn = gtk.TreeViewColumn(None)
self._treeview.append_column(self._thumbnail_page_treeviewcolumn)
self._treeview.append_column(self._thumbnail_image_treeviewcolumn)
self._text_cellrenderer = gtk.CellRendererText()
self._pixbuf_cellrenderer = gtk.CellRendererPixbuf()
bg_colour = prefs['thumb bg colour']
self._pixbuf_cellrenderer.set_property('cell-background-gdk', gtk.gdk.colormap_get_system().alloc_color(gtk.gdk.Color(
bg_colour[0], bg_colour[1], bg_colour[2]), False, True))
self._text_cellrenderer.set_property('background-gdk', gtk.gdk.colormap_get_system().alloc_color(gtk.gdk.Color(
bg_colour[0], bg_colour[1], bg_colour[2]), False, True))
self._thumbnail_page_treeviewcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
self._thumbnail_page_treeviewcolumn.pack_start(self._text_cellrenderer, False)
self._thumbnail_page_treeviewcolumn.add_attribute(self._text_cellrenderer, 'text', 0)
if not prefs['show page numbers on thumbnails']:
self._thumbnail_page_treeviewcolumn.set_property('visible', False)
self._thumbnail_image_treeviewcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
self._thumbnail_image_treeviewcolumn.pack_start(self._pixbuf_cellrenderer, True)
self._thumbnail_image_treeviewcolumn.add_attribute(self._pixbuf_cellrenderer, 'pixbuf', 1)
self._thumbnail_image_treeviewcolumn.set_alignment(0.0)
self._layout = gtk.Layout()
self._layout.put(self._treeview, 0, 0)
self.update_layout_size()
self._treeview.set_headers_visible(False)
self._vadjust = self._layout.get_vadjustment()
self._vadjust.step_increment = 15
self._vadjust.page_increment = 1
self._scroll = gtk.VScrollbar(None)
self._scroll.set_adjustment(self._vadjust)
self._selection = self._treeview.get_selection()
self.pack_start(self._layout)
self.pack_start(self._scroll)
self._treeview.connect('columns-changed', self.refresh)
self._treeview.connect('expose-event', self.refresh)
self._treeview.connect_after('drag_begin', self._drag_begin)
self._treeview.connect('drag_data_get', self._drag_data_get)
self._selection.connect('changed', self._selection_event)
self._layout.connect('scroll_event', self._scroll_event)
self.show_all()
def __init__(self,
fullscreen=False,
is_slideshow=slideshow,
show_library=False,
manga_mode=False,
double_page=False,
zoom_mode=None,
open_path=None,
open_page=1):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
# ----------------------------------------------------------------
# Attributes
# ----------------------------------------------------------------
self.is_in_focus = True
self.is_fullscreen = False
self.is_double_page = False
self.is_manga_mode = False
self.is_virtual_double_page = False # I.e. a wide image is displayed
self.width = None
self.height = None
self.was_out_of_focus = False
#: Used to remember if changing to fullscreen enabled 'Hide all'
self.hide_all_forced = False
self._waiting_for_redraw = False
self._image_box = gtk.HBox(False, 2)
self._main_layout = gtk.Layout()
self._event_handler = event.EventHandler(self)
self._vadjust = self._main_layout.get_vadjustment()
self._hadjust = self._main_layout.get_hadjustment()
self._vscroll = gtk.VScrollbar(self._vadjust)
self._hscroll = gtk.HScrollbar(self._hadjust)
self.filehandler = file_handler.FileHandler(self)
self.imagehandler = image_handler.ImageHandler(self)
self.imagehandler.page_available += self._page_available
self.thumbnailsidebar = thumbbar.ThumbnailSidebar(self)
self.statusbar = status.Statusbar()
self.clipboard = clipboard.Clipboard(self)
self.slideshow = slideshow.Slideshow(self)
self.cursor_handler = cursor_handler.CursorHandler(self)
self.enhancer = enhance_backend.ImageEnhancer(self)
self.lens = lens.MagnifyingLens(self)
self.osd = osd.OnScreenDisplay(self)
self.zoom = zoom.ZoomModel()
self.uimanager = ui.MainUI(self)
self.menubar = self.uimanager.get_widget('/Menu')
self.toolbar = self.uimanager.get_widget('/Tool')
self.popup = self.uimanager.get_widget('/Popup')
self.actiongroup = self.uimanager.get_action_groups()[0]
self.left_image = gtk.Image()
self.right_image = gtk.Image()
# ----------------------------------------------------------------
# Setup
# ----------------------------------------------------------------
self.set_title(constants.APPNAME)
self.set_size_request(300, 300) # Avoid making the window *too* small
self.resize(prefs['window width'], prefs['window height'])
# Hook up keyboard shortcuts
self._event_handler.register_key_events()
# This is a hack to get the focus away from the toolbar so that
# we don't activate it with space or some other key (alternative?)
self.toolbar.set_focus_child(
self.uimanager.get_widget('/Tool/expander'))
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
self.toolbar.set_icon_size(gtk.ICON_SIZE_LARGE_TOOLBAR)
self._image_box.add(self.left_image)
self._image_box.add(self.right_image)
self._image_box.show_all()
self._main_layout.put(self._image_box, 0, 0)
self.set_bg_colour(prefs['bg colour'])
self._vadjust.step_increment = 15
self._vadjust.page_increment = 1
self._hadjust.step_increment = 15
self._hadjust.page_increment = 1
table = gtk.Table(2, 2, False)
table.attach(self.thumbnailsidebar, 0, 1, 2, 5, gtk.FILL,
gtk.FILL | gtk.EXPAND, 0, 0)
table.attach(self._main_layout, 1, 2, 2, 3, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
table.attach(self._vscroll, 2, 3, 2, 3, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
table.attach(self._hscroll, 1, 2, 4, 5, gtk.FILL | gtk.SHRINK,
gtk.FILL, 0, 0)
table.attach(self.menubar, 0, 3, 0, 1, gtk.FILL | gtk.SHRINK, gtk.FILL,
0, 0)
table.attach(self.toolbar, 0, 3, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL,
0, 0)
table.attach(self.statusbar, 0, 3, 5, 6, gtk.FILL | gtk.SHRINK,
gtk.FILL, 0, 0)
if prefs['default double page'] or double_page:
self.actiongroup.get_action('double_page').activate()
if prefs['default manga mode'] or manga_mode:
self.actiongroup.get_action('manga_mode').activate()
# Determine zoom mode. If zoom_mode is passed, it overrides
# the zoom mode preference.
zoom_actions = {
constants.ZOOM_MODE_BEST: 'best_fit_mode',
constants.ZOOM_MODE_WIDTH: 'fit_width_mode',
constants.ZOOM_MODE_HEIGHT: 'fit_height_mode',
constants.ZOOM_MODE_SIZE: 'fit_size_mode',
constants.ZOOM_MODE_MANUAL: 'fit_manual_mode'
}
if zoom_mode is not None:
zoom_action = zoom_actions[zoom_mode]
else:
zoom_action = zoom_actions[prefs['zoom mode']]
if zoom_action == 'fit_manual_mode':
# This little ugly hack is to get the activate call on
# 'fit_manual_mode' to actually create an event (and callback).
# Since manual mode is the default selected radio button action
# it won't send an event if we activate it when it is already
# the selected one.
self.actiongroup.get_action('best_fit_mode').activate()
self.actiongroup.get_action(zoom_action).activate()
if prefs['stretch']:
self.actiongroup.get_action('stretch').activate()
if prefs['invert smart scroll']:
self.actiongroup.get_action('invert_scroll').activate()
if prefs['show toolbar']:
prefs['show toolbar'] = False
self.actiongroup.get_action('toolbar').activate()
if prefs['show menubar']:
prefs['show menubar'] = False
self.actiongroup.get_action('menubar').activate()
if prefs['show statusbar']:
prefs['show statusbar'] = False
self.actiongroup.get_action('statusbar').activate()
if prefs['show scrollbar']:
prefs['show scrollbar'] = False
self.actiongroup.get_action('scrollbar').activate()
if prefs['show thumbnails']:
prefs['show thumbnails'] = False
self.actiongroup.get_action('thumbnails').activate()
if prefs['hide all']:
prefs['hide all'] = False
self.actiongroup.get_action('hide all').activate()
if prefs['keep transformation']:
prefs['keep transformation'] = False
self.actiongroup.get_action('keep_transformation').activate()
else:
prefs['rotation'] = 0
prefs['vertical flip'] = False
prefs['horizontal flip'] = False
self.actiongroup.get_action('menu_autorotate_width').set_sensitive(
False)
self.actiongroup.get_action('menu_autorotate_height').set_sensitive(
False)
self.add(table)
table.show()
self._main_layout.show()
self._display_active_widgets()
self._main_layout.set_events(gtk.gdk.BUTTON1_MOTION_MASK
| gtk.gdk.BUTTON2_MOTION_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self._main_layout.drag_dest_set(
gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 0)],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self.connect('focus-in-event', self.gained_focus)
self.connect('focus-out-event', self.lost_focus)
self.connect('delete_event', self.close_program)
self.connect('key_press_event', self._event_handler.key_press_event)
self.connect('key_release_event',
self._event_handler.key_release_event)
self.connect('configure_event', self._event_handler.resize_event)
self._main_layout.connect('button_release_event',
self._event_handler.mouse_release_event)
self._main_layout.connect('scroll_event',
self._event_handler.scroll_wheel_event)
self._main_layout.connect('button_press_event',
self._event_handler.mouse_press_event)
self._main_layout.connect('motion_notify_event',
self._event_handler.mouse_move_event)
self._main_layout.connect('drag_data_received',
self._event_handler.drag_n_drop_event)
self.uimanager.set_sensitivities()
self.show()
# If MComix is set to start in fullscreen mode, it
# cannot switch to windowed mode on Win32 unless this
# condition is set to trigger after normal show().
if prefs['default fullscreen'] or fullscreen:
self.actiongroup.get_action('fullscreen').activate()
if prefs['previous quit was quit and save']:
fileinfo = self.filehandler.read_fileinfo_file()
if fileinfo != None:
open_path = fileinfo[0]
open_page = fileinfo[1] + 1
prefs['previous quit was quit and save'] = False
if open_path is not None:
self.filehandler.open_file(open_path, open_page)
if is_slideshow:
self.actiongroup.get_action('slideshow').activate()
if show_library:
self.actiongroup.get_action('library').activate()
def widgetSetUp(self):
if not hasattr(self, '_gtk_container'):
self._gtk_container = gtk.Layout()
self.widget.add(self._gtk_container)
self._gtk_container.show()
def __init__(self, cwin):
self.version = this_software_version
global CONFIG_THEME_PATH
CONFIG_THEME_PATH = getIceWMPrivConfigPath() + "cursors" + os.sep
icepref_td.CONFIG_THEME_PATH = getIceWMPrivConfigPath(
) + "cursors" + os.sep
icepref_td.APP_WINDOW = cwin
try:
os.makedirs(CONFIG_THEME_PATH)
except:
pass
self.cursors = [
'left.xpm', 'move.xpm', 'right.xpm', 'sizeB.xpm', 'sizeBL.xpm',
'sizeBR.xpm', 'sizeL.xpm', 'sizeR.xpm', 'sizeT.xpm',
'sizeTL.xpm', 'sizeTR.xpm'
]
self.widgets = []
self.vbox = gtk.VBox(0, 0)
vbox = self.vbox
vbox.pack_start(gtk.Label(_("Cursor Editor")), 0, 0, 3)
sc = gtk.ScrolledWindow()
slay = gtk.Layout()
self.slay = slay
sc.add(slay)
vbox.pack_start(sc, 1, 1, 6)
myy = 3
for ii in self.cursors:
hb = gtk.HBox(0, 0)
hb.set_border_width(2)
cwid = icepref_td.ImageWidget(ii, "\"" + ii + "\"",
icepref_td.ImagePreviewer(0))
cwid.entry.set_editable(0)
cwid.set_data("my_image", ii)
self.widgets.append(cwid)
hb.pack_start(cwid, 1, 1, 0)
hb.show_all()
f = gtk.Frame()
f.add(hb)
f.show_all()
self.slay.put(f, 3, myy)
myy = myy + f.size_request()[1] + 4
for ii in self.widgets:
ii.PREV.update_image(CONFIG_THEME_PATH + ii.get_data("my_image"))
slay.set_size(400, myy + 50)
vbox.set_border_width(0)
#cwin.set_default_size(420,470)
actstr = _('/File/_Apply Changes Now...'
)[_('/File/_Apply Changes Now...').rfind("/") +
1:len(_('/File/_Apply Changes Now...'))].replace(
"_", "").replace(".", "").strip()
abutt = gtk.Button(" " + actstr + " ")
abutt.connect(
"clicked",
restart_ice) # bug fix, 5.5.2003, left this out of vers. 2.2
TIPS.set_tip(abutt, actstr)
cbutton = gtk.Button(_("Close"))
TIPS.set_tip(cbutton, _("Close"))
cbutton.connect("clicked", doQuit)
hbox1 = gtk.HBox(1, 0)
hbox1.set_border_width(3)
hbox1.set_spacing(5)
hbox1.pack_start(abutt, 1, 1, 0)
hbox1.pack_start(cbutton, 1, 1, 0)
vbox.pack_start(hbox1, 0, 0, 1)
self.mainvbox = vbox
vbox.show_all()
