Module pgentry

Expand source code
#!/usr/bin/env python

import sys, traceback, os, time, warnings

import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GObject
from gi.repository import GLib

import pgutils, pggui, pgtextview

def wrap(cont):
    fr = Gtk.Frame()
    sc = Gtk.ScrolledWindow()
    sc.set_hexpand(True)
    sc.set_vexpand(True)
    sc.add(cont)
    fr.add(sc)
    return fr, cont

class Entryx(Gtk.Entry):

    def __init__(self, noemit = False):
        super(Entryx).__init__()
        Gtk.Entry.__init__(self)
        self.noemit = noemit    # do not emit move next on enter
        self.connect("key-press-event", self.key_press_event)

    def set_noemit(self, flag):
        self.noemit = flag

    def set_gray(self, flag):
        if flag:
            self.set_editable(False);
            style = self.get_style_context()
            color = style.get_background_color(Gtk.StateFlags.NORMAL)
            color2 = Gdk.RGBA(color.red-.1, color.green-.1, color.blue-.1)
            self.override_background_color(Gtk.StateFlags.NORMAL, color2)
        else:
            self.set_editable(True);
            style = self.get_style_context()
            color = style.get_background_color(Gtk.StateFlags.NORMAL)
            self.override_background_color(Gtk.StateFlags.NORMAL, color)

    def  key_press_event(self, arg1, event):
        #print("keypress", event.keyval)
        if event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab:
            #print("tab keypress ", event.keyval, event.state)
            if event.state & Gdk.ModifierType.SHIFT_MASK:
                self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
            else:
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True

        if event.keyval == Gdk.KEY_Return:
            if not self.noemit:
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
                return True

# Expects two tuples of stuff
# labtext, labname, tip, defval = None:

def entryquad(arr, vbox, entry1, entry2):

    hbox2 = Gtk.HBox(False, 2)

    lab1a = Gtk.Label(label="      ")
    hbox2.pack_start(lab1a, False, 0, 0)
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0]) ; lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    hbox2.pack_start(lab1, False, 0, 0)
    lab1a = Gtk.Label(label="      ")
    hbox2.pack_start(lab1a, False, 0, 0)
    headx = Entryx();  headx.set_width_chars(33)
    lab1.set_mnemonic_widget(headx)

    if entry1[3] != None:
        headx.set_text(entry1[3][entry1[1]])
    hbox2.pack_start(headx, True, 0, 0)
    lab3 = Gtk.Label(label="        ")
    hbox2.pack_start(lab3, False, 0, 0)
    arr.append((entry1[1], headx))

    lab1b = Gtk.Label(label="      ")
    hbox2.pack_start(lab1b, False, 0, 0)
    lab2 = Gtk.Label.new_with_mnemonic(entry2[0])  ; lab2.set_alignment(1, 0)
    lab2.set_tooltip_text(entry2[2])
    hbox2.pack_start(lab2, False, 0, 0)
    lab1b = Gtk.Label(label="      ")
    hbox2.pack_start(lab1b, False, 0, 0)
    headx2 = Entryx();  headx2.set_width_chars(33)
    lab2.set_mnemonic_widget(headx2)
    if entry2[3] != None:
        headx2.set_text(entry2[3][entry2[1]])
    hbox2.pack_start(headx2, True, 0, 0)
    lab3b = Gtk.Label(label="        ")
    hbox2.pack_start(lab3b, False, 0, 0)
    arr.append((entry2[1], headx2))

    #self.ySpacer(vbox)
    vbox.pack_start(hbox2, True, True, 0)
    return lab1, lab2

