Application Interface Example

#ifndef APP_TEXT_EDITOR
#define APP_TEXT_EDITOR

#include "ApplicationInterface.h"
#include "texteditor.h"

class AppTextEditor : public ApplicationInterface
{
    // Add CLASSINFO Credits, Dependency
    Q_OBJECT
    Q_CLASSINFO("ApplicationName",              "TextEditor")
    Q_CLASSINFO("Description",                  "Text editor with programmable syntax highlighter and completer")
    Q_CLASSINFO("Dependencies",                 "")
    Q_CLASSINFO("RegisteredFileName",           "c,cpp,cs,css,cxx,c++,cmake,d,di,diff,f,f77,f90,h,hh,hpp,hxx,txt,sh,run")
    Q_CLASSINFO("Classification",               "Document/Editors/Text")
    Q_CLASSINFO("UserHelp",                     "TextEditor.html")
    Q_CLASSINFO("Version",                      "1.0.5")
    Q_CLASSINFO("Author",                       "Manuele Turini")
    Q_CLASSINFO("Email",                        "info@officinaturini.com")
    Q_CLASSINFO("URL",                          "https://www.officinaturini.com")
    Q_CLASSINFO("Credits",                      "SciTE text editor and much more ... by Neil Hodgson, http://www.scintilla.org")
    Q_CLASSINFO("Packing",                      "*,qscintilla2.dll")
    Q_CLASSINFO("History.1",                    "1.0.0 12/01/2008 First release.")
    Q_CLASSINFO("History.2",                    "1.0.1 14/08/2009 Update of QScintilla to 2.4.")
    Q_CLASSINFO("History.3",                    "1.0.2 20/10/2009 Improved functions: bookmark, find, replace")
    Q_CLASSINFO("History.3",                    "1.0.3 23/02/2010 Added gotoLine in visible methods")
    Q_CLASSINFO("History.4",                    "1.0.4 30/10/2011 Added sendHTML method")
    Q_CLASSINFO("History.4",                    "1.0.5 29/09/2014 Update of QScintilla to 2.8.4.")
    

    Q_CLASSINFO("Alias.1.ApplicationName",      "RichTextEditor")
    Q_CLASSINFO("Alias.1.Description",          "Advanced WYSIWYG viewer/editor supporting rich text formatting using HTML-style <a href=\"tags.html\">tags</a>")
    Q_CLASSINFO("Alias.1.RegisteredFileName",   "htm,html,rtf")
    Q_CLASSINFO("Alias.1.Classification",       "Document/Editors/Text")
    Q_CLASSINFO("Alias.1.UserHelp",             "RichTextEditor.html")
    Q_CLASSINFO("Alias.1.Version",              "1.0.1")
    Q_CLASSINFO("Alias.1.Author",               "Manuele Turini")
    Q_CLASSINFO("Alias.1.Email",                "info@officinaturini.com")
    Q_CLASSINFO("Alias.1.URL",                  "https://www.officinaturini.com")
    Q_CLASSINFO("Alias.1.Credits",              "")
    Q_CLASSINFO("Alias.1.Packing",              "*,qscintilla2.dll")
    Q_CLASSINFO("Alias.1.History.1",            "1.0.0 12/01/2008 First release.")

    Q_CLASSINFO("Alias.2.ApplicationName",      "HexEditor")
    Q_CLASSINFO("Alias.2.Description",          "Editor for binary files")
    Q_CLASSINFO("Alias.2.RegisteredFileName",   "dll,lib")
    Q_CLASSINFO("Alias.2.Classification",       "Document/Editors/Binary")
    Q_CLASSINFO("Alias.2.UserHelp",             "HexEditor.html")
    Q_CLASSINFO("Alias.2.Version",              "1.0.0")
    Q_CLASSINFO("Alias.2.Author",               "Manuele Turini")
    Q_CLASSINFO("Alias.2.Email",                "info@officinaturini.com")
    Q_CLASSINFO("Alias.2.URL",                  "https://www.officinaturini.com")
    Q_CLASSINFO("Alias.2.Credits",              "")
    Q_CLASSINFO("Alias.2.Packing",              "*,qscintilla2.dll")
    Q_CLASSINFO("Alias.2.History.1",            "1.0.0 12/01/2008 First release.")

