#!/usr/bin/env python
# Copyright (C) 2014-2016 Oleh Prypin <blaxpirit@gmail.com>
#
# This file is part of SixCells.
#
# SixCells is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# SixCells is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with SixCells. If not, see <http://www.gnu.org/licenses/>.
from __future__ import division, print_function
import sys
import math
import os.path
import common
from common import *
from qt.core import QPoint, QPointF, QRectF, QTimer
from qt.gui import QIcon, QKeySequence, QMouseEvent, QPainterPath, QPen, QTransform, QPolygonF
from qt.widgets import QDialog, QDialogButtonBox, QFileDialog, QGraphicsPathItem, QGraphicsView, QLabel, QLineEdit, QMessageBox, QShortcut, QVBoxLayout
class Cell(common.Cell):
def __init__(self):
common.Cell.__init__(self)
self.revealed = False
self.preview = None
@property
def selected(self):
return self in self.scene().selection
@selected.setter
def selected(self, value):
if value:
self.scene().selection.add(self)
self.setOpacity(0.5)
else:
try:
self.scene().selection.remove(self)
except KeyError: pass
self.setOpacity(1)
def upd(self, first=False):
common.Cell.upd(self, first)
if self.revealed:
self.setBrush(Color.revealed_border)
def mousePressEvent(self, e):
if e.button() == qt.LeftButton and e.modifiers() & qt.ShiftModifier:
self.selected = not self.selected
e.ignore()
if self.scene().selection:
return
if e.button() == qt.LeftButton and e.modifiers() & (qt.AltModifier | qt.ControlModifier):
self.revealed = not self.revealed
self.upd()
e.ignore()
def mouseMoveEvent(self, e):
if self.scene().selection:
if self.selected:
x, y = convert_pos(e.scenePos().x(), e.scenePos().y())
x, y = round(x), round(y)
dx = x-self.coord.x
dy = y-self.coord.y
if dx or dy:
full_selection = set(self.scene().selection)
for cell in self.scene().selection:
full_selection |= set(cell.columns)
for it in full_selection:
new = Cell()
self.scene().addItem(new)
new.coord = (it.coord.x+dx, it.coord.y+dy)
overlapping = set(new.overlapping)-full_selection
new.remove()
if overlapping:
break
else:
for cell in self.scene().selection:
for it in [cell] + cell.columns:
it.place((it.coord.x+dx, it.coord.y+dy))
elif not self.contains(e.pos()): # mouse was dragged outside
if not self.preview:
self.preview = Column()
self.scene().addItem(self.preview)
a = angle(e.pos())*360/tau
x, y = self.coord
if -30 < a < 30:
self.preview.coord = x, y-2
self.preview.angle = 0
elif -90 < a < -30:
self.preview.coord = x-1, y-1
self.preview.angle = -60
elif 30 < a < 90:
self.preview.coord = x+1, y-1
self.preview.angle = 60
else:
self.preview.remove()
self.preview = None
if self.preview:
self.preview.upd()
def mouseReleaseEvent(self, e):
if self.scene().ignore_release:
self.scene().ignore_release = False
return
if self.scene().supress:
return
if self.scene().selection:
self.scene().full_upd()
self.scene().undo_step()
if e.modifiers() & (qt.ShiftModifier | qt.AltModifier | qt.ControlModifier) or self.scene().selection:
e.ignore()
return
if not self.preview:
if self.contains(e.pos()): # mouse was not dragged outside
if e.button() == qt.LeftButton:
self.show_info = (self.show_info+1)%(3 if self.kind is Cell.empty else 2)
self.upd()
self.scene().undo_step(self)
elif e.button() == qt.RightButton:
for col in self.columns:
col.remove()
scene = self.scene()
with self.upd_neighbors():
self.remove()
scene.undo_step()
else:
for it in self.preview.overlapping:
self.preview.remove()
self.preview = None
break
else:
self.preview.place()
self.preview.upd()
self.preview = None
def copyattrs(self, new):
new.kind = self.kind
new.show_info = self.show_info
new.revealed = self.revealed
new.extra_text = self.extra_text
class Column(common.Column):
def __init__(self):
common.Column.__init__(self)
def mousePressEvent(self, e):
pass
def mouseReleaseEvent(self, e):
if self.scene().supress:
return
if self.contains(e.pos()): # mouse was not dragged outside
if e.button() == qt.LeftButton:
self.show_info = not self.show_info
self.upd()
self.scene().undo_step(self)
elif e.button() == qt.RightButton:
scene = self.scene()
self.remove()
scene.undo_step(self)
def copyattrs(self, new):
new.angle = self.angle
new.show_info = self.show_info
def convert_pos(x, y):
return x/cos30, y*2
class Scene(common.Scene):
def __init__(self):
common.Scene.__init__(self)
self.reset()
self.swap_buttons = False
self.use_rightclick = False
self.ignore_release = False
self.undo_history_length = 16
self.undo_step()
def reset(self):
self.clear()
self.preview = None
self.selection = set()
self.selection_path_item = None
self.supress = False
self.title = self.author = self.information = ''
self.undo_history = []
self.undo_pos = -1
def _place(self, p, kind=Cell.unknown):
if not self.preview:
self.preview = Cell()
self.preview.kind = kind
self.preview.setOpacity(0.4)
self.addItem(self.preview)
x, y = convert_pos(p.x(), p.y())
x = round(x)
for yy in [round(y), int(math.floor(y - 1e-4)), int(math.ceil(y + 1e-4))]:
self.preview.coord = (x, yy)
if not any(isinstance(it, Cell) for it in self.preview.overlapping):
break
else:
self.preview.coord = (round(x), round(y))
self.preview.upd()
self.preview._text.setText('')
def mousePressEvent(self, e):
if self.supress:
return
self.last_press = self.itemAt(e.scenePos(), QTransform())
if self.selection:
if (e.button() == qt.LeftButton and not self.itemAt(e.scenePos(), QTransform())) or e.button() == qt.RightButton:
old_selection = self.selection
self.selection = set()
for it in old_selection:
try:
it.selected = False
except AttributeError: pass
if not self.itemAt(e.scenePos(), QTransform()):
if e.button() == qt.LeftButton:
if e.modifiers() & qt.ShiftModifier:
self.selection_path_item = QGraphicsPathItem()
self.selection_path = path = QPainterPath()
self.selection_path_item.setPen(QPen(Color.selection, 0, qt.DashLine))
path.moveTo(e.scenePos())
self.selection_path_item.setPath(path)
self.addItem(self.selection_path_item)
if e.button() == qt.LeftButton or (self.use_rightclick and e.button() == qt.RightButton):
if not e.modifiers() & qt.ShiftModifier:
self._place(e.scenePos(), Cell.full if (e.button() == qt.LeftButton) ^ self.swap_buttons else Cell.empty)
else:
common.Scene.mousePressEvent(self, e)
def mouseMoveEvent(self, e):
if self.supress:
return
if self.selection_path_item:
p = self.selection_path
p.lineTo(e.scenePos())
p2 = QPainterPath(p)
p2.lineTo(p.pointAtPercent(0))
self.selection_path_item.setPath(p2)
elif self.preview:
self._place(e.scenePos())
else:
common.Scene.mouseMoveEvent(self, e)
def mouseReleaseEvent(self, e):
if self.supress:
return
if self.selection_path_item:
p = self.selection_path
p.lineTo(p.pointAtPercent(0))
for it in self.items(p, qt.IntersectsItemShape):
if isinstance(it, Cell):
it.selected = True
self.removeItem(self.selection_path_item)
self.selection_path_item = None
elif self.preview:
col = None
for it in self.preview.overlapping:
if isinstance(it, Column):
if it.coord == self.preview.coord:
col = it
continue
if isinstance(it, Cell) or abs(it.coord.y - self.preview.coord.y) == 1:
self.preview.remove()
break
else:
if col:
old_cell = col.cell
p = (col.coord.x - old_cell.coord.x + self.preview.coord.x, col.coord.y - old_cell.coord.y + self.preview.coord.y)
if not self.grid.get(p):
old_cell = col.cell
col.place((col.coord.x - old_cell.coord.x + self.preview.coord.x, col.coord.y - old_cell.coord.y + self.preview.coord.y))
col.upd()
col = None
if not col:
self.preview.setOpacity(1)
self.preview.place()
self.undo_step()
self.preview.show_info = self.black_show_info if self.preview.kind is Cell.empty else self.blue_show_info
self.preview.upd(True)
else:
self.preview.remove()
self.preview = None
else:
common.Scene.mouseReleaseEvent(self, e)
def mouseDoubleClickEvent(self, e):
it = self.itemAt(e.scenePos(), QTransform())
if not it:
self.mousePressEvent(e)
return
if not isinstance(it, Cell):
return
if self.last_press is None and not self.use_rightclick:
if it.kind is Cell.full:
it.kind = Cell.empty
it.show_info = self.black_show_info
else:
it.kind = Cell.full
it.show_info = self.blue_show_info
it.upd(True)
self.ignore_release = True
common.Scene.mouseDoubleClickEvent(self, e)
def undo_step(self, it=None):
step = dict(self.grid)
if it is not None:
new = type(it)()
it.copyattrs(new)
step[tuple(it.coord)] = new
self.undo_history[self.undo_pos+1:] = [step]
self.undo_pos = len(self.undo_history) - 1
if self.undo_history_length and len(self.undo_history) > self.undo_history_length:
del self.undo_history[0]
self.undo_pos -= 1
def undo(self, step=-1):
self.undo_pos += step
try:
if self.undo_pos < 0:
raise IndexError()
grid = self.undo_history[self.undo_pos]
except IndexError:
self.undo_pos -= step
return
for it in self.items():
self.removeItem(it)
self.grid = {}
for (x, y), it in grid.items():
self.addItem(it)
it.place((x, y))
self.full_upd()
return True
def redo(self):
self.undo(1)
class View(common.View):
def __init__(self, scene):
common.View.__init__(self, scene)
self.setResizeAnchor(QGraphicsView.AnchorViewCenter)
self.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
inf = -1e10
self.setSceneRect(QRectF(QPointF(-inf, -inf), QPointF(inf, inf)))
self.scale(50, 50) #*1.00955
self.hexcells_ui = False
def mousePressEvent(self, e):
if e.button() == qt.MidButton or (e.button() == qt.RightButton and not self.scene.use_rightclick and not self.scene.itemAt(self.mapToScene(e.pos()), QTransform())):
fake = QMouseEvent(e.type(), e.pos(), qt.LeftButton, qt.LeftButton, e.modifiers())
self.scene.supress = True
self.setDragMode(QGraphicsView.ScrollHandDrag)
common.View.mousePressEvent(self, fake)
else:
common.View.mousePressEvent(self, e)
def mouseReleaseEvent(self, e):
if e.button() == qt.MidButton or (e.button() == qt.RightButton and self.scene.supress):
fake = QMouseEvent(e.type(), e.pos(), qt.LeftButton, qt.LeftButton, e.modifiers())
common.View.mouseReleaseEvent(self, fake)
self.setDragMode(QGraphicsView.NoDrag)
self.scene.supress = False
else:
common.View.mouseReleaseEvent(self, e)
def zoom(self, d):
zoom = self.transform().scale(d, d).mapRect(QRectF(0, 0, 1, 1)).width()
if zoom < 10 and d < 1:
return
elif zoom > 350 and d > 1:
return
self.scale(d, d)
def wheelEvent(self, e):
try:
d = e.angleDelta().y()
except AttributeError:
d = e.delta()
self.zoom(1.0015**d) #1.00005
@event_property
def hexcells_ui(self):
self.viewport().update()
self.setViewportUpdateMode(QGraphicsView.FullViewportUpdate if self.hexcells_ui else QGraphicsView.MinimalViewportUpdate)
def drawBackground(self, g, rect):
common.View.drawBackground(self, g, rect)
if self.hexcells_ui:
pts = [(-13.837, 8.321), (-13.837, -4.232), (-9.843, -8.274), (11.713, -8.274), (11.713, -5.421), (13.837, -5.421), (13.837, 8.321)]
poly = QPolygonF([rect.center() + QPointF(*p) for p in pts])
pen = QPen(qt.gray, 1)
pen.setCosmetic(True)
g.setPen(pen)
g.drawPolygon(poly)
class MainWindow(common.MainWindow):
title = "SixCells Editor"
Cell = Cell
Column = Column
def __init__(self):
common.MainWindow.__init__(self)
self.resize(1280, 720)
self.setWindowIcon(QIcon(here('resources', 'editor.ico')))
self.scene = Scene()
self.view = View(self.scene)
self.setCentralWidget(self.view)
self.statusBar()
menu = self.menuBar().addMenu("&File")
action = menu.addAction("&New", self.close_file, QKeySequence.New)
action.setStatusTip("Close the current level and start with an empty one.")
action = menu.addAction("&Open...", self.load_file, QKeySequence.Open)
action.setStatusTip("Close the current level and load one from a file.")
action = menu.addAction("&Save", lambda: self.save_file(self.current_file), QKeySequence.Save)
action.setStatusTip("Save the level, overwriting the current file.")
action = menu.addAction("Save &As...", self.save_file, QKeySequence('Ctrl+Shift+S'))
action.setStatusTip("Save the level into a different file.")
menu.addSeparator()
action = menu.addAction("&Copy to Clipboard", self.copy, QKeySequence('Ctrl+C'))
action.setStatusTip("Copy the current level into clipboard, in a text-based .hexcells format, padded with Tab characters.")
action = menu.addAction("&Paste from Clipboard", self.paste, QKeySequence('Ctrl+V'))
action.setStatusTip("Load a level in text-based .hexcells format that is currently in the clipboard.")
menu.addSeparator()
action = menu.addAction("&Quit", self.close, QKeySequence.Quit)
action.setStatusTip("Close SixCells Editor.")
menu = self.menuBar().addMenu("&Edit")
action = menu.addAction("&Undo", self.scene.undo, QKeySequence.Undo)
action.setStatusTip("Cancel the last action.")
action = menu.addAction("&Redo", self.scene.redo, QKeySequence.Redo)
action.setStatusTip("Repeat the last cancelled action.")
menu.addSeparator()
action = menu.addAction("Level &Information", self.set_information, QKeySequence('Ctrl+D'))
action.setStatusTip("Add or change the level's title, author's name and custom text hints.")
menu = self.menuBar().addMenu("&Play")
action = menu.addAction("From &Start", self.play, QKeySequence('Shift+Tab'))
QShortcut(QKeySequence('Ctrl+Tab'), self, action.trigger)
action.setStatusTip("Playtest this level from the beginning (discarding all progress).")
action = menu.addAction("&Resume", lambda: self.play(resume=True), QKeySequence('Tab'))
action.setStatusTip("Continue playtesting this level from where you left off.")
menu = self.menuBar().addMenu("Preference&s")
self.swap_buttons_group = make_action_group(self, menu, self.scene, 'swap_buttons', [
("&Left Click Places Blue", False, "A blue cell will be placed when left mouse button is clicked. Black will then be the secondary color."),
("&Left Click Places Black", True, "A black cell will be placed when left mouse button is clicked. Blue will then be the secondary color."),
])
self.swap_buttons_group[False].setChecked(True)
menu.addSeparator()
self.secondary_action_group = make_action_group(self, menu, self.scene, 'use_rightclick', [
("&Right Click Places Secondary", True, "A cell with color opposite to the above choice will be placed when right mouse button is clicked."),
("&Double Click Places Secondary", False, "A cell with color opposite to the above choice will be placed when left mouse button is double-clicked."),
])
self.secondary_action_group[True].setChecked(True)
menu.addSeparator()
states = [
("&Blank", 0, "When placed, these cells will not contain a number."),
("With &Number", 1, "When placed, these cells will contain a number, for example, \"2\"."),
("With &Connection Info", 2, "When placed, these cells will contain a number and connection information, for example, \"{2}\" or \"-3-\"."),
]
submenu = menu.addMenu("Place Blac&ks")
submenu.setStatusTip("Black cells, when placed, will be...")
self.black_show_info_group = make_action_group(self, submenu, self.scene, 'black_show_info', states)
self.black_show_info_group[1].setChecked(True)
submenu = menu.addMenu("Place &Blues")
submenu.setStatusTip("Blue cells, when placed, will be...")
self.blue_show_info_group = make_action_group(self, submenu, self.scene, 'blue_show_info', states[:-1])
self.blue_show_info_group[0].setChecked(True)
self.blue_show_info_group[2] = self.blue_show_info_group[0] # for config backwards compatibility
menu.addSeparator()
self.enable_hexcells_ui_action = action = make_check_action("Show Hexcells &UI", self, 'hexcells_ui')
action.setChecked(False)
action.setStatusTip("Show the borders of Hexcells UI to see the limit of level size.")
menu.addAction(action)
self.enable_statusbar_action = action = make_check_action("Show &Status Bar", self, 'statusbar_visible')
action.setChecked(True)
menu.addAction(action)
menu = self.menuBar().addMenu("&Help")
action = menu.addAction("&Instructions", self.help, QKeySequence.HelpContents)
action.setStatusTip("View README on the project's webpage.")
action = menu.addAction("&About", self.about)
action.setStatusTip("About SixCells Editor.")
action = QAction("Zoom In", self)
action.setShortcut(QKeySequence.ZoomIn)
QShortcut(QKeySequence('+'), self, action.trigger)
QShortcut(QKeySequence('='), self, action.trigger)
action.triggered.connect(lambda: self.view.zoom(1.2))
self.addAction(action)
action = QAction("Zoom Out", self)
action.setShortcut(QKeySequence.ZoomOut)
QShortcut(QKeySequence('-'), self, action.trigger)
action.triggered.connect(lambda: self.view.zoom(0.85))
self.addAction(action)
self.current_file = None
self.any_changes = False
self.scene.changed.connect(self.changed)
self.last_used_folder = None
self.swap_buttons = False
self.default_author = None
load_config_from_file(self, self.config_format, 'sixcells', 'editor.cfg')
config_format = '''
swap_buttons = next(v for v, a in swap_buttons_group.items() if a.isChecked()); swap_buttons_group[v].setChecked(True)
secondary_cell_action = 'double' if next(v for v, a in secondary_action_group.items() if a.isChecked()) else 'right'; secondary_action_group[v=='double'].setChecked(True)
default_black = next(v for v, a in black_show_info_group.items() if a.isChecked()); black_show_info_group[v].setChecked(True)
default_blue = next(v for v, a in blue_show_info_group.items() if a.isChecked()); blue_show_info_group[v].setChecked(True)
hexcells_ui = enable_hexcells_ui_action.isChecked(); enable_hexcells_ui_action.setChecked(v)
status_bar = enable_statusbar_action.isChecked(); enable_statusbar_action.setChecked(v)
undo_history_length = scene.undo_history_length; scene.undo_history_length = v
antialiasing = view.antialiasing; view.antialiasing = v
default_author
last_used_folder
window_geometry_qt = save_geometry_qt(); restore_geometry_qt(v)
'''
def changed(self, rects=None):
if rects is None or any((rect.width() or rect.height()) for rect in rects):
self.any_changes = True
def no_changes(self):
self.any_changes = False
def no_changes():
self.any_changes = False
QTimer.singleShot(0, no_changes)
@property
def status(self):
return self.statusBar().currentMessage()
@status.setter
def status(self, value):
if not value:
self.statusBar().clearMessage()
elif isinstance(value, tuple):
self.statusBar().showMessage(value[0], int(value[1]*1000))
else:
self.statusBar().showMessage(value)
app.processEvents()
@property
def hexcells_ui(self):
self.view.hexcells_ui
@hexcells_ui.setter
def hexcells_ui(self, value):
self.view.hexcells_ui = value
@property
def statusbar_visible(self):
return self.statusBar().isVisible()
@statusbar_visible.setter
def statusbar_visible(self, value):
self.statusBar().setVisible(value)
@event_property
def current_file(self):
title = self.title
if self.current_file:
title = os.path.basename(self.current_file) + ' - ' + title
self.setWindowTitle(title)
def close_file(self):
result = False
if not self.any_changes:
result = True
else:
if self.current_file:
msg = "The level \"{}\" has been modified. Do you want to save it?".format(self.current_file)
else:
msg = "Do you want to save this level?"
btn = QMessageBox.warning(self, "Unsaved changes", msg, QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel, QMessageBox.Save)
if btn == QMessageBox.Save:
if self.save_file(self.current_file):
result = True
elif btn == QMessageBox.Discard:
result = True
if result:
self.current_file = None
self.scene.reset()
self.no_changes()
self.scene.undo_step()
return result
def set_information(self, desc=None):
dialog = QDialog()
dialog.setWindowTitle("Level Information")
layout = QVBoxLayout()
dialog.setLayout(layout)
layout.addWidget(QLabel("Title:"))
title_field = QLineEdit(self.scene.title)
title_field.setMaxLength(50)
layout.addWidget(title_field)
layout.addWidget(QLabel("Author name:"))
author_field = QLineEdit(self.scene.author or self.default_author)
author_field.setMaxLength(20)
layout.addWidget(author_field)
old_author = author_field.text()
information = (self.scene.information).splitlines()
layout.addWidget(QLabel("Custom text hints:"))
information1_field = QLineEdit(information[0] if information else '')
information1_field.setMaxLength(120)
layout.addWidget(information1_field)
information2_field = QLineEdit(information[1] if len(information) > 1 else '')
information2_field.setMaxLength(120)
layout.addWidget(information2_field)
layout.addWidget(QLabel("This text will be displayed within the level"))
def accepted():
self.scene.title = title_field.text().strip()
self.scene.author = author_field.text().strip()
if self.scene.author and self.scene.author!=old_author:
self.default_author = self.scene.author
self.scene.information = '\n'.join(line for line in [information1_field.text().strip(), information2_field.text().strip()] if line)
self.changed()
dialog.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
button_box.rejected.connect(dialog.close)
button_box.accepted.connect(accepted)
layout.addWidget(button_box)
dialog.exec_()
def center_on(self, x, y):
self.view.centerOn(x*cos30, y/2 + 0.3)
def copy(self):
common.MainWindow.copy(self)
self.center_on(*common.level_center)
def save_file(self, fn=None):
if not fn:
try:
dialog = QFileDialog.getSaveFileNameAndFilter
except AttributeError:
dialog = QFileDialog.getSaveFileName
fn, _ = dialog(self, "Save", self.last_used_folder, "Hexcells level (*.hexcells)")
if not fn:
return
self.status = "Saving..."
try:
level, status = save(self.scene)
with open(fn, 'wb') as f:
f.write(level.encode('utf-8'))
if isinstance(status, basestring):
QMessageBox.warning(None, "Warning", status + '\n' + "Saved anyway.")
self.no_changes()
self.current_file = fn
self.last_used_folder = os.path.dirname(fn)
self.status = "Done", 1
self.center_on(*common.level_center)
return True
except ValueError as e:
QMessageBox.critical(None, "Error", str(e))
self.status = "Failed", 1
def prepare(self):
self.view.fitInView(self.scene.itemsBoundingRect().adjusted(-0.5, -0.5, 0.5, 0.5), qt.KeepAspectRatio)
self.center_on(16, 16)
self.no_changes()
self.scene.undo_step()
def play(self, resume=False):
self.status = "Switching to Player..."
import player
player.app = app
window = player.MainWindow(playtest=True)
window.setWindowModality(qt.ApplicationModal)
window.setWindowState(self.windowState())
window.setGeometry(self.geometry())
window.scene.author = self.scene.author
window.scene.title = self.scene.title
window.scene.information = self.scene.information
corresponding_cells = []
for cell in self.scene.all(Cell):
new = player.Cell()
window.scene.addItem(new)
new.place(cell.coord)
cell.copyattrs(new)
if resume:
try:
new.revealed = new.revealed or cell.revealed_resume
except AttributeError: pass
corresponding_cells.append((cell, new))
for col in self.scene.all(Column):
new = player.Column()
window.scene.addItem(new)
new.place(col.coord)
col.copyattrs(new)
window.prepare()
windowcloseevent = window.closeEvent
def closeevent(e):
windowcloseevent(e)
for edcell, plcell in corresponding_cells:
edcell.revealed_resume = plcell.display is not Cell.unknown
edcell.extra_text = plcell.extra_text
window.closeEvent = closeevent
window.show()
app.processEvents()
window.view.setSceneRect(self.view.sceneRect())
window.view.setTransform(self.view.transform())
window.view.horizontalScrollBar().setValue(self.view.horizontalScrollBar().value())
delta = window.view.mapTo(window.central_widget, QPoint(0, 0))
window.view.verticalScrollBar().setValue(self.view.verticalScrollBar().value() + delta.y())
window.view.setFocus()
self.status = "Done", 1
def closeEvent(self, e):
if not self.close_file():
e.ignore()
return
save_config_to_file(self, self.config_format, 'sixcells', 'editor.cfg')
def main(f=None):
global window
window = MainWindow()
window.show()
if not f and len(sys.argv[1:]) == 1:
f = sys.argv[1]
if f:
f = os.path.abspath(f)
QTimer.singleShot(50, lambda: window.load_file(f))
app.exec_()
if __name__ == '__main__':
main()
