from GUI import export
from GUI.GImageBases import ImageBase as GImageBase
class ImageBase(GImageBase):
# def get_width(self):
# return self._gtk_surface.get_width()
#
# def get_height(self):
# return self._gtk_surface.get_height()
def draw(self, canvas, src_rect, dst_rect):
sx, sy, sr, sb = src_rect
dx, dy, dr, db = dst_rect
sw = sr - sx
sh = sb - sy
dw = dr - dx
dh = db - dy
ctx = canvas._gtk_ctx
ctx.save()
ctx.translate(dx, dy)
ctx.new_path()
ctx.rectangle(0, 0, dw, dh)
ctx.clip()
ctx.scale(dw / sw, dh / sh)
self._gtk_set_source(canvas._gtk_ctx, -sx, -sy)
ctx.paint()
ctx.restore()
export(ImageBase)
def set_font(self, x):
self._ns_column.dataCell().setFont_(x._ns_font)
def get_header_font(self):
return Font._from_ns_font(self._ns_column.headerCell().font())
def set_header_font(self, x):
self._ns_column.headerCell().setFont_(x._ns_font)
def get_just(self):
return ns_get_just(self._ns_column.dataCell())
def set_just(self, x):
ns_column = self._ns_column
ns_set_just(ns_column.headerCell(), x)
ns_set_just(ns_column.dataCell(), x)
#-------------------------------------------------------------------------------
class PyNSTableColumn(NSTableColumn):
pass
#-------------------------------------------------------------------------------
export(TableColumn)
titles, values = self._extract_initial_items(kwds)
self._titles = titles
self._values = values
win = CreateComboBox(win_none, (0, 0), (100, 320), wc.CBS_DROPDOWNLIST)
win.ShowWindow()
self._win_update_items(win)
GListButton.__init__(self, _win = win, **kwds)
def _update_items(self):
self._win_update_items(self._win)
def _win_update_items(self, win):
win.ResetContent()
for title in self._titles:
win.AddString(title)
def _get_selected_index(self):
return self._win.GetCurSel()
def _set_selected_index(self, x):
try:
self._win.SetCurSel(x)
except ui.error:
pass
def _cbn_sel_change(self):
self.do_action()
export(ListButton)
# # Python GUI - Containers - Gtk version # from gtk import gdk from GUI import export from GUI.Geometry import inset_rect from GUI.GContainers import Container as GContainer class Container(GContainer): # Subclasses must set the inner widget to be a Fixed or Layout # widget. def _add(self, comp): GContainer._add(self, comp) x, y = comp._position self._gtk_inner_widget.put(comp._gtk_outer_widget, int(x), int(y)) def _remove(self, comp): self._gtk_inner_widget.remove(comp._gtk_outer_widget) GContainer._remove(self, comp) export(Container)
def get_mixed(self):
return self._ns_view.allowsMixedState()
def set_mixed(self, x):
self._ns_view.setAllowsMixedState_(x)
def get_on(self):
state = self._ns_view.state()
if state == NSMixedState:
return "mixed"
else:
return state <> NSOffState
def set_on(self, v):
if v == "mixed" and self.mixed:
state = NSMixedState
elif v:
state = NSOnState
else:
state = NSOffState
self._ns_view.setState_(state)
def do_action(self):
if not self._auto_toggle:
self.on = not self.on
Action.do_action(self)
export(CheckBox)
ns_item = NSMenuItem.separatorItem()
self._ns_menu.addItem_(ns_item)
def _add_item_to_platform_menu(self, item, name, command=None, index=None):
key = item._key or ""
if item._shift:
key = key.upper()
else:
key = key.lower()
ns_item = NSMenuItem.alloc()
#ns_action = _ns_standard_actions.get(command, 'menuSelection:')
ns_action = 'menuSelection:'
ns_item.initWithTitle_action_keyEquivalent_(name, ns_action, key)
ns_item.setEnabled_(item.enabled)
if item.checked:
ns_item.setState_(NSOnState)
ns_modifiers = NSCommandKeyMask
if item._option:
ns_modifiers |= NSAlternateKeyMask
ns_item.setKeyEquivalentModifierMask_(ns_modifiers)
ns_item.setRepresentedObject_(command)
if index is not None:
ns_tag = index
else:
ns_tag = -1
ns_item.setTag_(ns_tag)
self._ns_menu.addItem_(ns_item)
export(Menu)
try:
try:
self.write_contents(file)
finally:
file.close()
except EnvironmentError:
os.unlink(fd)
raise
path = self.file.path
try:
os.unlink(path)
except EnvironmentError:
pass
os.rename(temp_path, path)
self.needs_saving = 0
def setup_menus(self, m):
#print "Document.setup_menus" ###
if self._needs_saving or not self._file:
m.save_cmd.enabled = 1
if self._needs_saving and self._file:
m.revert_cmd.enabled = 1
m.save_as_cmd.enabled = 1
m.page_setup_cmd.enabled = 1
def next_handler(self):
return application()
export(Document)
#--------------------------------------------------------------------
#
# PyGUI - ImageBase - Win32
#
#--------------------------------------------------------------------
from GUI import export
from GUI.GImageBases import ImageBase as GImageBase
class ImageBase(GImageBase):
# _win_image GdiPlus.Image
def get_width(self):
return self._win_image.GetWidth()
def get_height(self):
return self._win_image.GetHeight()
def draw(self, canvas, src_rect, dst_rect):
canvas._win_graphics.DrawImage_rr(self._win_image, dst_rect, src_rect)
export(ImageBase)
except Exception, e:
app.report_error()
return False
def applicationDidFinishLaunching_(self, notification):
app = self.pygui_app
if app._ns_using_clargs:
return
try:
if not app._ns_files_opened:
app.open_app()
except Exception, e:
app.report_error()
return False
export(Application)
#------------------------------------------------------------------------------
def raise_pending_exception():
exc_type, exc_value, exc_tb = Globals.pending_exception
Globals.pending_exception = None
raise exc_type, exc_value, exc_tb
def create_ns_application():
ns_app = _PyGui_NSApplication.sharedApplication()
ns_app.setDelegate_(ns_app)
Globals.ns_application = ns_app
def dispatch_to_app(ns_app, *args):
app = ns_app.pygui_app
event._originator = self
self.handle_event(event)
return not event._not_handled
def key_down(self, event):
#print "MessageHandler.key_down for", self ###
self._default_key_event(event)
def key_up(self, event):
self._default_key_event(event)
def mouse_down(self, event):
self._default_mouse_event(event)
def mouse_drag(self, event):
self._default_mouse_event(event)
def mouse_up(self, event):
self._default_mouse_event(event)
def mouse_move(self, event):
self._default_mouse_event(event)
def mouse_enter(self, event):
self._default_mouse_event(event)
def mouse_leave(self, event):
self._default_mouse_event(event)
export(MessageHandler)
from __future__ import division
from array import array
import cairo
from gtk import gdk
from GUI import export
from GUI.GImages import Image as GImage
class Image(GImage):
def _init_from_file(self, file):
self._gdk_pixbuf = gdk.pixbuf_new_from_file(file)
def _from_gdk_pixbuf(cls, gdk_pixbuf):
self = cls.__new__(cls)
self._gdk_pixbuf = gdk_pixbuf
return self
_from_gdk_pixbuf = classmethod(_from_gdk_pixbuf)
def _gtk_set_source(self, ctx, x, y):
ctx.set_source_pixbuf(self._gdk_pixbuf, x, y)
def get_width(self):
return self._gdk_pixbuf.get_width()
def get_height(self):
return self._gdk_pixbuf.get_height()
export(Image)
#
# Python GUI - Cursors - Cocoa
#
from AppKit import NSCursor
from GUI import export
from GUI.GCursors import Cursor as GCursor
class Cursor(GCursor):
#
# _ns_cursor NSCursor
def _from_ns_cursor(cls, ns_cursor):
cursor = cls.__new__(cls)
cursor._ns_cursor = ns_cursor
return cursor
_from_ns_cursor = classmethod(_from_ns_cursor)
def _init_from_image_and_hotspot(self, image, hotspot):
#print "Cursor._init_from_image_and_hotspot:", image, hotspot ###
ns_image = image._ns_image.copy()
ns_image.setFlipped_(False)
self._ns_cursor = NSCursor.alloc().initWithImage_hotSpot_(
ns_image, hotspot)
export(Cursor)
ps = self._ns_inner_view.defaultParagraphStyle()
return ps.defaultTabInterval()
def set_tab_spacing(self, x):
ps = NSMutableParagraphStyle.alloc().init()
ps.setTabStops_([])
ps.setDefaultTabInterval_(x)
self._ns_inner_view.setDefaultParagraphStyle_(ps)
self._ns_apply_style()
def paste_cmd(self):
GTextEditor.paste_cmd(self)
self._ns_apply_style()
def _ns_apply_style(self):
ns_textview = self._ns_inner_view
ps = ns_textview.defaultParagraphStyle()
font = ns_textview.font()
ns_storage = self._ns_inner_view.textStorage()
ns_storage.setAttributes_range_(
{"NSParagraphStyle": ps, "NSFont": font},
(0, self.text_length))
#------------------------------------------------------------------------------
class PyGUI_NSTextView(NSTextView, PyGUI_NS_EventHandler):
__metaclass__ = NSMultiClass
__slots__ = ['pygui_component']
export(TextEditor)
#
# Python GUI - Views - PyObjC
#
from GUI import export
from GUI.GViews import View as GView
class View(GView):
_ns_scrollable = False
export(View)
self.start()
def get_scheduled(self):
return self._gtk_timeout_id is not None
def get_interval(self):
return self._gtk_interval / 1000.0
def get_repeat(self):
return self._repeat
def start(self):
if self._gtk_timeout_id is None:
self._gtk_timeout_id = gobject.timeout_add(self._gtk_interval,
self._gtk_fire)
def stop(self):
id = self._gtk_timeout_id
if id is not None:
gobject.source_remove(id)
self._gtk_timeout_id = None
def _gtk_fire(self):
self._proc()
if self._repeat:
return 1
else:
self._gtk_timeout_id = None
export(Task)
from GUI.StdFonts import system_font
from GUI.GLabels import Label as GLabel
class Label(GLabel):
_vertical_padding = 6
def __init__(self, text = "New Label", font = system_font, **kwds):
width, height = font.text_size(text)
gtk_label = gtk.Label(text)
gtk_label.set_alignment(0.0, 0.5)
gtk_label.set_size_request(width, height + self._vertical_padding)
gtk_label.show()
GLabel.__init__(self, _gtk_outer = gtk_label, font = font, **kwds)
def get_text(self):
return self._gtk_outer_widget.get_text()
def set_text(self, text):
self._gtk_outer_widget.set_text(text)
def _gtk_get_alignment(self):
return self._gtk_outer_widget.get_alignment()[0]
def _gtk_set_alignment(self, fraction, just):
gtk_label = self._gtk_outer_widget
gtk_label.set_alignment(fraction, 0.0)
gtk_label.set_justify(just)
export(Label)
def get_font(self):
return self._font
def set_font(self, x):
self._font = x
self._win.SetFont(x._win_font)
self.invalidate()
def get_tab_spacing(self):
pf = self._win_ctl.GetParaFormat()
tabs = pf[8]
if tabs:
return tabs[0] // 20
else:
return 36
def set_tab_spacing(self, x):
dc = self._win.GetDC()
dpi = dc.GetDeviceCaps(LOGPIXELSX)
mask = PFM_TABSTOPS
twips = 1440 * x / dpi
tabs = [int(round((i + 1) * twips)) for i in range(MAX_TAB_STOPS)]
pf = (mask, 0, 0, 0, 0, 0, 0, tabs)
old_sel = self.selection
self.select_all()
self._win_ctl.SetParaFormat(pf)
self.selection = old_sel
export(TextEditor)
#
# Python GUI - Pixmap - Gtk
#
from gtk import gdk
from GUI import export
from GUI.GtkPixmaps import GtkPixmap
from GUI.GPixmaps import Pixmap as GPixmap
class Pixmap(GtkPixmap, GPixmap):
def __init__(self, width, height):
GtkPixmap.__init__(self, width, height)
export(Pixmap)
#
# Python GUI - Radio groups - PyObjC
#
from GUI import export
from GUI.GRadioGroups import RadioGroup as GRadioGroup
class RadioGroup(GRadioGroup):
def __init__(self, items = [], **kwds):
GRadioGroup.__init__(self, items, **kwds)
def _item_added(self, item):
item._update()
def _item_removed(self, item):
pass
def _value_changed(self):
for item in self._items:
item._update()
export(RadioGroup)
# Python GUI - Images - Cocoa
#
from Foundation import NSData
from AppKit import NSImage, NSBitmapImageRep
from GUI import export
from GUI.GImages import Image as GImage
class Image(GImage):
# _ns_bitmap_image_rep
def _init_from_file(self, file):
#ns_image = NSImage.alloc().initWithContentsOfFile_(file)
#if not ns_image:
ns_data = NSData.dataWithContentsOfFile_(file)
if not ns_data:
raise EnvironmentError("Unable to read image file: %s" % file)
ns_rep = NSBitmapImageRep.imageRepWithData_(ns_data)
if not ns_rep:
raise ValueError("Unrecognised image file type: %s" % file)
ns_rep.setSize_((ns_rep.pixelsWide(), ns_rep.pixelsHigh()))
self._init_from_ns_rep(ns_rep)
def _init_from_ns_rep(self, ns_rep):
ns_image = NSImage.alloc().init()
ns_image.addRepresentation_(ns_rep)
self._ns_bitmap_image_rep = ns_rep
self._init_with_ns_image(ns_image, flipped = True)
export(Image)
#------------------------------------------------------------------------------
#
# Python GUI - Frames - Cocoa
#
#------------------------------------------------------------------------------
from GUI.GFrames import Frame as GFrame
from GUI import export
from GUI.Utils import NSMultiClass
from GUI.Utils import PyGUI_NS_EventHandler, PyGUI_Flipped_NSView
class Frame(GFrame):
def __init__(self, **kwds):
ns_view = PyGUI_Frame.alloc().initWithFrame_(((0, 0), (100, 100)))
ns_view.pygui_component = self
GFrame.__init__(self, _ns_view = ns_view, **kwds)
#------------------------------------------------------------------------------
class PyGUI_Frame(PyGUI_Flipped_NSView, PyGUI_NS_EventHandler):
__metaclass__ = NSMultiClass
__slots__ = ['pygui_component']
export(Frame)
def _gtk_menu_setup(self):
application()._perform_menu_setup(self._all_menus)
def _default_key_event(self, event):
self.pass_event_to_next_handler(event)
if event._originator is self:
event._not_handled = True
def dispatch(self, message, *args):
self.target.handle(message, *args)
_gtk_menubar_height = None
def _gtk_find_menubar_height():
global _gtk_menubar_height
if _gtk_menubar_height is None:
print "Windows: Finding menubar height"
item = gtk.MenuItem("X")
bar = gtk.MenuBar()
bar.append(item)
bar.show_all()
w, h = bar.size_request()
_gtk_menubar_height = h
print "...done"
return _gtk_menubar_height
export(Window)
def invalidate_rect(self, r):
self._ns_inner_view.setNeedsDisplayInRect_(rect_to_ns_rect(r))
def with_canvas(self, proc):
ns_view = self._ns_view
ns_view.lockFocus()
proc(Canvas())
ns_view.unlockFocus()
def update(self):
self._ns_view.displayIfNeeded()
def track_mouse(self):
return self._ns_track_mouse(self._ns_inner_view)
#------------------------------------------------------------------------------
class PyGUI_User_NSView(PyGUI_Flipped_NSView, PyGUI_NS_ViewBase):
#
# pygui_component View
__metaclass__ = NSMultiClass
__slots__ = ['pygui_component']
def drawRect_(self, ns_rect):
(l, t), (w, h) = ns_rect
rect = (l, t, l + w, t + h)
self.pygui_component.draw(Canvas(), rect)
export(DrawableContainer)
#-------------------------------------------------------------------------------
#
# Python GUI - Scrollable objects mixin - Cocoa
#
#-------------------------------------------------------------------------------
from GUI import export
from GUI.GScrollableBases import ScrollableBase as GScrollableBase
class ScrollableBase(GScrollableBase):
def get_hscrolling(self):
return self._ns_view.hasHorizontalScroller()
def set_hscrolling(self, value):
self._ns_view.setHasHorizontalScroller_(value)
def get_vscrolling(self):
return self._ns_view.hasVerticalScroller()
def set_vscrolling(self, value):
self._ns_view.setHasVerticalScroller_(value)
export(ScrollableBase)
def mouse_leave(self, event):
#self._ns_pass_to_platform(event, 'mouseExited_')
pass
def key_down(self, event):
#print "Component.key_down:", repr(event.char), "for", self ###
self._ns_pass_to_platform(event, 'keyDown_')
def key_up(self, event):
self._ns_pass_to_platform(event, 'keyUp_')
#------------------------------------------------------------------------------
ns_mouse_down_methods = {
'left': 'mouseDown_',
'middle': 'otherMouseDown_',
'right': 'rightMouseDown_'
}
ns_mouse_up_methods = {
'left': 'mouseUp_',
'middle': 'otherMouseUp_',
'right': 'rightMouseUp_'
}
#------------------------------------------------------------------------------
export(Component)
def __init__(self, title = "New Button", **kwds):
font = self._win_predict_font(kwds)
style = kwds.pop('style', 'normal')
self._style = style
w = font.width(title) + win_hpad
h = self._calc_height(font)
win = self._win_create_button(title, win_style(style), w, h)
GButton.__init__(self, _win = win, **kwds)
def get_style(self):
return self._style
def set_style(self, x):
self._style = x
self._win.SetButtonStyle(win_style(x))
def flash(self):
win = self._win
win.SetState(True)
sleep(0.05)
win.SetState(False)
def _win_bn_clicked(self):
self.do_action()
def _win_activate(self):
self.do_action()
export(Button)
#------------------------------------------------------------------------------ # # Python GUI - Frames - Cocoa # #------------------------------------------------------------------------------ from GUI.GFrames import Frame as GFrame from GUI import export from GUI.Utils import NSMultiClass from GUI.Utils import PyGUI_NS_EventHandler, PyGUI_Flipped_NSView class Frame(GFrame): def __init__(self, **kwds): ns_view = PyGUI_Frame.alloc().initWithFrame_(((0, 0), (100, 100))) ns_view.pygui_component = self GFrame.__init__(self, _ns_view = ns_view, **kwds) #------------------------------------------------------------------------------ class PyGUI_Frame(PyGUI_Flipped_NSView, PyGUI_NS_EventHandler): __metaclass__ = NSMultiClass __slots__ = ['pygui_component'] export(Frame)
u1 = h - u0
v1 = w
state = gtk.STATE_NORMAL
for i in xrange(steps + 1):
u = u0 + i * (u1 - u0) / steps
draw_line(gdk_win, state, None, gtk_ticks, "", v0, v1, u)
def _gtk_value_changed(self):
if self._live and self._gtk_enable_action:
self.do_action()
def _gtk_change_value(self, event_type, value):
gtk_adjustment = self._gtk_adjustment
vmin = gtk_adjustment.lower
vmax = gtk_adjustment.upper
value = min(max(vmin, value), vmax)
if self._discrete:
steps = self._ticks - 1
if steps > 0:
q = round(steps * (value - vmin) / (vmax - vmin))
value = vmin + q * (vmax - vmin) / steps
if gtk_adjustment.value <> value:
gtk_adjustment.value = value
return True
def _gtk_button_release(self, gtk_event):
self.do_action()
export(Slider)
text = self._win.GetWindowText()
if d > 0:
text = text.replace("\r\n", "\n")
nl = "\n"
else:
nl = "\r\n"
def adj(x):
return x + d * text.count(nl, 0, x)
return map(adj, sel)
def get_multiline(self):
return self._multiline
def get_password(self):
return self._password
def _tab_in(self):
self.select_all()
def key_down(self, event):
# print "TextField.key_down" ###
if event.char == "\t":
self.pass_event_to_next_handler(event)
else:
GTextField.key_down(self, event)
export(TextField)
# # Python GUI - Views - Gtk # from GUI import export from GUI.GViews import View export(View)
def get_on(self):
return win_states[self._mixed][self._win.GetCheck() & 0x3]
def set_on(self, x):
try:
state = win_states[self._mixed].index(x)
except ValueError:
raise ValueError("Invalid CheckBox state '%s'" % x)
self._win.SetCheck(state)
def _win_update_button_style(self):
self._win.SetButtonStyle(self._win_button_style())
def _win_button_style(self):
return win_styles[self._mixed][self._auto_toggle]
def _win_bn_clicked(self):
#print "CheckBox._win_bn_clicked:", self ###
self.do_action()
def _win_activate(self):
if self.auto_toggle:
states = win_states[self._mixed]
i = states.index(self.on)
self.on = states[(i + 1) % len(states)]
self.do_action()
export(CheckBox)
self.handle_event(event)
return not event._not_handled
def key_down(self, event):
#print "MessageHandler.key_down for", self ###
self._default_key_event(event)
def key_up(self, event):
self._default_key_event(event)
def mouse_down(self, event):
self._default_mouse_event(event)
def mouse_drag(self, event):
self._default_mouse_event(event)
def mouse_up(self, event):
self._default_mouse_event(event)
def mouse_move(self, event):
self._default_mouse_event(event)
def mouse_enter(self, event):
self._default_mouse_event(event)
def mouse_leave(self, event):
self._default_mouse_event(event)
export(MessageHandler)
def with_canvas(self, proc):
ns_view = self._ns_view
ns_view.lockFocus()
proc(Canvas())
ns_view.unlockFocus()
def update(self):
self._ns_view.displayIfNeeded()
def track_mouse(self):
return self._ns_track_mouse(self._ns_inner_view)
#------------------------------------------------------------------------------
class PyGUI_User_NSView(PyGUI_Flipped_NSView, PyGUI_NS_ViewBase):
#
# pygui_component View
__metaclass__ = NSMultiClass
__slots__ = ['pygui_component']
def drawRect_(self, ns_rect):
(l, t), (w, h) = ns_rect
rect = (l, t, l + w, t + h)
self.pygui_component.draw(Canvas(), rect)
export(DrawableContainer)
class FlippedNSGraphicsContext(NSGraphicsContext):
def initWithBase_(self, base):
self.base = base
self.graphics_port = base.graphicsPort()
return self
def isFlipped(self):
return True
def graphicsPort(self):
return self.graphics_port
def isDrawingToScreen(self):
return self.base.isDrawingToScreen()
def setCompositingOperation_(self, x):
self.base.setCompositingOperation_(x)
def focusStack(self):
return self.base.focusStack()
def saveGraphicsState(self):
return self.base.saveGraphicsState()
def restoreGraphicsState(self):
return self.base.restoreGraphicsState()
export(Pixmap)
def set_format(self, x):
self._format = x
def get_parser(self):
return self._parser
def set_parser(self, x):
self._parser = x
def format_value(self, value):
"""Convert value to string for display, and also for editing with the
default editor. Default is to perform %-formatting with the format property
if specified, otherwise apply str to the value."""
format = self.format
if format:
return format % value
else:
return str(value)
def parse_value(self, text):
"""Convert string to value when using the default editor. Default is to
return the text unchanged."""
parser = self.parser
if parser:
return parser(text)
else:
return text
export(TextColumn)
# Python GUI - Common code for scrollable components - Gtk
#
import gtk
from GUI import export
from GUI import Globals
gtk_scroll_policies = [gtk.POLICY_NEVER, gtk.POLICY_ALWAYS]
class Scrollable(object):
gtk_scrollbar_breadth = gtk.VScrollbar().size_request()[0] + 3
s = gtk.ScrolledWindow().get_style()
gtk_border_thickness = (s.xthickness, s.ythickness)
del s
def get_hscrolling(self):
return self._gtk_outer_widget.get_property('hscrollbar-policy') <> gtk.POLICY_NEVER
def set_hscrolling(self, value):
self._gtk_outer_widget.set_property('hscrollbar-policy', gtk_scroll_policies[value])
def get_vscrolling(self):
return self._gtk_outer_widget.get_property('vscrollbar-policy') <> gtk.POLICY_NEVER
def set_vscrolling(self, value):
self._gtk_outer_widget.set_property('vscrollbar-policy', gtk_scroll_policies[value])
export(Scrollable)
application().dispatch_menu_command(command)
return True
def _screen_rect(self):
return WinUtils.win_screen_rect
def modal_event_loop(self):
disabled = []
for window in application().windows:
if window is not self:
if not window._win.EnableWindow(False):
# print "Window.modal_event_loop: disabled", window.title ###
disabled.append(window)
status = self._win.RunModalLoop(0)
if status:
print "Window._modal_event_loop:", self, "status =", status ###
# raise Cancel
for window in disabled:
# print "Window.modal_event_loop: enabling", window.title ###
window._win.EnableWindow(True)
if status <> 0: ###
from GUI.Exceptions import InternalError ###
raise InternalError("RunModalLoop returned %s" % status) ###
def exit_modal_event_loop(self):
self._win.EndModalLoop(0)
export(Window)
class RadioButton(GRadioButton):
def __init__(self, title = "New Control", **kwds):
gtk_radiobutton = gtk.RadioButton(None, title)
gtk_radiobutton.show()
self._gtk_connect(gtk_radiobutton, 'toggled', self._gtk_toggled_signal)
GRadioButton.__init__(self, _gtk_outer = gtk_radiobutton, **kwds)
def _value_changed(self):
group = self._group
if group:
if self._value == group._value:
self._turn_on()
else:
group._turn_all_off()
def _turn_on(self):
self._gtk_outer_widget.set_active(1)
def _is_on(self):
return self._gtk_outer_widget.get_active()
def _gtk_toggled_signal(self):
if self._is_on():
group = self._group
if group and group._value <> self._value:
group._value = self._value
group.do_action()
export(RadioButton)
def get_multiline(self):
return self._multiline
def get_password(self):
return self._password
def _tab_in(self):
self.select_all()
def key_down(self, event):
#print "TextField.key_down" ###
if event.char == "\t":
self.pass_event_to_next_handler(event)
else:
GTextField.key_down(self, event)
def _en_change(self, *args):
#print("TextField._en_change")
if not self._win_setting_text:
self.do_text_changed_action()
def get_editable(self):
return not self._win.GetReadOnly()
def set_editable(self, x):
self._win.SetReadOnly(not x)
export(TextField)
self._win.ReleaseCapture()
# #<<<
# if kind.startswith('key'):
# if pass_message:
# print "Component._win_event_message: passing", event ###
# else:
# print "Component._win_event_message: absorbing", event ###
# #>>>
return pass_message
except Cancel:
pass
except:
application().report_error()
# print "Component._win_event_message: Posting quit message with 1" ###
# api.PostQuitMessage(1)
def _win_dump_flags(self):
from WinUtils import win_deconstruct_style, win_deconstruct_style_ex
print "%s.%s: style:" % (self.__class__.__module__, self.__class__.__name__)
win_deconstruct_style(self._win.GetStyle())
win_deconstruct_style_ex(self._win.GetExStyle())
# def PreTranslateMessage(self, message):
# print "Component.PreTranslateMessage:", self, \
# message[0], win_message_name(message[1]), \
# message[2]
#
#from WinUtils import win_message_name
export(Component)
"\x1b": 'cancel',
}
class Button(ButtonBasedControl, GButton):
_default_tab_stop = None
def __init__(self, title = "New Button", font = system_font, **kwds):
ns_button = self._create_ns_button(title = title, font = font,
ns_button_type = AppKit.NSMomentaryLight,
ns_bezel_style = AppKit.NSRoundedBezelStyle,
padding = (10, 2)
)
GButton.__init__(self, _ns_view = ns_button, **kwds)
def get_style(self):
ns_key = self._ns_view.getKeyEquivalent()
return _ns_key_equivalent_to_style.get(ns_key, 'normal')
def set_style(self, style):
ns_key = _style_to_ns_key_equivalent.get(style, "")
self._ns_view.setKeyEquivalent_(ns_key)
def activate(self):
self._ns_view.performClick_(None)
# def key_down(self, e): ###
# print "Button.key_down:", e ###
export(Button)
from AppKit import NSView
from GUI.Utils import PyGUI_Flipped_NSView
from GUI import export
from GUI.GContainers import Container as GContainer
class Container(GContainer):
# _ns_inner_view NSView Containing NSView for subcomponents
# def __init__(self, _ns_view, **kwds):
# GContainer.__init__(self, _ns_view = _ns_view, **kwds)
# def destroy(self):
# #print "Container.destroy:", self ###
# GContainer.destroy(self)
# #print "Container.destroy: breaking inner link to", self._ns_inner_view ###
def _add(self, comp):
GContainer._add(self, comp)
self._ns_inner_view.addSubview_(comp._ns_view)
def _remove(self, comp):
GContainer._remove(self, comp)
comp._ns_view.removeFromSuperview()
# ------------------------------------------------------------------------------
export(Container)
# hwnd = self._win.GetSafeHwnd()
self.win_icon = win_load_icon(id)
def draw(self, c, r):
gfx = c._win_graphics
hdc = gfx.GetHDC()
gui.DrawIcon(hdc, 0, 0, self.win_icon)
gfx.ReleaseHDC(hdc)
# def draw(self, c, r):
# dc = c._win_dc
# dc.DrawIcon((0, 0), self.win_icon)
class BaseAlert(GBaseAlert):
_win_icon = None
def _layout_icon(self, kind):
id = win_icon_ids.get(kind)
if id:
icon = AlertIcon(id, position=(self._left_margin, self._top_margin))
self.add(icon)
return icon.size
else:
return (0, 0)
export(BaseAlert)
while not finished:
self._mouse_event = None
while not self._mouse_event:
gtk.main_iteration()
event = self._mouse_event
if event.kind == 'mouse_up':
finished = 1
yield event
def _cursor_changed(self):
gtk_widget = self._gtk_inner_widget
gdk_window = gtk_widget.window
if gdk_window:
cursor = self._cursor
if cursor:
gdk_window.set_cursor(self._cursor._gtk_cursor)
else:
gdk_window.set_cursor(None)
def _gtk_realize(self):
self._cursor_changed()
# def _targeted(self):
# self.targeted()
#
# def _untargeted(self):
# self.untargeted()
export(ViewBase)
app.report_error()
return False
def applicationDidFinishLaunching_(self, notification):
app = self.pygui_app
if app._ns_using_clargs:
return
try:
if not app._ns_files_opened:
app.open_app()
except Exception, e:
app.report_error()
return False
export(Application)
#------------------------------------------------------------------------------
def raise_pending_exception():
exc_type, exc_value, exc_tb = Globals.pending_exception
Globals.pending_exception = None
raise exc_type, exc_value, exc_tb
def create_ns_application():
ns_app = _PyGui_NSApplication.sharedApplication()
ns_app.setDelegate_(ns_app)
Globals.ns_application = ns_app
def _from_gdk_color(cls, _gdk_color):
c = cls.__new__(cls)
c._gdk_color = _gdk_color
return c
_from_gdk_color = classmethod(_from_gdk_color)
def __init__(self, red, green, blue, alpha = 1.0):
self._rgba = (red, green, blue, alpha)
gdk_color = gdk.Color()
gdk_color.red = int(red * 65535)
gdk_color.green = int(green * 65535)
gdk_color.blue = int(blue * 65535)
self._gdk_color = gdk_color
self._alpha = alpha
def get_red(self):
return self._gdk_color.red / 65535.0
def get_green(self):
return self._gdk_color.green / 65535.0
def get_blue(self):
return self._gdk_color.blue / 65535.0
def get_alpha(self):
return self._alpha
export(Color)
class RadioButton(GRadioButton):
def __init__(self, title="New Control", **kwds):
gtk_radiobutton = gtk.RadioButton(None, title)
gtk_radiobutton.show()
self._gtk_connect(gtk_radiobutton, 'toggled', self._gtk_toggled_signal)
GRadioButton.__init__(self, _gtk_outer=gtk_radiobutton, **kwds)
def _value_changed(self):
group = self._group
if group:
if self._value == group._value:
self._turn_on()
else:
group._turn_all_off()
def _turn_on(self):
self._gtk_outer_widget.set_active(1)
def _is_on(self):
return self._gtk_outer_widget.get_active()
def _gtk_toggled_signal(self):
if self._is_on():
group = self._group
if group and group._value <> self._value:
group._value = self._value
group.do_action()
export(RadioButton)
def rotate(self, rotation):
matrix = NSAffineTransform.transform()
matrix.rotateByDegrees_(rotation)
self._ns_path.transformUsingAffineTransform_(matrix)
self.transformstack[-1].append(["rotate",rotation])
def scale(self, sx, sy):
matrix = NSAffineTransform.transform()
matrix.scaleXBy_yBy_(sx, sy)
self._ns_path.transformUsingAffineTransform_(matrix)
self.transformstack[-1].append(["scale",sx,sy])
def _transform(self, x, y):
for i in self.transformstack: #reversed(self.transformstack):
for j in i: # reversed(i):
if j[0]=="translate":
x = x+j[1]
y = y+j[2]
elif j[0]=="rotate":
x = x*math.cos(j[1])-y*math.sin(j[1])
y = x*math.sin(j[1])+y*math.cos(j[1])
elif j[0]=="scale":
x = x*j[1]
y = y*j[2]
return x, y
def _ns_rect((l, t, r, b)):
return NSMakeRect(l, t, r - l, b - t)
export(Canvas)
def notify_views(self, message='model_changed', *args, **kwds):
"""For each observer, if the observer defines a method with the name of the
message, call it with the given arguments. Otherwise, if it defines a
method called 'model_changed', call it with no arguments. Otherwise,
do nothing for that observer."""
for view in self.views:
if not self._call_if_present(view, message, self, *args, **kwds):
self._call_if_present(view, 'model_changed', self)
def _call_if_present(self, obj, method_name, *args, **kwds):
method = getattr(obj, method_name, None)
if method:
method(*args, **kwds)
return 1
else:
return 0
#
# Marking as changed
#
def changed(self):
"Mark the containing Document as changed."
parent = self.parent
if parent:
parent.changed()
export(Model)
def get_scroll_offset(self):
ns_clip_view = self._ns_view.contentView()
x, y = ns_clip_view.bounds().origin
return x, y
def set_scroll_offset(self, (x, y)):
ns_view = self._ns_view
ns_clip_view = ns_view.contentView()
new_pt = ns_clip_view.constrainScrollPoint_(NSPoint(x, y))
ns_clip_view.scrollToPoint_(new_pt)
ns_view.reflectScrolledClipView_(ns_clip_view)
def get_line_scroll_amount(self):
ns_view = self._ns_view
x = ns_view.horizontalLineScroll()
y = ns_view.verticalLineScroll()
return x, y
def set_line_scroll_amount(self, (x, y)):
ns_view = self._ns_view
ns_view.setHorizontalLineScroll_(x)
ns_view.setVerticalLineScroll_(y)
ns_view.setHorizontalPageScroll_(x)
ns_view.setVerticalPageScroll_(y)
def viewed_rect(self):
ns_rect = self._ns_view.contentView().documentVisibleRect()
return ns_rect_to_rect(ns_rect)
export(ScrollableView)
def get_just(self):
return self._just
def set_just(self, x):
self._just = x
self.invalidate()
def _win_create_button(self, title, style, w, h):
w = int(ceil(w))
win = ui.CreateButton()
win.CreateWindow(title, style, (0, 0, w, h), win_none, 0)
#if self._win_transparent:
# win.ModifyStyleEx(0, wc.WS_EX_TRANSPARENT, 0)
win.ShowWindow(wc.SW_SHOW)
return win
def _win_on_ctlcolor(self, dc, typ):
#print "Control._win_on_ctlcolor:", self ###
c = self._color
if c:
dc.SetTextColor(c._win_color)
if self._win_transparent:
dc.SetBkMode(wc.TRANSPARENT)
return win_null_hbrush
def _win_predict_font(self, kwds):
return kwds.setdefault('font', system_font)
export(Control)
class Task(GTask):
_win_timer_id = 0
def __init__(self, proc, interval, repeat=False, start=True):
self._proc = proc
self._milliseconds = int(1000 * interval)
self._repeat = repeat
if start:
self.start()
def __del__(self, timer_wnd=timer_wnd):
timer_wnd.cancel(self)
def get_interval(self):
return self._milliseconds / 1000.0
def get_repeat(self):
return self._repeat
def start(self):
timer_wnd.schedule(self)
def stop(self):
timer_wnd.cancel(self)
export(Task)
def _add_separator_to_platform_menu(self):
ns_item = NSMenuItem.separatorItem()
self._ns_menu.addItem_(ns_item)
def _add_item_to_platform_menu(self, item, name, command = None, index = None):
key = item._key or ""
if item._shift:
key = key.upper()
else:
key = key.lower()
ns_item = NSMenuItem.alloc()
#ns_action = _ns_standard_actions.get(command, 'menuSelection:')
ns_action = 'menuSelection:'
ns_item.initWithTitle_action_keyEquivalent_(name, ns_action, key)
ns_item.setEnabled_(item.enabled)
if item.checked:
ns_item.setState_(NSOnState)
ns_modifiers = NSCommandKeyMask
if item._option:
ns_modifiers |= NSAlternateKeyMask
ns_item.setKeyEquivalentModifierMask_(ns_modifiers)
ns_item.setRepresentedObject_(command)
if index is not None:
ns_tag = index
else:
ns_tag = -1
ns_item.setTag_(ns_tag)
self._ns_menu.addItem_(ns_item)
export(Menu)
def get_scroll_offset(self):
hadj, vadj = self._gtk_adjustments()
return int(hadj.value), int(vadj.value)
def set_scroll_offset(self, (x, y)):
hadj, vadj = self._gtk_adjustments()
hadj.set_value(min(float(x), hadj.upper - hadj.page_size))
vadj.set_value(min(float(y), vadj.upper - vadj.page_size))
def get_line_scroll_amount(self):
hadj, vadj = self._gtk_adjustments()
return hadj.step_increment, vadj.step_increment
def set_line_scroll_amount(self, (dx, dy)):
hadj, vadj = self._gtk_adjustments()
hadj.step_increment = float(dx) # Amazingly, ints are not
vadj.step_increment = float(dy) # acceptable here.
#
# Internal
#
def _gtk_adjustments(self):
gtk_widget = self._gtk_inner_widget
hadj = gtk_widget.get_hadjustment()
vadj = gtk_widget.get_vadjustment()
return hadj, vadj
export(ScrollableView)
x = col_width - item.width
else:
x = (col_width - item.width) // 2
if 't' in align:
y = 0
elif 'b' in align:
y = row_height - item.height
else:
y = (row_height - item.height) // 2
item.position = (hpad + col_left + x, vpad + row_top + y)
if j == expand_column:
item.anchor = 'lr' + vanchor
else:
item.anchor = hanchor + vanchor
self.add(item)
if j == expand_column:
hanchor = 'r'
col_left += col_width
col_gap = column_spacing
tot_width = max(tot_width, col_left)
if i == expand_row:
vanchor = 'b'
row_top += row_height
row_gap = row_spacing
tot_height = row_top
self.size = (tot_width + 2 * hpad, tot_height + 2 * vpad)
self.set(**kwds)
export(Grid)
#--------------------------------------------------------------------
#
# PyGUI - Event - Win32
#
#--------------------------------------------------------------------
from GUI import export
from GUI.GEvents import Event as GEvent
class Event(GEvent):
def _platform_modifiers_str(self):
return ""
export(Event)
def erase_oval(self, r):
self._backcolor._ns_color.set()
self._ns_oval_path(_ns_rect(r)).fill()
def _ns_arc_path(self, c, r, sa, ea):
ns_path = NSBezierPath.bezierPath()
ns_path.setLineWidth_(self._pensize)
ns_path.\
appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_(
c, r, sa, ea)
return ns_path
def stroke_arc(self, center, radius, start_angle, arc_angle):
ns_path = self._ns_arc_path(center, radius, start_angle, arc_angle)
self._pencolor._ns_color.set()
ns_path.stroke()
def frame_arc(self, center, radius, start_angle, arc_angle):
r = radius - 0.5 * self._pensize
ns_path = self._ns_arc_path(center, r, start_angle, arc_angle)
self._pencolor._ns_color.set()
ns_path.stroke()
def _ns_rect((l, t, r, b)):
return NSMakeRect(l, t, r - l, b - t)
export(Canvas)
#print "Slider._win_wm_scroll:", code ###
if self._live:
report = code != 8
else:
report = code == 8
if report:
self.do_action()
def _win_on_ctlcolor(self, dc, typ):
#print "Slider._win_on_ctlcolor:", self ###
return self._win.OnCtlColor(dc, self._win, typ)
def key_down(self, event):
k = event.key
if k == 'left_arrow' or k == 'up_arrow':
self._nudge_value(-1)
elif k == 'right_arrow' or k == 'down_arrow':
self._nudge_value(1)
else:
GSlider.key_down(self, event)
def _nudge_value(self, d):
if not self.discrete:
d *= (win_continuous_range // 100)
win = self._win
p = win.GetPos()
win.SetPos(p + d)
self.do_action()
export(Slider)
