Assigning a file type to an Application on Windows

From Qt Wiki
Jump to: navigation, search

En Ar Bg De El Es Fa Fi Fr Hi Hu It Ja Kn Ko Ms Nl Pl Pt Ru Sq Th Tr Uk Zh

Background / technical stuff

File types in windows are defined in the Windows registry. First there is the entry of "<extension>" in HKCR which contains the file type name. In HKCRamp;lt;file type name> the different actions are defined.

This means, there is a file extension gidoc, whose files are called "MDI Text Editor Document". These documents should be opened in an application, which is located here: E:.exe. The file itself should be a parameter.

Using this pattern, each double click on a file opens a new Process which gets the file as parameter. This is fine for SDI (Single Document Interface) applications.

Example below:

HKEY_CLASSES_ROOT
 idoc
 "Default"="GiMdi.Document"
 "NullFile"=""

.Document
 "Default"="MDI Text Editor Document"
 ]
 "Default"="E:.exe,0"
 "Default"="E:.exe %1"

For MDI (Multi Document Interfaces), it should be opened in the existing Process. To achieve this, windows uses the old DDE mechanism. There must be some additional entries to achieve this:

HKEY_CLASSES_ROOT
 .Document
 "Default"="[open(quot;%1quot;)]"
 ]
 "Default"="SimpleCryptIoDevided"
 "Default"="system"

If this is also added, Windows starts the process, which is given in command and then sends a WM_DDE_INITIATE broadcast message to windows. The application must react on this, then handle WM_DDE_EXECUTE messages and, if requested, WM_DDE_TERMINATE message. If the reaction on the DDE messages is not correc, Windows displays some error messages.

How to do it

Normally, your application registers the file types (changes the registry) during startup. If the DDE Mdi stuff should be used, it then has to create some ATOMS (::GlobalAddAtom). Then it starts up the rest and waits fo user input.

If the file type is registered, and no dde is set, the application is started with the file path as parameter.

If ddeexec keys are set in the registry, the application is started and the the DDE messages are send. While handling these messages, WM_DDE_ACK messages are send back to the caller and the messages must be handled.

This behaviour and the code would always look the same, only the registration keys and the handling of the DDE commands differ from application to application. There fore I created a class, that does all this and can be used as base class instead of QMainWindow: DocumentWindow.

Use the DocumentWindow class

If you want to create an (MDI) editor application, you can derive your main window class from DocumentWindow instead of QMainWindow. If you implement an MDI application, you should also reimplement the virtual method
ddeOpenFile
.

The example code is based on the Qt MDI Example

class MainWindow : public DocumentWindow
{

protected:
 virtual void ddeOpenFile(const QString& filePath);
}

all other things that need to be done is extending your constructor

MainWindow::MainWindow(QWidget* parent, Qt::WindowFlags flags) :
 DocumentWindow(parent, flags)
{
 
 registerFileType("GiMdi.Document", // Document type name
 "MDI Text Editor Document",// User readable file type name
 ".gidoc", // file extension
 0, // index of the icon to use for the files.
 true); // register for DDE events
 enableShellOpen();
 
}

and reimplement ddeFileOpen

