Error "unable to find vcvarsall.bat" generally means that Visual C++ need be installed.
But for installing Twisted we get another option: Twisted windows installer, please check here http://twistedmatrix.com/trac/wiki/Downloads
After installing it, if you try to "import twisted", you will get ImportError: Twisted requires zope.interfaces: no module named zope.interface.
We can install this missed module by using easy_install:
easy_install zope.interface
Searching "pygtk get window hwnd" on Google for a while, I found there is not much help in top results. So I decide to write this short article.
gtk.Window has a property called "window", it's almost same level as Window in winapi.
|
1 2 3 |
w = gtk.Window() print w.window |
Running above code will get following output:
<gtk.gdk.Window object at 0x2713be8 (GdkWindow at 0x1d9e160)>
Then we can get the hwnd by retrieving "handle" property of this gtk.gdk.Window object
|
1 2 3 |
w = gtk.Window() hwnd = w.window.handle |
|
1 |
ret = ctypes.windll.kernel32.CreateProcessA(path, None, None, None, True, 0x00000010, None, None, byref(startup_info), byref(process_info)) |
Above simple code didn't work in the latest version of my program, but it works well in previous version.
After reading documentation from MSDN, I got that CreateProcessA will return TRUE(1) if execution succeed, and return FALSE(0) if failed. Then I put "print ret" right after that line of code, exactly the return value is 0 (FALSE).
But how to get more details about the error? We can use GetLastError() function.
|
1 |
err_code = ctypes.windll.kernel32.GetLastError() |
And after calling GetLastError(), it returns 2.
By looking up this error code page at MSDN, we can get the return value is actually ERROR_FILE_NOT_FOUND, meaning the system cannot find the file specified. But after printing the file path to console and checking the file path twice, I found the file existed actually.
Searching on google for some time, I found this post from stackoverflow
This guy met same problem: the executable file exists but calling CreateProcessA failed. The answer is use CreateProcessA with ANSI string, and use CreateProcessW with Unicode string. Then I tried CreateProcessW instead of CreateProcessA and it works perfectly!
Actually in previous version of the application, the executable path is read only from configuration file. But in the latest version, it can be loaded from registry key value, using _winreg.QueryValueEx. And this bug is introduced as well. So, is registry key value Unicode? or QueryValueEx returns an Unicode string?
Reading this documentation, we know that REG_SZ key value can either be ANSI or Unicode, it's depending on what function we use. And this bug post tells us that QueryValueEx will convert REG_SZ to unicode automatically, so finally we found where problem is.
In this tutorial, we will download a file by HTTP and display the downloading progress by progress bar. The final screenshot is like this:
To display the downloading progress, we need know file size and currently downloaded bytes size.
So how to get the size of file need download? If you're familiar with HTTP, it will go easy. When downloading a file, first client will send a HTTP request to server for the file URL, then the server will send back a HTTP response to client. If requested URL is valid, the response body will be the file content.In the response header, there's a field called "Content-Length", which is used to indicate size of the response body. Since response body here is the file content, so this "Content-Length" is what we're looking for.
First we need use urllib2.urlopen() to open an url, this method returns a response object. Chain method info().get_headers() of response object can fetch the response header.So we can get file size like this:
|
1 |
file_size = r.meta().get_headers(['Content-Length'])[0] |
And next, we need know how many bytes we have downloaded.
the read(n) method of response object will receive n bytes of data from server. Actually read() can be called with no parameter, then it will receive all data sent by server. But calling read() method like that will let urllib2 module to handle the whole transferring progress. we cannot know how many bytes have been downloaded until downloading is finished.
To get currently downloaded bytes size, we need download fixed size of bytes everytime and update the downloaded bytes size after that block of bytes are downloaded. Then continue downloading until all data is received. You got the idea? so lets implement it.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import urllib2 import os u = urllib2.urlopen('http://ck.kolivas.org/apps/cgminer/3.3/cgminer-3.3.0-windows.zip') meta = u.info() file_size = int(meta.getheaders('Content-Length')[0]) # save downloaded file to TEMP directory f = open(os.path.join(os.environ['TEMP'], 'cgminer.zip'), 'wb') downloaded_bytes = 0 block_size = 1024*8 while True: buffer = u.read(block_size) if not buffer: break f.write(buffer) downloaded_bytes += block_size print downloaded_bytes f.close() |
Now we need QProgressBar to display our downloading progress. set_value() method of QProgressBar is used to set value of progress bar. The default value range is 0-100. and you can modify them by using setMinimum() and setMaximum() of QProgressBar.
Following code will create a window and put a progress bar in it. a setProgress() method is provided to set the progress bar value, so the downloading thread can set progress bar value by calling this method.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import os import sys from PySide.QtCore import * from PySide.QtGui import * class DownloadingWindow(QWidget): def __init__(self): QWidget.__init__(self) vbox = QVBoxLayout() label = QLabel('downloading..') label.setAlignment(Qt.AlignCenter) vbox.addWidget(label) self.progress_bar = QProgressBar() self.progress_bar.setAlignment(Qt.AlignCenter) vbox.addWidget(self.progress_bar) self.setLayout(vbox) self.setGeometry(300, 300, 300, 50) def setProgress(self, value): if value > 100: value = 100 self.progress_bar.setValue(value) def closeEvent(self, event): os._exit(0) if __name__ == '__main__': app = QApplication(sys.argv) w = DownloadingWindow() w.show() app.exec_() |
We will need put downloading part in a separate thread, otherwise it will block UI.
So here's the complete source code
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 |
import threading import sys import urllib2 import os from PySide.QtCore import * from PySide.QtGui import * class DownloadThread(threading.Thread): def __init__(self, url, tmp_file_name, downloading_window): threading.Thread.__init__(self) self.url = url self.tmp_file_name = tmp_file_name self.downloading_window = downloading_window def run(self): u = urllib2.urlopen(self.url) meta = u.info() file_size = int(meta.getheaders('Content-Length')[0]) print file_size f = open(os.path.join(os.environ['TEMP'], self.tmp_file_name), 'wb') downloaded_bytes = 0 block_size = 1024*8 while True: buffer = u.read(block_size) if not buffer: break f.write(buffer) downloaded_bytes += block_size print downloaded_bytes self.downloading_window.setProgress(float(downloaded_bytes)/file_size*100) f.close() return class DownloadingWindow(QWidget): def __init__(self): QWidget.__init__(self) vbox = QVBoxLayout() label = QLabel('downloading..') label.setAlignment(Qt.AlignCenter) vbox.addWidget(label) self.progress_bar = QProgressBar() self.progress_bar.setAlignment(Qt.AlignCenter) vbox.addWidget(self.progress_bar) self.setLayout(vbox) self.setGeometry(300, 300, 300, 50) def setProgress(self, value): if value > 100: value = 100 self.progress_bar.setValue(value) def closeEvent(self, event): os._exit(0) app = QApplication(sys.argv) w = DownloadingWindow() w.show() DownloadThread('http://ck.kolivas.org/apps/cgminer/3.3/cgminer-3.3.0-windows.zip', 'cgminer.zip', w).start() app.exec_() |
Have you used any command line program which represents its progress by displaying a dynamic progress bar in console? Think about Git, a popular version control system, when using git clone to fetch a repository, you will find that it's updating the downloading progress all the time.
The first program I wrote in my life is "Hello world" (maybe everyone is same as me, lol). I found that after "Hello world" text is outputted to console, the cursor moves to the end of line. Since then, I thought once text is outputted to console, it cannot be updated anymore. But later I found such dynamic progress bar (see above image), it's really amazing!
But how can we make one by our own hands? The key is to use the control character "\r", it's called Carriage Return.
Carriage Return is used to reset cursor's position to the beginning of line. Imagine we print "Hello" first, then we use Carriage Return to reset cursor's position to beginning of line, and print "world" next. What we will see in console is "world" replaced "Hello". To implement our thoughts, we wrote following code:
|
1 2 3 4 |
import sys sys.stdout.write('Hello') sys.stdout.write('\rworld') |
You may tell me running above code only display "world" in the console, and most importantly you didn't see that "world" is replacing "Hello". Well, actually that happens, just because the progress is too fast, your eyes cannot capture it:)
What we need do is let program blocks for some time after "Hello" is printed on console. time.sleep() function will make current thread sleep for specified number of seconds. So the improved code is following:
|
1 2 3 4 5 6 |
import sys import time sys.stdout.write('Hello') time.sleep(0.5) sys.stdout.write('\rworld') |
Now you can see "world" is replacing "Hello". You may ask me why not use "print" statement? Because print will send newline to console, we will not use it.
Next is the real progress bar. Progress bar is consisted of a bar which is increasing by time and a value indicates the progress. So let's focus on the "bar" first
|
1 2 3 4 5 6 |
import sys import time for i in range(30): sys.stdout.write('\r[{0}{1}]'.format('#'*i, ' '*(30-i))) time.sleep(0.1) |
Combining it with progress "value", we got a progress bar
|
1 2 3 4 5 6 |
import sys import time for i in range(100): sys.stdout.write('\r[{0}{1}] {2}'.format('#'*(i/10), ' '*(10-i/10), i)) time.sleep(0.1) |