# Create a label entry pair
def entrypair(vbox, labtext, labname, tip, defval = None):

    hbox2 = Gtk.HBox()
    lab1b = Gtk.Label(label="      ")
    hbox2.pack_start(lab1b, False, 0, 0)

    lab1 = Gtk.Label.new_with_mnemonic(labtext) ; lab1.set_alignment(1, 0)
    hbox2.pack_start(lab1, False, 0, 0)

    lab1a = Gtk.Label(label="      ")
    hbox2.pack_start(lab1a, False, 0, 0)

    headx = Gtk.Entry();
    if defval != None:
        headx.set_text(defval[labname])
    lab1.set_mnemonic_widget(headx)

    hbox2.pack_start(headx, True, 0, 0)
    lab3 = Gtk.Label(label="        ")
    hbox2.pack_start(lab3, False, 0, 0)
    arr.append((labname, headx))

    pggui.ySpacer(vbox)
    vbox.pack_start(hbox2, False, 0, 0)
    lab1.set_tooltip_text(tip)

    return lab1

def textviewpair(arr, vbox, labtext, labname, tip, defval=None, expand=False):

    hbox2 = Gtk.HBox();
    pggui.xSpacer(hbox2)

    lab2a = Gtk.Label(label="     ")
    hbox2.pack_start(lab2a, False , 0, 0)

    lab2 = Gtk.Label.new_with_mnemonic(labtext); lab2.set_alignment(1, 0)
    lab2.set_tooltip_text(tip)
    hbox2.pack_start(lab2, False , 0, 0)
    if defval:
        sw = scrolledtext(arr, labname, defval[labname])
    else:
        sw = scrolledtext(arr, labname, defval)

    lab2.set_mnemonic_widget(sw.textx)

    pggui.xSpacer(hbox2)
    hbox2.pack_start(sw, True, True, 0)
    pggui.xSpacer(hbox2)
    pggui.ySpacer(vbox)

    lab2b = Gtk.Label(label="     ")
    hbox2.pack_start(lab2b, False , 0, 0)
    vbox.pack_start(hbox2, True, True, 0)
    return lab2

def gridquad(gridx, left, top, entry1, entry2, butt = None):
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0] + "  ")
    lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    gridx.attach(lab1, left, top, 1, 1)

    headx = Entryx();
    lab1.set_mnemonic_widget(headx)
    headx.set_width_chars(20)
    if entry1[3] != None:
        headx.set_text(entry1[3])
    gridx.attach(headx, left+1, top, 1, 1)

    lab2 = Gtk.Label.new_with_mnemonic("  " + entry2[0] + "  ")
    lab2.set_alignment(1, 0)
    lab2.set_tooltip_text(entry2[2])
    gridx.attach(lab2, left+2, top, 1, 1)

    headx2 = Entryx();
    lab2.set_mnemonic_widget(headx2)

    headx2.set_width_chars(20)
    if entry2[3] != None:
        headx2.set_text(entry2[3])
    gridx.attach(headx2, left+3, top, 1, 1)
    if butt:
        gridx.attach(butt, left+4, top, 1, 1)
    return headx, headx2

def griddouble(gridx, left, top, entry1, buttx = None):
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0] + "   ")
    lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    gridx.attach(lab1, left, top, 1, 1)

    headx = Entryx();
    lab1.set_mnemonic_widget(headx)
    headx.set_width_chars(40)
    if entry1[3] != None:
        headx.set_text(entry1[3])
    gridx.attach(headx, left+1, top, 2, 1)
    if buttx:
        gridx.attach(buttx, left+3, top, 1, 1)
    return headx

