Example #1
0
 def trackselector(block_ptr, string_ptr, data_ptr):
     b = Block(block_ptr)
     string = Str(string_ptr)
     ret = func(b)
     if not ret:
         gterror("Track selector callback function must return a string!")
     string.append_cstr(ret)
Example #2
0
 def trackselector(block_ptr, string_ptr, data_ptr):
     b = Block(block_ptr)
     string = Str(string_ptr)
     ret = func(b)
     if not ret:
         gterror("Track selector callback function must return a string!")
     string.append_cstr(ret)
 def create_new(cls, seqid, start, end):
     if start > end:
         raise "start > end"
     seq_str = Str(str(seqid))
     fn = gtlib.gt_region_node_new(seq_str, start, end)
     n = cls.create_from_ptr(fn, True)
     return n
Example #4
0
 def load_str(self, string):
     err = Error()
     strg = Str(str(string.encode("utf-8")))
     rval = gtlib.gt_style_load_str(self.style, strg._as_parameter_,
                                    err._as_parameter_)
     if rval != 0:
         gterror(err)
Example #5
0
 def create_new(cls, seqid, start, end):
     if start > end:
         raise Error("start > end")
     seq_str = Str(str(seqid))
     fn = gtlib.gt_region_node_new(seq_str._as_parameter_, start, end)
     n = cls.create_from_ptr(fn, True)
     return n
Example #6
0
 def to_str(self):
     err = Error()
     string = Str()
     if gtlib.gt_style_to_str(self.style, string, err) == 0:
         return str(string)
     else:
         gterror(err)
Example #7
0
 def to_str(self):
     err = Error()
     string = Str()
     if gtlib.gt_style_to_str(self.style, string._as_parameter_,
                              err._as_parameter_) == 0:
         return str(string)
     else:
         gterror(err)
Example #8
0
 def create_new(cls, seqid, type, start, end, strand):
     from gt.extended.strand import strandchars
     if not strand in strandchars:
         gterror("Invalid strand '%s' -- must be one of %s" %
                 (strand, strandchars))
     s = Str(str(seqid.encode("utf-8")))
     fn = gtlib.gt_feature_node_new(s, type, start, end, \
                                    strandchars.index(strand))
     n = cls.create_from_ptr(fn, True)
     n.depth_first = True
     return n
Example #9
0
 def get_cstr(self, section, key, gn=None):
     string = Str()
     err = Error()
     rval = gtlib.gt_style_get_str(self.style, section, key, string, gn,
                                   err)
     if rval == STYLE_OK:
         return str(string)
     elif rval == STYLE_NOT_SET:
         return None
     elif rval == STYLE_ERROR:
         gterror(err)
Example #10
0
 def get_cstr(self, section, key, gn=None):
     string = Str()
     err = Error()
     gnp = None
     if gn:
         gnp = gn._as_parameter_
     rval = gtlib.gt_style_get_str(self.style, section, key,
                                   string._as_parameter_, gnp,
                                   err._as_parameter_)
     if rval == STYLE_OK:
         return str(string)
     elif rval == STYLE_NOT_SET:
         return None
     elif rval == STYLE_ERROR:
         gterror(err)
Example #11
0
 def get_caption(self):
     s = Str(gtlib.gt_block_get_caption(self.block))
     return str(s)
Example #12
0
 def get_seqid(self):
     strptr = gtlib.gt_genome_node_get_seqid(self.gn)
     if strptr:
         return str(Str(strptr))
     else:
         return None
Example #13
0
 def to_stream(self):
     from ctypes import string_at
     s = Str(None)
     gtlib.gt_graphics_save_to_stream(self.g, s._as_parameter_)
     return string_at(s.get_mem(), s.length())
Example #14
0
 def decode_seq(self, encoded):
     encstr = (c_ubyte * len(encoded))(*encoded)
     str_p = gtlib.gt_alphabet_decode_seq_to_str(self.alpha, encstr,
                                                 len(encstr))
     s = Str(str_p)
     return str(s)
Example #15
0
 def to_stream(self):
     from ctypes import string_at
     s = Str(None)
     gtlib.gt_graphics_save_to_stream(self.g, s)
     return string_at(s.get_mem(), s.length())
Example #16
0
 def create_new(cls, description, sequence):
     seq_str = Str(sequence.encode('UTF-8'))
     description = description.encode('UTF-8')
     fn = gtlib.gt_sequence_node_new(description, seq_str._as_parameter_)
     n = cls.create_from_ptr(fn, True)
     return n
Example #17
0
 def set_symbolmap_file(self, fn):
     gtlib.gt_encseq_encoder_set_symbolmap_file(self.ee, Str(str(fn.encode("utf-8"))))
Example #18
0
 def set_representation_type(self, sat):
     gtlib.gt_encseq_encoder_set_access_type(self.ee, Str(str(sat.encode("utf-8"))))
Example #19
0
 def to_stream(self):
     from ctypes import string_at
     str = Str(None)
     gtlib.gt_canvas_cairo_file_to_stream(self.canvas, str)
     return string_at(str.get_mem(), str.length())
Example #20
0
 def create_new(cls, description, sequence):
     seq_str = Str(str(sequence.encode("utf-8")))
     fn = gtlib.gt_sequence_node_new(description, seq_str)
     n = cls.create_from_ptr(fn, True)
     return n
Example #21
0
 def set_source(self, source):
     s = Str(str(source.encode("utf-8")))
     gtlib.gt_feature_node_set_source(self.gn, s._as_parameter_)
Example #22
0
 def set_cstr(self, section, key, value):
     string = Str(str(value.encode("utf-8")))
     gtlib.gt_style_set_str(self.style, section, key, string)
Example #23
0
 def to_stream(self):
     from ctypes import string_at
     str = Str(None)
     gtlib.gt_canvas_cairo_file_to_stream(self.canvas, str._as_parameter_)
     return string_at(str.get_mem(), str.length())
Example #24
0
 def get_title_w(ptr, str):
     s = Str(str)
     title = self.get_title()
     s.append_cstr(title)
     return 0
Example #25
0
 def load_str(self, string):
     err = Error()
     strg = Str(str(string).encode("utf-8"))
     rval = gtlib.gt_style_load_str(self.style, strg, err)
     if rval != 0:
         gterror(err)