Changeset 441 for trunk/src

Timestamp:

Dec 26, 2009, 2:14:18 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: QPMMime: Adding more DND support code, fixing the build.

Location:

trunk/src/gui/kernel

Files:

• qmime.h (modified) (5 diffs)
• qmime_pm.cpp (modified) (41 diffs)

trunk/src/gui/kernel/qmime.h

@@ -115 +115 @@
 */
 
-typedef unsigned long ULONG;
+#if !defined(QT_NO_DRAGANDDROP)
+QT_END_NAMESPACE
+#include "private/qpmobjectwindow_pm_p.h"
+QT_BEGIN_NAMESPACE
+#endif
 
 class QPMCoopDragWorker;
@@ -125 +129 @@
 #if !defined(QT_NO_DRAGANDDROP)
 
+
+
     class DragWorker
     {
     public:
-        DragWorker() : data(0) {}
+        DragWorker() : (0) {}
         virtual ~DragWorker() {}
 
@@ -177 +183 @@
         {
         public:
-            virtual const char *format( const char *drf ) const = 0;
+            virtual const ) const = 0;
             virtual bool provide(const char *drf, const QByteArray &allData,
                                  ULONG itemIndex, QByteArray &itemData) = 0;
@@ -246 +252 @@
 
         static bool canRender(DRAGITEM *item, const char *drf );
-        static bool getSupportedRMFs(DRAGITEM *item, QPtrList<QStrList> &list);
+        static bool getSupportedRMFs(DRAGITEM *item, QList> &list);
 
     private:
@@ -297 +303 @@
     static QByteArray querySourceNameFull(DRAGITEM *item);
     static bool canTargetRenderAsOS2File(DRAGITEM *item, QByteArray *fullName = 0);
-    static bool parseRMFs(HSTR rmfs, QList<QList<QByteArray> > &list);
+    static bool parseRMFs(HSTR rmfs, QList<Q> &list);
     static bool parseRMF(HSTR rmf, QByteArray &mechanism, QByteArray &format);
 

trunk/src/gui/kernel/qmime_pm.cpp

@@ -63 +63 @@
 
 #ifdef QDND_DEBUG
+
 #   define DEBUG(a) qDebug a
 #else
@@ -72 +73 @@
 #if !defined(QT_NO_DRAGANDDROP)
 
-// @todo remove
-//#define DRT_URL "UniformResourceLocator"
-//
-//#define DRM_OS2FILE "DRM_OS2FILE"
-//#define DRM_SHAREDMEM "DRM_SHAREDMEM"
-//
-//#define DRF_UNKNOWN "DRF_UNKNOWN"
-//#define DRF_TEXT "DRF_TEXT"
-//#define DRF_POINTERDATA "DRF_POINTERDATA"
-//
-//#define MIME_TEXT_PLAIN "text/plain"
-//#define MIME_TEXT_PLAIN_CHARSET_SYSTEM "text/plain;charset=system"
-//#define MIME_TEXT_URI_LIST "text/uri-list"
+// Undoc'd DC_PREPAREITEM, see
+// http://lxr.mozilla.org/seamonkey/source/widget/src/os2/nsDragService.cpp
+#if !defined (DC_PREPAREITEM)
+#define DC_PREPAREITEM 0x40
+#endif
 
 /*! \internal
@@ -241 +234 @@
         ULONG index;
         Provider *provider;
-        QCString drm;
-        QCString drf;
+        Q drm;
+        Q drf;
         DRAGTRANSFER *xfer;
         bool rendered;
@@ -255 +248 @@
         DrfProvider() : prov(0) {}
         DrfProvider(const char *d, Provider *p) : drf(d), prov(p) {}
-        const QByteArray drf;
-        Provider * const prov;
+        QByteArray drf;
+        Provider *prov;
     };
 
@@ -378 +371 @@
     // (however, it doesn't help when dropping objects to it -- WPS still
     // chooses DRM_OS2FILE).
-    formats = "("DRM_SHAREDMEM","DRM_OS2FILE")x(" + formats + "),"
-              "<"DRM_SHAREDMEM","DRF_POINTERDATA">";
+    formats = "()x(" + formats + "),"
+              "<>";
 
     DEBUG(() << "DefaultDragWorker: formats" << formats
@@ -400 +393 @@
 
     DEBUG(() << "DefaultDragWorker: Preparing item" <<  itemIndex << "(id "
-             << item->ulItemID << ") for <" << drm << "," << drf ">");
+             << item->ulItemID << ") for <" << drm << "," << drf ">");
 
     Provider *p = d->providerFor(drf);
@@ -469 +462 @@
                  << "(id " << xfer->pditem->ulItemID << ")");
 
-        QCString drm, drf;
+        Q drm, drf;
         if (!parseRMF(xfer->hstrSelectedRMF, drm, drf))
             Q_ASSERT(/* parseRMF() = */ FALSE);
