pylocate32_python3.py

#!/usr/bin/python

#python3 variant, first version

#requires: Linux, KDE, PyQt4, toledo
from multiprocessing import Process
import subprocess, sys, os, time, threading, shlex, time, signal, datetime, base64, configparser
from PyQt4 import QtGui, QtCore
#import ctypes  # An included library with Python install.
#from pprint import pprint
#from inspect import getmembers
from pipes import quote
from tendo import singleton
me = singleton.SingleInstance() # will sys.exit(-1) if other instance is running

#sys.settrace
#globally used variables
app_icon = QtGui.QIcon()
tray_icon = QtGui.QSystemTrayIcon()
updateTimer = QtCore.QTimer()
searchTimer = QtCore.QTimer()
updateAnimCount = 0
searchAnimCount = 0
updatingProcess = ''
updateIsDone = False
UpdateAction = ''
output = ''
sucommand = ''
haveSearchResults = False
config = configparser.RawConfigParser()
scriptlocation = os.path.dirname(os.path.realpath(__file__))
fullconfpath = scriptlocation+'/pylocate32.conf'

#base64 encoded icons
strLocateIcon="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"

strAnim1="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAAA60lEQVRYw+3RwUrDQBSF4T/JTGsktmhpKG2zdWfpUrAFfZ8+Tp/IhTvpUhBKaUFoEEQQJThNxo1uGofMA9xvd4fLPXAGhBBCCCGEEEII8SeozQpNVHt3sZQYDljXgqrNKRlp7d3FkLNd5gvnwvEhTcacCaeeAV+sOCxeqXwDIlImwa3qaJRPTx9W2xezL95dRR0HhLTpqrTfyhigG+9Xyedlfr1WxYYdOaY5wGKpdDnmhilxY8B3+Dx6mG1GPHLPm08AVJTK9OMr7jjzaKg8XyUMKHgi8vmD355iLhgSNgYkQaIjTZseJ/+v/wAh7DojKomjHwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNS0wNi0wOVQyMDoxOTo0NSswMjowMNHZdLMAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDCghMwPAAAAAElFTkSuQmCC"

strAnim2="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAACm0lEQVRYw+2UXU8TQRiFn9mdaWlLXUqghXZLaZD4RfgwBhNTkOjf4ef4gzBceKEEozGRBEFECAUMVAJUt7vjRcemtF3AOy/23M2Zd+fse94zAxEiRIgQIUKECBEi/B8QXWuJwu7iw6Dx8Wigwwpk1zpLkWwXHwaPKjuvqsuhBZ0HKYosME3ylgIXrNNYPiK4rYBNlmmxJO8o5G18OtNK73kH9dMwozoFLOI4MjsUc8mhsLDMRkCARrQxmoBG/9nk/vyGYCvMqE4BjUYr3+UZc6Swsc2Gj49GdDCX1ufCamUz778NM6p7mAEN6eUSc7wkiYfXGo7CImhjJIq6VoNb6bxbE2FG9UyLoI8MGX6zzz4eoMgzjsNpGzNCiSFRVrOKvmqoUSFxtBDU+c4K77gAkjzhBTbf2phZlpiiyAIl62OoUSECmoA6P/jCOmdAmgwzZK8w/UzRYJgByppQo64RsHEoM8slkKCMgyLNGI+oY5HiLkMkkCiSYlI9VqLvaPJwflvUv7LL4d9RhQj4+ChcnnPfOJ7DJUWBChME2MQZodT6vMQiY9anwpvKToE1Vjm5QUCjsUkhGUWbsSeJkyXDFB4ePjaCmrmMMR7gam/wQ5oCHhutLIcJCAQ+NXapmg6GcckikSQ4Zo8DfuHjmwi7TOCIfmUrbBzirdsYJmBj47HHa9bMDGZYJIMEPLZZYZ1zAhOYJE+JMda85UHzst7YgYVPjW3em8ykmaYBQJ1jNg3fRJocJ2TRCPBotAf12hk4jDNjUl9mwBhrM0CZn1y0qpOM42C3//hNAgE+ijwVJmgAkhxFlHG8yCL3TD/NQ0bJo/B7PEbXCEgcHB6aFEmUKZbkGLzy5AgkMc7/RUCjsZA9twXK9HIVVk+L/gAuyPWV10SV3gAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNS0wNi0wOVQyMDoxOTo0NSswMjowMNHZdLMAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDCghMwPAAAAAElFTkSuQmCC"

strAnim3="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAADzUlEQVRYw+3W3VMTZxgF8N9mdwMEaUgGA0L4ELS1yqBoa2c6ftX+O/45/Xfa0XrRi+rYqdMZrR+gqCN+ITpiNNlsL7KNEUgJveZc7T7Pu3vmPc95zy572MMe9rCHPRBsuY/Ewi31bkgl6hrSbguiLfcVkypb6t1Qt+rBT6uXui7Y/KLYpLMWFHok2HBD49JzzV4JQhULwYXoi1jUi05v0zh9XH9ae91NqM0EOX2KUWUkXzUqlpPLGk1NqaCjkmpq7Ht7+Mnp24H73YTaTJBKpXFS9b1Fg0Jh1kgkUsGmyvvcrYmrZ+6OJ793E2rrMJsaUX10YNGPCurq7eHEcpodlUislsbl+0Pj1fWgm1DbuiXQr6TkoyeeqCM2bkbR647KmGkjwcH4RKx/tatQXeyYE6h55LJrNlDwjYtCDzsqJ1wwb9JZ07mbXYXqQpBqqnnpnhveYkjJcZXPKvvMa9hv2MFUV6H+gyBUdNAJ7zHgoKLYkCnH1OQMOmTEgEisEByOT8ZB//PDz04vBbVlK579O6ouBIlErOq8I5nio6oGTThjTlOoz5jp9uPTzpnK/TXx25kHE667am0HglQqNChyQJqNvaBPRcm8urpEKLCeHca8r1XTevnPIRPqbre93I0gEEisW7Ga7WC/qopIZMALjz31QSLJLFw1pxjsi8NYqKivfRq7EYRCdY9dcT2bwXHnlESoW3LZDe80M8MUfCdvqnXKm63DuuMOchLrlvyReWbIggaoeeFuVm9hyKg1FamAukanUXt20azhbHG/shlr3ssJBG2PhZrbpF3PLtqvKs4Un3HBVxrtXGp5LGrPpAeC7V2U0/BRYsAxRyXtXAr0G1TrlH4ngq0uGjXpCy8tWTPikBHrHbk0alKUCdYTwVYXnXLBtBVX3PGlWF9HLrW6Ex1R3sMONruobFHdG8tuib2y8VkulS0ak+t9B60ZdCbPrKK8YXMCh4woKJk27327uysXNSXijuTJG1NVMOWiU8pmDJl0zpyGKOvuykVNiUixnTxNfQryhuV9kMNbfY46otHuftiNi1pzaCXPMw+9VjRl2BsrnvqoITJhTtmaR14pmpLfjYs+oe6eXyybdVHeI7+65p2mAd/Kiy372V2zLprejYs+oea5v92SOumjdffbvqpYs+GFO25KnVTdjYs+IVQyJzJrWKxoxvHsmzyjKDZsVmrWsHC3M2ghNuMH60qqBo07Y04DkQPGDao6b0FJVSzZ5sdoR4LImLKmUCy0X9HRLJ0ieTkVJYlQbOP/EQTiLEUht82/Zty+2k6ifwAuVHOiJB8rZwAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNS0wNi0wOVQyMDoxOTo0NSswMjowMNHZdLMAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDCghMwPAAAAAElFTkSuQmCC"

