232 lines
7.1 KiB
Python
Executable File
232 lines
7.1 KiB
Python
Executable File
#!/usr/bin/python
|
|
#
|
|
# examples/draw.py -- protocol test application.
|
|
#
|
|
# Copyright (C) 2000 Peter Liljenberg <petli@ctrl-c.liu.se>
|
|
#
|
|
# This library is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU Lesser General Public License
|
|
# as published by the Free Software Foundation; either version 2.1
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This library 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 Lesser General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Lesser General Public
|
|
# License along with this library; if not, write to the
|
|
# Free Software Foundation, Inc.,
|
|
# 59 Temple Place,
|
|
# Suite 330,
|
|
# Boston, MA 02111-1307 USA
|
|
|
|
|
|
import sys
|
|
import os
|
|
|
|
# Change path so we find Xlib
|
|
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
|
|
|
|
from Xlib import X
|
|
from Xlib.protocol import display
|
|
from Xlib.protocol.request import *
|
|
|
|
# Application window (only one)
|
|
class Window(object):
|
|
def __init__(self, display):
|
|
self.d = display
|
|
self.objects = []
|
|
|
|
# Find which screen to open the window on
|
|
self.screen = self.d.info.roots[self.d.default_screen]
|
|
|
|
# Allocate ids to the window and gc
|
|
self.window = self.d.allocate_resource_id()
|
|
self.gc = self.d.allocate_resource_id()
|
|
|
|
# Create a window
|
|
CreateWindow(self.d, None,
|
|
self.screen.root_depth,
|
|
self.window,
|
|
self.screen.root,
|
|
50, 50, 300, 200, 2,
|
|
X.InputOutput,
|
|
X.CopyFromParent,
|
|
|
|
# special attribute values
|
|
background_pixel = self.screen.white_pixel,
|
|
event_mask = (X.ExposureMask |
|
|
X.StructureNotifyMask |
|
|
X.ButtonPressMask |
|
|
X.ButtonReleaseMask |
|
|
X.Button1MotionMask),
|
|
colormap = X.CopyFromParent)
|
|
|
|
# Create a gc for drawing
|
|
CreateGC(self.d, None,
|
|
self.gc,
|
|
self.window,
|
|
|
|
# special attribute values
|
|
foreground = self.screen.black_pixel,
|
|
background = self.screen.white_pixel)
|
|
|
|
# Map the window, making it visible
|
|
MapWindow(self.d, None, self.window)
|
|
|
|
# Main loop, handling events
|
|
|
|
def loop(self):
|
|
current = None
|
|
while 1:
|
|
e = self.d.next_event()
|
|
|
|
# Window has been destroyed, quit
|
|
if e.type == X.DestroyNotify:
|
|
sys.exit(0)
|
|
|
|
# Some part of the window has been exposed,
|
|
# redraw all the objects.
|
|
if e.type == X.Expose:
|
|
for o in self.objects:
|
|
o.expose(e)
|
|
|
|
# Left button pressed, start to draw
|
|
if e.type == X.ButtonPress and e.detail == 1:
|
|
current = Movement(self, e)
|
|
self.objects.append(current)
|
|
|
|
# Left button released, finish drawing
|
|
if e.type == X.ButtonRelease and e.detail == 1 and current:
|
|
current.finish(e)
|
|
current = None
|
|
|
|
# Mouse movement with button pressed, draw
|
|
if e.type == X.MotionNotify and current:
|
|
current.motion(e)
|
|
|
|
# A drawed objects, consisting of either a single
|
|
# rhomboid, or two rhomboids connected by a winding line
|
|
|
|
class Movement(object):
|
|
def __init__(self, win, ev):
|
|
self.win = win
|
|
|
|
self.left = ev.event_x - 5
|
|
self.right = ev.event_x + 5
|
|
self.top = ev.event_y - 5
|
|
self.bottom = ev.event_y + 5
|
|
|
|
self.time = ev.time
|
|
self.lines = [(ev.event_x, ev.event_y)]
|
|
|
|
self.first = Rhomboid(self.win, ev)
|
|
self.last = None
|
|
|
|
def motion(self, ev):
|
|
# Find all the mouse coordinates since the
|
|
# last event received
|
|
|
|
r = GetMotionEvents(self.win.d,
|
|
window = self.win.window,
|
|
start = self.time,
|
|
stop = ev.time)
|
|
|
|
# Record the previous last coordinate, and append
|
|
# the new coordinates
|
|
|
|
firstline = len(self.lines) - 1
|
|
|
|
if r.events:
|
|
# Discard the first coordinate if that is identical to
|
|
# the last recorded coordinate
|
|
|
|
pos = r.events[0]
|
|
if (pos.x, pos.y) == self.lines[-1]:
|
|
events = r.events[1:]
|
|
else:
|
|
events = r.events
|
|
|
|
# Append all coordinates
|
|
for pos in events:
|
|
x = pos.x
|
|
y = pos.y
|
|
|
|
if x < self.left:
|
|
self.left = x
|
|
if x > self.right:
|
|
self.right = x
|
|
|
|
if y < self.top:
|
|
self.top = y
|
|
if y > self.bottom:
|
|
self.bottom = y
|
|
|
|
self.lines.append((x, y))
|
|
|
|
# Append the event coordinate, if that is different from the
|
|
# last movement coordinate
|
|
if (ev.event_x, ev.event_y) != self.lines[-1]:
|
|
self.lines.append((ev.event_x, ev.event_y))
|
|
|
|
# Draw a line between the new coordinates
|
|
PolyLine(self.win.d, None,
|
|
X.CoordModeOrigin,
|
|
self.win.window,
|
|
self.win.gc,
|
|
self.lines[firstline:])
|
|
|
|
self.time = ev.time
|
|
|
|
def finish(self, ev):
|
|
self.motion(ev)
|
|
if len(self.lines) > 1:
|
|
self.last = Rhomboid(self.win, ev)
|
|
|
|
self.left = min(ev.event_x - 5, self.left)
|
|
self.right = max(ev.event_x + 5, self.right)
|
|
self.top = min(ev.event_y - 5, self.top)
|
|
self.bottom = max(ev.event_y + 5, self.bottom)
|
|
|
|
def expose(self, ev):
|
|
# We should check if this object is in the exposed
|
|
# area, but I can't be bothered right now, so just
|
|
# redraw on the last Expose in every batch
|
|
|
|
if ev.count == 0:
|
|
self.first.draw()
|
|
if self.last:
|
|
# Redraw all the lines
|
|
PolyLine(self.win.d, None,
|
|
X.CoordModeOrigin,
|
|
self.win.window,
|
|
self.win.gc,
|
|
self.lines)
|
|
self.last.draw()
|
|
|
|
|
|
# A rhomboid, drawed around the Movement endpoints
|
|
class Rhomboid(object):
|
|
def __init__(self, win, ev):
|
|
self.win = win
|
|
self.x = ev.event_x
|
|
self.y = ev.event_y
|
|
self.draw()
|
|
|
|
def draw(self):
|
|
# Draw the segments of the rhomboid
|
|
PolyLine(self.win.d, None,
|
|
X.CoordModePrevious,
|
|
self.win.window,
|
|
self.win.gc,
|
|
[(self.x, self.y - 5),
|
|
(5, 5),
|
|
(-5, 5),
|
|
(-5, -5),
|
|
(5, -5)])
|
|
|
|
|
|
if __name__ == '__main__':
|
|
Window(display.Display()).loop()
|