    // Library documentation
    Q_CLASSINFO("Library.asciiText.Desc",       "Get the editor contents as ASCII text")
    Q_CLASSINFO("Library.asciiText.Params.1",   "QWidget * // Pointer to textEditor widget")
    Q_CLASSINFO("Library.asciiText.Return",     "const char *")
    Q_CLASSINFO("Library.asciiText.Usage",      " // This example show how to get the text from active text editor in MDI\n"
                                                " // Get the selected window\n"
                                                " QWidget * wd = mInt->selectedWindow();\n"
                                                "     if(wd)\n"
                                                "     {\n"
                                                "         ApplicationInterface * textEditor = mInt->applicationInterface();\n"
                                                "         // Check if the selected window is a text editor class\n"
                                                "         if(mInt->isTheApplication(textEditor, \"TextEditor\"))\n"
                                                "             const char * text = (const char *) mInt->method(textEditor, \"asciiText\", wd);\n"
                                                "             ...")
    Q_CLASSINFO("Library.setAsciiText.Desc",    "Set the editor contents with an ASCII text")
    Q_CLASSINFO("Library.setAsciiText.Params.1","QWidget *    // Pointer to textEditor widget")
    Q_CLASSINFO("Library.setAsciiText.Params.2","const char * // Pointer to text")
    Q_CLASSINFO("Library.setAsciiText.Return",  "void")
    Q_CLASSINFO("Library.setAsciiText.Usage",   "mInt->method(appInt, \"setAsciiText\", (void *) wd, (void *) htxt);\n"
                                                "// See <a href=\"#asciiText\">asciiText</a> on detailed parameters usage\n")

public:

    AppTextEditor(MdiInterface * mdiInterface);
    ~AppTextEditor();

    // Property
    const char      * name();
    QIcon           * icon(unsigned index = 0);
    unsigned        uniqueId(void * objectPtr);

    // Creation
    QWidget         * create(unsigned alias = 0, AppBatchList & par = AppBatchList());
    QWidget         * open(unsigned alias = 0, const char * fileName = 0, AppBatchList & par = AppBatchList());

    // File
    const char      * fileName(void * objectPtr);
    bool            saveAs(const char * filePath, void * objectPtr);
    bool            save(void * objectPtr);
    bool            print(void * objectPtr);

    // Edit
    void            undo(void * objectPtr);
    void            redo(void * objectPtr);
    void            cut(void * objectPtr);
    void            copy(void * objectPtr);
    void            paste(void * objectPtr);

    // Control
    bool            close(void * objectPtr);
    void            update(void * objectPtr);
    void            help(unsigned alias = 0);

    void            script(void * sctx);

    bool            execCalback(TextEditor * te);

    // Visible methods for all applications
    const void      * asciiText(const void ** par);
    const void      * setAsciiText(const void ** par);
    const void      * clearFilter(const void ** par);
    const void      * setFileFilter(const void ** par);
    const void      * setHighLighter(const void ** par);
    const void      * setCallerId(const void ** par);
    const void      * findText(const void ** par);
    const void      * findNextText(const void ** par);
    const void      * findPreviousText(const void ** par);
    const void      * replaceText(const void ** par);
    const void      * exportAsPdf(const void ** par);
    const void      * printPreview(const void ** par);
    const void      * insertChar(const void ** par);
    const void      * setTextBold(const void ** par);
    const void      * setTextItalic(const void ** par);
    const void      * setTextUnderline(const void ** par);
    const void      * setTextStrikeOut(const void ** par);
    const void      * setTextAlignLeft(const void ** par);
    const void      * setTextAlignRight(const void ** par);
    const void      * setTextAlignCenter(const void ** par);
    const void      * setTextAlignJustify(const void ** par);
    const void      * setTextColor(const void ** par);
    const void      * setTextBackgroundColor(const void ** par);
    const void      * setDirectory(const void ** par);
    const void      * setFileName(const void ** par);
    const void      * textFont(const void ** par);
    const void      * textSize(const void ** par);
    const void      * textStyle(const void ** par);
    const void      * addImage(const void ** par);
    const void      * textMargin(const void ** par);
    const void      * makeLink(const void ** par);
    const void      * bookmark(const void ** par);
    const void      * gotoLine(const void ** par);
    const void      * bookmarkList(const void ** par);
    const void      * selectAll(const void ** par);
    const void      * setAutoreload(const void ** par);
    const void      * reload(const void ** par);
    const void      * addLineBar(const void ** par);
    const void      * textVerticalAlignment(const void ** par);
    const void      * createTable(const void ** par);
    const void      * sendHTML(const void ** par);
    const void      * sendText(const void ** par);
    const void      * setCallback(const void ** par);
    const void      * setWindowTitle(const void ** par);

    bool            loadFileFilters(QString & fnp);
        void                    setDefaultFileExtension(QString & ext);

    // Internal
    bool            lookingForBrothers();
    void            printDocument(TextEditor * te, int who = 0);