strAnim4="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"

strAnim5="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"

strAnim6="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"


strAnim7="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"

strAnim8="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"

strAnim9="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAAExElEQVRYw+3X628T6RUG8N94ZpzEIThXh02cO+xudxEQ9lKpYtkI/p39c/rvtNqL1H7YXaUqrQRdrpuASGAxISI4zNjTDx4cE8dgV5X6peebnzN+H73nPO+jc/h//K8j6PodiYVdeK/INCRSWa8Poq7fFQsqXXivSOx48Medb3p+cPyg2IKvXFDqk+DApvSbJ5r9EoQqLgQb0elY1E+d9rM4e5g8rj/vVajjBAVDylFlulg1K1ZQyBNNTZmgA8k0paf2zz368lbgbq9CHSfIZLK4UfUH60aFwjzR0JAJjiGvCjfnf7hye67xY69CdTezKY2S2ZF115UkknZzYgXNDiQSq2fx5N2xuepe0KtQJ6olMGzChNceeSRBbM6ysucdyBlLpoOV+FJseKdnoXrIsSBQt+1bPzlAyeeuCf3agVyy4bwFX1kq3OhZqB4Emaa639yxaR9jJlxUeQs55bzUjHErmZ6FegdBqGzFJa8wYkVZbMyiT9UVjDpr2ohIrBSciy/HwfCTc7tf3gvq923ZfdOqHgQNDbGqr32cV3xW1ah5V6xpCg05Y6n99yVXLRb+Of/XKw/m/ewHtfcQZDKhUZEPZHnbS4ZUTDgvkWgIBfbyx1j0O9Usmfz7mHmJW20t9yIIBBr2bNnJbzCjqiISGfHUQ48damjkEq5aUw5OxWEsVDbUfo29CEKhxEPf+TnvwUVXTYiQuOdbm15q5oIp+b2ixdYrb7Ye63tvUNCw556/5ZoZc0EK6p66neOtGDOrpiITkEg7hdq3ilaN5x8Pm7Ss5pWCQNDWWKh5gtv1raIZVXFe8WUbPpK2famlsajdkz4ITlZRQeq1hhGf+kSj7UuBYaPqnaV/H0G3imYtOO0399RMO2vaXocvzVoQ5QXri6BbRZ/ZsGTLd37xodhQhy+1svMdVt7HDY6raNK6xAv33RR75uAtX5q07oxC/zdo9aDTeVaVFY1bEzhrWsmEJee9amcHUlFTQ9zhPEVnVJUsuuYzk5aNWXDVmlSUZwdSUVNDpNx2nqYhJUXjig4VsG/IJz6WtrOHg6io1YeW8+z61XNli8a9sOWx11KReWsm1Wx7pmxRcRAVHUXijj+7b9U1Rdu+95OXmkZ8oSh235/ctuqapUFUdBR1T/zLTZnLXttzt62ripoDT/3ihsxl1UFUdBTDpqwKrJhUMmXNs/wGSyaUTDsnsGp8MBUdRWzVdTVTloxZtOFDdQ2ReQvGLLtuXdmieBAVQZY7T8mFHNmXmVPJB/CWlqiaG1xFBaHU4w7neeaOh1KhYXOWjbWR1jsY0IsKQknuPB+JDdnyvR/zd/uFa5bfQj739aBeFGi85Tw1D/yj7TwXVY4hlwbzokDBcK6Qs6aNmrKmls90a6ZOQIYHIWjKDOcKaTlPSz9v5tTFE5Ci7ITx+kSCTF1NzYiqD4TYk5kzk+dj2QlITU29S0fdBAVRGu/YxKhQQfPEzaAbeWnTjjQWHU1F3QSBQJCE2/7iTr5uZvlx79p2mpoSO7YlYeuMXgRNh/bS3aen99zqe5d9U9hUIn1hz+FRM44TpHZsZmlSSgY6vCMO3LCTz2i6F/FIRdVMPgL9J5F4YtvuG4qTN/2+Nth3V6r37v9fjn8DpZv6PoX67F0AAAAldEVYdGRhdGU6Y3JlYXRlADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDDR2XSzAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE1LTA2LTA5VDIwOjE5OjQ1KzAyOjAwoITMDwAAAABJRU5ErkJggg=="

