def on_labels(self, instance, value):
self.reset()
image_view = self.ids.image_view
for i, label in enumerate(value):
# Make an image for this mask
image = Image(source="", keep_ratio=True, allow_stretch=True)
imgIO = io.BytesIO()
mask_img = np.zeros((*label.mask.shape, 4))
mask_img[:, :, :3] = np.array(
PAINTBRUSH_COLORS[i % len(PAINTBRUSH_COLORS)])
mask_img[:, :,
3] = np.where(np.isnan(label.mask), 0.0, label.mask) * 0.6
pil_img = PILImage.fromarray(
(mask_img * 255).astype(np.uint8),
mode='RGBA').resize(image_view.image_size)
pil_img.save(imgIO, format='png')
imgIO.seek(0)
imgData = io.BytesIO(imgIO.read())
image.texture = CoreImage(imgData, ext='png').texture
image.reload()
self.ids.paintbrush_parent.add_widget(image)
self.paintbrushes.append(image)
image.pos = self.ids.paintbrush_parent.pos
image.size = self.ids.paintbrush_parent.size
for center, stroke in zip(label.centers, label.strokes):
# Label
center = image_view.convert_point_from_image(center)
lw = Label(pos=(int(center[0] + self.ids.label_parent.pos[0]),
int(center[1] + self.ids.label_parent.pos[1])),
text=label.label)
self.label_widgets.append(lw)
self.ids.label_parent.add_widget(lw)
def build(self):
label = Label(text="Testing going on.")
atlas = Atlas("player_sheet.atlas")
image1 = Image(allow_stretch=True)
image1.texture = atlas["walkleft4"]
label.add_widget(image1)
return label
def buildImage(self, sourceData):
imageBytesObj = decode(sourceData['image'])
imageBytesObj.seek(0)
img = CoreImage(imageBytesObj, ext='jpg')
new_img = Image()
new_img.texture = img.texture
return new_img
def exibir_imagem(self):
ce = self.ids.conteudo_edicao
ce.clear_widgets()
#############################
# Obtendo Textura da Imagem #
#############################
# Criando Buffer
image_bytes = io.BytesIO()
# Salvando Imagem de PIL no Buffer
ed.img.save(image_bytes, format=ed.img_formato)
# Defininto ponto inicial 0
image_bytes.seek(0)
# Carregando imagem no CoreImage -> Ex: (Buffer, ext='png')
im = CoreImage(image_bytes, ext=ed.img_formato)
# Coletando textura da Imagem de CoreImage
tex = im.texture
# Encerrando Buffer
image_bytes.close()
# ----------------------- #
# Criando Widget de Imagem
img = Image(nocache=True)
# Passando a textura gerada no CoreImage para ele
img.texture = tex
ce.add_widget(img)
def get_module_resource_path(file_name, size, resource_package=__name__):
import os
regex = re.compile(
r'^(?:http|ftp)s?://' # http:// or https://
r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
r'localhost|' # localhost...
r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
r'(?::\d+)?' # optional port
r'(?:/?|[/?]\S+)$',
re.IGNORECASE)
if regex.match(file_name) or os.path.isfile(file_name):
image = Image(source=file_name)
else:
__requires__ = ["CherryPy < 3"
] # Must be set before pkg_resources import
import pkg_resources
resource_path = '/' + file_name
reader = pkg_resources.resource_stream(resource_package, resource_path)
if reader:
stream = io.BytesIO(reader.read())
_, file_extension = os.path.splitext(file_name)
im = CoreImage(stream, ext=file_extension[1:])
image = Image(source="")
image.texture = im.texture
image.reload()
image.size = size
return image
def buildImage(self):
imageBytesObj = decode(self.dataSource)
imageBytesObj.seek(0)
img = CoreImage(imageBytesObj, ext='jpg')
new_img = Image()
new_img.texture = img.texture
self.add_widget(new_img)
def main():
sm = ScreenManager()
screenshare = Screen(name="screenshare")
sm.switch_to(screenshare)
boxl = BoxLayout(orientation='vertical')
data = BytesIO()
canvas_img = Im.new('RGB', (1920, 1080), color=(0, 0, 0))
canvas_img.save(data, format='png')
data.seek(0)
kimg = KiImage(data, ext='png')
img = Image()
img.texture = kimg.texture
img.allow_strech = True
img.keep_ratio = True
btn = Button(text='start', pos_hint={'x': 0, 'y': 0}, size_hint=(0.1, 0.1))
sock = socket.socket()
host = '127.0.0.1'
port = 8000
def retreive(*a):
rwh = sock.recv(50).decode()
rwh = eval(rwh)
print(rwh)
repeat = rwh[0]
width = rwh[1]
height = rwh[2]
print(repeat)
b = bytearray()
flag = 0
for i in range(repeat):
im = sock.recv(1024)
b.extend(im)
flag = flag + 1
print(flag, len(b))
z = Im.frombytes('RGB', (width, height), bytes(b))
data.seek(0)
z.save(data, format='png')
data.seek(0)
kimg = KiImage(data, ext='png')
img.texture = kimg.texture
#img.source(z)
def startret(*a):
print('hello')
sock.connect((host, port))
Clock.schedule_interval(retreive, 1.0 / 20)
boxl.add_widget(img)
boxl.add_widget(btn)
btn.bind(on_press=startret)
screenshare.add_widget(boxl)
return sm
def action(self, button):
item = []
if type(button.parent.parent.parent).__name__ == 'History':
for data in self.left_check_list:
if data.state == 'down':
item.append(data.parent.parent)
else:
item.append(button.parent.parent.parent)
item_data = str(item[0].text + ' ' + item[0].secondary_text)
if button.icon == 'content-copy':
Clipboard.copy(item_data)
elif button.icon == 'history':
self.main.pages.pages_list[
current_page[0]].entry.text = item_data.split()[0]
self.parent.dismiss()
elif button.icon == 'qrcode':
image = Image(source="")
imgIO = io.BytesIO()
qrcode.make(item_data).save(imgIO, ext='png')
imgIO.seek(0)
imgData = io.BytesIO(imgIO.read())
image.texture = CoreImage(imgData, ext='png').texture
image.reload()
dialog = ModalView(size_hint=(None, None), size=image.texture.size)
dialog.add_widget(image)
dialog.open()
elif button.icon in ['delete', 'delete-sweep']:
dialog_yes = MDFlatButton(text="yes")
dialog_no = MDRaisedButton(text="no")
dialog = MDDialog(text="Delete {} item{}?".format(
len(item), '' if len(item) == 1 else 's'),
buttons=[dialog_no, dialog_yes])
with open('history.json', 'r') as file:
data = json.load(file)
for item_ in item:
data.pop(item_.time)
dialog_no.bind(on_release=dialog.dismiss)
dialog_yes.bind(on_release=dialog.dismiss)
dialog_yes.bind(on_release=lambda button: json.dump(
data, open('history.json', 'w'), indent=4))
dialog_yes.bind(on_release=self.item_check)
dialog.bind(on_dismiss=self.refresh)
dialog.open()
def build(self):
image = Image(source="")
pil_image = PilImage.open("hummingbird.jpg")
imag_data = BytesIO()
pil_image.save(img_data, format="png")
img_data.seek(0)
image.texture = CoreImage(imag_data, ext="png").texture
image.reload()
return image
def show_frame_bgra(self, frame):
buf1 = cv2.flip(frame, 0)
buf = buf1.tostring()
#image_texture = Texture.create(
# size=(frame.shape[1], frame.shape[0]), colorfmt='bgr')
#image_texture.blit_buffer(buf, colorfmt='bgr', bufferfmt='ubyte')
image_texture = Texture.create(size=(frame.shape[1], frame.shape[0]),
colorfmt='bgra')
image_texture.blit_buffer(buf, colorfmt='bgra', bufferfmt='ubyte')
#self.ids.image.texture = image_texture
new_image = Image()
new_image.texture = image_texture
#new_image.color = [1,1,1,self.bg_opacity]
self.ids.screen.add_widget(new_image)
def exibir_imagem(self):
area_imagem = self.ids.area_imagem
area_imagem.clear_widgets()
img_buffer = BytesIO()
ed.img.save(img_buffer, format=ed.img_formato)
img_buffer.seek(0)
co = aImage(img_buffer, ext=ed.img_formato.lower())
textura = co.texture
img_buffer.close()
img = Image()
img.texture = textura
area_imagem.add_widget(img)
def open_mag_glass(self):
Logger.debug('my id=%s' % str(self.id))
mag_glass_setting_x = int(App.get_running_app().config.get('Display', 'mag_glass_size'))
mag_glass_setting_y = int(App.get_running_app().config.get('Display', 'mag_glass_size'))
comic_image_id = self.id.replace('comic_scatter','pi_')
print App.get_running_app().root.ids
try:
for child in self.walk():
print child.id
if child.id == comic_image_id:
image_w = child
Logger.debug('>>>>>Found grandchild named %s this is the image' %comic_image_id)
elif child.id == 'mag_glass':
mag_glass_w = child
except:
Logger.critical('Some bad happened in _call_mag')
else:
print 'image_w = %s' % str(image_w)
if self.move_state == 'open':
self.move_state = 'locked'
self.do_scale=False
self.do_translation=False
Logger.debug('image_w.center = %d,%d' % (image_w.center_x,image_w.center_y))
mag_glass = MagnifyingGlassScatter(size=(mag_glass_setting_x,mag_glass_setting_y),size_hint = (None, None),
do_rotation=False, do_scale=False,
pos=((image_w.center_x-(mag_glass_setting_x/2)),
(image_w.center_y-(mag_glass_setting_y/2))
),id='mag_glass'
)
mag_glass.page_widget = image_w
mag_glass_image = Image(size_hint= (None,None),pos_hint={'x':1, 'y':1},id='mag_image',keep_ratio=True,
allow_stretch=False,size=mag_glass.size )
mag_glass.mag_img = mag_glass_image
mag_glass_image.texture = image_w.texture.get_region(
mag_glass.x,mag_glass.y,mag_glass_setting_x,mag_glass_setting_y)
mag_glass.add_widget(mag_glass_image)
self.add_widget(mag_glass)
else:
self.move_state = 'open'
self.do_scale=True
self.do_translation=True
self.remove_widget(mag_glass_w)
def __init__(self):
super(MainGrid, self).__init__()
encodedimg = decode(SourceData.objects[50].image)
im = PILImage.fromarray(encodedimg)
#im.show()
imgIO = io.BytesIO()
im.save(imgIO, format='JPEG')
imgIO.seek(0)
img = CoreImage(imgIO, ext='jpg')
#new_img = KImage(source="sakimi-chan-rinoa-portrait-tutorial-rinoa.jpg")
new_img = Image()
new_img.texture = img.texture
#new_img.reload()
self.image_wid.texture = img.texture
labels = [
"Sitting Slouched", "Sitting Straight", "Slide left or right",
"Standing Slouched", "Standing Straight"
]
self.add_widget(Label(text="Test"))
layout = GridLayout(cols=len(labels),
pos_hint={
'center_x': .5,
'center_y': .5
})
for i in range(len(labels)):
label = Label(font_size=15,
size_hint_x=None,
width=10,
text=labels[i])
label.bind(size_hint_min_x=label.setter('width'))
scroll = ScrollView(size_hint=(None, None),
size=(100, 100),
pos_hint={
'center_x': .5,
'center_y': .5
})
scroll.add_widget(label)
layout.add_widget(scroll)
self.add_widget(layout)
def get_region(self, pos):
num_wide = self.texture.size[0] / self.tile_size[0]
num_high = self.texture.size[1] / self.tile_size[1]
if num_high == 0 or num_wide == 0:
return (0,0,1,1)
if pos > num_wide * num_high:
return None
#this is an error
else:
#(x,y) = (0,0)
x = pos % num_wide * self.tile_size[0]
y = pos / num_wide * self.tile_size[1]
Logger.info('%d %d %d, %d %d',pos, num_wide, num_high, x, y )
#self.texture = self.image.texture.get_region(x,y,width,height)
r = Image(size=self.tile_size)
r.texture = self.texture.get_region(x,y,self.tile_size[0],self.tile_size[1])
return r
def on_post_processing(self, widget, value):
if not self._init_request[0]:
self._init_request[0] = True
self._init_request[1] = value
return
for children in self.children[:]:
if isinstance(children, Canvas3D) or isinstance(
children, BlurEffectWidget):
self.remove_widget(children)
#for children in self.effect_widget.children[:]:
# self.effect_widget.remove_widget(children)
if value:
self.effect_widget = EffectWidget()
self.effect_widget.add_widget(self.canvas3d)
self.effect_widget.effects = [FXAAEffect()]
self.effect_widget.size = (1366, 768)
effect = Image(size_hint=(1.0, 1.0),
allow_stretch=True,
keep_ratio=False)
effect.texture = self.canvas3d.canvas.texture
self.effect_widget.add_widget(effect)
self.add_widget(self.effect_widget, 100000)
self.remove_widget(self.render_texture)
effect.texture.mag_filter = 'linear'
effect.texture.min_filter = 'linear'
self.effect_widget.texture.mag_filter = 'linear'
self.effect_widget.texture.min_filter = 'linear'
# self.effect_widget.add_widget(self.canvas3d)
# self.effect_widget.effect_mask = self.canvas3d.picking_fbo
# self.add_widget(self.effect_widget)
else:
if self.effect_widget:
if self.canvas3d in self.effect_widget.children:
self.effect_widget.remove_widget(self.canvas3d)
self.remove_widget(self.effect_widget)
self.add_widget(self.canvas3d, 100000)
self.add_widget(self.render_texture, 100000)
def get_region(self, pos):
num_wide = self.texture.size[0] / self.tile_size[0]
num_high = self.texture.size[1] / self.tile_size[1]
if num_high == 0 or num_wide == 0:
return (0, 0, 1, 1)
if pos > num_wide * num_high:
return None
#this is an error
else:
#(x,y) = (0,0)
x = pos % num_wide * self.tile_size[0]
y = pos / num_wide * self.tile_size[1]
Logger.info('%d %d %d, %d %d', pos, num_wide, num_high, x, y)
#self.texture = self.image.texture.get_region(x,y,width,height)
r = Image(size=self.tile_size)
r.texture = self.texture.get_region(x, y, self.tile_size[0],
self.tile_size[1])
return r
def capture(self):
if self.live_capture:
return
frame = snapshot(self.camera_number)
current = self.current_frame
self.frames.insert(self.current_frame, frame)
self.n_frames += 1
if current != 0:
self.ids.frame_slider.value += 1
#self.show_frames()
return
buf1 = cv2.flip(frame, 0)
buf = buf1.tostring()
image_texture = Texture.create(size=(frame.shape[1], frame.shape[0]),
colorfmt='bgr')
image_texture.blit_buffer(buf, colorfmt='bgr', bufferfmt='ubyte')
#self.ids.image.texture = image_texture
new_image = Image()
new_image.texture = image_texture
new_image.color = [1, 1, 1, 0.2]
self.ids.screen.add_widget(new_image)
def on_hover_in(self, sprite_name):
if self.hover_popup.get_parent_window():
return
gc.collect()
main_scr = App.get_running_app().get_main_screen()
char = main_scr.user.get_char()
user_handler = App.get_running_app().get_user_handler()
sprite_option = user_handler.get_chosen_sprite_option()
sprite = char.get_sprite(sprite_name)
main_scr.sprite_settings.apply_post_processing(sprite, sprite_option)
sprite_texture = char.get_sprite(sprite_name).get_texture()
sprite_size = sprite_texture.size
# Can't use absolute position so it uses a workaround
hover_x = self.right / Window.width
hover_y = self.y / Window.height
sprite_size = sprite_size[0] * 0.8, sprite_size[1] * 0.8
im = Image()
im.texture = sprite_texture
im.size = sprite_texture.size
self.hover_popup.add_widget(im)
self.hover_popup.size = sprite_size
self.hover_popup.pos_hint = {'x': hover_x, 'y': hover_y}
self.hover_popup.open()
def display_image(self):
# Set up the screen area to display the images
area_image = self.ids.area_image
area_image.clear_widgets()
# Opening an Image Buffering for image rendering.
# new_buffer = screen_coordinator.screen_img_buffer
new_buffer = BytesIO()
editor_instance.img.save(new_buffer, format=editor_instance.img_format)
new_buffer.seek(0)
# Using a CoreImage instance from the kivy.core.image class to render the display texture.
core_img = CoreImage(new_buffer,
ext=editor_instance.img_format.lower())
texture = core_img.texture
new_buffer.close()
# Displaying the buffered Image.
img = Image()
img.texture = texture
# Adding the image widted to the Editor screen.
area_image.add_widget(img)
def __init__(self, **kwargs):
super(MainScreen, self).__init__(**kwargs)
self.backend = Backend()
self.initialize_keyboard()
"""---------------------A: this section of code controls the appearance of the main window-------------------"""
self.cols = 3
self.rows = 2
self.padding = 20
self.spacing = 10
Window.size = (980, 700)
self.control_down = False
def window_color_updater(instance, value):
self.rect.pos = instance.pos
self.rect.size = instance.size
self.rect2.pos = 20, instance.size[1] - self.rect2.texture.size[
1] - 10
with self.canvas.before:
Color(1, 1, 1, 0.2)
self.rect = Rectangle(pos=self.pos, size=(200, 200))
lable_texture = self.map_title()
self.rect2 = Rectangle(size=lable_texture.size,
texture=lable_texture)
self.bind(size=window_color_updater, pos=window_color_updater)
"""------------B: This section of code creates the tileset control menue and active tile display------------"""
def handle_tileset_select(instance):
target_tileset = self.backend.working_dir + "img_store/tilesets/" + instance.text + ".png"
if target_tileset != self.backend.active_tile_set_file:
self.backend.active_tile_set_file = target_tileset
self.backend.update_active_tileset()
self.redraw_tileset()
if self.backend.check_active_layer_type():
self.backend.layerlist.new_layer(
self.backend.active_tile_set_file,
position=self.backend.active_layer + 1)
self.backend.active_layer += 1
self.populate_layer_list(layer_list)
self.backend.draw_map()
self.redraw_active_tile()
current_set.text = self.backend.active_tile_set_file.split(
'/')[-1]
tileset_dropdown.dismiss()
else:
tileset_dropdown.dismiss()
def open_tile_set_dropdown(instance):
tileset_dropdown.open(instance)
tileset_menue = GridLayout(size_hint=(None, None),
size=(300, 100),
spacing=20,
pos_hint=(None, 1),
cols=3)
tileset_select_shell = FloatLayout(size=(175, 100),
size_hint=(None, None))
tileset_dropdown = DropDown()
available_sets = os.listdir(self.backend.working_dir +
'img_store/tilesets')
for i in available_sets:
set_name = i[:len(i) - 4]
set_btn = Button(text=set_name, size_hint_y=None, height=44)
set_btn.bind(on_press=handle_tileset_select)
tileset_dropdown.add_widget(set_btn)
tileset_dropdown_btn = Button(text="Select",
size=(175, 27),
size_hint=(None, None),
pos_hint={
'x': 0,
'y': .2
})
tileset_dropdown_btn.bind(on_release=open_tile_set_dropdown)
current_set = Label(
text=self.backend.active_tile_set_file.split('/')[-1],
size=(175, 25),
size_hint=(None, None),
pos_hint={
'x': 0,
'y': .5
})
tileset_select_shell.add_widget(current_set)
tileset_select_shell.add_widget(tileset_dropdown_btn)
tileset_menue.add_widget(tileset_select_shell)
tileset_menue.add_widget(Label(text="Active\nTile:", font_size='18sp'))
active_tile_display = KvyImage()
active_tile_display.texture = self.get_texture(
self.backend.get_active_tile_image())
tileset_menue.add_widget(active_tile_display)
self.add_widget(tileset_menue)
"""-------------C: This section of code creates the map space control buttons and drawing tools--------------"""
map_control = GridLayout(cols=5,
size=(100, 100),
size_hint=(1, None),
padding=20,
spacing=5,
rows=2)
def alter_map(instance):
if instance.text == "Resize":
self.popup_constructor_size("Resize Map").open()
else:
self.popup_constructor_size(
"New Map: !!UNSAVED PROGRESS WILL BE LOST!!").open()
def save_load_export(instance):
if instance.text == "Save":
self.popup_constructor_file("Save Map")
if instance.text == "Load":
self.popup_constructor_file("Load Map")
if instance.text == "Export":
self.popup_constructor_file("Export Map")
resize_map_btn = Button(text="Resize")
new_map_btn = Button(text="New")
save_btn = Button(text="Save")
load_btn = Button(text="Load")
export_btn = Button(text="Export")
resize_map_btn.bind(on_press=alter_map)
new_map_btn.bind(on_press=alter_map)
for button in [save_btn, load_btn, export_btn]:
button.bind(on_press=save_load_export)
for button in [
new_map_btn, resize_map_btn, save_btn, load_btn, export_btn
]:
map_control.add_widget(button)
def tool_logic(instance):
if instance.text == "Grid":
self.backend.grid_toggle = 1 if self.backend.grid_toggle == 0 else 0
self.backend.undo_tracker += -1
self.backend.undo_array = self.backend.undo_array[0:-1]
self.redraw_map()
if self.backend.grid_toggle:
tool_buttons[0].background_color = (0.5, 0.5, 0.5, 1.0)
else:
tool_buttons[0].background_color = (1.0, 1.0, 1.0, 1.0)
if instance.text == "Fill":
self.backend.fill_toggle = 1 if self.backend.fill_toggle == 0 else 0
self.backend.square_toggle = 0
self.redraw_map()
if self.backend.fill_toggle:
tool_buttons[1].background_color = (0.5, 0.5, 0.5, 1.0)
tool_buttons[2].background_color = (1.0, 1.0, 1.0, 1.0)
else:
tool_buttons[1].background_color = (1.0, 1.0, 1.0, 1.0)
if instance.text == "Sqr":
self.backend.square_toggle = 1 if self.backend.square_toggle == 0 else 0
self.backend.fill_toggle = 0
if self.backend.square_toggle:
tool_buttons[2].background_color = (0.5, 0.5, 0.5, 1.0)
tool_buttons[1].background_color = (1.0, 1.0, 1.0, 1.0)
else:
tool_buttons[2].background_color = (1.0, 1.0, 1.0, 1.0)
if instance.text == "2x":
self.backend.zoom_mod = 2 if self.backend.zoom_mod != 2 else 1
self.backend.undo_tracker += -1
self.backend.undo_array = self.backend.undo_array[0:-1]
self.redraw_map()
if self.backend.zoom_mod == 2:
tool_buttons[3].background_color = (0.5, 0.5, 0.5, 1.0)
tool_buttons[4].background_color = (1.0, 1.0, 1.0, 1.0)
else:
tool_buttons[3].background_color = (1.0, 1.0, 1.0, 1.0)
if instance.text == ".5x":
self.backend.zoom_mod = 0.5 if self.backend.zoom_mod != 0.5 else 1
self.backend.undo_tracker += -1
self.backend.undo_array = self.backend.undo_array[0:-1]
self.redraw_map()
if self.backend.zoom_mod == 0.5:
tool_buttons[4].background_color = (0.5, 0.5, 0.5, 1.0)
tool_buttons[3].background_color = (1.0, 1.0, 1.0, 1.0)
else:
tool_buttons[4].background_color = (1.0, 1.0, 1.0, 1.0)
elif instance.text == "Img":
self.popup_constructor_file('Import Image')
tool_buttons = []
for tool in [
'Grid',
'Fill',
'Sqr',
'2x',
'.5x',
'Img',
]:
tool_btn = Button(text=tool)
tool_btn.bind(on_press=tool_logic)
tool_buttons.append(tool_btn)
for i in range(0, 6, 2):
button_shell = GridLayout(cols=2, spacing=5)
button_shell.add_widget(tool_buttons[i])
button_shell.add_widget(tool_buttons[i + 1])
map_control.add_widget(button_shell)
self.add_widget(map_control)
"""-------------------------D: This section of code creates an important spacer label------------------------"""
self.add_widget(
Label(text="\n\n\n\n[b]Layer Menue[/b]",
markup=True,
text_size=(200, 100),
font_size='20dp',
size_hint=(None, None),
size=(200, 100),
pos_hint=(1, 0)))
"""---------------E: This section of code creates the scrollable viewers for the map and tileset-------------"""
map_scroller = self.get_map_scroller()
tile_scroller = self.get_tileset_scroller()
tileset = TilesetView(backend=self.backend, size_hint=(None, None))
map_image = MapView(backend=self.backend, size_hint=(None, None))
map_scroller.add_widget(map_image)
tile_scroller.add_widget(tileset)
self.add_widget(tile_scroller)
self.add_widget(map_scroller)
tileset.texture = self.get_texture(self.backend.active_tile_set)
map_image.texture = self.get_texture(self.backend.draw_map())
tileset.size = tileset.texture.size
map_image.size = map_image.texture.size
cursor_size = (self.backend.layerlist.get_grid_res(),
self.backend.layerlist.get_grid_res())
cursor_size = tuple(val * self.backend.zoom_mod for val in cursor_size)
map_cursor = Button(text="", size=cursor_size)
tile_cursor = Button(text="", size=cursor_size)
map_image.add_widget(map_cursor)
tileset.add_widget(tile_cursor)
def cursor_polling(instance, pos):
res = self.backend.layerlist.get_grid_res()
if map_scroller.collide_point(*pos):
res = self.backend.layerlist.get_grid_res(
) * self.backend.zoom_mod
pos = map_scroller.to_local(*pos)
if map_image.collide_point(*pos):
tile_cursor.background_color = [0, 0, 0, 0]
map_cursor.background_color = [0, 0, 1, 0.3]
map_cursor.size = tuple(
val * self.backend.zoom_mod
for val in self.backend.active_tile_image.size)
if self.backend.check_active_layer_type():
pos = (pos[0] // res) * res, (pos[1] // res) * res - (
map_cursor.size[1] - res)
else:
pos = pos[0] - map_cursor.size[1] / 2, pos[1] - \
map_cursor.size[1] / 2
map_cursor.pos = pos
else:
map_cursor.background_color = [0, 0, 0, 0]
elif tile_scroller.collide_point(*pos):
pos = tile_scroller.to_local(*pos)
if tileset.collide_point(*pos):
tile_cursor.background_color = [0, 1, 0, 0.5]
map_cursor.background_color = [0, 0, 0, 0]
tile_cursor.size = cursor_size
pos = (pos[0] // res) * res, (pos[1] // res) * res
tile_cursor.pos = pos
else:
tile_cursor.background_color = [0, 0, 0, 0]
Window.bind(mouse_pos=cursor_polling)
"""-------------------------F: This section of code creates the layer control panel--------------------------"""
layer_control_shell = GridLayout(rows=2,
size_hint=(None, 1),
size=(200, 200))
layer_control_panel = GridLayout(rows=3,
cols=3,
size_hint=(None, None),
size=(200, 40),
pos=self.size,
pos_hint=(None, None))
layer_list = GridLayout(rows=1,
cols=1,
size=(200, 1),
size_hint=(None, 1))
def modify_layer_list(instance):
"""
This method handles button presses on the layer control buttons.
:param instance:
:return:
"""
if instance.text == "New":
self.backend.layerlist.new_layer(
self.backend.active_tile_set_file,
position=self.backend.active_layer + 1)
self.backend.active_layer += 1
elif instance.text == "Delete":
self.backend.layerlist.del_layer(self.backend.active_layer)
self.backend.active_layer += -1
if self.backend.active_layer < 1:
if len(self.backend.layerlist.stack) <= 1:
self.backend.layerlist.new_layer(
self.backend.active_tile_set_file)
self.backend.active_layer += 1
else:
self.backend.active_layer = 1
self.backend.active_tile_set_file = self.backend.layerlist.get_layer(
self.backend.active_layer).tileset
self.backend.update_active_tileset()
self.redraw_active_tile()
self.redraw_tileset()
elif instance.text == "Up":
if self.backend.active_layer > 1:
self.backend.layerlist.move_up(self.backend.active_layer)
self.backend.active_layer += -1
elif instance.text == "Down":
if self.backend.active_layer < len(
self.backend.layerlist.stack) - 1:
self.backend.layerlist.move_down(self.backend.active_layer)
self.backend.active_layer += 1
elif instance.text == "Rename":
self.popup_constructor_rename().open()
else:
self.backend.layerlist.add_image_layer(
self.backend.active_tile_set_file,
position=self.backend.active_layer + 1)
self.backend.active_layer += 1
self.populate_layer_list(layer_list)
self.redraw_map()
new_layer_btn = Button(text="New")
del_layer_btn = Button(text="Delete")
new_layer_btn.bind(on_press=modify_layer_list)
del_layer_btn.bind(on_press=modify_layer_list)
up_btn = Button(text="Up")
down_btn = Button(text="Down")
rename_btn = Button(text="Rename")
freedraw_btn = Button(text="Unsnap")
for button in [
rename_btn, new_layer_btn, up_btn, freedraw_btn, del_layer_btn,
down_btn
]:
button.bind(on_press=modify_layer_list)
layer_control_panel.add_widget(button)
layer_control_shell.add_widget(layer_control_panel)
self.populate_layer_list(layer_list)
layer_control_shell.add_widget(layer_list)
self.add_widget(layer_control_shell)
def play_song(self, i):
try:
self.stop()
except:
pass
link = self.down_path_list[i][0]
if self.root.ids.screen_manager.current != 'PlayScreen':
self.change_screen("PlayScreen")
self.prepare(link)
if link.endswith('.m4a'):
self.audio = MP4(link)
self.play_song_name = self.audio.get('\xa9nam', ['Unknown'])[0]
#print(audio['\xa9alb'])
self.play_art_name = self.audio.get('\xa9ART', ['Unknown'])[0]
#print(audio['\xa9day'])
#print(audio['\xa9gen'])
try:
self.img_data = self.audio["covr"][0]
except:
with open('cover.jpg', 'rb') as f:
self.img_data = f.read()
elif link.endswith('.mp3'):
self.audio = MP3(link, ID3=EasyID3)
self.audio_tags = ID3(link)
self.play_song_name = self.audio.get('title', ['Unknown'])[0]
self.play_art_name = self.audio.get('artist', ['Unknown'])[0]
try:
self.img_data = self.audio_tags.get("APIC:").data
except:
with open('cover.jpg', 'rb') as f:
self.img_data = f.read()
else:
with open('cover.jpg', 'rb') as f:
self.img_data = f.read()
self.play_song_name = 'Unknown'
self.play_art_name = 'Unknown'
play_image_data = io.BytesIO(self.img_data)
img = CoreImage(play_image_data, ext="jpg").texture
song_image = Image(allow_stretch=True)
song_image.texture = img
self.root.ids.PlayScreen.clear_widgets()
self.root.ids.PlayScreen.add_widget(
MDIconButton(icon='chevron-left',
pos_hint={
"center_x": 0.05,
"center_y": 0.95
},
on_press=lambda x: self.back_screen()))
card = MDCard(orientation='vertical',
pos_hint={
"center_x": 0.5,
"center_y": 0.65
},
size_hint=(None, None),
size=(self.win_size * 0.9, self.win_size * 0.9))
card.add_widget(song_image)
self.root.ids.PlayScreen.add_widget(card)
self.root.ids.PlayScreen.add_widget(
MDLabel(text=self.play_song_name,
halign='center',
theme_text_color='Custom',
text_color=self.theme_cls.primary_color,
font_style='H4',
bold=True,
pos_hint={"top": 0.84}))
self.root.ids.PlayScreen.add_widget(
MDLabel(text=self.play_art_name,
halign='center',
theme_text_color='Secondary',
font_style='H6',
pos_hint={"top": 0.8}))
self.play_progress = MDProgressBar(pos_hint={
'center_x': 0.5,
'center_y': 0.25
},
size_hint_x=0.9,
value=0,
color=self.theme_cls.primary_color)
self.root.ids.PlayScreen.add_widget(self.play_progress)
self.root.ids.PlayScreen.add_widget(
MDIconButton(icon="chevron-double-left",
pos_hint={
"center_x": .15,
"center_y": .15
},
user_font_size="40sp",
on_release=lambda x: self.rewind()))
self.root.ids.PlayScreen.add_widget(
MDIconButton(icon="chevron-double-right",
pos_hint={
"center_x": .85,
"center_y": .15
},
user_font_size="40sp",
on_release=lambda x: self.forward()))
self.next_button = MDIconButton(
icon="skip-next",
pos_hint={
"center_x": .65,
"center_y": .15
},
user_font_size="55sp",
on_release=lambda x: self.play_song(i + 1))
self.root.ids.PlayScreen.add_widget(self.next_button)
self.previous_button = (MDIconButton(
icon="skip-previous",
pos_hint={
"center_x": .35,
"center_y": .15
},
user_font_size="55sp",
on_release=lambda x: self.play_song(i - 1)))
self.root.ids.PlayScreen.add_widget(self.previous_button)
self.play_btn = MDFloatingActionButton(
icon='play',
pos_hint={
'center_x': 0.5,
"center_y": 0.15
},
user_font_size="50sp",
md_bg_color=(1, 1, 1, 1),
elevation_normal=10,
on_press=lambda x: self.play_song_offline(i))
self.root.ids.PlayScreen.add_widget(self.play_btn)
self.length_stamp = MDLabel(text=self.convert_sec(
self.sound.getDuration()),
halign='right',
theme_text_color='Secondary',
padding_x='20dp',
pos_hint={"top": 0.725})
self.root.ids.PlayScreen.add_widget(self.length_stamp)
self.play_stamp = (MDLabel(text=self.convert_sec(
self.sound.getCurrentPosition()),
halign='left',
theme_text_color='Secondary',
padding_x='20dp',
pos_hint={"top": 0.725}))
self.root.ids.PlayScreen.add_widget(self.play_stamp)
self.play_song_offline(i)
def _proxy_loaded(self,proxyImage):
if proxyImage.image.texture:
x = Image(size=(130,200),allow_stretch=False,size_hint=(None, None))
x.texture = proxyImage.image.texture
Clock.schedule_once(partial(self.save_cover,x), .05)
def _image_downloaded(self, widget ,comicstream_number, proxyImage,):
'''Fired once the image is downloaded and ready to use'''
if proxyImage.image.texture:
base_url = App.get_running_app().config.get('Server', 'url')
src_thumb = "%s/comic/%d/page/%d?max_height=200#.jpg" % (base_url, comicstream_number, self._index)
app = App.get_running_app()
inner_grid_id ='inner_grid' + str(self._index)
page_image_id = str(self._index)
split_dbl_page = App.get_running_app().config.get('Display', 'dblpagesplit')
if proxyImage.image.texture.width > 2*Window.width and split_dbl_page == '1':
m_win_x = Window.width
m_win_y = Window.height
self.texture = proxyImage.image.texture
c_width = self.texture.width
c_height = self.texture.height
part_1 = Image()
part_1_thumb = Image()
scatter = ComicScatter(do_rotation=False, do_scale=False,do_translation_x=False,
id='comic_scatter'+str(self._index)+'b',scale_min=1, scale_max=2,
size_hint=(None,None), size = (m_win_x,m_win_y),
)
part_2 = ComicImage(_index=self._index+1,nocache=False,keep_ratio=False,allow_stretch=True,
id='pi_'+str(self._index)+'b',size_hint = (None,None),size=self.size
)
scatter.add_widget(part_2)
part_1.texture = proxyImage.image.texture.get_region(0,0,c_width/2,c_height)
part_2.texture = proxyImage.image.texture.get_region((c_width/2+1),0,c_width/2,c_height)
self.texture = part_1.texture
app.root.ids['comicscreenid'].ids['my_carousel'].add_widget(scatter,self._index+1)
inner_grid = GridLayout(cols=1, rows =2,id='inner_grid'+str(self._index),size_hint=(None,None),
size=(130,200), spacing=5)
page_thumb = PageThumbImage(allow_stretch=True,
size=(130,200),size_hint=(None, None),id=str(self._index),_index=self._index)
page_thumb.texture = part_1.texture
inner_grid.add_widget(page_thumb)
page_thumb.parent.bind(pos=app.root.setter('pos'))
page_thumb.parent.bind(pos=app.root.setter('pos'))
page_thumb.bind(on_press=app.root.pop.dismiss)
page_thumb.bind(on_press=page_thumb.click)
smbutton = Button(size_hint=(None,None),size=(10,10),text='P%sa'%str(self._index+1),text_color=(0,0,0),
background_color=(1,1,1,.5))
inner_grid.add_widget(smbutton)
widget.add_widget(inner_grid)
inner_grid = GridLayout(cols=1, rows =2,id='inner_grid'+str(self._index+1),size_hint=(None,None),
size=(130,200), spacing=5)
part_2_thumb = PageThumbImage(allow_stretch=True,
size=(130,200),size_hint=(None, None),id=str(self._index+1),_index=self._index+1)
part_2_thumb.texture =part_2.texture
inner_grid.add_widget(part_2_thumb)
Logger.debug('ok it did it')
part_2_thumb.parent.bind(pos=app.root.setter('pos'))
part_2_thumb.parent.bind(pos=app.root.setter('pos'))
part_2_thumb.bind(on_press=app.root.pop.dismiss)
part_2_thumb.bind(on_press=part_2_thumb.click)
smbutton = Button(size_hint=(None,None),size=(10,10),text='P%sb'%str(self._index+1) ,text_color=(0,0,0),
background_color=(1,1,1,.5))
inner_grid.add_widget(smbutton)
widget.add_widget(inner_grid)
else:
if proxyImage.image.texture.width > 2*Window.width:
self.size_hint=(2,1)
self.texture = proxyImage.image.texture
inner_grid = GridLayout(cols=1, rows =2,id='inner_grid'+str(self._index),size_hint=(None,None),
size=(130,200), spacing=5)
page_thumb = PageThumbImage(source=src_thumb,allow_stretch=True,
size=(130,200),size_hint=(None, None),id=str(self._index),_index=self._index)
inner_grid.add_widget(page_thumb)
page_thumb.parent.bind(pos=app.root.setter('pos'))
page_thumb.parent.bind(pos=app.root.setter('pos'))
page_thumb.bind(on_press=app.root.pop.dismiss)
page_thumb.bind(on_press=page_thumb.click)
smbutton = Button(size_hint=(None,None),size=(10,10),text='P%s'%str(self._index+1),text_color=(0,0,0),
background_color=(1,1,1,.5))
inner_grid.add_widget(smbutton)
widget.add_widget(inner_grid)
def open_mag_glass(self):
Logger.debug("my id=%s" % str(self.id))
mag_glass_setting_x = int(App.get_running_app().config.get(
"Display", "mag_glass_size"))
mag_glass_setting_y = int(App.get_running_app().config.get(
"Display", "mag_glass_size"))
comic_image_id = self.id.replace("comic_scatter", "pi_")
try:
for child in self.walk():
if child.id == comic_image_id:
image_w = child
Logger.debug(">>>>>gc named %s this is the image" %
comic_image_id)
elif child.id == "mag_glass":
mag_glass_w = child
except Exception:
Logger.critical("Some bad happened in _call_mag")
else:
if self.move_state == "open":
self.move_state = "locked"
self.do_scale = False
self.do_translation = False
Logger.debug("image_w.center = %d,%d" %
(image_w.center_x, image_w.center_y))
mag_glass = MagnifyingGlassScatter(
size=(mag_glass_setting_x, mag_glass_setting_y),
size_hint=(None, None),
do_rotation=False,
do_scale=False,
pos=(
(image_w.center_x - (mag_glass_setting_x / 2)),
(image_w.center_y - (mag_glass_setting_y / 2)),
),
id="mag_glass",
)
mag_glass.page_widget = image_w
mag_glass_image = Image(
size_hint=(None, None),
pos_hint={
"x": 1,
"y": 1
},
id="mag_image",
keep_ratio=True,
allow_stretch=False,
size=mag_glass.size,
)
mag_glass.mag_img = mag_glass_image
mag_glass_image.texture = image_w.texture.get_region(
mag_glass.x,
mag_glass.y,
mag_glass_setting_x,
mag_glass_setting_y,
)
mag_glass.add_widget(mag_glass_image)
self.add_widget(mag_glass)
else:
self.move_state = "open"
self.do_scale = True
self.do_translation = True
self.remove_widget(mag_glass_w)
