--- a/build.py Sat Oct 21 11:35:34 2006 +0200
+++ b/build.py Mon Oct 23 09:24:36 2006 +0200
@@ -39,7 +39,7 @@
COMMAND_LINE_TARGETS = CommandLineTargets
class Ns3Module:
- def __init__ (self, name, dir):
+ def __init__(self, name, dir):
self.sources = []
self.inst_headers = []
self.headers = []
@@ -51,71 +51,71 @@
self.dir = dir
self.executable = False
self.library = True
- def set_library (self):
+ def set_library(self):
self.library = True
self.executable = False
- def set_executable (self):
+ def set_executable(self):
self.library = False
self.executable = True
- def add_config (self, config_fn):
- self.config.append (config_fn)
- def add_extra_dist (self, dist):
- self.extra_dist.append (dist)
- def add_external_dep (self, dep):
- self.external_deps.append (dep)
- def add_dep (self, dep):
- self.deps.append (dep)
- def add_deps (self, deps):
- self.deps.extend (deps)
- def add_source (self, source):
- self.sources.append (source)
- def add_sources (self, sources):
- self.sources.extend (sources)
- def add_header (self, header):
- self.headers.append (header)
- def add_headers (self, headers):
- self.headers.extend (headers)
- def add_inst_header (self, header):
- self.inst_headers.append (header)
- def add_inst_headers (self, headers):
- self.inst_headers.extend (headers)
+ def add_config(self, config_fn):
+ self.config.append(config_fn)
+ def add_extra_dist(self, dist):
+ self.extra_dist.append(dist)
+ def add_external_dep(self, dep):
+ self.external_deps.append(dep)
+ def add_dep(self, dep):
+ self.deps.append(dep)
+ def add_deps(self, deps):
+ self.deps.extend(deps)
+ def add_source(self, source):
+ self.sources.append(source)
+ def add_sources(self, sources):
+ self.sources.extend(sources)
+ def add_header(self, header):
+ self.headers.append(header)
+ def add_headers(self, headers):
+ self.headers.extend(headers)
+ def add_inst_header(self, header):
+ self.inst_headers.append(header)
+ def add_inst_headers(self, headers):
+ self.inst_headers.extend(headers)
-def MyCopyAction (target, source, env):
+def MyCopyAction(target, source, env):
try:
- if len (target) == len (source):
- for i in range (len(target)):
- shutil.copy (source[i].path, target[i].path)
+ if len(target) == len(source):
+ for i in range(len(target)):
+ shutil.copy(source[i].path, target[i].path)
return 0
else:
return 'invalid target/source match'
except:
print
return 'exception'
-def MyCopyActionPrint (target, source, env):
- if len (target) == len (source):
+def MyCopyActionPrint(target, source, env):
+ if len(target) == len(source):
output = ''
- for i in range (len(target)):
- output = output + 'copy \'' + source[i].path + '\' to \'' + target[i].path + '\''
- if i < len (target) - 1:
+ for i in range(len(target)):
+ output = output + 'copy \'' + source[i].path + '\' to \'' + target[i].path + '\''
+ if i < len(target) - 1:
output = output + '\n'
return output
else:
return 'error in copy'
-def GcxxEmitter (target, source, env):
- if os.path.exists (source[0].path):
+def GcxxEmitter(target, source, env):
+ if os.path.exists(source[0].path):
return [target, source]
else:
return [[], []]
-def MyRmTree (target, source, env):
- shutil.rmtree (env['RM_DIR'])
+def MyRmTree(target, source, env):
+ shutil.rmtree(env['RM_DIR'])
return 0
-def MyRmTreePrint (target, source, env):
+def MyRmTreePrint(target, source, env):
return ''
def print_cmd_line(s, target, src, env):
print 'Building ' + (' and '.join([str(x) for x in target])) + '...'
class Ns3BuildVariant:
- def __init__ (self):
+ def __init__(self):
self.static = False
self.gcxx_deps = False
self.gcxx_root = ''
@@ -123,27 +123,27 @@
self.env = None
class Ns3:
- def __init__ (self):
+ def __init__(self):
self.__modules = []
self.extra_dist = []
self.build_dir = 'build'
self.version = '0.0.1'
self.name = 'noname'
self.doxygen_config = ''
- def add (self, module):
- self.__modules.append (module)
- def add_extra_dist (self, dist):
- self.extra_dist.append (dist)
- def __get_module (self, name):
+ def add(self, module):
+ self.__modules.append(module)
+ def add_extra_dist(self, dist):
+ self.extra_dist.append(dist)
+ def __get_module(self, name):
for module in self.__modules:
if module.name == name:
return module
return None
- def get_mod_output (self, module, variant):
+ def get_mod_output(self, module, variant):
if module.executable:
- suffix = variant.env.subst (variant.env['PROGSUFFIX'])
- filename = os.path.join (variant.build_root, 'bin',
- module.name + suffix)
+ suffix = variant.env.subst(variant.env['PROGSUFFIX'])
+ filename = os.path.join(variant.build_root, 'bin',
+ module.name + suffix)
else:
if variant.static:
prefix = variant.env['LIBPREFIX']
@@ -151,78 +151,78 @@
else:
prefix = variant.env['SHLIBPREFIX']
suffix = variant.env['SHLIBSUFFIX']
- prefix = variant.env.subst (prefix)
- suffix = variant.env.subst (suffix)
- filename = os.path.join (variant.build_root, 'lib',
+ prefix = variant.env.subst(prefix)
+ suffix = variant.env.subst(suffix)
+ filename = os.path.join(variant.build_root, 'lib',
prefix + module.name + suffix)
return filename
- def get_obj_builders (self, variant, module):
+ def get_obj_builders(self, variant, module):
env = variant.env
objects = []
- if len (module.config) > 0:
- src_config_file = os.path.join (self.build_dir, 'config', module.name + '-config.h')
- tgt_config_file = os.path.join (variant.build_root, 'include',
- 'ns3', module.name + '-config.h')
+ if len(module.config) > 0:
+ src_config_file = os.path.join(self.build_dir, 'config', module.name + '-config.h')
+ tgt_config_file = os.path.join(variant.build_root, 'include',
+ 'ns3', module.name + '-config.h')
for source in module.sources:
- obj_file = os.path.splitext (source)[0] + '.o'
- tgt = os.path.join (variant.build_root, module.dir, obj_file)
- src = os.path.join (module.dir, source)
+ obj_file = os.path.splitext(source)[0] + '.o'
+ tgt = os.path.join(variant.build_root, module.dir, obj_file)
+ src = os.path.join(module.dir, source)
if variant.static:
- obj_builder = env.StaticObject (target = tgt, source = src)
+ obj_builder = env.StaticObject(target = tgt, source = src)
else:
- obj_builder = env.SharedObject (target = tgt, source = src)
- if len (module.config) > 0:
- config_file = env.MyCopyBuilder (target = [tgt_config_file],
+ obj_builder = env.SharedObject(target = tgt, source = src)
+ if len(module.config) > 0:
+ config_file = env.MyCopyBuilder(target = [tgt_config_file],
source = [src_config_file])
- env.Depends (obj_builder, config_file)
+ env.Depends(obj_builder, config_file)
if variant.gcxx_deps:
- gcno_tgt = os.path.join (variant.build_root, module.dir,
- os.path.splitext (source)[0] + '.gcno')
- gcda_tgt = os.path.join (variant.build_root, module.dir,
- os.path.splitext (source)[0] + '.gcda')
- gcda_src = os.path.join (variant.gcxx_root, module.dir,
- os.path.splitext (source)[0] + '.gcda')
- gcno_src = os.path.join (variant.gcxx_root, module.dir,
- os.path.splitext (source)[0] + '.gcno')
- gcno_builder = env.CopyGcxxBuilder (target = gcno_tgt, source = gcno_src)
- gcda_builder = env.CopyGcxxBuilder (target = gcda_tgt, source = gcda_src)
- env.Depends (obj_builder, gcda_builder)
- env.Depends (obj_builder, gcno_builder)
- objects.append (obj_builder)
+ gcno_tgt = os.path.join(variant.build_root, module.dir,
+ os.path.splitext(source)[0] + '.gcno')
+ gcda_tgt = os.path.join(variant.build_root, module.dir,
+ os.path.splitext(source)[0] + '.gcda')
+ gcda_src = os.path.join(variant.gcxx_root, module.dir,
+ os.path.splitext(source)[0] + '.gcda')
+ gcno_src = os.path.join(variant.gcxx_root, module.dir,
+ os.path.splitext(source)[0] + '.gcno')
+ gcno_builder = env.CopyGcxxBuilder(target = gcno_tgt, source = gcno_src)
+ gcda_builder = env.CopyGcxxBuilder(target = gcda_tgt, source = gcda_src)
+ env.Depends(obj_builder, gcda_builder)
+ env.Depends(obj_builder, gcno_builder)
+ objects.append(obj_builder)
return objects
- def get_internal_deps (self, module, hash):
+ def get_internal_deps(self, module, hash):
for dep_name in module.deps:
- dep = self.__get_module (dep_name)
+ dep = self.__get_module(dep_name)
hash[dep_name] = dep
- self.get_internal_deps (dep, hash)
- def get_external_deps (self, module):
+ self.get_internal_deps(dep, hash)
+ def get_external_deps(self, module):
hash = {}
- self.get_internal_deps (module, hash)
+ self.get_internal_deps(module, hash)
ext_hash = {}
- for mod in hash.values ():
+ for mod in hash.values():
for ext_dep in mod.external_deps:
ext_hash[ext_dep] = 1
- return ext_hash.keys ()
- def get_sorted_deps (self, module):
+ return ext_hash.keys()
+ def get_sorted_deps(self, module):
h = {}
- self.get_internal_deps (module, h)
+ self.get_internal_deps(module, h)
modules = []
- for dep in h.keys ():
+ for dep in h.keys():
deps_copy = []
mod = h[dep]
- deps_copy.extend (mod.deps)
- modules.append ([mod, deps_copy])
+ deps_copy.extend(mod.deps)
+ modules.append([mod, deps_copy])
sorted = []
- while len (modules) > 0:
+ while len(modules) > 0:
to_remove = []
for item in modules:
- if len (item[1]) == 0:
- to_remove.append (item[0].name)
+ if len(item[1]) == 0:
+ to_remove.append(item[0].name)
for item in to_remove:
for i in modules:
if item in i[1]:
- i[1].remove (item)
+ i[1].remove(item)
new_modules = []
for mod in modules:
found = False
@@ -231,289 +231,289 @@
found = True
break
if not found:
- new_modules.append (mod)
+ new_modules.append(mod)
modules = new_modules
- sorted.extend (to_remove)
- sorted.reverse ()
+ sorted.extend(to_remove)
+ sorted.reverse()
# append external deps
- ext_deps = self.get_external_deps (module)
+ ext_deps = self.get_external_deps(module)
for dep in ext_deps:
- sorted.append (dep)
+ sorted.append(dep)
return sorted
- def gen_mod_dep (self, variant):
+ def gen_mod_dep(self, variant):
build_root = variant.build_root
- cpp_path = os.path.join (variant.build_root, 'include')
+ cpp_path = os.path.join(variant.build_root, 'include')
env = variant.env
- env.Append (CPPPATH=[cpp_path])
- header_dir = os.path.join (build_root, 'include', 'ns3')
- lib_path = os.path.join (build_root, 'lib')
+ env.Append(CPPPATH = [cpp_path])
+ header_dir = os.path.join(build_root, 'include', 'ns3')
+ lib_path = os.path.join(build_root, 'lib')
module_builders = []
for module in self.__modules:
- objects = self.get_obj_builders (variant, module)
- libs = self.get_sorted_deps (module)
+ objects = self.get_obj_builders(variant, module)
+ libs = self.get_sorted_deps(module)
- filename = self.get_mod_output (module, variant)
+ filename = self.get_mod_output(module, variant)
if module.executable:
if env['PLATFORM'] == 'posix':
- module_builder = env.Program (target = filename, source = objects,
- LIBPATH=lib_path, LIBS=libs,
- RPATH=lib_path)
+ module_builder = env.Program(target=filename, source=objects,
+ LIBPATH=lib_path, LIBS=libs,
+ RPATH=lib_path)
else:
- module_builder = env.Program (target = filename, source = objects,
- LIBPATH=lib_path, LIBS=libs)
+ module_builder = env.Program(target=filename, source=objects,
+ LIBPATH=lib_path, LIBS=libs)
else:
if variant.static:
- module_builder = env.StaticLibrary (target = filename, source = objects)
+ module_builder = env.StaticLibrary(target=filename, source=objects)
else:
- module_builder = env.SharedLibrary (target = filename, source = objects,
- LIBPATH=lib_path, LIBS=libs)
+ module_builder = env.SharedLibrary(target=filename, source=objects,
+ LIBPATH=lib_path, LIBS=libs)
for dep_name in module.deps:
- dep = self.__get_module (dep_name)
- env.Depends (module_builder, self.get_mod_output (dep, variant))
+ dep = self.__get_module(dep_name)
+ env.Depends(module_builder, self.get_mod_output(dep, variant))
for header in module.inst_headers:
- tgt = os.path.join (header_dir, header)
- src = os.path.join (module.dir, header)
- #builder = env.Install (target = tgt, source = src)
- header_builder = env.MyCopyBuilder (target = tgt, source = src)
- env.Depends (module_builder, header_builder)
+ tgt = os.path.join(header_dir, header)
+ src = os.path.join(module.dir, header)
+ #builder = env.Install(target = tgt, source = src)
+ header_builder = env.MyCopyBuilder(target=tgt, source=src)
+ env.Depends(module_builder, header_builder)
- module_builders.append (module_builder)
+ module_builders.append(module_builder)
return module_builders
- def gen_mod_config (self, env):
- config_dir = os.path.join (self.build_dir, 'config')
+ def gen_mod_config(self, env):
+ config_dir = os.path.join(self.build_dir, 'config')
for module in self.__modules:
- if len (module.config) > 0:
- config_file = os.path.join (config_dir, module.name + '-config.h')
+ if len(module.config) > 0:
+ config_file = os.path.join(config_dir, module.name + '-config.h')
config_file_guard = module.name + '_CONFIG_H'
- config_file_guard.upper ()
- if not os.path.isfile (config_file):
- if not os.path.isdir (config_dir):
- os.makedirs (config_dir)
- outfile = open (config_file, 'w')
- outfile.write ('#ifndef ' + config_file_guard + '\n')
- outfile.write ('#define ' + config_file_guard + '\n')
- config = env.Configure ()
+ config_file_guard.upper()
+ if not os.path.isfile(config_file):
+ if not os.path.isdir(config_dir):
+ os.makedirs(config_dir)
+ outfile = open(config_file, 'w')
+ outfile.write('#ifndef ' + config_file_guard + '\n')
+ outfile.write('#define ' + config_file_guard + '\n')
+ config = env.Configure()
for fn in module.config:
- output = fn (env, config)
+ output = fn(env, config)
for o in output:
- outfile.write (o)
- outfile.write ('\n')
- outfile.write ('#endif /*' + config_file_guard + '*/\n')
- config.Finish ()
- def generate_dependencies (self):
+ outfile.write(o)
+ outfile.write('\n')
+ outfile.write('#endif /*' + config_file_guard + '*/\n')
+ config.Finish()
+ def generate_dependencies(self):
env = Environment()
- self.gen_mod_config (env)
+ self.gen_mod_config(env)
cc = env['CC']
- cxx = env.subst (env['CXX'])
- common_flags = ARGUMENTS.get('cflags', '').split (' ')
- cxxflags = ARGUMENTS.get('cxxflags', '').split (' ')
- ldflags = ARGUMENTS.get('ldflags', '').split (' ')
+ cxx = env.subst(env['CXX'])
+ common_flags = ARGUMENTS.get('cflags', '').split(' ')
+ cxxflags = ARGUMENTS.get('cxxflags', '').split(' ')
+ ldflags = ARGUMENTS.get('ldflags', '').split(' ')
if cc == 'cl' and cxx == 'cl':
- env = Environment (tools = ['mingw'])
+ env = Environment(tools=['mingw'])
cc = env['CC']
- cxx = env.subst (env['CXX'])
+ cxx = env.subst(env['CXX'])
if cc == 'gcc' and cxx == 'g++':
- common_flags.extend (['-g3', '-Wall', '-Werror'])
+ common_flags.extend(['-g3', '-Wall', '-Werror'])
debug_flags = []
opti_flags = ['-O3']
elif cc == 'cl' and cxx == 'cl':
- env = Environment (ENV = os.environ)
+ env = Environment(ENV=os.environ)
debug_flags = ['-W1', '-GX', '-EHsc', '-D_DEBUG', '/MDd']
opti_flags = ['-O2', '-EHsc', '-DNDEBUG', '/MD']
- env.Append (CCFLAGS=common_flags,
- CPPDEFINES=['RUN_SELF_TESTS'],
- TARFLAGS='-c -z',
- CPPFLAGS=cxxflags,
- LINKFLAGS=ldflags)
+ env.Append(CCFLAGS = common_flags,
+ CPPDEFINES = ['RUN_SELF_TESTS'],
+ TARFLAGS = '-c -z',
+ CPPFLAGS = cxxflags,
+ LINKFLAGS = ldflags)
verbose = ARGUMENTS.get('verbose', 'n')
if verbose == 'n':
env['PRINT_CMD_LINE_FUNC'] = print_cmd_line
- header_builder = Builder (action = Action (MyCopyAction, strfunction = MyCopyActionPrint))
- env.Append (BUILDERS = {'MyCopyBuilder':header_builder})
- gcxx_builder = Builder (action = Action (MyCopyAction, strfunction = MyCopyActionPrint),
+ header_builder = Builder(action = Action(MyCopyAction, strfunction=MyCopyActionPrint))
+ env.Append(BUILDERS = {'MyCopyBuilder':header_builder})
+ gcxx_builder = Builder(action = Action(MyCopyAction, strfunction=MyCopyActionPrint),
emitter = GcxxEmitter)
- env.Append (BUILDERS = {'CopyGcxxBuilder':gcxx_builder})
- variant = Ns3BuildVariant ()
+ env.Append(BUILDERS = {'CopyGcxxBuilder':gcxx_builder})
+ variant = Ns3BuildVariant()
builders = []
- gcov_env = env.Copy ()
- gcov_env.Append (CFLAGS=['-fprofile-arcs', '-ftest-coverage'],
- CXXFLAGS=['-fprofile-arcs', '-ftest-coverage'],
- LINKFLAGS=['-fprofile-arcs'])
+ gcov_env = env.Copy()
+ gcov_env.Append(CFLAGS = ['-fprofile-arcs', '-ftest-coverage'],
+ CXXFLAGS = ['-fprofile-arcs', '-ftest-coverage'],
+ LINKFLAGS = ['-fprofile-arcs'])
# code coverage analysis
variant.static = False
variant.env = gcov_env
- variant.build_root = os.path.join (self.build_dir, 'gcov')
- builders = self.gen_mod_dep (variant)
+ variant.build_root = os.path.join(self.build_dir, 'gcov')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- gcov_env.Alias ('gcov', builder)
- gcov_env.Alias ('lcov-report')
+ gcov_env.Alias('gcov', builder)
+ gcov_env.Alias('lcov-report')
if 'lcov-report' in COMMAND_LINE_TARGETS:
- lcov_report_dir = os.path.join (self.build_dir, 'lcov-report')
+ lcov_report_dir = os.path.join(self.build_dir, 'lcov-report')
create_dir_command = "rm -rf " + lcov_report_dir
create_dir_command += " && mkdir " + lcov_report_dir + ";"
- gcov_env.Execute (create_dir_command)
- info_file = os.path.join (lcov_report_dir, 'ns3.info')
+ gcov_env.Execute(create_dir_command)
+ info_file = os.path.join(lcov_report_dir, 'ns3.info')
lcov_command = "utils/lcov/lcov -c -d . -o " + info_file
- lcov_command += " --source-dirs=" + os.getcwd ()
- lcov_command += ":" + os.path.join (os.getcwd (),
- variant.build_root,
+ lcov_command += " --source-dirs=" + os.getcwd()
+ lcov_command += ":" + os.path.join(os.getcwd(),
+ variant.build_root,
'include')
- gcov_env.Execute (lcov_command)
+ gcov_env.Execute(lcov_command)
genhtml_command = "utils/lcov/genhtml -o " + lcov_report_dir
genhtml_command += " " + info_file
- gcov_env.Execute (genhtml_command)
+ gcov_env.Execute(genhtml_command)
- opt_env = env.Copy ()
- opt_env.Append (CFLAGS=opti_flags,
- CXXFLAGS=opti_flags,
+ opt_env = env.Copy()
+ opt_env.Append(CFLAGS=opti_flags,
+ CXXFLAGS=opti_flags,
CPPDEFINES=['NDEBUG'])
# optimized static support
variant.static = True
variant.env = opt_env
- variant.build_root = os.path.join (self.build_dir, 'opt-static')
- builders = self.gen_mod_dep (variant)
+ variant.build_root = os.path.join(self.build_dir, 'opt-static')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- opt_env.Alias ('opt-static', builder)
+ opt_env.Alias('opt-static', builder)
- opt_env = env.Copy ()
- opt_env.Append (CFLAGS=opti_flags,
- CXXFLAGS=opti_flags,
- CPPDEFINES=['NDEBUG'])
+ opt_env = env.Copy()
+ opt_env.Append(CFLAGS = opti_flags,
+ CXXFLAGS = opti_flags,
+ CPPDEFINES = ['NDEBUG'])
# optimized shared support
variant.static = False
variant.env = opt_env
- variant.build_root = os.path.join (self.build_dir, 'opt-shared')
- builders = self.gen_mod_dep (variant)
+ variant.build_root = os.path.join(self.build_dir, 'opt-shared')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- opt_env.Alias ('opt-shared', builder)
+ opt_env.Alias('opt-shared', builder)
- arc_env = env.Copy ()
- arc_env.Append (CFLAGS=opti_flags,
- CXXFLAGS=opti_flags,
+ arc_env = env.Copy()
+ arc_env.Append(CFLAGS=opti_flags,
+ CXXFLAGS=opti_flags,
CPPDEFINES=['NDEBUG'])
- arc_env.Append (CFLAGS=['-frandom-seed=0','-fprofile-generate'],
- CXXFLAGS=['-frandom-seed=0','-fprofile-generate'],
+ arc_env.Append(CFLAGS=['-frandom-seed=0', '-fprofile-generate'],
+ CXXFLAGS=['-frandom-seed=0', '-fprofile-generate'],
LINKFLAGS=['-frandom-seed=0', '-fprofile-generate'])
# arc profiling
variant.static = False
variant.env = arc_env
- variant.build_root = os.path.join (self.build_dir, 'opt-arc')
- builders = self.gen_mod_dep (variant)
+ variant.build_root = os.path.join(self.build_dir, 'opt-arc')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- arc_env.Alias ('opt-arc', builder)
+ arc_env.Alias('opt-arc', builder)
- arcrebuild_env = env.Copy ()
- arcrebuild_env.Append (CFLAGS=opti_flags,
- CXXFLAGS=opti_flags,
+ arcrebuild_env = env.Copy()
+ arcrebuild_env.Append(CFLAGS=opti_flags,
+ CXXFLAGS=opti_flags,
CPPDEFINES=['NDEBUG'])
- arcrebuild_env.Append (CFLAGS=['-frandom-seed=0', '-fprofile-use'],
- CXXFLAGS=['-frandom-seed=0', '-fprofile-use'],
- LINKFLAGS=['-frandom-seed=0','-fprofile-use'])
+ arcrebuild_env.Append(CFLAGS=['-frandom-seed=0', '-fprofile-use'],
+ CXXFLAGS=['-frandom-seed=0', '-fprofile-use'],
+ LINKFLAGS=['-frandom-seed=0', '-fprofile-use'])
# arc rebuild
variant.static = False
variant.env = arcrebuild_env
variant.gcxx_deps = True
- variant.gcxx_root = os.path.join (self.build_dir, 'opt-arc')
- variant.build_root = os.path.join (self.build_dir, 'opt-arc-rebuild')
- builders = self.gen_mod_dep (variant)
+ variant.gcxx_root = os.path.join(self.build_dir, 'opt-arc')
+ variant.build_root = os.path.join(self.build_dir, 'opt-arc-rebuild')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- arcrebuild_env.Alias ('opt-arc-rebuild', builder)
+ arcrebuild_env.Alias('opt-arc-rebuild', builder)
variant.gcxx_deps = False
- dbg_env = env.Copy ()
- env.Append (CFLAGS=debug_flags,
- CXXFLAGS=debug_flags,)
+ dbg_env = env.Copy()
+ env.Append(CFLAGS = debug_flags,
+ CXXFLAGS = debug_flags, )
# debug static support
variant.static = True
variant.env = dbg_env
- variant.build_root = os.path.join (self.build_dir, 'dbg-static')
- builders = self.gen_mod_dep (variant)
+ variant.build_root = os.path.join(self.build_dir, 'dbg-static')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- dbg_env.Alias ('dbg-static', builder)
+ dbg_env.Alias('dbg-static', builder)
- dbg_env = env.Copy ()
- env.Append (CFLAGS=debug_flags,
- CXXFLAGS=debug_flags,)
+ dbg_env = env.Copy()
+ env.Append(CFLAGS=debug_flags,
+ CXXFLAGS=debug_flags, )
# debug shared support
variant.static = False
variant.env = dbg_env
- variant.build_root = os.path.join (self.build_dir, 'dbg-shared')
- builders = self.gen_mod_dep (variant)
+ variant.build_root = os.path.join(self.build_dir, 'dbg-shared')
+ builders = self.gen_mod_dep(variant)
for builder in builders:
- dbg_env.Alias ('dbg-shared', builder)
+ dbg_env.Alias('dbg-shared', builder)
- env.Alias ('dbg', 'dbg-shared')
- env.Alias ('opt', 'opt-shared')
- env.Default ('dbg')
- env.Alias ('all', ['dbg-shared', 'dbg-static', 'opt-shared', 'opt-static'])
+ env.Alias('dbg', 'dbg-shared')
+ env.Alias('opt', 'opt-shared')
+ env.Default('dbg')
+ env.Alias('all', ['dbg-shared', 'dbg-static', 'opt-shared', 'opt-static'])
# dist support
- dist_env = env.Copy ()
+ dist_env = env.Copy()
if dist_env['PLATFORM'] == 'posix':
dist_list = []
for module in self.__modules:
for f in module.sources:
- dist_list.append (os.path.join (module.dir, f))
+ dist_list.append(os.path.join(module.dir, f))
for f in module.headers:
- dist_list.append (os.path.join (module.dir, f))
+ dist_list.append(os.path.join(module.dir, f))
for f in module.inst_headers:
- dist_list.append (os.path.join (module.dir, f))
+ dist_list.append(os.path.join(module.dir, f))
for f in module.extra_dist:
- dist_list.append (os.path.join (module.dir, f))
+ dist_list.append(os.path.join(module.dir, f))
for f in self.extra_dist:
- dist_list.append (f)
- dist_list.append ('SConstruct')
- dist_list.append ('build.py')
+ dist_list.append(f)
+ dist_list.append('SConstruct')
+ dist_list.append('build.py')
targets = []
basename = self.name + '-' + self.version
for src in dist_list:
- tgt = os.path.join (basename, src)
- targets.append (dist_env.MyCopyBuilder (target = tgt, source = src))
+ tgt = os.path.join(basename, src)
+ targets.append(dist_env.MyCopyBuilder(target=tgt, source=src))
tar = basename + '.tar.gz'
zip = basename + '.zip'
- tmp_tar = os.path.join (self.build_dir, tar)
- tmp_zip = os.path.join (self.build_dir, zip)
+ tmp_tar = os.path.join(self.build_dir, tar)
+ tmp_zip = os.path.join(self.build_dir, zip)
dist_tgt = [tar, zip]
dist_src = [tmp_tar, tmp_zip]
- dist_env.Tar (tmp_tar, targets)
- dist_env.Zip (tmp_zip, targets)
- dist_builder = dist_env.MyCopyBuilder (target = dist_tgt, source = dist_src)
- dist_env.Alias ('dist', dist_builder)
- dist_env.Append (RM_DIR=basename)
- dist_env.AddPostAction (dist_builder, dist_env.Action (MyRmTree,
- strfunction = MyRmTreePrint))
- dist_builder = dist_env.MyCopyBuilder (target = dist_tgt, source = dist_src)
- dist_env.Alias ('fastdist', dist_tgt)
+ dist_env.Tar(tmp_tar, targets)
+ dist_env.Zip(tmp_zip, targets)
+ dist_builder = dist_env.MyCopyBuilder(target=dist_tgt, source=dist_src)
+ dist_env.Alias('dist', dist_builder)
+ dist_env.Append(RM_DIR=basename)
+ dist_env.AddPostAction(dist_builder, dist_env.Action(MyRmTree,
+ strfunction=MyRmTreePrint))
+ dist_builder = dist_env.MyCopyBuilder(target=dist_tgt, source=dist_src)
+ dist_env.Alias('fastdist', dist_tgt)
# distcheck
distcheck_list = []
for src in dist_list:
- tgt = os.path.join (self.build_dir, basename, src)
- distcheck_list.append (tgt)
- untar = env.Command (distcheck_list, tar,
- ['cd ' + self.build_dir + ' && tar -zxf ../' + tar])
- scons_dir = os.path.join (self.build_dir, basename)
- distcheck_builder = env.Command ('x',distcheck_list,
- ['cd ' + scons_dir + ' && scons'])
- env.AlwaysBuild (distcheck_builder)
- env.Alias ('distcheck', distcheck_builder)
+ tgt = os.path.join(self.build_dir, basename, src)
+ distcheck_list.append(tgt)
+ untar = env.Command(distcheck_list, tar,
+ ['cd ' + self.build_dir + ' && tar -zxf ../' + tar])
+ scons_dir = os.path.join(self.build_dir, basename)
+ distcheck_builder = env.Command('x', distcheck_list,
+ ['cd ' + scons_dir + ' && scons'])
+ env.AlwaysBuild(distcheck_builder)
+ env.Alias('distcheck', distcheck_builder)
if self.doxygen_config != '':
- doxy = env.Command ('doc/html/*', self.doxygen_config,
- ['doxygen ' + self.doxygen_config])
- env.AlwaysBuild (doxy)
- env.Alias ('doc', doxy)
+ doxy = env.Command('doc/html/*', self.doxygen_config,
+ ['doxygen ' + self.doxygen_config])
+ env.AlwaysBuild(doxy)
+ env.Alias('doc', doxy)
--- a/utils/grid.py Sat Oct 21 11:35:34 2006 +0200
+++ b/utils/grid.py Mon Oct 23 09:24:36 2006 +0200
@@ -9,36 +9,36 @@
class DataRange:
- def __init__ (self, start = 0, end = 0, value = ''):
+ def __init__(self, start = 0, end = 0, value = ''):
self.start = start
self.end = end
self.value = value
class EventString:
- def __init__ (self, at = 0, value = ''):
+ def __init__(self, at = 0, value = ''):
self.at = at
self.value = value
class EventFloat:
- def __init__ (self, at = 0, value = 0.0):
+ def __init__(self, at = 0, value = 0.0):
self.at = at
self.value = value
class EventInt:
- def __init__ (self, at = 0, value = 0.0):
+ def __init__(self, at = 0, value = 0.0):
self.at = at
self.value = value
-def ranges_cmp (a, b):
+def ranges_cmp(a, b):
return a.start - b.start
-def events_cmp (a,b):
+def events_cmp(a, b):
return a.at - b.at
class TimelineDataRange:
- def __init__ (self, name = ''):
+ def __init__(self, name = ''):
self.name = name
self.ranges = []
return
- def __search (self, key):
+ def __search(self, key):
l = 0
- u = len (self.ranges)-1
+ u = len(self.ranges)-1
while l <= u:
- i = int ((l+u)/2)
+ i = int((l + u) / 2)
if key >= self.ranges[i].start and key <= self.ranges[i].end:
return i
elif key < self.ranges[i].start:
@@ -46,51 +46,51 @@
else:
# key > self.ranges[i].end
l = i + 1
- return -1
- def add_range (self, range):
- self.ranges.append (range)
- def get_all (self):
+ return - 1
+ def add_range(self, range):
+ self.ranges.append(range)
+ def get_all(self):
return self.ranges
- def get_ranges (self, start, end):
- s = self.__search (start)
- e = self.__search (end)
+ def get_ranges(self, start, end):
+ s = self.__search(start)
+ e = self.__search(end)
if s == -1 and e == -1:
return []
elif s == -1:
- return self.ranges[0:e+1]
+ return self.ranges[0:e + 1]
elif e == -1:
- return self.ranges[s:len (self.ranges)]
+ return self.ranges[s:len(self.ranges)]
else:
- return self.ranges[s:e+1]
- def get_ranges_bounds (self, start, end):
- s = self.__search (start)
- e = self.__search (end)
+ return self.ranges[s:e + 1]
+ def get_ranges_bounds(self, start, end):
+ s = self.__search(start)
+ e = self.__search(end)
if s == -1 and e == -1:
- return (0,0)
+ return(0, 0)
elif s == -1:
- return (0,e+1)
+ return(0, e + 1)
elif e == -1:
- return (s, len (self.ranges))
+ return(s, len(self.ranges))
else:
- return (s,e+1)
- def sort (self):
- self.ranges.sort (ranges_cmp)
- def get_bounds (self):
- if len (self.ranges) > 0:
+ return(s, e + 1)
+ def sort(self):
+ self.ranges.sort(ranges_cmp)
+ def get_bounds(self):
+ if len(self.ranges) > 0:
lo = self.ranges[0].start
- hi = self.ranges[len (self.ranges)-1].end
- return (lo, hi)
+ hi = self.ranges[len(self.ranges)-1].end
+ return(lo, hi)
else:
- return (0,0)
+ return(0, 0)
class TimelineEvent:
- def __init__ (self, name = ''):
+ def __init__(self, name = ''):
self.name = name
self.events = []
- def __search (self, key):
+ def __search(self, key):
l = 0
- u = len (self.events)-1
+ u = len(self.events)-1
while l <= u:
- i = int ((l+u)/2)
+ i = int((l + u) / 2)
if key == self.events[i].at:
return i
elif key < self.events[i].at:
@@ -99,160 +99,160 @@
# key > self.events[i].at
l = i + 1
return l
- def add_event (self, event):
- self.events.append (event)
- def get_events (self, start, end):
- s = self.__search (start)
- e = self.__search (end)
- return self.events[s:e+1]
- def get_events_bounds (self, start, end):
- s = self.__search (start)
- e = self.__search (end)
- return (s, e+1)
- def sort (self):
- self.events.sort (events_cmp)
- def get_bounds (self):
- if len (self.events) > 0:
+ def add_event(self, event):
+ self.events.append(event)
+ def get_events(self, start, end):
+ s = self.__search(start)
+ e = self.__search(end)
+ return self.events[s:e + 1]
+ def get_events_bounds(self, start, end):
+ s = self.__search(start)
+ e = self.__search(end)
+ return(s, e + 1)
+ def sort(self):
+ self.events.sort(events_cmp)
+ def get_bounds(self):
+ if len(self.events) > 0:
lo = self.events[0].at
hi = self.events[-1].at
- return (lo,hi)
+ return(lo, hi)
else:
- return (0,0)
+ return(0, 0)
class Timeline:
- def __init__ (self, name = ''):
+ def __init__(self, name = ''):
self.ranges = []
self.event_str = []
self.event_int = []
self.name = name
- def get_range (self, name):
+ def get_range(self, name):
for range in self.ranges:
if range.name == name:
return range
- timeline = TimelineDataRange (name)
- self.ranges.append (timeline)
+ timeline = TimelineDataRange(name)
+ self.ranges.append(timeline)
return timeline
- def get_event_str (self, name):
+ def get_event_str(self, name):
for event_str in self.event_str:
if event_str.name == name:
return event_str
- timeline = TimelineEvent (name)
- self.event_str.append (timeline)
+ timeline = TimelineEvent(name)
+ self.event_str.append(timeline)
return timeline
- def get_event_int (self, name):
+ def get_event_int(self, name):
for event_int in self.event_int:
if event_int.name == name:
return event_int
- timeline = TimelineEvent (name)
- self.event_int.append (timeline)
+ timeline = TimelineEvent(name)
+ self.event_int.append(timeline)
return timeline
- def get_ranges (self):
+ def get_ranges(self):
return self.ranges
- def get_events_str (self):
+ def get_events_str(self):
return self.event_str
- def get_events_int (self):
+ def get_events_int(self):
return self.event_int
- def sort (self):
+ def sort(self):
for range in self.ranges:
- range.sort ()
+ range.sort()
for event in self.event_int:
- event.sort ()
+ event.sort()
for event in self.event_str:
- event.sort ()
- def get_bounds (self):
+ event.sort()
+ def get_bounds(self):
lo = 0
hi = 0
for range in self.ranges:
- (range_lo, range_hi) = range.get_bounds ()
+ (range_lo, range_hi) = range.get_bounds()
if range_lo < lo:
lo = range_lo
if range_hi > hi:
hi = range_hi
for event_str in self.event_str:
- (ev_lo, ev_hi) = event_str.get_bounds ()
+ (ev_lo, ev_hi) = event_str.get_bounds()
if ev_lo < lo:
lo = ev_lo
if ev_hi > hi:
hi = ev_hi
for event_int in self.event_int:
- (ev_lo, ev_hi) = event_int.get_bounds ()
+ (ev_lo, ev_hi) = event_int.get_bounds()
if ev_lo < lo:
lo = ev_lo
if ev_hi > hi:
hi = ev_hi
- return (lo, hi)
+ return(lo, hi)
class Timelines:
- def __init__ (self):
+ def __init__(self):
self.timelines = []
- def get (self, name):
+ def get(self, name):
for timeline in self.timelines:
if timeline.name == name:
return timeline
- timeline = Timeline (name)
- self.timelines.append (timeline)
+ timeline = Timeline(name)
+ self.timelines.append(timeline)
return timeline
- def get_all (self):
+ def get_all(self):
return self.timelines
- def sort (self):
+ def sort(self):
for timeline in self.timelines:
- timeline.sort ()
- def get_bounds (self):
+ timeline.sort()
+ def get_bounds(self):
lo = 0
hi = 0
for timeline in self.timelines:
- (t_lo, t_hi) = timeline.get_bounds ()
+ (t_lo, t_hi) = timeline.get_bounds()
if t_lo < lo:
lo = t_lo
if t_hi > hi:
hi = t_hi
- return (lo, hi)
- def get_all_range_values (self):
+ return(lo, hi)
+ def get_all_range_values(self):
range_values = {}
for timeline in self.timelines:
- for ranges in timeline.get_ranges ():
- for ran in ranges.get_all ():
+ for ranges in timeline.get_ranges():
+ for ran in ranges.get_all():
range_values[ran.value] = 1
- return range_values.keys ()
+ return range_values.keys()
class Color:
- def __init__ (self, r = 0.0, g = 0.0, b = 0.0):
+ def __init__(self, r = 0.0, g = 0.0, b = 0.0):
self.r = r
self.g = g
self.b = b
- def set (self, r, g, b):
+ def set(self, r, g, b):
self.r = r
self.g = g
self.b = b
class Colors:
# XXX add more
- default_colors = [Color (1,0,0), Color (0,1,0), Color (0,0,1),Color (1,1,0), Color(1,0,1), Color (0,1,1)]
- def __init__ (self):
+ default_colors = [Color(1, 0, 0), Color(0, 1, 0), Color(0, 0, 1), Color(1, 1, 0), Color(1, 0, 1), Color(0, 1, 1)]
+ def __init__(self):
self.__colors = {}
- def add (self, name, color):
+ def add(self, name, color):
self.__colors[name] = color
- def lookup (self, name):
- if not self.__colors.has_key (name):
- self.add (name, self.default_colors.pop ())
+ def lookup(self, name):
+ if not self.__colors.has_key(name):
+ self.add(name, self.default_colors.pop())
return self.__colors.get(name)
class TopLegendRenderer:
- def __init__ (self):
+ def __init__(self):
self.__padding = 10
- def set_padding (self, padding):
+ def set_padding(self, padding):
self.__padding = padding
- def set_legends (self, legends, colors):
+ def set_legends(self, legends, colors):
self.__legends = legends
self.__colors = colors
- def layout (self, width):
+ def layout(self, width):
self.__width = width
- surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1,1)
+ surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
ctx = cairo.Context(surface)
line_height = 0
total_height = self.__padding
line_used = self.__padding
for legend in self.__legends:
- (t_width, t_height) = ctx.text_extents (legend)[2:4]
- item_width = self.__padding + self.__padding + t_width + self.__padding
+ (t_width, t_height) = ctx.text_extents(legend)[2:4]
+ item_width = self.__padding + self.__padding + t_width + self.__padding
item_height = t_height + self.__padding
if item_height > line_height:
line_height = item_height
@@ -265,16 +265,16 @@
total_height += line_height
self.__height = total_height
- def get_height (self):
+ def get_height(self):
return self.__height
- def draw (self, ctx):
+ def draw(self, ctx):
i = 0
line_height = 0
total_height = self.__padding
line_used = self.__padding
for legend in self.__legends:
- (t_width, t_height) = ctx.text_extents (legend)[2:4]
- item_width = self.__padding + self.__padding + t_width + self.__padding
+ (t_width, t_height) = ctx.text_extents(legend)[2:4]
+ item_width = self.__padding + self.__padding + t_width + self.__padding
item_height = t_height + self.__padding
if item_height > line_height:
line_height = item_height
@@ -284,39 +284,39 @@
else:
line_used += item_width
x = line_used - item_width
- ctx.rectangle (x, total_height, self.__padding, self.__padding)
- ctx.set_source_rgb (0,0,0)
- ctx.set_line_width (2)
- ctx.stroke_preserve ()
- ctx.set_source_rgb (self.__colors[i].r,
- self.__colors[i].g,
- self.__colors[i].b)
- ctx.fill ()
- ctx.move_to (x+self.__padding*2, total_height+t_height)
- ctx.set_source_rgb (0,0,0)
- ctx.show_text (legend)
+ ctx.rectangle(x, total_height, self.__padding, self.__padding)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(2)
+ ctx.stroke_preserve()
+ ctx.set_source_rgb(self.__colors[i].r,
+ self.__colors[i].g,
+ self.__colors[i].b)
+ ctx.fill()
+ ctx.move_to(x + self.__padding*2, total_height + t_height)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.show_text(legend)
i += 1
return
class TimelinesRenderer:
- def __init__ (self):
+ def __init__(self):
self.padding = 10
return
- def get_height (self):
+ def get_height(self):
return self.height
- def set_timelines (self, timelines, colors):
+ def set_timelines(self, timelines, colors):
self.timelines = timelines
self.colors = colors
- def set_render_range (self, start, end):
+ def set_render_range(self, start, end):
self.start = start
self.end = end
- def get_data_x_start (self):
- return self.padding / 2 + self.left_width + self.padding + self.right_width + self.padding/2
- def layout (self, width):
- surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1,1)
+ def get_data_x_start(self):
+ return self.padding / 2 + self.left_width + self.padding + self.right_width + self.padding / 2
+ def layout(self, width):
+ surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
ctx = cairo.Context(surface)
- max_text_height = ctx.text_extents ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]
+ max_text_height = ctx.text_extents("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]
left_width = 0
right_width = 0
@@ -324,21 +324,21 @@
range_n = 0
eventint_n = 0
eventstr_n = 0
- for timeline in self.timelines.get_all ():
+ for timeline in self.timelines.get_all():
left_n_lines += 1
- t_width = ctx.text_extents (timeline.name)[2]
- left_width = max (left_width, t_width)
- for rang in timeline.get_ranges ():
- t_width = ctx.text_extents (rang.name)[2]
- right_width = max (right_width, t_width)
+ t_width = ctx.text_extents(timeline.name)[2]
+ left_width = max(left_width, t_width)
+ for rang in timeline.get_ranges():
+ t_width = ctx.text_extents(rang.name)[2]
+ right_width = max(right_width, t_width)
range_n += 1
- for events_int in timeline.get_events_int ():
- t_width = ctx.text_extents (events_int.name)[2]
- right_width = max (right_width, t_width)
+ for events_int in timeline.get_events_int():
+ t_width = ctx.text_extents(events_int.name)[2]
+ right_width = max(right_width, t_width)
eventint_n += 1
- for events_str in timeline.get_events_str ():
- t_width = ctx.text_extents (events_str.name)[2]
- right_width = max (right_width, t_width)
+ for events_str in timeline.get_events_str():
+ t_width = ctx.text_extents(events_str.name)[2]
+ right_width = max(right_width, t_width)
eventstr_n += 1
left_height = left_n_lines * max_text_height + (left_n_lines - 1) * self.padding
@@ -347,132 +347,132 @@
right_data_height = (eventint_n + eventstr_n) * (max_text_height + 5) + range_n * 10
right_data_height += (right_n_lines - 1) * self.padding
- height = max (left_height, right_height)
- height = max (height, right_data_height)
+ height = max(left_height, right_height)
+ height = max(height, right_data_height)
self.left_width = left_width
self.right_width = right_width
self.max_text_height = max_text_height
self.width = width
self.height = height + self.padding
- def draw_line (self, ctx, x, y, width, height):
- ctx.move_to (x, y)
- ctx.rel_line_to (width, height)
- ctx.close_path ()
- ctx.set_operator (cairo.OPERATOR_SOURCE)
- ctx.set_line_width (1.0)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke ()
- def draw_events (self, ctx, events, x, y, width, height):
+ def draw_line(self, ctx, x, y, width, height):
+ ctx.move_to(x, y)
+ ctx.rel_line_to(width, height)
+ ctx.close_path()
+ ctx.set_operator(cairo.OPERATOR_SOURCE)
+ ctx.set_line_width(1.0)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke()
+ def draw_events(self, ctx, events, x, y, width, height):
if (self.grey_background % 2) == 0:
- ctx.rectangle (x, y-self.padding/2,
- width, height+self.padding)
- ctx.set_source_rgb (0.9,0.9,0.9)
- ctx.fill ()
- last_x_drawn = int (x)
- (lo, hi) = events.get_events_bounds (self.start, self.end)
+ ctx.rectangle(x, y - self.padding / 2,
+ width, height + self.padding)
+ ctx.set_source_rgb(0.9, 0.9, 0.9)
+ ctx.fill()
+ last_x_drawn = int(x)
+ (lo, hi) = events.get_events_bounds(self.start, self.end)
for event in events.events[lo:hi]:
- real_x = int (x + (event.at - self.start) * width / (self.end - self.start))
- if real_x > last_x_drawn+2:
- ctx.rectangle (real_x, y, 1, 1)
- ctx.set_source_rgb (1,0,0)
- ctx.stroke ()
- ctx.move_to (real_x, y+self.max_text_height)
- ctx.set_source_rgb (0,0,0)
- ctx.show_text (str (event.value))
+ real_x = int(x + (event.at - self.start) * width / (self.end - self.start))
+ if real_x > last_x_drawn + 2:
+ ctx.rectangle(real_x, y, 1, 1)
+ ctx.set_source_rgb(1, 0, 0)
+ ctx.stroke()
+ ctx.move_to(real_x, y + self.max_text_height)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.show_text(str(event.value))
last_x_drawn = real_x
self.grey_background += 1
- def draw_ranges (self, ctx, ranges, x, y, width, height):
+ def draw_ranges(self, ctx, ranges, x, y, width, height):
if (self.grey_background % 2) == 0:
- ctx.rectangle (x, y-self.padding/2,
- width, height+self.padding)
- ctx.set_source_rgb (0.9,0.9,0.9)
- ctx.fill ()
- last_x_drawn = int (x-1)
- (lo, hi) = ranges.get_ranges_bounds (self.start, self.end)
+ ctx.rectangle(x, y - self.padding / 2,
+ width, height + self.padding)
+ ctx.set_source_rgb(0.9, 0.9, 0.9)
+ ctx.fill()
+ last_x_drawn = int(x - 1)
+ (lo, hi) = ranges.get_ranges_bounds(self.start, self.end)
for data_range in ranges.ranges[lo:hi]:
- s = max (data_range.start, self.start)
- e = min (data_range.end, self.end)
- x_start = int (x + (s - self.start) * width / (self.end - self.start))
- x_end = int (x + (e - self.start) * width / (self.end - self.start))
+ s = max(data_range.start, self.start)
+ e = min(data_range.end, self.end)
+ x_start = int(x + (s - self.start) * width / (self.end - self.start))
+ x_end = int(x + (e - self.start) * width / (self.end - self.start))
if x_end > last_x_drawn:
- ctx.rectangle (x_start, y, x_end - x_start, 10)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke_preserve ()
- color = self.colors.lookup (data_range.value)
- ctx.set_source_rgb (color.r, color.g, color.b)
- ctx.fill ()
+ ctx.rectangle(x_start, y, x_end - x_start, 10)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke_preserve()
+ color = self.colors.lookup(data_range.value)
+ ctx.set_source_rgb(color.r, color.g, color.b)
+ ctx.fill()
last_x_drawn = x_end
self.grey_background += 1
- def draw (self, ctx):
+ def draw(self, ctx):
timeline_top = 0
top_y = self.padding / 2
left_x_start = self.padding / 2
left_x_end = left_x_start + self.left_width
right_x_start = left_x_end + self.padding
right_x_end = right_x_start + self.right_width
- data_x_start = right_x_end + self.padding /2
+ data_x_start = right_x_end + self.padding / 2
data_x_end = self.width
data_width = data_x_end - data_x_start
cur_y = top_y
- self.draw_line (ctx, 0, 0, self.width, 0)
+ self.draw_line(ctx, 0, 0, self.width, 0)
self.grey_background = 1
- for timeline in self.timelines.get_all ():
- (y_bearing,t_width,t_height) = ctx.text_extents (timeline.name)[1:4]
- ctx.move_to (left_x_start, cur_y + self.max_text_height - (t_height+y_bearing))
- ctx.show_text (timeline.name);
- for events_int in timeline.get_events_int ():
- (y_bearing, t_width, t_height) = ctx.text_extents (events_int.name)[1:4]
- ctx.move_to (right_x_start, cur_y + self.max_text_height - (t_height+y_bearing))
- ctx.show_text (events_int.name)
- self.draw_events (ctx, events_int, data_x_start, cur_y, data_width, self.max_text_height+5)
+ for timeline in self.timelines.get_all():
+ (y_bearing, t_width, t_height) = ctx.text_extents(timeline.name)[1:4]
+ ctx.move_to(left_x_start, cur_y + self.max_text_height - (t_height + y_bearing))
+ ctx.show_text(timeline.name);
+ for events_int in timeline.get_events_int():
+ (y_bearing, t_width, t_height) = ctx.text_extents(events_int.name)[1:4]
+ ctx.move_to(right_x_start, cur_y + self.max_text_height - (t_height + y_bearing))
+ ctx.show_text(events_int.name)
+ self.draw_events(ctx, events_int, data_x_start, cur_y, data_width, self.max_text_height + 5)
cur_y += self.max_text_height + 5 + self.padding
- self.draw_line (ctx, right_x_start-self.padding/2, cur_y - self.padding / 2,
- self.right_width + self.padding, 0)
+ self.draw_line(ctx, right_x_start - self.padding / 2, cur_y - self.padding / 2,
+ self.right_width + self.padding, 0)
- for events_str in timeline.get_events_str ():
- (y_bearing, t_width, t_height) = ctx.text_extents (events_str.name)[1:4]
- ctx.move_to (right_x_start, cur_y + self.max_text_height - (t_height+y_bearing))
- ctx.show_text (events_str.name)
- self.draw_events (ctx, events_str, data_x_start, cur_y, data_width, self.max_text_height+5)
+ for events_str in timeline.get_events_str():
+ (y_bearing, t_width, t_height) = ctx.text_extents(events_str.name)[1:4]
+ ctx.move_to(right_x_start, cur_y + self.max_text_height - (t_height + y_bearing))
+ ctx.show_text(events_str.name)
+ self.draw_events(ctx, events_str, data_x_start, cur_y, data_width, self.max_text_height + 5)
cur_y += self.max_text_height + 5 + self.padding
- self.draw_line (ctx, right_x_start-self.padding/2, cur_y - self.padding / 2,
- self.right_width + self.padding, 0)
- for ranges in timeline.get_ranges ():
- (y_bearing, t_width, t_height) = ctx.text_extents (ranges.name)[1:4]
- ctx.move_to (right_x_start, cur_y + self.max_text_height - (t_height+y_bearing))
- ctx.show_text (ranges.name)
- self.draw_ranges (ctx, ranges, data_x_start, cur_y, data_width, 10)
+ self.draw_line(ctx, right_x_start - self.padding / 2, cur_y - self.padding / 2,
+ self.right_width + self.padding, 0)
+ for ranges in timeline.get_ranges():
+ (y_bearing, t_width, t_height) = ctx.text_extents(ranges.name)[1:4]
+ ctx.move_to(right_x_start, cur_y + self.max_text_height - (t_height + y_bearing))
+ ctx.show_text(ranges.name)
+ self.draw_ranges(ctx, ranges, data_x_start, cur_y, data_width, 10)
cur_y += self.max_text_height + self.padding
- self.draw_line (ctx, right_x_start-self.padding/2, cur_y - self.padding / 2,
- self.right_width + self.padding, 0)
- self.draw_line (ctx, 0, cur_y - self.padding / 2,
- self.width, 0)
+ self.draw_line(ctx, right_x_start - self.padding / 2, cur_y - self.padding / 2,
+ self.right_width + self.padding, 0)
+ self.draw_line(ctx, 0, cur_y - self.padding / 2,
+ self.width, 0)
bot_y = cur_y - self.padding / 2
- self.draw_line (ctx, left_x_end+self.padding/2, 0,
- 0, bot_y)
- self.draw_line (ctx, right_x_end+self.padding/2, 0,
- 0, bot_y)
+ self.draw_line(ctx, left_x_end + self.padding / 2, 0,
+ 0, bot_y)
+ self.draw_line(ctx, right_x_end + self.padding / 2, 0,
+ 0, bot_y)
return
class ScaleRenderer:
- def __init__ (self):
+ def __init__(self):
self.__top = 0
return
- def set_bounds (self, lo, hi):
+ def set_bounds(self, lo, hi):
self.__lo = lo
self.__hi = hi
- def get_position (self, x):
+ def get_position(self, x):
real_x = (x - self.__lo ) * self.__width / (self.__hi - self.__lo)
return real_x
- def set_top (self):
+ def set_top(self):
self.__top = 1
- def set_bot (self):
+ def set_bot(self):
self.__top = 0
- def layout (self, width):
- surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1,1)
+ def layout(self, width):
+ surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
ctx = cairo.Context(surface)
# calculate scale delta
@@ -482,7 +482,7 @@
closest *= 10
if (data_delta / closest) == 0:
delta = closest
- elif (data_delta / closest) == 1:
+ elif(data_delta / closest) == 1:
delta = closest / 10
else:
delta = closest
@@ -493,14 +493,14 @@
self.__width = width
# calculate text height
- max_text_height = ctx.text_extents ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]
+ max_text_height = ctx.text_extents("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]
self.max_text_height = max_text_height
height = max_text_height + 10
self.__height = height
- def get_height (self):
+ def get_height(self):
return self.__height
- def draw (self, ctx):
+ def draw(self, ctx):
delta = self.__delta
start = self.__lo - (self.__lo % delta) + delta
end = self.__hi - (self.__hi % delta)
@@ -510,276 +510,276 @@
else:
s = 1
# print scale points
- ctx.set_source_rgb (0, 0, 0)
- ctx.set_line_width (1.0)
- ticks = range (int (start), int (end + delta), int (delta))
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(1.0)
+ ticks = range(int(start), int(end + delta), int(delta))
for x in ticks:
real_x = (x - self.__lo ) * self.__width / (self.__hi - self.__lo)
- ctx.move_to (real_x, 0)
- ctx.line_to (real_x, 5*s)
- ctx.close_path ()
- ctx.stroke ()
- (t_y_bearing, t_width, t_height) = ctx.text_extents (str (x))[1:4]
+ ctx.move_to(real_x, 0)
+ ctx.line_to(real_x, 5*s)
+ ctx.close_path()
+ ctx.stroke()
+ (t_y_bearing, t_width, t_height) = ctx.text_extents(str(x))[1:4]
if self.__top:
text_delta = t_height + t_y_bearing
else:
text_delta = -t_y_bearing
- ctx.move_to (real_x - t_width/2, (5 + 5 + text_delta)*s)
- ctx.show_text (str (x))
+ ctx.move_to(real_x - t_width / 2, (5 + 5 + text_delta)*s)
+ ctx.show_text(str(x))
# draw subticks
delta /= 10
if delta > 0:
start = self.__lo - (self.__lo % delta) + delta
end = self.__hi - (self.__hi % delta)
- for x in range (int (start), int (end + delta), int (delta)):
+ for x in range(int(start), int(end + delta), int(delta)):
real_x = (x - self.__lo ) * self.__width / (self.__hi - self.__lo)
- ctx.move_to (real_x, 0)
- ctx.line_to (real_x, 3*s)
- ctx.close_path ()
- ctx.stroke ()
+ ctx.move_to(real_x, 0)
+ ctx.line_to(real_x, 3*s)
+ ctx.close_path()
+ ctx.stroke()
class GraphicRenderer:
def __init__(self, start, end):
- self.__start = float (start)
- self.__end = float (end)
- self.__mid_scale = ScaleRenderer ()
- self.__mid_scale.set_top ()
- self.__bot_scale = ScaleRenderer ()
- self.__bot_scale.set_bounds (start, end)
- self.__bot_scale.set_bot ()
+ self.__start = float(start)
+ self.__end = float(end)
+ self.__mid_scale = ScaleRenderer()
+ self.__mid_scale.set_top()
+ self.__bot_scale = ScaleRenderer()
+ self.__bot_scale.set_bounds(start, end)
+ self.__bot_scale.set_bot()
self.__width = 1
self.__height = 1
- def get_width (self):
+ def get_width(self):
return self.__width
- def get_height (self):
+ def get_height(self):
return self.__height
# return x, y, width, height
- def get_data_rectangle (self):
- y_start = self.__top_legend.get_height ()
- x_start = self.__data.get_data_x_start ()
- return (x_start, y_start, self.__width - x_start, self.__data.get_height ())
- def scale_data (self, x):
- x_start = self.__data.get_data_x_start ()
+ def get_data_rectangle(self):
+ y_start = self.__top_legend.get_height()
+ x_start = self.__data.get_data_x_start()
+ return(x_start, y_start, self.__width - x_start, self.__data.get_height())
+ def scale_data(self, x):
+ x_start = self.__data.get_data_x_start()
x_scaled = x / (self.__width - x_start) * (self.__r_end - self.__r_start)
return x_scaled
# return x, y, width, height
- def get_selection_rectangle (self):
- y_start = self.__top_legend.get_height () + self.__data.get_height () + self.__mid_scale.get_height () + 20
- y_height = self.__bot_scale.get_height () + 20
- x_start = self.__bot_scale.get_position (self.__r_start)
- x_end = self.__bot_scale.get_position (self.__r_end)
- return (x_start,y_start,x_end-x_start,y_height)
- def scale_selection (self, x):
+ def get_selection_rectangle(self):
+ y_start = self.__top_legend.get_height() + self.__data.get_height() + self.__mid_scale.get_height() + 20
+ y_height = self.__bot_scale.get_height() + 20
+ x_start = self.__bot_scale.get_position(self.__r_start)
+ x_end = self.__bot_scale.get_position(self.__r_end)
+ return(x_start, y_start, x_end - x_start, y_height)
+ def scale_selection(self, x):
x_scaled = x / self.__width * (self.__end - self.__start)
return x_scaled
- def set_range (self,start, end):
- s = min (start, end)
- e = max (start, end)
- start = max (self.__start, s)
- end = min (self.__end, e)
+ def set_range(self, start, end):
+ s = min(start, end)
+ e = max(start, end)
+ start = max(self.__start, s)
+ end = min(self.__end, e)
self.__r_start = start
self.__r_end = end
- self.__data.set_render_range (start, end)
- self.__mid_scale.set_bounds (start, end)
- self.layout (self.__width, self.__height)
- def get_range (self):
- return (self.__r_start, self.__r_end)
- def set_data (self, data):
+ self.__data.set_render_range(start, end)
+ self.__mid_scale.set_bounds(start, end)
+ self.layout(self.__width, self.__height)
+ def get_range(self):
+ return(self.__r_start, self.__r_end)
+ def set_data(self, data):
self.__data = data
- def set_top_legend (self, top_legend):
+ def set_top_legend(self, top_legend):
self.__top_legend = top_legend
- def layout (self, width, height):
+ def layout(self, width, height):
self.__width = width
self.__height = height
- self.__top_legend.layout (width)
- top_legend_height = self.__top_legend.get_height ()
- self.__data.layout (width)
- self.__mid_scale.layout (width - self.__data.get_data_x_start ())
- self.__bot_scale.layout (width)
+ self.__top_legend.layout(width)
+ top_legend_height = self.__top_legend.get_height()
+ self.__data.layout(width)
+ self.__mid_scale.layout(width - self.__data.get_data_x_start())
+ self.__bot_scale.layout(width)
return
- def __x_pixel (self, x, width):
+ def __x_pixel(self, x, width):
new_x = (x - self.__start) * width / (self.__end - self.__start)
return new_x
- def draw (self, ctx):
+ def draw(self, ctx):
# default background is white
- ctx.save ()
- ctx.set_source_rgb (1, 1, 1)
- ctx.set_operator (cairo.OPERATOR_SOURCE)
- ctx.rectangle (0,0,self.__width,self.__height)
- ctx.fill ()
+ ctx.save()
+ ctx.set_source_rgb(1, 1, 1)
+ ctx.set_operator(cairo.OPERATOR_SOURCE)
+ ctx.rectangle(0, 0, self.__width, self.__height)
+ ctx.fill()
# top legend
- ctx.save ()
- self.__top_legend.draw (ctx)
- top_legend_height = self.__top_legend.get_height ()
- ctx.restore ()
+ ctx.save()
+ self.__top_legend.draw(ctx)
+ top_legend_height = self.__top_legend.get_height()
+ ctx.restore()
# separation line
- ctx.move_to (0, top_legend_height)
- ctx.line_to (self.__width, top_legend_height)
- ctx.close_path ()
- ctx.set_line_width (2)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke ()
+ ctx.move_to(0, top_legend_height)
+ ctx.line_to(self.__width, top_legend_height)
+ ctx.close_path()
+ ctx.set_line_width(2)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke()
# data
- ctx.save ()
- ctx.translate (0,
+ ctx.save()
+ ctx.translate(0,
top_legend_height)
- self.__data.draw (ctx)
- ctx.restore ()
+ self.__data.draw(ctx)
+ ctx.restore()
# scale below data
- ctx.save ()
- ctx.translate (self.__data.get_data_x_start (),
- top_legend_height + self.__data.get_height () + self.__mid_scale.get_height ())
- self.__mid_scale.draw (ctx)
- ctx.restore ()
+ ctx.save()
+ ctx.translate(self.__data.get_data_x_start(),
+ top_legend_height + self.__data.get_height() + self.__mid_scale.get_height())
+ self.__mid_scale.draw(ctx)
+ ctx.restore()
- height_used = top_legend_height + self.__data.get_height () + self.__mid_scale.get_height ()
+ height_used = top_legend_height + self.__data.get_height() + self.__mid_scale.get_height()
# separation between scale and left pane
- ctx.move_to (self.__data.get_data_x_start (), height_used)
- ctx.rel_line_to (0, -self.__mid_scale.get_height ())
- ctx.close_path ()
- ctx.set_source_rgb (0,0,0)
- ctx.set_line_width (2)
- ctx.stroke ()
+ ctx.move_to(self.__data.get_data_x_start(), height_used)
+ ctx.rel_line_to(0, -self.__mid_scale.get_height())
+ ctx.close_path()
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(2)
+ ctx.stroke()
# separation below scale
- ctx.move_to (0, height_used)
- ctx.line_to (self.__width, height_used)
- ctx.close_path ()
- ctx.set_line_width (2)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke ()
+ ctx.move_to(0, height_used)
+ ctx.line_to(self.__width, height_used)
+ ctx.close_path()
+ ctx.set_line_width(2)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke()
- select_start = self.__bot_scale.get_position (self.__r_start)
- select_end = self.__bot_scale.get_position (self.__r_end)
+ select_start = self.__bot_scale.get_position(self.__r_start)
+ select_end = self.__bot_scale.get_position(self.__r_end)
# left connection between top scale and bottom scale
- ctx.move_to (0, height_used);
- ctx.line_to (self.__data.get_data_x_start (), height_used)
- ctx.line_to (select_start, height_used + 20)
- ctx.line_to (0, height_used + 20)
- ctx.line_to (0,height_used)
- ctx.set_source_rgb (0,0,0)
- ctx.set_line_width (1)
- ctx.stroke_preserve ()
- ctx.set_source_rgb (0.9,0.9,0.9)
- ctx.fill ()
+ ctx.move_to(0, height_used);
+ ctx.line_to(self.__data.get_data_x_start(), height_used)
+ ctx.line_to(select_start, height_used + 20)
+ ctx.line_to(0, height_used + 20)
+ ctx.line_to(0, height_used)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(1)
+ ctx.stroke_preserve()
+ ctx.set_source_rgb(0.9, 0.9, 0.9)
+ ctx.fill()
# right connection between top scale and bottom scale
- ctx.move_to (self.__width, height_used)
- ctx.line_to (self.__width, height_used+20)
- ctx.line_to (select_end, height_used+20)
- ctx.line_to (self.__width, height_used)
- ctx.set_source_rgb (0,0,0)
- ctx.set_line_width (1)
- ctx.stroke_preserve ()
- ctx.set_source_rgb (0.9,0.9,0.9)
- ctx.fill ()
+ ctx.move_to(self.__width, height_used)
+ ctx.line_to(self.__width, height_used + 20)
+ ctx.line_to(select_end, height_used + 20)
+ ctx.line_to(self.__width, height_used)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(1)
+ ctx.stroke_preserve()
+ ctx.set_source_rgb(0.9, 0.9, 0.9)
+ ctx.fill()
height_used += 20
# unused area background
- unused_start = self.__bot_scale.get_position (self.__r_start)
- unused_end = self.__bot_scale.get_position (self.__r_end)
- unused_height = self.__bot_scale.get_height () + 20
- ctx.rectangle (0, height_used,
- unused_start,
+ unused_start = self.__bot_scale.get_position(self.__r_start)
+ unused_end = self.__bot_scale.get_position(self.__r_end)
+ unused_height = self.__bot_scale.get_height() + 20
+ ctx.rectangle(0, height_used,
+ unused_start,
unused_height)
- ctx.rectangle (unused_end,
- height_used,
- self.__width - unused_end,
+ ctx.rectangle(unused_end,
+ height_used,
+ self.__width - unused_end,
unused_height)
- ctx.set_source_rgb (0.9,0.9,0.9)
- ctx.fill ()
+ ctx.set_source_rgb(0.9, 0.9, 0.9)
+ ctx.fill()
# border line around bottom scale
- ctx.move_to (unused_end, height_used)
- ctx.line_to (self.__width, height_used)
- ctx.line_to (self.__width, height_used + unused_height)
- ctx.line_to (0, height_used + unused_height)
- ctx.line_to (0, height_used)
- ctx.line_to (unused_start, height_used)
- ctx.close_path ()
- ctx.set_line_width (2)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke ()
- ctx.move_to (unused_start, height_used)
- ctx.line_to (unused_end, height_used)
- ctx.close_path ()
- ctx.set_line_width (1)
- ctx.set_source_rgb (0.9,0.9,0.9)
- ctx.stroke ()
+ ctx.move_to(unused_end, height_used)
+ ctx.line_to(self.__width, height_used)
+ ctx.line_to(self.__width, height_used + unused_height)
+ ctx.line_to(0, height_used + unused_height)
+ ctx.line_to(0, height_used)
+ ctx.line_to(unused_start, height_used)
+ ctx.close_path()
+ ctx.set_line_width(2)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke()
+ ctx.move_to(unused_start, height_used)
+ ctx.line_to(unused_end, height_used)
+ ctx.close_path()
+ ctx.set_line_width(1)
+ ctx.set_source_rgb(0.9, 0.9, 0.9)
+ ctx.stroke()
# unused area dot borders
- ctx.save ()
- ctx.move_to (max (unused_start, 2), height_used)
- ctx.rel_line_to (0,unused_height)
- ctx.move_to (min (unused_end, self.__width-2), height_used)
- ctx.rel_line_to (0, unused_height)
- ctx.set_dash ([5], 0)
- ctx.set_source_rgb (0,0,0)
- ctx.set_line_width (1)
- ctx.stroke ()
- ctx.restore ()
+ ctx.save()
+ ctx.move_to(max(unused_start, 2), height_used)
+ ctx.rel_line_to(0, unused_height)
+ ctx.move_to(min(unused_end, self.__width - 2), height_used)
+ ctx.rel_line_to(0, unused_height)
+ ctx.set_dash([5], 0)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(1)
+ ctx.stroke()
+ ctx.restore()
# bottom scale
- ctx.save ()
- ctx.translate (0, height_used)
- self.__bot_scale.draw (ctx)
- ctx.restore ()
+ ctx.save()
+ ctx.translate(0, height_used)
+ self.__bot_scale.draw(ctx)
+ ctx.restore()
-class GtkGraphicRenderer (gtk.DrawingArea):
- def __init__ (self, data):
- super (GtkGraphicRenderer, self).__init__ ()
+class GtkGraphicRenderer(gtk.DrawingArea):
+ def __init__(self, data):
+ super(GtkGraphicRenderer, self).__init__()
self.__data = data
self.__moving_left = False
self.__moving_right = False
self.__moving_both = False
self.__moving_top = False
self.__force_full_redraw = True
- self.add_events (gtk.gdk.POINTER_MOTION_MASK)
- self.add_events (gtk.gdk.BUTTON_PRESS_MASK)
- self.add_events (gtk.gdk.BUTTON_RELEASE_MASK)
- self.connect ("expose_event", self.expose)
- self.connect ('size-allocate', self.size_allocate)
- self.connect ('motion-notify-event', self.motion_notify)
- self.connect ('button-press-event', self.button_press)
- self.connect ('button-release-event', self.button_release)
- def set_smaller_zoom (self):
- (start, end) = self.__data.get_range ()
- self.__data.set_range (start, start+(end-start)*2)
+ self.add_events(gtk.gdk.POINTER_MOTION_MASK)
+ self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
+ self.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
+ self.connect("expose_event", self.expose)
+ self.connect('size-allocate', self.size_allocate)
+ self.connect('motion-notify-event', self.motion_notify)
+ self.connect('button-press-event', self.button_press)
+ self.connect('button-release-event', self.button_release)
+ def set_smaller_zoom(self):
+ (start, end) = self.__data.get_range()
+ self.__data.set_range(start, start + (end - start)*2)
self.__force_full_redraw = True
- self.queue_draw ()
- def set_bigger_zoom (self):
- (start, end) = self.__data.get_range ()
- self.__data.set_range (start, start+(end-start)/2)
+ self.queue_draw()
+ def set_bigger_zoom(self):
+ (start, end) = self.__data.get_range()
+ self.__data.set_range(start, start + (end - start) / 2)
self.__force_full_redraw = True
- self.queue_draw ()
- def output_png (self, filename):
- surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
- self.__data.get_width (),
- self.__data.get_height ())
- ctx = cairo.Context (self.__buffer_surface)
- self.__data.draw (ctx)
- surface.write_to_png (filename)
- def button_press (self, widget, event):
- (x, y, width, height) = self.__data.get_selection_rectangle ()
- (d_x, d_y, d_width, d_height) = self.__data.get_data_rectangle ()
- if event.y > y and event.y < y+height:
- if abs (event.x - x) < 5:
+ self.queue_draw()
+ def output_png(self, filename):
+ surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
+ self.__data.get_width(),
+ self.__data.get_height())
+ ctx = cairo.Context(self.__buffer_surface)
+ self.__data.draw(ctx)
+ surface.write_to_png(filename)
+ def button_press(self, widget, event):
+ (x, y, width, height) = self.__data.get_selection_rectangle()
+ (d_x, d_y, d_width, d_height) = self.__data.get_data_rectangle()
+ if event.y > y and event.y < y + height:
+ if abs(event.x - x) < 5:
self.__moving_left = True
return True
- if abs (event.x - (x+width)) < 5:
+ if abs(event.x - (x + width)) < 5:
self.__moving_right = True
return True
- if event.x > x and event.x < x+width:
+ if event.x > x and event.x < x + width:
self.__moving_both = True
self.__moving_both_start = event.x
self.__moving_both_cur = event.x
@@ -791,44 +791,44 @@
self.__moving_top_cur = event.x
return True
return False
- def button_release (self, widget, event):
+ def button_release(self, widget, event):
if self.__moving_left:
self.__moving_left = False
- left = self.__data.scale_selection (self.__moving_left_cur)
- right = self.__data.get_range ()[1]
- self.__data.set_range (left, right)
+ left = self.__data.scale_selection(self.__moving_left_cur)
+ right = self.__data.get_range()[1]
+ self.__data.set_range(left, right)
self.__force_full_redraw = True
- self.queue_draw ()
+ self.queue_draw()
return True
if self.__moving_right:
self.__moving_right = False
- right = self.__data.scale_selection (self.__moving_right_cur)
- left = self.__data.get_range ()[0]
- self.__data.set_range (left, right)
+ right = self.__data.scale_selection(self.__moving_right_cur)
+ left = self.__data.get_range()[0]
+ self.__data.set_range(left, right)
self.__force_full_redraw = True
- self.queue_draw ()
+ self.queue_draw()
return True
if self.__moving_both:
self.__moving_both = False
- delta = self.__data.scale_selection (self.__moving_both_cur - self.__moving_both_start)
- (left, right) = self.__data.get_range ()
- self.__data.set_range (left+delta, right+delta)
+ delta = self.__data.scale_selection(self.__moving_both_cur - self.__moving_both_start)
+ (left, right) = self.__data.get_range()
+ self.__data.set_range(left + delta, right + delta)
self.__force_full_redraw = True
- self.queue_draw ()
+ self.queue_draw()
return True
if self.__moving_top:
self.__moving_top = False
return False
- def motion_notify (self, widget, event):
- (x, y, width, height) = self.__data.get_selection_rectangle ()
+ def motion_notify(self, widget, event):
+ (x, y, width, height) = self.__data.get_selection_rectangle()
if self.__moving_left:
if event.x <= 0:
self.__moving_left_cur = 0
- elif event.x >= x+width:
- self.__moving_left_cur = x+width
+ elif event.x >= x + width:
+ self.__moving_left_cur = x + width
else:
self.__moving_left_cur = event.x
- self.queue_draw_area (0, int(y), int(self.__width), int(height))
+ self.queue_draw_area(0, int(y), int(self.__width), int(height))
return True
if self.__moving_right:
if event.x >= self.__width:
@@ -837,7 +837,7 @@
self.__moving_right_cur = x
else:
self.__moving_right_cur = event.x
- self.queue_draw_area (0, int(y), int(self.__width), int(height))
+ self.queue_draw_area(0, int(y), int(self.__width), int(height))
return True
if self.__moving_both:
cur_e = self.__width - (x + width - self.__moving_both_start)
@@ -848,207 +848,207 @@
self.__moving_both_cur = cur_e
else:
self.__moving_both_cur = event.x
- self.queue_draw_area (0, int(y), int(self.__width), int(height))
+ self.queue_draw_area(0, int(y), int(self.__width), int(height))
return True
if self.__moving_top:
self.__moving_top_cur = event.x
- delta = self.__data.scale_data (self.__moving_top_start-self.__moving_top_cur)
- (left, right) = self.__data.get_range ()
- self.__data.set_range (left+delta, right+delta)
+ delta = self.__data.scale_data(self.__moving_top_start - self.__moving_top_cur)
+ (left, right) = self.__data.get_range()
+ self.__data.set_range(left + delta, right + delta)
self.__force_full_redraw = True
self.__moving_top_start = event.x
- self.queue_draw ()
+ self.queue_draw()
return True
- (d_x, d_y, d_width, d_height) = self.__data.get_data_rectangle ()
- if event.y > y and event.y < y+height:
- if abs (event.x - x) < 5 or abs (event.x - (x+width)) < 5:
- widget.window.set_cursor (gtk.gdk.Cursor (gtk.gdk.SB_H_DOUBLE_ARROW))
+ (d_x, d_y, d_width, d_height) = self.__data.get_data_rectangle()
+ if event.y > y and event.y < y + height:
+ if abs(event.x - x) < 5 or abs(event.x - (x + width)) < 5:
+ widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.SB_H_DOUBLE_ARROW))
return True
- if event.x > x and event.x < x+width:
- widget.window.set_cursor (gtk.gdk.Cursor (gtk.gdk.FLEUR))
+ if event.x > x and event.x < x + width:
+ widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR))
return True
if event.y > d_y and event.y < (d_y + d_height):
if event.x > d_x and event.x < (d_x + d_width):
- widget.window.set_cursor (gtk.gdk.Cursor (gtk.gdk.FLEUR))
+ widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.FLEUR))
return True
- widget.window.set_cursor (None)
+ widget.window.set_cursor(None)
return False
- def size_allocate (self, widget, allocation):
+ def size_allocate(self, widget, allocation):
self.__width = allocation.width
self.__height = allocation.height
- self.__data.layout (allocation.width, allocation.height)
+ self.__data.layout(allocation.width, allocation.height)
self.__force_full_redraw = True
- self.queue_draw ()
- def expose (self, widget, event):
+ self.queue_draw()
+ def expose(self, widget, event):
if self.__force_full_redraw:
- self.__buffer_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
- self.__data.get_width (),
- self.__data.get_height ())
+ self.__buffer_surface = cairo.ImageSurface(cairo.FORMAT_ARGB32,
+ self.__data.get_width(),
+ self.__data.get_height())
ctx = cairo.Context(self.__buffer_surface)
- self.__data.draw (ctx)
+ self.__data.draw(ctx)
self.__force_full_redraw = False
ctx = widget.window.cairo_create()
- ctx.rectangle(event.area.x, event.area.y,
+ ctx.rectangle(event.area.x, event.area.y,
event.area.width, event.area.height)
ctx.clip()
- ctx.set_source_surface (self.__buffer_surface)
- ctx.paint ()
- (x, y, width, height) = self.__data.get_selection_rectangle ()
+ ctx.set_source_surface(self.__buffer_surface)
+ ctx.paint()
+ (x, y, width, height) = self.__data.get_selection_rectangle()
if self.__moving_left:
- ctx.move_to (max (self.__moving_left_cur, 2), y)
- ctx.rel_line_to (0, height)
- ctx.close_path ()
- ctx.set_line_width (1)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke ()
+ ctx.move_to(max(self.__moving_left_cur, 2), y)
+ ctx.rel_line_to(0, height)
+ ctx.close_path()
+ ctx.set_line_width(1)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke()
if self.__moving_right:
- ctx.move_to (min (self.__moving_right_cur, self.__width-2), y)
- ctx.rel_line_to (0, height)
- ctx.close_path ()
- ctx.set_line_width (1)
- ctx.set_source_rgb (0,0,0)
- ctx.stroke ()
+ ctx.move_to(min(self.__moving_right_cur, self.__width - 2), y)
+ ctx.rel_line_to(0, height)
+ ctx.close_path()
+ ctx.set_line_width(1)
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.stroke()
if self.__moving_both:
delta_x = self.__moving_both_cur - self.__moving_both_start
left_x = x + delta_x
- ctx.move_to (x+delta_x, y)
- ctx.rel_line_to (0, height)
- ctx.close_path ()
- ctx.move_to (x+width+delta_x, y)
- ctx.rel_line_to (0, height)
- ctx.close_path ()
- ctx.set_source_rgb (0,0,0)
- ctx.set_line_width (1)
- ctx.stroke ()
+ ctx.move_to(x + delta_x, y)
+ ctx.rel_line_to(0, height)
+ ctx.close_path()
+ ctx.move_to(x + width + delta_x, y)
+ ctx.rel_line_to(0, height)
+ ctx.close_path()
+ ctx.set_source_rgb(0, 0, 0)
+ ctx.set_line_width(1)
+ ctx.stroke()
return False
class MainWindow:
- def __init__ (self):
+ def __init__(self):
return
- def run (self, graphic):
+ def run(self, graphic):
window = gtk.Window()
self.__window = window
- window.set_default_size (200, 200)
- vbox = gtk.VBox ()
- window.add (vbox)
+ window.set_default_size(200, 200)
+ vbox = gtk.VBox()
+ window.add(vbox)
render = GtkGraphicRenderer(graphic)
self.__render = render
- vbox.pack_end (render, True, True, 0)
- hbox = gtk.HBox ()
- vbox.pack_start (hbox, False, False, 0)
- smaller_zoom = gtk.Button ("Zoom Out")
- smaller_zoom.connect ("clicked", self.__set_smaller_cb)
- hbox.pack_start (smaller_zoom)
- bigger_zoom = gtk.Button ("Zoom In")
- bigger_zoom.connect ("clicked", self.__set_bigger_cb)
- hbox.pack_start (bigger_zoom)
- output_png = gtk.Button ("Output Png")
- output_png.connect ("clicked", self.__output_png_cb)
- hbox.pack_start (output_png)
+ vbox.pack_end(render, True, True, 0)
+ hbox = gtk.HBox()
+ vbox.pack_start(hbox, False, False, 0)
+ smaller_zoom = gtk.Button("Zoom Out")
+ smaller_zoom.connect("clicked", self.__set_smaller_cb)
+ hbox.pack_start(smaller_zoom)
+ bigger_zoom = gtk.Button("Zoom In")
+ bigger_zoom.connect("clicked", self.__set_bigger_cb)
+ hbox.pack_start(bigger_zoom)
+ output_png = gtk.Button("Output Png")
+ output_png.connect("clicked", self.__output_png_cb)
+ hbox.pack_start(output_png)
window.connect('destroy', gtk.main_quit)
window.show_all()
- #gtk.bindings_activate (gtk.main_quit, 'q', 0)
+ #gtk.bindings_activate(gtk.main_quit, 'q', 0)
gtk.main()
- def __set_smaller_cb (self, widget):
- self.__render.set_smaller_zoom ()
- def __set_bigger_cb (self, widget):
- self.__render.set_bigger_zoom ()
- def __output_png_cb (self, widget):
- dialog = gtk.FileChooserDialog ("Output Png", self.__window,
- gtk.FILE_CHOOSER_ACTION_SAVE, ("Save",1))
+ def __set_smaller_cb(self, widget):
+ self.__render.set_smaller_zoom()
+ def __set_bigger_cb(self, widget):
+ self.__render.set_bigger_zoom()
+ def __output_png_cb(self, widget):
+ dialog = gtk.FileChooserDialog("Output Png", self.__window,
+ gtk.FILE_CHOOSER_ACTION_SAVE, ("Save", 1))
self.__dialog = dialog
- dialog.set_default_response (1)
- dialog.connect ("response", self.__dialog_response_cb)
- dialog.show ()
+ dialog.set_default_response(1)
+ dialog.connect("response", self.__dialog_response_cb)
+ dialog.show()
return
- def __dialog_response_cb (self, widget, response):
+ def __dialog_response_cb(self, widget, response):
if response == 1:
- filename = self.__dialog.get_filename ()
- self.__render.output_png (filename)
- widget.hide ()
+ filename = self.__dialog.get_filename()
+ self.__render.output_png(filename)
+ widget.hide()
return
def read_data(filename):
- timelines = Timelines ()
- colors = Colors ()
+ timelines = Timelines()
+ colors = Colors()
fh = open(filename)
- m1 = re.compile ('range ([^ ]+) ([^ ]+) ([^ ]+) ([0-9]+) ([0-9]+)')
- m2 = re.compile ('event-str ([^ ]+) ([^ ]+) ([^ ]+) ([0-9]+)')
- m3 = re.compile ('event-int ([^ ]+) ([^ ]+) ([0-9]+) ([0-9]+)')
- m4 = re.compile ('color ([^ ]+) #([a-fA-F0-9]{2,2})([a-fA-F0-9]{2,2})([a-fA-F0-9]{2,2})')
+ m1 = re.compile('range ([^ ]+) ([^ ]+) ([^ ]+) ([0-9]+) ([0-9]+)')
+ m2 = re.compile('event-str ([^ ]+) ([^ ]+) ([^ ]+) ([0-9]+)')
+ m3 = re.compile('event-int ([^ ]+) ([^ ]+) ([0-9]+) ([0-9]+)')
+ m4 = re.compile('color ([^ ]+) #([a-fA-F0-9]{2,2})([a-fA-F0-9]{2,2})([a-fA-F0-9]{2,2})')
for line in fh.readlines():
- m = m1.match (line)
+ m = m1.match(line)
if m:
- line_name = m.group (1)
- timeline = timelines.get (m.group (1))
- rang = timeline.get_range (m.group (2))
- data_range = DataRange ()
- data_range.value = m.group (3)
- data_range.start = int (m.group (4))
- data_range.end = int (m.group (5))
- rang.add_range (data_range)
+ line_name = m.group(1)
+ timeline = timelines.get(m.group(1))
+ rang = timeline.get_range(m.group(2))
+ data_range = DataRange()
+ data_range.value = m.group(3)
+ data_range.start = int(m.group(4))
+ data_range.end = int(m.group(5))
+ rang.add_range(data_range)
continue
- m = m2.match (line)
+ m = m2.match(line)
if m:
- line_name = m.group (1)
- timeline = timelines.get (m.group (1))
- ev = timeline.get_event_str (m.group (2))
- event = EventString ()
- event.value = m.group (3)
- event.at = int (m.group (4))
- ev.add_event (event)
+ line_name = m.group(1)
+ timeline = timelines.get(m.group(1))
+ ev = timeline.get_event_str(m.group(2))
+ event = EventString()
+ event.value = m.group(3)
+ event.at = int(m.group(4))
+ ev.add_event(event)
continue
- m = m3.match (line)
+ m = m3.match(line)
if m:
- line_name = m.group (1)
- timeline = timelines.get (m.group (1))
- ev = timeline.get_event_int (m.group (2))
- event = EventInt ()
- event.value = int (m.group (3))
- event.at = int (m.group (4))
- ev.add_event (event)
+ line_name = m.group(1)
+ timeline = timelines.get(m.group(1))
+ ev = timeline.get_event_int(m.group(2))
+ event = EventInt()
+ event.value = int(m.group(3))
+ event.at = int(m.group(4))
+ ev.add_event(event)
continue
- m = m4.match (line)
+ m = m4.match(line)
if m:
- r = int (m.group (2), 16)
- g = int (m.group (3), 16)
- b = int (m.group (4), 16)
- color = Color (r/255, g/255, b/255)
- colors.add (m.group (1), color)
+ r = int(m.group(2), 16)
+ g = int(m.group(3), 16)
+ b = int(m.group(4), 16)
+ color = Color(r / 255, g / 255, b / 255)
+ colors.add(m.group(1), color)
continue
- timelines.sort ()
+ timelines.sort()
return (colors, timelines)
def main():
- (colors, timelines) = read_data (sys.argv[1])
- (lower_bound, upper_bound) = timelines.get_bounds ()
- graphic = GraphicRenderer (lower_bound, upper_bound)
- top_legend = TopLegendRenderer ()
- range_values = timelines.get_all_range_values ()
+ (colors, timelines) = read_data(sys.argv[1])
+ (lower_bound, upper_bound) = timelines.get_bounds()
+ graphic = GraphicRenderer(lower_bound, upper_bound)
+ top_legend = TopLegendRenderer()
+ range_values = timelines.get_all_range_values()
range_colors = []
for range_value in range_values:
- range_colors.append (colors.lookup (range_value))
- top_legend.set_legends (range_values,
- range_colors)
- graphic.set_top_legend (top_legend)
- data = TimelinesRenderer ()
- data.set_timelines (timelines, colors)
- graphic.set_data (data)
+ range_colors.append(colors.lookup(range_value))
+ top_legend.set_legends(range_values,
+ range_colors)
+ graphic.set_top_legend(top_legend)
+ data = TimelinesRenderer()
+ data.set_timelines(timelines, colors)
+ graphic.set_data(data)
# default range
- range_mid = (upper_bound - lower_bound) /2
- range_width = (upper_bound - lower_bound) /10
+ range_mid = (upper_bound - lower_bound) / 2
+ range_width = (upper_bound - lower_bound) / 10
range_lo = range_mid - range_width / 2
range_hi = range_mid + range_width / 2
- graphic.set_range (range_lo, range_hi)
+ graphic.set_range(range_lo, range_hi)
- main_window = MainWindow ()
- main_window.run (graphic)
+ main_window = MainWindow()
+ main_window.run(graphic)
-main ()
+main()