strAnim10="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAAEOklEQVRYw+3Xy28b1xkF8N/McCiSqkxZ1MOmKEqWnAfsQM6jQRdNE8NZFMgq6KL/YRdZdOE/oEUSoO2iaV24LZA2dv2QHNiKI5o2LFMekrcLTknKkiVzXZ/l+Tj33Pt9Zw7vcBCn/Mpvq+1fh6vhbrgaPg9xEIQ4fB6uhjsHmM/CF+FRCCGER+E34ZcheeQLn0kOLlhwJAIiJXPqnmDGnJLkAFNTEoNYWU09bpdCLTvb2ZXpCscK9PUULNjUs4eKTQtKai7o6IhNu2RZGZSdtSkkPyzsXLzV6dyxbUf3RIFU3Ufe0EXBkmUVdT+3ricx5Yxm/njBmmAt/efKn35xp+Gv/qB1gkAQJKYVnBm2q2LKglkXZDI9iUhbBCouahaypetzVgU3Ruu+RCAS6Wnb8kCG1IKGRQUFZQ/dc9++nh5INWyoRj9Jk1SiaiofzssFEonMPV/5i2cou+RjpxWQueVL1zzV18/3/zNFTbGYviD8b8THnCDW03bL33LPzNjM29rx0I2cH2DGkpZFQUSmm+seP4O+RNU57+YnWDeb/7hkzpqWZ2KRCGXnVCX6o42fJNDTk2r4xNtjM0jzjq+57C1dSf5WpZY0FIYzeQWBkYvOjrko1vVcT9lFF/RksryhJdM6460/SeCwi5asOOVHt7TMO29e2/e+H6sW8oa9ksBhF33gslVbvvKdN6Wm3PWlb+wNq8vDlr3SCV500Zz3ZB677VupXXt+dNO1seoZ8aufYDCDGU0X8+RZV1U0a0PkvHkVp616x7NhdSIXDbJo2Uc29CWKzmioaLriA3PWzFjxsQ1dhbw6kYsGaVp12jsymb4pFUWzivbFeGLKBW/rDqv7k7hoMIdB8uy465GqplmPbbnvua6CZRvmtGzbVdVUnMRFI2Ru+r3b1l1RtO1r33iqr+xDRanbfueGdVesTuKiETp+8G/fCt73XNt/hr5a1LLnoe/8XfC+xiQuGqGkZl3knDkVNRt28xOsOq1i3hsi62Ync9EIqXWfaqlZNaPpsjd19BQsWzFjzafeU9WUTuIiCHnyVGzmzBNB3aKCVJJ7iYb65C6KJbrujyXPrpvu6UqU1K2ZGTKD92DCLIolsjx53pKasuVrf87f2w9dsXaA+alPJs2iSO9A8rTc8Y9h8lyy+ALz7mRZFImVcoecN29azYZWfkfaUDuCKU0i0BeUcocMkmfgn0H61zWPYIrC+J/xcQJBR0tLWcNZCdqCuoW8ngpHMC0tnUM+OiwQK3TTB65hWiLW1xNEYyPsHck8dc0D3VRhdCs6LBCJRFmy7Y9uSiUiIV8uHj7X1z+CyTywLUsGa7xMoG9fu7vz8FTbv44Y2XEIujLdx9r2R8N4UaBnx/Ugq2QTLT6GPdftjDLjxU2mFq1YPDmjXoquHVt28hvNIYEoD5rJunOwU73xD5DXeI3XeI3/C/wXBWipXGm54ZIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDDR2XSzAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE1LTA2LTA5VDIwOjE5OjQ1KzAyOjAwoITMDwAAAABJRU5ErkJggg=="

strAnim11="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAACxklEQVRYw+3UTW+UVRjG8d/zNp1OLVM6pcD0lRYlEoNIZMUCAwu2hAVfkrDoB9BEFm40waALFKt9M4GRdBwaypTnmTkuGAulU+2YuJv/8rpz7uucc1+5OcgJd9yvtu6GlbARVsLtEAdBiMPtsBLWw71wK5wMt8K9sH6ouhFWwt1QbbnvjhN/N0z1JSBSNqluB+MmlSVG1ZxVMyo5VI165w5ypEFHquaitrZYxSWnlE27rGpZ3bjTPtH2StKrpjq6xzXo6srUXbOkK1Fy2oyKWdddNmneB2Zcc04hMeK0GclgBh2pqgkX5XJdIypKJpTsibFjxMcuKPare8LxvwgiqdSohg1/qpo34YVNT71WSM1YNqlpy7aqeSWRaBCDN+RWfWXNkhtKtjzwnZe6Rl1VklnzpV8suWFBIhncoO0PP3ssuOK1ll9930vOtKZdzz3xg+CKWfF/eUFZzZLIOZMqapZt916w4KSKKR+KLJmQ6A42gzdkltzUVLNg3LwvfKStIzVjzrhFN32mal6mozOIQVB4raPiUk/ZEdRNS2WSXpaYVR88RbFE4anfNE05b8q2Vb8rJMrqFo3vK6mSM+akg6Qolsht+toTF2RGbHrgW6/Exlx1w+IB5XPXzQySokik44U1j2W27Wpa9+P+5vnU9HvKZWcGSVEkVu4l5LwpY2qWNe2iYlmtj1IexKArKPcSMmlxPz85MnXzfZSScNxdFLQ1NY2adVaClqDuVK+eCX2Upqb2oRwdNoilRfbMQ4xJxLo6guidEXb6Ki899EyRScVHG0QiUZ5s+caqTCISeu3i/XNd3T5K7pktefKmx1EGXXtaReP5iZaf+ozsnwgKueKFlr23w3jfoKPhUZBX8oGav8OuRxpvd8b7l8xMmzP97zvqSAoNmxry/gZRb9EM9jsHf6ojV/RZS0OGDBkyZMiQIUP+T/4CKBEQ67CXq5QAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDDR2XSzAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDE1LTA2LTA5VDIwOjE5OjQ1KzAyOjAwoITMDwAAAABJRU5ErkJggg=="

strAnim12="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAQAAAD9CzEMAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAP+Hj8y/AAAACXBIWXMAAABIAAAASABGyWs+AAABVklEQVRYw+3SP0/CQBjH8e+11AAGiGCIRWTRXeJu4sZKGHiThKFvwpWEzcFBZKExIdVIINf2caD+IVzjn9HcZ/z17vnlrge7qgwY16KhBDKTkfTkSHoykgcJpC+OIIgjfQkMyUwCGUotYsyA6vvAAkYCKEo08GlQwqVInRYvQIU6RUOisn27cgq241tcUeOcFhV8uiSsgDJdfENSQhnm5J5AKNLhhkuO6FChzTUXaMDDp21IDpCfnkBYs2RJiVNOcIEIwec4++4hhmTJkvVexX6BQyH2FkyAQ1wcUhIEhYubLUmMySsTFsQeBZz8AoVCaXfOLfd4uCgkG+d87EtJDYlmwRztbmfkFaRsiOLwqRpxZ/xp+YQYTfxMxIY0ryAhZCrosv7V8C9WTAlJPq9kl0eTM5r5z/dbMSGPhGhzgaKQXf1fCQma2PBiLcuyLMuyLMuyrP/uDcu0jpWAf2bBAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE1LTA2LTA5VDIwOjE5OjQ1KzAyOjAw0dl0swAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxNS0wNi0wOVQyMDoxOTo0NSswMjowMKCEzA8AAAAASUVORK5CYII="

