874 lines
34 KiB
Python
874 lines
34 KiB
Python
#!/usr/bin/python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
# This file is part of texter package
|
|
#
|
|
# texter 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.
|
|
#
|
|
# texter 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 texter. If not, see <http://www.gnu.org/licenses/>.
|
|
#
|
|
# Copyright (C) 2014 Stefan Kögl
|
|
|
|
from __future__ import absolute_import
|
|
|
|
|
|
import cPickle
|
|
import os.path
|
|
import re
|
|
|
|
from PyQt4 import QtCore, QtGui
|
|
|
|
from PyQt4.QtCore import QBuffer, QByteArray, QIODevice
|
|
from PyQt4.QtGui import QPixmap
|
|
|
|
from PyKDE4.kdeui import (KDialog, KActionCollection, KRichTextWidget,
|
|
KRichTextWidget, KMainWindow, KToolBar, KAction, KToolBarSpacerAction,
|
|
KSelectAction, KToggleAction, KShortcut)
|
|
|
|
from PyQt4.QtNetwork import QTcpServer, QTcpSocket
|
|
|
|
from chaosc.argparser_groups import ArgParser
|
|
from chaosc.lib import resolve_host, logger
|
|
|
|
from texter.texter_ui import Ui_MainWindow, _fromUtf8
|
|
from texter.edit_dialog_ui import Ui_EditDialog
|
|
from texter.text_model import TextModel
|
|
|
|
app = QtGui.QApplication([])
|
|
|
|
|
|
# NOTE: if the QIcon.fromTheme method does not find any icons, you can use
|
|
# qtconfig and set a default theme or copy|symlink an existing theme dir to hicolor
|
|
# in your local icon directory:
|
|
# ln -s /your/icon/theme/directory $HOME/.icons/hicolor
|
|
|
|
def get_preview_text(text):
|
|
return re.sub(" +", " ", text.replace("\n", " ")).strip()[:20]
|
|
|
|
class MjpegStreamingServer(QTcpServer):
|
|
|
|
def __init__(self, server_address, parent=None):
|
|
super(MjpegStreamingServer, self).__init__(parent)
|
|
self.server_address = server_address
|
|
self.newConnection.connect(self.start_streaming)
|
|
self.widget = parent.live_text
|
|
self.win_id = self.widget.winId()
|
|
self.sockets = list()
|
|
self.img_data = None
|
|
self.timer = QtCore.QTimer()
|
|
self.timer.timeout.connect(self.render_image)
|
|
self.timer.start(80)
|
|
self.stream_clients = list()
|
|
self.regex = re.compile("^GET /(\w+?)\.(\w+?) HTTP/(\d+\.\d+)$")
|
|
self.html_map = dict()
|
|
self.coords = parent.live_text_rect()
|
|
|
|
def handle_request(self):
|
|
print "foo"
|
|
sock = self.sender()
|
|
logger.info("handle_request: %s %d", sock.peerAddress(), sock.peerPort())
|
|
sock_id = id(sock)
|
|
if sock.state() in (QTcpSocket.UnconnectedState, QTcpSocket.ClosingState):
|
|
logger.info("connection closed")
|
|
self.sockets.remove(sock)
|
|
sock.deleteLater()
|
|
return
|
|
|
|
client_data = str(sock.readAll())
|
|
logger.info("request %r", client_data)
|
|
line = client_data.split("\r\n")[0]
|
|
logger.info("first line: %r", line)
|
|
try:
|
|
resource, ext, http_version = self.regex.match(line).groups()
|
|
logger.info("resource=%r, ext=%r, http_version=%r", resource, ext, http_version)
|
|
except AttributeError:
|
|
logger.info("no matching request - sending 404 not found")
|
|
sock.write("HTTP/1.1 404 Not Found\r\n")
|
|
else:
|
|
if ext == "ico":
|
|
directory = os.path.dirname(os.path.abspath(__file__))
|
|
data = open(os.path.join(directory, "favicon.ico"), "rb").read()
|
|
sock.write(QByteArray('HTTP/1.1 200 Ok\r\nContent-Type: image/x-ico\r\n\r\n%s' % data))
|
|
elif ext == "html":
|
|
directory = os.path.dirname(os.path.abspath(__file__))
|
|
data = open(os.path.join(directory, "index.html"), "rb").read() % sock_id
|
|
self.html_map[sock_id] = None
|
|
sock.write(QByteArray('HTTP/1.1 200 Ok\r\nContent-Type: text/html;encoding: utf-8\r\n\r\n%s' % data))
|
|
#sock.close()
|
|
elif ext == "mjpeg":
|
|
try:
|
|
_, html_sock_id = resource.split("_", 1)
|
|
html_sock_id = int(html_sock_id)
|
|
except ValueError:
|
|
html_sock_id = None
|
|
|
|
if sock not in self.stream_clients:
|
|
logger.info("starting streaming...")
|
|
if html_sock_id is not None:
|
|
self.html_map[html_sock_id] = sock
|
|
self.stream_clients.append(sock)
|
|
sock.write(QByteArray('HTTP/1.1 200 Ok\r\nContent-Type: multipart/x-mixed-replace; boundary=--2342\r\n\r\n'))
|
|
else:
|
|
logger.error("request not found/handled - sending 404 not found")
|
|
sock.write("HTTP/1.1 404 Not Found\r\n")
|
|
|
|
|
|
def remove_stream_client(self):
|
|
try:
|
|
sock = self.sender()
|
|
except RuntimeError:
|
|
return
|
|
sock_id = id(sock)
|
|
logger.info("remove_stream_client: sock=%r, sock_id=%r", sock, sock_id)
|
|
if sock.state() == QTcpSocket.UnconnectedState:
|
|
sock.disconnected.disconnect(self.remove_stream_client)
|
|
self.sockets.remove(sock)
|
|
logger.info("removed sock_id=%r", sock_id)
|
|
sock.close()
|
|
try:
|
|
self.stream_clients.remove(sock)
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
stream_client = self.html_map.pop(sock_id)
|
|
except KeyError:
|
|
logger.info("socket has no child socket")
|
|
else:
|
|
stream_client.close()
|
|
try:
|
|
self.stream_clients.remove(stream_client)
|
|
logger.info("removed stream_client=%r", id(stream_client))
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
self.sockets.remove(stream_client)
|
|
logger.info("removed child sock_id=%r", id(stream_client))
|
|
except ValueError:
|
|
pass
|
|
|
|
def render_image(self):
|
|
if not self.stream_clients:
|
|
return
|
|
|
|
#pixmap = QPixmap.grabWidget(self.widget, QtCore.QRect(10, 10, 768, 576))
|
|
pixmap = QPixmap.grabWindow(self.win_id, 5, 5, 768, 576)
|
|
buf = QBuffer()
|
|
buf.open(QIODevice.WriteOnly)
|
|
pixmap.save(buf, "JPG", 30)
|
|
self.img_data = buf.data()
|
|
len_data = len(self.img_data)
|
|
array = QByteArray("--2342\r\nContent-Type: image/jpeg\r\nContent-length: %d\r\n\r\n%s\r\n\r\n\r\n" % (len_data, self.img_data))
|
|
for sock in self.stream_clients:
|
|
sock.write(array)
|
|
|
|
def start_streaming(self):
|
|
while self.hasPendingConnections():
|
|
sock = self.nextPendingConnection()
|
|
logger.info("new connection=%r", id(sock))
|
|
sock.readyRead.connect(self.handle_request)
|
|
sock.disconnected.connect(self.remove_stream_client)
|
|
self.sockets.append(sock)
|
|
|
|
def stop(self):
|
|
for sock in self.sockets:
|
|
sock.close()
|
|
sock.deleteLater()
|
|
for sock in self.stream_clients:
|
|
sock.close()
|
|
sock.deleteLater()
|
|
self.stream_clients = list()
|
|
self.sockets = list()
|
|
self.html_map = dict()
|
|
self.close()
|
|
|
|
|
|
class EditDialog(QtGui.QWidget, Ui_EditDialog):
|
|
def __init__(self, parent=None):
|
|
super(EditDialog, self).__init__(parent)
|
|
|
|
self.setupUi(self)
|
|
self.model = None
|
|
self.fill_list()
|
|
|
|
self.text_list.clicked.connect(self.slot_show_text)
|
|
self.remove_button.clicked.connect(self.slot_remove_item)
|
|
self.move_up_button.clicked.connect(self.slot_text_up)
|
|
self.move_down_button.clicked.connect(self.slot_text_down)
|
|
self.text_list.clicked.connect(self.slot_toggle_buttons)
|
|
self.move_up_button.setEnabled(False)
|
|
self.move_down_button.setEnabled(False)
|
|
|
|
|
|
def slot_toggle_buttons(self, index):
|
|
row = index.row()
|
|
if row <= 0:
|
|
self.move_up_button.setEnabled(False)
|
|
else:
|
|
self.move_up_button.setEnabled(True)
|
|
|
|
if row >= len(self.model.text_db) - 1:
|
|
self.move_down_button.setEnabled(False)
|
|
else:
|
|
self.move_down_button.setEnabled(True)
|
|
|
|
def fill_list(self):
|
|
self.model = self.parent().parent().model
|
|
self.text_list.setModel(self.model)
|
|
index = self.parent().parent().current_index
|
|
model_index = self.model.index(index, 0)
|
|
self.text_list.setCurrentIndex(model_index)
|
|
|
|
|
|
def slot_text_up(self):
|
|
row = self.text_list.currentIndex().row()
|
|
if row <= 0:
|
|
return False
|
|
|
|
text_db = self.model.text_db
|
|
text_db[row-1], text_db[row] = text_db[row], text_db[row-1]
|
|
self.text_list.setCurrentIndex(self.model.index(row - 1, 0))
|
|
self.text_list.clicked.emit(self.model.index(row - 1, 0))
|
|
self.parent().parent().db_dirty = True
|
|
return True
|
|
|
|
def slot_text_down(self):
|
|
text_db = self.model.text_db
|
|
row = self.text_list.currentIndex().row()
|
|
if row >= len(text_db) - 1:
|
|
return False
|
|
|
|
text_db[row], text_db[row+1] = text_db[row+1], text_db[row]
|
|
index = self.model.index(row + 1, 0)
|
|
self.text_list.setCurrentIndex(index)
|
|
self.text_list.clicked.emit(index)
|
|
self.parent().parent().db_dirty = True
|
|
return True
|
|
|
|
def slot_show_text(self, model_index):
|
|
try:
|
|
self.text_preview.setTextOrHtml(self.parent().parent().model.text_db[model_index.row()][1])
|
|
except IndexError:
|
|
pass
|
|
|
|
def slot_remove_item(self):
|
|
index = self.text_list.currentIndex().row()
|
|
self.model.removeRows(index, 1)
|
|
index = self.model.index(0, 0)
|
|
self.text_list.setCurrentIndex(index)
|
|
self.text_list.clicked.emit(index)
|
|
self.parent().parent().db_dirty = True
|
|
|
|
class TextAnimation(QtCore.QObject):
|
|
animation_started = QtCore.pyqtSignal()
|
|
animation_finished = QtCore.pyqtSignal()
|
|
animation_stopped = QtCore.pyqtSignal()
|
|
|
|
def __init__(self, parent=None):
|
|
super(TextAnimation, self).__init__(parent)
|
|
self.src_text_edit = None
|
|
self.cursor_position = 0
|
|
self.src_cursor = None
|
|
self.dst_text_edit = None
|
|
self.dst_cursor = None
|
|
self.src_block = None
|
|
self.fragment_iter = None
|
|
self.text = None
|
|
self.it = None
|
|
self.timer = None
|
|
self.dst_current_block = None
|
|
self.fonts = dict()
|
|
self.count = 0
|
|
|
|
def start_animation(self, src_text_edit, dst_text_edit, cursor_position):
|
|
if self.timer is not None:
|
|
return False
|
|
self.parent().slot_clear_live()
|
|
self.src_document = QtGui.QTextDocument(self)
|
|
self.src_document.setHtml(src_text_edit.document().toHtml())
|
|
self.src_text_edit = src_text_edit
|
|
self.dst_text_edit = dst_text_edit
|
|
self.cursor_position = cursor_position
|
|
|
|
self.dst_cursor = self.dst_text_edit.textCursor()
|
|
self.dst_cursor.setPosition(self.cursor_position)
|
|
self.timer = QtCore.QTimer(self)
|
|
self.timer.timeout.connect(self.slot_animate)
|
|
self.parent().slot_clear_live()
|
|
self.timer.start(55)
|
|
return True
|
|
|
|
def slot_animate(self):
|
|
self.animation_started.emit()
|
|
|
|
if self.it is None:
|
|
src_root_frame = self.src_document.rootFrame()
|
|
self.it = src_root_frame.begin()
|
|
self.dst_text_edit.document().rootFrame().setFrameFormat(src_root_frame.frameFormat())
|
|
|
|
if not self.it.atEnd():
|
|
if self.src_block is None:
|
|
self.src_block = self.it.currentBlock()
|
|
self.fragment_iter = self.src_block.begin()
|
|
|
|
src_block_format = self.src_block.blockFormat()
|
|
src_char_format = self.src_block.charFormat()
|
|
if self.dst_current_block is not None:
|
|
self.dst_cursor.insertBlock(src_block_format)
|
|
self.dst_current_block = self.dst_current_block.next()
|
|
else:
|
|
self.dst_current_block = self.dst_cursor.block()
|
|
self.dst_cursor.setBlockFormat(src_block_format)
|
|
self.dst_cursor.setBlockCharFormat(src_char_format)
|
|
self.dst_cursor.setCharFormat(src_char_format)
|
|
|
|
self.dst_cursor.mergeBlockCharFormat(src_char_format)
|
|
self.dst_cursor.mergeCharFormat(src_char_format)
|
|
self.dst_cursor.mergeBlockFormat(src_block_format)
|
|
|
|
if not self.fragment_iter.atEnd():
|
|
if self.text is None:
|
|
fragment = self.fragment_iter.fragment()
|
|
self.text = iter(unicode(fragment.text()))
|
|
self.fragment_char_format = fragment.charFormat()
|
|
self.dst_cursor.setCharFormat(self.fragment_char_format)
|
|
|
|
try:
|
|
char = self.text.next()
|
|
self.dst_cursor.insertText(char)
|
|
self.dst_text_edit.ensureCursorVisible()
|
|
except StopIteration:
|
|
self.fragment_iter += 1
|
|
self.text = None
|
|
else:
|
|
self.it += 1
|
|
self.src_block = None
|
|
else:
|
|
self.timer.stop()
|
|
self.timer.timeout.disconnect(self.slot_animate)
|
|
self.timer.deleteLater()
|
|
self.dst_current_block = None
|
|
self.it = None
|
|
self.text = None
|
|
self.animation_finished.emit()
|
|
self.timer = None
|
|
|
|
self.count += 1
|
|
|
|
|
|
class MainWindow(KMainWindow, Ui_MainWindow):
|
|
def __init__(self, args, parent=None):
|
|
super(MainWindow, self).__init__(parent)
|
|
self.args = args
|
|
self.is_streaming = False
|
|
|
|
self.live_center_action = None
|
|
self.preview_center_action = None
|
|
self.live_size_action = None
|
|
self.preview_font_action = None
|
|
self.live_font_action = None
|
|
self.preview_size_action = None
|
|
self.default_size = 28
|
|
self.default_align_text = "format_align_center"
|
|
self.preview_actions = list()
|
|
self.live_actions = list()
|
|
self.current = 0
|
|
self.model = TextModel(self)
|
|
self.animation = TextAnimation(self)
|
|
self.db_dirty = False
|
|
self.is_animate = False
|
|
self.fade_animation = None
|
|
self.dialog = None
|
|
self.current_object = None
|
|
self.current_index = -1
|
|
|
|
self.is_auto_publish = False
|
|
|
|
self.setupUi(self)
|
|
self.http_server = MjpegStreamingServer((args.http_host, args.http_port), self)
|
|
|
|
self.live_text.setLineWrapMode(QtGui.QTextEdit.LineWrapMode(QtGui.QTextEdit.FixedPixelWidth))
|
|
self.live_text.setLineWrapColumnOrWidth(768)
|
|
|
|
self.font = QtGui.QFont("monospace", self.default_size)
|
|
self.font.setStyleHint(QtGui.QFont.TypeWriter)
|
|
|
|
self.previous_action = None
|
|
self.next_action = None
|
|
self.publish_action = None
|
|
self.auto_publish_action = None
|
|
self.save_live_action = None
|
|
self.save_preview_action = None
|
|
self.save_action = None
|
|
self.dialog_widget = None
|
|
self.action_collection = None
|
|
self.streaming_action = None
|
|
self.text_combo = None
|
|
self.clear_live_action = None
|
|
self.clear_preview_action = None
|
|
self.toolbar = None
|
|
self.typer_animation_action = None
|
|
self.text_editor_action = None
|
|
|
|
self.preview_text.setFont(self.font)
|
|
self.preview_text.setRichTextSupport(KRichTextWidget.RichTextSupport(0xffffffff))
|
|
self.preview_editor_collection = KActionCollection(self)
|
|
self.preview_text.createActions(self.preview_editor_collection)
|
|
|
|
self.live_text.setRichTextSupport(KRichTextWidget.RichTextSupport(0xffffffff))
|
|
self.live_text.setFont(self.font)
|
|
self.live_editor_collection = KActionCollection(self)
|
|
self.live_text.createActions(self.live_editor_collection)
|
|
self.filter_editor_actions()
|
|
self.create_toolbar()
|
|
self.slot_load()
|
|
|
|
app.focusChanged.connect(self.focusChanged)
|
|
self.start_streaming()
|
|
|
|
self.show()
|
|
|
|
def getPreviewCoords(self):
|
|
public_rect = self.preview_text.geometry()
|
|
global_rect = QtCore.QRect(self.mapToGlobal(public_rect.topLeft()), self.mapToGlobal(public_rect.bottomRight()))
|
|
return global_rect.x(), global_rect.y()
|
|
|
|
|
|
def filter_editor_actions(self):
|
|
disabled_action_names = [
|
|
"action_to_plain_text",
|
|
"format_painter",
|
|
"direction_ltr",
|
|
"direction_rtl",
|
|
"format_font_family",
|
|
"format_text_background_color",
|
|
"format_list_style",
|
|
"format_list_indent_more",
|
|
"format_list_indent_less",
|
|
"format_text_bold",
|
|
"format_text_underline",
|
|
"format_text_strikeout",
|
|
"format_text_italic",
|
|
"format_align_right",
|
|
"manage_link",
|
|
"format_text_subscript",
|
|
"format_text_superscript",
|
|
"insert_horizontal_rule"
|
|
]
|
|
|
|
for action in self.live_editor_collection.actions():
|
|
text = str(action.objectName())
|
|
if text in disabled_action_names:
|
|
action.setVisible(False)
|
|
|
|
if text == self.default_align_text:
|
|
self.live_center_action = action
|
|
elif text == "format_font_size":
|
|
self.live_size_action = action
|
|
elif text == "format_font_family":
|
|
self.live_font_action = action
|
|
|
|
for action in self.preview_editor_collection.actions():
|
|
text = str(action.objectName())
|
|
if text in disabled_action_names:
|
|
action.setVisible(False)
|
|
|
|
if text == self.default_align_text:
|
|
self.preview_center_action = action
|
|
elif text == "format_font_size":
|
|
self.preview_size_action = action
|
|
elif text == "format_font_family":
|
|
self.preview_font_action = action
|
|
|
|
self.slot_set_preview_defaults()
|
|
self.slot_set_live_defaults()
|
|
|
|
def create_toolbar(self):
|
|
|
|
self.toolbar = KToolBar(self, True, True)
|
|
self.toolbar.setIconDimensions(16)
|
|
self.toolbar.setAllowedAreas(QtCore.Qt.BottomToolBarArea)
|
|
self.toolbar.setMovable(False)
|
|
self.toolbar.setFloatable(False)
|
|
self.toolbar.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
|
|
self.addToolBar(QtCore.Qt.BottomToolBarArea, self.toolbar)
|
|
|
|
self.toolbar.show()
|
|
self.action_collection = KActionCollection(self)
|
|
self.action_collection.addAssociatedWidget(self.toolbar)
|
|
|
|
self.clear_live_action = self.action_collection.addAction("clear_live_action")
|
|
icon = QtGui.QIcon(":texter/images/edit-clear.png")
|
|
self.clear_live_action.setIcon(icon)
|
|
self.clear_live_action.setIconText("clear live")
|
|
self.clear_live_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_Q)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.save_live_action = self.action_collection.addAction("save_live_action")
|
|
icon = QtGui.QIcon(":texter/images/document-new.png")
|
|
self.save_live_action.setIcon(icon)
|
|
self.save_live_action.setIconText("save live")
|
|
self.save_live_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_W)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.clear_preview_action = self.action_collection.addAction("clear_preview_action")
|
|
icon = QtGui.QIcon(":texter/images/edit-clear.png")
|
|
self.clear_preview_action.setIcon(icon)
|
|
self.clear_preview_action.setIconText("clear preview")
|
|
self.clear_preview_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_A)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.save_preview_action = self.action_collection.addAction("save_preview_action")
|
|
icon = QtGui.QIcon(":texter/images/document-new.png")
|
|
self.save_preview_action.setIcon(icon)
|
|
self.save_preview_action.setIconText("save preview")
|
|
self.save_preview_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_S)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.publish_action = self.action_collection.addAction("publish_action")
|
|
icon = QtGui.QIcon(":texter/images/edit-copy.png")
|
|
self.publish_action.setIcon(icon)
|
|
self.publish_action.setIconText("publish")
|
|
self.publish_action.setShortcutConfigurable(True)
|
|
self.publish_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_Return)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.toolbar.insertSeparator(self.publish_action)
|
|
|
|
self.auto_publish_action = KToggleAction(self.action_collection)
|
|
self.action_collection.addAction("auto publish", self.auto_publish_action)
|
|
icon = QtGui.QIcon(":texter/images/view-refresh.png")
|
|
self.auto_publish_action.setIcon(icon)
|
|
self.auto_publish_action.setObjectName("auto_publish_action")
|
|
self.auto_publish_action.setIconText("auto publish")
|
|
self.auto_publish_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_P)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.typer_animation_action = KToggleAction(self.action_collection)
|
|
icon = QtGui.QIcon(":texter/images/media-playback-stop.png")
|
|
self.typer_animation_action.setIcon(icon)
|
|
self.typer_animation_action.setIconText("animate")
|
|
self.typer_animation_action.setObjectName("typer_animation_action")
|
|
self.typer_animation_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_M)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
self.action_collection.addAction("typer_animation_action", self.typer_animation_action)
|
|
|
|
self.text_editor_action = self.action_collection.addAction("text_editor_action")
|
|
icon = QtGui.QIcon(":texter/images/document-open-data.png")
|
|
self.text_editor_action.setIcon(icon)
|
|
self.text_editor_action.setIconText("edit")
|
|
self.text_editor_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_O)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.toolbar.insertSeparator(self.text_editor_action)
|
|
|
|
self.save_action = self.action_collection.addAction("save_action")
|
|
icon = QtGui.QIcon(":texter/images/document-save.png")
|
|
self.save_action.setIcon(icon)
|
|
self.save_action.setIconText("save")
|
|
self.save_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_S)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.streaming_action = KToggleAction(self.action_collection)
|
|
icon = QtGui.QIcon(":texter/images/media-record.png")
|
|
self.streaming_action.setIcon(icon)
|
|
self.streaming_action.setIconText("stream")
|
|
self.streaming_action.setObjectName("stream")
|
|
self.streaming_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.CTRL + QtCore.Qt.Key_1)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
self.action_collection.addAction("stream", self.streaming_action)
|
|
|
|
spacer = KToolBarSpacerAction(self.action_collection)
|
|
self.action_collection.addAction("1_spacer", spacer)
|
|
|
|
self.previous_action = self.action_collection.addAction("previous_action")
|
|
icon = QtGui.QIcon(":texter/images/go-previous-view-page.png")
|
|
self.previous_action.setIcon(icon)
|
|
self.previous_action.setIconText("previous")
|
|
self.previous_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_Left)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.text_combo = KSelectAction(self.action_collection)
|
|
self.text_combo.setEditable(False)
|
|
icon = QtGui.QIcon(":texter/images/document-open-recent.png")
|
|
self.text_combo.setIcon(icon)
|
|
self.text_combo.setIconText("saved texts")
|
|
self.text_combo.setObjectName("text_combo")
|
|
self.action_collection.addAction("saved texts", self.text_combo)
|
|
|
|
self.next_action = self.action_collection.addAction("next_action")
|
|
icon = QtGui.QIcon(":texter/images/go-next-view-page.png")
|
|
self.next_action.setIcon(icon)
|
|
self.next_action.setIconText("next")
|
|
self.next_action.setShortcut(KShortcut(QtGui.QKeySequence(QtCore.Qt.ALT + QtCore.Qt.Key_Right)), KAction.ShortcutTypes(KAction.ActiveShortcut | KAction.DefaultShortcut))
|
|
|
|
self.toolbar.addSeparator()
|
|
|
|
self.save_action.triggered.connect(self.slot_save)
|
|
|
|
self.publish_action.triggered.connect(self.slot_publish)
|
|
self.clear_live_action.triggered.connect(self.slot_clear_live)
|
|
self.clear_preview_action.triggered.connect(self.slot_clear_preview)
|
|
self.text_combo.triggered[int].connect(self.slot_load_preview_text)
|
|
self.text_editor_action.triggered.connect(self.slot_open_dialog)
|
|
self.save_live_action.triggered.connect(self.slot_save_live_text)
|
|
self.save_preview_action.triggered.connect(self.slot_save_preview_text)
|
|
self.streaming_action.triggered.connect(self.slot_toggle_streaming)
|
|
self.auto_publish_action.toggled.connect(self.slot_auto_publish)
|
|
self.typer_animation_action.toggled.connect(self.slot_toggle_animation)
|
|
self.preview_size_action.triggered[QtGui.QAction].connect(self.slot_preview_font_size)
|
|
self.live_size_action.triggered[QtGui.QAction].connect(self.slot_live_font_size)
|
|
|
|
self.next_action.triggered.connect(self.slot_next_item)
|
|
self.previous_action.triggered.connect(self.slot_previous_item)
|
|
self.streaming_action.setChecked(True)
|
|
|
|
def closeEvent(self, event):
|
|
if self.db_dirty:
|
|
self.dialog = KDialog(self)
|
|
self.dialog.setCaption("4.48 texter - text db not saved")
|
|
label = QtGui.QLabel("The Text database is not saved. Do you want to save before exit?", self.dialog)
|
|
self.dialog.setMainWidget(label)
|
|
self.dialog.setButtons(KDialog.ButtonCodes(KDialog.Ok | KDialog.Cancel))
|
|
self.dialog.okClicked.connect(self.slot_save)
|
|
self.dialog.exec_()
|
|
|
|
def live_text_rect(self):
|
|
return 5, 5, 768, 576
|
|
|
|
def stop_streaming(self):
|
|
self.is_streaming = False
|
|
self.http_server.stop()
|
|
|
|
def start_streaming(self):
|
|
self.http_server.listen(port=self.args.http_port)
|
|
self.is_streaming = True
|
|
|
|
def focusChanged(self, old, new):
|
|
if new == self.preview_text:
|
|
self.live_editor_collection.clearAssociatedWidgets()
|
|
self.preview_editor_collection.addAssociatedWidget(self.toolbar)
|
|
elif new == self.live_text:
|
|
self.preview_editor_collection.clearAssociatedWidgets()
|
|
self.live_editor_collection.addAssociatedWidget(self.toolbar)
|
|
|
|
def custom_clear(self, cursor):
|
|
cursor.beginEditBlock()
|
|
cursor.movePosition(QtGui.QTextCursor.Start)
|
|
cursor.movePosition(QtGui.QTextCursor.End, QtGui.QTextCursor.KeepAnchor)
|
|
cursor.removeSelectedText()
|
|
cursor.endEditBlock()
|
|
|
|
def slot_auto_publish(self, state):
|
|
self.is_auto_publish = bool(state)
|
|
|
|
def slot_toggle_animation(self, state):
|
|
self.is_animate = bool(state)
|
|
|
|
def slot_toggle_streaming(self):
|
|
if self.is_streaming:
|
|
self.stop_streaming()
|
|
else:
|
|
self.start_streaming()
|
|
|
|
def slot_next_item(self):
|
|
try:
|
|
self.current = (self.text_combo.currentItem() + 1) % len(self.model.text_db)
|
|
self.text_combo.setCurrentItem(self.current)
|
|
self.slot_load_preview_text(self.current)
|
|
except ZeroDivisionError:
|
|
pass
|
|
|
|
def slot_previous_item(self):
|
|
try:
|
|
self.current = (self.text_combo.currentItem() - 1) % len(self.model.text_db)
|
|
self.text_combo.setCurrentItem(self.current)
|
|
self.slot_load_preview_text(self.current)
|
|
except ZeroDivisionError:
|
|
pass
|
|
|
|
def slot_publish(self):
|
|
if self.is_animate:
|
|
self.animation.start_animation(self.preview_text, self.live_text, 0)
|
|
else:
|
|
self.live_text.setTextOrHtml(self.preview_text.textOrHtml())
|
|
|
|
def slot_live_font_size(self, action):
|
|
self.default_size = self.live_size_action.fontSize()
|
|
self.slot_set_preview_defaults()
|
|
self.slot_set_live_defaults()
|
|
|
|
def slot_preview_font_size(self, action):
|
|
self.default_size = self.preview_size_action.fontSize()
|
|
self.slot_set_live_defaults()
|
|
self.slot_set_preview_defaults()
|
|
|
|
def slot_toggle_publish(self, state=None):
|
|
|
|
if state:
|
|
self.slot_publish()
|
|
else:
|
|
self.slot_clear_live()
|
|
|
|
def slot_set_preview_defaults(self):
|
|
self.preview_center_action.setChecked(True)
|
|
self.preview_text.alignCenter()
|
|
self.font.setPointSize(self.default_size)
|
|
self.preview_text.setFontSize(self.default_size)
|
|
self.preview_text.setFont(self.font)
|
|
self.preview_size_action.setFontSize(self.default_size)
|
|
self.preview_text.document().setDefaultFont(self.font)
|
|
|
|
def slot_set_live_defaults(self):
|
|
self.live_center_action.setChecked(True)
|
|
self.live_text.alignCenter()
|
|
self.live_text.setFontSize(self.default_size)
|
|
self.live_size_action.setFontSize(self.default_size)
|
|
self.live_text.document().setDefaultFont(self.font)
|
|
|
|
def slot_clear_live(self):
|
|
self.live_text.clear()
|
|
self.slot_set_live_defaults()
|
|
|
|
def slot_clear_preview(self):
|
|
self.preview_text.clear()
|
|
self.slot_set_preview_defaults()
|
|
|
|
def slot_fade(self):
|
|
if self.fade_animation.timer is None:
|
|
self.fade_animation.start_animation()
|
|
|
|
def fill_combo_box(self):
|
|
if self.dialog is not None:
|
|
self.dialog.deleteLater()
|
|
self.dialog = None
|
|
|
|
self.text_combo.clear()
|
|
current_row = -1
|
|
for index, list_obj in enumerate(self.model.text_db):
|
|
preview, text = list_obj
|
|
self.text_combo.addAction(preview)
|
|
if list_obj == self.current_object:
|
|
current_row = index
|
|
|
|
if current_row == -1:
|
|
current_row = self.current_index
|
|
self.slot_load_preview_text(current_row)
|
|
self.text_combo.setCurrentItem(current_row)
|
|
|
|
def slot_load_preview_text(self, index):
|
|
try:
|
|
preview, text = self.model.text_db[index]
|
|
except IndexError:
|
|
return
|
|
self.preview_text.setTextOrHtml(text)
|
|
if self.is_auto_publish:
|
|
self.slot_publish()
|
|
|
|
def slot_save_live_text(self):
|
|
text = self.live_text.toHtml()
|
|
preview = get_preview_text(unicode(self.live_text.toPlainText()))
|
|
if not preview:
|
|
return
|
|
old_item = self.model.text_by_preview(preview)
|
|
if old_item is not None:
|
|
suffix = 1
|
|
while 1:
|
|
tmp_preview = "%s_%d" % (preview, suffix)
|
|
tmp = self.model.text_by_preview(tmp_preview)
|
|
if tmp is None:
|
|
preview = tmp_preview
|
|
break
|
|
else:
|
|
suffix += 1
|
|
|
|
self.model.text_db.append([preview, text])
|
|
self.model.modelReset.emit()
|
|
action = self.text_combo.addAction(preview)
|
|
self.text_combo.setCurrentAction(action)
|
|
self.db_dirty = True
|
|
|
|
def slot_save_preview_text(self):
|
|
text = self.preview_text.toHtml()
|
|
preview = get_preview_text(unicode(self.preview_text.toPlainText()))
|
|
|
|
if not preview:
|
|
return
|
|
old_item = self.model.text_by_preview(preview)
|
|
if old_item is not None:
|
|
ix, old_preview, old_text = old_item
|
|
self.model.text_db[ix][1] = text
|
|
else:
|
|
self.model.text_db.append([preview, text])
|
|
action = self.text_combo.addAction(preview)
|
|
self.model.modelReset.emit()
|
|
self.text_combo.setCurrentAction(action)
|
|
self.db_dirty = True
|
|
|
|
def slot_save(self):
|
|
path = os.path.expanduser("~/.texter")
|
|
if not os.path.isdir(path):
|
|
os.mkdir(path)
|
|
try:
|
|
f = open(os.path.join(path, "texter.db"), "w")
|
|
except IOError:
|
|
return
|
|
else:
|
|
cPickle.dump(self.model.text_db, f, cPickle.HIGHEST_PROTOCOL)
|
|
self.db_dirty = False
|
|
|
|
def slot_open_dialog(self):
|
|
self.current_index = self.text_combo.currentItem()
|
|
self.current_object = self.model.text_db[self.current_index]
|
|
if self.dialog is not None:
|
|
self.dialog.deleteLater()
|
|
self.dialog = None
|
|
|
|
self.dialog = KDialog(self)
|
|
self.dialog.setButtons(KDialog.Close)
|
|
self.dialog_widget = EditDialog(self.dialog)
|
|
self.dialog.setMainWidget(self.dialog_widget)
|
|
pos_x, pos_y = self.getPreviewCoords()
|
|
self.dialog.move(pos_x, self.pos().y())
|
|
self.dialog.exec_()
|
|
self.fill_combo_box()
|
|
|
|
def slot_load(self):
|
|
path = os.path.expanduser("~/.texter")
|
|
if not os.path.isdir(path):
|
|
os.mkdir(path)
|
|
try:
|
|
db_file = open(os.path.join(path, "texter.db"))
|
|
except IOError:
|
|
return
|
|
|
|
try:
|
|
self.model.text_db = [list(i) for i in cPickle.load(db_file)]
|
|
except ValueError, error:
|
|
logger.exception(error)
|
|
|
|
self.fill_combo_box()
|
|
self.text_combo.setCurrentItem(0)
|
|
self.slot_load_preview_text(0)
|
|
|
|
|
|
def main():
|
|
arg_parser = ArgParser("texter")
|
|
arg_parser.add_global_group()
|
|
client_group = arg_parser.add_client_group()
|
|
arg_parser.add_argument(client_group, '-x', "--http_host", default="::",
|
|
help='my host, defaults to "::"')
|
|
arg_parser.add_argument(client_group, '-X', "--http_port", default=9001,
|
|
type=int, help='my port, defaults to 9001')
|
|
arg_parser.add_chaosc_group()
|
|
arg_parser.add_subscriber_group()
|
|
args = arg_parser.finalize()
|
|
|
|
args.http_host, args.http_port = resolve_host(args.http_host, args.http_port, args.address_family)
|
|
|
|
window = MainWindow(args)
|
|
app.exec_()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|