class   TextViewx(Gtk.TextView):

    ''' Override textview for simple deployment '''

    def __init__(self):
        super(TextViewx).__init__()
        GObject.GObject.__init__(self)
        self.buffer = Gtk.TextBuffer()
        self.set_buffer(self.buffer)
        self.single_line = False
        self.connect("key-press-event", self.key_press_event)

    def  key_press_event(self, arg1, event):

        ''' Override tabs '''

        if event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab:
            #print("tab keypress ", event.keyval, event.state)
            if event.state & Gdk.ModifierType.SHIFT_MASK:
                self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
            else:
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True

        # If reached last line, TAB it
        if event.keyval == Gdk.KEY_Down:
            pos = self.buffer.get_property("cursor-position")
            #print("Down", pos)
            #print(self.buffer.list_properties())
            sss = self.buffer.get_start_iter()
            eee = self.buffer.get_end_iter()
            textx = self.buffer.get_text(sss, eee, True)
            if pos == len(textx):
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
                return True

        # If reached first line, TAB it
        if event.keyval == Gdk.KEY_Up:
            # Are we at the beginning:
            pos = self.buffer.get_property("cursor-position")
            #print("Up", pos)
            if pos == 0:
                self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
                return True

        if event.keyval == Gdk.KEY_Return:
            if event.state & Gdk.ModifierType.SHIFT_MASK:
                #print("keypress shift ", event)
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
                return True

    def get_text(self):
        startt = self.buffer.get_start_iter()
        endd = self.buffer.get_end_iter()
        return self.buffer.get_text(startt, endd, False)

    def set_text(self, txt, eventx = False):
        if eventx:
            self.check_saved()
        startt = self.buffer.get_start_iter()
        endd = self.buffer.get_end_iter()
        self.buffer.delete(startt, endd)
        self.buffer.insert(startt, txt)
        self.buffer.set_modified(True)

def gridsingle(gridx, left, top, entry1):
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0] + "   ")
    lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    gridx.attach(lab1, left, top, 1, 1)

    headx, cont = wrap(TextViewx())
    lab1.set_mnemonic_widget(cont)

    if entry1[3] != None:
         headx.set_text(entry1[3])
    gridx.attach(headx, left+1, top, 3, 1)

    return cont

def scrolledtext(arr, name, body = None):
    textx = Gtk.TextView();
    textx.set_border_width(4)
    arr.append((name, textx))
    if body != None:
        #textx.grab_focus()
        buff = Gtk.TextBuffer(); buff.set_text(body)
        textx.set_buffer(buff)

    sw = Gtk.ScrolledWindow()
    sw.textx = textx
    sw.add(textx)
    sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
    sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
    return sw

def imgbutt(imgfile, txt, func, win):
    hbb = Gtk.HBox(); vbb = Gtk.VBox();  ic = Gtk.Image();
    ic.set_from_file(imgfile)
    pb = ic.get_pixbuf();
    #pb2 = pb.scale_simple(150, 150, GdkPixbuf.InterpType.BILINEAR)
    pb2 = pb.scale_simple(150, 150, 0)
    ic2 = Gtk.Image.new_from_pixbuf(pb2)
    butt1d = Gtk.Button.new_with_mnemonic(txt)
    butt1d.connect("clicked", func, win)

    vbb.pack_start(Gtk.Label(label=" "), True, True, 0)
    vbb.pack_start(ic2, False, 0, 0)
    vbb.pack_start(Gtk.Label(label=" "), True, True, 0)
    vbb.pack_start(butt1d, False, 0, 0)
    vbb.pack_start(Gtk.Label(label=" "), True, True, 0)

    hbb.pack_start(Gtk.Label(label="  "), True, True, 0)
    hbb.pack_start(vbb, True, True, 0)
    hbb.pack_start(Gtk.Label(label="  "), True, True, 0)

    return hbb

# eof

Functions

def entrypair(vbox, labtext, labname, tip, defval=None)
Expand source code
def entrypair(vbox, labtext, labname, tip, defval = None):

    hbox2 = Gtk.HBox()
    lab1b = Gtk.Label(label="      ")
    hbox2.pack_start(lab1b, False, 0, 0)

    lab1 = Gtk.Label.new_with_mnemonic(labtext) ; lab1.set_alignment(1, 0)
    hbox2.pack_start(lab1, False, 0, 0)

    lab1a = Gtk.Label(label="      ")
    hbox2.pack_start(lab1a, False, 0, 0)

    headx = Gtk.Entry();
    if defval != None:
        headx.set_text(defval[labname])
    lab1.set_mnemonic_widget(headx)

    hbox2.pack_start(headx, True, 0, 0)
    lab3 = Gtk.Label(label="        ")
    hbox2.pack_start(lab3, False, 0, 0)
    arr.append((labname, headx))

    pggui.ySpacer(vbox)
    vbox.pack_start(hbox2, False, 0, 0)
    lab1.set_tooltip_text(tip)

    return lab1