strAnim13="iVBORw0KGgoAAAANSUhEUgAAADAAAAAwAQAAAAB/ecQqAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAAHdihOkAAAACXBIWXMAAABIAAAASABGyWs+AAAADUlEQVQY02NgGAXUBAABUAABp+LaFgAAACV0RVh0ZGF0ZTpjcmVhdGUAMjAxNS0wNi0wOVQyMDoxOTo0NSswMjowMNHZdLMAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTUtMDYtMDlUMjA6MTk6NDUrMDI6MDCghMwPAAAAAElFTkSuQmCC"


signal.signal(signal.SIGINT, signal.SIG_DFL) #So we can Ctrl+C out

def readconfig(sourceClass,strVar):
    try:
        config.read(fullconfpath)
        #print "DEBUG - SettingsWindow - readconfig("+strVar+")"
        var = config.getboolean("Settings", str(strVar))
        return var
    except Exception as e:
        QtGui.QMessageBox.warning(main_window, "pyLocate32 - Settings file error", "Settings file is corrupt\nFunction:readconfig("+str(SettingsWindow)+",strVar)\nError:"+str(e))

def writeconfig(sourceClass, strVar, value):
    #print "DEBUG - SettingsWindow - writeconfig("+strVar+",("+str(value) +")"
    try:
        config.set("Settings", strVar, value)
        with open(fullconfpath, 'w+') as configfile:
            config.write(configfile)
    except Exception as e:
        QtGui.QMessageBox.warning(main_window, "pyLocate32 - Settings", "Error while writing "+fullconfpath+":\nFunction:SettingsWindow.writeconfig("+str(SettingsWindow)+", strVar, value)\nError:"+str(e))

#from http://www.linuxquestions.org/questions/programming-9/pyside-qtreewidget-numeric-sorting-4175502323/#post5156692
#with slight modification
class ProxyModel(QtGui.QSortFilterProxyModel):

    def __init__(self, parent=None):
        super(ProxyModel, self).__init__(parent)

    def lessThan(self, left, right):
        leftData = self.sourceModel().data(left).toString()
        rightData = self.sourceModel().data(right).toString()
        if leftData == 'Access Denied':
            return True
        elif leftData == '<1':
            return True
        elif rightData == 'Access Denied':
            return False
        elif rightData == '<1':
            return False
        else:
            try:
                return int(leftData) < int(rightData)
            except ValueError:
                return leftData < rightData