@@ -525 +518 @@
 
         bool renderOk = false;
-        QByteArray allData =
-            source()->encodedData(req->provider->format(req->drf));
+
+        ata(req->provider->format(req->drf));
         QByteArray itemData;
 
@@ -534 +527 @@
         if (renderOk) {
             enum DRM { OS2File, SharedMem } drmType;
-            if (qstrcmp(req->drm, DRM_SHAREDMEM) == 0) drmType = SharedMem;
+            if (qstrcmp(req->drm, ) == 0) drmType = SharedMem;
             else drmType = OS2File;
 
             if (drmType == OS2File) {
-                QCString renderToName = queryHSTR(req->xfer->hstrRenderToName);
+                Q renderToName = queryHSTR(req->xfer->hstrRenderToName);
                 Q_ASSERT(!renderToName.isEmpty());
                 renderOk = !renderToName.isEmpty();
@@ -544 +537 @@
                     DEBUG(() << "DefaultDragWorker: Will write to" << renderToName);
                     QFile file(QFile::decodeName(renderToName));
-                    renderOk = file.open(IO_WriteOnly);
+                    renderOk = file.open(WriteOnly);
                     if (renderOk) {
-                        Q_LONG written =
-                            file.writeBlock(itemData.data(), itemData.size());
-                        renderOk = written == (Q_LONG) itemData.size() &&
-                                   file.status() == IO_Ok;
+                        qint64 written = file.write(itemData, itemData.size());
+                        renderOk = written == itemData.size();
                         file.close();
                         if (renderOk && req->xfer->pditem->hstrType) {
@@ -626 +617 @@
             DEBUG(("DefaultDragWorker: Freed DRAGTRANSFER: "
                    "req->xfer %p size %lu (0x%08lX) flags 0x%08lX",
-                   req->xfer, size, size, flags);
+                   req->xfer, size, size, flags);
         }
 #endif
@@ -686 +677 @@
             // first provider
             d->itemCnt = itemCnt;
-            d->providers.insert(Data::DrfProvider(drf, provider));
+            d->providers.(Data::DrfProvider(drf, provider));
             return true;
         }
@@ -693 +684 @@
             // ensure there are no dups (several providers for the same drf)
             if (!d->providerFor(drf))
-                d->providers.insert(Data::DrfProvider(drf, provider));
+                d->providers.(Data::DrfProvider(drf, provider));
             return true;
         }
@@ -703 +694 @@
 bool QPMMime::DefaultDragWorker::canRender(const char *drm)
 {
-    return qstrcmp(drm, DRM_SHAREDMEM) == 0 ||
-           qstrcmp(drm, DRM_OS2FILE) == 0;
+    return qstrcmp(drm, ) == 0 ||
+           qstrcmp(drm, ) == 0;
 }
 
@@ -715 +706 @@
         MimeProvider() : prov(NULL) {}
         MimeProvider(const QString &m, Provider *p) : mime(m), prov(p) {}
-        const QString mime;
-        Provider * const prov;
+        QString mime;
+        Provider *prov;
     };
 
@@ -736 +727 @@
     bool got_DM_RENDERCOMPLETE : 1;
     USHORT flags_DM_RENDERCOMPLETE;
-    int waiting_DM_RENDERCOMPLETE;
+
+    QEventLoop eventLoop;
 };
 
