def createVideoDDS(self, ddobj, size=None):
if self._rect is None:
return
if size is not None:
w, h = size
else:
w, h = self._rect[2:]
if ddobj is None:
intefacePtr = Qt.GetDDObject()
if intefacePtr:
ddobj = ddraw.CreateDirectDrawWrapper(intefacePtr)
if ddobj:
self._ddobj = ddobj
ddsd = ddraw.CreateDDSURFACEDESC()
ddsd.SetFlags(ddraw.DDSD_WIDTH | ddraw.DDSD_HEIGHT
| ddraw.DDSD_CAPS)
ddsd.SetCaps(ddraw.DDSCAPS_OFFSCREENPLAIN)
ddsd.SetSize(w, h)
self._dds = ddobj.CreateSurface(ddsd)
Qt.SetDDObject(self._ddobj)
Qt.SetDDPrimarySurface(self._dds)
self._movie.SetMovieBox((0, 0, w, h))
self._movie.SetMovieActive(1)
def Terminate():
global initialized
global refcount
if initialized:
refcount = refcount - 1
if refcount == 0:
Qt.ExitMovies()
Qt.TerminateQTML()
initialized = 0
def create_menu(self, menu, item):
enforce_requirements = Qt.QAction('Enforce requirements',
menu,
checkable=True)
enforce_requirements.setChecked(self.ui_state.enforce_requirements)
enforce_requirements.triggered.connect(
self.toggle_enforce_requirements)
menu.addAction(enforce_requirements)
hide_unused_figures = Qt.QAction('Hide unused figures',
menu,
checkable=True)
hide_unused_figures.setChecked(self.ui_state.hide_unused_figures)
hide_unused_figures.triggered.connect(self.toggle_hide_unused_figures)
menu.addAction(hide_unused_figures)
menu.addSeparator()
if item is None:
return
if hasattr(item, 'path'):
menu.addAction('Browse to file',
lambda: util.browse_to_file(item.path))
if isinstance(item, ModifierListItem):
modifier_url = item.modifier.asset_url
# Create a submenu showing which modifiers this modifier requires.
requirements_menu = Qt.QMenu()
requirements_menu.setTitle('Requirements')
menu.addMenu(requirements_menu)
modifiers_required = item.available_modifiers_required()
modifiers_required_by = item.available_modifiers_required_by()
if not modifiers_required:
requirements_menu.setEnabled(False)
for modifier_data in modifiers_required:
requirements_menu.addAction(
modifier_data.label,
partial(self.select_modifier, modifier_data))
# Create a submenu showing which modifiers require this one.
required_by_menu = Qt.QMenu()
required_by_menu.setTitle('Required by')
menu.addMenu(required_by_menu)
if not modifiers_required_by:
required_by_menu.setEnabled(False)
for modifier_data in modifiers_required_by:
required_by_menu.addAction(
modifier_data.label,
partial(self.select_modifier, modifier_data))
def update(self):
if self._movie:
global QtPlayerInstances
if self._dds is not None and QtPlayerInstances > 1:
Qt.SetDDObject(self._ddobj)
Qt.SetDDPrimarySurface(self._dds)
self._movie.MoviesTask(0)
self._movie.UpdateMovie()
return not self._movie.IsMovieDone()
return 0
def test_unicode_error_messages():
"""Test if unicode error messages with non-ascii characters
throw the error reporter off"""
import Qt
unicode_message = u"DLL load failed : le module spécifié est introuvable."
str_message = "DLL load failed : le module"
with captured_output() as out:
stdout, stderr = out
Qt._warn(text=unicode_message)
assert str_message in stderr.getvalue()
def OnDestroy(self, params):
if self.__timer_id:
self.KillTimer(self.__timer_id)
if self.movie:
self.movie.StopMovie()
del self.movie
Qt.ExitMovies()
Qt.TerminateQTML()
del self.__movieBuffer
del self.__frontBuffer
del self.__backBuffer
del self.__clipper
del self.__ddraw
def test_convert_simple():
"""python -m Qt --convert works in general"""
before = """\
from PySide2 import QtCore, QtGui, QtWidgets
class Ui_uic(object):
def setupUi(self, uic):
self.retranslateUi(uic)
def retranslateUi(self, uic):
self.pushButton_2.setText(
QtWidgets.QApplication.translate("uic", "NOT Ok", None, -1))
""".split("\n")
after = """\
from Qt import QtCore, QtGui, QtWidgets
class Ui_uic(object):
def setupUi(self, uic):
self.retranslateUi(uic)
def retranslateUi(self, uic):
self.pushButton_2.setText(
Qt.QtCompat.translate("uic", "NOT Ok", None, -1))
""".split("\n")
import Qt
assert Qt.convert(before) == after, after
def import_file(path):
main_window_ptr = omui.MQtUtil.mainWindow()
main_window = Qt.wrapInstance(long(main_window_ptr), Qt.QWidget)
window = ControlMainWindow(path, parent=main_window)
window.show()
Qt.QApplication.setActiveWindow(window)
def OpenKrakenEditor_Execute():
# Deffered importing: We can only import the kraken modules after the
# plugin has loaded, as it configures the python import paths on load.
import kraken.ui.kraken_window
reload(kraken.ui.kraken_window)
from kraken.ui.kraken_window import KrakenWindow
from kraken.ui.kraken_window import createSplash
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance(long(sianchor), QWidget)
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication([])
for widget in app.topLevelWidgets():
if widget.objectName() == 'KrakenMainWindow':
widget.showNormal()
return
splash = createSplash(app)
splash.show()
window = KrakenWindow(parent=sianchor)
window.show()
splash.finish(window)
return True
def OpenKrakenEditor_Execute():
# Deffered importing: We can only import the kraken modules after the
# plugin has loaded, as it configures the python import paths on load.
import kraken.ui.kraken_window
reload(kraken.ui.kraken_window)
from kraken.ui.kraken_window import KrakenWindow
from kraken.ui.kraken_splash import KrakenSplash
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance(long(sianchor), QWidget)
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication([])
for widget in app.topLevelWidgets():
if widget.objectName() == 'KrakenMainWindow':
widget.showNormal()
return
splash = KrakenSplash(app)
splash.show()
window = KrakenWindow(parent=sianchor)
window.show()
splash.finish(window)
return True
class QtPlayer:
def __init__(self):
Initialize()
self._movie = None
self._videomedia = None
self._videotrack = None
self._audiomedia = None
self._audiotrack = None
self._ddobj = None
self._dds = None
self._rect = None
global QtPlayerInstances
QtPlayerInstances = QtPlayerInstances + 1
def __del__(self):
self._videomedia = None
self._videotrack = None
self._audiomedia = None
self._audiotrack = None
self._audiodescr = None
self._movie = None
self._movie = None
self._dds = None
self._ddobj = None
self._rect = None
Terminate()
global QtPlayerInstances
QtPlayerInstances = QtPlayerInstances - 1
def __repr__(self):
s = '<%s instance' % self.__class__.__name__
s = s + '>'
return s
def open(self, url, exporter=None, asaudio=0):
try:
movieResRef = Qt.OpenMovieFileWin(url, 1)
except Exception, arg:
print arg
return 0
try:
self._movie, d1, d2 = Qt.NewMovieFromFile(movieResRef, 0, 0)
except Exception, arg:
print arg
Qt.CloseMovieFile(movieResRef)
return 0
def ExampleMenu_Execute():
"""a simple example showing the use of a qmenu"""
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance(long(sianchor), QWidget)
menu = ExampleMenu(sianchor)
# notice the use of QCursor and exec_ call
menu.exec_(QCursor.pos())
def setup_modifiers(self):
groups = {}
self.ui_state.modifier_items_by_url = {}
for modifier in sorted(
self.ui_state.asset_cache_resolver.all_modifiers.itervalues(),
key=lambda item: item.relative_path.lower()):
path = modifier.relative_path
parent_dir = os.path.dirname(modifier.relative_path)
parent_group = groups.get(parent_dir)
if parent_group is None:
parent_group = Qt.QStandardItem(parent_dir)
parent_group.is_group = True
parent_group.modifier = None
parent_group.setCheckable(True)
parent_group.setTristate(True)
parent_group.setEditable(False)
parent_group.path = os.path.dirname(modifier.absolute_path)
groups[parent_dir] = parent_group
self.modifier_widget.model.appendRow(parent_group)
# This doesn't work, because QT is bad.
# index = self.modifier_widget.model_filter.mapFromSource(parent_group.index())
# self.modifier_widget.ui.treeView.setFirstColumnSpanned(index.row(), index.parent(), True)
item = ModifierListItem(modifier, self.ui_state, self)
item.setCheckable(True)
item.set_view(self.modifier_widget.ui.treeView)
item.setTristate(True)
item.setEditable(False)
dynamic_check = DynamicCheckItem(modifier, self.ui_state, self)
dynamic_check.set_view(self.modifier_widget.ui.treeView)
item_group = Qt.QStandardItem(modifier.group)
item_group.setCheckable(False)
item_group.setEditable(False)
parent_group.appendRow([item, dynamic_check, item_group])
self.ui_state.modifier_items_by_url[modifier.asset_url] = item
self.modifier_widget.ui.treeView.setFirstColumnSpanned(
0, self.modifier_widget.ui.treeView.rootIndex(), True)
self.modifier_widget.ui.treeView.setFirstColumnSpanned(
1, self.modifier_widget.ui.treeView.rootIndex(), True)
def go():
mh.setup_logging()
qt_path = os.path.dirname(__file__) + '/qt/'
qtpy_path = os.path.dirname(__file__) + '/qtpy/'
for fn in os.listdir(qt_path):
if not fnmatch(fn, '*.ui'):
continue
input_file = qt_path + fn
output_file = qtpy_path + fn.replace('.ui', '.py')
if mtime(input_file) < mtime(output_file):
continue
with open(input_file) as input:
with open(output_file, 'w') as output:
Qt.pysideuic.compileUi(input, output)
main_window_ptr = omui.MQtUtil.mainWindow()
main_window = Qt.wrapInstance(long(main_window_ptr), Qt.QWidget)
current_prefs = prefs.load_prefs()
picker = Qt.QFileDialog(main_window,
caption='Open DSON scene',
filter='DUF (*.duf)')
# Restore the last directory the user was in.
if 'last_path' in current_prefs:
picker.setDirectory(current_prefs['last_path'])
def import_file_queued(path):
# Save the directory the user was in.
current_prefs['last_path'] = picker.directory().absolutePath()
prefs.save_prefs(current_prefs)
# Wait for an event loop cycle, or the open dialog will stay on screen while we load
# data.
def run_import():
import_file(path)
Qt.QTimer.singleShot(0, run_import)
picker.fileSelected.connect(import_file_queued)
picker.setAcceptMode(Qt.QFileDialog.AcceptOpen)
picker.setFileMode(Qt.QFileDialog.ExistingFile)
picker.show()
def ExampleMenu_Execute():
"""a simple example showing the use of a qmenu"""
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance( long(sianchor), QWidget )
menu = ExampleMenu( sianchor )
# notice the use of QCursor and exec_ call
menu.exec_(QCursor.pos())
def Initialize(incrref=1):
global initialized
global refcount
if initialized:
if incrref:
refcount = refcount + 1
return 1
if Qt is None:
return 0
try:
Qt.InitializeQTML()
except:
return 0
Qt.EnterMovies()
initialized = 1
if incrref:
refcount = refcount + 1
return 1
def createDirectDrawQt(self, ddobj, size):
w, h = size
ddsd = ddraw.CreateDDSURFACEDESC()
ddsd.SetFlags(ddraw.DDSD_WIDTH | ddraw.DDSD_HEIGHT | ddraw.DDSD_CAPS)
ddsd.SetCaps(ddraw.DDSCAPS_OFFSCREENPLAIN)
ddsd.SetSize(w, h)
self.__movieBuffer = ddobj.CreateSurface(ddsd)
Qt.InitializeQTML()
Qt.EnterMovies()
Qt.SetDDObject(ddobj)
Qt.SetDDPrimarySurface(self.__movieBuffer)
fn = 'D:\\ufs\\mm\\cmif\\win32\\Qt\\media\\fashion.mov'
try:
movieResRef = Qt.OpenMovieFileWin(fn, 1)
except Exception, arg:
print arg
return
def open_menu(self, widget, position):
idx = self.ui.treeView.indexAt(position)
if idx.model() is not None:
idx = idx.model().mapToSource(idx)
item = idx.model().itemFromIndex(idx)
else:
item = None
menu = Qt.QMenu()
self.create_menu(menu, item)
menu.exec_(self.ui.treeView.viewport().mapToGlobal(position))
def ExampleUIFile_Execute():
"""a simple example showing the use of a .ui file created using QtDesigner"""
# find plugin to get the path to the example ui file
plugin = Application.Plugins("PyQt_Example")
if plugin is None:
return False
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance(long(sianchor), QWidget)
uifilepath = os.path.join(plugin.OriginPath, "exampleui.ui")
dialog = ExampleUIFile(sianchor, uifilepath)
dialog.show()
def ExampleUIFile_Execute():
"""a simple example showing the use of a .ui file created using QtDesigner"""
# find plugin to get the path to the example ui file
plugin = Application.Plugins("PyQt_Example")
if plugin is None:
return False
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance( long(sianchor), QWidget )
uifilepath = os.path.join(plugin.OriginPath, "exampleui.ui")
dialog = ExampleUIFile(sianchor, uifilepath)
dialog.show()
def __init__(self, ui_state, parent, main_window):
super(ModifierList, self).__init__()
self.ui_state = ui_state
self.main_window = main_window
from qtpy import modifier_list
self.ui = modifier_list.Ui_Form()
self.ui.setupUi(parent)
if MGlobal.apiVersion() >= 201700:
# XXX 2017 crashes when we do this.
pass
#self.ui.treeView.header().setSectionResizeMode(0, Qt.QHeaderView.Stretch)
#self.ui.treeView.header().setSectionResizeMode(1, Qt.QHeaderView.ResizeToContents)
#self.ui.treeView.header().setSectionResizeMode(2, Qt.QHeaderView.Interactive)
else:
self.ui.treeView.header().setResizeMode(0, Qt.QHeaderView.Stretch)
self.ui.treeView.header().setResizeMode(
1, Qt.QHeaderView.ResizeToContents)
self.ui.treeView.header().setResizeMode(2,
Qt.QHeaderView.Interactive)
self.model = Qt.QStandardItemModel()
self.model.setColumnCount(3)
self.model.setHeaderData(0, Qt.Qt.Horizontal, 'Item',
Qt.Qt.DisplayRole)
self.model.setHeaderData(1, Qt.Qt.Horizontal, 'D', Qt.Qt.DisplayRole)
self.model.setHeaderData(2, Qt.Qt.Horizontal, 'Group',
Qt.Qt.DisplayRole)
self.model_filter = Filter()
self.model_filter.setSourceModel(self.model)
self.ui.treeView.setModel(self.model_filter)
self.ui.treeView.setSortingEnabled(True)
self.model_filter.setFilterCaseSensitivity(Qt.Qt.CaseInsensitive)
self.ui.searchBox.textChanged.connect(
self.model_filter.setFilterFixedString)
self.ui.searchBox.textChanged.connect(
lambda text: self.ui.clearButton.setEnabled(len(text)))
self.ui.clearButton.setEnabled(False)
self.ui.clearButton.clicked.connect(lambda: self.ui.searchBox.clear())
self.ui.treeView.setSelectionMode(
Qt.QAbstractItemView.ExtendedSelection)
self.ui.treeView.setContextMenuPolicy(Qt.Qt.CustomContextMenu)
self.ui.treeView.customContextMenuRequested.connect(
lambda position: self.open_menu(self.ui.treeView, position))
def _initddraw(self):
movie_w = self.videodescr['width']
movie_h = self.videodescr['height']
movie_rect = (0, 0, movie_w, movie_h)
ddrawobj = ddraw.CreateDirectDraw()
ddrawobj.SetCooperativeLevel(0, ddraw.DDSCL_NORMAL)
ddsd = ddraw.CreateDDSURFACEDESC()
ddsd.SetFlags(ddraw.DDSD_WIDTH | ddraw.DDSD_HEIGHT | ddraw.DDSD_CAPS)
ddsd.SetCaps(ddraw.DDSCAPS_OFFSCREENPLAIN)
ddsd.SetSize(movie_w, movie_h)
dds = ddrawobj.CreateSurface(ddsd)
pxlfmt = dds.GetPixelFormat()
Qt.SetDDObject(ddrawobj)
Qt.SetDDPrimarySurface(dds)
self._ddrawobj = ddrawobj
self._dds = dds
self.pxlfmt = pxlfmt
self.movie.SetMovieBox(movie_rect)
self.movie.SetMovieActive(1)
self.movie.MoviesTask(0)
self.movie.SetMoviePlayHints(winqtcon.hintsHighQuality, winqtcon.hintsHighQuality)
def __init__(self, url):
self.movie = None
self.videotrack = None
self.videomedia = None
self.videotimescale = None
self.audiotrack = None
self.audiomedia = None
self.audiotimescale = None
self.audiodescr = {}
self.videocurtime = None
self.audiocurtime = None
winqt.Initialize()
path = MMurl.urlretrieve(url)[0]
try:
movieResRef = Qt.OpenMovieFileWin(path, 1)
except Qt.Error, arg:
print arg
def OpenKrakenEditor_Execute():
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance(long(sianchor), QWidget)
app = QtGui.QApplication.instance()
if not app:
app = QtGui.QApplication([])
for widget in app.topLevelWidgets():
if widget.objectName() == 'KrakenMainWindow':
widget.showNormal()
return
splash = createSplash(app)
splash.show()
window = KrakenWindow(parent=sianchor)
window.show()
splash.finish(window)
return True
import sys
# Add this plug-in path to python path
if __sipath__ not in sys.path:
sys.path.append(__sipath__)
import Qt
Qt.initialize()
from Qt.QtCore import Qt
from Qt.QtGui import QApplication, QCursor, QKeyEvent
from win32com.client import Dispatch as disp
from win32com.client import constants as C
si = disp("XSI.Application")
# Create a mapping of virtual keys
import win32con
KEY_MAPPING = {
# key: ( Qt::Key, ascii, modifiers )
8: (Qt.Key_Backspace, "", None),
9: (Qt.Key_Tab, "\t", None),
13: (Qt.Key_Enter, "\n", None),
16: (Qt.Key_Shift, "", None),
17: (Qt.Key_Control, "", None),
18: (Qt.Key_Alt, "", None),
19: (Qt.Key_Pause, "", None),
20: (Qt.Key_CapsLock, "", None),
def __init__(self, parent=None):
QTimer.__init__(self, parent)
Qt._addDynamicMethod('clicked(bool)',self, self.clicked)
def _audiotime_to_ms(self, time):
value, d1, d2 = Qt.ConvertTimeScale((time, self.audiotimescale, None), 1000)
return value
def _videotime_to_movietime(self, time):
value, d1, d2 = Qt.ConvertTimeScale((time, self.videotimescale, None),
self.movietimescale)
return value
self.audiotimescale = None
self.audiodescr = {}
self.videocurtime = None
self.audiocurtime = None
winqt.Initialize()
path = MMurl.urlretrieve(url)[0]
try:
movieResRef = Qt.OpenMovieFileWin(path, 1)
except Qt.Error, arg:
print arg
else:
try:
self.movie, d1, d2 = Qt.NewMovieFromFile(movieResRef, 0, 0)
except Qt.Error, arg:
print arg
self.movie = None
Qt.CloseMovieFile(movieResRef)
if not self.movie:
raise IOError, "Cannot open: %s" % url
self.movietimescale = self.movie.GetMovieTimeScale()
try:
self.audiotrack = self.movie.GetMovieIndTrackType(1,
winqtcon.AudioMediaCharacteristic, winqtcon.movieTrackCharacteristic)
self.audiomedia = self.audiotrack.GetTrackMedia()
except Qt.Error, arg:
def convert(py_uifile):
Qt._cli(['--convert', py_uifile])
print('convert py_uifile for PySide & PySide2 done')
# Kraken_Plugin
from win32com.client import constants
import json
import os
import sys
import inspect
from win32com.client import constants
from multiprocessing import Pool
import webbrowser
import Qt
Qt.initialize()
from Qt.QtGui import QMainWindow
from Qt.QtGui import QWidget
from PySide import QtGui, QtCore
si = Application
log = si.LogMessage
def XSILoadPlugin(in_reg):
in_reg.Author = 'Eric Thivierge & Phil Taylor'
in_reg.Name = 'Kraken_Plugin'
in_reg.Major = 1
in_reg.Minor = 0
pluginPath = in_reg.OriginPath
def ExampleDialog_Execute():
"""a simple example dialog showing basic functionality of the pyqt for softimage plugin"""
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance( long(sianchor), QWidget )
dialog = ExampleDialog( sianchor )
dialog.show()
def ExampleSignalSlot_Execute():
"""a simple example showing softimage events triggering pyqt signals"""
sianchor = Application.getQtSoftimageAnchor()
sianchor = Qt.wrapinstance( long(sianchor), QWidget )
dialog = ExampleSignalSlot( sianchor )
dialog.show()
s = s + '>'
return s
def open(self, url, exporter=None, asaudio=0):
try:
movieResRef = Qt.OpenMovieFileWin(url, 1)
except Exception, arg:
print arg
return 0
try:
self._movie, d1, d2 = Qt.NewMovieFromFile(movieResRef, 0, 0)
except Exception, arg:
print arg
Qt.CloseMovieFile(movieResRef)
return 0
Qt.CloseMovieFile(movieResRef)
if not asaudio:
l, t, r, b = self._movie.GetMovieBox()
self._rect = l, t, r - l, b - t
return 1
def getMovieRect(self):
return self._rect
def getCurrentMovieRect(self):
if self._movie:
l, t, r, b = self._movie.GetMovieBox()
return l, t, r - l, b - t
return 0, 0
def setMovieRect(self, rect):
def open(self, url, exporter=None, asaudio=0):
try:
movieResRef = Qt.OpenMovieFileWin(url, 1)
except Exception, arg:
print arg
return 0
__version__ = "$Id$"
try:
import Qt
except ImportError:
Qt = None
mcTopLeftMovie = 1
mcScaleMovieToFit = 1 << 1
mcWithBadge = 1 << 2
mcNotVisible = 1 << 3
mcWithFrame = 1 << 4
if Qt is not None:
VisualMediaCharacteristic = Qt.BuildOSType('eyes')
AudioMediaCharacteristic= Qt.BuildOSType('ears')
kCharacteristicCanSendVideo = Qt.BuildOSType('vsnd')
kCharacteristicProvidesActions = Qt.BuildOSType('actn')
kCharacteristicNonLinear= Qt.BuildOSType('nonl')
kCharacteristicCanStep = Qt.BuildOSType('step')
kCharacteristicHasNoDuration = Qt.BuildOSType('noti')
movieTrackMediaType = 1 << 0
movieTrackCharacteristic= 1 << 1
movieTrackEnabledOnly = 1 << 2
hintsScrubMode = 1 << 0
hintsLoop = 1 << 1
hintsDontPurge = 1 << 2
hintsUseScreenBuffer= 1 << 5
hintsAllowInterlace = 1 << 6
def __init__(self):
Project.Project.__init__(self)
self.success = False
self.shortName = 'mks'
self.name = 'Monkey Studio IDE'
self.version = '1.9.0.4'
#self.version = 'dev'
#self.version = 'trunk'
self.company = 'The Monkey Studio Team'
self.copyrights = '2005 - 2012 Azevedo Filipe & The Monkey Studio Team'
self.description = 'Free, Fast and Flexible cross-platform IDE'
self.urlHomepage = 'http://monkeystudio.org'
self.urlForums = '%s/forum' % (self.urlHomepage)
self.urlIssuesTracker = 'https://bugs.launchpad.net/monkeystudio/+filebug'
self.target = '%s/Releases/%s' % (os.environ['HOME'], self.shortName)
self.makeJobs = 4
self.qtLinux = Qt.QtTriplet(
#'%s/Developpement/OS/Unix-Libraries/Qt/4.8.3' % ( os.environ[ 'HOME' ] ), # linux
'/usr', # linux
'%s/Developpement/OS/OSX-Libraries/Qt/4.8.3-carbon' %
(os.environ['HOME']), # mac
'%s/Developpement/OS/Win32-Libraries/Qt/4.8.3' %
(os.environ['HOME']) # windows
)
self.qtMac = Qt.QtTriplet(
'', # linux
'/usr/local/Trolltech/4.7.4-carbon-lgpl', # mac
'/usr/local/Trolltech/win32/4.7.4' # windows
)
self.qt = Qt.QtHost(self)
self.wine = Wine.Wine()
self.svnList['mks'] = Svn.Svn(
'svn://svn.tuxfamily.org/svnroot/monkeystudio/mks')
if Tools.isLinuxOS():
self.svnList[
'mks'].workingCopy = '%s/Developpement/C++/Qt4/mks' % (
os.environ['HOME'])
elif Tools.isMacOS():
self.svnList['mks'].workingCopy = '%s/Developpement/mks' % (
os.environ['HOME'])
self.gitList['fresh'] = Git.Git('git://github.com/pasnox/fresh.git')
# Custom variables
self.baseName = '%s_%s' % (self.shortName, self.version)
self.sourceName = '%s-src' % (self.baseName)
self.tmpFolder = tempfile.mkdtemp()
self.logFolder = '%s/log' % (self.tmpFolder)
self.packagesFolder = '%s/packages' % (self.tmpFolder)
self.sourcesFolder = '%s/%s' % (self.tmpFolder, self.sourceName)
self.projectFile = '%s/monkeystudio.pro' % (self.sourcesFolder)
self.tgzFile = '%s/%s.tar.gz' % (self.packagesFolder, self.sourceName)
self.zipFile = '%s/%s.zip' % (self.packagesFolder, self.sourceName)
self.winSetup = '%s/%s.exe' % (self.packagesFolder, self.baseName)
self.winZip = '%s/%s-win32.zip' % (self.packagesFolder, self.baseName)
self.macDmg = '%s/%s.dmg' % (self.packagesFolder, self.baseName)
self.macZip = '%s/%s-mac.zip' % (self.packagesFolder, self.baseName)
os.environ['PWD'] = self.tmpFolder
os.chdir(self.tmpFolder)