def entryquad(arr, vbox, entry1, entry2)
Expand source code
def entryquad(arr, vbox, entry1, entry2):

    hbox2 = Gtk.HBox(False, 2)

    lab1a = Gtk.Label(label="      ")
    hbox2.pack_start(lab1a, False, 0, 0)
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0]) ; lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    hbox2.pack_start(lab1, False, 0, 0)
    lab1a = Gtk.Label(label="      ")
    hbox2.pack_start(lab1a, False, 0, 0)
    headx = Entryx();  headx.set_width_chars(33)
    lab1.set_mnemonic_widget(headx)

    if entry1[3] != None:
        headx.set_text(entry1[3][entry1[1]])
    hbox2.pack_start(headx, True, 0, 0)
    lab3 = Gtk.Label(label="        ")
    hbox2.pack_start(lab3, False, 0, 0)
    arr.append((entry1[1], headx))

    lab1b = Gtk.Label(label="      ")
    hbox2.pack_start(lab1b, False, 0, 0)
    lab2 = Gtk.Label.new_with_mnemonic(entry2[0])  ; lab2.set_alignment(1, 0)
    lab2.set_tooltip_text(entry2[2])
    hbox2.pack_start(lab2, False, 0, 0)
    lab1b = Gtk.Label(label="      ")
    hbox2.pack_start(lab1b, False, 0, 0)
    headx2 = Entryx();  headx2.set_width_chars(33)
    lab2.set_mnemonic_widget(headx2)
    if entry2[3] != None:
        headx2.set_text(entry2[3][entry2[1]])
    hbox2.pack_start(headx2, True, 0, 0)
    lab3b = Gtk.Label(label="        ")
    hbox2.pack_start(lab3b, False, 0, 0)
    arr.append((entry2[1], headx2))

    #self.ySpacer(vbox)
    vbox.pack_start(hbox2, True, True, 0)
    return lab1, lab2
def griddouble(gridx, left, top, entry1, buttx=None)
Expand source code
def griddouble(gridx, left, top, entry1, buttx = None):
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0] + "   ")
    lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    gridx.attach(lab1, left, top, 1, 1)

    headx = Entryx();
    lab1.set_mnemonic_widget(headx)
    headx.set_width_chars(40)
    if entry1[3] != None:
        headx.set_text(entry1[3])
    gridx.attach(headx, left+1, top, 2, 1)
    if buttx:
        gridx.attach(buttx, left+3, top, 1, 1)
    return headx
def gridquad(gridx, left, top, entry1, entry2, butt=None)
Expand source code
def gridquad(gridx, left, top, entry1, entry2, butt = None):
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0] + "  ")
    lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    gridx.attach(lab1, left, top, 1, 1)

    headx = Entryx();
    lab1.set_mnemonic_widget(headx)
    headx.set_width_chars(20)
    if entry1[3] != None:
        headx.set_text(entry1[3])
    gridx.attach(headx, left+1, top, 1, 1)

    lab2 = Gtk.Label.new_with_mnemonic("  " + entry2[0] + "  ")
    lab2.set_alignment(1, 0)
    lab2.set_tooltip_text(entry2[2])
    gridx.attach(lab2, left+2, top, 1, 1)

    headx2 = Entryx();
    lab2.set_mnemonic_widget(headx2)

    headx2.set_width_chars(20)
    if entry2[3] != None:
        headx2.set_text(entry2[3])
    gridx.attach(headx2, left+3, top, 1, 1)
    if butt:
        gridx.attach(butt, left+4, top, 1, 1)
    return headx, headx2
