• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdenetwork API Reference
  • KDE Home
  • Contact Us
 

kopete/kopete

  • sources
  • kde-4.14
  • kdenetwork
  • kopete
  • kopete
  • chatwindow
kopetechatwindowstyle.cpp
Go to the documentation of this file.
1  /*
2  kopetechatwindowstyle.cpp - A Chat Window Style.
3 
4  Copyright (c) 2005 by MichaĆ«l Larouche <larouche@kde.org>
5 
6  Kopete (c) 2002-2008 by the Kopete developers <kopete-devel@kde.org>
7 
8  *************************************************************************
9  * *
10  * This program is free software; you can redistribute it and/or modify *
11  * it under the terms of the GNU General Public License as published by *
12  * the Free Software Foundation; either version 2 of the License, or *
13  * (at your option) any later version. *
14  * *
15  *************************************************************************
16 */
17 
18 #include "kopetechatwindowstyle.h"
19 
20 // Qt includes
21 #include <QFile>
22 #include <QDir>
23 #include <QHash>
24 #include <QStringList>
25 #include <QTextCodec>
26 #include <QTextStream>
27 
28 // KDE includes
29 #include <kdebug.h>
30 #include <klocale.h>
31 #include <kstandarddirs.h>
32 
33 class ChatWindowStyle::Private
34 {
35 public:
36  QString styleName;
37  StyleVariants variantsList;
38  QString baseHref;
39  QString currentVariantPath;
40 
41  QString headerHtml;
42  QString footerHtml;
43  QString incomingHtml;
44  QString nextIncomingHtml;
45  QString outgoingHtml;
46  QString nextOutgoingHtml;
47  QString statusHtml;
48  QString actionIncomingHtml;
49  QString actionOutgoingHtml;
50  QString fileTransferIncomingHtml;
51  QString voiceClipIncomingHtml;
52  QString outgoingStateSendingHtml;
53  QString outgoingStateErrorHtml;
54  QString outgoingStateSentHtml;
55  QString outgoingStateUnknownHtml;
56 
57  QHash<QString, bool> compactVariants;
58 };
59 
60 ChatWindowStyle::ChatWindowStyle(const QString &styleName, StyleBuildMode styleBuildMode)
61  : QObject(), d(new Private)
62 {
63  init(styleName, styleBuildMode);
64 }
65 
66 ChatWindowStyle::ChatWindowStyle(const QString &styleName, const QString &variantPath, StyleBuildMode styleBuildMode)
67  : QObject(), d(new Private)
68 {
69  d->currentVariantPath = variantPath;
70  init(styleName, styleBuildMode);
71 }
72 
73 void ChatWindowStyle::init(const QString &styleName, StyleBuildMode styleBuildMode)
74 {
75  QStringList styleDirs = KGlobal::dirs()->findDirs("appdata", QString("styles/%1/Contents/Resources/").arg(styleName));
76  if(styleDirs.isEmpty())
77  {
78  kDebug(14000) << "Failed to find style" << styleName;
79  return;
80  }
81  d->styleName = styleName;
82  if(styleDirs.count() > 1)
83  kDebug(14000) << "found several styles with the same name. using first";
84  d->baseHref = styleDirs.at(0);
85  kDebug(14000) << "Using style:" << d->baseHref;
86  readStyleFiles();
87  if(styleBuildMode & StyleBuildNormal)
88  {
89  listVariants();
90  }
91 }
92 
93 ChatWindowStyle::~ChatWindowStyle()
94 {
95  kDebug(14000) ;
96  delete d;
97 }
98 
99 bool ChatWindowStyle::isValid() const
100 {
101  return ( !d->statusHtml.isEmpty() && !d->fileTransferIncomingHtml.isEmpty() && !d->nextIncomingHtml.isEmpty()
102  && !d->incomingHtml.isEmpty() && !d->nextOutgoingHtml.isEmpty() && !d->outgoingHtml.isEmpty() );
103 }
104 
105 ChatWindowStyle::StyleVariants ChatWindowStyle::getVariants()
106 {
107  // If the variantList is empty, list available variants.
108  if( d->variantsList.isEmpty() )
109  {
110  listVariants();
111  }
112  return d->variantsList;
113 }
114 
115 QString ChatWindowStyle::getStyleName() const
116 {
117  return d->styleName;
118 }
119 
120 QString ChatWindowStyle::getStyleBaseHref() const
121 {
122  return d->baseHref;
123 }
124 
125 QString ChatWindowStyle::getHeaderHtml() const
126 {
127  return d->headerHtml;
128 }
129 
130 QString ChatWindowStyle::getFooterHtml() const
131 {
132  return d->footerHtml;
133 }
134 
135 QString ChatWindowStyle::getIncomingHtml() const
136 {
137  return d->incomingHtml;
138 }
139 
140 QString ChatWindowStyle::getNextIncomingHtml() const
141 {
142  return d->nextIncomingHtml;
143 }
144 
145 QString ChatWindowStyle::getOutgoingHtml() const
146 {
147  return d->outgoingHtml;
148 }
149 
150 QString ChatWindowStyle::getNextOutgoingHtml() const
151 {
152  return d->nextOutgoingHtml;
153 }
154 
155 QString ChatWindowStyle::getStatusHtml() const
156 {
157  return d->statusHtml;
158 }
159 
160 QString ChatWindowStyle::getActionIncomingHtml() const
161 {
162  return d->actionIncomingHtml;
163 }
164 
165 QString ChatWindowStyle::getActionOutgoingHtml() const
166 {
167  return d->actionOutgoingHtml;
168 }
169 
170 QString ChatWindowStyle::getFileTransferIncomingHtml() const
171 {
172  return d->fileTransferIncomingHtml;
173 }
174 
175 QString ChatWindowStyle::getVoiceClipIncomingHtml() const
176 {
177  return d->voiceClipIncomingHtml;
178 }
179 
180 QString ChatWindowStyle::getOutgoingStateSendingHtml() const
181 {
182  return d->outgoingStateSendingHtml;
183 }
184 
185 QString ChatWindowStyle::getOutgoingStateSentHtml() const
186 {
187  return d->outgoingStateSentHtml;
188 }
189 
190 QString ChatWindowStyle::getOutgoingStateErrorHtml() const
191 {
192  return d->outgoingStateErrorHtml;
193 }
194 
195 QString ChatWindowStyle::getOutgoingStateUnknownHtml() const
196 {
197  return d->outgoingStateUnknownHtml;
198 }
199 
200 bool ChatWindowStyle::hasActionTemplate() const
201 {
202  return ( !d->actionIncomingHtml.isEmpty() && !d->actionOutgoingHtml.isEmpty() );
203 }
204 
205 void ChatWindowStyle::listVariants()
206 {
207  QString variantDirPath = d->baseHref + QString::fromUtf8("Variants/");
208  QDir variantDir(variantDirPath);
209 
210  QStringList variantList = variantDir.entryList( QStringList("*.css") );
211  QStringList::ConstIterator it, itEnd = variantList.constEnd();
212  QLatin1String compactVersionPrefix("_compact_");
213  for(it = variantList.constBegin(); it != itEnd; ++it)
214  {
215  QString variantName = *it, variantPath;
216  // Retrieve only the file name.
217  variantName = variantName.left(variantName.lastIndexOf("."));
218  if ( variantName.startsWith( compactVersionPrefix ) ) {
219  if ( variantName == compactVersionPrefix ) {
220  d->compactVariants.insert( "", true );
221  }
222  continue;
223  }
224  QString compactVersionFilename = *it;
225  QString compactVersionPath = variantDirPath + compactVersionFilename.prepend( compactVersionPrefix );
226  if ( QFile::exists( compactVersionPath )) {
227  d->compactVariants.insert( variantName, true );
228  }
229  // variantPath is relative to baseHref.
230  variantPath = QString("Variants/%1").arg(*it);
231  d->variantsList.insert(variantName, variantPath);
232  }
233 }
234 
235 void ChatWindowStyle::readStyleFiles()
236 {
237  QString headerFile = d->baseHref + QString("Header.html");
238  QString footerFile = d->baseHref + QString("Footer.html");
239  QString incomingFile = d->baseHref + QString("Incoming/Content.html");
240  QString nextIncomingFile = d->baseHref + QString("Incoming/NextContent.html");
241  QString outgoingFile = d->baseHref + QString("Outgoing/Content.html");
242  QString nextOutgoingFile = d->baseHref + QString("Outgoing/NextContent.html");
243  QString statusFile = d->baseHref + QString("Status.html");
244  QString actionIncomingFile = d->baseHref + QString("Incoming/Action.html");
245  QString actionOutgoingFile = d->baseHref + QString("Outgoing/Action.html");
246  QString fileTransferIncomingFile = d->baseHref + QString("Incoming/FileTransferRequest.html");
247  QString voiceClipIncomingFile = d->baseHref + QString("Incoming/voiceClipRequest.html");
248  QString outgoingStateUnknownFile = d->baseHref + QString("Outgoing/StateUnknown.html");
249  QString outgoingStateSendingFile = d->baseHref + QString("Outgoing/StateSending.html");
250  QString outgoingStateSentFile = d->baseHref + QString("Outgoing/StateSent.html");
251  QString outgoingStateErrorFile = d->baseHref + QString("Outgoing/StateError.html");
252 
253  QFile fileAccess;
254  // First load header file.
255  if( QFile::exists(headerFile) )
256  {
257  fileAccess.setFileName(headerFile);
258  fileAccess.open(QIODevice::ReadOnly);
259  QTextStream headerStream(&fileAccess);
260  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
261  d->headerHtml = headerStream.readAll();
262  kDebug(14000) << "Header HTML: " << d->headerHtml;
263  fileAccess.close();
264  }
265  // Load Footer file
266  if( QFile::exists(footerFile) )
267  {
268  fileAccess.setFileName(footerFile);
269  fileAccess.open(QIODevice::ReadOnly);
270  QTextStream headerStream(&fileAccess);
271  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
272  d->footerHtml = headerStream.readAll();
273  kDebug(14000) << "Footer HTML: " << d->footerHtml;
274  fileAccess.close();
275  }
276  // Load incoming file
277  if( QFile::exists(incomingFile) )
278  {
279  fileAccess.setFileName(incomingFile);
280  fileAccess.open(QIODevice::ReadOnly);
281  QTextStream headerStream(&fileAccess);
282  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
283  d->incomingHtml = headerStream.readAll();
284  kDebug(14000) << "Incoming HTML: " << d->incomingHtml;
285  fileAccess.close();
286  }
287  // Load next Incoming file
288  if( QFile::exists(nextIncomingFile) )
289  {
290  fileAccess.setFileName(nextIncomingFile);
291  fileAccess.open(QIODevice::ReadOnly);
292  QTextStream headerStream(&fileAccess);
293  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
294  d->nextIncomingHtml = headerStream.readAll();
295  kDebug(14000) << "NextIncoming HTML: " << d->nextIncomingHtml;
296  fileAccess.close();
297  }
298  // Load outgoing file
299  if( QFile::exists(outgoingFile) )
300  {
301  fileAccess.setFileName(outgoingFile);
302  fileAccess.open(QIODevice::ReadOnly);
303  QTextStream headerStream(&fileAccess);
304  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
305  d->outgoingHtml = headerStream.readAll();
306  kDebug(14000) << "Outgoing HTML: " << d->outgoingHtml;
307  fileAccess.close();
308  }
309  // Load next outgoing file
310  if( QFile::exists(nextOutgoingFile) )
311  {
312  fileAccess.setFileName(nextOutgoingFile);
313  fileAccess.open(QIODevice::ReadOnly);
314  QTextStream headerStream(&fileAccess);
315  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
316  d->nextOutgoingHtml = headerStream.readAll();
317  kDebug(14000) << "NextOutgoing HTML: " << d->nextOutgoingHtml;
318  fileAccess.close();
319  }
320  // Load status file
321  if( QFile::exists(statusFile) )
322  {
323  fileAccess.setFileName(statusFile);
324  fileAccess.open(QIODevice::ReadOnly);
325  QTextStream headerStream(&fileAccess);
326  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
327  d->statusHtml = headerStream.readAll();
328  kDebug(14000) << "Status HTML: " << d->statusHtml;
329  fileAccess.close();
330  }
331 
332  // Load Action Incoming file
333  if( QFile::exists(actionIncomingFile) )
334  {
335  fileAccess.setFileName(actionIncomingFile);
336  fileAccess.open(QIODevice::ReadOnly);
337  QTextStream headerStream(&fileAccess);
338  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
339  d->actionIncomingHtml = headerStream.readAll();
340  kDebug(14000) << "ActionIncoming HTML: " << d->actionIncomingHtml;
341  fileAccess.close();
342  }
343  // Load Action Outgoing file
344  if( QFile::exists(actionOutgoingFile) )
345  {
346  fileAccess.setFileName(actionOutgoingFile);
347  fileAccess.open(QIODevice::ReadOnly);
348  QTextStream headerStream(&fileAccess);
349  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
350  d->actionOutgoingHtml = headerStream.readAll();
351  kDebug(14000) << "ActionOutgoing HTML: " << d->actionOutgoingHtml;
352  fileAccess.close();
353  }
354  // Load FileTransfer Incoming file
355  if( QFile::exists(fileTransferIncomingFile) )
356  {
357  fileAccess.setFileName(fileTransferIncomingFile);
358  fileAccess.open(QIODevice::ReadOnly);
359  QTextStream headerStream(&fileAccess);
360  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
361  d->fileTransferIncomingHtml = headerStream.readAll();
362  kDebug(14000) << "fileTransferIncoming HTML: " << d->fileTransferIncomingHtml;
363  fileAccess.close();
364  }
365 
366  if ( d->fileTransferIncomingHtml.isEmpty() ||
367  ( !d->fileTransferIncomingHtml.contains( "saveFileHandlerId" ) &&
368  !d->fileTransferIncomingHtml.contains( "saveFileAsHandlerId" ) ) )
369  { // Create default html
370  d->fileTransferIncomingHtml = d->incomingHtml;
371  QString message = QString( "%message%\n"
372  "<div>\n"
373  " <div style=\"width:37px; float:left;\">\n"
374  " <img src=\"%fileIconPath%\" style=\"width:32px; height:32px; vertical-align:middle;\" />\n"
375  " </div>\n"
376  " <div>\n"
377  " <span><b>%fileName%</b> (%fileSize%)</span><br>\n"
378  " <span>\n"
379  " <input id=\"%saveFileAsHandlerId%\" type=\"button\" value=\"%1\">\n"
380  " <input id=\"%cancelRequestHandlerId%\" type=\"button\" value=\"%2\">\n"
381  " </span>\n"
382  " </div>\n"
383  "</div>" )
384  .arg( i18n( "Download" ), i18n( "Cancel" ) );
385  d->fileTransferIncomingHtml.replace( QLatin1String("%message%"), message );
386  }
387 
388  // Load VoiceClip Incoming file
389  if( QFile::exists(voiceClipIncomingFile) )
390  {
391  fileAccess.setFileName(voiceClipIncomingFile);
392  fileAccess.open(QIODevice::ReadOnly);
393  QTextStream headerStream(&fileAccess);
394  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
395  d->voiceClipIncomingHtml = headerStream.readAll();
396  kDebug(14000) << "voiceClipIncoming HTML: " << d->voiceClipIncomingHtml;
397  fileAccess.close();
398  }
399 
400  if ( d->voiceClipIncomingHtml.isEmpty() ||
401  ( !d->voiceClipIncomingHtml.contains( "playVoiceHandlerId" ) &&
402  !d->voiceClipIncomingHtml.contains( "saveAsVoiceHandlerId" ) ) )
403  { // Create default html
404  d->voiceClipIncomingHtml = d->incomingHtml;
405  QString message = QString( "%message%\n"
406  "<div>\n"
407  " <div style=\"width:37px; float:left;\">\n"
408  " <img src=\"%fileIconPath%\" style=\"width:32px; height:32px; vertical-align:middle;\" />\n"
409  " </div>\n"
410  " <div>\n"
411  " <span>\n"
412  " <input id=\"%playVoiceHandlerId%\" type=\"button\" value=\"%1\">\n"
413  " <input id=\"%saveAsVoiceHandlerId%\" type=\"button\" value=\"%2\">\n"
414  " </span>\n"
415  " </div>\n"
416  "</div>" )
417  .arg( i18n( "Play" ), i18n( "Save as" ) );
418  d->voiceClipIncomingHtml.replace( QLatin1String("%message%"), message );
419  }
420 
421  // Load outgoing file
422  if( QFile::exists(outgoingStateUnknownFile) )
423  {
424  fileAccess.setFileName(outgoingStateUnknownFile);
425  fileAccess.open(QIODevice::ReadOnly);
426  QTextStream headerStream(&fileAccess);
427  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
428  d->outgoingStateUnknownHtml = headerStream.readAll();
429  kDebug(14000) << "Outgoing StateUnknown HTML: " << d->outgoingStateUnknownHtml;
430  fileAccess.close();
431  }
432 
433  if( QFile::exists(outgoingStateSendingFile) )
434  {
435  fileAccess.setFileName(outgoingStateSendingFile);
436  fileAccess.open(QIODevice::ReadOnly);
437  QTextStream headerStream(&fileAccess);
438  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
439  d->outgoingStateSendingHtml = headerStream.readAll();
440  kDebug(14000) << "Outgoing StateSending HTML: " << d->outgoingStateSendingHtml;
441  fileAccess.close();
442  }
443 
444  if( QFile::exists(outgoingStateSentFile) )
445  {
446  fileAccess.setFileName(outgoingStateSentFile);
447  fileAccess.open(QIODevice::ReadOnly);
448  QTextStream headerStream(&fileAccess);
449  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
450  d->outgoingStateSentHtml = headerStream.readAll();
451  kDebug(14000) << "Outgoing StateSent HTML: " << d->outgoingStateSentHtml;
452  fileAccess.close();
453  }
454 
455  if( QFile::exists(outgoingStateErrorFile) )
456  {
457  fileAccess.setFileName(outgoingStateErrorFile);
458  fileAccess.open(QIODevice::ReadOnly);
459  QTextStream headerStream(&fileAccess);
460  headerStream.setCodec(QTextCodec::codecForName("UTF-8"));
461  d->outgoingStateErrorHtml = headerStream.readAll();
462  kDebug(14000) << "Outgoing StateError HTML: " << d->outgoingStateErrorHtml;
463  fileAccess.close();
464  }
465 }
466 
467 void ChatWindowStyle::reload()
468 {
469  d->variantsList.clear();
470  readStyleFiles();
471  listVariants();
472 }
473 
474 bool ChatWindowStyle::hasCompact( const QString & styleVariant ) const
475 {
476  if ( d->compactVariants.contains( styleVariant ) ) {
477  return d->compactVariants.value( styleVariant );
478  }
479  return false;
480 }
481 
482 QString ChatWindowStyle::compact( const QString & styleVariant ) const
483 {
484  QString compacted = styleVariant;
485  if ( styleVariant.isEmpty() ) {
486  return QLatin1String( "Variants/_compact_.css" );
487  } else {
488  return compacted.insert( compacted.lastIndexOf('/') + 1, QString("_compact_") );
489  }
490 }
ChatWindowStyle::StyleBuildMode
StyleBuildMode
This enum specifies the mode of the constructor.
Definition: kopetechatwindowstyle.h:46
ChatWindowStyle::~ChatWindowStyle
~ChatWindowStyle()
Definition: kopetechatwindowstyle.cpp:93
ChatWindowStyle::getOutgoingStateErrorHtml
QString getOutgoingStateErrorHtml() const
Definition: kopetechatwindowstyle.cpp:190
ChatWindowStyle::getOutgoingHtml
QString getOutgoingHtml() const
Definition: kopetechatwindowstyle.cpp:145
ChatWindowStyle::getIncomingHtml
QString getIncomingHtml() const
Definition: kopetechatwindowstyle.cpp:135
QString::prepend
QString & prepend(QChar ch)
QList::at
const T & at(int i) const
kopetechatwindowstyle.h
QFile::setFileName
void setFileName(const QString &name)
ChatWindowStyle::hasActionTemplate
bool hasActionTemplate() const
Check if the style has the support for Kopete Action template (Kopete extension)
Definition: kopetechatwindowstyle.cpp:200
ChatWindowStyle::getHeaderHtml
QString getHeaderHtml() const
Definition: kopetechatwindowstyle.cpp:125
QFile::exists
bool exists() const
ChatWindowStyle::getNextIncomingHtml
QString getNextIncomingHtml() const
Definition: kopetechatwindowstyle.cpp:140
ChatWindowStyle::getActionOutgoingHtml
QString getActionOutgoingHtml() const
Definition: kopetechatwindowstyle.cpp:165
QFile
QTextStream
QString::lastIndexOf
int lastIndexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
ChatWindowStyle::getActionIncomingHtml
QString getActionIncomingHtml() const
Definition: kopetechatwindowstyle.cpp:160
QList::count
int count(const T &value) const
QString::fromUtf8
QString fromUtf8(const char *str, int size)
QString::insert
QString & insert(int position, QChar ch)
ChatWindowStyle::compact
QString compact(const QString &variant) const
Return the compact version of the given style variant.
Definition: kopetechatwindowstyle.cpp:482
QHash< QString, bool >
ChatWindowStyle::getFooterHtml
QString getFooterHtml() const
Definition: kopetechatwindowstyle.cpp:130
QObject
ChatWindowStyle::getFileTransferIncomingHtml
QString getFileTransferIncomingHtml() const
Definition: kopetechatwindowstyle.cpp:170
QList::isEmpty
bool isEmpty() const
QString::isEmpty
bool isEmpty() const
QString::startsWith
bool startsWith(const QString &s, Qt::CaseSensitivity cs) const
ChatWindowStyle::isValid
bool isValid() const
Checks if the style is valid.
Definition: kopetechatwindowstyle.cpp:99
QString
QFile::open
virtual bool open(QFlags< QIODevice::OpenModeFlag > mode)
ChatWindowStyle::hasCompact
bool hasCompact(const QString &variant) const
Check if the supplied variant has a compact form.
Definition: kopetechatwindowstyle.cpp:474
QStringList
ChatWindowStyle::reload
void reload()
Reload style from disk.
Definition: kopetechatwindowstyle.cpp:467
ChatWindowStyle::getStyleName
QString getStyleName() const
Get the style path.
Definition: kopetechatwindowstyle.cpp:115
QFile::close
virtual void close()
QDir
ChatWindowStyle::getStyleBaseHref
QString getStyleBaseHref() const
Get the style resource directory.
Definition: kopetechatwindowstyle.cpp:120
ChatWindowStyle::getVariants
StyleVariants getVariants()
Get the list of all variants for this theme.
Definition: kopetechatwindowstyle.cpp:105
QLatin1String
ChatWindowStyle::StyleVariants
QHash< QString, QString > StyleVariants
StyleVariants is a typedef to a QHash key = Variant Name value = Path to variant CSS file...
Definition: kopetechatwindowstyle.h:39
ChatWindowStyle::getOutgoingStateUnknownHtml
QString getOutgoingStateUnknownHtml() const
Definition: kopetechatwindowstyle.cpp:195
ChatWindowStyle::ChatWindowStyle
ChatWindowStyle(const QString &styleName, StyleBuildMode styleBuildMode=StyleBuildNormal)
Build a single chat window style.
Definition: kopetechatwindowstyle.cpp:60
QTextCodec::codecForName
QTextCodec * codecForName(const QByteArray &name)
QList::ConstIterator
typedef ConstIterator
QString::left
QString left(int n) const
ChatWindowStyle::getStatusHtml
QString getStatusHtml() const
Definition: kopetechatwindowstyle.cpp:155
QList::constEnd
const_iterator constEnd() const
QList::constBegin
const_iterator constBegin() const
ChatWindowStyle::getOutgoingStateSentHtml
QString getOutgoingStateSentHtml() const
Definition: kopetechatwindowstyle.cpp:185
QString::arg
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
ChatWindowStyle::getVoiceClipIncomingHtml
QString getVoiceClipIncomingHtml() const
Definition: kopetechatwindowstyle.cpp:175
ChatWindowStyle::StyleBuildNormal
Definition: kopetechatwindowstyle.h:46
ChatWindowStyle::getOutgoingStateSendingHtml
QString getOutgoingStateSendingHtml() const
Definition: kopetechatwindowstyle.cpp:180
ChatWindowStyle::getNextOutgoingHtml
QString getNextOutgoingHtml() const
Definition: kopetechatwindowstyle.cpp:150
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:29:08 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

kopete/kopete

Skip menu "kopete/kopete"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdenetwork API Reference

Skip menu "kdenetwork API Reference"
  • kget
  • kopete
  •   kopete
  •   libkopete
  • krdc
  • krfb

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal