class Main: def __init__(self): pygame.init() pygame.display.init() pygame.font.init() self.screen_w = pygame.display.Info().current_w self.screen_h = pygame.display.Info().current_h self.w = int(self.screen_h * 1.2) self.h = int(self.screen_h * 0.8) self.preferences = Preferences() self.fullscreen = self.preferences.get("fullscreen") self.go_mode() pygame.mouse.set_visible(False) pygame.display.set_caption(Constants.CAPTION) def go_mode(self): if self.fullscreen: self.mode = (self.screen_w, self.screen_h) if not self.mode in pygame.display.list_modes(): self.mode = pygame.display.list_modes()[0] self.screen = pygame.display.set_mode(self.mode, pygame.FULLSCREEN) else: self.mode = (self.w, self.h) self.screen = pygame.display.set_mode(self.mode) self.unit = int(self.mode[1] / Constants.UNITS) def main(self): self.boot_screen() while True: if not self.title_screen(): break if self.preferences.edit_flag: self.preferences.save() fullscreen = self.preferences.get("fullscreen") if self.fullscreen != fullscreen: self.fullscreen = fullscreen self.go_mode() else: self.play_game() def boot_screen(self): bs = BootScreen(self.screen, self.unit) bs.main() return bs.running def title_screen(self): self.go_mode() ts = TitleScreen(self.screen, self.unit, self.preferences) ts.main() return ts.running def play_game(self): gm = Game(self.screen, self.unit, self.preferences) gm.main() return gm.running
def create(self, text): """ Takes a string of text, converts it using the PicoTTS engine, and plays it. Wave files are buffered in /tmp/OnoTTS/<text>.wav. First call blocks while PicoTTS generates the .wav, this may take about a second. Subsequent calls of the same text return immediately. If you wish to avoid this, sound files can be generated on beforehand by using generate_only=True. """ def format_filename(s): """ Take a string and return a valid filename constructed from the string. Uses a whitelist approach: any characters not present in valid_chars are removed. Also spaces are replaced with underscores. Note: this method may produce invalid filenames such as ``, `.` or `..` When I use this method I prepend a date string like '2009_01_15_19_46_32_' and append a file extension like '.txt', so I avoid the potential of using an invalid filename. Taken from: https://gist.github.com/seanh/93666 """ valid_chars = "-_.() %s%s" % (string.ascii_letters, string.digits) filename = ''.join(c for c in s if c in valid_chars) filename = filename.replace(' ','_') # I don't like spaces in filenames. return filename if not os.path.exists("/tmp/OpsoroTTS/"): os.makedirs("/tmp/OpsoroTTS/") filename = format_filename(text) # Max length of filename is 255 chars if len(filename) >= 250: filename = filename[:250] full_path = os.path.join(get_path("/tmp/OpsoroTTS/"), filename + ".wav") # # Sound buffering # if os.path.isfile(full_path): # # Sound file already exists # return full_path self.engine = Preferences.get("audio", "tts_engine", self.engine) self.language = Preferences.get("audio", "tts_language", self.language) self.gender = Preferences.get("audio", "tts_gender", self.gender) if self.engine == "pico": self.create_pico(text, full_path) elif self.engine == "espeak": self.create_espeak(text, full_path, self.language, self.gender, self.delay, self.speed) return full_path
class Game: def __init__(self): pygame.init() #get preferences self.preferences = Preferences() #resolution, flags, depth, display self.unit = Constants.RESOLUTION[0] / Constants.UNITS self.banner = Banner() self.score_width = self.unit * 15 if self.preferences.fullscreen: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),pygame.FULLSCREEN) else: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),0,32) pygame.display.set_caption(Constants.CAPTION) #game area surface self.gamescreen = pygame.Surface(Constants.RESOLUTION) #score area rectangle surface self.scorescreen = pygame.Surface( (self.score_width, Constants.RESOLUTION[1])) #Snake and foods manager self.me=Snake(color=pygame.color.THECOLORS[self.preferences.get("color")],\ nickname=self.preferences.get("nickname")) self.nickname = self.preferences.get("nickname") self.f = Foods() #Score manager self.scores = Scores((self.score_width, Constants.RESOLUTION[1])) #add our own score, the server will send us the remaining one at connection self.scores.new_score(self.preferences.get("nickname"),\ pygame.color.THECOLORS[self.preferences.get("color")]) #game area background color self.gamescreen.fill(Constants.COLOR_BG) self.scorescreen.fill((100, 100, 100)) #timers self.clock = pygame.time.Clock() self.current_time = 0 self.move_snake_timer = Timer(1.0 / Constants.SNAKE_SPEED * 1000, self.current_time, periodic=True) self.blink_snake_timer = Timer(1.0 / Constants.SNAKE_BLINKING_SPEED * 1000, self.current_time, periodic=True) self.blink_banner_timer = Timer(500, self.current_time, periodic=True) self.new_apple_timer = Timer(Constants.NEW_APPLE_PERIOD * 1000, self.current_time, periodic=True) def process_events(self): #key handling for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: self.running = False if event.key == pygame.K_UP: self.me.action(1) if event.key == pygame.K_DOWN: self.me.action(2) if event.key == pygame.K_LEFT: self.me.action(3) if event.key == pygame.K_RIGHT: self.me.action(4) if event.key == pygame.K_SPACE: self.me.set_ready() def run(self): whole_second = 0 self.running = True while self.running: #time tracking self.current_time += self.clock.tick(Constants.FPS) #check if the snake is still alive if not self.me.alive: self.me.alive = True self.me.restart() #check if game need more food if self.new_apple_timer.expired(self.current_time): self.f.make() #check if we need to move our own snake's state #if we do, send an update of our position to #the server if self.move_snake_timer.expired(self.current_time): self.me.move() #check if we need to blink the unready snakes (unready state) if self.blink_snake_timer.expired(self.current_time): self.me.blink() #check if snake has eaten if self.me.ready: if self.f.check(self.me.head): self.me.grow(Constants.GROW) self.scores.inc_score(self.nickname, 1) #cleanup background self.gamescreen.fill(Constants.COLOR_BG) #draw scores self.scores.draw(self.screen) #draw all snakes positions as last seen by the server #we do not compute their positions ourselves! self.me.draw(self.gamescreen) #draw food self.f.draw(self.gamescreen) #process external events (keyboard,...) self.process_events() #then update display #update game area on screen container self.screen.blit(self.gamescreen, (self.score_width, 0)) pygame.display.update()
class IssueView(BottomView, IPreferencesMonitor): """ """ _log = getLogger("IssueView") label = "Issues" icon = gtk.STOCK_DIALOG_INFO scope = View.SCOPE_EDITOR def __init__(self, context, editor): BottomView.__init__(self, context) self._editor = editor self._handlers = {} def init(self, context): self._log.debug("init") self._preferences = Preferences() self._show_tasks = self._preferences.get_bool("IssuesShowTasks", True) self._show_warnings = self._preferences.get_bool( "IssuesShowWarnings", True) self._context = context self._icons = { Issue.SEVERITY_WARNING: pixbuf_new_from_file(find_resource("icons/warning.png")), Issue.SEVERITY_ERROR: pixbuf_new_from_file(find_resource("icons/error.png")), Issue.SEVERITY_INFO: None, Issue.SEVERITY_TASK: pixbuf_new_from_file(find_resource("icons/task.png")) } self._store = gtk.ListStore(Pixbuf, str, str, object) self._view = gtk.TreeView(self._store) column = gtk.TreeViewColumn() column.set_title("Message") pixbuf_renderer = gtk.CellRendererPixbuf() column.pack_start(pixbuf_renderer, False) column.add_attribute(pixbuf_renderer, "pixbuf", 0) text_renderer = gtk.CellRendererText() column.pack_start(text_renderer, True) column.add_attribute(text_renderer, "markup", 1) self._view.append_column(column) self._view.insert_column_with_attributes(-1, "File", gtk.CellRendererText(), markup=2) self._handlers[self._view] = self._view.connect( "row-activated", self._on_row_activated) self._scr = gtk.ScrolledWindow() self._scr.add(self._view) self._scr.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._scr.set_shadow_type(gtk.SHADOW_IN) self.pack_start(self._scr, True) # toolbar self._button_warnings = gtk.ToggleToolButton() self._button_warnings.set_tooltip_text("Show/Hide Warnings") image = gtk.Image() image.set_from_file(find_resource("icons/warning.png")) self._button_warnings.set_icon_widget(image) self._button_warnings.set_active(self._show_warnings) self._handlers[self._button_warnings] = self._button_warnings.connect( "toggled", self.__on_warnings_toggled) self._button_tasks = gtk.ToggleToolButton() self._button_tasks.set_tooltip_text("Show/Hide Tasks") imageTask = gtk.Image() imageTask.set_from_file(find_resource("icons/task.png")) self._button_tasks.set_icon_widget(imageTask) self._button_tasks.set_active(self._show_tasks) self._handlers[self._button_tasks] = self._button_tasks.connect( "toggled", self.__on_tasks_toggled) toolbar = gtk.Toolbar() toolbar.set_orientation(gtk.ORIENTATION_VERTICAL) toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_icon_size(gtk.ICON_SIZE_MENU) toolbar.insert(self._button_warnings, -1) toolbar.insert(self._button_tasks, -1) self.pack_start(toolbar, False) self._issues = [] self._preferences.register_monitor(self) self._log.debug("init finished") def _on_row_activated(self, view, path, column): """ A row has been double-clicked on """ issue = self._store.get(self._store.get_iter(path), 3)[0] self._context.activate_editor(issue.file) #~ # FIXME: this doesn't work correctly #~ if not self._context.active_editor is None: #~ self._context.active_editor.select(issue.start, issue.end) self._editor.select(issue.start, issue.end) def _on_value_changed(self, key, value): if key == "IssuesShowWarnings" or key == "IssuesShowTasks": # update filter self._store.clear() for issue, local in self._issues: self.__append_issue_filtered(issue, local) def __on_tasks_toggled(self, togglebutton): self._show_tasks = togglebutton.get_active() self._preferences.set("IssuesShowTasks", self._show_tasks) def __on_warnings_toggled(self, togglebutton): self._show_warnings = togglebutton.get_active() self._preferences.set("IssuesShowWarnings", self._show_warnings) def clear(self): """ Remove all issues from the view """ self.assure_init() self._store.clear() self._issues = [] def append_issue(self, issue, local=True): """ Append a new Issue to the view @param issue: the Issue object @param local: indicates whether the Issue occured in the edited file or not """ self.assure_init() self._issues.append((issue, local)) self.__append_issue_filtered(issue, local) def __append_issue_filtered(self, issue, local): if issue.severity == Issue.SEVERITY_WARNING: if self._show_warnings: self.__do_append_issue(issue, local) elif issue.severity == Issue.SEVERITY_TASK: if self._show_tasks: self.__do_append_issue(issue, local) else: self.__do_append_issue(issue, local) def __do_append_issue(self, issue, local): if local: message = issue.message filename = escape(issue.file.basename) else: message = "<span color='%s'>%s</span>" % (self._preferences.get( "LightForeground", "#7f7f7f"), issue.message) filename = "<span color='%s'>%s</span>" % (self._preferences.get( "LightForeground", "#7f7f7f"), issue.file.basename) self._store.append( [self._icons[issue.severity], message, filename, issue]) def destroy(self): del self._editor self._preferences.remove_monitor(self) for obj in self._handlers: obj.disconnect(self._handlers[obj]) BottomView.destroy(self)
class IssueView(PanelView): """ """ _log = getLogger("IssueView") def __init__(self, context, editor): PanelView.__init__(self, context) self._log.debug("init") self._editor = editor self._handlers = {} self._preferences = Preferences() self._preferences.connect("preferences-changed", self._on_preferences_changed) self._show_tasks = self._preferences.get("issues-show-tasks") self._show_warnings = self._preferences.get("issues-show-warnings") self._icons = { Issue.SEVERITY_WARNING : GdkPixbuf.Pixbuf.new_from_file(Resources().get_icon("warning.png")), Issue.SEVERITY_ERROR : GdkPixbuf.Pixbuf.new_from_file(Resources().get_icon("error.png")), Issue.SEVERITY_INFO : None, Issue.SEVERITY_TASK : GdkPixbuf.Pixbuf.new_from_file(Resources().get_icon("task.png")) } grid = Gtk.Grid() self.add(grid) self._store = Gtk.ListStore(GdkPixbuf.Pixbuf, str, str, object) self._view = Gtk.TreeView(model=self._store) column = Gtk.TreeViewColumn() column.set_title(_("Message")) pixbuf_renderer = Gtk.CellRendererPixbuf() column.pack_start(pixbuf_renderer, False) column.add_attribute(pixbuf_renderer, "pixbuf", 0) text_renderer = Gtk.CellRendererText() column.pack_start(text_renderer, True) column.add_attribute(text_renderer, "markup", 1) self._view.append_column(column) column = Gtk.TreeViewColumn() column.set_title(_("File")) text_renderer2 = Gtk.CellRendererText() column.pack_start(text_renderer2, True) column.add_attribute(text_renderer2, "markup", 2) self._view.insert_column(column, -1) self._handlers[self._view] = self._view.connect("row-activated", self._on_row_activated) self._scr = Gtk.ScrolledWindow() self._scr.add(self._view) self._scr.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) self._scr.set_shadow_type(Gtk.ShadowType.IN) self._scr.set_hexpand(True) self._scr.set_vexpand(True) grid.add(self._scr) # toolbar self._button_warnings = Gtk.ToggleToolButton() self._button_warnings.set_tooltip_text(_("Show/Hide Warnings")) image = Gtk.Image() image.set_from_file(Resources().get_icon("warning.png")) self._button_warnings.set_icon_widget(image) self._button_warnings.set_active(self._show_warnings) self._handlers[self._button_warnings] = self._button_warnings.connect("toggled", self.__on_warnings_toggled) self._button_tasks = Gtk.ToggleToolButton() self._button_tasks.set_tooltip_text(_("Show/Hide Tasks")) imageTask = Gtk.Image() imageTask.set_from_file(Resources().get_icon("task.png")) self._button_tasks.set_icon_widget(imageTask) self._button_tasks.set_active(self._show_tasks) self._handlers[self._button_tasks] = self._button_tasks.connect("toggled", self.__on_tasks_toggled) toolbar = Gtk.Toolbar() toolbar.set_orientation(Gtk.Orientation.VERTICAL) toolbar.set_style(Gtk.ToolbarStyle.ICONS) toolbar.set_icon_size(Gtk.IconSize.MENU) toolbar.insert(self._button_warnings, -1) toolbar.insert(self._button_tasks, -1) toolbar.set_vexpand(True) grid.add(toolbar) # theme like gtk3 ctx = self._scr.get_style_context() ctx.set_junction_sides(Gtk.JunctionSides.RIGHT) ctx = toolbar.get_style_context() ctx.set_junction_sides(Gtk.JunctionSides.LEFT | Gtk.JunctionSides.RIGHT) ctx.add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR) self._issues = [] self.show_all() self._log.debug("init finished") def get_label(self): return _("Issues") def get_icon(self): return Gtk.Image.new_from_stock(Gtk.STOCK_DIALOG_INFO, Gtk.IconSize.MENU) def _on_row_activated(self, view, path, column): """ A row has been double-clicked on """ issue = self._store.get(self._store.get_iter(path), 3)[0] self._context.activate_editor(issue.file) #~ # FIXME: this doesn't work correctly #~ if not self._context.active_editor is None: #~ self._context.active_editor.select(issue.start, issue.end) self._editor.select(issue.start, issue.end) def _on_preferences_changed(self, prefs, key, value): if key == "issues-show-warnings" or key == "issues-show-tasks": # update filter self._store.clear() for issue, local in self._issues: self._append_issue_filtered(issue, local) def __on_tasks_toggled(self, togglebutton): self._show_tasks = togglebutton.get_active() self._preferences.set("issues-show-tasks", self._show_tasks) def __on_warnings_toggled(self, togglebutton): self._show_warnings = togglebutton.get_active() self._preferences.set("issues-show-warnings", self._show_warnings) def clear(self): """ Remove all issues from the view """ self._store.clear() self._issues = [] def append_issue(self, issue, local=True): """ Append a new Issue to the view @param issue: the Issue object @param local: indicates whether the Issue occured in the edited file or not """ self._issues.append((issue, local)) self._append_issue_filtered(issue, local) def _append_issue_filtered(self, issue, local): if issue.severity == Issue.SEVERITY_WARNING: if self._show_warnings: self._do_append_issue(issue, local) elif issue.severity == Issue.SEVERITY_TASK: if self._show_tasks: self._do_append_issue(issue, local) else: self._do_append_issue(issue, local) def _do_append_issue(self, issue, local): if local: message = issue.message filename = escape(issue.file.basename) else: message = "<span color='%s'>%s</span>" % (self._preferences.get("light-foreground-color"), issue.message) filename = "<span color='%s'>%s</span>" % (self._preferences.get("light-foreground-color"), issue.file.basename) self._store.append([self._icons[issue.severity], message, filename, issue])
class BaseOutlineView(PanelView): """ Base class for the BibTeX and LaTeX outline views """ __log = getLogger("BaseOutlineView") def __init__(self, context, editor): PanelView.__init__(self, context) self._editor = editor self._base_handlers = {} self.set_orientation(Gtk.Orientation.VERTICAL) self._preferences = Preferences() grid = Gtk.Grid() grid.set_orientation(Gtk.Orientation.VERTICAL) self.add(grid) # toolbar btn_follow = Gtk.ToggleToolButton.new_from_stock(Gtk.STOCK_CONNECT) btn_follow.set_tooltip_text(_("Follow Editor")) btn_follow.set_active( self._preferences.get("outline-connect-to-editor")) self._base_handlers[btn_follow] = btn_follow.connect( "toggled", self._on_follow_toggled) btn_expand = Gtk.ToolButton.new_from_stock(Gtk.STOCK_ZOOM_IN) btn_expand.set_tooltip_text(_("Expand All")) self._base_handlers[btn_expand] = btn_expand.connect( "clicked", self._on_expand_clicked) btn_collapse = Gtk.ToolButton.new_from_stock(Gtk.STOCK_ZOOM_OUT) btn_collapse.set_tooltip_text(_("Collapse All")) self._base_handlers[btn_collapse] = btn_collapse.connect( "clicked", self._on_collapse_clicked) self._toolbar = Gtk.Toolbar() self._toolbar.set_style(Gtk.ToolbarStyle.ICONS) self._toolbar.set_icon_size(Gtk.IconSize.MENU) self._toolbar.insert(btn_follow, -1) self._toolbar.insert(Gtk.SeparatorToolItem(), -1) self._toolbar.insert(btn_expand, -1) self._toolbar.insert(btn_collapse, -1) self._toolbar.insert(Gtk.SeparatorToolItem(), -1) self._toolbar.set_hexpand(True) grid.add(self._toolbar) # tree view column = Gtk.TreeViewColumn() pixbuf_renderer = Gtk.CellRendererPixbuf() column.pack_start(pixbuf_renderer, False) column.add_attribute(pixbuf_renderer, "pixbuf", 1) text_renderer = Gtk.CellRendererText() column.pack_start(text_renderer, True) column.add_attribute(text_renderer, "markup", 0) self._offset_map = OutlineOffsetMap() self._store = Gtk.TreeStore(str, GdkPixbuf.Pixbuf, object) # label, icon, node object self._view = Gtk.TreeView(model=self._store) self._view.append_column(column) self._view.set_headers_visible(False) self._cursor_changed_id = self._view.connect("cursor-changed", self._on_cursor_changed) self._base_handlers[self._view] = self._view.connect( "row-activated", self._on_row_activated) scrolled = Gtk.ScrolledWindow() scrolled.add(self._view) scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled.set_vexpand(True) grid.add(scrolled) # this holds a list of the currently expanded paths self._expandedPaths = None def get_label(self): return _("Outline") def get_icon(self): return Gtk.Image.new_from_file(Resources().get_icon("outline.png")) def _on_follow_toggled(self, toggle_button): value = toggle_button.get_active() self._preferences.set("outline-connect-to-editor", value) def _on_expand_clicked(self, button): self._view.expand_all() def _on_collapse_clicked(self, button): self._view.collapse_all() def select_path_by_offset(self, offset): """ Select the path corresponding to a given offset in the source Called by the Editor """ try: path = self._offset_map.lookup(offset) self._select_path(path) except KeyError: pass def _save_state(self): """ Save the current expand state """ self._expanded_paths = [] self._view.map_expanded_rows(self._save_state_map_function, None) def _save_state_map_function(self, view, path, user_data=None): """ Mapping function for saving the current expand state """ self._expanded_paths.append(path.to_string()) def _restore_state(self): """ Restore the last expand state """ self._view.collapse_all() if self._expanded_paths: for path in self._expanded_paths: self._view.expand_to_path(Gtk.TreePath.new_from_string(path)) def _on_cursor_changed(self, view): selection = view.get_selection() if not selection: return store, it = selection.get_selected() if not it: return outline_node = store.get_value(it, 2) self._on_node_selected(outline_node) def _on_row_activated(self, view, path, column): it = self._store.get_iter(path) node = self._store.get(it, 2)[0] self._on_node_activated(node) def _select_path(self, path): """ Expand a path and select the last node """ selection = self._view.get_selection() if not selection: return # select path self._view.expand_to_path(path) selection.select_path(path) # # methods to be overridden by the subclass # def _on_node_selected(self, node): """ To be overridden """ def _on_node_activated(self, node): """ To be overridden """ def set_outline(self, outline): """
class BaseOutlineView(PanelView): """ Base class for the BibTeX and LaTeX outline views """ __log = getLogger("BaseOutlineView") def __init__(self, context, editor): PanelView.__init__(self, context) self._editor = editor self._base_handlers = {} self.set_orientation(Gtk.Orientation.VERTICAL) self._preferences = Preferences() grid = Gtk.Grid() grid.set_orientation(Gtk.Orientation.VERTICAL) self.add(grid) # toolbar btn_follow = Gtk.ToggleToolButton.new_from_stock(Gtk.STOCK_CONNECT) btn_follow.set_tooltip_text(_("Follow Editor")) btn_follow.set_active(self._preferences.get("outline-connect-to-editor")) self._base_handlers[btn_follow] = btn_follow.connect("toggled", self._on_follow_toggled) btn_expand = Gtk.ToolButton.new_from_stock(Gtk.STOCK_ZOOM_IN) btn_expand.set_tooltip_text(_("Expand All")) self._base_handlers[btn_expand] = btn_expand.connect("clicked", self._on_expand_clicked) btn_collapse = Gtk.ToolButton.new_from_stock(Gtk.STOCK_ZOOM_OUT) btn_collapse.set_tooltip_text(_("Collapse All")) self._base_handlers[btn_collapse] = btn_collapse.connect("clicked", self._on_collapse_clicked) self._toolbar = Gtk.Toolbar() self._toolbar.set_style(Gtk.ToolbarStyle.ICONS) self._toolbar.set_icon_size(Gtk.IconSize.MENU) self._toolbar.insert(btn_follow, -1) self._toolbar.insert(Gtk.SeparatorToolItem(), -1) self._toolbar.insert(btn_expand, -1) self._toolbar.insert(btn_collapse, -1) self._toolbar.insert(Gtk.SeparatorToolItem(), -1) self._toolbar.set_hexpand(True) grid.add(self._toolbar) # tree view column = Gtk.TreeViewColumn() pixbuf_renderer = Gtk.CellRendererPixbuf() column.pack_start(pixbuf_renderer, False) column.add_attribute(pixbuf_renderer, "pixbuf", 1) text_renderer = Gtk.CellRendererText() column.pack_start(text_renderer, True) column.add_attribute(text_renderer, "markup", 0) self._offset_map = OutlineOffsetMap() self._store = Gtk.TreeStore(str, GdkPixbuf.Pixbuf, object) # label, icon, node object self._view = Gtk.TreeView(model=self._store) self._view.append_column(column) self._view.set_headers_visible(False) self._cursor_changed_id = self._view.connect("cursor-changed", self._on_cursor_changed) self._base_handlers[self._view] = self._view.connect("row-activated", self._on_row_activated) scrolled = Gtk.ScrolledWindow() scrolled.add(self._view) scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) scrolled.set_vexpand(True) grid.add(scrolled) # this holds a list of the currently expanded paths self._expandedPaths = None def get_label(self): return _("Outline") def get_icon(self): return Gtk.Image.new_from_file(Resources().get_icon("outline.png")) def _on_follow_toggled(self, toggle_button): value = toggle_button.get_active() self._preferences.set("outline-connect-to-editor", value) def _on_expand_clicked(self, button): self._view.expand_all() def _on_collapse_clicked(self, button): self._view.collapse_all() def select_path_by_offset(self, offset): """ Select the path corresponding to a given offset in the source Called by the Editor """ try: path = self._offset_map.lookup(offset) self._select_path(path) except KeyError: pass def _save_state(self): """ Save the current expand state """ self._expanded_paths = [] self._view.map_expanded_rows(self._save_state_map_function,None) def _save_state_map_function(self, view, path, user_data=None): """ Mapping function for saving the current expand state """ self._expanded_paths.append(path.to_string()) def _restore_state(self): """ Restore the last expand state """ self._view.collapse_all() if self._expanded_paths: for path in self._expanded_paths: self._view.expand_to_path(Gtk.TreePath.new_from_string(path)) def _on_cursor_changed(self, view): selection = view.get_selection() if not selection: return store, it = selection.get_selected() if not it: return outline_node = store.get_value(it, 2) self._on_node_selected(outline_node) def _on_row_activated(self, view, path, column): it = self._store.get_iter(path) node = self._store.get(it, 2)[0] self._on_node_activated(node) def _select_path(self, path): """ Expand a path and select the last node """ selection = self._view.get_selection() if not selection: return # select path self._view.expand_to_path(path) selection.select_path(path) # # methods to be overridden by the subclass # def _on_node_selected(self, node): """ To be overridden """ def _on_node_activated(self, node): """ To be overridden """ def set_outline(self, outline): """
class Game: def __init__(self): pygame.init() #get preferences self.preferences = Preferences() # self.nickname = raw_input('Choose a username: '******'Choose a color (red, green, blue, yellow, white): ') #resolution, flags, depth, display self.unit=Constants.RESOLUTION[0]/Constants.UNITS self.banner = Banner() self.score_width=self.unit*15 if self.preferences.fullscreen: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),pygame.FULLSCREEN) else: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),0,32) pygame.display.set_caption(Constants.CAPTION) #game area surface self.gamescreen = pygame.Surface(Constants.RESOLUTION) #score area rectangle surface self.scorescreen = pygame.Surface((self.score_width,Constants.RESOLUTION[1])) #Snake and foods manager self.me=Snake(color=pygame.color.THECOLORS[self.preferences.get("color")],\ nickname=self.preferences.get("nickname")) self.f=Foods() self.others = {} #Score manager self.scores=Scores((self.score_width,Constants.RESOLUTION[1])) #add our own score, the server will send us the remaining one at connection self.scores.new_score(self.preferences.get("nickname"),\ pygame.color.THECOLORS[self.preferences.get("color")]) #game area background color self.gamescreen.fill(Constants.COLOR_BG) self.scorescreen.fill((100,100,100)) #timers self.clock=pygame.time.Clock(); self.current_time=0 self.move_snake_timer=Timer(1.0/Constants.SNAKE_SPEED*1000,self.current_time,periodic=True) self.blink_snake_timer=Timer(1.0/Constants.SNAKE_BLINKING_SPEED*1000,self.current_time,periodic=True) self.blink_banner_timer=Timer(500,self.current_time,periodic=True) self.new_apple_timer=Timer(Constants.NEW_APPLE_PERIOD*1000,self.current_time,periodic=True) def process_events(self): #key handling for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: self.running=False if event.key == pygame.K_UP: self.me.action(1) if event.key == pygame.K_DOWN: self.me.action(2) if event.key == pygame.K_LEFT: self.me.action(3) if event.key == pygame.K_RIGHT: self.me.action(4) if event.key == pygame.K_SPACE: #self.me.set_ready() self.com.sendSecure("{\"ready\": true}", self.address) def run(self): self.address = (self.preferences.get("server"), self.preferences.get("port")) #initialisation du snakePost self.client = SnakeChan() self.client.connect(self.address, self.preferences.get("color"), self.preferences.get("nickname")) self.com = SnakePost(self.client, self.preferences.get("nickname")) whole_second=0 self.running=True while self.running: #time tracking self.current_time+=self.clock.tick(Constants.FPS) #check if the snake is still alive if not self.me.alive: self.me.alive=True self.me.restart() #check if game need more food # if self.new_apple_timer.expired(self.current_time): # self.f.make() #check if we need to move our own snake's state #if we do, send an update of our position to #the server if self.move_snake_timer.expired(self.current_time): self.me.move() pos = self.me.netinfo() self.com.send(pos, self.address) #check if we need to blink the unready snakes (unready state) if self.blink_snake_timer.expired(self.current_time): for snake in self.others: self.others[snake].blink() #cleanup background self.gamescreen.fill(Constants.COLOR_BG) #draw scores self.scores.draw(self.screen) #draw all snakes positions as last seen by the server #we do not compute their positions ourselves! for snake in self.others: self.others[snake].draw(self.gamescreen) #draw food self.f.draw(self.gamescreen) #process external events (keyboard,...) self.process_events() #then update display #update game area on screen container self.screen.blit(self.gamescreen,(self.score_width,0)) pygame.display.update() # Sur message du serveur... data, addr = self.com.listen() if data is not None: dat = json.loads(data) for key in dat: if key == 'players_info': #On met a jour les scores et les etats des joueurs for player in dat[key]: if not self.others.get(player[0]): # Si on a pas de joueur de ce nom, on l'ajoute self.others[player[0]] = Snake(color=pygame.color.THECOLORS[player[1]], nickname=player[0]) self.scores.new_score(player[0], self.others.get(player[0]).color) else: # On a deja le joueur, on update son etat if player[3]: self.others[player[0]].set_ready() else: self.others[player[0]].set_unready() # on update les scores self.scores.set_score(player[0], player[2]) elif key == "snakes": # message de position des joueurs # on regarde si il y a des serpents a enlever if len(dat[key]) != len(self.others): for nickname in self.others.keys(): connected = False for val in dat[key]: if val[0] == nickname: connected = True if not connected: del self.others[nickname] self.scores.del_score(nickname) for val in dat[key]: # si on a ce joeur et que ses positions ne sont pas vides (premier message) if len(val[1]) > 0 and self.others[val[0]]: self.others[val[0]].setBody(val[1]) elif key == "foods": # les pommes envoyees par le serveur self.f.set_positions(dat[key]) elif key == "grow": # Un serpent a mange une pomme ! if dat[key] == self.preferences.get("nickname"): self.me.grow(Constants.GROW) elif key == "game_over": # Desole, c'est perdu if dat[key] == self.preferences.get("nickname"): self.me.restart()
class Game: def __init__(self): pygame.init() #get preferences self.preferences = Preferences() #resolution, flags, depth, display self.unit=Constants.RESOLUTION[0]/Constants.UNITS self.banner = Banner() self.score_width=self.unit*15 if self.preferences.fullscreen: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),pygame.FULLSCREEN) else: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),0,32) pygame.display.set_caption(Constants.CAPTION) #game area surface self.gamescreen = pygame.Surface(Constants.RESOLUTION) #score area rectangle surface self.scorescreen = pygame.Surface((self.score_width,Constants.RESOLUTION[1])) #Snake and foods manager self.me=Snake(color=pygame.color.THECOLORS[self.preferences.get("color")],\ nickname=self.preferences.get("nickname")) self.nickname = self.preferences.get("nickname") self.f=Foods() #Score manager self.scores=Scores((self.score_width,Constants.RESOLUTION[1])) #add our own score, the server will send us the remaining one at connection self.scores.new_score(self.preferences.get("nickname"),\ pygame.color.THECOLORS[self.preferences.get("color")]) #game area background color self.gamescreen.fill(Constants.COLOR_BG) self.scorescreen.fill((100,100,100)) #timers self.clock=pygame.time.Clock(); self.current_time=0 self.move_snake_timer=Timer(1.0/Constants.SNAKE_SPEED*1000,self.current_time,periodic=True) self.blink_snake_timer=Timer(1.0/Constants.SNAKE_BLINKING_SPEED*1000,self.current_time,periodic=True) self.blink_banner_timer=Timer(500,self.current_time,periodic=True) self.new_apple_timer=Timer(Constants.NEW_APPLE_PERIOD*1000,self.current_time,periodic=True) def process_events(self): #key handling for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: self.running=False if event.key == pygame.K_UP: self.me.action(1) if event.key == pygame.K_DOWN: self.me.action(2) if event.key == pygame.K_LEFT: self.me.action(3) if event.key == pygame.K_RIGHT: self.me.action(4) if event.key == pygame.K_SPACE: self.me.set_ready() def run(self): whole_second=0 self.running=True while self.running: #time tracking self.current_time+=self.clock.tick(Constants.FPS) #check if the snake is still alive if not self.me.alive: self.me.alive=True self.me.restart() #check if game need more food if self.new_apple_timer.expired(self.current_time): self.f.make() #check if we need to move our own snake's state #if we do, send an update of our position to #the server if self.move_snake_timer.expired(self.current_time): self.me.move() #check if we need to blink the unready snakes (unready state) if self.blink_snake_timer.expired(self.current_time): self.me.blink() #check if snake has eaten if self.me.ready: if self.f.check(self.me.head): self.me.grow(Constants.GROW) self.scores.inc_score(self.nickname,1) #cleanup background self.gamescreen.fill(Constants.COLOR_BG) #draw scores self.scores.draw(self.screen) #draw all snakes positions as last seen by the server #we do not compute their positions ourselves! self.me.draw(self.gamescreen) #draw food self.f.draw(self.gamescreen) #process external events (keyboard,...) self.process_events() #then update display #update game area on screen container self.screen.blit(self.gamescreen,(self.score_width,0)) pygame.display.update()
class IssueView(BottomView, IPreferencesMonitor): """ """ _log = getLogger("IssueView") label = "Issues" icon = gtk.STOCK_DIALOG_INFO scope = View.SCOPE_EDITOR def __init__(self, context, editor): BottomView.__init__(self, context) self._editor = editor self._handlers = {} def init(self, context): self._log.debug("init") self._preferences = Preferences() self._show_tasks = self._preferences.get_bool("IssuesShowTasks", True) self._show_warnings = self._preferences.get_bool("IssuesShowWarnings", True) self._context = context self._icons = { Issue.SEVERITY_WARNING : pixbuf_new_from_file(find_resource("icons/warning.png")), Issue.SEVERITY_ERROR : pixbuf_new_from_file(find_resource("icons/error.png")), Issue.SEVERITY_INFO : None, Issue.SEVERITY_TASK : pixbuf_new_from_file(find_resource("icons/task.png")) } self._store = gtk.ListStore(Pixbuf, str, str, object) self._view = gtk.TreeView(self._store) column = gtk.TreeViewColumn() column.set_title("Message") pixbuf_renderer = gtk.CellRendererPixbuf() column.pack_start(pixbuf_renderer, False) column.add_attribute(pixbuf_renderer, "pixbuf", 0) text_renderer = gtk.CellRendererText() column.pack_start(text_renderer, True) column.add_attribute(text_renderer, "markup", 1) self._view.append_column(column) self._view.insert_column_with_attributes(-1, "File", gtk.CellRendererText(), markup=2) self._handlers[self._view] = self._view.connect("row-activated", self._on_row_activated) self._scr = gtk.ScrolledWindow() self._scr.add(self._view) self._scr.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self._scr.set_shadow_type(gtk.SHADOW_IN) self.pack_start(self._scr, True) # toolbar self._button_warnings = gtk.ToggleToolButton() self._button_warnings.set_tooltip_text("Show/Hide Warnings") image = gtk.Image() image.set_from_file(find_resource("icons/warning.png")) self._button_warnings.set_icon_widget(image) self._button_warnings.set_active(self._show_warnings) self._handlers[self._button_warnings] = self._button_warnings.connect("toggled", self.__on_warnings_toggled) self._button_tasks = gtk.ToggleToolButton() self._button_tasks.set_tooltip_text("Show/Hide Tasks") imageTask = gtk.Image() imageTask.set_from_file(find_resource("icons/task.png")) self._button_tasks.set_icon_widget(imageTask) self._button_tasks.set_active(self._show_tasks) self._handlers[self._button_tasks] = self._button_tasks.connect("toggled", self.__on_tasks_toggled) toolbar = gtk.Toolbar() toolbar.set_orientation(gtk.ORIENTATION_VERTICAL) toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_icon_size(gtk.ICON_SIZE_MENU) toolbar.insert(self._button_warnings, -1) toolbar.insert(self._button_tasks, -1) self.pack_start(toolbar, False) self._issues = [] self._preferences.register_monitor(self) self._log.debug("init finished") def _on_row_activated(self, view, path, column): """ A row has been double-clicked on """ issue = self._store.get(self._store.get_iter(path), 3)[0] self._context.activate_editor(issue.file) #~ # FIXME: this doesn't work correctly #~ if not self._context.active_editor is None: #~ self._context.active_editor.select(issue.start, issue.end) self._editor.select(issue.start, issue.end) def _on_value_changed(self, key, value): if key == "IssuesShowWarnings" or key == "IssuesShowTasks": # update filter self._store.clear() for issue, local in self._issues: self.__append_issue_filtered(issue, local) def __on_tasks_toggled(self, togglebutton): self._show_tasks = togglebutton.get_active() self._preferences.set("IssuesShowTasks", self._show_tasks) def __on_warnings_toggled(self, togglebutton): self._show_warnings = togglebutton.get_active() self._preferences.set("IssuesShowWarnings", self._show_warnings) def clear(self): """ Remove all issues from the view """ self.assure_init() self._store.clear() self._issues = [] def append_issue(self, issue, local=True): """ Append a new Issue to the view @param issue: the Issue object @param local: indicates whether the Issue occured in the edited file or not """ self.assure_init() self._issues.append((issue, local)) self.__append_issue_filtered(issue, local) def __append_issue_filtered(self, issue, local): if issue.severity == Issue.SEVERITY_WARNING: if self._show_warnings: self.__do_append_issue(issue, local) elif issue.severity == Issue.SEVERITY_TASK: if self._show_tasks: self.__do_append_issue(issue, local) else: self.__do_append_issue(issue, local) def __do_append_issue(self, issue, local): if local: message = issue.message filename = escape(issue.file.basename) else: message = "<span color='%s'>%s</span>" % (self._preferences.get("LightForeground", "#7f7f7f"), issue.message) filename = "<span color='%s'>%s</span>" % (self._preferences.get("LightForeground", "#7f7f7f"), issue.file.basename) self._store.append([self._icons[issue.severity], message, filename, issue]) def destroy(self): del self._editor self._preferences.remove_monitor(self) for obj in self._handlers: obj.disconnect(self._handlers[obj]) BottomView.destroy(self)
class Game: def __init__(self): pygame.init() #get preferences self.preferences = Preferences() # self.nickname = raw_input('Choose a username: '******'Choose a color (red, green, blue, yellow, white): ') #resolution, flags, depth, display self.unit = Constants.RESOLUTION[0] / Constants.UNITS self.banner = Banner() self.score_width = self.unit * 15 if self.preferences.fullscreen: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),pygame.FULLSCREEN) else: self.screen = pygame.display.set_mode((Constants.RESOLUTION[0]+self.score_width,\ Constants.RESOLUTION[1]),0,32) pygame.display.set_caption(Constants.CAPTION) #game area surface self.gamescreen = pygame.Surface(Constants.RESOLUTION) #score area rectangle surface self.scorescreen = pygame.Surface( (self.score_width, Constants.RESOLUTION[1])) #Snake and foods manager self.me=Snake(color=pygame.color.THECOLORS[self.preferences.get("color")],\ nickname=self.preferences.get("nickname")) self.f = Foods() self.others = {} #Score manager self.scores = Scores((self.score_width, Constants.RESOLUTION[1])) #add our own score, the server will send us the remaining one at connection self.scores.new_score(self.preferences.get("nickname"),\ pygame.color.THECOLORS[self.preferences.get("color")]) #game area background color self.gamescreen.fill(Constants.COLOR_BG) self.scorescreen.fill((100, 100, 100)) #timers self.clock = pygame.time.Clock() self.current_time = 0 self.move_snake_timer = Timer(1.0 / Constants.SNAKE_SPEED * 1000, self.current_time, periodic=True) self.blink_snake_timer = Timer(1.0 / Constants.SNAKE_BLINKING_SPEED * 1000, self.current_time, periodic=True) self.blink_banner_timer = Timer(500, self.current_time, periodic=True) self.new_apple_timer = Timer(Constants.NEW_APPLE_PERIOD * 1000, self.current_time, periodic=True) def process_events(self): #key handling for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: self.running = False if event.key == pygame.K_UP: self.me.action(1) if event.key == pygame.K_DOWN: self.me.action(2) if event.key == pygame.K_LEFT: self.me.action(3) if event.key == pygame.K_RIGHT: self.me.action(4) if event.key == pygame.K_SPACE: #self.me.set_ready() self.com.sendSecure("{\"ready\": true}", self.address) def run(self): self.address = (self.preferences.get("server"), self.preferences.get("port")) #initialisation du snakePost self.client = SnakeChan() self.client.connect(self.address, self.preferences.get("color"), self.preferences.get("nickname")) self.com = SnakePost(self.client, self.preferences.get("nickname")) whole_second = 0 self.running = True while self.running: #time tracking self.current_time += self.clock.tick(Constants.FPS) #check if the snake is still alive if not self.me.alive: self.me.alive = True self.me.restart() #check if game need more food # if self.new_apple_timer.expired(self.current_time): # self.f.make() #check if we need to move our own snake's state #if we do, send an update of our position to #the server if self.move_snake_timer.expired(self.current_time): self.me.move() pos = self.me.netinfo() self.com.send(pos, self.address) #check if we need to blink the unready snakes (unready state) if self.blink_snake_timer.expired(self.current_time): for snake in self.others: self.others[snake].blink() #cleanup background self.gamescreen.fill(Constants.COLOR_BG) #draw scores self.scores.draw(self.screen) #draw all snakes positions as last seen by the server #we do not compute their positions ourselves! for snake in self.others: self.others[snake].draw(self.gamescreen) #draw food self.f.draw(self.gamescreen) #process external events (keyboard,...) self.process_events() #then update display #update game area on screen container self.screen.blit(self.gamescreen, (self.score_width, 0)) pygame.display.update() # Sur message du serveur... data, addr = self.com.listen() if data is not None: dat = json.loads(data) for key in dat: if key == 'players_info': #On met a jour les scores et les etats des joueurs for player in dat[key]: if not self.others.get( player[0] ): # Si on a pas de joueur de ce nom, on l'ajoute self.others[player[0]] = Snake( color=pygame.color.THECOLORS[player[1]], nickname=player[0]) self.scores.new_score( player[0], self.others.get(player[0]).color) else: # On a deja le joueur, on update son etat if player[3]: self.others[player[0]].set_ready() else: self.others[player[0]].set_unready() # on update les scores self.scores.set_score(player[0], player[2]) elif key == "snakes": # message de position des joueurs # on regarde si il y a des serpents a enlever if len(dat[key]) != len(self.others): for nickname in self.others.keys(): connected = False for val in dat[key]: if val[0] == nickname: connected = True if not connected: del self.others[nickname] self.scores.del_score(nickname) for val in dat[key]: # si on a ce joeur et que ses positions ne sont pas vides (premier message) if len(val[1]) > 0 and self.others[val[0]]: self.others[val[0]].setBody(val[1]) elif key == "foods": # les pommes envoyees par le serveur self.f.set_positions(dat[key]) elif key == "grow": # Un serpent a mange une pomme ! if dat[key] == self.preferences.get("nickname"): self.me.grow(Constants.GROW) elif key == "game_over": # Desole, c'est perdu if dat[key] == self.preferences.get("nickname"): self.me.restart()