@@ -744 +736 @@
     d->sending_DM_RENDER = d->got_DM_RENDERCOMPLETE = false;
     d->flags_DM_RENDERCOMPLETE = 0;
-    d->waiting_DM_RENDERCOMPLETE = 0;
 }
 
@@ -754 +745 @@
 void QPMMime::DefaultDropWorker::cleanup(bool isAccepted, bool isActAccepted)
 {
-    if (d->waiting_DM_RENDERCOMPLETE != 0) {
+    if (d->) {
 #ifndef QT_NO_DEBUG
         qWarning("The previous drag source didn't post DM_RENDERCOMPLETE!\n"
                  "Contact the drag source developer.");
 #endif
-        qApp->eventLoop()->exitLoop();
+        );
     }
 
@@ -766 +757 @@
     d->sending_DM_RENDER = d->got_DM_RENDERCOMPLETE = false;
     d->flags_DM_RENDERCOMPLETE = 0;
-    d->waiting_DM_RENDERCOMPLETE = 0;
 }
 
@@ -774 +764 @@
 }
 
-bool QPMMime::DefaultDropWorker::provides(const char *format) const
-{
-    return d->providerFor(format) != NULL;
-}
-
-int QPMMime::DefaultDropWorker::formatCount() const
-{
-    return d->providers.count();
-}
-
-const char *QPMMime::DefaultDropWorker::format(int fn) const
-{
-    if (fn >= 0 && (uint) fn < d->providers.count())
-        return d->providers[ fn ].mime;
-    return NULL;
-}
-
-static QCString composeTempFileName()
-{
-    static char defTmpDir[ 3 ] = { 0 };
-    const char *tmpDir = getenv("TEMP");
-    if (!tmpDir) tmpDir = getenv("TMP");
-    if (!tmpDir || !QFile::exists(QFile::decodeName(tmpDir))) {
-        if (!defTmpDir[ 0 ]) {
-            ULONG bootDrive = 0;
-            DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
-                            &bootDrive, sizeof (bootDrive));
-            defTmpDir[ 0 ] = bootDrive;
-            defTmpDir[ 1 ] = ':';
-        }
-        tmpDir = defTmpDir;
-    }
+bool QPMMime::DefaultDropWorker::hasFormat(const QString &mimeType) const
+{
+    return d->providerFor(mimeType) != NULL;
+}
+
+// @todo
+//int QPMMime::DefaultDropWorker::formatCount() const
+//{
+//    return d->providers.count();
+//}
+
+QStringList QPMMime::DefaultDropWorker::formats() const
+{
+    QStringList mimes;
+    foreach(const Data::MimeProvider &p, d->providers)
+        mimes << p.mime;
+    return mimes;
+}
+
+static QByteArray composeTempFileName()
+{
+    QByteArray tmpDir =
+        QFile::encodeName(QDir::toNativeSeparators(QDir::tempPath()));
 
     static bool srandDone = false;
@@ -817 +798 @@
     int attempts = Attempts;
 
-    QCString tmpName;
+    QString tmpName;
     do {
-        tmpName.sprintf("%s\\%08lX.tmp", tmpDir, num);
-        if (!QFile::exists(QFile::decodeName(tmpName)))
+        tmpName.sprintf("%s\\%08lX.tmp", tmpDir, num);
+        if (!QFile::exists())
             break;
         num = rand();
@@ -827 +808 @@
     Q_ASSERT(attempts > 0);
     if (attempts <= 0)
-        tmpName.resize(0);
-
-    return tmpName;
-}
-
-QByteArray QPMMime::DefaultDropWorker::encodedData(const char *format) const
-{
-    DEBUG("DefaultDropWorker::encodedData(" << format << ")");
-
-    QByteArray data;
+        tmpName.clear();
+
+    return QFile::encodeName(tmpName);
+}
+
+QVariant QPMMime::DefaultDropWorker::retrieveData(const QString &mimeType,
+                                                  QVariant::Type type) const
+{
+    Q_UNUSED(type);
+
+    DEBUG(() << "DefaultDropWorker::retrieveData(" << mimeType << ")");
+
+    QVariant ret;
 
     Q_ASSERT(info());
     if (!info())
-        return data;
+        return ;
 
     ULONG itemCount = DrgQueryDragitemCount(info());
     Q_ASSERT(itemCount);
     if (!itemCount)
-        return data;
-
-    Provider *provider = d->providerFor(format);
+        return ;
+
+    Provider *provider = d->providerFor();
     if (!provider)
-        return data;
-
-    const char *drf = provider->drf(format);
+        return ;
+
+    const char *drf = provider->drf();
     Q_ASSERT(drf);
     if (!drf)
-        return data;
+        return ;
 
     // Note: Allocating and freeing DRAGTRANSFER structures is a real mess. It's
@@ -868 +852 @@
     // always allocate a new struct per every item. It seems to work.
 
-    QCString renderToName = composeTempFileName();
+    Q renderToName = composeTempFileName();
     HSTR hstrRenderToName = DrgAddStrHandle(renderToName);
 
     HSTR rmfOS2File =
-        DrgAddStrHandle(QCString().sprintf("<"DRM_OS2FILE",%s>", drf));
+        DrgAddStrHandle(Q));
     HSTR rmfSharedMem =
-        DrgAddStrHandle(QCString().sprintf("<"DRM_SHAREDMEM",%s>", drf));
+        DrgAddStrHandle(Q));
 
     MRESULT mrc;
