def __init__(self):
self.palette = None
self.color = Color()
self.color.connect('changed', self.color_changed)
self.icon_path = os.path.join(os.path.dirname(__file__), 'data', 'icons')
self.init_config()
self.build_gui()
self.palette_dir = os.path.join(base.save_config_path(appinfo.pkgname), 'palettes')
Palette.PaletteDir = self.palette_dir
self.palette_list = PaletteList()
self.palette_list.load(self.palette_dir)
self.palette_combo.set_model(self.palette_list)
# no palettes, so create default
if len(self.palette_list) == 0:
palette = Palette()
palette.name = "Default Palette"
palette.filename = os.path.join(self.palette_dir, 'default.gpl')
self.palette_list.append(palette)
self.palette_combo.select(0)
self.colorpicker.set_color(self.color)
self.load_config()
def __init__(self):
self.palette = None
self.color = Color()
self.h_ids = {}
self.color.connect("changed", self.color_changed)
self.init_config()
self.build_gui()
self.palette_dir = os.path.join(base.save_config_path(appinfo.pkgname), "palettes")
Palette.PaletteDir = self.palette_dir
self.palette_list = PaletteList()
self.palette_list.load(self.palette_dir)
self.palette_combo.set_model(self.palette_list)
# no palettes, so create default
if len(self.palette_list) == 0:
palette = Palette()
palette.name = "Default Palette"
palette.filename = os.path.join(self.palette_dir, "default.gpl")
self.palette_list.append(palette)
self.palette_combo.select(0)
self.colorpicker.set_color(self.color)
self.load_config()
def choose_palette(self, palette_file):
palette_file = Palette.get_abs_path(palette_file)
if palette_file:
self.palette = Palette(palette_file)
self.update_image()
self.update_actions()
self.palette_window = ColorRampWidget(self.palette)
class TestPaletteMatchingPalette(unittest.TestCase):
def setUp(self):
self.palette = Palette('6081e8', '344283', '251c1e', '775a30')
def test_permutate_keeping_channel_order(self):
"""
Each channel is one from the same channel that in the original.
E.g.: From Palette ['ACC', 'BCC'] red can be A or B only.
"""
values_r = [color.channels['red'] for color in self.palette.colors]
values_g = [color.channels['green'] for color in self.palette.colors]
values_b = [color.channels['blue'] for color in self.palette.colors]
result = self.palette.retrieve_matching_palette()
self.assertTrue(result.colors[0].channels['red'] in values_r)
self.assertTrue(result.colors[0].channels['green'] in values_g)
self.assertTrue(result.colors[0].channels['blue'] in values_b)
def test_retrieve_another_palette(self):
"""Can repeat some but not all."""
result = self.palette.retrieve_matching_palette()
self.assertNotEqual(self.palette, result)
def test_retrieve_all_permutations_as_default(self):
result = self.palette.retrieve_matching_palette()
self.assertEqual(len(result.colors), len(self.palette.colors)**3)
def test_retrieve_amount_of_colors_asked(self):
number_of_colors = 2
result = self.palette.retrieve_matching_palette(number_of_colors)
self.assertEqual(len(result.colors), number_of_colors)
def __init__(self):
self.palette = None
self.color = Color()
self.color.connect('changed', self.color_changed)
self.icon_path = os.path.join(os.path.dirname(__file__), 'data',
'icons')
self.init_config()
self.build_gui()
self.palette_dir = os.path.join(base.save_config_path(appinfo.pkgname),
'palettes')
Palette.PaletteDir = self.palette_dir
self.palette_list = PaletteList()
self.palette_list.load(self.palette_dir)
self.palette_combo.set_model(self.palette_list)
# no palettes, so create default
if len(self.palette_list) == 0:
palette = Palette()
palette.name = "Default Palette"
palette.filename = os.path.join(self.palette_dir, 'default.gpl')
self.palette_list.append(palette)
self.palette_combo.select(0)
self.colorpicker.set_color(self.color)
self.load_config()
def extend_color(self, color_data, palette):
"""
:param color_data:
:param palette:
:return: palette, data_index
"""
color_set = set()
for color in color_data:
color_set.add(color)
if palette.can_extend(color_set):
return palette, palette.extend(color_data)
for pal in self._palettes:
if pal is palette:
continue
if pal.can_extend(color_set):
return pal, pal.extend(color_data)
palette = Palette(self, 'palette_%d' % (len(self._palettes) + 1), [])
self.add_palette(palette)
if palette.can_extend(color_set, 65536):
return palette, palette.extend(color_data)
assert False
def color(self):
"""Return color of instrument in palette."""
return {
'choir': Palette.choir(self.identifier),
'dolan': Palette.dolan(self.identifier),
'instrument': Palette.instrument(self.identifier),
'monochrome': Palette.monochrome()
}.get(self.palette, Palette.monochrome()) # default to monochrome
def __save_clicked(self, button):
pal = Palette()
mask = self.editor.get_mask()
for i, shape in enumerate(mask):
for j, col in enumerate(shape):
col_name = "mask#%d primary#%d" % (i, j) # NOT localised
pal.append(col, col_name)
preview = HCYMaskPreview()
pal.save_via_dialog(title=_("Save mask as a Gimp palette"), parent=self, preview=preview)
def init(self):
# get screen
win = self['main_window']
screen = win.get_screen()
print screen.get_width(), screen.get_height()
self.current_window = None
self.move(0,0)
#print self.get_position()
palette = Palette(self)
palette.show()
vbox = self['vbox']
hpaned = gtk.HPaned()
hpaned.show()
win.remove(vbox)
hpaned.pack1(vbox, shrink=False)
hpaned.pack2(palette.toplevel())
hpaned.set_property('position', 300)
vbox0 = gtk.VBox()
vbox0.pack_start(hpaned, expand=False)
centerbox = gtk.HBox()
centerbox.show()
vbox0.pack_start(centerbox)
vbox0.show()
win.add(vbox0)
browser = Browser(self)
browser.show()
centerbox.pack_start(browser.toplevel(), expand=False)
self.tree = WidgetTree(self)
obtreeview = self.tree['treeview']
self.tree.remove(obtreeview)
browser.toplevel().append_page(obtreeview)
#self.tree.move(0, self.get_height()+60)
self.tree.hide()
editor = Editor(self)
editor.show()
centerbox.pack_start(editor.toplevel())
propertybrowser = PropertyBrowser(self)
self.propertybrowser = propertybrowser
pbnotebook = propertybrowser['notebook']
propertybrowser.toplevel().remove(pbnotebook)
centerbox.pack_start(pbnotebook, expand=False)
propertybrowser.hide()
self['toolbar'].set_style(gtk.TOOLBAR_ICONS)
def init(self):
# get screen
win = self['main_window']
screen = win.get_screen()
print screen.get_width(), screen.get_height()
self.current_window = None
self.move(0, 0)
#print self.get_position()
palette = Palette(self)
palette.show()
vbox = self['vbox']
hpaned = gtk.HPaned()
hpaned.show()
win.remove(vbox)
hpaned.pack1(vbox, shrink=False)
hpaned.pack2(palette.toplevel())
hpaned.set_property('position', 300)
vbox0 = gtk.VBox()
vbox0.pack_start(hpaned, expand=False)
centerbox = gtk.HBox()
centerbox.show()
vbox0.pack_start(centerbox)
vbox0.show()
win.add(vbox0)
browser = Browser(self)
browser.show()
centerbox.pack_start(browser.toplevel(), expand=False)
self.tree = WidgetTree(self)
obtreeview = self.tree['treeview']
self.tree.remove(obtreeview)
browser.toplevel().append_page(obtreeview)
#self.tree.move(0, self.get_height()+60)
self.tree.hide()
editor = Editor(self)
editor.show()
centerbox.pack_start(editor.toplevel())
propertybrowser = PropertyBrowser(self)
self.propertybrowser = propertybrowser
pbnotebook = propertybrowser['notebook']
propertybrowser.toplevel().remove(pbnotebook)
centerbox.pack_start(pbnotebook, expand=False)
propertybrowser.hide()
self['toolbar'].set_style(gtk.TOOLBAR_ICONS)
def __init__(self, prefs, datapath):
"""Initialises with default colors and an empty adjuster list.
:param prefs: Prefs dict for saving settings.
:param datapath: Base path for saving palettes and masks.
"""
gobject.GObject.__init__(self)
# Defaults
self._color = None #: Currently edited color, a UIColor object
self._hist = [] #: List of previous colors, most recent last
self._palette = None #: Current working palette
self._adjusters = weakref.WeakSet() #: The set of registered adjusters
self._picker_cursor = gdk.Cursor(gdk.CROSSHAIR) #: Cursor for pickers
self._datapath = datapath #: Base path for saving palettes and masks
self._hue_distorts = None #: Hue-remapping table for color wheels
self._prefs = prefs #: Shared preferences dictionary
# Build the history. Last item is most recent.
hist_hex = list(prefs.get(PREFS_KEY_COLOR_HISTORY, []))
hist_hex = self._DEFAULT_HIST + hist_hex
self._hist = [RGBColor.new_from_hex_str(s) for s in hist_hex]
self._trim_hist()
# Restore current color, or use the most recent color.
col_hex = prefs.get(PREFS_KEY_CURRENT_COLOR, None)
if col_hex is None:
col_hex = hist_hex[-1]
self._color = RGBColor.new_from_hex_str(col_hex)
# Initialize angle distort table
wheel_type = prefs.get(PREFS_KEY_WHEEL_TYPE, self._DEFAULT_WHEEL_TYPE)
distorts_table = self._HUE_DISTORTION_TABLES[wheel_type]
self._hue_distorts = distorts_table
# Initialize working palette
palette_dict = prefs.get(PREFS_PALETTE_DICT_KEY, None)
if palette_dict is not None:
palette = Palette.new_from_simple_dict(palette_dict)
else:
datapath = self.get_data_path()
palettes_dir = os.path.join(datapath, DATAPATH_PALETTES_SUBDIR)
default = os.path.join(palettes_dir, DEFAULT_PALETTE_FILE)
palette = Palette(filename=default)
self._palette = palette
# Capture updates to the working palette
palette.info_changed += self._palette_changed_cb
palette.match_changed += self._palette_changed_cb
palette.sequence_changed += self._palette_changed_cb
palette.color_changed += self._palette_changed_cb
def get_colors(self,
image_path,
num,
return_color_counts=False,
return_image=False,
use_logs=False):
if num < 2:
print("The image must have at least 2 colors.")
return
image = cv2.imread(image_path, cv2.IMREAD_COLOR)
(h, w) = image.shape[:2]
# Convert color spaces
image = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
image = image.reshape((image.shape[0] * image.shape[1], 3))
clusters = MiniBatchKMeans(n_clusters=num)
labels = clusters.fit_predict(image)
res = clusters.cluster_centers_.astype("uint8")[labels]
# To get the colors back to RGB, we must convert to an image and extract the colors
res = res.reshape((h, w, 3))
res = cv2.cvtColor(res, cv2.COLOR_LAB2BGR)
if return_image:
res_image = res
res = res.reshape((h * w, 3))
res_colors = []
color_counts = []
for color in res:
string_color = generate_hex(color, bgr=True)
if string_color not in res_colors:
res_colors.append(string_color)
color_counts.append(0)
else:
color_counts[res_colors.index(string_color)] += 1
palette = Palette()
for i, color in enumerate(res_colors):
palette.add(Color(color, color_counts[i]))
self.scheme_cache = palette
# Oh no
if return_image:
if return_color_counts:
return palette, color_counts, res_image
return palette, res_image
if return_color_counts:
return palette, color_counts
return palette
def update_files(ifs_files, args):
palette = None
if args.palette:
palette = Palette.from_open_file(args.palette)
for ifs_file in ifs_files:
g = pyifs.Generator.from_file(ifs_file)
if args.iterations:
g.iterations = args.iterations
if args.points:
g.num_points = args.points
if args.scale:
g.scale = args.scale
if args.gamma:
g.gamma = args.gamma
if args.zoom:
g.ifs.d = args.zoom
if args.colour or palette:
g.ifs.transforms = [(p, t.get_mutated_colour(palette=palette) ) for (p,t) in g.ifs.transforms]
if args.saturation:
adjust_saturation(g, args.saturation)
f = open(ifs_file, 'w')
f.write(repr(g))
f.truncate()
f.close()
def add_color(my, name, palette_key, modifier=0, default=None):
from palette import Palette
palette = Palette.get()
color = palette.color(palette_key, modifier, default=default)
my.add_style("%s: %s" % (name, color))
return color
def main():
args = sys.argv
if not validate_command_line_args(args):
return
json_file_name = args[1]
if len(args) == 2:
generate_png = False
png_file_name = None
else:
generate_png = True
png_file_name = args[3]
try:
data_to_draw = JsonParser(json_file_name)
except IOError as err:
print(err)
return
palette = Palette(data_to_draw.get_palette())
screen = Screen(data_to_draw.get_screen())
figures = []
for figure in data_to_draw.get_figures():
try:
figures.append(create_figure_obj(figure))
except Exception as err:
print(err)
canvas = PyGameCanvas(palette, screen, figures)
canvas.run_pygame(generate_png, png_file_name)
return
def _init(self):
"""
Creates the board and palette.
"""
self._file_name = None
self._root = Tk()
self._root.resizable(0, 0)
self._menu = Menu(self._root, tearoff=0)
self.board = Board(self._root, self._menu, width=self._board_width,
height=self._board_height, directed_wires=self._directed_wires,
label_tooltips_enabled=self._label_tooltips_enabled,
same_label_per_connector=self._same_label_per_connector,
on_changed=self._on_changed, on_exit=self._request_save)
self._init_board()
self.palette = Palette(self._root, self.board, width=self._board_width,
height=self._palette_height)
# buttons to change board cursor state
self.palette.current_left_x -= PALETTE_PADDING
self._draw_display = self.palette.add_drawable_type(Image_Run_Drawable,
LEFT, self._switch_cursor_to_draw, image_file=PENCIL_IMAGE)
self.palette.current_left_x -= PALETTE_PADDING
self._drag_display = self.palette.add_drawable_type(Image_Run_Drawable,
LEFT, self._switch_cursor_to_drag, image_file=HAND_IMAGE)
self.palette.draw_separator()
self._switch_cursor_to_draw()
def createDockWidgets(self):
# Palette widget
self.palette = QtWidgets.QDockWidget(
self.context.getText("dock_widgets", "palette"), self)
self.palette.setAllowedAreas(Qt.RightDockWidgetArea)
self.palette.setFeatures(QtWidgets.QDockWidget.NoDockWidgetFeatures)
paletteWidget = Palette(self.context, self.signals)
self.palette.setWidget(paletteWidget)
self.palette.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Minimum)
self.addDockWidget(Qt.RightDockWidgetArea, self.palette)
# Tool Properties widget
self.toolProperties = ToolProperties(
self.context.getText("dock_widgets", "tool_properties"),
self.context, self.signals)
self.addDockWidget(Qt.RightDockWidgetArea, self.toolProperties)
self.toolProperties.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Expanding)
# Preview
self.preview = Preview(self.context.getText("dock_widgets", "preview"),
self.context, self.signals, self)
self.addDockWidget(Qt.RightDockWidgetArea, self.preview)
def __load_clicked(self, button):
preview = HCYMaskPreview()
preview.set_size_request(128, 128)
pal = Palette.load_via_dialog(title=_("Load mask from a Gimp palette"), parent=self, preview=preview)
if pal is None:
return
self.editor.set_mask_from_palette(pal)
def get_gradient(my, palette_key, modifier=0, range=-20, reverse=False, default=None,angle=180):
from palette import Palette
from web_container import WebContainer
web = WebContainer.get_web()
palette = Palette.get()
if web.is_IE():
color = palette.color(palette_key, (modifier+range)/2, default=default)
return color
else:
if not reverse:
color1 = palette.color(palette_key, modifier, default=default)
color2 = palette.color(palette_key, modifier+range, default=default)
else:
color2 = palette.color(palette_key, modifier, default=default)
color1 = palette.color(palette_key, modifier+range, default=default)
"""
if web.get_browser() == 'Mozilla':
gradient = "-moz-linear-gradient(top, %s, %s)" % (color1, color2)
else:
gradient = "-webkit-gradient(linear, 0%% 0%%, 0%% 100%%, from(%s), to(%s))" % (color1, color2)
"""
gradient = "linear-gradient(%sdeg, %s, %s)" % (angle, color1, color2)
return gradient
def create_dock_widgets(self):
# Palette widget
palette = QtGui.QDockWidget('palette', self)
palette.setAllowedAreas(Qt.RightDockWidgetArea)
palette.setFeatures(QtGui.QDockWidget.NoDockWidgetFeatures)
palette.setWidget(Palette(self.context, self.signals))
palette.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Minimum)
self.addDockWidget(Qt.RightDockWidgetArea, palette)
# Global properties
curve_properties = CurveProperties('curve properties', self.context,
self.signals)
curve_properties.setSizePolicy(QtGui.QSizePolicy.Maximum,
QtGui.QSizePolicy.Maximum)
self.addDockWidget(Qt.RightDockWidgetArea, curve_properties)
# Tool Properties widget
tool_properties = ToolProperties('tool properties', self.context,
self.signals)
tool_properties.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
self.addDockWidget(Qt.RightDockWidgetArea, tool_properties)
# Curves
curve_selector = CurveSelector('curve selector', self.context,
self.signals, self)
curve_selector.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
self.addDockWidget(Qt.RightDockWidgetArea, curve_selector)
def getPalettesFromBankData(self):
assert(self.PALETTE_COLOR_AMOUNT > 0)
assert(self.PALETTE_AMOUNT > 0)
paletteList = []
pointer = 0
for palNum in range(0, self.PALETTE_AMOUNT):
pal = Palette(False)
for colorNum in range(0, self.PALETTE_COLOR_AMOUNT):
B = ((self.data[pointer+1] & 0b01111100) >> 2)
G = (((self.data[pointer+1] & 0b00000011) << 3) + ((self.data[pointer] & 0b11100000) >> 5))
R = self.data[pointer] & 0b00011111
pal.append(Color(red=R, green=G, blue=B, type=False))
pointer += 2
pal.switchType()
paletteList.append(pal)
self.setPalettes(paletteList)
return self.palettes
def __save_clicked(self, button):
pal = Palette()
mask = self.editor.get_mask()
for i, shape in enumerate(mask):
for j, col in enumerate(shape):
col_name = "mask#%d primary#%d" % (i, j) # NOT localised
pal.append(col, col_name)
preview = HCYMaskPreview()
preview.set_size_request(128, 128)
target_mgr = self.target.get_color_manager()
prefs_ro = deepcopy(target_mgr.get_prefs())
datapath = target_mgr.get_data_path()
mgr = ColorManager(prefs=prefs_ro, datapath=datapath)
preview.set_color_manager(mgr)
preview.set_managed_color(self.editor.get_managed_color())
palette_save_via_dialog(pal, title=_("Save mask as a Gimp palette"),
parent=self, preview=preview)
def generate_ifs():
ifs = IFS(d=3.0)
p = Palette.from_file("/Users/efredine/Pictures/Vancouver/_MG_4051.ptl") # blue and gold
# p = Palette.from_file('/Users/efredine/Pictures/Vancouver/_MG_4306.ptl') #subdued
for n in range(NUM_TRANSFORMS):
transform = random.choice(TRANSFORM_CHOICES)
ifs.add(transform.get_new_transform(params={"palette": p}))
return ifs
def getPalette(self, pid):
# print(pid)
data = self.client.hgetall("palette:" + pid)
lerp = (data[b'lerp'].decode('utf-8') == "true")
colors = self.client.lrange("palette:" + pid + ":colors", 0, -1)
in_palette = []
for color in colors:
in_palette.append(color.decode('utf-8'))
return Palette(colors=in_palette, lerp=lerp)
def __init__(self, lid, layer={}, palette=0):
#print(layer)
self.lid = lid
self.params = layer
# print(self.params)
if palette == 0:
self.palette = Palette()
else:
self.palette = palette
def create_actions(self):
self.open_act = QAction('&Open image...',
self,
shortcut='Ctrl+O',
enabled=False,
triggered=self.open)
self.choose_palette_act_dict = {
os.path.basename(palette_file):
self.create_choose_palette_action(palette_file)
for palette_file in Palette.get_palette_files()
}
self.exit_act = QAction('E&xit',
self,
shortcut='Ctrl+Q',
triggered=self.close)
self.zoom_in_act = QAction('Zoom &In ({}%)'.format(
int(100 * self.scale_step)),
self,
shortcut='Ctrl++',
enabled=False,
triggered=self.zoom_in)
self.zoom_out_act = QAction('Zoom &Out ({}%)'.format(
int(100 * self.scale_step)),
self,
shortcut='Ctrl+-',
enabled=False,
triggered=self.zoom_out)
self.normal_size_act = QAction('&Normal Size',
self,
shortcut='Ctrl+N',
enabled=False,
triggered=self.normal_size)
self.fit_to_window_act = QAction('&Fit to Window',
self,
enabled=False,
checkable=True,
shortcut='Ctrl+F',
triggered=self.fit_to_window)
self.save_single_image_act = QAction('&Save image',
self,
enabled=False,
shortcut='Ctrl+S',
triggered=self.save_single_image)
self.create_gallery_act = QAction('&Create gallery',
self,
shortcut='Ctrl+G',
enabled=False,
triggered=self.create_gallery_folder)
def _palette_loadsave_dialog_update_preview_cb(dialog, preview):
"""Updates the preview widget when loading/saving palettes via dialog"""
filename = dialog.get_preview_filename()
palette = None
if filename is not None and os.path.isfile(filename):
try:
palette = Palette(filename=filename)
except Exception, ex:
logger.warning("Couldn't update preview widget: %s", str(ex))
return
def __save_clicked(self, button):
pal = Palette()
mask = self.editor.get_mask()
for i, shape in enumerate(mask):
for j, col in enumerate(shape):
col_name = "mask#%d primary#%d" % (i, j) # NOT localised
pal.append(col, col_name)
preview = HCYMaskPreview()
preview.set_size_request(128, 128)
target_mgr = self.target.get_color_manager()
prefs_ro = deepcopy(target_mgr.get_prefs())
datapath = target_mgr.get_data_path()
mgr = ColorManager(prefs=prefs_ro, datapath=datapath)
preview.set_color_manager(mgr)
preview.set_managed_color(self.editor.get_managed_color())
palette_save_via_dialog(pal,
title=_("Save mask as a Gimp palette"),
parent=self,
preview=preview)
def __load_btn_clicked(self, button):
preview = _PalettePreview()
manager = self.__target.get_color_manager()
datapath = manager.get_data_path()
palettes_dir = os.path.join(datapath, DATAPATH_PALETTES_SUBDIR)
palette = Palette.load_via_dialog(title=_("Load palette"),
parent=self,
preview=preview,
shortcuts=[palettes_dir])
if palette is not None:
self.__view.set_palette(palette)
def get_constants():
window_title = 'PyRogue'
screen_width = 80
screen_height = 50
bar_width = 20
panel_height = 7
panel_y = screen_height - panel_height
message_x = bar_width + 12
message_width = screen_width - bar_width - 2
message_height = panel_height - 1
map_width = 80
map_height = 43
room_max_size = 10
room_min_size = 6
max_rooms = 30
fov_algorithm = 0
fov_light_walls = True
fov_radius = 10
max_monsters_per_room = 3
max_items_per_room = 2
colors = Palette()
constants = {
'window_title': window_title,
'screen_width': screen_width,
'screen_height': screen_height,
'bar_width': bar_width,
'panel_height': panel_height,
'panel_y': panel_y,
'message_x': message_x,
'message_width': message_width,
'message_height': message_height,
'map_width': map_width,
'map_height': map_height,
'room_max_size': room_max_size,
'room_min_size': room_min_size,
'max_rooms': max_rooms,
'fov_algorithm': fov_algorithm,
'fov_light_walls': fov_light_walls,
'fov_radius': fov_radius,
'max_monsters_per_room': max_monsters_per_room,
'max_items_per_room': max_items_per_room,
'colors': colors
}
return constants
def __init__(self):
#Variáveis para criação da tela
self.SIZE = eval( all_config.data["tamanho_tela"])
self.SCREEN = pygame.display.set_mode(self.SIZE)
self.objWorkArea = Work_Area()
self.objPalette = Palette()
self.objSerial = Serial_Arduino()
self.CLOCK = pygame.time.Clock()
self.file = Arquivos()
#Cria os rects
print "Lista de rects criados para a palette:"
def set_color_manager(self, manager):
CombinedAdjusterPage.set_color_manager(self, manager)
self.__adj.set_color_manager(manager)
prefs = self._get_prefs()
palette_dict = prefs.get(PREFS_PALETTE_DICT_KEY, None)
if palette_dict is not None:
palette = Palette.new_from_simple_dict(palette_dict)
else:
datapath = manager.get_data_path()
palettes_dir = os.path.join(datapath, DATAPATH_PALETTES_SUBDIR)
default = os.path.join(palettes_dir, DEFAULT_PALETTE_FILE)
palette = Palette(filename=default)
self.__adj.set_palette(palette)
def _init(self):
"""
Creates the board and palette.
"""
self._file_name = None
self._root = Tk()
self._root.resizable(0, 0)
self._menu = Menu(self._root, tearoff=0)
self.board = Board(
self._root,
self._menu,
width=self._board_width,
height=self._board_height,
directed_wires=self._directed_wires,
label_tooltips_enabled=self._label_tooltips_enabled,
same_label_per_connector=self._same_label_per_connector,
on_changed=self._on_changed,
on_exit=self._request_save)
self._init_board()
self.palette = Palette(self._root,
self.board,
width=self._board_width,
height=self._palette_height)
# buttons to change board cursor state
self.palette.current_left_x -= PALETTE_PADDING
self._draw_display = self.palette.add_drawable_type(
Image_Run_Drawable,
LEFT,
self._switch_cursor_to_draw,
image_file=PENCIL_IMAGE)
self.palette.current_left_x -= PALETTE_PADDING
self._drag_display = self.palette.add_drawable_type(
Image_Run_Drawable,
LEFT,
self._switch_cursor_to_drag,
image_file=HAND_IMAGE)
self.palette.draw_separator()
self._switch_cursor_to_draw()
def __init__(self, app):
gtk.Window.__init__(self)
self.app = app
vbox = gtk.VBox(False, 0)
self.mb = AppMenubar(self)
vbox.pack_start(self.mb, False, False, 0)
self.toolbar = AppToolbar(self)
vbox.pack_start(self.toolbar, False, False, 0)
#---CENTRAL PART
hbox = gtk.HBox(False, 0)
self.tools_frame = gtk.EventBox()
self.tools = AppTools(self)
hbox.pack_start(self.tools_frame, False, False, 1)
self.nb_frame = gtk.EventBox()
self.nb_splash = SplashArea(self)
hbox.pack_start(self.nb_frame, True, True, 1)
self.nb = gtk.Notebook()
self.nb_frame.add(self.nb_splash)
self.nb.connect('switch-page', self.change_doc)
self.nb.set_property('scrollable', True)
vbox.pack_start(hbox, True, True, 2)
#---CENTRAL PART
self.statusbar = AppStatusbar(self)
vbox.pack_end(self.statusbar, expand=False)
self.palette = Palette(self)
vbox.pack_end(self.palette, False, False, 0)
self.add(vbox)
self.set_win_title()
self.set_size_request(config.mw_min_width, config.mw_min_height)
self.set_default_size(config.mw_width, config.mw_height)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("delete-event", self.exit)
self.add_accel_group(self.app.accelgroup)
icon = os.path.join(config.resource_dir, 'app_icon.png')
self.set_icon_from_file(icon)
self.show_all()
if config.mw_maximized:
self.window.maximize()
def run_open():
try:
open_app.close()
open_app.deleteLater()
except:
pass
open_app = OpenDialog()
open_app.setParent(parentHou, QtCore.Qt.Window)
open_app.setStyle(QtWidgets.QStyleFactory.create("fusion"))
dark_palette = QtGui.QPalette()
Palette(dark_palette)
open_app.setPalette(dark_palette)
open_app.show()
def __init__(self, root):
self.root = root
self.writer = Writer()
w = root.winfo_screenwidth() // 2
root.geometry(f"{w}x800+{w // 4 * 3}+100")
root.title("")
top = Toplevel(root)
Palette(top).place(relx=0, rely=0, relheight=1, relwidth=1)
self.board = Board(root, height=800, width=w)
self.board.pack(fill="both", expand=True)
self.manager = Manager(root, self.writer, self.root, bg="#435661", height=800, width=w // 5 * 2)
self.manager.geometry("+250+100")
self.set_bind()
def palette_load_via_dialog(title, parent=None, preview=None,
shortcuts=None):
"""Runs a file chooser dialog, returning a palette or `None`.
The dialog is both modal and blocking. A new `Palette` object is returned
if the load was successful. The value `None` is returned otherwise.
:param parent: specifies the parent window
:param title: dialog title
:param preview: any preview widget with a ``set_palette()`` method
:param shortcuts: optional list of shortcut folders
"""
dialog = Gtk.FileChooserDialog(
title=title,
parent=parent,
action=Gtk.FileChooserAction.OPEN,
buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT,
Gtk.STOCK_OPEN, Gtk.ResponseType.ACCEPT),
)
if preview is not None:
dialog.set_preview_widget(preview)
dialog.connect("update-preview",
_palette_loadsave_dialog_update_preview_cb,
preview)
if shortcuts is not None:
for shortcut in shortcuts:
dialog.add_shortcut_folder(shortcut)
dialog.set_do_overwrite_confirmation(True)
filter = Gtk.FileFilter()
filter.add_pattern("*.gpl")
filter.set_name(_("GIMP palette file (*.gpl)"))
dialog.add_filter(filter)
filter = Gtk.FileFilter()
filter.add_pattern("*")
filter.set_name(_("All files (*)"))
dialog.add_filter(filter)
response_id = dialog.run()
palette = None
if response_id == Gtk.ResponseType.ACCEPT:
filename = dialog.get_filename()
logger.info("Loading palette from %r", filename)
palette = Palette(filename=filename)
dialog.destroy()
return palette
def Main():
try:
app.close()
app.deleteLater()
except:
pass
app = QtWidgets.QApplication(sys.argv)
app.setStyle(QtWidgets.QStyleFactory.create("fusion"))
dark_palette = QtGui.QPalette()
Palette(dark_palette)
app.setPalette(dark_palette)
ui = MainWindow()
ui.show()
sys.exit(app.exec_())
def createDockWidgets(self):
#Palette widget
self.palette = QDockWidget(self)
self.palette.setAllowedAreas(Qt.RightDockWidgetArea)
self.palette.setFeatures(QtWidgets.QDockWidget.NoDockWidgetFeatures)
palette = Palette(self.context, self.signals)
self.palette.setWidget(paletteWidget)
self.palette.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Minimum)
self.addDockWidget(Qt.RightDockWidgetArea, self.palette)
# image editing widget
self.ieTools = ieTools(self.context, self.signals)
self.addDockWidget(Qt.RightDockWidgetArea, self.ieTools)
self.ieTools.setSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Expanding)
def __init__(self, data=[], hasPalettes=False):
self.data = data
self.bankHasPalettes = hasPalettes
self.palettes = None
if ((self.bankHasPalettes) and (data is not None)):
self.palettes = self.getPalettesFromBankData()
# two hardcoded palettes, not sure where they are in ROM yet
# or why they are part of tilemap's palette selection
hardcodedPalette1 = Palette(True)
hardcodedPalette2 = Palette(True)
for x in range(0, self.PALETTE_COLOR_AMOUNT):
hardcodedPalette1.append(self.COLORS_HARDCODED_1[x])
hardcodedPalette2.append(self.COLORS_HARDCODED_2[x])
self.palettes.append(hardcodedPalette1)
self.palettes.append(hardcodedPalette2)
self.image = None
self.tileAmount = 1024
self.createImage()
def __init__(self, parent):
wx.Panel.__init__(self, parent, size = (1100,600))
self.SetBackgroundColour((60,70,100))
self.SetForegroundColour((255,255,255))
self.screens_tall = 2
self.screens_wide = 2
self.tiles_per_axis = 5
self.name = 'circleburg'
self.image_dir = '%s_images' % self.name
self.savepath = 'saved/%s' % self.name
self.make_widgets()
self.position = (0,0)
self.slides = []
self.palette = Palette(self, tiles_across=2, tiles_tall=10, full_tile_size=50)
self.worldmap = Worldmap(self, self.palette, self.screens_wide, self.screens_tall, self.tiles_per_axis)
self.room_index = (0,0)
self.current_room = self.worldmap.room_grid[self.room_index[0]][self.room_index[1]]
self.display_window = DisplayWindow(self, height=500, width=800, current_room=self.current_room)
self.highlighter = self.make_highlighter(1,0,0,5)
self.avatar = wx.Image('characters/Mr_Circle.png', wx.BITMAP_TYPE_ANY)
self.current_room.DrawImageAtPosition(self.highlighter, self.position[0], self.position[1])
self.display_window.refresh()
self.Bind(wx.EVT_CHAR_HOOK, lambda event: self.onKey(event))
#self.load_path('saved/circleburg')
self.refresh()
def get_palette(cls):
return Palette.get()
'BICUBIC': Image.BICUBIC, 'ANTIALIAS': Image.ANTIALIAS}
}
for key,value in args.iteritems():
if key in translations:
if value in translations[key]:
args[key] = translations[key][value]
return args
if __name__ == '__main__':
arguments = docopt(usage, argv=sys.argv[1:], help=True, version=None)
arguments = set_defaults(arguments)
arguments = translate(arguments)
palette = Palette(arguments['--color-space'])
palette.add_csv(arguments['--csv'])
if arguments['--exclude']:
exclude = [x.strip() for x in arguments['--exclude'].split(',')]
palette.exclude(exclude)
if arguments['--limit']:
exclude = [x.strip() for x in arguments['--limit'].split(',')]
palette.exclude_all_but(exclude)
beader = Beader(palette, arguments['<input_file>'])
if arguments['--flip']:
beader.flip = True
if arguments['--crop'] or arguments['--crop-color']:
beader.crop = True
def get_color(col_code, grade=0):
# TODO: document
return Palette.get_instance().get_col(col_code, grade)
def get_lighter(col, steps=1):
# TODO: document
return Palette.get_instance().shift_col(col, steps)
class tela(object):
"""
Está é a classe que gerenciará a tela, tudo que estiver na tela, ou qualquer
modificação será gerenciado por essa classe
"""
def __init__(self):
#Variáveis para criação da tela
self.SIZE = eval( all_config.data["tamanho_tela"])
self.SCREEN = pygame.display.set_mode(self.SIZE)
self.objWorkArea = Work_Area()
self.objPalette = Palette()
self.objSerial = Serial_Arduino()
self.CLOCK = pygame.time.Clock()
self.file = Arquivos()
#Cria os rects
print "Lista de rects criados para a palette:"
def inicia_screen(self):
"""
É um método que inicia a tela ou SCREEN
"""
print "Iniciando show_screen"
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
print "\tFinalizando show_screen"
def drag_and_drop(self, tuple_caixa):
"""
Esta função é a que faz o drag and drop de toda a interface, ou seja, quando clicar em algo que possui uma caixa
ela irá funcionar como um drag and drop.
"""
caixa = tuple_caixa[0]
# MELHORAR ESTE CÓDIGO, ESTÁ A CONSUMIR MUITO PROCESSAMENTO
teste = 0
pos_anterior = (0,0)
TELA = self.SCREEN.copy()
while teste == 0:
self.CLOCK.tick(10)
for event in pygame.event.get():
pos = pygame.mouse.get_pos()
self.SCREEN.blit(TELA,(0,0))
caixa.show_em_nova_posicao( self.SCREEN,(pos[0]-50,pos[1]-50))
if event.type == pygame.MOUSEBUTTONUP:
posv = self.objWorkArea.retorna_posv()
posx = self.objWorkArea.retorna_posx()
variacao = 0
if ( posv - posx > 520 or posv - posx < 0):
variacao = (posv - posx) - 310;
self.objWorkArea.modifica_posx(posx + variacao)
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
self.objWorkArea.nova_caixa(self.SCREEN, (pos[0]-variacao,pos[1]), tuple_caixa[1])
teste = 1
pygame.display.update((pos_anterior[0]-50,pos_anterior[1]-50, 100, 100))
pygame.display.update((pos[0]-50,pos[1]-50,100,100))
pos_anterior = pos
print "SAi do While"
self.SCREEN.blit(TELA,(0,0))
pygame.display.update()
""""""
def acoes(self):
"""
Esta função é a que irá atualizar, adicionar/remover e verificar as modificações feitas pelo usuário.
"""
for event in pygame.event.get(pygame.MOUSEBUTTONDOWN):
posicao = event.pos
if posicao[1] > 540:
temp = self.objWorkArea.teste_botoes(posicao)
if temp != -1:
self.botoes_Tela(temp)
elif posicao[0] > 620:
temp = self.objPalette.verifica_palette( posicao )
if temp == 1:
print "Troca de palette"
self.objPalette.mostra_palette(self.SCREEN)
elif temp == 0:
print "Não faz drag and drop"
pass
else:
"Faz drag and drop"
print temp
self.drag_and_drop(temp)
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
else:
if event.button == 1: #TODO 1 significa que o botão clicado foi o da direita
if (self.objWorkArea.modifica_caixa(self.SCREEN,posicao) == 1):
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
elif event.button == 3:
if (self.objWorkArea.retira_caixa(posicao) == 1):
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
def botoes_Tela(self, temp):
if temp == 0:
posx = self.objWorkArea.retorna_posx()
self.objWorkArea.modifica_posx(posx - 50)
print "Diminui posx"
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
elif temp == 1:
posx = self.objWorkArea.retorna_posx()
self.objWorkArea.modifica_posx(posx + 50)
print "Aumenta posx"
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
elif temp == 2:
if self.file.askOpenOk() == 1:
programa = self.file.openFile()
self.objWorkArea.recria_programa(programa)
self.objWorkArea.mostra_workarea(self.SCREEN)
self.objPalette.mostra_palette(self.SCREEN)
pygame.display.update()
#Gera apartir do texto o programa
elif temp == 3:
text = self.objWorkArea.gera_programa()
print text
self.file.saveFile(text)
elif temp == 4:
#Enviar arquivo
teste = self.objSerial.localiza_arduino()
if teste == 0:
pass
#Pega os dados e envia
else:
pass
#Mostra uma msg na tela demonstrando qual foi o ocorrido
pass
def append_path(self, path):
""" Add a palette to the end of the list by specifying its path """
p = Palette()
if p.load(path):
self.append(p)
def add_color(my, name, palette_key, modifier=0, default=None):
from palette import Palette
palette = Palette.get()
color = palette.color(palette_key, modifier, default=default)
my.add_style("%s: %s" % (name, color) )
return color
def get_theme(my):
from palette import Palette
palette = Palette.get()
return palette.get_theme()
class App_Runner:
"""
App runner that uses a Board and a Palette.
"""
def __init__(self, on_init, app_name, dev_stage, file_extension,
deserializers, board_width, board_height, palette_height,
directed_wires, label_tooltips_enabled, same_label_per_connector,
init_file=None):
"""
|on_init|: method called every time a new board of this app's type is
created.
|app_name|: name of this app.
|dev_stage|: development stage of this app.
|file_extension|: the file extension used for boards of this app's type.
|deserializers|: drawabel types to open files of this app's type.
|board_width|, |board_height|: board dimensions.
|palette_height|: height of palette, width will be the same as board width.
|directed_wires|: True if the board is to have directed wires, False
otherwise.
|label_tooltips_enabled|: if True, show wire and drawable label tooltips.
|same_label_per_connector|: if True, all wires from a connector will have
the same label. If False, this will only be true for wire connectors.
|init_file|: file to open at init time.
"""
self._on_init = on_init
self._app_name = app_name
self._dev_stage = dev_stage
self._file_extension = file_extension
self._deserializers = deserializers
self._board_width = board_width
self._board_height = board_height
self._palette_height = palette_height
self._directed_wires = directed_wires
self._label_tooltips_enabled = label_tooltips_enabled
self._same_label_per_connector = same_label_per_connector
self._init_file = init_file
self._init()
self._setup_menu()
self._setup_shortcuts()
def _switch_cursor_to_draw(self, *args):
"""
Switches board cursor state to 'draw'.
"""
self._draw_display.highlight()
self._drag_display.unhighlight()
self.board.set_cursor_state('draw')
def _switch_cursor_to_drag(self, *args):
"""
Switches board cursor state to 'drag'.
"""
self._draw_display.unhighlight()
self._drag_display.highlight()
self.board.set_cursor_state('drag')
def _toggle_cursor(self):
"""
Toggles board cursor state.
"""
if self.board.get_cursor_state() == 'draw':
self._switch_cursor_to_drag()
else:
self._switch_cursor_to_draw()
def _init(self):
"""
Creates the board and palette.
"""
self._file_name = None
self._root = Tk()
self._root.resizable(0, 0)
self._menu = Menu(self._root, tearoff=0)
self.board = Board(self._root, self._menu, width=self._board_width,
height=self._board_height, directed_wires=self._directed_wires,
label_tooltips_enabled=self._label_tooltips_enabled,
same_label_per_connector=self._same_label_per_connector,
on_changed=self._on_changed, on_exit=self._request_save)
self._init_board()
self.palette = Palette(self._root, self.board, width=self._board_width,
height=self._palette_height)
# buttons to change board cursor state
self.palette.current_left_x -= PALETTE_PADDING
self._draw_display = self.palette.add_drawable_type(Image_Run_Drawable,
LEFT, self._switch_cursor_to_draw, image_file=PENCIL_IMAGE)
self.palette.current_left_x -= PALETTE_PADDING
self._drag_display = self.palette.add_drawable_type(Image_Run_Drawable,
LEFT, self._switch_cursor_to_drag, image_file=HAND_IMAGE)
self.palette.draw_separator()
self._switch_cursor_to_draw()
def _setup_menu(self):
"""
Creates the menu.
"""
file_menu = Menu(self._menu, tearoff=0)
file_menu.add_command(label='New', command=self._new_file,
accelerator='Ctrl+N')
file_menu.add_command(label='Open', command=self._open_file,
accelerator='Ctrl+O')
file_menu.add_command(label='Save', command=self._save_file,
accelerator='Ctrl+S')
file_menu.add_command(label='Save as', command=self._save_as)
file_menu.add_separator()
file_menu.add_command(label='Quit', command=self.board.quit,
accelerator='Ctrl+Q')
self._menu.add_cascade(label='File', menu=file_menu)
edit_menu = Menu(self._menu, tearoff=0)
edit_menu.add_command(label='Undo', command=self.board.undo,
accelerator='Ctrl+Z')
edit_menu.add_command(label='Redo', command=self.board.redo,
accelerator='Ctrl+Y')
edit_menu.add_command(label='Delete selected',
command=self.board._delete_selected_items, accelerator='Delete')
edit_menu.add_command(label='Rotate selected',
command=self.board._rotate_selected_item, accelerator='r')
edit_menu.add_command(label='Toggle cursor', command=self._toggle_cursor,
accelerator='D')
self._menu.add_cascade(label='Edit', menu=edit_menu)
self._root.config(menu=self._menu)
def _setup_shortcuts(self):
"""
Adds basic shortcuts.
"""
self.board.parent.bind('<Control-n>', lambda event: self._new_file())
self.board.parent.bind('<Control-N>', lambda event: self._new_file())
self.board.parent.bind('<Control-o>', lambda event: self._open_file())
self.board.parent.bind('<Control-O>', lambda event: self._open_file())
self.board.parent.bind('<Control-q>', lambda event: self.board.quit())
self.board.parent.bind('<Control-Q>', lambda event: self.board.quit())
self.board.parent.bind('<Control-s>', lambda event: self._save_file())
self.board.parent.bind('<Control-S>', lambda event: self._save_file())
self.board.parent.bind('<Control-y>', lambda event: self.board.redo())
self.board.parent.bind('<Control-Y>', lambda event: self.board.redo())
self.board.parent.bind('<Control-z>', lambda event: self.board.undo())
self.board.parent.bind('<Control-Z>', lambda event: self.board.undo())
self.board.add_key_binding('d', self._toggle_cursor)
def _init_board(self):
"""
(Re)Initializes the board based on this app's specific needs, as per
self._on_init.
"""
self.board.clear()
self._on_init(self.board)
self.board.reset()
def _on_changed(self, board_changed):
"""
Callback for when the board is changed. Updates the title of the app window
to indicate whether we need to save the file.
"""
self._root.title('%s (%s) %s %s' % (self._app_name, self._dev_stage,
strip_file_name(self._file_name), '*' if board_changed else ''))
def _save_as(self, file_name=None):
"""
Saves the current state of the app with the given |file_name|.
"""
saved_file_name = save_board(self.board, file_name, self._app_name,
self._file_extension)
if saved_file_name:
self._file_name = saved_file_name
self.board.set_changed(False)
def _save_file(self):
"""
Saves the current state of the app with its current file name (asks for a
a file path if it currently does not have one).
"""
self._save_as(self._file_name)
def _request_save(self):
"""
Requests for a file save if necessary. Returns True if there isn't anything
to save or, in the case that there is something to save, if the user
either decides to save the file (will be presented with a dialog to do
so) or decides not to save the file. Returns False if the user cancels
the request for save (i.e. does neither).
"""
if self.board.changed():
save = request_save_board()
if save == 'yes':
self._save_file()
return True
elif save == 'no':
return True
else:
return False
else:
return True
def _open_file(self, new_file_name=None):
"""
Opens a saved file of this app's type.
"""
if self._request_save():
new_file_name = new_file_name or get_board_file_name(self._file_name,
self._app_name, self._file_extension)
if open_board_from_file(self.board, new_file_name, self._deserializers,
self._file_extension):
self._file_name = new_file_name
self._on_changed(False)
self.board.reset_cursor_state()
def _new_file(self):
"""
Opens a new file of this app's type.
"""
if self._request_save():
self._file_name = None
self._init_board()
def run(self):
"""
Runs this app.
"""
self.board.clear_action_history()
self._root.title('%s (%s)' % (self._app_name, self._dev_stage))
if self._init_file:
self._open_file(self._init_file)
self._root.mainloop()
def quantize(self, maxColors): p = Palette(maxColors) for rgb in self.__data: p.addColor(rgb) return p.quantize()
def append_path(self, path):
""" Add a palette to the end of the list by specifying its path """
p = Palette()
if p.load(path):
self.append(p)
def get_color(my, palette_key, modifier=0, default=None):
from palette import Palette
palette = Palette.get()
color = palette.color(palette_key, modifier, default=default)
return color
def get_palette():
return Palette.get()
def add_palette(self, button):
p = Palette()
p.name = "Untitled Palette"
self.palette_list.append(p)
self.palette_combo.select(self.palette_list.index_of_palette(p))
def __clear_btn_clicked(self, button):
pal = Palette()
pal.append(None)
self.__view.set_palette(pal)