#custom class so we can use the context menu on a qtreeview
class myQTreeView(QtGui.QTreeView):

    global haveSearchResults
    global proxymodel
    proxymodel = ProxyModel()
    
    @QtCore.pyqtSlot()
    def OpenFile(self):
        indexlist = self.selectedIndexes()
         #selection is more than 1 row (multiple files)
        if len(indexlist) > 3:
            reply = QtGui.QMessageBox.warning(self, "Open File question", "Multiple items selected, open all?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                for indexitem in self.selectedIndexes():
                    if indexitem.column() == 0:
                        filepath = proxymodel.sibling(indexitem.row(), 0, indexitem).data().toString()
                        filepath2 = str(filepath)
                        filepath3 = quote(filepath2)
                        result = subprocess.call(shlex.split("xdg-open " + filepath3))
        #one row selected (one file)
        else:
            filepath = proxymodel.sibling(self.currentIndex().row(), 0, self.currentIndex()).data().toString()
            filepath2 = str(filepath)
            filepath3 = quote(filepath2)
            result = subprocess.call(shlex.split("xdg-open " + filepath3))

    @QtCore.pyqtSlot()
    def OpenFolder(self):
        indexlist = self.selectedIndexes()
        #selection is more than 1 row (multiple files)
        if len(indexlist) > 3:
            reply = QtGui.QMessageBox.warning(self, "Open Folder question", "Multiple items selected, open all folders?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                for indexitem in self.selectedIndexes():
                    if indexitem.column() == 0:
                        filepath = proxymodel.sibling(indexitem.row(), 0, indexitem).data().toString()
                        filepath2 = str(filepath)
                        filepath3 = os.path.dirname(filepath2)
                        filepath4 = quote(filepath3)
                        result = subprocess.call(shlex.split("xdg-open " + filepath4))
        #one row selected (one file)
        else:
            filepath = proxymodel.sibling(self.currentIndex().row(), 0, self.currentIndex()).data().toString()
            filepath2 = str(filepath)
            filepath3 = os.path.dirname(filepath2)
            filepath4 = quote(filepath3)
            result = subprocess.call(shlex.split("xdg-open " + filepath4))

    @QtCore.pyqtSlot()
    def OpenWith(self):
        indexlist = self.selectedIndexes()
        filepath = ''
        #selection is more than 1 row (multiple files)
        if len(indexlist) > 3:
            reply = QtGui.QMessageBox.warning(self, "Open File With question", "Multiple items selected, continue?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
            if reply == QtGui.QMessageBox.Yes:
                reply = QtGui.QMessageBox.warning(self, "Open File With question2", "Open all items with same program?", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
                if reply == QtGui.QMessageBox.Yes:
                        #open each file with the same program"
                    text, ok = QtGui.QInputDialog.getText(self, 'Open with...', 'Open selected files with:')
                    if ok:
                        for indexitem in self.selectedIndexes():
                            if indexitem.column() == 0:
                                filepath = proxymodel.sibling(indexitem.row(), 0, indexitem).data().toString()
                                filepath2 = str(filepath)
                                filepath3 = quote(filepath2)
                                try:
                                    result = subprocess.call(shlex.split(str(text) + " " + filepath3))
                                except Exception as e:
                                    QtGui.QMessageBox.warning(main_window, "Open With error", "Error when trying to open \""+str(filepath)+"\" with \""+str(text)+"\".\n\nError message: "+str(e))
                else:
                    #open each file with a different program
                    for indexitem in self.selectedIndexes():
                        if indexitem.column() == 0:
                            text, ok = QtGui.QInputDialog.getText(self, 'Open with...', 'Open \"'+str(proxymodel.sibling(indexitem.row(), 0, indexitem).data().toString() +'\" with:'))
                            if ok:
                                filepath = proxymodel.sibling(indexitem.row(), 0, indexitem).data().toString()
                                filepath2 = str(filepath)
                                filepath3 = quote(filepath2)
                                try:
                                    result = subprocess.call(shlex.split(str(text) + " " + filepath3))
                                except Exception as e:
                                    QtGui.QMessageBox.warning(main_window, "Open With error", "Error when trying to open \""+str(filepath)+"\" with \""+str(text)+"\".\n\nError message: "+str(e))
        else: #one row selected (one file)
            text, ok = QtGui.QInputDialog.getText(self, 'Open with...', 'Open \"'+str(proxymodel.sibling(self.currentIndex().row(), 0, self.currentIndex()).data().toString() +'\" with:'))
            if ok:
                filepath = proxymodel.sibling(self.currentIndex().row(), 0, self.currentIndex()).data().toString()
                filepath2 = str(filepath)
                filepath3 = quote(filepath2)
                try:
                    result = subprocess.call(shlex.split(str(text) + " " + filepath3))
                except Exception as e:
                    QtGui.QMessageBox.warning(main_window, "Open With error", "Error when trying to open \""+str(filepath)+"\" with \""+str(text)+"\".\n\nError message: "+str(e))



    @QtCore.pyqtSlot(QtCore.QPoint)
    def contextMenuRequested(self, point):
        if haveSearchResults:
            menu = QtGui.QMenu()

            action1 = menu.addAction("Open file")
            self.connect(action1, QtCore.SIGNAL("triggered()"), self, QtCore.SLOT("OpenFile()"))

            action2 = menu.addAction("Open folder")
            self.connect(action2, QtCore.SIGNAL("triggered()"), self, QtCore.SLOT("OpenFolder()"))

            seperator1 = menu.addSeparator()

            action3 = menu.addAction("Open with...")
            self.connect(action3, QtCore.SIGNAL("triggered()"), self, QtCore.SLOT("OpenWith()"))

            menu.exec_(self.mapToGlobal(point))


    @classmethod
    def _createRow(cls, *args):
        return [cls._createItem(value) for value in args]

    @staticmethod
    def _createItem(data):
        item = QtGui.QStandardItem(data)
        flags = item.flags()
        flags ^= QtCore.Qt.ItemIsEditable
        item.setFlags(flags)
        return item

#thanks qt creator!
try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)

class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        self.centralWidget = QtGui.QGroupBox(MainWindow)
        self.centralWidget.setObjectName(_fromUtf8("centralWidget"))

        form = QtGui.QGridLayout()

        MainWindow.setObjectName(_fromUtf8("MainWindow"))
        MainWindow.resize(320, 200)
        MainWindow.setTabShape(QtGui.QTabWidget.Rounded)

        self.lineEdit = QtGui.QLineEdit()
        self.lineEdit.setGeometry(QtCore.QRect(10, 10, 211, 26))
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
        
        self.buttonSearch = QtGui.QPushButton()
        self.buttonSearch.setGeometry(QtCore.QRect(230, 10, 81, 26))
        self.buttonSearch.setObjectName(_fromUtf8("buttonSearch"))
        
        form.addWidget(self.lineEdit, 1, 0)
        form.addWidget(self.buttonSearch, 1, 1)
        
        self.treeView = myQTreeView(self.centralWidget)
        self.treeView.setSortingEnabled(True)
        self.treeView.setSelectionMode(QtGui.QAbstractItemView.MultiSelection)
        self.treeView.setGeometry(QtCore.QRect(10, 40, 301, 141))
        self.treeView.setObjectName(_fromUtf8("treeView"))
        form.addWidget(self.treeView, 4, 0)
        
        self.buttonStop = QtGui.QPushButton()
        self.buttonStop.setGeometry(QtCore.QRect(230, 10, 81, 26))
        self.buttonStop.setObjectName(_fromUtf8("buttonStop"))
        form.addWidget(self.buttonStop, 3, 1)
        self.buttonStop.setEnabled(False)

        self.treeView.connect(self.treeView, QtCore.SIGNAL("triggered()"), self.treeView.OpenFile)
        self.treeView.connect(self.treeView, QtCore.SIGNAL("triggered()"), self.treeView.OpenFolder)
        self.treeView.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
        self.treeView.connect(self.treeView, QtCore.SIGNAL("customContextMenuRequested(QPoint)"), self.treeView, QtCore.SLOT("contextMenuRequested(QPoint)"))

        #can I just remove this?
        #self.menuBar = QtGui.QMenuBar(MainWindow)
        #self.menuBar.setGeometry(QtCore.QRect(0, 0, 320, 22))
        #self.menuBar.setObjectName(_fromUtf8("menuBar"))
        #MainWindow.setMenuBar(self.menuBar)
        #self.mainToolBar = QtGui.QToolBar(MainWindow)
        #self.mainToolBar.setObjectName(_fromUtf8("mainToolBar"))
        #MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar)
        
        self.statusBar = QtGui.QStatusBar(MainWindow)
        self.statusBar.setObjectName(_fromUtf8("statusBar"))
        MainWindow.setStatusBar(self.statusBar)
        MainWindow.setCentralWidget(self.centralWidget)

        self.centralWidget.setLayout(form)
        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)
    
    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(_translate("MainWindow", "pyLocate32 - Search", None))
        self.buttonSearch.setText(_translate("buttonSearch", "Search", None))
        self.buttonStop.setText(_translate("buttonStop", "Stop", None))



class MainWindow(QtGui.QMainWindow, Ui_MainWindow):
    global config

    def __init__(self, win_parent=None):
        super(MainWindow, self).__init__()
        self.setupUi(self)
        self.buttonSearch.clicked.connect(self.on_buttonSearch_clicked)
        self.lineEdit.returnPressed.connect(self.lineEditReturnPressed)
        self.lineEdit.setFocus()
        self.buttonStop.clicked.connect(self.on_buttonStop_clicked)
        
    def on_buttonSearch_clicked(self, b=None):
        doSearch()

    def lineEditReturnPressed(self, b=None):
        doSearch()
        
    def on_buttonStop_clicked(self, b=None):
        stopSearch()
        
    def closeEvent(self, event):
        if (readconfig(self,"MinimizeToTray")):
            self.hide()
            event.ignore()
        else:
            event.accept()

class Ui_SettingsWindow(object):
    def setupUi(self, SettingsWindow):
        SettingsWindow.setObjectName(_fromUtf8("SettingsWindow"))
        SettingsWindow.resize(360, 110)
        self.centralWidget = QtGui.QWidget(SettingsWindow)
        self.centralWidget.setObjectName(_fromUtf8("centralWidget"))

        self.cb_minimize = QtGui.QCheckBox(self.centralWidget)
        self.cb_minimize.setGeometry(QtCore.QRect(20, 10, 351, 21))
        self.cb_minimize.setObjectName(_fromUtf8("cb_minimize"))

        self.cb_notification = QtGui.QCheckBox(self.centralWidget)
        self.cb_notification.setGeometry(QtCore.QRect(20, 40, 351, 21))
        self.cb_notification.setObjectName(_fromUtf8("cb_notification"))
        
        self.cb_hidemainonstartup = QtGui.QCheckBox(self.centralWidget)
        self.cb_hidemainonstartup.setGeometry(QtCore.QRect(20, 70, 351, 21))
        self.cb_hidemainonstartup.setObjectName(_fromUtf8("cb_hidemainonstartup"))

        self.retranslateUi(SettingsWindow)
        QtCore.QMetaObject.connectSlotsByName(SettingsWindow)

    def retranslateUi(self, SettingsWindow):
        SettingsWindow.setWindowTitle(_translate("SettingsWindow", "pyLocate32 - Settings", None))
        self.cb_minimize.setText(_translate("SettingsWindow", "Minimize Search window to tray on exit.", None))
        self.cb_notification.setText(_translate("SettingsWindow", "Show notification when finished updating database", None))
        self.cb_hidemainonstartup.setText(_translate("SettingsWindow", "Hide Main window on startup", None))

class SettingsWindow(QtGui.QWidget, Ui_SettingsWindow):

    def __init__(self, win_parent=None):
        super(SettingsWindow, self).__init__()
        self.setupUi(self)
        self.cb_minimize.stateChanged.connect(self.cb_minimize_changed)
        self.cb_notification.stateChanged.connect(self.cb_notification_changed)
        self.cb_hidemainonstartup.stateChanged.connect(self.cb_hidemainonstartup_changed)

        if os.path.isfile(fullconfpath):
            config.read(fullconfpath)
            try:
                MinimizeToTray = config.getboolean("Settings", "minimizetotray")
                UpdateFinishedNotification = config.getboolean("Settings", "updatefinishednotification")
                HideMainOnStartup = config.getboolean("Settings", "hidemainonstartup")
                
                if(MinimizeToTray):
                    self.cb_minimize.setCheckState(2)
                else:
                    self.cb_minimize.setCheckState(0)

                if(UpdateFinishedNotification):
                    self.cb_notification.setCheckState(2)
                else:
                    self.cb_notification.setCheckState(0)
                    
                if(HideMainOnStartup):
                    self.cb_hidemainonstartup.setCheckState(2)
                else:
                    self.cb_hidemainonstartup.setCheckState(0)

            except Exception as e:
                QtGui.QMessageBox.warning(main_window, "pyLocate32 - Settings file error", "Settings file is corrupt\nError:"+str(e)+"\nDelete pyLocate32.conf and restart pyLocate32.")
        else:
            QtGui.QMessageBox.information(main_window, "pyLocate32 - Settings", "Config file missing, creating new config file.")
            config.add_section("Settings")
            config.set("Settings", "minimizetotray", "True")
            config.set("Settings", "updatefinishednotification", "True")
            config.set("Settings", "hidemainonstartup", "True")
            try:
                with open(fullconfpath, 'wt') as configfile:
                    config.write(configfile)
                QtGui.QMessageBox.information(main_window, "pyLocate32 - Settings", "Written config file "+fullconfpath+".")
            except Exception as e:
                QtGui.QMessageBox.warning(main_window, "pyLocate32 - Settings", "Error while writing "+fullconfpath+":\n"+str(e))

    def readconfig(self,strVar):
        try:
            config.read(fullconfpath)
            var = config.getboolean("Settings", str(strVar))
            return var
        except Exception as e:
            QtGui.QMessageBox.warning(main_window, "pyLocate32 - Settings file error", "Settings file is corrupt\nFunction:SettingsWindow.readconfig(self,strVar)\nError:"+str(e))

    def writeconfig(self, strVar, value):
        try:
            config.set("Settings", strVar, value)
            with open(fullconfpath, 'wb') as configfile:
                config.write(configfile)
        except Exception as e:
            QtGui.QMessageBox.warning(main_window, "pyLocate32 - Settings", "Error while writing "+fullconfpath+":\nFunction:SettingsWindow.writeconfig(self, strVar, value)\nError:"+str(e))

    def cb_minimize_changed(self, state):
        if state == 2:
            writeconfig(self, "MinimizeToTray", True)
        elif state == 0:
            writeconfig(self, "MinimizeToTray", False)
        var = self.readconfig("MinimizeToTray")

    def cb_notification_changed(self, state):
        if state == 2:
            writeconfig(self, "UpdateFinishedNotification", True)
        elif state == 0:
            writeconfig(self, "UpdateFinishedNotification", False)
            
    def cb_hidemainonstartup_changed(self, state):
        if state == 2:
            writeconfig(self, "HideMainOnStartup", True)
        elif state == 0:
            writeconfig(self, "HideMainOnStartup", False)
            
    def closeEvent(self, event):
        self.hide()
        event.ignore()

class TrayIcon(QtGui.QSystemTrayIcon):

    def __init__(self, win_parent=None):
        QtGui.QMainWindow.__init__(self, win_parent)

        self.setToolTip("pyLocate32")

        restoreTrayIcon()

        #menu icons below, currently empty
        OpenIcon = QtGui.QIcon("") #needs icon?
        UpdateIcon = QtGui.QIcon("") #needs icon?
        StopUpdateIcon = QtGui.QIcon("") #needs icon?
        SettingsIcon = QtGui.QIcon("") #needs icon?
        AboutIcon = QtGui.QIcon("") #needs icon?
        QuitIcon = QtGui.QIcon("") #needs icon?

        #right click menu content
        global UpdateAction
        global OpenAction
        global StopUpdateAction
        global AboutAction
        global QuitAction
        ActionsMenu = QtGui.QMenu()
        OpenAction = ActionsMenu.addAction(OpenIcon, "Open Locate...")
        ActionsMenu.addSeparator()
        UpdateAction = ActionsMenu.addAction(UpdateIcon, "Update Database")
        StopUpdateAction = ActionsMenu.addAction(StopUpdateIcon, "Stop Updating")
        ActionsMenu.addSeparator()
        SettingsAction = ActionsMenu.addAction(SettingsIcon, "Settings")
        AboutAction = ActionsMenu.addAction(AboutIcon, "About")
        ActionsMenu.addSeparator()
        QuitAction = ActionsMenu.addAction(QuitIcon, "Exit")

        # -- Now add the menu:
        # -- trigger the check action to set current state
        self.setContextMenu(ActionsMenu)

        # -- connect the actions:
        self.connect(OpenAction, QtCore.SIGNAL("triggered()"), showSearchScreen)
        self.connect(UpdateAction, QtCore.SIGNAL("triggered()"), updateDB)
        self.connect(StopUpdateAction, QtCore.SIGNAL("triggered()"), stopUpdateDB)
        self.connect(SettingsAction, QtCore.SIGNAL("triggered()"), showSettingScreen)
        self.connect(AboutAction, QtCore.SIGNAL("triggered()"), showAbout)
        self.connect(QuitAction, QtCore.SIGNAL("triggered()"), exitProperly)

        #disable "Stop Updating" as nothing is running
        StopUpdateAction.setEnabled(False)


def showSearchScreen():
    global main_window
    main_window.show()

#from https://stackoverflow.com/a/1526089
def modif_date(filename):
    try:
        t = os.path.getmtime(filename)
        return datetime.datetime.fromtimestamp(t)
    except Exception as e:
        return str(e)

def file_size(path):
    try:
        itemsize = os.path.getsize(path)
        #itemsize = itemsize/1024 #KB
        itemsize = itemsize/1048576 #MB
        if itemsize == 0:
            itemsize = "<1"
        else:
            itemsize = str(itemsize)
        return itemsize
    except Exception as e:
        return str(e)

def doSearch():
    global main_window
    global viewmodel
    global output
    global searchIsDone
    global searchAnimCount
    global haveSearchResults
    global searchThreadVar
    global proxymodel
    global searchThreadAlive
    searchThreadAlive = True
    main_window.buttonSearch.setEnabled(False)
    main_window.buttonStop.setEnabled(True)
    continuesearch = True
    searchIsDone = False
    main_window.treeView.setModel(None)

    main_window.lineEdit.setEnabled(False)

    viewmodel = QtGui.QStandardItemModel()

    proxymodel.setSourceModel(viewmodel)


    #on empty search field, list everything, else show searching
    if main_window.lineEdit.text() == '' or main_window.lineEdit.text() == '*':
        reply = QtGui.QMessageBox.warning(main_window, "Search question", "Search for everthing?  This is slow.", QtGui.QMessageBox.Yes|QtGui.QMessageBox.No)
        if reply == QtGui.QMessageBox.Yes:
            viewmodel.appendRow(QtGui.QStandardItem(""))
            viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, "Searching everything - please wait")
            viewmodel.removeRows(0, 1)
            main_window.lineEdit.setText('*')
        elif reply == QtGui.QMessageBox.No:
            viewmodel.clear()
            main_window.buttonSearch.setEnabled(True)
            main_window.buttonStop.setEnabled(False)
            main_window.lineEdit.setEnabled(True)
            continuesearch = False
            haveSearchResults = False
    else:
        viewmodel.appendRow(QtGui.QStandardItem(""))
        viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, "Searching - please wait")
        viewmodel.removeRows(0, 1)

    if continuesearch:
        main_window.treeView.setModel(proxymodel)
        main_window.treeView.setEnabled(False)
        main_window.show()
        searchThreadVar = threading.Thread(target=searchThread, args=(""))
        searchAnimCount = 0
        searchTimer.start(200)
        app.setOverrideCursor(QtGui.QCursor(QtCore.Qt.BusyCursor))
        searchThreadVar.start()
        
