#!/usr/bin/env python
import pygtk
pygtk.require('2.0')
import gtk
import gobject
import xml.dom.minidom
import math
import os.path
cellmap_ClientBrush = (1,1, '',
['ClientBrush'] )
cellmap_Window = (3,3, '',
['WindowTopLeft', 'WindowTopEdge', 'WindowTopRight',
'WindowLeftEdge', 'WindowBackdrop', 'WindowRightEdge',
'WindowBottomLeft', 'WindowBottomEdge', 'WindowBottomRight'] )
cellmap_CheckboxNormal = (1,1, '',
['CheckboxNormal'] )
cellmap_CheckboxHover = (1,1, '',
['CheckboxHover'] )
cellmap_CheckboxMark = (1,1, '',
['CheckboxMark'] )
cellmap_RadioButtonNormal = (1,1, '',
['RadioButtonNormal'] )
cellmap_RadioButtonHover = (1,1, '',
['RadioButtonHover'] )
cellmap_RadioButtonMark = (1,1, '',
['RadioButtonMark'] )
cellmap_Titlebar = (3,1, '',
['TitlebarLeft', 'TitlebarMiddle', 'TitlebarRight'] )
cellmap_NewTitlebar = (5,1, '',
['NewTitlebarLeft', 'NewTitlebarMiddle', 'NewTitlebarRight', 'SysAreaMiddle', 'SysAreaRight'] )
cellmap_ButtonNormal = (3,1, '',
['ButtonLeftNormal', 'ButtonMiddleNormal', 'ButtonRightNormal'] )
cellmap_ButtonPushed = (3,1, '',
['ButtonLeftPushed', 'ButtonMiddlePushed', 'ButtonRightPushed'] )
cellmap_ButtonHighlight = (3,1, '',
['ButtonLeftHighlight', 'ButtonMiddleHighlight', 'ButtonRightHighlight'] )
cellmap_Static = (3,3, '',
['StaticTopLeft', 'StaticTop', 'StaticTopRight',
'StaticLeft', 'StaticBackdrop', 'StaticRight',
'StaticBottomLeft', 'StaticBottom', 'StaticBottomRight'] )
cellmap_ProgressBar = (3,1, '',
['ProgressBarLeft', 'ProgressBarMiddle', 'ProgressBarRight'] )
cellmap_ProgressBarDimSeg = (1,1, '',
['ProgressBarDimSegment'] )
cellmap_ProgressBarLitSeg = (1,1, '',
['ProgressBarLitSegment'] )
cellmap_EditBox = (3,1, '',
['EditBoxLeft', 'EditBoxMiddle', 'EditBoxRight'] )
cellmap_EditBoxCarat = (1,1, '',
['EditBoxCarat'] )
cellmap_TextSelectionBrush = (1,1, '',
['TextSelectionBrush'] )
cellmap_VertScroll = (3,1, '',
['VertScrollTop', 'VertScrollMiddle', 'VertScrollBottom'] )
cellmap_VertScrollBarSegment = (1,1, '',
['VertScrollBarSegment'] )
cellmap_VertScrollThumbNormal = (1,1, '',
['VertScrollThumbNormal'] )
cellmap_VertScrollThumbHover = (1,1, '',
['VertScrollThumbHover'] )
cellmap_VertScrollUpNormal = (1,1, '',
['VertScrollUpNormal'] )
cellmap_VertScrollDownNormal = (1,1, '',
['VertScrollDownNormal'] )
cellmap_VertScrollUpHover = (1,1, '',
['VertScrollUpHover'] )
cellmap_VertScrollDownHover = (1,1, '',
['VertScrollDownHover'] )
cellmap_MiniVertScrollBarSegment = (1,1, '',
['MiniVertScrollBarSegment'] )
cellmap_MiniVertScrollThumbNormal = (1,1, '',
['MiniVertScrollThumbNormal'] )
cellmap_MiniVertScrollThumbNormalExt = (1,3, '',
['MiniVertScrollThumbTopNormal', 'MiniVertScrollThumbMiddleNormal', 'MiniVertScrollThumbBottomNormal'] )
cellmap_MiniVertScrollThumbHover = (1,1, '',
['MiniVertScrollThumbHover'] )
cellmap_MiniVertScrollThumbHoverExt = (1,3, '',
['MiniVertScrollThumbTopHover', 'MiniVertScrollThumbMiddleHover', 'MiniVertScrollThumbBottomHover'] )
cellmap_MiniVertScrollUpNormal = (1,1, '',
['MiniVertScrollUpNormal'] )
cellmap_MiniVertScrollDownNormal = (1,1, '',
['MiniVertScrollDownNormal'] )
cellmap_MiniVertScrollUpHover = (1,1, '',
['MiniVertScrollUpHover'] )
cellmap_MiniVertScrollDownHover = (1,1, '',
['MiniVertScrollDownHover'] )
cellmap_VertSliderBody = (1,1, '',
['VertSliderBody'] )
cellmap_VertSliderThumbNormal = (1,1, '',
['VertSliderThumbNormal'] )
cellmap_VertSliderThumbHover = (1,1, '',
['VertSliderThumbHover'] )
cellmap_MiniHorzScrollBarSegment = (1,1, '',
['MiniHorzScrollBarSegment'] )
cellmap_MiniHorzScrollThumbNormal = (1,1, '',
['MiniHorzScrollThumbNormal'] )
cellmap_MiniHorzScrollThumbNormalExt = (3,1, '',
['MiniHorzScrollThumbLeftNormal', 'MiniHorzScrollThumbMiddleNormal', 'MiniHorzScrollThumbRightNormal'] )
cellmap_MiniHorzScrollThumbHover = (1,1, '',
['MiniHorzScrollThumbHover'] )
cellmap_MiniHorzScrollThumbHoverExt = (3,1, '',
['MiniHorzScrollThumbLeftHover', 'MiniHorzScrollThumbMiddleHover', 'MiniHorzScrollThumbRightHover'] )
cellmap_MiniHorzScrollLeftNormal = (1,1, '',
['MiniHorzScrollLeftNormal'] )
cellmap_MiniHorzScrollRightNormal = (1,1, '',
['MiniHorzScrollRightNormal'] )
cellmap_MiniHorzScrollLeftHover = (1,1, '',
['MiniHorzScrollLeftHover'] )
cellmap_MiniHorzScrollRightHover = (1,1, '',
['MiniHorzScrollRightHover'] )
cellmap_Listbox = (3,3, '',
['ListboxTopLeft', 'ListboxTop', 'ListboxTopRight',
'ListboxLeft', 'ListboxBackdrop', 'ListboxRight',
'ListboxBottomLeft', 'ListboxBottom', 'ListboxBottomRight'] )
cellmap_ListboxSelectionBrush = (1,1, '',
['ListboxSelectionBrush'] )
cellmap_ComboboxEdit = (2,1, '',
['ComboboxEditLeft', 'ComboboxEditMiddle'] )
cellmap_ComboboxListButtonNormal = (1,1, '',
['ComboboxListButtonNormal'] )
cellmap_ComboboxListButtonHover = (1,1, '',
['ComboboxListButtonHover'] )
cellmap_ComboboxList = (3,3, '',
['ComboboxListTopLeft', 'ComboboxListTop', 'ComboboxListTopRight',
'ComboboxListLeft', 'ComboboxListBackdrop', 'ComboboxListRight',
'ComboboxListBottomLeft', 'ComboboxListBottom', 'ComboboxListBottomRight'] )
cellmap_ComboboxSelectionBrush = (1,1, '',
['ComboboxSelectionBrush'] )
cellmap_ComboboxDivider = (3,1, '',
['ComboboxDividerLeft', 'ComboboxDividerMiddle', 'ComboboxDividerRight'] )
cellmap_HeaderBarBackdropNormal = (1,1, '',
['HeaderBarBackdropNormal'] )
cellmap_HeaderBarBackdropHover = (1,1, '',
['HeaderBarBackdropHover'] )
cellmap_HeaderBarSplitterNormal = (1,1, '',
['HeaderBarSplitterNormal'] )
cellmap_HeaderBarSplitterHover = (1,1, '',
['HeaderBarSplitterHover'] )
cellmap_HeaderBarSortUp = (1,1, '',
['HeaderBarSortUp'] )
cellmap_HeaderBarSortDown = (1,1, '',
['HeaderBarSortDown'] )
cellmap_MultiList = (3,3, '',
['MultiListTopLeft', 'MultiListTop', 'MultiListTopRight',
'MultiListLeft', 'MultiListBackdrop', 'MultiListRight',
'MultiListBottomLeft', 'MultiListBottom', 'MultiListBottomRight'] )
cellmap_MultiListSelectionBrush = (1,1, '',
['MultiListSelectionBrush'] )
cellmap_AltProgress = (3,1, '',
['AltProgressLeft', 'AltProgressMiddle', 'AltProgressRight'] )
cellmap_AltProgressQuarter = (1,1, '',
['AltProgressQuarter'] )
cellmap_AltProgressHalf = (1,1, '',
['AltProgressHalf'] )
cellmap_AltProgressLight1 = (1,1, '',
['AltProgressLight1'] )
cellmap_AltProgressLight2 = (1,1, '',
['AltProgressLight2'] )
cellmap_AltProgressLight3 = (1,1, '',
['AltProgressLight3'] )
cellmap_AltProgressLight4 = (1,1, '',
['AltProgressLight4'] )
cellmap_AltProgressLight5 = (1,1, '',
['AltProgressLight5'] )
cellmap_AltProgressLight6 = (1,1, '',
['AltProgressLight6'] )
cellmap_AltProgressLight7 = (1,1, '',
['AltProgressLight7'] )
cellmap_AltProgressLight8 = (1,1, '',
['AltProgressLight8'] )
cellmap_AltProgressLight9 = (1,1, '',
['AltProgressLight9'] )
cellmap_AltProgressLight10 = (1,1, '',
['AltProgressLight10'] )
cellmap_CloseButtonNormal = (1,1, '',
['CloseButtonNormal'] )
cellmap_CloseButtonHover = (1,1, '',
['CloseButtonHover'] )
cellmap_CloseButtonPressed = (1,1, '',
['CloseButtonPressed'] )
cellmap_NewCloseButtonNormal = (1,1, '',
['NewCloseButtonNormal'] )
cellmap_NewCloseButtonHover = (1,1, '',
['NewCloseButtonHover'] )
cellmap_NewCloseButtonPressed = (1,1, '',
['NewCloseButtonPressed'] )
cellmap_MultiLineEditbox = (3,3, '',
['MultiLineEditboxTopLeft', 'MultiLineEditboxTop', 'MultiLineEditboxTopRight',
'MultiLineEditboxLeft', 'MultiLineEditboxBackdrop', 'MultiLineEditboxRight',
'MultiLineEditboxBottomLeft', 'MultiLineEditboxBottom', 'MultiLineEditboxBottomRight'] )
cellmap_MultiLineEditboxSelectionBrush = (1,1, '',
['MultiLineEditboxSelectionBrush'] )
cellmap_MouseTarget = (1,1, '',
['MouseTarget'] )
cellmap_MouseArrow = (1,1, '',
['MouseArrow'] )
cellmap_MouseMoveCursor = (1,1, '',
['MouseMoveCursor'] )
cellmap_MouseNoSoCursor = (1,1, '',
['MouseNoSoCursor'] )
cellmap_MouseEsWeCursor = (1,1, '',
['MouseEsWeCursor'] )
cellmap_MouseNeSwCursor = (1,1, '',
['MouseNeSwCursor'] )
cellmap_MouseNwSeCursor = (1,1, '',
['MouseNwSeCursor'] )
cellmap_MouseTextBar = (1,1, '',
['MouseTextBar'] )
cellmap_TabControlButtonPaneFiller = (1,1, '',
['TabControlButtonPaneFiller'] )
cellmap_NewCloseButtonHover = (1,1, '',
['NewCloseButtonHover'] )
cellmap_TabPane = (3,2, '',
['TabPaneLeft', 'TabPaneMiddle', 'TabPaneRight',
'TabPaneLowerLeft', 'TabPaneLower', 'TabPaneLowerRight'] )
cellmap_TabButtonNormal = (3,3, '',
['TabButtonUpperLeftNormal', 'TabButtonUpperNormal', 'TabButtonUpperRightNormal',
'TabButtonLeftNormal', 'TabButtonMiddleNormal', 'TabButtonRightNormal',
'TabButtonLowerLeftNormal', 'TabButtonLowerNormal', 'TabButtonLowerRightNormal'] )
cellmap_TabButtonSelected = (3,3, '',
['TabButtonUpperLeftSelected', 'TabButtonUpperSelected', 'TabButtonUpperRightSelected',
'TabButtonLeftSelected', 'TabButtonMiddleSelected', 'TabButtonRightSelected',
'TabButtonLowerLeftSelected', 'TabButtonLowerSelected', 'TabButtonLowerRightSelected'] )
FROM = 1
TO = 2
LIMIT_DIST = 1000000 # Initializing value for finding the closest gridline
LIMIT_SNAP = 5 # Closeness in pixels in the x/y direction for selecting a grid-point
LIMIT_CORNER = 2 # Closeness in pixels in the x/y direction for selecting a corner-point
SEL_POINT = 1
SEL_EDGE = 2
SEL_RECT = 3
class GridEditor:
def __init__(self, cellmap):
self.xcells = cellmap[0]
self.ycells = cellmap[1]
self.info = cellmap[2]
self.cellmap = cellmap[3]
self.rects = [[] for i in range(self.xcells)]
for i in range(self.xcells):
self.rects[i] = [(i*10+10,j*10+10,i*10+19,j*10+19) for j in range(self.ycells)]
self.mode = 'hover'
self.prox = None # ..or (gridline, FROM | TO)
self.dist = LIMIT_DIST # I doubt a skin-map will ever have this
self.lastPixelX = 0
self.lastPixelY = 0
self.clickPixelX = 0
self.clickPixelY = 0
self.magnify = 1
def use_magnification(self, magnify_times):
self.magnify = magnify_times
def use_objects(self, console, dataview):
self.console = console
if dataview != None:
self.dataview = dataview
self.update_dataview()
def print_datablock(self):
s = ''
for y in range(self.ycells):
for x in range(self.xcells):
s += ('%s: x,y=(%d, %d) size=(%d, %d)' %
(self.cellmap[y*self.xcells + x],
self.rects[x][y][0],
self.rects[x][y][1],
self.rects[x][y][2]-self.rects[x][y][0]+1,
self.rects[x][y][3]-self.rects[x][y][1]+1))
s += '\n'
s += ''
return s
def update_dataview(self):
if self.dataview == None: return
model = self.dataview.get_model()
model.clear()
sel_iter = None
for y in range(self.ycells):
for x in range(self.xcells):
iter = model.insert_before(None, None)
name = self.cellmap[y*self.xcells + x]
if self.prox!=None and (x,y) == self.prox[0]:
sel_iter = iter
model.set_value(iter, 0, name)
model.set_value(iter, 1, self.rects[x][y][0])
model.set_value(iter, 2, self.rects[x][y][1])
model.set_value(iter, 3, self.rects[x][y][2]-self.rects[x][y][0]+1)
model.set_value(iter, 4, self.rects[x][y][3]-self.rects[x][y][1]+1)
if sel_iter != None:
sel = self.dataview.get_selection()
sel.select_iter(sel_iter)
self.dataview.columns_autosize()
def from_xml(self, dom_images):
def findImage(dom_images, name):
for image in dom_images:
elemnm = elemnm = image.getAttribute('Name')
if elemnm == name:
return image
return None
# For each Cell Name, find a matching node and get the coords from that
for y in range(self.ycells):
for x in range(self.xcells):
cellnm = self.cellmap[y*self.xcells + x]
image = findImage(dom_images, cellnm)
if image != None:
(xp,yp) = (int(image.getAttribute('XPos')),int(image.getAttribute('YPos')))
(w,h) = (int(image.getAttribute('Width')),int(image.getAttribute('Height')))
self.rects[x][y] = (xp, yp, xp+w-1, yp+h-1)
else:
print "Couldn't find element for: " + cellnm + ". Using default coordinates"
def to_xml(self):
s = ''
for y in range(self.ycells):
for x in range(self.xcells):
s += ('\n' %
(self.cellmap[y*self.xcells + x],
self.rects[x][y][0],
self.rects[x][y][1],
self.rects[x][y][2]-self.rects[x][y][0]+1,
self.rects[x][y][3]-self.rects[x][y][1]+1))
print s
return s
def on_con_button_press(self, event):
self.lastPixelX = event.x/self.magnify
self.lastPixelY = event.y/self.magnify
self.clickPixelX = event.x/self.magnify
self.clickPixelY = event.y/self.magnify
if self.prox != None:
self.mode = 'drag'
else:
self.mode = 'hover'
def on_con_button_release(self, event):
self.mode = 'hover'
def on_con_motion_notify(self, event):
pixelx = event.x/self.magnify
pixely = event.y/self.magnify
if self.mode == 'hover':
def ptDist(x,y):
return math.sqrt( (pixelx-x)*(pixelx-x)+(pixely-y)*(pixely-y) )
def edgeDistVert(x1,x2,y):
if pixelx>=x1 and pixelx<=x2:
return abs(pixely-y)
else:
return LIMIT_DIST
def edgeDistHorz(x,y1,y2):
if pixely>=y1 and pixely<=y2:
return abs(pixelx-x)
else:
return LIMIT_DIST
def insideRect(r):
return pixelx>r[0] and pixelxr[1] and pixely LIMIT_CORNER:
for i in range(self.xcells):
for j in range(self.ycells):
r = self.rects[i][j]
dist = edgeDistVert( r[0], r[2], r[1] )
updateMin( dist, ((i,j), [(0,1),(2,1)], SEL_EDGE ) )
dist = edgeDistVert( r[0], r[2], r[3] )
updateMin( dist, ((i,j), [(0,3),(2,3)], SEL_EDGE ) )
dist = edgeDistHorz( r[0], r[1], r[3] )
updateMin( dist, ((i,j), [(0,1),(0,3)], SEL_EDGE ) )
dist = edgeDistHorz( r[2], r[1], r[3] )
updateMin( dist, ((i,j), [(2,1),(2,3)], SEL_EDGE) )
# Finally, if we're still not close but we're inside a rect use SEL_RECT mode
if self.dist > LIMIT_CORNER:
for i in range(self.xcells):
for j in range(self.ycells):
r = self.rects[i][j]
if insideRect( r ):
updateMin( 0, ((i,j), [(0,1),(0,3),(2,1),(2,3)], SEL_RECT ) )
endij=(-1,-1)
if self.prox != None:
endij = self.prox[0]
if startij != endij:
self.update_dataview()
self.console.queue_draw()
elif self.mode == 'drag':
# Moving a grid point is a bit tricky. For now we just make the grid go bananas.
# Later on we should take care to push gridpoints to the right and below so that
# no grid cell is smaller than NxN pixels
# Also it would be nice to allow selection of an entire row insted of just
# one grid square.
(i,j)=self.prox[0]
pts = self.prox[1]
rectl = list(self.rects[i][j])
if self.prox[2] == SEL_POINT:
(ii,jj) = pts[0]
rectl[ii] = int(pixelx)
rectl[jj] = int(pixely)
elif self.prox[2] == SEL_EDGE:
(ii,jj) = pts[0]
(ii1,jj1) = pts[1]
if ii==ii1:
rectl[ii] = int(pixelx)
rectl[ii1] = int(pixelx)
elif jj==jj1:
rectl[jj] = int(pixely)
rectl[jj1] = int(pixely)
elif self.prox[2] == SEL_RECT:
odeltax = self.lastPixelX - self.clickPixelX
odeltay = self.lastPixelY - self.clickPixelY
deltax = pixelx - self.clickPixelX
deltay = pixely - self.clickPixelY
rectl[0] += int(deltax)-int(odeltax)
rectl[1] += int(deltay)-int(odeltay)
rectl[2] += int(deltax)-int(odeltax)
rectl[3] += int(deltay)-int(odeltay)
self.rects[i][j] = tuple(rectl)
self.update_dataview()
self.console.queue_draw()
self.lastPixelX = pixelx;
self.lastPixelY = pixely;
def on_con_hover_hilite(self, event, gc):
gc.set_rgb_fg_color( gtk.gdk.Color(40000,40000,65535) )
gc.line_style = gtk.gdk.LINE_ON_OFF_DASH
minx = min( [ x[0] for x in reduce(lambda x,y: x+y, self.rects) ] )
miny = min( [ x[1] for x in reduce(lambda x,y: x+y, self.rects) ] )
maxx = max( [ x[2] for x in reduce(lambda x,y: x+y, self.rects) ] )
maxy = max( [ x[3] for x in reduce(lambda x,y: x+y, self.rects) ] )
minx = minx * self.magnify;
miny = miny * self.magnify;
maxx = (maxx+1) * self.magnify - 1;
maxy = (maxy+1) * self.magnify - 1;
self.console.window.draw_rectangle (gc, False, minx,miny, maxx-minx+1, maxy-miny+1)
gc.line_style = gtk.gdk.LINE_SOLID
for i in range(self.xcells):
for j in range(self.ycells):
(xbegin,ybegin,xend,yend) = (self.rects[i][j][0] * self.magnify,
self.rects[i][j][1] * self.magnify,
self.rects[i][j][2] * self.magnify + self.magnify - 1,
self.rects[i][j][3] * self.magnify + self.magnify - 1)
self.console.window.draw_rectangle (gc, False, xbegin,ybegin, xend-xbegin+1, yend-ybegin+1)
gc.line_style = gtk.gdk.LINE_SOLID
gc.set_rgb_fg_color (gtk.gdk.Color(0,0,0))
def on_con_expose(self, event, gc):
Cnorm = gtk.gdk.Color(65535,40000,40000)
Cprox = gtk.gdk.Color(65535, 0, 0)
def setColor(cell,side1,side2,prox,gc):
C = Cnorm
if prox!=None and cell==prox[0]:
pts = prox[1]
if prox[2]==SEL_POINT and (side1==pts[0] or side2==pts[0]):
C = Cprox
elif prox[2]==SEL_EDGE and (side1==pts[0] and side2==pts[1]):
C = Cprox
elif prox[2]==SEL_RECT:
C = Cprox
gc.set_rgb_fg_color (C)
gc.line_style = gtk.gdk.LINE_ON_OFF_DASH
minx = min( [ x[0] for x in reduce(lambda x,y: x+y, self.rects) ] )
miny = min( [ x[1] for x in reduce(lambda x,y: x+y, self.rects) ] )
maxx = max( [ x[2] for x in reduce(lambda x,y: x+y, self.rects) ] )
maxy = max( [ x[3] for x in reduce(lambda x,y: x+y, self.rects) ] )
minx = minx * self.magnify;
miny = miny * self.magnify;
maxx = (maxx+1) * self.magnify - 1;
maxy = (maxy+1) * self.magnify - 1;
gc.set_rgb_fg_color(Cnorm)
self.console.window.draw_rectangle (gc, False, minx,miny, maxx-minx+1, maxy-miny+1)
gc.line_style = gtk.gdk.LINE_SOLID
for i in range(self.xcells):
for j in range(self.ycells):
rr = self.rects[i][j]
wr = (rr[0] * self.magnify,
rr[1] * self.magnify,
rr[2] * self.magnify + self.magnify - 1,
rr[3] * self.magnify + self.magnify - 1)
gc.line_style = gtk.gdk.LINE_SOLID
setColor((i,j),(0,1),(0,3),self.prox,gc)
self.console.window.draw_line (gc, wr[0],wr[1], wr[0],wr[3])
setColor((i,j),(2,1),(2,3),self.prox,gc)
self.console.window.draw_line (gc, wr[2],wr[1], wr[2],wr[3])
setColor((i,j),(0,1),(2,1),self.prox,gc)
self.console.window.draw_line (gc, wr[0],wr[1], wr[2],wr[1])
setColor((i,j),(0,3),(2,3),self.prox,gc)
self.console.window.draw_line (gc, wr[0],wr[3], wr[2],wr[3])
gc.line_style = gtk.gdk.LINE_SOLID
gc.set_rgb_fg_color (gtk.gdk.Color(0,0,0))
class TaharezSkin:
class ClientBrush( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ClientBrush)
class Window( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_Window)
class CheckboxNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_CheckboxNormal)
class CheckboxHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_CheckboxHover)
class CheckboxMark( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_CheckboxMark)
class RadioButtonNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_RadioButtonNormal)
class RadioButtonHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_RadioButtonHover)
class RadioButtonMark( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_RadioButtonMark)
class Titlebar( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_Titlebar)
class NewTitlebar( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_NewTitlebar)
class ButtonNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ButtonNormal)
class ButtonPushed( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ButtonPushed)
class ButtonHighlight( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ButtonHighlight)
class Static( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_Static)
class ProgressBar( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ProgressBar)
class ProgressBarDimSeg( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ProgressBarDimSeg)
class ProgressBarLitSeg( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ProgressBarLitSeg)
class EditBox( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_EditBox)
class EditBoxCarat( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_EditBoxCarat)
class TextSelectionBrush( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_TextSelectionBrush)
class VertScroll( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScroll)
class VertScrollBarSegment( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollBarSegment)
class VertScrollThumbNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollThumbNormal)
class VertScrollThumbHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollThumbHover)
class VertScrollUpNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollUpNormal)
class VertScrollDownNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollDownNormal)
class VertScrollUpHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollUpHover)
class VertScrollDownHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertScrollDownHover)
class MiniVertScrollBarSegment( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollBarSegment)
class MiniVertScrollThumbNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollThumbNormal)
class MiniVertScrollThumbNormalExt( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollThumbNormalExt)
class MiniVertScrollThumbHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollThumbHover)
class MiniVertScrollThumbHoverExt( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollThumbHoverExt)
class MiniVertScrollUpNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollUpNormal)
class MiniVertScrollDownNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollDownNormal)
class MiniVertScrollUpHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollUpHover)
class MiniVertScrollDownHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniVertScrollDownHover)
class VertSliderBody( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertSliderBody)
class VertSliderThumbNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertSliderThumbNormal)
class VertSliderThumbHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_VertSliderThumbHover)
class MiniHorzScrollBarSegment( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollBarSegment)
class MiniHorzScrollThumbNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollThumbNormal)
class MiniHorzScrollThumbNormalExt( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollThumbNormalExt)
class MiniHorzScrollThumbHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollThumbHover)
class MiniHorzScrollThumbHoverExt( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollThumbHoverExt)
class MiniHorzScrollLeftNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollLeftNormal)
class MiniHorzScrollRightNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollRightNormal)
class MiniHorzScrollLeftHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollLeftHover)
class MiniHorzScrollRightHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MiniHorzScrollRightHover)
class Listbox( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_Listbox)
class ListboxSelectionBrush( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ListboxSelectionBrush)
class ComboboxEdit( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ComboboxEdit)
class ComboboxListButtonNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ComboboxListButtonNormal)
class ComboboxListButtonHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ComboboxListButtonHover)
class ComboboxList( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ComboboxList)
class ComboboxSelectionBrush( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ComboboxSelectionBrush)
class ComboboxDivider( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_ComboboxDivider)
class HeaderBarBackdropNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_HeaderBarBackdropNormal)
class HeaderBarBackdropHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_HeaderBarBackdropHover)
class HeaderBarSplitterNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_HeaderBarSplitterNormal)
class HeaderBarSplitterHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_HeaderBarSplitterHover)
class HeaderBarSortUp( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_HeaderBarSortUp)
class HeaderBarSortDown( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_HeaderBarSortDown)
class MultiList( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MultiList)
class MultiListSelectionBrush( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MultiListSelectionBrush)
class AltProgress( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgress)
class AltProgressQuarter( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressQuarter)
class AltProgressHalf( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressHalf)
class AltProgressLight1( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight1)
class AltProgressLight2( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight2)
class AltProgressLight3( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight3)
class AltProgressLight4( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight4)
class AltProgressLight5( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight5)
class AltProgressLight6( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight6)
class AltProgressLight7( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight7)
class AltProgressLight8( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight8)
class AltProgressLight9( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight9)
class AltProgressLight10( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_AltProgressLight10)
class CloseButtonNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_CloseButtonNormal)
class CloseButtonHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_CloseButtonHover)
class CloseButtonPressed( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_CloseButtonPressed)
class NewCloseButtonNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_NewCloseButtonNormal)
class NewCloseButtonHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_NewCloseButtonHover)
class NewCloseButtonPressed( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_NewCloseButtonPressed)
class MultiLineEditbox( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MultiLineEditbox)
class MultiLineEditboxSelectionBrush( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MultiLineEditboxSelectionBrush)
class MouseTarget( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseTarget)
class MouseArrow( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseArrow)
class MouseMoveCursor( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseMoveCursor)
class MouseNoSoCursor( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseNoSoCursor)
class MouseEsWeCursor( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseEsWeCursor)
class MouseNeSwCursor( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseNeSwCursor)
class MouseNwSeCursor( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseNwSeCursor)
class MouseTextBar( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_MouseTextBar)
class TabControlButtonPaneFiller( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_TabControlButtonPaneFiller)
class NewCloseButtonHover( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_NewCloseButtonHover)
class TabPane( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_TabPane)
class TabButtonNormal( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_TabButtonNormal)
class TabButtonSelected( GridEditor ):
def __init__(self): GridEditor.__init__(self, cellmap_TabButtonSelected)
def __init__(self):
self.elements = {}
self.elements['ClientBrush' ] = self.ClientBrush()
self.elements['Window' ] = self.Window()
self.elements['CheckboxNormal' ] = self.CheckboxNormal()
self.elements['CheckboxHover' ] = self.CheckboxHover()
self.elements['CheckboxMark' ] = self.CheckboxMark()
self.elements['RadioButtonNormal' ] = self.RadioButtonNormal()
self.elements['RadioButtonHover' ] = self.RadioButtonHover()
self.elements['RadioButtonMark' ] = self.RadioButtonMark()
self.elements['Titlebar' ] = self.Titlebar()
self.elements['NewTitlebar' ] = self.NewTitlebar()
self.elements['ButtonNormal' ] = self.ButtonNormal()
self.elements['ButtonPushed' ] = self.ButtonPushed()
self.elements['ButtonHighlight' ] = self.ButtonHighlight()
self.elements['Static' ] = self.Static()
self.elements['ProgressBar' ] = self.ProgressBar()
self.elements['ProgressBarDimSeg' ] = self.ProgressBarDimSeg()
self.elements['ProgressBarLitSeg' ] = self.ProgressBarLitSeg()
self.elements['EditBox' ] = self.EditBox()
self.elements['EditBoxCarat' ] = self.EditBoxCarat()
self.elements['TextSelectionBrush' ] = self.TextSelectionBrush()
self.elements['VertScroll' ] = self.VertScroll()
self.elements['VertScrollBarSegment' ] = self.VertScrollBarSegment()
self.elements['VertScrollThumbNormal' ] = self.VertScrollThumbNormal()
self.elements['VertScrollThumbHover' ] = self.VertScrollThumbHover()
self.elements['VertScrollUpNormal' ] = self.VertScrollUpNormal()
self.elements['VertScrollDownNormal' ] = self.VertScrollDownNormal()
self.elements['VertScrollUpHover' ] = self.VertScrollUpHover()
self.elements['VertScrollDownHover' ] = self.VertScrollDownHover()
self.elements['MiniVertScrollBarSegment' ] = self.MiniVertScrollBarSegment()
self.elements['MiniVertScrollThumbNormal' ] = self.MiniVertScrollThumbNormal()
self.elements['MiniVertScrollThumbNormalExt' ] = self.MiniVertScrollThumbNormalExt()
self.elements['MiniVertScrollThumbHover' ] = self.MiniVertScrollThumbHover()
self.elements['MiniVertScrollThumbHoverExt' ] = self.MiniVertScrollThumbHoverExt()
self.elements['MiniVertScrollUpNormal' ] = self.MiniVertScrollUpNormal()
self.elements['MiniVertScrollDownNormal' ] = self.MiniVertScrollDownNormal()
self.elements['MiniVertScrollUpHover' ] = self.MiniVertScrollUpHover()
self.elements['MiniVertScrollDownHover' ] = self.MiniVertScrollDownHover()
self.elements['VertSliderBody' ] = self.VertSliderBody()
self.elements['VertSliderThumbNormal' ] = self.VertSliderThumbNormal()
self.elements['VertSliderThumbHover' ] = self.VertSliderThumbHover()
self.elements['MiniHorzScrollBarSegment' ] = self.MiniHorzScrollBarSegment()
self.elements['MiniHorzScrollThumbNormal' ] = self.MiniHorzScrollThumbNormal()
self.elements['MiniHorzScrollThumbNormalExt' ] = self.MiniHorzScrollThumbNormalExt()
self.elements['MiniHorzScrollThumbHover' ] = self.MiniHorzScrollThumbHover()
self.elements['MiniHorzScrollThumbHoverExt' ] = self.MiniHorzScrollThumbHoverExt()
self.elements['MiniHorzScrollLeftNormal' ] = self.MiniHorzScrollLeftNormal()
self.elements['MiniHorzScrollRightNormal' ] = self.MiniHorzScrollRightNormal()
self.elements['MiniHorzScrollLeftHover' ] = self.MiniHorzScrollLeftHover()
self.elements['MiniHorzScrollRightHover' ] = self.MiniHorzScrollRightHover()
self.elements['Listbox' ] = self.Listbox()
self.elements['ListboxSelectionBrush' ] = self.ListboxSelectionBrush()
self.elements['ComboboxEdit' ] = self.ComboboxEdit()
self.elements['ComboboxListButtonNormal' ] = self.ComboboxListButtonNormal()
self.elements['ComboboxListButtonHover' ] = self.ComboboxListButtonHover()
self.elements['ComboboxList' ] = self.ComboboxList()
self.elements['ComboboxSelectionBrush' ] = self.ComboboxSelectionBrush()
self.elements['ComboboxDivider' ] = self.ComboboxDivider()
self.elements['HeaderBarBackdropNormal' ] = self.HeaderBarBackdropNormal()
self.elements['HeaderBarBackdropHover' ] = self.HeaderBarBackdropHover()
self.elements['HeaderBarSplitterNormal' ] = self.HeaderBarSplitterNormal()
self.elements['HeaderBarSplitterHover' ] = self.HeaderBarSplitterHover()
self.elements['HeaderBarSortUp' ] = self.HeaderBarSortUp()
self.elements['HeaderBarSortDown' ] = self.HeaderBarSortDown()
self.elements['MultiList' ] = self.MultiList()
self.elements['MultiListSelectionBrush' ] = self.MultiListSelectionBrush()
self.elements['AltProgress' ] = self.AltProgress()
self.elements['AltProgressQuarter' ] = self.AltProgressQuarter()
self.elements['AltProgressHalf' ] = self.AltProgressHalf()
self.elements['AltProgressLight1' ] = self.AltProgressLight1()
self.elements['AltProgressLight2' ] = self.AltProgressLight2()
self.elements['AltProgressLight3' ] = self.AltProgressLight3()
self.elements['AltProgressLight4' ] = self.AltProgressLight4()
self.elements['AltProgressLight5' ] = self.AltProgressLight5()
self.elements['AltProgressLight6' ] = self.AltProgressLight6()
self.elements['AltProgressLight7' ] = self.AltProgressLight7()
self.elements['AltProgressLight8' ] = self.AltProgressLight8()
self.elements['AltProgressLight9' ] = self.AltProgressLight9()
self.elements['AltProgressLight10' ] = self.AltProgressLight10()
self.elements['CloseButtonNormal' ] = self.CloseButtonNormal()
self.elements['CloseButtonHover' ] = self.CloseButtonHover()
self.elements['CloseButtonPressed' ] = self.CloseButtonPressed()
self.elements['NewCloseButtonNormal' ] = self.NewCloseButtonNormal()
self.elements['NewCloseButtonHover' ] = self.NewCloseButtonHover()
self.elements['NewCloseButtonPressed' ] = self.NewCloseButtonPressed()
self.elements['MultiLineEditbox' ] = self.MultiLineEditbox()
self.elements['MultiLineEditboxSelectionBrush' ] = self.MultiLineEditboxSelectionBrush()
self.elements['MouseTarget' ] = self.MouseTarget()
self.elements['MouseArrow' ] = self.MouseArrow()
self.elements['MouseMoveCursor' ] = self.MouseMoveCursor()
self.elements['MouseNoSoCursor' ] = self.MouseNoSoCursor()
self.elements['MouseEsWeCursor' ] = self.MouseEsWeCursor()
self.elements['MouseNeSwCursor' ] = self.MouseNeSwCursor()
self.elements['MouseNwSeCursor' ] = self.MouseNwSeCursor()
self.elements['MouseTextBar' ] = self.MouseTextBar()
self.elements['TabControlButtonPaneFiller' ] = self.TabControlButtonPaneFiller()
self.elements['NewCloseButtonHover' ] = self.NewCloseButtonHover()
self.elements['TabPane' ] = self.TabPane()
self.elements['TabButtonNormal' ] = self.TabButtonNormal()
self.elements['TabButtonSelected' ] = self.TabButtonSelected()
def __getitem__(self,key):
return self.elements[key]
def get_element_names(self):
return self.elements.keys()
def use_magnification(self,level):
self.magnify = level
for element in self.elements.values():
element.use_magnification(level)
def read_xml(self, doc):
dom = xml.dom.minidom.parseString(doc)
imageset = dom.firstChild
images = imageset.getElementsByTagName ('Image')
self.imagefile = imageset.getAttribute ('Imagefile')
for element in self.elements.values():
element.from_xml (images)
def write_xml(self):
Es = self.elements.keys()
Es.sort()
doc = ''
doc += '' % os.path.basename(self.imagefile)
for E in Es:
doc += self.elements[E].to_xml()
doc += ''
return doc
# A cheap hack that would fit the TaharezLook skin
#
class CrazySkinEddietor:
def __init__(self):
self.skin = TaharezSkin()
self.skinimage = None
self.skinimagemagnify = None
self.magnify = 1
self.current_element = None
self.hover_element = None
self.con = gtk.DrawingArea()
self.con.set_events ( gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.KEY_PRESS_MASK)
self.con.connect ('expose-event', self.on_con_expose)
self.con.connect ('button_press_event' , self.on_con_button_press)
self.con.connect ('button_release_event' , self.on_con_button_release)
self.con.connect ('motion_notify_event' , self.on_con_motion_notify)
self.con.set_size_request (10,10)
self.conview = gtk.ScrolledWindow()
self.conview.add_with_viewport (self.con)
self.conview.set_size_request(400,400)
self.conhadj = self.conview.get_hadjustment()
self.convadj = self.conview.get_vadjustment()
self.conhruler = gtk.HRuler()
self.convruler = gtk.VRuler()
self.conhruler.set_range (0,10,0,10)
self.convruler.set_range (0,10,0,10)
self.con.connect_object ('motion_notify_event', lambda r,e: r.emit('motion_notify_event',e), self.conhruler)
self.con.connect_object ('motion_notify_event', lambda r,e: r.emit('motion_notify_event',e), self.convruler)
self.conhadj.connect ('value-changed', self.on_conruler_value_changed, self.conhruler, True)
self.convadj.connect ('value-changed', self.on_conruler_value_changed, self.convruler, False)
self.conview.connect ('size-allocate', self.on_conview_size_allocate)
self.contable = gtk.Table(2,2)
self.contable.attach (self.conhruler, 1,2, 0,1, yoptions=0)
self.contable.attach (self.convruler, 0,1, 1,2, xoptions=0)
self.contable.attach (self.conview , 1,2, 1,2)
self.elementcombo = gtk.combo_box_new_text()
self.elementcombo.connect('changed', self.on_elementcombo_change)
names = self.skin.get_element_names()
names.sort()
for n in names: self.elementcombo.append_text(n)
self.elementdesc = gtk.Label('Description of the GUI element:')
self.elementdesc.set_line_wrap (True)
#----------------------------
self.elpropmodel = gtk.TreeStore(gobject.TYPE_STRING,gobject.TYPE_INT,gobject.TYPE_INT,gobject.TYPE_INT,gobject.TYPE_INT)
# Create the main list view.
self.elpropview = gtk.TreeView(self.elpropmodel)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn("Element", renderer, text=0)
self.elpropview.append_column(column)
column = gtk.TreeViewColumn("x", renderer, text=1)
self.elpropview.append_column(column)
column = gtk.TreeViewColumn("y", renderer, text=2)
self.elpropview.append_column(column)
column = gtk.TreeViewColumn("w", renderer, text=3)
self.elpropview.append_column(column)
column = gtk.TreeViewColumn("h", renderer, text=4)
self.elpropview.append_column(column)
# Create scrollbars around the view.
propviewscroll = gtk.ScrolledWindow()
propviewscroll.add(self.elpropview)
#----------------------------
adj = gtk.Adjustment(self.magnify,1,9,1,1,1)
self.magnifyscale = gtk.HScale( adj )
self.magnifyscale.set_digits(0)
adj.connect('value-changed', self.on_magnifyscale_change)
self.skinfileentry = gtk.Entry()
self.skinfileentry.set_text('myskin.imageset')
self.skinimagefileentry = gtk.Entry()
self.browsefilebutton = gtk.Button('...')
self.browsefilebutton.connect('clicked', self.on_browsefilebutton_clicked)
self.skinimagefileentry.connect('activate', self.on_skinimagefileentry_activate)
self.readbutton = gtk.Button('Read from file')
self.readbutton.connect ('clicked', self.on_readbutton_clicked)
self.writebutton = gtk.Button('Write to file')
self.writebutton.connect ('clicked', self.on_writebutton_clicked)
self.box1 = gtk.VBox()
self.box1.pack_start (self.elementcombo, False, False)
self.box1h = gtk.HBox()
self.box1h.pack_start (self.skinfileentry, True, True)
self.box1h.pack_end (self.browsefilebutton, False, False)
self.box1.pack_start (self.box1h, False, False)
self.box1.pack_start (self.skinimagefileentry, False, False)
self.box1.pack_start (self.readbutton, False, False)
self.box1.pack_start (self.writebutton, False, False)
self.box1.pack_start (self.magnifyscale, False, False)
self.box1.pack_start (self.elementdesc, False, False)
self.box1.pack_start (propviewscroll, True, True)
self.box0 = gtk.HPaned()
self.box0.pack1 (self.contable, True, True)
self.box0.pack2 (self.box1, True, True)
self.window = gtk.Window (gtk.WINDOW_TOPLEVEL)
self.window.set_title('Crazy Skin Eddietor v0.1')
self.window.connect ('destroy', lambda w: gtk.main_quit())
self.window.connect('key_press_event', self.on_con_key_press )
self.window.add (self.box0)
self.window.show_all()
def prepare_skin(self):
self.skinimage = gtk.gdk.pixbuf_new_from_file (self.skin.imagefile)
self.skinimagemagnify = self.skinimage.scale_simple(
self.skinimage.get_width() * self.magnify,
self.skinimage.get_height()* self.magnify,
gtk.gdk.INTERP_NEAREST)
self.current_element = None
self.hover_element = None
self.con.set_size_request (self.skinimagemagnify.get_width(), self.skinimagemagnify.get_height())
def on_skinimagefileentry_activate(self,object):
self.skin.imagefile = self.skinimagefileentry.get_text()
self.prepare_skin()
self.con.queue_draw()
def on_browsefilebutton_clicked(self,object):
dialog = gtk.FileChooserDialog('Choose imageset file...',
buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
filter1 = gtk.FileFilter()
filter1.set_name('CEGUI imageset files (*.imageset)')
filter1.add_pattern('*.imageset')
dialog.add_filter(filter1)
filter2 = gtk.FileFilter()
filter2.set_name('All files (*.*)')
filter2.add_pattern('*.*')
dialog.add_filter(filter2)
dialog.set_modal(True)
if dialog.run()==gtk.RESPONSE_ACCEPT:
fname = dialog.get_filename()
self.skinfileentry.set_text(fname)
self.on_readbutton_clicked(dialog)
dialog.destroy();
def on_readbutton_clicked(self,object):
infile = file(self.skinfileentry.get_text(), 'r')
try:
doc = infile.read()
except IOError:
print 'No such file: ' + self.skinfileentry.get_text()
infile.close()
return
infile.close()
self.skin.read_xml(doc)
dir = os.path.dirname(self.skinfileentry.get_text()) + os.path.sep
self.skinimagefileentry.set_text(self.skin.imagefile)
self.skin.imagefile = dir+self.skin.imagefile
self.prepare_skin()
self.con.queue_draw()
def on_writebutton_clicked(self,object):
doc = self.skin.write_xml()
outfile = file(self.skinfileentry.get_text(), 'w')
outfile.write(doc)
outfile.close
def on_elementcombo_change(self, object):
model = self.elementcombo.get_model()
active = self.elementcombo.get_active()
if active >= 0:
elementname = model[active][0]
self.current_element = self.skin[elementname]
self.elementdesc.set_text (self.skin[elementname].info)
self.current_element.use_objects (self.con, self.elpropview)
self.con.queue_draw()
def on_magnifyscale_change(self, object):
level = int(round( object.get_value() ))
if self.magnify == level:
return
self.magnify = level
if self.skinimage:
self.skinimagemagnify = self.skinimage.scale_simple(
self.skinimage.get_width() * self.magnify,
self.skinimage.get_height()* self.magnify,
gtk.gdk.INTERP_NEAREST)
self.con.set_size_request (self.skinimagemagnify.get_width(), self.skinimagemagnify.get_height())
self.skin.use_magnification(self.magnify)
self.con.queue_draw()
def on_conruler_value_changed(self, adj, ruler, horiz):
if horiz:
span = self.conview.get_allocation()[3]
else:
span = self.conview.get_allocation()[2]
l,u,p,m = ruler.get_range()
v = adj.value
ruler.set_range (v,v+span,p,m)
while gtk.events_pending():
gtk.main_iteration()
def on_conview_size_allocate(self, wid, allocation):
x,y,w,h = allocation
l,u,p,m = self.conhruler.get_range()
m = max(m,w)
self.conhruler.set_range(l,l+w,p,m)
l,u,p,m = self.convruler.get_range()
m = max(m,w)
self.convruler.set_range(l,l+h,p,m)
def on_con_key_press(self, area, event):
# TODO: add some accelerators
# Most wanted: Ctrl+-, Ctrl++ for zoom out / zoom in
# Ctrl+N, Ctrl+P to step through the items in the elementcombo
# Spacebar to toggle into 'pan' mode
print 'pressed key', event.keyval
print ' string', event.string
def on_con_button_press(self, area, event):
if event.type == gtk.gdk._2BUTTON_PRESS and self.hover_element!=self.current_element:
self.current_element = self.hover_element
if self.current_element:
self.current_element.use_objects(self.con, self.elpropview)
else:
self.elpropmodel.clear()
# TODO: update the self.elementcombo!
self.con.queue_draw()
if self.current_element != None:
self.current_element.on_con_button_press(event)
def on_con_button_release(self, area, event):
if self.current_element != None:
self.current_element.on_con_button_release(event)
def find_element_at_point(self, x, y):
pixelx = x/self.magnify
pixely = y/self.magnify
for (elname,el) in self.skin.elements.items():
for i in range(el.xcells):
for j in range(el.ycells):
(minx,miny,maxx,maxy) = el.rects[i][j]
#print ( '(%d,%d) in (%d, %d)(%d, %d)?' % (pixelx,pixely,minx,miny,maxx,maxy) )
if pixelx>=minx and pixelx<=maxx+1 and pixely>=miny and pixely<=maxy+1:
return el
return None
def on_con_motion_notify(self, area, event):
if self.current_element != None:
self.current_element.on_con_motion_notify(event)
hover = self.find_element_at_point(event.x,event.y)
if hover != None and hover != self.hover_element:
if self.current_element == None:
hover.use_objects (self.con, self.elpropview)
else:
hover.use_objects (self.con, None)
if hover != self.hover_element:
self.con.queue_draw()
self.hover_element = hover
def on_con_expose(self, area, event):
gc = self.con.get_style().fg_gc [gtk.STATE_NORMAL]
if self.skinimagemagnify:
self.con.window.draw_pixbuf (gc, self.skinimagemagnify, 0,0, 0,0)
if self.current_element != None:
self.current_element.on_con_expose(event,gc)
if self.hover_element != None and self.hover_element != self.current_element:
self.hover_element.on_con_hover_hilite(event,gc)
return True
def main( ):
gtk.main()
return 0
if __name__ == '__main__':
c = CrazySkinEddietor()
main()