    QString         prevFileNamePath;
    QString         prevFileFilter;
    static AppTextEditor * application;

private:
    // TextEditor setup
    AppBatchList    sendBack;
    QStringList     fileFilter;
    QString         highLighterFile;
    QString         directory, fileNamePath;
    unsigned        hlCode;
};
#endif

#include <QIcon>
#include <QMdiArea>
#include <QMdiSubWindow>
#include <QFile>
#include <QFileDialog>
#include <QTextStream>
#include <QDockWidget>
#include <QDateTime>
#include <QFileInfo>
#include <QTextCodec>
#include <QFontComboBox>
#include <QSettings>
#include <QMessageBox>
#include <QDesktopServices>
#include <QUrl>
#include <QToolButton>
#include <QPrintDialog>
#include <QPropertyEditor/QPropertyEditorWidget.h>

#include <Qsci/qsciprinter.h>

#include "appTextEditor.h"
#include "mdiInterface.h"
#include "textprinter.h" 
#include "sci.h"
#include "hexedit.h"

AppTextEditor * AppTextEditor::application;

extern "C" ApplicationInterface LIB_MODE * ApplicationInit(MdiInterface * mdiInterface)
{
  AppTextEditor::application = new AppTextEditor(mdiInterface);
  return AppTextEditor::application;
}

typedef void * (*MethodP)(void ** par);

