Can I run webkit.WebView object without GTK loop? I want to make a simple webkit-based headless browser and I do not need GTK anywhere - I don't display anything.
win = gtk.Window() # <------------------------+--- can I not use those?
web = webkit.WebView() # |
web.load_uri("http://example.com") # |
web.connect("load-finished", get_html_source) #|
win.add(web) # <-------------------------------|
#win.show_all() # |
gtk.main() # <---------------------------------|
True that without show_all I don not display anything, but I still use GTK. I want to make the script multi threading and GTK is problematic here (the less modules I use the better for me)
(I use Python but this is not a python-specific question)
No, that is impossible. webkit.WebView is built on top of the GTK toolkit and even if you are only displaying a web view, you still need a GTK window to put it in.
If you really don't want a GTK window, then why not open the page in the default browser?
For a headless you can also use gtk_offscreen_window_new(). For gtk_main() and multi-threading consider reading the article "Multi-threaded GTK applications".
Related
Autonomous life can be controlled from within Choregraphe's UI as well as by pressing the chest button twice on the robot, however, how can this be done from a Choregraphe project?
After browsing the list of tools in the Box Library, it is unclear which tool can be used for this.
When Autonomous Life is on, the robot, in order to appear alive, makes small motions with its head, arms, and legs. The behaviour I'm developing is subtle and difficult to distinguish from the Autonomous Life movements, so I'm trying to make the robot stand still before my behaviour runs.
The ALAutonomousLife API offers the method setState
In Choregraph you could make a python box with this content:
class MyClass(GeneratedClass):
def __init__(self):
GeneratedClass.__init__(self)
self.al = ALProxy("ALAutonomousLife")
def onLoad(self):
#put initialization code here
pass
def onUnload(self):
#put clean-up code here
pass
def onInput_onStart(self):
self.al.setState("disabled")
#self.onStopped() #activate the output of the box
pass
def onInput_onStop(self):
self.onUnload() #it is recommended to reuse the clean-up as the box is stopped
self.onStopped() #activate the output of the box
And then activate this Box to disable AutonomousLife.
You can also test it in a python console like this:
import naoqi
from naoqi import ALProxy
al = ALProxy("ALAutonomousLife", "pepper.local", 9559)
al.setState("diabled")
This will have the same effect as pressign the chest button twice.
To only disable subtle autonomous movement have a look at Autonomous Abilities
A method setEnabled is offered by
ALListeningMovement
ALBackgroundMovement
ALSpeakingMovement
How to automatically reload Clojure code?
I have watched the presentation. And in there they use some hot swap Clojure technology that reloads code whenever changes are made into source files. I can run the code, but I can not observe the effect of auto reload. How is it possible to reload the code?
the source code.
There are many ways to reload code, depending on the situation:
Emacs/CIDER shortcuts to reload a file. Probably Rich is doing something similar. Also see this: How to reload a clojure file in REPL
watch files and reload the code (figwheel for frontend development does that, test plugins as well as CIDER shortcuts specifically for running tests, boot has a watch task...)
a middleware for the web server you use (ring for example has ring.middleware.reload/wrap-reload for this, pedestal comes with one as well, other webservers like yada play well with component)
a component workflow works also, there is an example of an auto-reloadable system with holy-grail
(I didn't fully re-watch this video, but these notes are from my observations after skipping through the video and making educated guesses)
From what I re-watched of this video it looks like Rich is evaluating the code in a running repl. This allows him to change the code, evaluate it, and see different behavior.
Many editors have support for evaluating code in a buffer in a Clojure repl. Here is some documentation on using CIDER with Emacs to get to interactively play with your code.
Unrelated to the video in question, if you are using ring for web development. You can use the wrap-reload middleware to have your code automatically reloaded when a file has changed and a request hits your web app. This is extremely useful when developing a Clojure web application.
For automatically reloading and running your clojure.tests I recommend lein-test-refresh. It is a Leiningen plug-in that monitors your project for file changes and when something changes it reloads and runs your tests. If you have tests for your project this greatly speeds up development.
Use mount to manage the starting and stopping of your components. For example in a backend web app, you'll want to startup the db before you start the webserver probably.
Then in emacs you can have:
(defun cider-repl-refresh ()
(interactive)
(save-some-buffers)
(with-current-buffer (cider-current-repl-buffer)
(goto-char (point-max))
(insert (concat "(require 'clojure.tools.namespace.repl) "
"(clojure.tools.namespace.repl/refresh)"))
(cider-repl-return)))
If you are not super fond of Emacs (I love Emacs, but hey not everybody does) LightTable is a very nice option for Clojure/ClojureScript interactive programming too.
For developing ClojureScript (Clojure that compiles to Javascript) LightTable and Figwheel are a really nice pair.
In my opinion LightTable has some advantages against Emacs (I never got cider to work perfectly with ClojureScript) for the webdev side, LightTable is basically a specialized version of Chrome, because it is built on top of Electron.
Check this documentation on the Figwheel GitHub page: Running Figwheel with LightTable:
If you are using Cursive IDE in IntelliJ, there is a special REPL tool which you have to setup to get the functionality you are looking for. It has many features vs. "lein repl" in a terminal window.
Full tutorial here: https://cursive-ide.com/userguide/repl.html
However, its very easy to setup a default instance:
Right click project.clj/deps.edn -> "Create Repl for...". Default settings are fine. Hit ok/apply.
Right click project.clj/deps.edn -> "Run Repl for..." (a repl window will open)
See Tools->Repl for a list of commands, such as:
switch to repl window: Ctrl+\
reload current file in repl: Alt + Shift + L
send function defn to repl: Alt + Shift + M
... and more
In addition you'll get full code completion, syntax highlighting, etc. when writing in a REPL.
I have three Qt 5 applications that work fine independently on the BeagleBone X-15 using the Qt 5 Wayland plugin on the TI SDK image.
When I launch them, they fill the whole screen so that the first app launched is covered by the second, and the second app is covered by the third.
How can I modify the transparency of the second and third app launched, so that I can see some of the view from the first app launched?
I tried modifying the window opacity with Qt’s setWindowOpacity, but the Wayland plugin says: “Window Opacity not supported by this Plugin.”
Qt 5 on Wayland page says:
Qt 5 is structured with the Lighthouse (or Qt Platform) Abstraction, which is the windowing system and device agnostic architecture. That means Qt can load in run-time different backend plugins for different window systems as desired. For instance, an application developed on Qt could be run using "-platform xcb" and "-platform wayland" for XCB or Wayland respectively (or set the QT_QPA_PLATFORM environment variable) and should have a similar behavior on both systems, without the need to recompile.
Qt abstraction exposes to applications developers two native resources of Wayland: wl_display and wl_surface. With those types, one could access Wayland internals to deal with special cases through the interface:
void *QPlatformNativeInterface::nativeResourceForWindow(const QByteArray &resource, QWindow *window)
Getting the display global handler is quite straightforward, as shown in the following example:
QPlatformNativeInterface *native =
QGuiApplication::platformNativeInterface();
struct wl_display *wl_dpy = (struct wl_display *)
native->nativeResourceForWindow("display", NULL);
and for wl_surface:
QPlatformNativeInterface *native =
QGuiApplication::platformNativeInterface();
struct wl_surface *surface = static_cast<struct wl_surface *>(
native->nativeResourceForWindow("surface", this->windowHandle()));
If I get the handle to this wl_surface, how can I change the transparency directly?
I'm new to PyopenGL and i'm currently working on a code originally based on the pyggel library, but now I'd like to add some features from GLUT (menu & text) and I'm not really sure how I should join both (if possible).
In GLUT, running glutMainLoop() is required, but on the other hand I have this run() routine:
def run(self):
while 1:
self.clock.tick(60)
self.getInput()
self.processInput()
pyggel.view.clear_screen()
self.mouse_over_object = self.scene.render(self.camera)
pyggel.view.refresh_screen()
#glutMainLoop()
Putting the GLUT routine inside my run() doesn't work (it crashes when it gets to the glutMainLoop).
So, how can I join both loops? Can I? I'm guessing that's what I need to make both things work.
Thanks in advance!
You likely are not going to find this easy to do. Pyggel is based on the Pygame GUI framework, while GLUT is its own GUI framework. You may be able to get text-rendering working, as under the covers GLUT is just doing regular OpenGL for that, but the menus are not going to easily work under Pyggel.
Pyggel has both text-rendering and a GUI framework that includes menus, frames, buttons, labels, etc. You likely want to use that if you're using Pyggel in your project there is an example of GUI usage here:
http://code.google.com/p/pyggel/source/browse/trunk/examples_and_tutorials/tut8-gui.py
I'd like the background of my matplotlib plots to be transparent in my IPython notebook. This may sound silly because the notebook itself defaults to a white background but:
1) I use a solarized background and
2) more importantly, I want them to be transparent for when I embed the notebook directly into my blog via nbconvert.
It's easy enough to use something like savefig('file', transparent=True) , but I'm not saving the figures, I am displaying them inline (by calling IPython with ipython notebook --matplotlib inline.
I've been playing around with the IPython notebook configuration file, especially with c.InlineBackend.rc. For example, I upgraded to the dev version of matplotlib to get access to its new savefig.transparent rcParam, and tried configuring that with c.InlineBackend.rc = {'savefig.transparent': True}, but as expected it only affects plots saved with savefig.
Note that I am using the recent IPython 2.0 release. This must be possible somehow, right? Any light that you can shed would be appreciated.
Just to follow up, the issue opened on Github by tillsten has been patched so something like this:
rcParams['figure.facecolor'] = (0,0,0,0)
should work now after you update IPython. Three cheers for open source.
The inline plots are html objects (<img>) with class ui-resizable. So you can change their default behavior by customizing the CSS for your notebooks:
locate your settings for notebooks: in a terminal, type
ipython locate
in the indicated directory, go to subdir profile_default\static\custom (or any profile you want to use instead)
edit or create a CSS file named custom.css
put this in it:
img.ui-resizable
{
opacity:0.4;
}
Close your notebooks, kill IPython and restart it (so that it recreates the served files).
It should work with exported notebooks, as long as you export them as html and you change the css there too.
It's not exactly what you want, but it does the job.