far2l/src/clipboard.cpp

   1 /*
   2 clipboard.cpp
   3
   4 Работа с буфером обмена.
   5 */
   6 /*
   7 Copyright (c) 1996 Eugene Roshal
   8 Copyright (c) 2000 Far Group
   9 All rights reserved.
  10
  11 Redistribution and use in source and binary forms, with or without
  12 modification, are permitted provided that the following conditions
  13 are met:
  14 1. Redistributions of source code must retain the above copyright
  15    notice, this list of conditions and the following disclaimer.
  16 2. Redistributions in binary form must reproduce the above copyright
  17    notice, this list of conditions and the following disclaimer in the
  18    documentation and/or other materials provided with the distribution.
  19 3. The name of the authors may not be used to endorse or promote products
  20    derived from this software without specific prior written permission.
  21
  22 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  23 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  24 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  25 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  26 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  27 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  31 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 */
  33
  34 #include "headers.hpp"
  35
  36 #include "clipboard.hpp"
  37 #include "console.hpp"
  38
  39 static const wchar_t FAR_VerticalBlock_Unicode[] = L"FAR_VerticalBlock_Unicode";
  40
  41 /* ------------------------------------------------------------ */
  42 // CF_OEMTEXT CF_TEXT CF_UNICODETEXT CF_HDROP
  43 HGLOBAL Clipboard::hInternalClipboard[5] = {0};
  44 UINT Clipboard::uInternalClipboardFormat[5] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
  45
  46 bool Clipboard::UseInternalClipboard = false;
  47 bool Clipboard::InternalClipboardOpen = false;
  48
  49 // Sets UseInternalClipboard to State, and returns previous state
  50 bool Clipboard::SetUseInternalClipboardState(bool State)
  51 {
  52         bool OldState = UseInternalClipboard;
  53         UseInternalClipboard = State;
  54         return OldState;
  55 }
  56
  57 bool Clipboard::GetUseInternalClipboardState()
  58 {
  59         return UseInternalClipboard;
  60 }
  61
  62 UINT Clipboard::RegisterFormat(LPCWSTR lpszFormat)
  63 {
  64         if (UseInternalClipboard) {
  65                 if (!StrCmp(lpszFormat, FAR_VerticalBlock_Unicode)) {
  66                         return 0xFEB1;
  67                 }
  68
  69                 return 0;
  70         }
  71
  72         return WINPORT(RegisterClipboardFormat)(lpszFormat);
  73 }
  74
  75 BOOL Clipboard::Open()
  76 {
  77         if (UseInternalClipboard) {
  78                 if (!InternalClipboardOpen) {
  79                         InternalClipboardOpen = true;
  80                         return TRUE;
  81                 }
  82
  83                 return FALSE;
  84         }
  85
  86         return WINPORT(OpenClipboard)(NULL);    // Console.GetWindow());
  87 }
  88
  89 BOOL Clipboard::Close()
  90 {
  91         if (UseInternalClipboard) {
  92                 if (InternalClipboardOpen) {
  93                         InternalClipboardOpen = false;
  94                         return TRUE;
  95                 }
  96
  97                 return FALSE;
  98         }
  99
 100         return WINPORT(CloseClipboard)();
 101 }
 102
 103 BOOL Clipboard::Empty()
 104 {
 105         if (UseInternalClipboard) {
 106                 if (InternalClipboardOpen) {
 107                         for (size_t I = 0; I < ARRAYSIZE(hInternalClipboard); ++I) {
 108                                 if (hInternalClipboard[I]) {
 109                                         WINPORT(ClipboardFree)(hInternalClipboard[I]);
 110                                         hInternalClipboard[I] = 0;
 111                                         uInternalClipboardFormat[I] = 0xFFFF;
 112                                 }
 113                         }
 114
 115                         return TRUE;
 116                 }
 117
 118                 return FALSE;
 119         }
 120
 121         return WINPORT(EmptyClipboard)();
 122 }
 123
 124 HANDLE Clipboard::GetData(UINT uFormat)
 125 {
 126         if (UseInternalClipboard) {
 127                 if (InternalClipboardOpen && uFormat != 0xFFFF) {
 128                         for (size_t I = 0; I < ARRAYSIZE(hInternalClipboard); ++I) {
 129                                 if (uInternalClipboardFormat[I] == uFormat) {
 130                                         return hInternalClipboard[I];
 131                                 }
 132                         }
 133                 }
 134
 135                 return (HANDLE) nullptr;
 136         }
 137
 138         return WINPORT(GetClipboardData)(uFormat);
 139 }
 140
 141 HANDLE Clipboard::SetData(UINT uFormat, HANDLE hMem)
 142 {
 143         if (UseInternalClipboard) {
 144                 if (InternalClipboardOpen) {
 145                         for (size_t I = 0; I < ARRAYSIZE(hInternalClipboard); ++I) {
 146                                 if (!hInternalClipboard[I]) {
 147                                         hInternalClipboard[I] = hMem;
 148                                         uInternalClipboardFormat[I] = uFormat;
 149                                         return hMem;
 150                                 }
 151                         }
 152                 }
 153
 154                 return (HANDLE) nullptr;
 155         }
 156
 157         return WINPORT(SetClipboardData)(uFormat, hMem);
 158 }
 159
 160 bool Clipboard::IsFormatAvailable(UINT Format)
 161 {
 162         if (UseInternalClipboard) {
 163                 for (size_t I = 0; I < ARRAYSIZE(hInternalClipboard); ++I) {
 164                         if (uInternalClipboardFormat[I] != 0xFFFF && uInternalClipboardFormat[I] == Format) {
 165                                 return true;
 166                         }
 167                 }
 168
 169                 return false;
 170         }
 171
 172         return WINPORT(IsClipboardFormatAvailable)(Format) != FALSE;
 173 }
 174
 175 // Перед вставкой производится очистка буфера
 176 bool Clipboard::Copy(const wchar_t *Data, bool IsVertical)
 177 {
 178         Empty();
 179
 180         if (!AddData(CF_UNICODETEXT, Data, (wcslen(Data) + 1) * sizeof(wchar_t))) {
 181                 return false;
 182         }
 183
 184         if (IsVertical) {
 185                 UINT FormatType = RegisterFormat(FAR_VerticalBlock_Unicode);
 186                 if (FormatType) {
 187                         AddData(FormatType, "\0\0\0\0", 4);
 188                 }
 189         }
 190
 191         return true;
 192 }
 193
 194 bool Clipboard::AddData(UINT FormatType, const void *Data, size_t Size)
 195 {
 196         if (!Data || !Size)
 197                 return true;
 198
 199         void *CData = WINPORT(ClipboardAlloc)(Size);
 200
 201         if (!CData)
 202                 return false;
 203
 204         memcpy(CData, Data, Size);
 205         if (!SetData(FormatType, (HANDLE)CData)) {
 206                 WINPORT(ClipboardFree)(CData);
 207                 return false;
 208         }
 209
 210         return true;
 211 }
 212
 213 // max - без учета символа конца строки!
 214 // max = -1 - there is no limit!
 215 wchar_t *Clipboard::Paste(bool &IsVertical, int MaxChars)
 216 {
 217         PVOID ClipData = GetData(CF_UNICODETEXT);
 218
 219         if (!ClipData)
 220                 return nullptr;
 221
 222         size_t CharsCount =
 223                         wcsnlen((const wchar_t *)ClipData, WINPORT(ClipboardSize)(ClipData) / sizeof(wchar_t));
 224
 225         if (MaxChars >= 0 && CharsCount < (size_t)MaxChars)
 226                 CharsCount = (size_t)MaxChars;
 227
 228         wchar_t *ClipText = (wchar_t *)malloc((CharsCount + 1) * sizeof(wchar_t));
 229         if (ClipText) {
 230                 wmemcpy(ClipText, (const wchar_t *)ClipData, CharsCount);
 231                 ClipText[CharsCount] = 0;
 232         }
 233
 234         IsVertical = false;
 235
 236         if (wcsstr(ClipText, NATIVE_EOLW)) {
 237                 UINT FormatType = RegisterFormat(FAR_VerticalBlock_Unicode);
 238                 if (FormatType && IsFormatAvailable(FormatType)) {
 239                         IsVertical = true;
 240                 }
 241         }
 242
 243         return ClipText;
 244 }
 245
 246 wchar_t *Clipboard::Paste()
 247 {
 248         bool IsVertical;
 249         return Paste(IsVertical);
 250 }
 251
 252 /* ------------------------------------------------------------ */
 253 int WINAPI CopyToClipboard(const wchar_t *Data)
 254 {
 255         Clipboard clip;
 256
 257         if (!clip.Open())
 258                 return FALSE;
 259
 260         BOOL ret = clip.Copy(Data);
 261
 262         clip.Close();
 263
 264         return ret;
 265 }
 266
 267 wchar_t *PasteFromClipboardEx(int MaxChars)
 268 {
 269         Clipboard clip;
 270
 271         if (!clip.Open())
 272                 return nullptr;
 273
 274         bool IsVertical;
 275         wchar_t *ClipText = clip.Paste(IsVertical, MaxChars);
 276
 277         clip.Close();
 278
 279         return ClipText;
 280 }
 281
 282 wchar_t *WINAPI PasteFromClipboard()
 283 {
 284         return PasteFromClipboardEx();
 285 }
 286
 287 BOOL EmptyInternalClipboard()
 288 {
 289         bool OldState = Clipboard::SetUseInternalClipboardState(true);
 290
 291         Clipboard clip;
 292
 293         if (!clip.Open())
 294                 return FALSE;
 295
 296         BOOL ret = clip.Empty();
 297
 298         clip.Close();
 299
 300         Clipboard::SetUseInternalClipboardState(OldState);
 301
 302         return ret;
 303 }