void MainWindow::ddeOpenFile(const QString& filePath)
{
 MdiChild '''child = createMdiChild();
 if (child->loadFile(filePath))
 {
 statusBar()->showMessage(tr("File loaded"), 2000);
 child->show();
 }
 else
 {
 child->close();
 }
}

That's it. Now it should work to just start the application, and the file type ".gidoc" is registered with your application. If you double click on it in the Windows explorer, it should be opened in the currently running Process or, if no instance of your application is running, start a new one. If your application has a windows icon in the resource (not in the qrc file! a windows resource file <file>.rc), this icon should be used for the files.

Use the DocumentWindow sources

DocumentWindow.h

// ————————————————————————————————-
/**
 * @file
 * @brief
 * @author Gerolf Reinwardt
 * @date 30. march 2011
 *
 * Copyright © 2011, Gerolf Reinwardt. All rights reserved.
 *
 * Simplified BSD License
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are those of the
 * authors and should not be interpreted as representing official policies, either expressed
 * or implied, of Gerolf Reinwardt.
 */
// ————————————————————————————————-

#ifndef WIDGET_H
#define WIDGET_H

// —— general includes —————————————————————————
#include <windows.h>
#include <QMainWindow>

// —— local includes —————————————————————————-
// —— pre defines ——————————————————————————-

// —— class definition —————————————————————————
/**
 * @short This class implements a main window with the ability to register file types on MS Windows and
 * react on the corresponding DDE events to open / print the files in an Windows MDI typical manner.
 *
 * The usage is fairly easy. Derive your own MainWindow class from DocumentWindow instead of QMainWindow.
 * Inside your constructor, call registerFileType and enableShellOpen. The axample is build on top of the
 * Qt MDI Example (http://doc.qt.nokia.com/4.7/mainwindows-mdi.html)
 *
 * @code
 MainWindow::MainWindow(QWidget* parent, Qt::WindowFlags flags) :
 DocumentWindow(parent, flags)
 {


registerFileType("GiMdi.Document", "MDI Text Editor Document", ".gidoc", 0, true);
 enableShellOpen();

setWindowTitle(tr("MDI"));
 setUnifiedTitleAndToolBarOnMac(true);
 }
 
 *
 * Aditionally, the actions must be performed by overwriting one or more of:
 * @li ddeOpenFile
 * @li ddeNewFile
 * @li ddePrintFile
 * @li executeUnknownDdeCommand
 *
 * 

 void MainWindow::ddeOpenFile(const QString& filePath)
 {
 MdiChild *child = createMdiChild();
 if (child->loadFile(filePath))
 {
 statusBar()->showMessage(tr("File loaded"), 2000);
 child->show();
 }
 else
 {
 child->close();
 }
 }

*
 */
class DocumentWindow : public QMainWindow
{
 Q_OBJECT
public:
 // —— enums ———————————————————————————
 /**
 * Known DDE command. These commands are typically used
 */
 enum DdeCommand {
 DDEOpen = 0x0001, /< open a file via explorer*/
 DDENew = 0x0002, /**< create a new file via explorer*/
 DDEPrint = 0x0004, /**< print a file via explorer*/
 };
 Q_DECLARE_FLAGS(DdeCommands, DdeCommand)

// —— construction —————————————————————————
 /**
 * Constructor.
 *
 * Creates a DocumentWindow with a given @arg parent and @arg flags.
 */
 explicit DocumentWindow(QWidget* parent = 0, Qt::WindowFlags flags = 0);

/**
 * Destructor
 */
 ~DocumentWindow();

 // —— operators ——————————————————————————
 // —— methods ——————————————————————————-
 // —— accessors ——————————————————————————
 // —— members ——————————————————————————-

protected:
 // —— events ———————————————————————————
 /**
 * reimpl as DDE events come as windows events and are not translated by Qt.
 */
 virtual bool winEvent(MSG *message, long *result);

 // —— helpers for the file registration ——————————————————
 /**
 * virtual function that must be implemented by the derived class to react to the open command
 * from Windows.
 *
 * @param filePath file that was selected in the explorer
 */
 virtual void ddeOpenFile(const QString& filePath);

 /**
 * virtual function that must be implemented by the derived class to react to the new command
 * from Windows.
 *
 * @param filePath file that was selected in the explorer
 */
 virtual void ddeNewFile(const QString& filePath);

 /**
 * virtual function that must be implemented by the derived class to react to the print command
 * from Windows.
 *
 * @param filePath file that was selected in the explorer
 */
 virtual void ddePrintFile(const QString& filePath);

 /**
 * virtual function that must be implemented by get custom dde commands from the explorer. If, e.g.
 * a printo or copy command should be available in explorer and they are registered via registerCommand,
 * this function is called.
 *
 * @param command name of the command
 * @param params parameter string, containing the hole stuff, also " and commas.
 *
 * @note a command like this [compare("%1")] will result in the parameters:
 command = "compare";
 params = "quot;<filepath>quot;";
 */
 virtual void executeUnknownDdeCommand(const QString& command, const QString& params);

 /**
 * Call this method to register the file type in Windows. It creates the default command
 * which means the app is started with the file to open as parameter. If @arg registerForDDE
 * is true, the dde events are also created so the opening of a file is done in typical MDI
 * behavior (all files open in the same app).
 *
 * @param documentId id of the document, typically <Application>.Document —> see in registry, e.g. "GiMdi.Document"
 * @param fileTypeName free name of the file type, e.g. "MDI Text Editor Document"
 * @param fileExtension File extension, including the dot (e.g. ".gidoc")
 * @param appIconIndex index of the app icon to use for the file in the windows explorer, typically the application icon
 * @param registerForDDE true if DDE should be used (typical for MDI apps), typically false for SDI apps.
 * @param commands a combination of the commands to install.
 *
 * @note If more then the default commands are needed, then subsequent calls of registerCommand are needed.
 *
 * @note DDEOpen leads to the DDE command: [open("%1)]
 DDENew leads to the DDE command: [new("%1)]
 DDEPrint leads to the DDE command: [print("%1)]
 */
 void registerFileType(const QString& documentId,
 const QString& fileTypeName,
 const QString& fileExtension,
 qint32 appIconIndex = 0,
 bool registerForDDE = false,
 DdeCommands commands = DDEOpen);

 /**
 * registeres one command for a given file type. It is called for the pre defined DDE command
 * types from registerFileType. if more then the normal commands are needed, it can be called
 * in addition to registerFileType.
 *
 * @code
 MainWindow::MainWindow(QWidget* parent, Qt::WindowFlags flags) :
 DocumentWindow(parent, flags)
 {


registerFileType("GiMdi.Document", "MDI Text Editor Document", ".gidoc", 0, true);
 registerCommand("fancyCommand", "GiMdi.Document", "-fancy %1", "[fancy(quot;%1quot;)]");
 enableShellOpen();


 }
 @endcode
 */
 void registerCommand(const QString& command,
 const QString& documentId,
 const QString cmdLineArg = QString::null,
 const QString ddeCommand = QString::null);

 /**
 * Call this method to enable the user to open data files associated with your application
 * by double-clicking the files in the windows file manager.
 *
 * Use it together with registerFileType to register the fspezified file types or provida a
 * registry file (*.reg) which does this.
*/
 void enableShellOpen();


private:
 // —— privat helpers ————————————————————————
 /**
 * implementation of the WM_DDE_INITIATE windows message
 */
 bool ddeInitiate(MSG* message, long* result);

 /**
 * implementation of the WM_DDE_EXECUTE windows message
 */
 bool ddeExecute(MSG* message, long* result);

 /**
 * implementation of the WM_DDE_TERMINATE windows message
 */
 bool ddeTerminate(MSG* message, long* result);

 /**
 * Sets specified value in the registry under HKCU\Software\Classes, which is mapped to HKCR then.
 */
 bool SetHkcrUserRegKey(QString key, const QString& value, const QString& valueName = QString::null);

 /**
 * this method is called to do the DDE command handling. It does argument splitting and then calls
 * ddeOpenFile, ddeNewFile, ddePrintFile or executeUnknownDdeCommand.
 */
 void executeDdeCommand(const QString& command, const QString& params);

 // —— members ——————————————————————————-
 bool m_registerForDDE; /< used to identfy, if the dde commands should be written to the registry*/
 QString m_appAtomName; /**< the name of the application, without file extension*/
 QString m_systemTopicAtomName; /**< the name of the system topic atom, typically "System"*/
 ATOM m_appAtom; /**< The windows atom needed for DDE communication*/
 ATOM m_systemTopicAtom; /**< The windows system topic atom needed for DDE communication*/
 // —— not allowed members ——————————————————————-
};

Q_DECLARE_OPERATORS_FOR_FLAGS(DocumentWindow::DdeCommands)

#endif // WIDGET_H

DocumentWindow.cpp

// ————————————————————————————————-
/**
 * @file
 * @brief
 * @author Gerolf Reinwardt
 * @date 30.01.2011
 *
 * Copyright © 2011, Gerolf Reinwardt. All rights reserved.
 *
 * Simplified BSD License
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this list of
 * conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
 * of conditions and the following disclaimer in the documentation and/or other materials
 * provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are those of the
 * authors and should not be interpreted as representing official policies, either expressed
 * or implied, of Gerolf Reinwardt.
 */
// ————————————————————————————————-

// —— general includes —————————————————————————
#include <windows.h>
#include <QMessageBox>
#include <QApplication>
#include <QDir>
#include <QFileInfo>
#include <QRegExp>

// —— local includes —————————————————————————-
#include "documentwindow.h"


// —— construction ——————————————————————————
DocumentWindow::DocumentWindow(QWidget''' parent, Qt::WindowFlags flags) :
 QMainWindow(parent, flags),
 m_registerForDDE(false),
 m_appAtomName(),
 m_systemTopicAtomName("system"),
 m_appAtom(0),
 m_systemTopicAtom(0)
{
 QFileInfo fi(qApp->applicationFilePath());
 m_appAtomName = fi.baseName();
}