@@ -880 +864 @@
 
     DRAGTRANSFER *xfer = NULL;
-    QCString srcFileName;
+    Q srcFileName;
 
     QByteArray allData, itemData;
@@ -897 +881 @@
         // determine the mechanism to use (prefer DRM_SHAREDMEM)
 
-        if (DrgVerifyRMF(item, DRM_SHAREDMEM, drf) &&
-             DrgVerifyRMF(item, DRM_SHAREDMEM, DRF_POINTERDATA))
+        if (DrgVerifyRMF(item, , drf) &&
+             DrgVerifyRMF(item, ))
             drm = SharedMem;
-        if (DrgVerifyRMF(item, DRM_OS2FILE, drf)) {
+        if (DrgVerifyRMF(item, , drf)) {
             srcFileName = querySourceNameFull(item);
             // If the source provides the full file name, we prefer DRM_OS2FILE
@@ -950 +934 @@
 
             mrc = (MRESULT)TRUE;
-            if ((item->fsControl & DC_PREPARE) |
-                 (item->fsControl & DC_PREPAREITEM)) {
+            if ((item->fsControl & DC_PREPARE) |
+                (item->fsControl & DC_PREPAREITEM)) {
                 DEBUG(("DefaultDropWorker: Sending DM_RENDERPREPARE to 0x%08lX...",
                        info()->hwndSource));
@@ -957 +941 @@
                                          MPFROMP (xfer), 0);
                 DEBUG(("DefaultDropWorker: Finisned sending DM_RENDERPREPARE\n"
-                       " mrc %p xfer->fsReply 0x%08hX", mrc, xfer->fsReply);
+                       " mrc %p xfer->fsReply 0x%08hX", mrc, xfer->fsReply);
                 renderOk = (BOOL) mrc;
             }
@@ -979 +963 @@
                 } else {
                     // synchronously wait for DM_RENDERCOMPLETE
-                    d->waiting_DM_RENDERCOMPLETE = qApp->loopLevel() + 1;
                     DEBUG(() << "DefaultDropWorker: Waiting for DM_RENDERCOMPLETE...");
-                    int level = qApp->eventLoop()->enterLoop();
+                    int ();
                     DEBUG(("DefaultDropWorker: Finished waiting for "
-                           "DM_RENDERCOMPLETE (%d)\n"
+                           "DM_RENDERCOMPLETE (%d)\n"
                            " got_DM_RENDERCOMPLETE %d usFS 0x%hX",
-                           level, d->got_DM_RENDERCOMPLETE, d->flags_DM_RENDERCOMPLETE));
-                    Q_UNUSED(level);
+                           , d->got_DM_RENDERCOMPLETE, d->flags_DM_RENDERCOMPLETE));
+                    Q_UNUSED();
                     // JFTR: at this point, cleanup() might have been called,
                     // as a result of either program exit or getting another
