def main():
#p = Project()
#root = p.load('./example_project.py')
#p.append(root, "root")
#p.save(None)
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(Editor, debug=False, address='0.0.0.0', port=8082)
from remi import start, App
class MyApp(App):
def __init__(self, *args):
super(MyApp, self).__init__(*args)
def main(self):
container = gui.VBox(width=120, height=100)
self.lbl = gui.Label('Hello world!')
self.bt = gui.Button('Press me!')
# setting the listener for the onclick event of the button
self.bt.onclick.connect(self.on_button_pressed)
# appending a widget to another, the first argument is a string key
container.append(self.lbl)
container.append(self.bt)
# returning the root widget
return container
# listener function
def on_button_pressed(self, widget):
self.lbl.set_text('Button pressed!')
self.bt.set_text('Hi!')
# starts the web server
start(MyApp)
class MyApp(App):
def __init__(self, *args):
res_path = os.path.join(os.path.dirname(__file__), 'res')
super(MyApp, self).__init__(*args, static_file_path=res_path)
def idle(self):
pass
def main(self):
self.floatingPaneContainer = FloatingPanesContainer(width=800, height=600, margin='0px auto')
self.floatingPaneContainer.append(gui.Label("Click a panel to select, than drag and stretch"))
pane1 = gui.Widget(width=100, height=200)
pane1.style['background-color'] = 'yellow'
self.floatingPaneContainer.add_pane(pane1, 10, 100)
pane1.append(gui.Label("Panel1, drag and stretch"))
pane2 = gui.VBox(width=100, height=200)
pane2.style['background-color'] = 'green'
self.floatingPaneContainer.add_pane(pane2, 150, 100)
pane2.append(gui.Label("Panel2, drag and stretch"))
# returning the root widget
return self.floatingPaneContainer
if __name__ == "__main__":
start(MyApp, debug=False, address='0.0.0.0', port=8082, update_interval=2.0)
def main(self, name='world'):
# the arguments are width - height - layoutOrientationOrizontal
wid = gui.Widget(120, 100, False, 10)
self.lbl = gui.Label(100, 30, 'Hello %s!' % name)
self.bt = gui.Button(100, 30, 'Press me!')
# setting the listener for the onclick event of the button
self.npressed = 0
self.bt.set_on_click_listener(self, 'on_button_pressed')
# appending a widget to another, the first argument is a string key
wid.append(self.lbl)
wid.append(self.bt)
# returning the root widget
return wid
# listener function
def on_button_pressed(self):
self.npressed += 1
self.lbl.set_text('Button pressed %s times' % self.npressed)
self.bt.set_text('Hi!')
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=False)
def conf_continue(self,result):
if result is True:
# print 'dialog confirm'
result=self.t1field1.get_value()
self.t1f1_field.set_text('Tab1 Field1: '+result)
result=self.t2field1.get_value()
self.t2f1_field.set_text('Tab2 Field1: '+result)
self.tabbed_dialog.hide()
OKDialog('Tabbed Editor','Saved').show(self)
else:
OKDialog('Tabbed Editor','Not Saved').show(self)
#
# ***************************************
# MAIN
# ***************************************
if __name__ == "__main__":
# setting up remi debug level
# 2=all debug messages 1=error messages 0=no messages
import remi.server
remi.server.DEBUG_MODE = 2
# start the web server to serve the App
start(Tabbed,address='127.0.0.1', port=8082,
multiple_instance=False,enable_file_cache=True,
update_interval=0.1, start_browser=False)
self.lbl.set_text('New color value: ' + value)
def date_changed(self, widget, value):
self.lbl.set_text('New date value: ' + value)
def menu_save_clicked(self, widget):
self.lbl.set_text('Menu clicked: Save')
def menu_saveas_clicked(self, widget):
self.lbl.set_text('Menu clicked: Save As')
def menu_open_clicked(self, widget):
self.lbl.set_text('Menu clicked: Open')
def menu_view_clicked(self, widget):
self.lbl.set_text('Menu clicked: View')
def fileupload_on_success(self, widget, filename):
self.lbl.set_text('File upload success: ' + filename)
def fileupload_on_failed(self, widget, filename):
self.lbl.set_text('File upload failed: ' + filename)
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True, address='0.0.0.0', start_browser=True)
b1 = gui.Button('Show second tab', width=200, height=30)
tb = gui.TabBox(width='80%')
tb.add_tab(b1, 'First', None)
b2 = gui.Button('Show third tab', width=200, height=30)
tb.add_tab(b2, 'Second', None)
b3 = gui.Button('Show first tab', width=200, height=30)
tb.add_tab(b3, 'Third', None)
b1.onclick.do(self.on_bt1_pressed, tb, b2)
b2.onclick.do(self.on_bt2_pressed, tb, 'Third')
b3.onclick.do(self.on_bt3_pressed, tb, 0)
return tb
def on_bt1_pressed(self, widget, tabbox, refWidgetTab):
tabbox.select_by_widget(refWidgetTab)
def on_bt2_pressed(self, widget, tabbox, refWidgetTabName):
tabbox.select_by_name(refWidgetTabName)
def on_bt3_pressed(self, widget, tabbox, tabIndex):
tabbox.select_by_index(tabIndex)
if __name__ == "__main__":
start(MyApp, title="Tab Demo", standalone=False)
import remi.gui as gui
from remi import start, App
import os
class MyApp(App):
def __init__(self, *args):
res_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'res')
#static_file_path can be an array of strings allowing to define
# multiple resource path in where the resources will be placed
super(MyApp, self).__init__(*args, static_file_path=res_path)
def idle(self):
""" Idle loop, you can place here custom code,
avoid to use infinite iterations, it would stop gui update.
This is a Thread safe method where you can update the
gui with information from external Threads.
"""
pass
def main(self):
#creating a container VBox type, vertical (you can use also HBox or Widget)
main_container = gui.VBox(width=300, height=200, style={'margin':'0px auto'})
# returning the root widget
return main_container
if __name__ == "__main__":
# starts the webserver
start(MyApp, address='0.0.0.0', port=0, start_browser=True, username=None, password=None)
choices=['dev', 'production'])
parser.add_argument(
"--port",
help="specify the port number to launch on, only used in dev mode",
default=8081)
parser.add_argument(
"--skip",
help=
"flag for specifying whether to skip the classifier if we get an error",
action="store_true")
args = parser.parse_args()
if (args.skip):
convert_transcript.skipClassifier = True
#process all the transcripts waiting to be processed
convert_transcript.batchProcessTranscripts(BASEPATH, METAPATH, True)
if (args.launchMode == 'dev'):
start(DTApp,
debug=True,
address='0.0.0.0',
port=args.port,
start_browser=False,
multiple_instance=True)
if (args.launchMode == 'production'):
start(DTApp,
debug=True,
address='0.0.0.0',
port=80,
start_browser=False,
multiple_instance=True)
super(MyApp, self).__init__(*args)
def main(self):
wid = gui.VBox(width=320, height=320, margin='0px auto')
wid.style['text-align'] = 'center'
bt = gui.Button('Data', width=100, height=30)
bt.style['margin'] = '10px'
bt.onclick.do(self.on_button_pressed)
self.plot_data = [0, 1]
self.mpl = MatplotImage(width=250, height=250)
self.mpl.style['margin'] = '10px'
self.mpl.ax.set_title("test")
self.mpl.ax.plot(self.plot_data)
self.mpl.redraw()
wid.append(bt)
wid.append(self.mpl)
return wid
def on_button_pressed(self, widget):
self.plot_data.append(random.random())
self.mpl.ax.plot(self.plot_data)
self.mpl.redraw()
if __name__ == "__main__":
start(MyApp, debug=True, address='0.0.0.0', port=0)
def main(self):
#creating a container VBox type, vertical
wid = gui.VBox(width=300, height=200)
#creating a text label
self.lbl = gui.Label('Hello', width='80%', height='50%')
#a button for simple interaction
bt = gui.Button('Press me!', width=200, height=30)
#setting up the listener for the click event
bt.onclick.connect(self.on_button_pressed)
#adding the widgets to the main container
wid.append(self.lbl)
wid.append(bt)
# returning the root widget
return wid
# listener function
def on_button_pressed(self, emitter):
self.lbl.set_text('Hello World!')
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True)
self.steamSwitch._checkbox.set_value(self.steam)
time.sleep(0.25)
self.switchContainer.remove_child(self.dummyUpdated)
self.switchContainer.append(self.dummyUpdated)
def display_counter(self):
self.counter.set_text('Running Time: ' + str(self.count))
self.count += 1
threading.Timer(1, self.display_counter).start()
def temperature_display(self):
currentTemp = self.tempProbe.getTemp() + self.calibrationOffset
self.boilerTemp = "{:.2f}".format(float(currentTemp))
self.tempLabel.set_text(str(self.boilerTemp))
threading.Timer(0.5, self.temperature_display).start()
def on_button_pressed(self):
self.lbl.set_text('Button pressed! ')
self.bt.set_text('Hi!')
def on_spin_change(self, newValue):
self.lbl.set_text('SpinBox changed, new value: ' + str(newValue))
def slider_changed(self, value):
self.lbl.set_text('New slider value: ' + str(value))
if __name__ == "__main__":
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(Espresso, debug=True, address='0.0.0.0')
def turn_on_button(self, emitter, tabIndex):
self.onofflabel.set_text("Current status: On")
def shutdown_button(self, _):
self.process_label.set_text("Bye!")
self.do_gui_update()
self.close()
def my_algorithm(self):
while self.thread_alive_flag:
self.my_thread_result = returntime()
def my_2algorithm(self):
while self.thread_alive_flag:
self.my_thread_result2 = myrandomfunction()
self.do_gui_update()
def start_thread(self):
self.thread_alive_flag = True
self.my_thread_result = 'n/a'
t = threading.Thread(target=self.my_algorithm)
t.start()
if __name__ == "__main__":
start(MyApp, debug=True, update_interval=.5)
mainContainer.children['pulseWidthValue'].onclick.do(
self.onclick_pulseWidthValue)
self.mainContainer = mainContainer
return self.mainContainer
def onclick_pulseWidthValue(self, emitter):
pass
#Configuration
configuration = {
'config_project_name': 'timeCorrelatedMeasurements',
'config_address': '0.0.0.0',
'config_port': 8081,
'config_multiple_instance': True,
'config_enable_file_cache': True,
'config_start_browser': True,
'config_resourcepath': './res/'
}
if __name__ == "__main__":
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(timeCorrelatedMeasurements,
address=configuration['config_address'],
port=configuration['config_port'],
multiple_instance=configuration['config_multiple_instance'],
enable_file_cache=configuration['config_enable_file_cache'],
start_browser=configuration['config_start_browser'])
u=u.reshape(int(bm_description['visible_height']),int(bm_description['buffer_width']))
v=numpy.empty(bm_frame_size//2, dtype=numpy.uint8)
v[0::2]=bm_raw_img[2::4]
v[1::2]=bm_raw_img[2::4]
v=v.reshape(int(bm_description['visible_height']),int(bm_description['buffer_width']))
raw_yuv=numpy.dstack((y,u,v))[:,0:int(bm_description['visible_width']),:]
bm_rgb=cv2.cvtColor(raw_yuv, cv2.COLOR_YUV2BGR)
if bmo_description['data_start'] >0:
bmo_raw_img=numpy.fromfile(myFile, dtype=numpy.int32, count=bmo_frame_size)
myFile.close()
if vp_rgb.shape[0]==408: # Workaround for video mode
extension=numpy.zeros((480,720,3))
extension[36:444, :, :]=vp_rgb # (480-408)/2:480-(480-408)/2, :, :
vp_rgb=extension
return vp_rgb, bm_rgb
def exec_lua(self, widget, value):
try:
self.camera.lua_execute(str(self.lua_value.get_value())+'\n' \
'press("shoot_half")\n' \
'repeat\n' \
' sleep(10)\n' \
'until get_shooting()\n' \
'return')
self.status_label.set_text('Done')
except:
self.status_label.set_text('Error executing LUA')
if __name__ == "__main__":
start(M10GUI, address='0.0.0.0', port=8081, multiple_instance=False, enable_file_cache=True, start_browser=False, debug=False, update_interval = 0.01)
from remi import start, App
from simple_app import MyApp
if __name__ == "__main__":
start(MyApp, standalone=True)
self.dropdown.append(str(i), gui.DropDownItem(200, 20, s))
step_selec.append('0', self.dropdown)
self.img = gui.Image(300, 300, '/res/logo.png')
step_selec.append('1', self.img)
# Second row - Detect / Motor info
motor_info = gui.Widget(350, 500, gui.Widget.LAYOUT_VERTICAL, 10)
self.table = gui.Table(300, 200)
self.table.from_2d_matrix([['ID', 'First Name', 'Last Name'],
['101', 'Danny', 'Young'],
['102', 'Christine', 'Holand'],
['103', 'Lars', 'Gordon'],
['104', 'Roberto', 'Robitaille'],
['105', 'Maria', 'Papadopoulos']])
motor_info.append('0', self.table)
self.configure_btn = gui.Button(200, 30, 'CONFIGURE')
motor_info.append('1', self.configure_btn)
mc.append('0', step_selec)
mc.append('1', motor_info)
self.wid.append('1', self.title_label)
self.wid.append('2', mc)
return self.wid
start(Werborist)
qr_code_data = qr_code_list[0][0].decode('utf-8')
self.qr_label.set_text(qr_code_data)
return
def main(self):
self.video_widgets()
screen = [self.video]
start_button = gui.Button('Start Video')
start_button.onclick.do(self.video_start, 'process_image')
screen.append(start_button)
stop_button = gui.Button('Stop Video')
stop_button.onclick.do(self.video_stop)
screen.append(stop_button)
self.qr_label = gui.Label('No QR code detected')
screen.append(self.qr_label)
return gui.VBox(children=screen)
if __name__ == "__main__":
start(Camera,
certfile='./ssl_keys/fullchain.pem',
keyfile='./ssl_keys/privkey.pem',
ssl_version=ssl.PROTOCOL_TLSv1_2,
address='0.0.0.0',
port=2020,
multiple_instance=True,
enable_file_cache=True,
start_browser=False,
debug=False)
print("tag deleted")
def onkeydown(self, keypressed):
if keypressed==46: #46 the delete keycode
self.toolbar_delete_clicked()
print("Key pressed: " + str(keypressed))
#function overload for widgets that have to be editable
#the normal onfocus function does not returns the widget instance
#def onfocus_with_instance(self):
# return self.eventManager.propagate(self.EVENT_ONFOCUS, [self])
def onclick_with_instance(self):
#return self.eventManager.propagate(self.EVENT_ON_WIDGET_SELECTION, [self])
self.editor.on_widget_selection(self)
def on_dropped(self, left, top):
self.style['left']=left
self.style['top']=top
if __name__ == "__main__":
#p = Project()
#root = p.load('./example_project.py')
#p.append(root, "root")
#p.save(None)
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(Editor, debug=False, port=8082)
for coord in [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1],
[1, -1], [1, 0], [1, 1]]:
_x, _y = coord
if not self.coord_in_map(cell.x + _x, cell.y + _y):
continue
if not self.mine_matrix[cell.y + _y][cell.x +
_x].opened:
self.mine_matrix[cell.y + _y][cell.x +
_x].check_mine(False)
checked_cells.append(
self.mine_matrix[cell.y + _y][cell.x + _x])
def explosion(self, cell):
print("explosion")
self.mine_table = gui.Table()
self.main_container.append(self.mine_table, key="mine_table")
for x in range(0, len(self.mine_matrix[0])):
for y in range(0, len(self.mine_matrix)):
self.mine_matrix[y][x].style['background-color'] = 'red'
self.mine_matrix[y][x].check_mine(False)
self.mine_table.from_2d_matrix(self.mine_matrix, False)
if __name__ == "__main__":
start(MyApp,
multiple_instance=False,
address='0.0.0.0',
port=8081,
debug=False)
def fill_void_cells(self, cell):
checked_cells = [cell, ]
while len(checked_cells) > 0:
for cell in checked_cells[:]:
checked_cells.remove(cell)
if (not self.mine_matrix[cell.y][cell.x].has_mine) and \
(self.mine_matrix[cell.y][cell.x].nearest_mine == 0):
for coord in [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]]:
_x, _y = coord
if not self.coord_in_map(cell.x + _x, cell.y + _y):
continue
if not self.mine_matrix[cell.y + _y][cell.x + _x].opened:
self.mine_matrix[cell.y + _y][cell.x + _x].check_mine(None, False)
checked_cells.append(self.mine_matrix[cell.y + _y][cell.x + _x])
def explosion(self, cell):
print("explosion")
self.mine_table = gui.Table(margin='0px auto')
self.main_container.append(self.mine_table, key="mine_table")
for x in range(0, len(self.mine_matrix[0])):
for y in range(0, len(self.mine_matrix)):
self.mine_matrix[y][x].style['background-color'] = 'red'
self.mine_matrix[y][x].check_mine(None, False)
self.mine_table.empty()
self.mine_table.append_from_list(self.mine_matrix, False)
if __name__ == "__main__":
start(MyApp, multiple_instance=False, address='0.0.0.0', port=8081, debug=False, start_browser=True )
def onerror(self, emitter, message, source, lineno, colno):
""" WebPage Event that occurs on webpage errors """
super(MyApp, self).onerror(emitter, message, source, lineno, colno)
def ononline(self, emitter):
""" WebPage Event that occurs on webpage goes online after a disconnection """
super(MyApp, self).ononline(emitter)
def onpagehide(self, emitter):
""" WebPage Event that occurs on webpage when the user navigates away """
super(MyApp, self).onpagehide(emitter)
def onpageshow(self, emitter, width, height):
""" WebPage Event that occurs on webpage gets shown """
super(MyApp, self).onpageshow(emitter, width, height)
def onresize(self, emitter, width, height):
""" WebPage Event that occurs on webpage gets resized """
super(MyApp, self).onresize(emitter, width, height)
if __name__ == "__main__":
# starts the webserver
start(MyApp,
debug=True,
address='0.0.0.0',
port=0,
start_browser=True,
username=None,
password=None)
self.projectConfiguration.show(self)
def toolbar_delete_clicked(self, widget):
if self.selectedWidget==self.project:
return
for drag_helper in self.drag_helpers:
drag_helper.setup(None, None)
parent = self.selectedWidget.get_parent()
parent.remove_child(self.selectedWidget)
self.instancesWidget.update(self.project, self.selectedWidget)
self.selectedWidget = parent
print("tag deleted")
def onkeydown(self, emitter, key, keycode, ctrl, shift, alt):
if str(keycode)=='46': #46 the delete keycode
self.toolbar_delete_clicked(None)
print("Key pressed: " + str(keycode))
def on_dropped(self, left, top):
if len(left)<1:
left='0px'
if len(top)<1:
top='0px'
self.style['left']=left
self.style['top']=top
if __name__ == "__main__":
start(Editor, debug=False, address='0.0.0.0', port=8082, update_interval=0.01, multiple_instance=True)
geoApi = GeolocationAPI()
oriApi = OrientationAPI()
accApi = AccelerometerAPI()
wid.add_child("javascript_geo", geoApi)
wid.add_child("javascript_ori", oriApi)
wid.add_child("javascript_acc", accApi)
geoApi.set_on_change_listener(self.onGeolocation, lblGeolocation)
oriApi.set_on_change_listener(self.onOrientation, lblOrientation)
accApi.set_on_change_listener(self.onAccelerometer, lblAccelerometer)
# returning the root widget
return wid
# listener function
def onGeolocation(self, widget, latitude, longitude, label):
label.set_text("lat: %s, lon:%s"%(latitude, longitude))
def onOrientation(self, widget, gamma, beta, alpha, label):
label.set_text("gamma: %s, beta:%s, alpha:%s"%(gamma, beta, alpha))
def onAccelerometer(self, widget, accelerationX, accelerationY, accelerationZ, label):
label.set_text("accX: %s, accY:%s, accZ:%s"%(accelerationX, accelerationY, accelerationZ))
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True, address='0.0.0.0', multiple_instance=True, certfile="server.crt", keyfile="server.key")#, ssl_version=ssl.PROTOCOL_TLSv1_2)
time.sleep(1)
def stop(self):
self.running = False
self.thread.join()
# listener function
def on_button_pressed(self, widget, settings):
if not self.started:
# self.plt.status.play()
widget.set_text('Stop')
widget.style['background-color'] = 'red'
for idx in range(len(self.data)):
self.data[idx]['x'] = []
self.data[idx]['y'] = []
self.running = True
self.thread = threading.Thread(target=self.run)
self.thread.start()
else:
# self.plt.status.stop()
self.stop()
widget.set_text('Start')
widget.style['background-color'] = 'green'
self.started = not self.started
if __name__ == "__main__":
# starts the webserver
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,
# enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=False, port=8081, address='0.0.0.0', start_browser=True)
import remi.gui as gui
from remi import start, App
import sys
class Communicator(App):
def __init__(self, *args):
super(Communicator, self).__init__(*args)
self.net_name = "Gellish semantic network"
# Define the main window
def main(self):
print('Net name:', self.net_name)
self.container = gui.Widget(margin='0px auto')
self.container.set_size(1020, 600)
return self.container
if __name__ == "__main__":
sys.setrecursionlimit(100000)
start(Communicator)
class MyApp(App):
def __init__(self, *args):
res_path = os.path.join(os.path.dirname(__file__), 'res')
super(MyApp, self).__init__(*args, static_file_path=res_path)
def idle(self):
pass
def main(self):
self.floatingPaneContainer = FloatingPanesContainer(width=800, height=600, margin='0px auto')
self.floatingPaneContainer.append(gui.Label("Click a panel to select, than drag and stretch"))
pane1 = gui.Container(width=100, height=200)
pane1.style['background-color'] = 'yellow'
self.floatingPaneContainer.add_pane(pane1, 10, 100)
pane1.append(gui.Label("Panel1, drag and stretch"))
pane2 = gui.VBox(width=100, height=200)
pane2.style['background-color'] = 'green'
self.floatingPaneContainer.add_pane(pane2, 150, 100)
pane2.append(gui.Label("Panel2, drag and stretch"))
# returning the root widget
return self.floatingPaneContainer
if __name__ == "__main__":
start(MyApp, debug=False, address='0.0.0.0', port=0, update_interval=0.01)
def change_save_location(self, widget, value, save_as):
self.save_location = value
self.save_location_label.set_text(f"Saving to {value}")
if save_as:
self._save()
def cbk_save_as(self, widget):
self._get_new_save_location(save_as=True)
def cbk_select_pickle(self, widget):
file_selector = gui.FileSelectionDialog("File Selection Dialog", "Select data pickle.", False, ".")
file_selector.set_on_confirm_value_listener(self.cbk_load)
file_selector.show(self)
def _load(self, filename):
with open(filename, "rb") as fin:
self.users = pickle.load(fin)
User.count = max(user.id_ for user in self.users) + 1
self.update_table()
self.update_user_list()
def cbk_load(self, widget, filenames):
if isinstance(filenames, list):
filenames = filenames[0]
self._load(filenames)
if __name__ == "__main__":
start(MyApp, title="Dashboard | SPIRIT")
self.lbl.set_text('New color value: ' + value)
def date_changed(self, value):
self.lbl.set_text('New date value: ' + value)
def menu_save_clicked(self):
self.lbl.set_text('Menu clicked: Save')
def menu_saveas_clicked(self):
self.lbl.set_text('Menu clicked: Save As')
def menu_open_clicked(self):
self.lbl.set_text('Menu clicked: Open')
def menu_view_clicked(self):
self.lbl.set_text('Menu clicked: View')
def fileupload_on_success(self, filename):
self.lbl.set_text('File upload success: ' + filename)
def fileupload_on_failed(self, filename):
self.lbl.set_text('File upload failed: ' + filename)
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True, address='0.0.0.0')
self.line.add_coord(x, y)
def write_on(self, emitter, x, y):
self.draw_element += 1
self.line = SvgPolyline()
self.line.set_stroke(width=2, color=self.color)
self.line.set_fill(None)
self.lines.append(self.line)
self.svg.append(self.line, str(self.draw_element))
self.write = True
def write_off(self, emitter, x, y):
global students
self.write = False
draw_element = 0
for line in self.lines:
draw_element += 1
students['default']['svg'].append(line, str(draw_element))
for IP in students:
students[IP]['update'] = True
if __name__ == "__main__":
start(Teach,
address='0.0.0.0',
port=8081,
start_browser=False,
username=None,
password=None,
multiple_instance=True)
exit()
options_file_path=editor_dir+os.sep+'pp_config'+os.sep+'pp_web.cfg'
if not os.path.exists(options_file_path):
print 'Web Editor - Cannot find Web Options file'
exit()
"""reads options from options file to interface"""
config=ConfigParser.ConfigParser()
config.read(options_file_path)
ip =config.get('network','ip',0)
port=int(config.get('editor','port',0))
username=config.get('editor','username',0)
password=config.get('editor','password',0)
print 'Web Editor Started'
# print ip,port, username,password
# setting up remi debug level
# 2=all debug messages 1=error messages 0=no messages
import remi.server
remi.server.DEBUG_MODE = 0
# start the web server to serve the Web Editor App
start(PPWebEditor,address=ip, port=port,username=username,password=password,
multiple_instance=False,enable_file_cache=True,
update_interval=0.1, start_browser=False)
js = gui.Tag(_type='script')
js.attributes["src"] = "/res/{}".format(js_file)
vbox_main.add_child(js_file, js)
return vbox_main
def _build_middle_box(self):
middle_container = gui.HBox(style=MainStyles['middle_container'])
middle_container.style["align-items"] = "stretch"
self.ipbox.refresh_ip_box()
middle_container.append(self.servicesbox.build_services_box())
self.servicesbox.refresh_service_table()
middle_container.append(self.scriptbox.build_script_box())
self.scriptbox.refresh_scripts_table()
# returning the root widget
return middle_container
if __name__ == "__main__":
# Starts the remi web server
start(RaspiCommander,
address=IP,
port=PORT,
enable_file_cache=False,
update_interval=0.1)
self.svgplot.style['margin'] = '10px'
self.plotData1 = gui.SvgPolyline(500)
self.plotData1.set_stroke(2.0, 'rgba(255,0,0,0.8)')
self.plotData2 = gui.SvgPolyline(500)
self.plotData2.set_stroke(1.0, 'green')
self.plotData3 = gui.SvgPolyline(300)
self.plotData3.set_stroke(3.0, 'orange')
self.svgplot.append_poly(self.plotData1)
self.svgplot.append_poly(self.plotData2)
self.svgplot.append_poly(self.plotData3)
self.wid.append(self.svgplot)
self.count = 0
self.add_data()
# returning the root widget
return self.wid
def add_data(self):
self.plotData1.add_coord(self.count, math.atan(self.count / 180.0 * math.pi))
self.plotData2.add_coord(self.count, math.cos(self.count / 180.0 * math.pi))
self.plotData3.add_coord(self.count, math.sin(self.count / 180.0 * math.pi))
self.svgplot.render()
self.count += 1
Timer(0.01, self.add_data).start()
if __name__ == "__main__":
start(MyApp, address='0.0.0.0')
def menu_open_clicked(self, widget):
self.lbl.set_text('Menu clicked: Open')
def menu_view_clicked(self, widget):
self.lbl.set_text('Menu clicked: View')
def fileupload_on_success(self, widget, filename):
self.lbl.set_text('File upload success: ' + filename)
def fileupload_on_failed(self, widget, filename):
self.lbl.set_text('File upload failed: ' + filename)
def on_close(self):
""" Overloading App.on_close event to stop the Timer.
"""
self.stop_flag = True
super(MyApp, self).on_close()
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
import ssl
start(MyApp,
debug=True,
address='0.0.0.0',
port=0,
start_browser=True,
multiple_instance=True)
# api function
def api_set_text(self, value1, value2):
self.set_text('parameters: %s - %s' % (value1, value2))
headers = {'Content-type': 'text/plain'}
return ['OK', headers]
class MyApp(App):
def __init__(self, *args):
super(MyApp, self).__init__(*args)
def main(self):
wid = gui.VBox()
#the 'id' param allows to have an alias in the url to refer to the widget that will manage the call
self.lbl = RemoteLabel('type in other page url "http://127.0.0.1:8082/label/api_set_text?value1=text1&value2=text2" !', width='80%', height='50%', id='label')
self.lbl.style['margin'] = 'auto'
# appending a widget to another, the first argument is a string key
wid.append(self.lbl)
# returning the root widget
return wid
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True, address='127.0.0.1', port=8082)
self.count = 0
self.add_data()
bt = gui.Button("Zoom - ")
bt.set_on_click_listener(self.zoom_out)
self.wid.append(bt)
# returning the root widget
return self.wid
def zoom_out(self, emitter):
scale_factor_x = 0.5
scale_factor_y = 100.0
self.plotData1.scale(scale_factor_x, scale_factor_y)
self.plotData2.scale(scale_factor_x, scale_factor_y)
self.plotData3.scale(scale_factor_x, scale_factor_y)
def add_data(self):
with self.update_lock:
#the scale factors are used to adapt the values to the view
self.plotData1.add_coord(self.count, math.atan(self.count / 180.0 * math.pi))
self.plotData2.add_coord(self.count, math.cos(self.count / 180.0 * math.pi))
self.plotData3.add_coord(self.count, math.sin(self.count / 180.0 * math.pi))
self.svgplot.render()
self.count += 10
Timer(0.1, self.add_data).start()
if __name__ == "__main__":
start(MyApp, address='0.0.0.0', update_interval=0.1, multiple_instance=True)
self.published_topics = [topic_name for topic_name, topic_type in self.published_topics_and_types]
self.published_topics.sort()
rospy.loginfo("Found topics:\n" +
str(self.published_topics))
self.dropdown = gui.DropDown(-1, -1)
choose_ddi = gui.DropDownItem(-1, -1, "Choose topic...")
self.dropdown.append(0, choose_ddi)
for idx, topic_name in enumerate(self.published_topics):
ddi = gui.DropDownItem(-1, -1, topic_name)
self.dropdown.append(idx+1, ddi)
self.dropdown.set_on_change_listener(self, 'on_dropdown_change')
# using ID 2 to update the dropdown
self.hor_topics.append(2, self.dropdown)
# This makes the dropdown not be left
self.dropdown.style['display'] = 'block'
self.dropdown.style['margin'] = '10px auto'
self.dropdown.style['float'] = 'none'
self.wid.append(1, self.hor_topics)
if __name__ == "__main__":
rospy.init_node('web_topic_viewer')
start(MyApp,
address="0.0.0.0",
port=8091,
multiple_instance=True,
update_interval=0.1,
start_browser=False,
debug=False)
self.lbl.set_text('New color value: ' + value)
def date_changed(self, value):
self.lbl.set_text('New date value: ' + value)
def menu_save_clicked(self):
self.lbl.set_text('Menu clicked: Save')
def menu_saveas_clicked(self):
self.lbl.set_text('Menu clicked: Save As')
def menu_open_clicked(self):
self.lbl.set_text('Menu clicked: Open')
def menu_view_clicked(self):
self.lbl.set_text('Menu clicked: View')
def fileupload_on_success(self, filename):
self.lbl.set_text('File upload success: ' + filename)
def fileupload_on_failed(self, filename):
self.lbl.set_text('File upload failed: ' + filename)
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True,address='192.168.1.108')
res_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'res')
#static_file_path can be an array of strings allowing to define
# multiple resource path in where the resources will be placed
super(MyApp, self).__init__(*args, static_file_path=res_path, html_head=my_html_head, css_head=my_css_head, js_head=my_js_head)
def idle(self):
#idle loop, you can place here custom code
# avoid to use infinite iterations, it would stop gui update
pass
def main(self):
#creating a container VBox type, vertical (you can use also HBox or Widget)
main_container = gui.VBox(width=300, height=200, style={'margin':'0px auto'})
#add the following 3 lines to your app and the on_window_close method to make the console close automatically
tag = gui.Tag(_type='script')
tag.add_child("javascript", """window.onunload=function(e){sendCallback('%s','%s');return "close?";};""" % (str(id(self)), "on_window_close"))
main_container.add_child("onbeforeunloadevent", tag)
# returning the root widget
return main_container
def on_window_close(self):
#here you can handle the unload
self.close()
if __name__ == "__main__":
# starts the webserver
start(MyApp, address='127.0.0.1', port=8081, websocket_port=0, host_name=None, start_browser=True, username=None, password=None)
main_container = gui.VBox(width=400,
height=140,
style={
'align': 'center',
'border': '5px #FFAC55 solid'
})
btn_container = gui.HBox(width=300, height=30)
link_to_github = gui.Link(
'https://github.com/npes87184/PyM3UGenerator', 'Fork me here')
self.lbl = gui.Label('Please choose a folder')
self.select_bt = gui.Button('Select folder', width=100, height=30)
self.go_bt = gui.Button('Go', width=100, height=30)
self.select_bt.onclick.do(self.on_select_btn_pressed)
self.go_bt.onclick.do(self.on_go_btn_pressed)
btn_container.append(self.select_bt)
btn_container.append(self.go_bt)
main_container.append(self.lbl)
main_container.append(btn_container)
main_container.append(link_to_github)
body.append(main_container)
return body
if __name__ == '__main__':
start(M3uGenerator)
mainContainer.append(lblAlignItems,'lblAlignItems')
mainContainer.children['comboJustifyContent'].onchange.do(self.onchange_comboJustifyContent,vbox,hbox)
mainContainer.children['comboAlignItems'].onchange.do(self.onchange_comboAlignItems,vbox,hbox)
lblTitle = gui.Label("The following example shows the two main layout style properties for the VBox and HBox containers. Change the value of the two combo boxes.",
style='position:absolute; left:0px; top:0px')
mainContainer.append(lblTitle)
self.mainContainer = mainContainer
return self.mainContainer
def onchange_comboJustifyContent(self,emitter,new_value,vbox,hbox):
vbox.style['justify-content'] = new_value
hbox.style['justify-content'] = new_value
def onchange_comboAlignItems(self,emitter,new_value,vbox,hbox):
vbox.style['align-items'] = new_value
hbox.style['align-items'] = new_value
#Configuration
configuration = {'config_enable_file_cache': True, 'config_multiple_instance': True, 'config_port': 0, 'config_address': '0.0.0.0', 'config_start_browser': True, 'config_project_name': 'untitled', 'config_resourcepath': './res/'}
if __name__ == "__main__":
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(untitled, address=configuration['config_address'], port=configuration['config_port'],
multiple_instance=configuration['config_multiple_instance'],
enable_file_cache=configuration['config_enable_file_cache'],
start_browser=configuration['config_start_browser'])
"height": "480px",
"top": "40px",
"left": "0px",
"position": "absolute",
"overflow": "auto"
})
wheelStatus.append(img_wheelStatus, 'img_wheelStatus')
self.wheelStatus = wheelStatus
return self.wheelStatus
#Configuration
configuration = {
'config_project_name': 'GrowBot',
'config_address': '0.0.0.0',
'config_port': 8081,
'config_multiple_instance': True,
'config_enable_file_cache': True,
'config_start_browser': True
} #, 'config_resourcepath': './'}
if __name__ == "__main__":
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(GrowBot,
address=configuration['config_address'],
port=configuration['config_port'],
multiple_instance=configuration['config_multiple_instance'],
enable_file_cache=configuration['config_enable_file_cache'],
start_browser=configuration['config_start_browser'])
self.client_connected = False
def reconnection(self):
rospy.logwarn("Reconnection of the client!")
self.client_connected = True
def joystick_moved(self, x, y): # 0 <= x <= 1 0 <= y <= 1
self.infoLabel.set_text("move x:%s y:%s" % (x, y))
self.last_x = x
self.last_y = y
def pub_twist(self, timerevent):
if self.joystick.drag_state and self.client_connected:
t = Twist()
if self.last_y >= 0:
t.linear.x = self.last_y * MAX_LINEAR_SPEED
else:
t.linear.x = self.last_y * MAX_ANGULAR_SPEED / 2.0
t.angular.z = -self.last_x * MAX_ANGULAR_SPEED
self.twist_pub.publish(t)
if __name__ == "__main__":
rospy.init_node('remi_joy')
start(MyApp,
address='0.0.0.0',
multiple_instance=True,
port=8092,
websocket_timeout_timer_ms=1000,
pending_messages_queue_length=1000)
# appending a widget to another, the first argument is a string key
wid.append('1', self.lbl)
self.sub = rospy.Subscriber('/test', Header, self.sub_cb, queue_size=1)
print "Initialized app"
# returning the root widget
return wid
if __name__ == "__main__":
if len(sys.argv) > 1:
rate = float(sys.argv[1])
else:
rate = 0.1
# Initialize ROS
rospy.init_node('test')
# starts the webserver
# optional parameters
start(MyApp,
address='127.0.0.1',
port=8081,
multiple_instance=False,
enable_file_cache=True,
update_interval=rate,
start_browser=True)
#start(MyApp, debug=False)
# returning the root widget
return self.mainContainer
def menu_open_clicked(self, widget):
self.fileselectionDialog = gui.FileSelectionDialog('File Selection Dialog', 'Select an image file', False, '.')
self.fileselectionDialog.confirm_value.do(
self.on_image_file_selected)
self.fileselectionDialog.cancel_dialog.do(
self.on_dialog_cancel)
# here is shown the dialog as root widget
self.fileselectionDialog.show(self)
def menu_save_clicked(self, widget):
pass
def menu_saveas_clicked(self, widget):
pass
def on_image_file_selected(self, widget, file_list):
if len(file_list) < 1:
return
self.image_widget.load(file_list[0])
self.set_root_widget(self.mainContainer)
def on_dialog_cancel(self, widget):
self.set_root_widget(self.mainContainer)
if __name__ == "__main__":
start(MyApp, address='0.0.0.0', port=0, start_browser=True)
lbl = gui.Label("Page 1. Press the button to change the page.",
style={'font-size': '20px'})
bt1 = gui.Button("change page")
page1 = gui.VBox(children=[lbl, bt1],
style={
'width': '300px',
'height': '200px',
'margin': '0px auto',
'background-color': 'white'
})
bt1.onclick.connect(self.set_different_root_widget, page2)
bt2.onclick.connect(self.set_different_root_widget, page1)
# returning the root widget
return page1
def set_different_root_widget(self, emitter, page_to_be_shown):
self.set_root_widget(page_to_be_shown)
if __name__ == "__main__":
# starts the webserver
start(MyApp,
address='127.0.0.1',
port=8081,
host_name=None,
start_browser=True,
username=None,
password=None)
for coord in [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]]:
_x, _y = coord
if not self.coord_in_map(cell.x + _x, cell.y + _y):
continue
if not self.mine_matrix[cell.y + _y][cell.x + _x].opened:
self.mine_matrix[cell.y + _y][cell.x + _x].check_mine(None, False)
checked_cells.append(self.mine_matrix[cell.y + _y][cell.x + _x])
def explosion(self, cell):
print("explosion")
self.mine_table = gui.Table(margin='0px auto')
self.main_container.append(self.mine_table, key="mine_table")
for x in range(0, len(self.mine_matrix[0])):
for y in range(0, len(self.mine_matrix)):
self.mine_matrix[y][x].style['background-color'] = 'red'
self.mine_matrix[y][x].check_mine(None, False)
self.mine_table.empty()
#self.mine_table.append_from_list(self.mine_matrix, False)
for x in range(0, len(self.mine_matrix[0])):
row = gui.TableRow()
for y in range(0, len(self.mine_matrix)):
row.append(self.mine_matrix[y][x])
self.mine_matrix[y][x].onclick.do(self.mine_matrix[y][x].check_mine)
self.mine_table.append(row)
if __name__ == "__main__":
start(MyApp, multiple_instance=True, address='0.0.0.0', port=0, debug=True, start_browser=True )
bt.style['background-color'] = 'red'
wid.append(self.lbl)
wid.append(bt)
self.thread_alive_flag = True
self.my_thread_result = 0
# Here I start a parallel thread that executes my algorithm for a long time
t = threading.Thread(target=self.my_intensive_long_time_algorithm)
t.start()
bt.onclick.do(self.on_button_pressed)
# returning the root widget
return wid
def my_intensive_long_time_algorithm(self):
while self.thread_alive_flag:
self.my_thread_result = self.my_thread_result + 1
def on_button_pressed(self, emitter):
self.thread_alive_flag = False
def on_close(self):
self.thread_alive_flag = False
super(MyApp, self).on_close()
if __name__ == "__main__":
start(MyApp, debug=True, address='0.0.0.0', port=0, update_interval=0.1)
def fill_void_cells(self, cell):
checked_cells = [cell, ]
while len(checked_cells) > 0:
for cell in checked_cells[:]:
checked_cells.remove(cell)
if (not self.mine_matrix[cell.y][cell.x].has_mine) and \
(self.mine_matrix[cell.y][cell.x].nearest_mine == 0):
for coord in [[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]]:
_x, _y = coord
if not self.coord_in_map(cell.x + _x, cell.y + _y):
continue
if not self.mine_matrix[cell.y + _y][cell.x + _x].opened:
self.mine_matrix[cell.y + _y][cell.x + _x].check_mine(False)
checked_cells.append(self.mine_matrix[cell.y + _y][cell.x + _x])
def explosion(self, cell):
print("explosion")
self.mine_table = gui.Table()
self.main_container.append(self.mine_table, key="mine_table")
for x in range(0, len(self.mine_matrix[0])):
for y in range(0, len(self.mine_matrix)):
self.mine_matrix[y][x].style['background-color'] = 'red'
self.mine_matrix[y][x].check_mine(False)
self.mine_table.from_2d_matrix(self.mine_matrix, False)
if __name__ == "__main__":
start(MyApp, multiple_instance=False, address='0.0.0.0', port=8081, debug=False)
def onkeydown(self, emitter, key, keycode, ctrl, shift, alt):
if str(keycode) == '46': # 46 the delete keycode
self.toolbar_delete_clicked(None)
print("Key pressed: " + str(keycode))
def show_error_dialog(self, title, message):
error_dialog = gui.GenericDialog(title, message)
error_dialog.children["title"].style['background-color'] = 'red'
error_dialog.children["message"].style['white-space'] = 'pre'
error_dialog.cancel.style['display'] = 'none'
error_dialog.show(self)
def on_dropped(self, left, top):
if len(left) < 1:
left = '0px'
if len(top) < 1:
top = '0px'
self.style['left'] = left
self.style['top'] = top
if __name__ == "__main__":
start(Editor,
debug=False,
address='0.0.0.0',
port=8082,
update_interval=0.05,
multiple_instance=True)
print "Dropdown changed to: " + value
if value == "Choose topic...":
if self.playing:
self.rosvideo_widget.stop()
self.playing = False
return
self.rosvideo_widget.subscribe(value)
self.rosvideo_widget.play()
self.playing = True
def on_fps_dropdown_change(self, value):
pass
def pause_play(self):
if self.playing:
self.bt_pause.set_text("Play video")
self.rosvideo_widget.stop()
self.playing = False
else:
self.bt_pause.set_text("Stop video")
self.rosvideo_widget.play()
self.playing = True
if __name__ == "__main__":
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
rospy.init_node('view_topic_remi')
start(MyApp, address='0.0.0.0', port=8093, debug=True)
# returning the root widget
return self.mainContainer
def menu_open_clicked(self, widget):
self.fileselectionDialog = gui.FileSelectionDialog('File Selection Dialog', 'Select an image file', False, '.')
self.fileselectionDialog.set_on_confirm_value_listener(
self.on_image_file_selected)
self.fileselectionDialog.set_on_cancel_dialog_listener(
self.on_dialog_cancel)
# here is shown the dialog as root widget
self.fileselectionDialog.show(self)
def menu_save_clicked(self, widget):
pass
def menu_saveas_clicked(self, widget):
pass
def on_image_file_selected(self, widget, file_list):
if len(file_list) < 1:
return
self.image_widget.load(file_list[0])
self.set_root_widget(self.mainContainer)
def on_dialog_cancel(self, widget):
self.set_root_widget(self.mainContainer)
if __name__ == "__main__":
start(MyApp, address='0.0.0.0', start_browser=True)
def main(self):
wid = gui.VBox(width=300, height=200, margin='0px auto')
self.lbl = gui.Label('Press the button', width='80%', height='50%')
self.lbl.style['margin'] = 'auto'
self.bt = gui.Button('Press me!', width=200, height=30)
self.bt.style['margin'] = 'auto 50px'
# setting the listener for the onclick event of the button
self.bt.onclick.do(self.on_button_pressed)
# appending a widget to another, the first argument is a string key
wid.append(self.lbl)
wid.append(self.bt)
# returning the root widget
return wid
# listener function
def on_button_pressed(self, widget):
self.lbl.set_text('A notification message should appear.')
self.bt.set_text('Hi!')
self.notification_message("Message title", "Hello world!", "")
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True, address='0.0.0.0', port=0, )
def __init__(self, *args, game=None, **kwargs):
userdata = (game, )
start(Connect4WebInterface_, *args, userdata=userdata, **kwargs)
self.drop_status = gui.Label('')
self.drop_btn = gui.Button('DROP')
self.drop_btn.style['background'] = 'teal'
self.buttons = {'drop_btn': False}
# setting the listener for the onclick event of the button
self.drop_btn.set_on_click_listener(self, 'on_button_pressed')
# appending a widget to another, the first argument is a string key
container.append(self.drop_status)
container.append(self.drop_btn)
# returning the root widget
return container
# listener function
def on_button_pressed(self):
if not self.buttons['drop_btn']:
self.buttons['drop_btn'] = True
self.drop_btn.style['background'] = 'red'
self.on_button_pressed()
else:
xdot.dropIt()
self.drop_btn.style['background'] = 'teal'
# starts the webserver
if __name__ == "__main__":
start(MyApp, address='127.0.0.1', start_browser=False)
self.error = gui.Label("",
width=300,
height=5,
style={"font-style": "italic"})
self.button = gui.Button("TRANSLATE",
width=300,
height=40,
margin="10px",
style={
"background-color": "#F16059",
"font-weight": "bold",
"font-size": "16px",
"box-shadow": "none"
})
# Adds the elements to the GUI
container.append(self.label)
container.append(self.textinput)
container.append(self.spanish)
container.append(self.french)
container.append(self.error)
container.append(self.button)
# When you click on button, call the function on_button_pressed
self.button.onclick.connect(self.on_button_pressed)
return container
start(MyApp, debug=False, address='0.0.0.0', port=0, multiple_instance=True)
self.lbl.set_text('New date value: ' + value)
def menu_save_clicked(self):
self.lbl.set_text('Menu clicked: Save')
def menu_saveas_clicked(self):
self.lbl.set_text('Menu clicked: Save As')
def menu_open_clicked(self):
self.lbl.set_text('Menu clicked: Open')
def menu_view_clicked(self):
self.lbl.set_text('Menu clicked: View')
def fileupload_on_success(self, filename):
self.lbl.set_text('File upload success: ' + filename)
def fileupload_on_failed(self, filename):
self.lbl.set_text('File upload failed: ' + filename)
# setting up remi debug level
# 2=all debug messages 1=error messages 0=no messages
#import remi.server
#remi.server.DEBUG_MODE = 2
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp)
class MyApp(App):
def __init__(self, *args):
super(MyApp, self).__init__(*args)
def main(self, name='world'):
# margin 0px auto allows to center the app to the screen
wid = gui.VBox(width=300, height=200, margin='0px auto')
lbl = gui.Label("Close the window, the console thread will stop automatically.")
wid.append(lbl)
#add the following 3 lines to your app and the on_window_close method to make the console close automatically
tag = gui.Tag(_type='script')
tag.add_child("javascript", """window.onunload=function(e){sendCallback('%s','%s');return "close?";};""" % (str(id(self)), "on_window_close"))
wid.add_child("onunloadevent", tag)
# returning the root widget
return wid
def on_window_close(self):
#here you can handle the unload
print("app closing")
self.close()
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True, start_browser=True) #standalone=True)
self._items = ("/test/1", "/test/7")
self.dd = gui.DropDown.new_from_list(self._items, width='80%', height=40)
self.list = gui.ListView.new_from_list(self._items, width='80%', height='50%')
self.ent = gui.TextInput(width=200, height=30, hint='enter words')
self.bt = gui.Button('Update Models', width=200, height=30)
self.bt.style['margin'] = 'auto 50px'
self.bt.set_on_click_listener(self.on_button_pressed)
# appending a widget to another, the first argument is a string key
wid.append([self.dd, self.list, self.ent, self.bt])
# returning the root widget
return wid
# listener function
def on_button_pressed(self, widget):
txt = self.ent.get_text()
if txt:
self._items = tuple("/test/%s" % i for i in txt.split(' '))
self.dd.synchronize_values(self._items)
self.list.synchronize_values(self._items)
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
start(MyApp, debug=True)
# listener function
# 跳转到官网
def on_img_clicked(self, widget):
print('官网: http://www.yuanxiang.cn')
def goto_tableocr_web(self, widget):
print('go to table-ocr')
def goto_dococr_web(self, widget):
print('go to doc-ocr')
def on_close(self):
""" Overloading App.on_close event to stop the Timer.
"""
self.stop_flag = True
super(OCR_miniApp, self).on_close()
if __name__ == "__main__":
# starts the webserver
# optional parameters
# start(MyApp,address='127.0.0.1', port=8081, multiple_instance=False,enable_file_cache=True, update_interval=0.1, start_browser=True)
import ssl
start(OCR_miniApp,
debug=True,
address='0.0.0.0',
port=8081,
start_browser=True,
multiple_instance=True)