AppTextEditor::AppTextEditor(MdiInterface * mdiInterface)
:ApplicationInterface(mdiInterface)
{
  prevFileNamePath = "";
  prevFileFilter = "";
  library["asciiText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::asciiText);
  library["setAsciiText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setAsciiText);
  library["clearFilter"] = reinterpret_cast<MethodPtr> (& AppTextEditor::clearFilter);
  library["setFilter"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setFileFilter);
  library["setHighLighter"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setHighLighter);
  library["setCallerId"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setCallerId);
  library["findText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::findText);
  library["findNextText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::findNextText);
  library["findPreviousText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::findPreviousText);
  library["replaceText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::replaceText);
  library["exportAsPdf"] = reinterpret_cast<MethodPtr> (& AppTextEditor::exportAsPdf);
  library["printPreview"] = reinterpret_cast<MethodPtr> (& AppTextEditor::printPreview);
  library["insertChar"] = reinterpret_cast<MethodPtr> (& AppTextEditor::insertChar);
  library["setTextBold"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextBold);
  library["setTextItalic"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextItalic);
  library["setTextUnderline"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextUnderline);
  library["setTextStrikeOut"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextStrikeOut);
  library["setTextAlignLeft"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextAlignLeft);
  library["setTextAlignRight"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextAlignRight);
  library["setTextAlignCenter"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextAlignCenter);
  library["setTextAlignJustify"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextAlignJustify);
  library["setTextColor"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextColor);
  library["setTextBackgroundColor"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setTextBackgroundColor);
  library["setDirectory"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setDirectory);
  library["setFileName"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setFileName);
  library["textFont"] = reinterpret_cast<MethodPtr> (& AppTextEditor::textFont);
  library["textSize"] = reinterpret_cast<MethodPtr> (& AppTextEditor::textSize);
  library["textStyle"] = reinterpret_cast<MethodPtr> (& AppTextEditor::textStyle);
  library["addImage"] = reinterpret_cast<MethodPtr> (& AppTextEditor::addImage);
  library["textMargin"] = reinterpret_cast<MethodPtr> (& AppTextEditor::textMargin);
  library["makeLink"] = reinterpret_cast<MethodPtr> (& AppTextEditor::makeLink);
  library["bookmark"] = reinterpret_cast<MethodPtr> (& AppTextEditor::bookmark);
  library["gotoLine"] = reinterpret_cast<MethodPtr> (& AppTextEditor::gotoLine);
  library["bookmarkList"] = reinterpret_cast<MethodPtr> (& AppTextEditor::bookmarkList);
  library["selectAll"] = reinterpret_cast<MethodPtr> (& AppTextEditor::selectAll);
  library["setAutoreload"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setAutoreload);
  library["reload"] = reinterpret_cast<MethodPtr> (& AppTextEditor::reload);
  library["addLineBar"] = reinterpret_cast<MethodPtr> (& AppTextEditor::addLineBar);
  library["textVerticalAlignment"] = reinterpret_cast<MethodPtr> (& AppTextEditor::textVerticalAlignment);
  library["createTable"] = reinterpret_cast<MethodPtr> (& AppTextEditor::createTable);
  library["sendText"] = reinterpret_cast<MethodPtr> (& AppTextEditor::sendText);
  library["sendHTML"] = reinterpret_cast<MethodPtr> (& AppTextEditor::sendHTML);
  library["setCallback"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setCallback);
  library["setWindowTitle"] = reinterpret_cast<MethodPtr> (& AppTextEditor::setWindowTitle);
}

AppTextEditor::~AppTextEditor()
{

}

QIcon * AppTextEditor::icon(unsigned index)
{
  QIcon * ic = 0;
  switch(index)
  {
  case 0: ic = new QIcon(":/TextEditor/images/edit.png");
      break;
  case 1: ic = new QIcon(":/TextEditor/images/redit.png");
      break;
  case 2: ic = new QIcon(":/TextEditor/images/hex.png");
      break;
  default:ic = new QIcon(":/TextEditor/images/edit.png");
      break;
  }
  return ic;
}

const char * AppTextEditor::name()
{
  return mInt->getProperty(this, "ApplicationName");
}

unsigned AppTextEditor::uniqueId(void * objectPtr)
{
  unsigned id;
  if(((QObject *) objectPtr)->objectName() == "HexEditor")
  {
    HexEdit * he = (HexEdit *) objectPtr;
    id = he->identifier();
  }
  else
  {
    TextEditor  * te = (TextEditor *) objectPtr;
    id = te->identifier();
  }
  return id;
}

QWidget * AppTextEditor::create(unsigned alias, AppBatchList & par)
{
  // TextEditor default setup
  highLighterFile = "c";
  switch(alias)
  {
  case 0: loadFileFilters(QString(mInt->applicationPath() + QString("/config/TextEditor/programmerFileTypes.txt")));
      break;
  case 1: loadFileFilters(QString(mInt->applicationPath() + QString("/config/TextEditor/richTextFileTypes.txt")));
      break;
  case 2: return 0;
      break;
  }

  mInt->batch(this, par);
  TextEditor  * te = new TextEditor(mInt->createUniqueId(), mInt->applicationPath(), alias, mInt->mainWindow());
  te->setHighlighter(highLighterFile);
  te->setWindowIcon(*icon(alias));
  if(fileNamePath.isEmpty())
    fileNamePath = "EmptyFile";
  te->setFileName(fileNamePath);
  te->setWindowModified(false);
  mInt->addApplication(te, this);
  return te;
}

bool AppTextEditor::loadFileFilters(QString & fnp)
{
  bool  ret = false;
  fileFilter.clear();
  //mInt->log("fileName [%s]\n", fnp.toLatin1().data());        // !!!
  // Load the file types
  QFile file(fnp);
  if(file.open(QFile::ReadOnly | QFile::Text))
  {
    QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
    while(!file.atEnd()) 
    {
      QByteArray line = file.readLine();
          //mInt->log("line [%s]\n", line.data());      // !!!
      if(!line.isEmpty() && line[0] != '/' && line[1] != '/')
        fileFilter << line.trimmed();
    }
    QApplication::restoreOverrideCursor();
    ret = true;
  }
  //mInt->log("fileFilter.size = %d\n", fileFilter.size());     // !!!
  return ret;
}

QWidget * AppTextEditor::open(unsigned alias, const char * fileName, AppBatchList & par)
{
  QDir                  dir;
  QString               fdir, str;
  QStringList   files;
  TextEditor    * te = 0;

  QWidget   * parent = mInt->mdiArea()->parentWidget();

  // TextEditor default setup
  highLighterFile = "c";
  mInt->batch(this, par);
  switch(alias)
  {
  case 0: loadFileFilters(QString(mInt->applicationPath() + QString("/config/TextEditor/programmerFileTypes.txt")));
        break;
  case 1: loadFileFilters(QString(mInt->applicationPath() + QString("/config/TextEditor/richTextFileTypes.txt")));
    break;
  case 2: loadFileFilters(QString(mInt->applicationPath() + QString("/config/TextEditor/BinaryFileTypes.txt")));
    break;
  }

  directory = "";
  
  //mInt->log("fileName [%s], alias = %d, fileFilter.size = %d\n", fileName, alias, fileFilter.size());         // !!!

  // When the filename isn't specified
  if(fileName == 0)
  {
    if(directory.isEmpty())
      fdir = dir.absoluteFilePath(prevFileNamePath);
    else fdir = directory;
    QFileDialog fd(parent, QObject::tr("Open File"), fdir);
    // Handle of the previously used filter
    if(!prevFileFilter.isEmpty())
    {
      // The last used filter now is the first of the list
      int p1 = fileFilter.indexOf(prevFileFilter);
      if(p1 >= 0)
        fileFilter.move(p1, 0);
    }
    fd.setFilters(fileFilter);
    fd.setFileMode(QFileDialog::ExistingFiles);
    int rc = fd.exec();
    files = fd.selectedFiles();
    if(rc)
    {
      QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
      for(int n = 0; n < files.size(); n++)
      {
        QFile file(files.at(n));
        if(file.open(QFile::ReadOnly | QFile::Text))
        {
          // Try to automatically setup highlighter
          if(par.count() == 0)
          {
            QFileInfo fi(files.at(n));
            QString   fe = fi.completeSuffix().toLower();
            if(!fe.isEmpty())
              highLighterFile = fe;
          }

          QByteArray rText = file.readAll();
          mInt->addRecentFile(files.at(n));
          if(alias == 2)
          {
            HexEdit * he = new HexEdit(mInt->createUniqueId(), parent);
            he->setData(rText);
            he->setFileName(files.at(n));
            mInt->addApplication(he, "HexEditor");
          }
          else
          {
            te = new TextEditor(mInt->createUniqueId(), mInt->applicationPath(), alias, parent, & rText);
            te->setWindowIcon(*icon(alias));
            qApp->processEvents();
            if(alias == 0)
              te->setHighlighter(highLighterFile);
            te->setFileName(files.at(n));
            te->markUnsaved(false);
            if(alias)
              mInt->addApplication(te, "RichTextEditor");
            else
              mInt->addApplication(te, "TextEditor");
          }
          qApp->processEvents();

        }
        prevFileNamePath = QDir::fromNativeSeparators(files.at(0));
        int   c = 0, nx = prevFileNamePath.size() - 1;
        while(prevFileNamePath[nx] != '/') { nx--; c++; }
        prevFileNamePath.chop(c);
        prevFileFilter = fd.selectedFilter();
      }
      QApplication::restoreOverrideCursor(); 
    }
  }
  else 
  {
    // Try to automatically setup completer and highlighter
    if(par.count() == 0)
    {
      QFileInfo fi(fileName);
      QString   fe = fi.completeSuffix().toLower();
      if(!fe.isEmpty())
        highLighterFile = fe;
    }
        setDefaultFileExtension(QString(fileName));
    QFile file(fileName);
    if(file.open(QFile::ReadOnly | QFile::Text))
    {
      bool  rt = alias;
      QByteArray rText = file.readAll();
      if(alias == 2)
      {
        HexEdit * he = new HexEdit(mInt->createUniqueId(), parent);
        he->setData(rText);
        he->setFileName(fileName);
        mInt->addApplication(he, "HexEditor");
      }
      else
      {
        if(!rt)
          rt = Qt::mightBeRichText(rText);
        //mInt->logDebug("Alias = %d", alias);
        te = new TextEditor(mInt->createUniqueId(), mInt->applicationPath(), rt, parent, & rText);
        te->setWindowIcon(*icon(alias));
        te->setFileName(fileName);
        if(alias == 0)
          te->setHighlighter(highLighterFile);
        te->markUnsaved(false);
        if(alias)
          mInt->addApplication(te, "RichTextEditor");
        else
          mInt->addApplication(te, "TextEditor");
      }
    }
  }
  //qDebug("Open end");
  return te;
}

// File
const char * AppTextEditor::fileName(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor")
  {
    HexEdit * he = (HexEdit *) objectPtr;
    he->tempData = he->fileName().toAscii();
    return he->tempData.data();
  }
  else
  {
    TextEditor  * te = (TextEditor *) objectPtr;
    te->tempData = te->fileName().toAscii();
    return te->tempData.data();
  }
}

bool AppTextEditor::saveAs(const char * filePath, void * objectPtr)
{
  bool    ret = false, ok;
  if(((QObject *) objectPtr)->objectName() == "HexEditor")
  {
    HexEdit * he = (HexEdit *) objectPtr;
    QString   fileN = mInt->saveAs(&ok, he, QObject::tr("Save As File"), filePath, fileFilter);
    ret = he->saveFile(fileN);
  }
  else
  {
    TextEditor  * te = (TextEditor *) objectPtr;
        mInt->log("filePath [%s], FF = %s, FFsize = %d\n", filePath, prevFileFilter.toLatin1().data(), fileFilter.size());      // !!!
    QString   fileN = mInt->saveAs(&ok, te, QObject::tr("Save As File"), filePath, fileFilter, prevFileFilter);

    if(ok)
      ret = te->saveAs(fileN);
  }
  return ret;
}

bool AppTextEditor::save(void * objectPtr)
{
  bool  ret = false;

  if(((QObject *) objectPtr)->objectName() == "HexEditor")
  {
    HexEdit * he = (HexEdit *) objectPtr;
    ret = he->saveFile(he->fileName());
  }
  else
  {
    TextEditor  * te = (TextEditor *) objectPtr;

    if(te->fileName().isEmpty())
      ret = saveAs("", objectPtr);
    else
    {
      QFile file(te->fileName());
      if(file.open(QFile::WriteOnly))
      {
        QTextStream out(&file);
        if(te->fileName().endsWith(".htm") || te->fileName().endsWith(".html"))
        {
          out.setCodec(QTextCodec::codecForName("UTF-8"));
          out << te->document()->toHtml("UTF-8");
          //out << te->htmlText();
        }
        else
          out << te->editText();
        te->markUnsaved(false);
        ret = true;
      }
    }
  }
  return ret;
}

void AppTextEditor::printDocument(TextEditor * te, int who)
{
  QDateTime dt = QDateTime::currentDateTime();

  QString headertext = 
    "<table width=\"100%\">"
    "  <tr>"
    "    <td align=\"left\"><strong>%1 - %2</strong></td>"
    "    <td align=\"right\"><strong>TextEditor</strong></td>"
    "  </tr>"
    "</table>";

  QString footertext = "<p align=\"right\"><strong>&page;</strong></p>";
  
  if(!te->isDocHtml() && who == 0)
  {
    int     line1, col1, line2, col2;
    te->getSelection(&line1, &col1, &line2, &col2);
    
    QsciPrinter prn;
    QPrintDialog dlg(&prn, te);
    if(dlg.exec() == QDialog::Accepted)
    {
      if(line1 >=0 && line2 >= 0 && col1 >= 0 && col2 >= 0)
      {
        //  We have selection. Print it.
        --line2;
        prn.printRange(te->textEdit, line1, line2);
      }
      else
        //  We don't have selection. Print the whole text.
        prn.printRange(te->textEdit, 0);
    }
    return;
  }
  TextPrinter * textprinter_ = new TextPrinter(this);

  textprinter_->setHeaderSize(10);
  textprinter_->setFooterSize(10);

  textprinter_->setHeaderText(headertext.arg(te->fileName()).arg(dt.toString()));
  textprinter_->setFooterText(footertext);
  switch(who)
  {
  case 0: textprinter_->print(te->document(), "TextEditor");
      break;
  case 1: {
        QFileInfo fi(te->fileName());
        QString base = fi.baseName();
        textprinter_->exportPdf(te->document(), "TextEditor", base + ".pdf");
      }
      break;
  case 2: textprinter_->preview(te->document(), "TextEditor");
      break;
  }
}

bool AppTextEditor::print(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor") return false;

  TextEditor  * te = (TextEditor *) objectPtr;
  printDocument(te);
  return true;
}
// Edit
void AppTextEditor::undo(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor") return;
  TextEditor  * te = (TextEditor *) objectPtr;
  te->undo();
}

void AppTextEditor::redo(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor") return;
  TextEditor  * te = (TextEditor *) objectPtr;
  te->redo();
}

void AppTextEditor::cut(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor") return;
  TextEditor  * te = (TextEditor *) objectPtr;
  te->cut();
}

void AppTextEditor::copy(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor") return;
  TextEditor  * te = (TextEditor *) objectPtr;
  te->copy();
}

void AppTextEditor::paste(void * objectPtr)
{
  if(((QObject *) objectPtr)->objectName() == "HexEditor") return;
  TextEditor  * te = (TextEditor *) objectPtr;
  te->paste();
}

// Control
bool AppTextEditor::close(void * objectPtr)
{
  bool  ret;
  if(((QObject *) objectPtr)->objectName() == "HexEditor")
  {
    HexEdit * he = (HexEdit *) objectPtr;
    if(he->close())
      mInt->removeApplication(he);
    ret = HexEdit::closeResult;
  }
  else
  {
    TextEditor  * te = (TextEditor *) objectPtr;
    if(te->close())
      mInt->removeApplication(te);
    ret = TextEditor::closeResult;
  }
  return ret;
}

void AppTextEditor::update(void * objectPtr)
{
}

void AppTextEditor::help(unsigned alias)
{
  switch(alias)
  {
  case 0: mInt->showContextHelp("TextEditor", "index.html");
      break;
  case 1: mInt->showContextHelp("RichTextEditor", "index.html");
      break;
  case 2: mInt->showContextHelp("HexEditor", "index.html");
      break;
  }
}

void AppTextEditor::script(void * sctx)
{

}

const void * AppTextEditor::asciiText(const void ** par)
{
  TextEditor * te = (TextEditor *) par[0];
  return (void *) te->asciiText();
}

const void * AppTextEditor::clearFilter(const void ** par)
{
  fileFilter.clear();
  return 0;
}

const void * AppTextEditor::setFileFilter(const void ** par)
{
  fileFilter << (const char *) par[0];
  return 0;
}

const void * AppTextEditor::setDirectory(const void ** par)
{
  directory = (const char *) par[0];
  return 0;
}

const void * AppTextEditor::setFileName(const void ** par)
{
  fileNamePath = (const char *) par[0];
  return 0;
}

const void * AppTextEditor::setAsciiText(const void ** par)
{
  TextEditor * te = (TextEditor *) par[0];
  if(te)
  {
    if(te->isDocHtml())
      te->edit->setHtml((const char *) par[1]);
    else
      te->textEdit->setText((const char *) par[1]);
  }
  return 0;
}

const void * AppTextEditor::setHighLighter(const void ** par)
{
  highLighterFile = (const char *) par[0];
  hlCode = (unsigned) par[1];
  return 0;
}

const void * AppTextEditor::setCallerId(const void ** par)
{
  unsigned id = (unsigned) par[0];
  TextEditor * te = (TextEditor *) par[1];
  if(mInt->checkAppPresence(id))
  {
    te->callerId = id;
    te->callerWid = te;
  }
  return 0;
}

const void * AppTextEditor::findText(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->findSlot();
  return 0;
}

const void * AppTextEditor::findNextText(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->findNextSlot();
  return 0;
}

const void * AppTextEditor::findPreviousText(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->findPrevSlot();
  return 0;
}

const void * AppTextEditor::replaceText(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->replaceSlot();
  return 0;
}

const void * AppTextEditor::exportAsPdf(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  printDocument(wd, 1);
  return 0;
}

const void * AppTextEditor::printPreview(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  printDocument(wd, 2);
  return 0;
}

const void * AppTextEditor::insertChar(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->edit->insertCharacterSlot();
  return 0;
}

const void * AppTextEditor::setTextBold(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->textBold(mInt->getToolButton("RichTextEditor.Main.Text Bold")->isChecked());
  return 0;
}

const void * AppTextEditor::setTextItalic(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->textItalic(mInt->getToolButton("RichTextEditor.Main.Text Italic")->isChecked());
  return 0;
}

const void * AppTextEditor::setTextUnderline(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->textUnderline(mInt->getToolButton("RichTextEditor.Main.Text Underline")->isChecked());
  return 0;
}

const void * AppTextEditor::setTextStrikeOut(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->textStrikeOut(mInt->getToolButton("RichTextEditor.Main.Text StrikeOut")->isChecked());
  return 0;
}

const void * AppTextEditor::setTextAlignLeft(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->edit->setAlignment(Qt::AlignLeft);
  return 0;
}

const void * AppTextEditor::setTextAlignRight(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->edit->setAlignment(Qt::AlignRight);
  return 0;
}

const void * AppTextEditor::setTextAlignCenter(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->edit->setAlignment(Qt::AlignCenter);
  return 0;
}

const void * AppTextEditor::setTextAlignJustify(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->edit->setAlignment(Qt::AlignJustify);
  return 0;
}

const void * AppTextEditor::setTextColor(const void ** par)
{
  QMdiArea * mdi = mInt->mdiArea();
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->setForegroundTextColor();
  return 0;
}

const void * AppTextEditor::setTextBackgroundColor(const void ** par)
{
  QMdiArea * mdi = mInt->mdiArea();
  TextEditor * wd = (TextEditor *) par[0];
  //if(wd->objectName() == QString(name()))
  wd->setBackgroundTextColor();
  return 0;
}

const void * AppTextEditor::textStyle(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->textStyle(wd->comboStyle->currentIndex());
  return 0;
}

const void * AppTextEditor::textSize(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->textSize(wd->comboSize->currentText());
  return 0;
}

const void * AppTextEditor::textFont(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->textFamily(wd->comboFont->currentText());
  return 0;
}

const void * AppTextEditor::addImage(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  QString fileimg = QFileDialog::getOpenFileName(mInt->mdiArea(), tr( "Choose Image" ), QString(mInt->settings()->value("TextEditor.LastDir").toString()), tr("Image Files (*.bmp *.gif *.jpeg *.jpg *.pbm *.pgm *.ppm *.png *.tif *.tiff *.xbm *.xpm)"));
  if(fileimg.isEmpty()) 
    return 0; 

  QImage base(fileimg);
  if(base.isNull()) 
  {
    QMessageBox::warning(mInt->mdiArea(), tr( "Image Plugin Error"), tr(
                          "Pleas install the plugin for this format.. or select other..\n"
                          "Or copy and paste image from your images application.\n"
                          "Accepted file formats: png jpg gif"));
    QDesktopServices::openUrl(QUrl(fileimg));
    return 0;
  }

  QString pathimage = fileimg.left(fileimg.lastIndexOf("/")) + "/";
  mInt->settings()->setValue("TextEditor.LastDir", pathimage);
  wd->imageInsert(fileimg, base.width(), base.height());
  return 0;
}

const void * AppTextEditor::textMargin(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->textMargin();
  return 0;
}

const void * AppTextEditor::makeLink(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->makeLink();
  return 0;
}

const void * AppTextEditor::bookmark(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->bookmark();
  return 0;
}

const void * AppTextEditor::gotoLine(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->gotoLine((int) par[1]);
  return 0;
}

const void * AppTextEditor::bookmarkList(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  return (void *) wd->bookmarkList((unsigned *) par[1], (unsigned) par[2]);
}

const void * AppTextEditor::selectAll(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->selectAllSlot();
  return 0; 
}

const void * AppTextEditor::setAutoreload(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->setAutoreload((bool) par[1]);
  return 0; 
}

const void * AppTextEditor::reload(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->reload();
  return 0; 
}

const void * AppTextEditor::addLineBar(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->lineBarInsert();
  return 0; 
}

const void * AppTextEditor::textVerticalAlignment(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->textVerticalAlignment((QTextCharFormat::VerticalAlignment) wd->comboVerAlign->currentIndex());
  return 0; 
}

const void * AppTextEditor::createTable(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->createTable();
  return 0; 
}

const void * AppTextEditor::sendHTML(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  ApplicationInterface * sendTo = mInt->applicationInterface((const char *) par[1]);
  if(sendTo)
  {
    // Param list: ApplicationInterface, "Method", class pointer, parameters list
    mInt->method(sendTo, (const char *) par[2], par[3], par[4], qPrintable(wd->htmlText()));
  }
  return 0; 
}

const void * AppTextEditor::sendText(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  ApplicationInterface * sendTo = mInt->applicationInterface((const char *) par[1]);
  if(sendTo)
  {
    // Param list: ApplicationInterface, "Method", class pointer, parameters list
    mInt->method(sendTo, (const char *) par[2], par[3], par[4], qPrintable(wd->editText()));
  }
  return 0; 
}

const void * AppTextEditor::setWindowTitle(const void ** par)
{
  TextEditor * wd = (TextEditor *) par[0];
  wd->setWindowTitle((const char *) par[1]);
  return 0; 
}

const void * AppTextEditor::setCallback(const void ** par)
{
  sendBack << AppComPar(QString(), par[0], par[1], par[2], par[3], par[4], par[5], par[6], par[7], par[8], par[9]);
  return 0; 
}

// Parameter syntax in senBack
// 0 - Local method
// 1 - ApplicationInterface receiver
// 2 - Method receiver
// 3 - Class receiver
// 4/9 Parameters for method receiver
bool AppTextEditor::execCalback(TextEditor * te)
{
  bool  ret = false;
  if(sendBack.size() == 0)
    return ret;
  ret = true;
  for(int i = 0; i < sendBack.size(); i++)
    mInt->method(this, sendBack[i].text(0), te, sendBack[i].voidPtr(1), sendBack[i].voidPtr(2), sendBack[i].voidPtr(3), sendBack[i].voidPtr(4),
           sendBack[i].voidPtr(5), sendBack[i].voidPtr(6), sendBack[i].voidPtr(7), sendBack[i].voidPtr(8), sendBack[i].voidPtr(9));
  sendBack.clear();
  return ret;
}

bool AppTextEditor::lookingForBrothers()
{
  QMdiArea * mdi = mInt->mdiArea();
  QList<QMdiSubWindow *> wl = mdi->subWindowList();
  for(int n = 0; n < wl.size(); n++)
  {
    QMdiSubWindow * sw = wl.at(n);
    QWidget * wd = sw->widget();
    if(wd)
    {
      if(wd->objectName() == QString(name()))
        return true;
    }
  }
  return false;
}

void AppTextEditor::setDefaultFileExtension(QString & ext)
{
        int                     i;
        QFileInfo       fi(ext);
        QString         fe = fi.completeSuffix().toLower();
        for(i = 0; i < fileFilter.size(); i++)
        {
                if(fileFilter[i].indexOf(QString("*.%1 ").arg(fe)) >= 0)
                {
                        prevFileFilter = fileFilter[i];
                        break;
                }
        }
        if(i == fileFilter.size())
                prevFileFilter.sprintf("??? - Unknown file format (*.%s )", fe.toLatin1().data());
        //mInt->log("prevFileFilter = %s\n", prevFileFilter.toLatin1().data()); // !!!
}

---