@@ -992 +975 @@
                     // DM_RENDERCOMPLETE from the source. Use data members with
                     // care!
-                    d->waiting_DM_RENDERCOMPLETE = 0;
                     renderOk = d->got_DM_RENDERCOMPLETE &&
                                (d->flags_DM_RENDERCOMPLETE & DMFL_RENDEROK);
@@ -1000 +982 @@
             }
         } else {
-            DEBUG(() << "DefaultDropWorker: Source supports <" << DRM_OS2FILE
-                     << "," << drf << "> and provides a file" << srcFileName
+            DEBUG(() << "DefaultDropWorker: Source supports <
+                     << drf << "> and provides a file" << srcFileName
                      << "for item" << item << "(no need to render)");
             renderOk = true;
@@ -1010 +992 @@
                 DEBUG(() << "DefaultDragWorker: Will read from" << srcFileName);
                 QFile file(QFile::decodeName(srcFileName));
-                renderOk = file.open(IO_ReadOnly);
+                renderOk = file.open(ReadOnly);
                 if (renderOk) {
                     itemData = file.readAll();
-                    renderOk = file.status() == IO_Ok;
+                    renderOk = file.;
                     file.close();
                 }
@@ -1030 +1012 @@
                         DEBUG(("DefaultDropWorker: Got shared data %p size %lu "
                                "(0x%08lX) flags 0x%08lX", ptr, size, size, flags));
-                        Q_ASSERT(flags & (PAG_COMMIT | PAG_READ | PAG_BASE) ==
+                        Q_ASSERT() ==
                                  (PAG_COMMIT | PAG_READ | PAG_BASE));
-                        renderOk = flags & (PAG_COMMIT | PAG_READ | PAG_BASE) ==
+                        renderOk = ) ==
                                    (PAG_COMMIT | PAG_READ | PAG_BASE);
 #ifndef QT_NO_DEBUG
@@ -1046 +1028 @@
                         if (renderOk) {
                             itemData.resize(realSize);
-                            memcpy(itemData.data(), ptr + sizeof (ULONG), realSize);
+                            memcpy(itemData.data(), ptr + sizeof(ULONG), realSize);
                         }
                     }
@@ -1058 +1040 @@
 
         if (renderOk)
-            renderOk = provider->provide(format, i, itemData, allData);
+            renderOk = provider->provide(, i, itemData, allData);
 
         if (needToTalk) {
@@ -1086 +1068 @@
 
     if (renderOk)
-        data = allData;
-
-    return data;
+         = allData;
+
+    return ;
 }
 
@@ -1100 +1082 @@
                 return (MRESULT)FALSE;
 
-            DEBUG("DefaultDropWorker: Got DM_RENDERCOMPLETE");
+            DEBUG();
             d->got_DM_RENDERCOMPLETE = true;
             d->flags_DM_RENDERCOMPLETE = SHORT1FROMMP(mp2);
@@ -1117 +1099 @@
 
             // stop synchronous waiting for DM_RENDERCOMPLETE
-            if (d->waiting_DM_RENDERCOMPLETE != 0)
-                qApp->eventLoop()->exitLoop();
+            if (d->)
+                ();
             return (MRESULT)FALSE;
         }
@@ -1128 +1110 @@
 }
 
-bool QPMMime::DefaultDropWorker::addProvider(const char *format,
+bool QPMMime::DefaultDropWorker::addProvider(const ,
                                              Provider *provider)
 {
-    Q_ASSERT(format && provider);
-    if (format && provider && !d->exclusive) {
+    Q_ASSERT( && provider);
+    if ( && provider && !d->exclusive) {
         // ensure there are no dups (several providers for the same mime)
-        if (!d->providerFor(format))
-            d->providers.insert(Data::MimeProvider(format, provider));
+        if (!d->providerFor())
+            d->providers., provider));
         return true;
     }
@@ -1141 +1123 @@
 }
 