def stopSearch():
    global searchTimer
    global searchIsDone
    global viewmodel
    global haveSearchResults
    global searchprocess
    global searchThreadAlive
    searchIsDone = True
    viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, "Search stopped.")
    viewmodel.setHeaderData(1, QtCore.Qt.Horizontal, "Date")
    viewmodel.setHeaderData(2, QtCore.Qt.Horizontal, "Size in MB")
    haveSearchResults = False
    searchAnimCount = 0
    main_window.treeView.setEnabled(True)
    main_window.buttonSearch.setEnabled(True)
    main_window.buttonStop.setEnabled(False)
    main_window.lineEdit.setEnabled(True)
    searchTimer.stop()
    app.restoreOverrideCursor()
    searchThreadAlive = False
    if viewmodel.rowCount() == 1:
        headerstring = str(viewmodel.rowCount())+" result-Path"
    else:
        headerstring = str(viewmodel.rowCount())+" results-Path"
    viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, headerstring)
    viewmodel.setHeaderData(1, QtCore.Qt.Horizontal, "Date")
    viewmodel.setHeaderData(2, QtCore.Qt.Horizontal, "Size in MB")



def searchThread():
    global haveSearchResults
    global searchIsDone
    global viewmodel
    global searchThreadPid
    global searchprocess
    global searchThreadAlive
    haveSearchResults = False
    searchTimer.start()
    try:
        args = shlex.split("/usr/bin/locate "+str(main_window.lineEdit.text()) +" "+ "universal_newlines=True")
        #print(str(args))
        #universal_newlines=False is to open in textmode
        searchprocess = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        output = searchprocess.communicate("universal_newlines=True")
        output2 = output[0].decode().split("\n")
        if output2 == ['']:
            haveSearchResults = False
        else:
            if  searchThreadAlive:
                haveSearchResults = True
                viewmodel.appendRow(QtGui.QStandardItem(""))
                viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, "Creating list - please wait") #QObject::connect: Cannot queue arguments of type 'Qt::Orientation' (Make sure 'Qt::Orientation' is registered using qRegisterMetaType()
                viewmodel.removeRows(0, 1)
            for item in output2:
                #do something here otherwise segfault?
                #print("searchThreadAlive=%d" % searchThreadAlive)
                pass
                if not searchThreadAlive:
                    #print "DEBUG - searchThread() - killing searchThread"
                    return
                itempath = QtGui.QStandardItem(item)
                if not itempath.text() == '':
                    path = itempath.text()
                    moddate = str(modif_date(path))
                    itemdate = QtGui.QStandardItem(moddate)
                    itemsizecount = file_size(path)
                    itemsize = QtGui.QStandardItem(str(itemsizecount))
                    rowlist = ([itempath, itemdate, itemsize])
                    viewmodel.appendRow(rowlist)
    except Exception as e:
        viewmodel.appendRow(QtGui.QStandardItem("searchThread Error - "+ str(e)))
        raise
    pass
    searchIsDone = True