def gridsingle(gridx, left, top, entry1)
Expand source code
def gridsingle(gridx, left, top, entry1):
    lab1 = Gtk.Label.new_with_mnemonic(entry1[0] + "   ")
    lab1.set_alignment(1, 0)
    lab1.set_tooltip_text(entry1[2])
    gridx.attach(lab1, left, top, 1, 1)

    headx, cont = wrap(TextViewx())
    lab1.set_mnemonic_widget(cont)

    if entry1[3] != None:
         headx.set_text(entry1[3])
    gridx.attach(headx, left+1, top, 3, 1)

    return cont
def imgbutt(imgfile, txt, func, win)
Expand source code
def imgbutt(imgfile, txt, func, win):
    hbb = Gtk.HBox(); vbb = Gtk.VBox();  ic = Gtk.Image();
    ic.set_from_file(imgfile)
    pb = ic.get_pixbuf();
    #pb2 = pb.scale_simple(150, 150, GdkPixbuf.InterpType.BILINEAR)
    pb2 = pb.scale_simple(150, 150, 0)
    ic2 = Gtk.Image.new_from_pixbuf(pb2)
    butt1d = Gtk.Button.new_with_mnemonic(txt)
    butt1d.connect("clicked", func, win)

    vbb.pack_start(Gtk.Label(label=" "), True, True, 0)
    vbb.pack_start(ic2, False, 0, 0)
    vbb.pack_start(Gtk.Label(label=" "), True, True, 0)
    vbb.pack_start(butt1d, False, 0, 0)
    vbb.pack_start(Gtk.Label(label=" "), True, True, 0)

    hbb.pack_start(Gtk.Label(label="  "), True, True, 0)
    hbb.pack_start(vbb, True, True, 0)
    hbb.pack_start(Gtk.Label(label="  "), True, True, 0)

    return hbb
def scrolledtext(arr, name, body=None)
Expand source code
def scrolledtext(arr, name, body = None):
    textx = Gtk.TextView();
    textx.set_border_width(4)
    arr.append((name, textx))
    if body != None:
        #textx.grab_focus()
        buff = Gtk.TextBuffer(); buff.set_text(body)
        textx.set_buffer(buff)

    sw = Gtk.ScrolledWindow()
    sw.textx = textx
    sw.add(textx)
    sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
    sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
    return sw
def textviewpair(arr, vbox, labtext, labname, tip, defval=None, expand=False)
Expand source code
def textviewpair(arr, vbox, labtext, labname, tip, defval=None, expand=False):

    hbox2 = Gtk.HBox();
    pggui.xSpacer(hbox2)

    lab2a = Gtk.Label(label="     ")
    hbox2.pack_start(lab2a, False , 0, 0)

    lab2 = Gtk.Label.new_with_mnemonic(labtext); lab2.set_alignment(1, 0)
    lab2.set_tooltip_text(tip)
    hbox2.pack_start(lab2, False , 0, 0)
    if defval:
        sw = scrolledtext(arr, labname, defval[labname])
    else:
        sw = scrolledtext(arr, labname, defval)

    lab2.set_mnemonic_widget(sw.textx)

    pggui.xSpacer(hbox2)
    hbox2.pack_start(sw, True, True, 0)
    pggui.xSpacer(hbox2)
    pggui.ySpacer(vbox)

    lab2b = Gtk.Label(label="     ")
    hbox2.pack_start(lab2b, False , 0, 0)
    vbox.pack_start(hbox2, True, True, 0)
    return lab2
def wrap(cont)
Expand source code
def wrap(cont):
    fr = Gtk.Frame()
    sc = Gtk.ScrolledWindow()
    sc.set_hexpand(True)
    sc.set_vexpand(True)
    sc.add(cont)
    fr.add(sc)
    return fr, cont