-bool QPMMime::DefaultDropWorker::addExclusiveProvider(const char *format,
+bool QPMMime::DefaultDropWorker::addExclusiveProvider(const ,
                                                       Provider *provider)
 {
-    Q_ASSERT(format && provider);
-    if (format && provider && !d->exclusive) {
+    Q_ASSERT( && provider);
+    if ( && provider && !d->exclusive) {
         d->exclusive = true;
         d->providers.clear();
-        d->providers.insert(Data::MimeProvider(format, provider));
+        d->providers., provider));
         return true;
     }
@@ -1157 +1139 @@
 bool QPMMime::DefaultDropWorker::canRender(DRAGITEM *item, const char *drf)
 {
-    return DrgVerifyRMF(item, DRM_OS2FILE, drf) ||
-           (DrgVerifyRMF(item, DRM_SHAREDMEM, drf) &&
-            DrgVerifyRMF(item, DRM_SHAREDMEM, DRF_POINTERDATA));
-}
-
+    return DrgVerifyRMF(item, "DRM_OS2FILE", drf) ||
+           (DrgVerifyRMF(item, "DRM_SHAREDMEM", drf) &&
+            DrgVerifyRMF(item, "DRM_SHAREDMEM", "DRF_POINTERDATA"));
+}
+
+/*! \internal
+
+    Parses the rendering mechanism/format specification of the given \a item
+    and stores only those mechanism branches in the given \a list that represent
+    mechanisms supported by this worker. Returns false if fails to parse the
+    RMF specification. Note that if no supported mechanisms are found, true is
+    returned but the \a list will simply contain zero items.
+
+    \note The method clears the given \a list variable before proceeding.
+
+    \sa canRender(), PMMime::parseRMFs()
+*/
 // static
-/*! \internal
-  Parses the rendering mechanism/format specification of the given \a item
-  and stores only those mechanism branches in the given \a list that represent
-  mechanisms supported by this worker. Returns false if fails to parse the
-  RMF specification. Note that if no supported mechanisms are found, true is
-  returned but the \a list will simply contain zero items.
-  \note The method clears the given \a list variable before proceeding and sets
-  auto-deletion to true.
-  \sa canRender(), PMMime::parseRMFs()
-*/
 bool QPMMime::DefaultDropWorker::getSupportedRMFs(DRAGITEM *item,
-                                                  QPtrList<QStrList> &list)
+                                                  QList> &list)
 {
     if (!parseRMFs(item->hstrRMF, list))
         return false;
 
-    for (QStrList *mech = list.first(); mech;) {
-        const char *drm = mech->first();
-        if (qstrcmp(drm, DRM_OS2FILE) == 0) {
-            mech = list.next();
+    for (QList<QByteArrayList>::iterator rmf = list.begin(); rmf != list.end();) {
+        QByteArrayList::iterator mf = rmf->begin();
+        Q_ASSERT(mf != rmf->end());
+        const char *drm = *mf;
+        if (qstrcmp(drm, "DRM_OS2FILE") == 0) {
+            ++rmf;
             continue;
         }
-        if (qstrcmp(drm, DRM_SHAREDMEM) == 0) {
-            const char *drf = mech->next();
+        if (qstrcmp(drm, "DRM_SHAREDMEM") == 0) {
             // accept DRM_SHAREDMEM only if there is DRF_POINTERDATA
-            for(; drf; drf = mech->next()) {
-                if (qstrcmp(drf, DRF_POINTERDATA) == 0)
+            for(; mf != rmf->end(); ++mf) {
+                const char *drf = *mf;
+                if (qstrcmp(drf, "DRF_POINTERDATA") == 0)
                     break;
             }
-            if (drf) {
-                mech = list.next();
+            if () {
+                ;
                 continue;
             }
         }
         // remove the unsupported mechanism branch from the list
-        bool wasLast = list.getLast() == mech;
-        list.removeRef(mech);
-        // after deleting the last item, the current one will be set to the new
-        // last item which was already analyzed earlier, so set to 0 to stop
-        mech = wasLast ? 0 : list.current();
+        rmf = list.erase(rmf);
     }
 
@@ -1518 +1500 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 ////////////////////////////////////////////////////////////////////////////////