def searchAnimation():
    global searchTimer
    global searchAnimCount
    global haveSearchResults
    if searchIsDone == True:

        if not haveSearchResults:
            viewmodel.clear()
            viewmodel.appendRow(QtGui.QStandardItem(""))
            viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, "No results.")
            viewmodel.removeRows(0, 1)
        else:
            if viewmodel.rowCount() == 1:
                headerstring = str(viewmodel.rowCount())+" result-Path"
            else:
                headerstring = str(viewmodel.rowCount())+" results-Path"
            viewmodel.setHeaderData(0, QtCore.Qt.Horizontal, headerstring)
            viewmodel.setHeaderData(1, QtCore.Qt.Horizontal, "Date")
            viewmodel.setHeaderData(2, QtCore.Qt.Horizontal, "Size in MB")
        searchAnimCount = 0
        app.restoreOverrideCursor()
        main_window.treeView.setEnabled(True)
        main_window.buttonSearch.setEnabled(True)
        main_window.buttonStop.setEnabled(False)
        main_window.lineEdit.setEnabled(True)
        searchTimer.stop()

def updateCommand():
    global notify_on_updatedb_complete
    global updateIsDone
    returncode = subprocess.call(shlex.split(sucommand+" /usr/bin/updatedb"))
    updateIsDone = True
    if (readconfig("updateCommand()","UpdateFinishedNotification")):
        tray_icon.showMessage("pyLocate32", "Database update completed.", 1)