DocumentWindow::~DocumentWindow()
{
 if(0 != m_appAtom)
 {
 ::GlobalDeleteAtom(m_appAtom);
 m_appAtom = 0;
 }
 if(0 != m_systemTopicAtom)
 {
 ::GlobalDeleteAtom(m_systemTopicAtom);
 m_systemTopicAtom = 0;
 }
}

// —— operators ———————————————————————————
// —— methods ————————————————————————————
// —— accessors ———————————————————————————
// —— public slots ——————————————————————————
// —— protected slots —————————————————————————
// —— events ————————————————————————————
bool DocumentWindow::winEvent(MSG *message, long '''result)
{
 switch(message->message)
 {
 case WM_DDE_INITIATE:
 return ddeInitiate(message, result);
 break;
 case WM_DDE_EXECUTE:
 return ddeExecute(message, result);
 break;
 case WM_DDE_TERMINATE:
 return ddeTerminate(message, result);
 break;
 }

 return QMainWindow::winEvent(message, result);
}

void DocumentWindow::ddeOpenFile(const QString&)
{
 // this method will be overwritten, if the application uses the dde open command
}

void DocumentWindow::ddeNewFile(const QString&)
{
 // this method will be overwritten, if the application uses the dde new command
}

void DocumentWindow::ddePrintFile(const QString&)
{
 // this method will be overwritten, if the application uses the dde print command
}

void DocumentWindow::executeUnknownDdeCommand(const QString&, const QString&)
{
 // this method will be overwritten, if the application uses other commands,
 // then open, new and print via DDE and Explorer
}

void DocumentWindow::registerFileType(const QString& documentId,
 const QString& fileTypeName,
 const QString& fileExtension,
 qint32 appIconIndex,
 bool registerForDDE,
 DdeCommands commands)
{
 // first register the type ID of our server
 if (!SetHkcrUserRegKey(documentId, fileTypeName))
 return;

 if (!SetHkcrUserRegKey(QString("%1DefaultIcon").arg(documentId),
 QString("quot;%1quot;,%2").arg(QDir::toNativeSeparators(qApp->applicationFilePath())).arg(appIconIndex)))
 return;

 m_registerForDDE = registerForDDE;

 if(commands & DDEOpen)
 registerCommand("Open", documentId, "quot;%1quot;", "[open(quot;%1quot;)]");
 if(commands & DDENew)
 registerCommand("New", documentId, "-new quot;%1quot;", "[new(quot;%1quot;)]");
 if(commands & DDEPrint)
 registerCommand("Print", documentId, "-print quot;%1quot;", "[print(quot;%1quot;)]");

 LONG lSize = _MAX_PATH * 2;
 wchar_t szTempBuffer[_MAX_PATH * 2];
 LONG lResult = ::RegQueryValue(HKEY_CLASSES_ROOT,
 (const wchar_t*)fileExtension.utf16(),
 szTempBuffer,
 &lSize);

 QString temp = QString::fromUtf16((unsigned short*)szTempBuffer);

 if (lResult != ERROR_SUCCESS || temp.isEmpty() || temp == documentId)
 {
 // no association for that suffix
 if (!SetHkcrUserRegKey(fileExtension, documentId))
 return;

 SetHkcrUserRegKey(QString("%1ShellNew").arg(fileExtension), QLatin1String(""), QLatin1String("NullFile"));
 }
}

void DocumentWindow::registerCommand(const QString& command,
 const QString& documentId,
 const QString cmdLineArg,
 const QString ddeCommand)
{
 QString commandLine = QDir::toNativeSeparators(qApp->applicationFilePath());
 commandLine.prepend(QLatin1String("quot;"));
 commandLine.append(QLatin1String("quot;"));

 if(!cmdLineArg.isEmpty())
 {
 commandLine.append(QChar(' '));
 commandLine.append(cmdLineArg);
 }

 if (!SetHkcrUserRegKey(QString("%1shell%2command").arg(documentId).arg(command), commandLine))
 return; // just skip it

 if(m_registerForDDE)
 {
 if (!SetHkcrUserRegKey(QString("%1shell%2ddeexec").arg(documentId).arg(command), ddeCommand))
 return;

 if (!SetHkcrUserRegKey(QString("%1shell%2ddeexecapplication").arg(documentId).arg(command), m_appAtomName))
 return;

 if (!SetHkcrUserRegKey(QString("%1shell%2ddeexectopic").arg(documentId).arg(command), m_systemTopicAtomName))
 return;
 }
}

void DocumentWindow::enableShellOpen()
{
 if((0 != m_appAtom) || (0 != m_systemTopicAtom))
 return;

 m_appAtom = ::GlobalAddAtomW((const wchar_t''')m_appAtomName.utf16());
 m_systemTopicAtom = ::GlobalAddAtomW((const wchar_t*)m_systemTopicAtomName.utf16());
}