Classes

class Entryx (noemit=False)

:Constructors:

::

Entry(**properties)
new() -> Gtk.Widget
new_with_buffer(buffer:Gtk.EntryBuffer) -> Gtk.Widget
Expand source code
class Entryx(Gtk.Entry):

    def __init__(self, noemit = False):
        super(Entryx).__init__()
        Gtk.Entry.__init__(self)
        self.noemit = noemit    # do not emit move next on enter
        self.connect("key-press-event", self.key_press_event)

    def set_noemit(self, flag):
        self.noemit = flag

    def set_gray(self, flag):
        if flag:
            self.set_editable(False);
            style = self.get_style_context()
            color = style.get_background_color(Gtk.StateFlags.NORMAL)
            color2 = Gdk.RGBA(color.red-.1, color.green-.1, color.blue-.1)
            self.override_background_color(Gtk.StateFlags.NORMAL, color2)
        else:
            self.set_editable(True);
            style = self.get_style_context()
            color = style.get_background_color(Gtk.StateFlags.NORMAL)
            self.override_background_color(Gtk.StateFlags.NORMAL, color)

    def  key_press_event(self, arg1, event):
        #print("keypress", event.keyval)
        if event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab:
            #print("tab keypress ", event.keyval, event.state)
            if event.state & Gdk.ModifierType.SHIFT_MASK:
                self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
            else:
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True

        if event.keyval == Gdk.KEY_Return:
            if not self.noemit:
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
                return True

Ancestors

  • gi.repository.Gtk.Entry
  • gi.overrides.Gtk.Widget
  • gi.repository.Gtk.Widget
  • gi.repository.GObject.InitiallyUnowned
  • gi.overrides.GObject.Object
  • gi.repository.GObject.Object
  • gi._gi.GObject
  • gi.repository.Atk.ImplementorIface
  • gi.repository.Gtk.Buildable
  • gi.repository.Gtk.CellEditable
  • gi.overrides.Gtk.Editable
  • gi.repository.Gtk.Editable
  • gobject.GInterface

Methods

def key_press_event(self, arg1, event)
Expand source code
def  key_press_event(self, arg1, event):
    #print("keypress", event.keyval)
    if event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab:
        #print("tab keypress ", event.keyval, event.state)
        if event.state & Gdk.ModifierType.SHIFT_MASK:
            self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
        else:
            self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
        return True

    if event.keyval == Gdk.KEY_Return:
        if not self.noemit:
            self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True
def set_gray(self, flag)
Expand source code
def set_gray(self, flag):
    if flag:
        self.set_editable(False);
        style = self.get_style_context()
        color = style.get_background_color(Gtk.StateFlags.NORMAL)
        color2 = Gdk.RGBA(color.red-.1, color.green-.1, color.blue-.1)
        self.override_background_color(Gtk.StateFlags.NORMAL, color2)
    else:
        self.set_editable(True);
        style = self.get_style_context()
        color = style.get_background_color(Gtk.StateFlags.NORMAL)
        self.override_background_color(Gtk.StateFlags.NORMAL, color)
def set_noemit(self, flag)
Expand source code
def set_noemit(self, flag):
    self.noemit = flag
class TextViewx

Override textview for simple deployment

