FXWinLinks.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                                 Windows Links                                 *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2005 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef FXWINLINKS_H
#define FXWINLINKS_H

#include "FXString.h"

namespace FX {

class QFileInfo;

struct FXAPI FXWinShellLink
{
    struct FXAPI Header
    {
        FXuint length;
        char guid[16];
        union Flags
        {
            struct
            {
                FXuint hasItemIdList : 1;
                FXuint pointsToFileOrDir : 1;
                FXuint hasDescription : 1;
                FXuint hasRelativePath : 1;
                FXuint hasWorkingDir : 1;
                FXuint hasCmdLineArgs : 1;
                FXuint hasCustomIcon : 1;
                FXuint useWorkingDir : 1;       // Seems to need to be set to enable working dir
                FXuint unused : 24;
            };
            FXuint raw;
        } flags;
        union FileAttribs
        {   // = return from GetFileAttributes()
            struct
            {
                FXuint isReadOnly : 1;
                FXuint isHidden : 1;
                FXuint isSystem : 1;
                FXuint isVolumeLabel : 1;
                FXuint isDir : 1;
                FXuint isModified : 1;  // =archive bit set, ie; is a file normally
                FXuint isEncrypted : 1;
                FXuint isNormal : 1;    // Doesn't seem to get set
                FXuint isTemporary : 1;
                FXuint isSparse : 1;
                FXuint hasReparsePoint : 1;
                FXuint isCompressed : 1;
                FXuint isOffline : 1;
                FXuint unused : 19;
            };
            FXuint raw;
        } fileattribs;      // in GetFileAttributes() format
        FXulong creation, modified, lastAccess; // in FILETIME format
        FXuint filelength;
        FXuint iconno;
        enum ShowWnd
        {
            HIDE=0,
            NORMAL,
            SHOWMINIMIZED,
            SHOWMAXIMIZED
        };
        ShowWnd showWnd;
        FXuint hotkey;
        FXuint unknown1, unknown2;

        Header()
        {
            memset(this, 0, sizeof(*this));
            static const char linkguid[]={
                0x01, 0x14, 0x02, 0x00,
                0x00, 0x00,
                0x00, 0x00,
                (char) 0xc0, 0x00,
                0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };
            length=0x4c;
            memcpy(guid, linkguid, sizeof(guid));
            showWnd=NORMAL;
        }

        friend FXAPI FXStream &operator<<(FXStream &s, const Header &i);
        friend FXAPI FXStream &operator>>(FXStream &s, Header &i);
    } header;
    /* Had to reverse engineer this myself!
    First item is guid of what I assume means "My Computer"
      +0: length of item (always 0x14=20 bytes)
      +2: Always 18 bytes:
        0x1f, 0x50, 0xe0, 0x4f, 0xd0, 0x20, 0xea, 0x3a,
        0x69, 0x10, 0xa2, 0xd8, 0x08, 0x00, 0x2b, 0x30,
        0x30, 0x9d
    Next item is drive:
      +0: length of item (always 0x19=25 bytes)
      +2: byte 0x2f
      +3: Drive in ASCII for 22 bytes
    Next comes path items:
      +0: length of overall item
      +2: short 0x31 for dir, 0x32 for file
      +4: int size of file (=0 for dir)
      +8: int created       d:\windows=0x63893326, c:\windows=0x052D3321, c:\downloads=0x48853328
      +12: GetFileAttributes() for entry
      +14: Null terminated ASCII short filename version (padded to two byte multiple)
     On WinXP only:
      +n: length of this item
      +n+2: short 0x3
      +n+4: short 0x4
      +n+6: short 0xbeef
      +n+8: int modified    d:\windows=0x8de5328c, c:\windows=0x63c43297, c:\downloads=0x76e8331a
      +n+12: int lastRead   d:\windows=0x49843328, c:\windows=0x41fa3328, c:\downloads=0x48853328
      +n+16: int 0x14
      +n+20: Null terminated Unicode version
      +n+m: Two bytes (unknown)
    */
    struct FXAPI ItemIdListTag
    {
        FXushort length;
        char path1[260];            // In ASCII
        FXnchar path2[260];     // In unicode
        ItemIdListTag()
        {
            memset(this, 0, sizeof(*this));
        }
        friend FXAPI FXStream &operator<<(FXStream &s, const ItemIdListTag &i);
        friend FXAPI FXStream &operator>>(FXStream &s, ItemIdListTag &i);
        char originalPath[260];     // [not in lnk file] Used so code knows the non-decoded path
    } itemIdList;
    struct FXAPI FileLocationTag
    {
        FXuint length;          // to end of whole tag
        FXuint firstOffset;     // to end of this tag header
        union Flags
        {
            struct
            {
                FXuint onLocalVolume : 1;
                FXuint onNetworkShare : 1;
                FXuint unused : 30;
            };
            FXuint raw;
        } flags;
        struct FXAPI LocalVolume
        {
            FXuint length;
            enum Type
            {
                Unknown=0,
                NoRoot,
                Removable,  // ie; floppy, usb drive etc.
                Fixed,      // ie; hard disc
                Remote,     // ie; network share
                CDROM,
                RamDrive
            };
            Type type;
            FXuint serialNo;
            char volumeLabel[64];
            LocalVolume()
            {
                memset(this, 0, sizeof(*this));
            }
            friend FXAPI FXStream &operator<<(FXStream &s, const LocalVolume &i);
            friend FXAPI FXStream &operator>>(FXStream &s, LocalVolume &i);
        } localVolume;
        char basePath[260];
        struct FXAPI NetworkVolume
        {
            FXuint length;
            FXuint type;
            FXchar shareName[260];
            NetworkVolume()
            {
                memset(this, 0, sizeof(*this));
                type=0x2;
            }
            friend FXAPI FXStream &operator<<(FXStream &s, const NetworkVolume &i);
            friend FXAPI FXStream &operator>>(FXStream &s, NetworkVolume &i);
        } networkVolume;
        char remainingPath[64];

        FileLocationTag()
        {
            memset(this, 0, sizeof(*this));
            firstOffset=0x1c;
        }
        friend FXAPI FXStream &operator<<(FXStream &s, const FileLocationTag &i);
        friend FXAPI FXStream &operator>>(FXStream &s, FileLocationTag &i);
    } fileLocation;
    struct FXAPI StringTag
    {
        FXushort length;            // in characters
        FXnchar string[260];        // Unicode string
        StringTag() { memset(this, 0, sizeof(*this)); }
        friend FXAPI FXStream &operator<<(FXStream &s, const StringTag &i);
        friend FXAPI FXStream &operator>>(FXStream &s, StringTag &i);
    };
    StringTag description;
    StringTag relativePath;
    StringTag workingDir;
    StringTag cmdLineArgs;
    StringTag customIcon;
    friend FXAPI FXStream &operator>>(FXStream &s, FXWinShellLink &i);

    void write(FXStream s, const QFileInfo &whereTo);

    static FXString read(const FXString &path, bool doDriveConversion=true);
    static void write(const FXString &path, const QFileInfo &whereTo);

};


struct FXAPI FXWinJunctionPoint
{
private:
    FXWinJunctionPoint();
    ~FXWinJunctionPoint();
public:
    static bool test(const FXString &path);
    static FXString read(const FXString &path);
    static void write(const FXString &path, const QFileInfo &whereTo);
    static void remove(const FXString &path);
};

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.