local_old_kind = None

         self.conv_textview.just_cleared = True

             if not msg: # message is empty, we don't print it

                 continue

                             KindConstant.SINGLE_MSG_SENT):

                 kind = 'outgoing'

                 name = self.get_our_nick()

                             KindConstant.CHAT_MSG_RECV):

                 kind = 'incoming'

                 name = self.contact.get_shown_name()

                 kind = 'status'

                 name = self.contact.get_shown_name()

             if gajim.config.get('restored_messages_small'):

                 small_attr = ['small']

             xhtml = None

             if msg.startswith('<body '):

                 xhtml = msg

                 msg = _('Subject: %(subject)s\n%(message)s') % \

             ChatControlBase.print_conversation_line(self, msg, kind, name,

                 tim, small_attr, small_attr + ['restored_message'],

                 small_attr + ['restored_message'], False,

                 old_kind=local_old_kind, xhtml=xhtml, additional_data=additional_data)

                 local_old_kind = None

             else:

                 local_old_kind = kind

     def get_encryption_state(self):

         config_key = '%s-%s' % (self.account, self.contact.jid)

         state = gajim.config.get_per('encryption', config_key, 'encryption')

     def set_encryption_menu_icon(self):

         for child in self.encryption_menu.get_children():

         gajim.ged.register_event_handler('gc-message-received',

             ged.POSTCORE, self._nec_gc_message_received)

     def dispatch(self, event, error):

         gajim.ged.raise_event(event, None, str(error))

         self.con = sqlite.connect(LOG_DB_FILE, timeout=20.0,

                 isolation_level='IMMEDIATE')

         os.chdir(back)

         self.cur = self.con.cursor()

         self.set_synchronous(False)

     def get_jids_already_in_db(self):

         try:

             self.cur.execute('SELECT jid FROM jids')

             rows = self.cur.fetchall()

         except sqlite.DatabaseError:

             raise exceptions.DatabaseMalformed(LOG_DB_PATH)

         self.jids_already_in = []

         for row in rows:

                 # malformed jid, ignore line

                 pass

             else:

     def get_jids_in_db(self):

         return self.jids_already_in

         if row is None:

             return None

         else:

                 return True

             return False

             self.cur.execute('SELECT jid_id FROM jids WHERE jid=?', [jid])

             row = self.cur.fetchone()

             if row:

         # oh! a new jid :), we add it now

         if typestr == 'ROOM':

             typ = JIDConstant.ROOM_TYPE

         except Exception:

             unread_results = []

         for message in unread_results:

             # here we get infos for that message, and related jid from jids table

             # do NOT change order of SELECTed things, unless you change function(s)

             # that called this function

                     WHERE logs.log_line_id = %d AND logs.jid_id = jids.jid_id

                     ''' % msg_log_id

                     )

             if len(results) == 0:

                 # Log line is no more in logs table. remove it from unread_messages

                 self.set_read_messages([msg_log_id])

                 continue

         return all_messages

     def write(self, kind, jid, message=None, show=None, tim=None, subject=None,

                 KindConstant.CHAT_MSG_SENT, KindConstant.ERROR, timeout,

                 restore_how_many, pending_how_many), jid_tuple)

         except sqlite.DatabaseError:

             self.dispatch('DB_ERROR',

                           exceptions.DatabaseMalformed(LOG_DB_PATH))

         start_of_day = int(time.mktime(local_time))

         return start_of_day

     def get_conversation_for_date(self, jid, year, month, day, account):

         """

         Load the complete conversation with a given jid on a specific date

             ORDER BY time

             ''' % (where_sql, start_of_day, last_second_of_day), jid_tuple)

     def search_log(self, jid, query, account, year=None, month=None, day=None):

         """

             ORDER BY time

             ''' % (where_sql, like_sql), jid_tuple)

     def get_days_with_logs(self, jid, year, month, max_day, account):

         """

         # and take only one of the same values (distinct)

         # Now we have timestamps of time 0:00 of every day with logs

         self.cur.execute('''

             WHERE (%s)

             AND time BETWEEN %d AND %d

             AND kind NOT IN (%d, %d)

         # convert timestamps to day of month

         for line in result:

         return days_with_logs

             where_sql = 'jid_id = ?'

             jid_tuple = (jid_id,)

         self.cur.execute('''

             WHERE (%s)

             AND kind NOT IN (%d, %d)

             ''' % (where_sql, KindConstant.STATUS, KindConstant.GCSTATUS),

         results = self.cur.fetchone()

         if results is not None:

         else:

             result = None

         return result

         results = self.cur.fetchone()

         if results is not None:

         else:

             result = None

         return result

             return

         self.cur.execute(

                 'SELECT type from transports_cache WHERE transport = "%s"' % jid)

         if results:

                 return

             sql = 'UPDATE transports_cache SET type = %d WHERE transport = "%s"' %\

                     (type_id, jid)

             return {}

         answer = {}

         for result in results:

         return answer

     # A longer note here:

         # list of corrupted entries that will be removed

         to_be_removed = []

             # for each row: unpack the data field

             # (format: (category, type, name, category, type, name, ...

             #   ..., 'FEAT', feature1, feature2, ...).join(' '))

             # NOTE: if there's a need to do more gzip, put that to a function

             try:

             except IOError:

                 # This data is corrupted. It probably contains non-ascii chars

                 continue

             i = 0

             identities = list()

                 i += 1

             # yield the row

         for hash_method, hash_ in to_be_removed:

             sql = '''DELETE FROM caps_cache WHERE hash_method = "%s" AND

                     hash = "%s"''' % (hash_method, hash_)

                 SELECT j.jid, re.jid_id, re.name, re.subscription, re.ask

                 FROM roster_entry re, jids j

                 WHERE re.account_jid_id=? AND j.jid_id=re.jid_id''', (account_jid_id,))

             data[jid] = {}

             if name:

                 data[jid]['name'] = name

                 data[jid]['name'] = None

             data[jid]['subscription'] = \

                     self.convert_db_api_values_to_human_subscription_values(

             data[jid]['groups'] = []

             data[jid]['resources'] = {}

                 data[jid]['ask'] = 'subscribe'

             else:

                 data[jid]['ask'] = None

         # Then we add group for roster entries

         for jid in data:

                     SELECT group_name FROM roster_group

                     WHERE account_jid_id=? AND jid_id=?''',

                     (account_jid_id, data[jid]['id']))

                 data[jid]['groups'].append(group_name)

             del data[jid]['id']

         old unread messages, delete them from unread table

         """

         results = gajim.logger.get_unread_msgs()

             if gajim.contacts.get_first_contact_from_jid(account, jid) and not \

             shown:

                 # We have this jid in our contacts list

                 # with them

                 session = gajim.connections[account].make_new_session(jid)

                 # ok, here we see that we have a message in unread messages

                 # table that is older than a month. It is probably from someone

                 # not in our roster for accounts we usually launch, so we will

                 # delete this id from unread message tables.

     def fill_contacts_and_groups_dicts(self, array, account):

         """