// —— private slots ——————————————————————————
// —— private helpers —————————————————————————
bool DocumentWindow::ddeInitiate(MSG* message, long* result)
{
 if( (0 != LOWORD (message->lParam)) &&
 (0 != HIWORD (message->lParam)) &&
 (LOWORD (message->lParam)  m_appAtom) &&
        (HIWORD(message->lParam)  m_systemTopicAtom))
 {
 // make duplicates of the incoming atoms (really adding a reference)
 wchar_t atomName[_MAX_PATH];
 Q_ASSERT(::GlobalGetAtomNameW(m_appAtom, atomName, _MAX_PATH - 1) != 0);
 Q_ASSERT(::GlobalAddAtomW(atomName)  m_appAtom);
        Q_ASSERT(::GlobalGetAtomNameW(m_systemTopicAtom, atomName, _MAX_PATH - 1) != 0);
        Q_ASSERT(::GlobalAddAtomW(atomName)  m_systemTopicAtom);

// send the WM_DDE_ACK (caller will delete duplicate atoms)
 ::SendMessage((HWND)message->wParam, WM_DDE_ACK, (WPARAM)winId(), MAKELPARAM (m_appAtom, m_systemTopicAtom));
 }
 '''result = 0;
 return true;
}

bool DocumentWindow::ddeExecute(MSG''' message, long* result)
{
 // unpack the DDE message
 UINT_PTR unused;
 HGLOBAL hData;
 //IA64: Assume DDE LPARAMs are still 32-bit
 Q_ASSERT(::UnpackDDElParam(WM_DDE_EXECUTE, message->lParam, &unused, (UINT_PTR*)&hData));

QString command = QString::fromWCharArray((LPCWSTR)::GlobalLock(hData));
 ::GlobalUnlock(hData);

// acknowledge now - before attempting to execute
 ::PostMessage((HWND)message->wParam, WM_DDE_ACK, (WPARAM)winId(),
 //IA64: Assume DDE LPARAMs are still 32-bit
 ReuseDDElParam(message->lParam, WM_DDE_EXECUTE, WM_DDE_ACK, (UINT)0x8000, (UINT_PTR)hData));

// don't execute the command when the window is disabled
 if (!isEnabled())
 {
 '''result = 0;
 return true;
 }

 QRegExp regCommand("<sup>$");
 if(regCommand.exactMatch(command))
 {
 executeDdeCommand(regCommand.cap(1), regCommand.cap(2));
 }

 '''result = 0;
 return true;
}

bool DocumentWindow::ddeTerminate(MSG''' message, long* result)
{
 // The client or server application should respond by posting a WM_DDE_TERMINATE message.
 ::PostMessageW((HWND)message->wParam, WM_DDE_TERMINATE, (WPARAM)winId(), message->lParam);
 return true;
}

bool DocumentWindow::SetHkcrUserRegKey(QString key, const QString& value, const QString& valueName)
{
 HKEY hKey;

 key.prepend("SoftwareClasses");

 LONG lRetVal = RegCreateKey(HKEY_CURRENT_USER,
 (const wchar_t*)key.utf16(),
 &hKey);

 if(ERROR_SUCCESS == lRetVal)
 {
 LONG lResult = ::RegSetValueExW(hKey,
 valueName.isEmpty() ? 0 : (const wchar_t*)valueName.utf16(),
 0,
 REG_SZ,
 (CONST BYTE*)value.utf16(),
 (value.length() + 1) * sizeof(wchar_t));

 if(::RegCloseKey(hKey)  ERROR_SUCCESS && lResult  ERROR_SUCCESS)
 return true;

 QMessageBox::warning(0, QString("Error in setting Registry values"),
 QString("registration database update failed for key '%s'.").arg(key));
 }
 else
 {
 wchar_t buffer[4096];
 ::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, 0, lRetVal, 0, buffer, 4096, 0);
 QString szText = QString::fromUtf16((const ushort*)buffer);
 QMessageBox::warning(this, QString("Error in setting Registry values"), szText);
 }
 return false;
}

void DocumentWindow::executeDdeCommand(const QString& command, const QString& params)
{
 QRegExp regCommand("</sup>quot;(.''')quot;$");
 bool singleCommand = regCommand.exactMatch(params);
 if((0  command.compare("open", Qt::CaseInsensitive)) && singleCommand)
    {
        ddeOpenFile(regCommand.cap(1));
    }
    else if((0  command.compare("new", Qt::CaseInsensitive)) && singleCommand)
 {
 ddeNewFile(regCommand.cap(1));
 }
 else if((0 == command.compare("print", Qt::CaseInsensitive)) && singleCommand)
 {
 ddePrintFile(regCommand.cap(1));
 }
 else
 {
 executeUnknownDdeCommand(command, params);
 }
}

You may use this code without any warranty.

Future extensions

The class might be extended so it also works on Linux or Mac. The code of the class and a demo project are located on gitorious in the following repository: qtdevnet-registereditorfiletype

Versions

The current code is version 1 of the code.

Version 1

This marks the first public release.

Feedback