def updateDB():
    global updateTimer
    global updateAnimCount
    global updatingProcess
    updatingProcess = threading.Thread(target=updateCommand, args=(""))
    updateAnimCount = 0
    tray_icon.setToolTip("pyLocate32 - Updating...")
    updateTimer.start(100)
    updatingProcess.start()

def stopUpdateDB():
    global updateTimer
    global updateIsDone
    global UpdateAction
    global StopUpdateAction
    global updatingProcess
    returncode = subprocess.call(shlex.split(sucommand+" \"/usr/bin/killall -q updatedb\""))
    UpdateAction.setEnabled(True)
    StopUpdateAction.setEnabled(False)
    updateIsDone = False
    updatingProcess.join()
    updateTimer.stop()
    restoreTrayIcon()

def base64toIcon(string):
    pm = QtGui.QPixmap()
    pm.loadFromData(base64.b64decode(string))
    icon = QtGui.QIcon(pm)
    return icon

def restoreTrayIcon():
    global LocateIcon
    tray_icon.setToolTip("pyLocate32")
    LocateIcon = base64toIcon(strLocateIcon)
    tray_icon.setIcon(LocateIcon)
    tray_icon.show()

def showSettingScreen():
    settings_window.show()

def showAbout():
    tray_icon.showMessage("pyLocate32", "About - pyLocate32 (http://Locate32.cogit.net/) lookalike for Linux, by zaggynl", 1)
    
def exitProperly():
    sys.exit(0)

def updateAnimation():
    global updateAnimCount
    global LocateIcon
    global tray_icon
    global updatingProcess
    global updateTimer
    global updateIsDone
    global UpdateAction
    global StopUpdateAction
    UpdateAction.setEnabled(False)
    StopUpdateAction.setEnabled(True)
    if updateIsDone == False:

        if updateAnimCount == 0:
            LocateIcon = base64toIcon(strAnim1)

        elif updateAnimCount == 1:
            LocateIcon = base64toIcon(strAnim2)

        elif updateAnimCount == 2:
            LocateIcon = base64toIcon(strAnim3)

        elif updateAnimCount == 3:
            LocateIcon = base64toIcon(strAnim4)

        elif updateAnimCount == 4:
            LocateIcon = base64toIcon(strAnim4)

        elif updateAnimCount == 5:
            LocateIcon = base64toIcon(strAnim6)

        elif updateAnimCount == 6:
            LocateIcon = base64toIcon(strAnim7)

        elif updateAnimCount == 7:
            LocateIcon = base64toIcon(strAnim8)

        elif updateAnimCount == 8:
            LocateIcon = base64toIcon(strAnim9)

        elif updateAnimCount == 9:
            LocateIcon = base64toIcon(strAnim10)

        elif updateAnimCount == 10:
            LocateIcon = base64toIcon(strAnim11)

        elif updateAnimCount == 11:
            LocateIcon = base64toIcon(strAnim12)

        elif updateAnimCount == 12:
            LocateIcon = base64toIcon(strAnim13)
            updateAnimCount = -1

        tray_icon.setIcon(LocateIcon)
        tray_icon.show()
        updateAnimCount = updateAnimCount +1
    else:
        updateTimer.stop()
        restoreTrayIcon()
        StopUpdateAction.setEnabled(False)
        UpdateAction.setEnabled(True)

if __name__ == "__main__":
    #check if running under linux, else exit
    if os.name is not 'posix':
        exit("This version of pyLocate32 is for Linux, for Windows try: http://pyLocate32.cogit.net/ (different developer)")

    #check if we have kdesudo or gksu, else exit
    if os.path.isfile("/usr/bin/kdesudo"):
        sucommand = "/usr/bin/kdesudo -c"

    if os.path.isfile("/usr/bin/gksu"):
        sucommand = "/usr/bin/gksu"
        
    if os.path.isfile("/usr/bin/kdesu"):
        sucommand = "/usr/bin/kdesu -c"

    if sucommand == '':
        exit("Please install kdesudo, gksu or kdesu, is required for starting/stopping locate database update.")

    # Someone is launching this directly
    # Create the QApplication
    app = QtGui.QApplication(sys.argv)

    #What the updateTimer does when it fires
    app.connect(updateTimer, QtCore.SIGNAL("timeout()"), updateAnimation)
    app.connect(searchTimer, QtCore.SIGNAL("timeout()"), searchAnimation)
    
    #order of below is important, don't change!
    #The Main window
    main_window = MainWindow()
    
    #settings window
    settings_window = SettingsWindow()
    
    if not (readconfig(app,"hidemainonstartup")):
        main_window.show()

    #tray icon
    tray_icon = TrayIcon()
    restoreTrayIcon()
    tray_icon.show()

    #show/hide on tray icon click, double click won't work, always registers single click
    def tray_icon_event(reason):
        if reason == QtGui.QSystemTrayIcon.Trigger:
            if main_window.isHidden():
                main_window.show()
            else:
                main_window.hide()

    tray_icon.activated.connect(tray_icon_event)
    app.setWindowIcon(base64toIcon(strLocateIcon))

    # Enter the main loop
    app.exec_()