Expand source code
class   TextViewx(Gtk.TextView):

    ''' Override textview for simple deployment '''

    def __init__(self):
        super(TextViewx).__init__()
        GObject.GObject.__init__(self)
        self.buffer = Gtk.TextBuffer()
        self.set_buffer(self.buffer)
        self.single_line = False
        self.connect("key-press-event", self.key_press_event)

    def  key_press_event(self, arg1, event):

        ''' Override tabs '''

        if event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab:
            #print("tab keypress ", event.keyval, event.state)
            if event.state & Gdk.ModifierType.SHIFT_MASK:
                self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
            else:
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True

        # If reached last line, TAB it
        if event.keyval == Gdk.KEY_Down:
            pos = self.buffer.get_property("cursor-position")
            #print("Down", pos)
            #print(self.buffer.list_properties())
            sss = self.buffer.get_start_iter()
            eee = self.buffer.get_end_iter()
            textx = self.buffer.get_text(sss, eee, True)
            if pos == len(textx):
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
                return True

        # If reached first line, TAB it
        if event.keyval == Gdk.KEY_Up:
            # Are we at the beginning:
            pos = self.buffer.get_property("cursor-position")
            #print("Up", pos)
            if pos == 0:
                self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
                return True

        if event.keyval == Gdk.KEY_Return:
            if event.state & Gdk.ModifierType.SHIFT_MASK:
                #print("keypress shift ", event)
                self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
                return True

    def get_text(self):
        startt = self.buffer.get_start_iter()
        endd = self.buffer.get_end_iter()
        return self.buffer.get_text(startt, endd, False)

    def set_text(self, txt, eventx = False):
        if eventx:
            self.check_saved()
        startt = self.buffer.get_start_iter()
        endd = self.buffer.get_end_iter()
        self.buffer.delete(startt, endd)
        self.buffer.insert(startt, txt)
        self.buffer.set_modified(True)

Ancestors

  • gi.repository.Gtk.TextView
  • gi.overrides.Gtk.Container
  • gi.repository.Gtk.Container
  • gi.overrides.Gtk.Widget
  • gi.repository.Gtk.Widget
  • gi.repository.GObject.InitiallyUnowned
  • gi.overrides.GObject.Object
  • gi.repository.GObject.Object
  • gi._gi.GObject
  • gi.repository.Atk.ImplementorIface
  • gi.repository.Gtk.Buildable
  • gi.repository.Gtk.Scrollable
  • gobject.GInterface

Methods

def get_text(self)
Expand source code
def get_text(self):
    startt = self.buffer.get_start_iter()
    endd = self.buffer.get_end_iter()
    return self.buffer.get_text(startt, endd, False)
def key_press_event(self, arg1, event)

Override tabs

Expand source code
def  key_press_event(self, arg1, event):

    ''' Override tabs '''

    if event.keyval == Gdk.KEY_Tab or event.keyval == Gdk.KEY_ISO_Left_Tab:
        #print("tab keypress ", event.keyval, event.state)
        if event.state & Gdk.ModifierType.SHIFT_MASK:
            self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
        else:
            self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
        return True

    # If reached last line, TAB it
    if event.keyval == Gdk.KEY_Down:
        pos = self.buffer.get_property("cursor-position")
        #print("Down", pos)
        #print(self.buffer.list_properties())
        sss = self.buffer.get_start_iter()
        eee = self.buffer.get_end_iter()
        textx = self.buffer.get_text(sss, eee, True)
        if pos == len(textx):
            self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True

    # If reached first line, TAB it
    if event.keyval == Gdk.KEY_Up:
        # Are we at the beginning:
        pos = self.buffer.get_property("cursor-position")
        #print("Up", pos)
        if pos == 0:
            self.emit("move-focus",  Gtk.DirectionType.TAB_BACKWARD)
            return True

    if event.keyval == Gdk.KEY_Return:
        if event.state & Gdk.ModifierType.SHIFT_MASK:
            #print("keypress shift ", event)
            self.emit("move-focus",  Gtk.DirectionType.TAB_FORWARD)
            return True
def set_text(self, txt, eventx=False)
Expand source code
def set_text(self, txt, eventx = False):
    if eventx:
        self.check_saved()
    startt = self.buffer.get_start_iter()
    endd = self.buffer.get_end_iter()
    self.buffer.delete(startt, endd)
    self.buffer.insert(startt, txt)
    self.buffer.set_modified(True)