diff --git a/SConstruct b/SConstruct index 445ae824b..5e84f17e6 100644 --- a/SConstruct +++ b/SConstruct @@ -2,37 +2,37 @@ import os.path import build -ns3 = build.Ns3 () +ns3 = build.Ns3() ns3.build_dir = 'build-dir' ns3.version = '0.0.1' ns3.name = 'ns3' -ns3.doxygen_config = os.path.join ('doc', 'doxygen.conf') -ns3.add_extra_dist (os.path.join ('doc', 'main.txt')) +ns3.doxygen_config = os.path.join('doc', 'doxygen.conf') +ns3.add_extra_dist(os.path.join('doc', 'main.txt')) # # The Core module # -core = build.Ns3Module ('core', 'src/core') -ns3.add (core) -core.add_sources ([ +core = build.Ns3Module('core', 'src/core') +ns3.add(core) +core.add_sources([ 'reference-list-test.cc', 'callback-test.cc', 'test.cc' ]) -env = Environment () +env = Environment() if env['PLATFORM'] == 'posix' or env['PLATFORM'] == 'darwin': - core.add_external_dep ('pthread') - core.add_sources ([ + core.add_external_dep('pthread') + core.add_sources([ 'unix-system-wall-clock-ms.cc', 'unix-system-file.cc' ]) elif env['PLATFORM'] == 'win32': - core.add_sources ([ + core.add_sources([ 'win32-system-wall-clock-ms.cc', 'win32-system-file.cc' ]) -core.add_inst_headers ([ +core.add_inst_headers([ 'system-file.h', 'system-wall-clock-ms.h', 'reference-list.h', @@ -44,10 +44,10 @@ core.add_inst_headers ([ # # The Simu module # -simu = build.Ns3Module ('simulator', 'src/simulator') -ns3.add (simu) -simu.add_dep ('core') -simu.add_sources ([ +simu = build.Ns3Module('simulator', 'src/simulator') +ns3.add(simu) +simu.add_dep('core') +simu.add_sources([ 'time.cc', 'event-id.cc', 'scheduler.cc', @@ -58,12 +58,12 @@ simu.add_sources ([ 'event-impl.cc', 'simulator.cc', ]) -simu.add_headers ([ +simu.add_headers([ 'scheduler-heap.h', 'scheduler-map.h', 'scheduler-list.h' ]) -simu.add_inst_headers ([ +simu.add_inst_headers([ 'nstime.h', 'event-id.h', 'event-impl.h', @@ -75,10 +75,10 @@ simu.add_inst_headers ([ # # The Common module # -common = build.Ns3Module ('common', 'src/common') -common.add_deps (['core', 'simulator']) -ns3.add (common) -common.add_sources ([ +common = build.Ns3Module('common', 'src/common') +common.add_deps(['core', 'simulator']) +ns3.add(common) +common.add_sources([ 'buffer.cc', 'header.cc', 'trailer.cc', @@ -89,7 +89,7 @@ common.add_sources ([ 'variable-tracer-test.cc', 'stream-tracer-test.cc', ]) -common.add_inst_headers ([ +common.add_inst_headers([ 'buffer.h', 'header.h', 'trailer.h', @@ -106,55 +106,55 @@ common.add_inst_headers ([ # utils -run_tests = build.Ns3Module ('run-tests', 'utils') -ns3.add (run_tests) -run_tests.set_executable () -run_tests.add_deps (['core', 'simulator', 'common']) -run_tests.add_source ('run-tests.cc') +run_tests = build.Ns3Module('run-tests', 'utils') +ns3.add(run_tests) +run_tests.set_executable() +run_tests.add_deps(['core', 'simulator', 'common']) +run_tests.add_source('run-tests.cc') -bench_packets = build.Ns3Module ('bench-packets', 'utils') -#ns3.add (bench_packets) -bench_packets.set_executable () -bench_packets.add_dep ('core') -bench_packets.add_source ('bench-packets.cc') +bench_packets = build.Ns3Module('bench-packets', 'utils') +#ns3.add(bench_packets) +bench_packets.set_executable() +bench_packets.add_dep('core') +bench_packets.add_source('bench-packets.cc') -bench_simu = build.Ns3Module ('bench-simulator', 'utils') -ns3.add (bench_simu) -bench_simu.set_executable () -bench_simu.add_dep ('simulator') -bench_simu.add_source ('bench-simulator.cc') +bench_simu = build.Ns3Module('bench-simulator', 'utils') +ns3.add(bench_simu) +bench_simu.set_executable() +bench_simu.add_dep('simulator') +bench_simu.add_source('bench-simulator.cc') # samples -sample_callback = build.Ns3Module ('sample-callback', 'samples') -sample_callback.set_executable () -ns3.add (sample_callback) -sample_callback.add_dep ('core') -sample_callback.add_source ('main-callback.cc') +sample_callback = build.Ns3Module('sample-callback', 'samples') +sample_callback.set_executable() +ns3.add(sample_callback) +sample_callback.add_dep('core') +sample_callback.add_source('main-callback.cc') -sample_trace = build.Ns3Module ('sample-trace', 'samples') -ns3.add (sample_trace) -sample_trace.add_dep ('common') -sample_trace.set_executable () -sample_trace.add_source ('main-trace.cc') +sample_trace = build.Ns3Module('sample-trace', 'samples') +ns3.add(sample_trace) +sample_trace.add_dep('common') +sample_trace.set_executable() +sample_trace.add_source('main-trace.cc') -sample_simu = build.Ns3Module ('sample-simulator', 'samples') -ns3.add (sample_simu) -sample_simu.set_executable () -sample_simu.add_dep ('simulator') -sample_simu.add_source ('main-simulator.cc') +sample_simu = build.Ns3Module('sample-simulator', 'samples') +ns3.add(sample_simu) +sample_simu.set_executable() +sample_simu.add_dep('simulator') +sample_simu.add_source('main-simulator.cc') -sample_packet = build.Ns3Module ('sample-packet', 'samples') -ns3.add (sample_packet) -sample_packet.set_executable () -sample_packet.add_dep ('common') -sample_packet.add_source ('main-packet.cc') +sample_packet = build.Ns3Module('sample-packet', 'samples') +ns3.add(sample_packet) +sample_packet.set_executable() +sample_packet.add_dep('common') +sample_packet.add_source('main-packet.cc') -sample_test = build.Ns3Module ('sample-test', 'samples') -sample_test.set_executable () -ns3.add (sample_test) -sample_test.add_dep ('core') -sample_test.add_source ('main-test.cc') +sample_test = build.Ns3Module('sample-test', 'samples') +sample_test.set_executable() +ns3.add(sample_test) +sample_test.add_dep('core') +sample_test.add_source('main-test.cc') -ns3.generate_dependencies () +ns3.generate_dependencies() diff --git a/build.py b/build.py index 7769ae117..a2c2c2552 100644 --- a/build.py +++ b/build.py @@ -39,7 +39,7 @@ except AttributeError: 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 @@ class Ns3Module: 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 @@ class Ns3BuildVariant: 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 @@ class Ns3: 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 @@ class Ns3: 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) diff --git a/utils/grid.py b/utils/grid.py index 2a527a005..dd195848c 100644 --- a/utils/grid.py +++ b/utils/grid.py @@ -9,36 +9,36 @@ import gtk 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 @@ class TimelineDataRange: 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 @@ class TimelineEvent: # 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 @@ class TopLegendRenderer: 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 @@ class TopLegendRenderer: 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 @@ class TimelinesRenderer: 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 @@ class TimelinesRenderer: 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 @@ class ScaleRenderer: 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 @@ class ScaleRenderer: 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 @@ class ScaleRenderer: 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 @@ class GtkGraphicRenderer (gtk.DrawingArea): 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 @@ class GtkGraphicRenderer (gtk.DrawingArea): 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 @@ class GtkGraphicRenderer (gtk.DrawingArea): 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()