Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove Windows CE support

Browse Source 
Windows CE doesn't seem to be supported by Microsoft any longer. Last CE
release was in early 2013 and the PocketPC and Smartphone targets supported by
wxWidgets are long gone.

The build files where already removed in an earlier cleanup this commit
removes all files, every #ifdef and all documentation regarding the Windows CE
support.

Closes https://github.com/wxWidgets/wxWidgets/pull/81
This commit is contained in:
Tobias Taschner
2015-08-27 17:48:54 +02:00
committed by Vadim Zeitlin
parent 6fbc2bd0b7
commit 8282c1be0f
388 changed files with 1109 additions and 19505 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
include/wx/msw/app.h
View File

@@ -116,25 +116,5 @@ protected:
wxDECLARE_DYNAMIC_CLASS(wxApp);
};
#ifdef __WXWINCE__
// under CE provide a dummy implementation of GetComCtl32Version() returning
// the value passing all ">= 470" tests (which are the only ones used in our
// code currently) as commctrl.dll under CE 2.0 and later support comctl32.dll
// functionality
inline int wxApp::GetComCtl32Version()
{
return 471;
}
// this is not currently used at all under CE so it's not really clear what do
// we need to return from here
inline int wxApp::GetShell32Version()
{
return 0;
}
#endif // __WXWINCE__
#endif // _WX_APP_H_

2
include/wx/msw/apptbase.h
View File

@@ -44,7 +44,6 @@ public:
#endif // wxUSE_THREADS
#ifndef __WXWINCE__
// console helpers
// ---------------
@@ -58,7 +57,6 @@ public:
// write text to the console, return true if ok or false on error
virtual bool WriteToStderr(const wxString& text) = 0;
#endif // !__WXWINCE__
protected:
#if wxUSE_THREADS

6
include/wx/msw/apptrait.h
View File

@@ -28,10 +28,8 @@ public:
virtual bool DoMessageFromThreadWait();
virtual WXDWORD WaitForThread(WXHANDLE hThread, int flags);
#endif // wxUSE_THREADS
#ifndef __WXWINCE__
virtual bool CanUseStderr() { return true; }
virtual bool WriteToStderr(const wxString& text);
#endif // !__WXWINCE__
};
#if wxUSE_GUI
@@ -53,10 +51,8 @@ public:
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL, int *minVer = NULL) const;
#ifndef __WXWINCE__
virtual bool CanUseStderr();
virtual bool WriteToStderr(const wxString& text);
#endif // !__WXWINCE__
};
#elif defined(__WXGTK__)
@@ -83,10 +79,8 @@ public:
#endif // wxUSE_THREADS
virtual wxPortId GetToolkitVersion(int *majVer = NULL, int *minVer = NULL) const;
#ifndef __WXWINCE__
virtual bool CanUseStderr() { return false; }
virtual bool WriteToStderr(const wxString& WXUNUSED(text)) { return false; }
#endif // !__WXWINCE__
};
#endif

2
include/wx/msw/colordlg.h
View File

@@ -48,13 +48,11 @@ protected:
// common part of all ctors
void Init();
#if !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
virtual void DoGetPosition( int *x, int *y ) const;
virtual void DoGetSize(int *width, int *height) const;
virtual void DoGetClientSize(int *width, int *height) const;
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual void DoCentre(int dir);
#endif // !(__SMARTPHONE__ && __WXWINCE__)
wxColourData m_colourData;
wxString m_title;

4
include/wx/msw/combo.h
View File

@@ -17,11 +17,9 @@
#if wxUSE_COMBOCTRL
#if !defined(__WXWINCE__) && wxUSE_TIMER
#if wxUSE_TIMER
#include "wx/timer.h"
#define wxUSE_COMBOCTRL_POPUP_ANIMATION 1
#else
#define wxUSE_COMBOCTRL_POPUP_ANIMATION 0
#endif

6
include/wx/msw/control.h
View File

@@ -76,12 +76,6 @@ protected:
// return default best size (doesn't really make any sense, override this)
virtual wxSize DoGetBestSize() const;
// This is a helper for all wxControls made with UPDOWN native control.
// In wxMSW it was only wxSpinCtrl derived from wxSpinButton but in
// WinCE of Smartphones this happens also for native wxTextCtrl,
// wxChoice and others.
virtual wxSize GetBestSpinnerSize(const bool is_vertical) const;
// create the control of the given Windows class: this is typically called
// from Create() method of the derived class passing its label, pos and
// size parameter (style parameter is not needed because m_windowStyle is

2
include/wx/msw/dc.h
View File

@@ -213,7 +213,7 @@ public:
double radius);
virtual void DoDrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height);
#if wxUSE_SPLINES && !defined(__WXWINCE__)
#if wxUSE_SPLINES
virtual void DoDrawSpline(const wxPointList *points);
#endif

2
include/wx/msw/debughlp.h
View File

@@ -13,9 +13,7 @@
#include "wx/dynlib.h"
#include "wx/msw/wrapwin.h"
#ifndef __WXWINCE__
#include <imagehlp.h>
#endif // __WXWINCE__
#include "wx/msw/private.h"
// wxUSE_DBGHELP can be predefined on the compiler command line to force using

47
include/wx/msw/dialog.h
View File

@@ -13,24 +13,10 @@
#include "wx/panel.h"
// this option is always enabled (there doesn't seem to be any good reason to
// disable it) for desktop Windows versions but Windows CE dialogs are usually
// not resizable and never show resize gripper anyhow so don't use it there
#ifdef __WXWINCE__
#define wxUSE_DIALOG_SIZEGRIP 0
#else
#define wxUSE_DIALOG_SIZEGRIP 1
#endif
extern WXDLLIMPEXP_DATA_CORE(const char) wxDialogNameStr[];
class WXDLLIMPEXP_FWD_CORE wxDialogModalData;
#if wxUSE_TOOLBAR && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
class WXDLLIMPEXP_FWD_CORE wxToolBar;
extern WXDLLIMPEXP_DATA_CORE(const char) wxToolBarNameStr[];
#endif
// Dialog boxes
class WXDLLIMPEXP_CORE wxDialog : public wxDialogBase
{
@@ -69,39 +55,12 @@ public:
virtual void EndModal(int retCode);
// we treat dialog toolbars specially under Windows CE
#if wxUSE_TOOLBAR && defined(__POCKETPC__)
// create main toolbar by calling OnCreateToolBar()
virtual wxToolBar* CreateToolBar(long style = -1,
wxWindowID winid = wxID_ANY,
const wxString& name = wxToolBarNameStr);
// return a new toolbar
virtual wxToolBar *OnCreateToolBar(long style,
wxWindowID winid,
const wxString& name );
// get the main toolbar
wxToolBar *GetToolBar() const { return m_dialogToolBar; }
#endif // wxUSE_TOOLBAR && __POCKETPC__
// implementation only from now on
// -------------------------------
// override some base class virtuals
virtual bool Show(bool show = true);
#if wxUSE_DIALOG_SIZEGRIP
virtual void SetWindowStyleFlag(long style);
#endif // wxUSE_DIALOG_SIZEGRIP
#ifdef __POCKETPC__
// Responds to the OK button in a PocketPC titlebar. This
// can be overridden, or you can change the id used for
// sending the event with SetAffirmativeId. Returns false
// if the event was not processed.
virtual bool DoOK();
#endif
// Windows callbacks
WXLRESULT MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
@@ -111,7 +70,6 @@ protected:
void Init();
private:
#if wxUSE_DIALOG_SIZEGRIP
// these functions deal with the gripper window shown in the corner of
// resizable dialogs
void CreateGripper();
@@ -125,11 +83,6 @@ private:
// gripper window for a resizable dialog, NULL if we're not resizable
WXHWND m_hGripper;
#endif // wxUSE_DIALOG_SIZEGRIP
#if wxUSE_TOOLBAR && defined(__POCKETPC__)
wxToolBar* m_dialogToolBar;
#endif
// this pointer is non-NULL only while the modal event loop is running
wxDialogModalData *m_modalData;

4
include/wx/msw/dib.h
View File

@@ -70,12 +70,10 @@ public:
// operations
// ----------
#ifndef __WXWINCE__
// create a bitmap compatible with the given HDC (or screen by default) and
// return its handle, the caller is responsible for freeing it (using
// DeleteObject())
HBITMAP CreateDDB(HDC hdc = 0) const;
#endif // !__WXWINCE__
// get the handle from the DIB and reset it, i.e. this object won't destroy
// the DIB after this (but the caller should do it)
@@ -119,7 +117,6 @@ public:
// these functions are only used by wxWidgets internally right now, please
// don't use them directly if possible as they're subject to change
#ifndef __WXWINCE__
// creates a DDB compatible with the given (or screen) DC from either
// a plain DIB or a DIB section (in which case the last parameter must be
// non NULL)
@@ -137,7 +134,6 @@ public:
// function (this overload is needed for wxBitmapDataObject code in
// src/msw/ole/dataobj.cpp)
static size_t ConvertFromBitmap(BITMAPINFO *pbi, HBITMAP hbmp);
#endif // __WXWINCE__
// wxImage conversion

4
include/wx/msw/filedlg.h
View File

@@ -30,10 +30,8 @@ public:
virtual void GetPaths(wxArrayString& paths) const;
virtual void GetFilenames(wxArrayString& files) const;
#ifndef __WXWINCE__
virtual bool SupportsExtraControl() const { return true; }
void MSWOnInitDialogHook(WXHWND hwnd);
#endif // __WXWINCE__
virtual int ShowModal();
@@ -48,12 +46,10 @@ public:
protected:
#if !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual void DoCentre(int dir);
virtual void DoGetSize( int *width, int *height ) const;
virtual void DoGetPosition( int *x, int *y ) const;
#endif // !(__SMARTPHONE__ && __WXWINCE__)
private:
wxArrayString m_fileNames;

9
include/wx/msw/init.h
View File

@@ -22,13 +22,8 @@
#define SW_SHOWNORMAL 1
#endif
// WinMain() is always ANSI, even in Unicode build, under normal Windows
// but is always Unicode under CE
#ifdef __WXWINCE__
typedef wchar_t *wxCmdLineArgType;
#else
typedef char *wxCmdLineArgType;
#endif
// WinMain() is always ANSI, even in Unicode build.
typedef char *wxCmdLineArgType;
// Windows-only overloads of wxEntry() and wxEntryStart() which take the
// parameters passed to WinMain() instead of those passed to main()

36
include/wx/msw/menu.h
View File

@@ -20,24 +20,8 @@
class WXDLLIMPEXP_FWD_CORE wxFrame;
#if defined(__WXWINCE__) && wxUSE_TOOLBAR
class WXDLLIMPEXP_FWD_CORE wxToolBar;
#endif
class wxMenuRadioItemsData;
// Not using a combined wxToolBar/wxMenuBar? then use
// a commandbar in WinCE .NET to implement the
// menubar, since there is no ::SetMenu function.
#if defined(__WXWINCE__)
# if ((_WIN32_WCE >= 400) && !defined(__POCKETPC__) && !defined(__SMARTPHONE__)) || \
defined(__HANDHELDPC__)
# define WINCE_WITH_COMMANDBAR
# else
# define WINCE_WITHOUT_COMMANDBAR
# endif
#endif
#include "wx/arrstr.h"
@@ -208,17 +192,6 @@ public:
virtual void Detach();
virtual void Attach(wxFrame *frame);
#if defined(__WXWINCE__) && wxUSE_TOOLBAR
// Under WinCE, a menubar is owned by the frame's toolbar
void SetToolBar(wxToolBar* toolBar) { m_toolBar = toolBar; }
wxToolBar* GetToolBar() const { return m_toolBar; }
#endif
#ifdef WINCE_WITH_COMMANDBAR
WXHWND GetCommandBar() const { return m_commandBar; }
bool AddAdornments(long style);
#endif
#if wxUSE_ACCEL
// update the accel table (must be called after adding/deleting a menu)
void RebuildAccelTable();
@@ -251,15 +224,6 @@ protected:
// the wxWidgets position.
int MSWPositionForWxMenu(wxMenu *menu, int wxpos);
#if defined(__WXWINCE__) && wxUSE_TOOLBAR
wxToolBar* m_toolBar;
#endif
#ifdef WINCE_WITH_COMMANDBAR
WXHWND m_commandBar;
bool m_adornmentsAdded;
#endif
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxMenuBar);
};

11
include/wx/msw/missing.h
View File

@@ -176,8 +176,7 @@
#define LVS_EX_FULLROWSELECT 0x00000020
#endif
// LVS_EX_LABELTIP is not supported by Windows CE, don't define it there
#if !defined(LVS_EX_LABELTIP) && !defined(__WXWINCE__)
#if !defined(LVS_EX_LABELTIP)
#define LVS_EX_LABELTIP 0x00004000
#endif
@@ -401,14 +400,6 @@ typedef struct
#define MUI_LANGUAGE_NAME 0x8
#endif
/*
* In addition to the declarations for VC++, the following are required for WinCE
*/
#ifdef __WXWINCE__
#include "wx/msw/wince/missing.h"
#endif
/*
* The following are specifically required for Wine
*/

5
include/wx/msw/notebook.h
View File

@@ -185,15 +185,12 @@ protected:
bool DoDrawBackground(WXHDC hDC, wxWindow *child = NULL);
#endif // wxUSE_UXTHEME
// these function are only used for reducing flicker on notebook resize and
// we don't need to do this for WinCE
#ifndef __WXWINCE__
// these function are used for reducing flicker on notebook resize
void OnEraseBackground(wxEraseEvent& event);
void OnPaint(wxPaintEvent& event);
// true if we have already subclassed our updown control
bool m_hasSubclassedUpdown;
#endif // __WXWINCE__
#if wxUSE_UXTHEME
// background brush used to paint the tab control

2
include/wx/msw/ole/activex.h
View File

@@ -34,9 +34,7 @@ class FrameSite;
#include <oleidl.h>
#include <olectl.h>
#if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
#include <exdisp.h>
#endif
#include <docobj.h>

10
include/wx/msw/ole/oleutils.h
View File

@@ -37,11 +37,7 @@
inline bool wxOleInitialize()
{
HRESULT
#ifdef __WXWINCE__
hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
#else
hr = ::OleInitialize(NULL);
#endif
hr = ::OleInitialize(NULL);
// RPC_E_CHANGED_MODE indicates that OLE had been already initialized
// before, albeit with different mode. Don't consider it to be an error as
@@ -60,11 +56,7 @@ inline bool wxOleInitialize()
inline void wxOleUninitialize()
{
#ifdef __WXWINCE__
::CoUninitialize();
#else
::OleUninitialize();
#endif
}
// ----------------------------------------------------------------------------

18
include/wx/msw/private.h
View File

@@ -67,12 +67,6 @@ WXDLLIMPEXP_BASE void wxSetInstance(HINSTANCE hInst);
// define things missing from some compilers' headers
// ---------------------------------------------------------------------------
#if defined(__WXWINCE__)
#ifndef ZeroMemory
inline void ZeroMemory(void *buf, size_t len) { memset(buf, 0, len); }
#endif
#endif // old mingw32
// this defines a CASTWNDPROC macro which casts a pointer to the type of a
// window proc
#if defined(STRICT) || defined(__GNUC__)
@@ -146,10 +140,7 @@ extern LONG APIENTRY
// Vc++, bcc, dmc, ow, mingw akk have _get_osfhandle() and Cygwin has
// get_osfhandle. Others are currently unknown, e.g. Salford, Intel, Visual
// Age.
#if defined(__WXWINCE__)
#define wxGetOSFHandle(fd) ((HANDLE)fd)
#define wxOpenOSFHandle(h, flags) ((int)wxPtrToUInt(h))
#elif defined(__CYGWIN__)
#if defined(__CYGWIN__)
#define wxGetOSFHandle(fd) ((HANDLE)get_osfhandle(fd))
#elif defined(__VISUALC__) \
|| defined(__BORLANDC__) \
@@ -642,12 +633,6 @@ private:
};
// set the given map mode for the life time of this object
//
// NB: SetMapMode() is not supported by CE so we also define a helper macro
// to avoid using it there
#ifdef __WXWINCE__
#define wxCHANGE_HDC_MAP_MODE(hdc, mm)
#else // !__WXWINCE__
class HDCMapModeChanger
{
public:
@@ -676,7 +661,6 @@ private:
#define wxCHANGE_HDC_MAP_MODE(hdc, mm) \
HDCMapModeChanger wxMAKE_UNIQUE_NAME(wxHDCMapModeChanger)(hdc, mm)
#endif // __WXWINCE__/!__WXWINCE__
// smart pointer using GlobalAlloc/GlobalFree()
class GlobalPtr

2
include/wx/msw/private/sockmsw.h
View File

@@ -21,7 +21,7 @@
# include <sys/types.h>
#endif
#if defined(__WXWINCE__) || defined(__CYGWIN__)
#if defined(__CYGWIN__)
#include <winsock.h>
#endif

2
include/wx/msw/radiobox.h
View File

@@ -160,9 +160,7 @@ protected:
virtual void DoSetItemToolTip(unsigned int n, wxToolTip * tooltip);
#endif
#ifndef __WXWINCE__
virtual WXHRGN MSWGetRegionWithoutChildren();
#endif // __WXWINCE__
// resolve ambiguity in base classes
virtual wxBorder GetDefaultBorder() const { return wxRadioBoxBase::GetDefaultBorder(); }

2
include/wx/msw/seh.h
View File

@@ -46,7 +46,7 @@
#define wxSEH_HANDLE(rc)
#endif // wxUSE_ON_FATAL_EXCEPTION
#if wxUSE_ON_FATAL_EXCEPTION && defined(__VISUALC__) && !defined(__WXWINCE__)
#if wxUSE_ON_FATAL_EXCEPTION && defined(__VISUALC__)
#include <eh.h>
// C++ exception to structured exceptions translator: we need it in order

2
include/wx/msw/statbmp.h
View File

@@ -69,11 +69,9 @@ protected:
void SetImage(const wxGDIImage* image);
void SetImageNoCopy( wxGDIImage* image );
#ifndef __WXWINCE__
// draw the bitmap ourselves here if the OS can't do it correctly (if it
// can we leave it to it)
void DoPaintManually(wxPaintEvent& event);
#endif // !__WXWINCE__
void WXHandleSize(wxSizeEvent& event);

2
include/wx/msw/statbox.h
View File

@@ -45,7 +45,6 @@ public:
protected:
virtual wxSize DoGetBestSize() const;
#ifndef __WXWINCE__
public:
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
@@ -63,7 +62,6 @@ protected:
virtual void PaintForeground(wxDC& dc, const struct tagRECT& rc);
void OnPaint(wxPaintEvent& event);
#endif // !__WXWINCE__
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxStaticBox);
};

2
include/wx/msw/textctrl.h
View File

@@ -99,10 +99,8 @@ public:
return wxTextCtrlBase::HitTest(pt, col, row);
}
#ifndef __WXWINCE__
virtual void SetLayoutDirection(wxLayoutDirection dir) wxOVERRIDE;
virtual wxLayoutDirection GetLayoutDirection() const wxOVERRIDE;
#endif // !__WXWINCE__
// Caret handling (Windows only)
bool ShowNativeCaret(bool show = true);

53
include/wx/msw/toplevel.h
View File

@@ -99,18 +99,6 @@ public:
void SetLastFocus(wxWindow *win) { m_winLastFocused = win; }
wxWindow *GetLastFocus() const { return m_winLastFocused; }
#if defined(__SMARTPHONE__) && defined(__WXWINCE__)
virtual void SetLeftMenu(int id = wxID_ANY, const wxString& label = wxEmptyString, wxMenu *subMenu = NULL);
virtual void SetRightMenu(int id = wxID_ANY, const wxString& label = wxEmptyString, wxMenu *subMenu = NULL);
bool HandleCommand(WXWORD id, WXWORD cmd, WXHWND control);
virtual bool MSWShouldPreProcessMessage(WXMSG* pMsg);
#endif // __SMARTPHONE__ && __WXWINCE__
#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
// Soft Input Panel (SIP) change notification
virtual bool HandleSettingChange(WXWPARAM wParam, WXLPARAM lParam);
#endif
// translate wxWidgets flags to Windows ones
virtual WXDWORD MSWGetStyle(long flags, WXDWORD *exstyle) const;
@@ -144,10 +132,8 @@ protected:
// override those to return the normal window coordinates even when the
// window is minimized
#ifndef __WXWINCE__
virtual void DoGetPosition(int *x, int *y) const;
virtual void DoGetSize(int *width, int *height) const;
#endif // __WXWINCE__
// Top level windows have different freeze semantics on Windows
virtual void DoFreeze();
@@ -192,47 +178,8 @@ protected:
// from iconic state (done by wxFrame).
wxWindow *m_winLastFocused;
#if defined(__SMARTPHONE__) && defined(__WXWINCE__)
class ButtonMenu
{
public:
ButtonMenu();
~ButtonMenu();
void SetButton(int id = wxID_ANY,
const wxString& label = wxEmptyString,
wxMenu *subMenu = NULL);
bool IsAssigned() const {return m_assigned;}
bool IsMenu() const {return m_menu!=NULL;}
int GetId() const {return m_id;}
wxMenu* GetMenu() const {return m_menu;}
wxString GetLabel() {return m_label;}
static wxMenu *DuplicateMenu(wxMenu *menu);
protected:
int m_id;
wxString m_label;
wxMenu *m_menu;
bool m_assigned;
};
ButtonMenu m_LeftButton;
ButtonMenu m_RightButton;
HWND m_MenuBarHWND;
void ReloadButton(ButtonMenu& button, UINT menuID);
void ReloadAllButtons();
#endif // __SMARTPHONE__ && __WXWINCE__
private:
#if defined(__SMARTPHONE__) || defined(__POCKETPC__)
void* m_activateInfo;
#endif
// The system menu: initially NULL but can be set (once) by
// MSWGetSystemMenu(). Owned by this window.
wxMenu *m_menuSystem;

90
include/wx/msw/wince/checklst.h
View File

@@ -1,90 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/checklst.h
// Purpose: wxCheckListBox class - a listbox with checkable items
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 30.10.2005
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef __CHECKLSTCE__H_
#define __CHECKLSTCE__H_
class WXDLLIMPEXP_CORE wxCheckListBox : public wxCheckListBoxBase
{
public:
// ctors
wxCheckListBox();
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int nStrings = 0,
const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
wxCheckListBox(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
virtual ~wxCheckListBox();
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
bool Create(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxListBoxNameStr);
// items may be checked
virtual bool IsChecked(unsigned int uiIndex) const;
virtual void Check(unsigned int uiIndex, bool bCheck = true);
// public interface derived from wxListBox and lower classes
virtual void DoClear();
virtual void DoDeleteOneItem(unsigned int n);
virtual unsigned int GetCount() const;
virtual int GetSelection() const;
virtual int GetSelections(wxArrayInt& aSelections) const;
virtual wxString GetString(unsigned int n) const;
virtual bool IsSelected(int n) const;
virtual void SetString(unsigned int n, const wxString& s);
// Implementation
virtual bool MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result);
protected:
void OnSize(wxSizeEvent& event);
// protected interface derived from wxListBox and lower classes
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void* DoGetItemClientData(unsigned int n) const;
virtual void DoSetItemClientData(unsigned int n, void* clientData);
virtual void DoSetFirstItem(int n);
virtual void DoSetSelection(int n, bool select);
// convert our styles to Windows
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const;
private:
wxArrayPtrVoid m_itemsClientData;
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxCheckListBox);
};
#endif //_CHECKLSTCE_H

151
include/wx/msw/wince/chkconf.h
View File

@@ -1,151 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/chkconf.h
// Purpose: WinCE-specific configuration options checks
// Author: Vadim Zeitlin
// Modified by:
// Created: 2005-03-07
// Copyright: (c) 2005 Vadim Zeitlin <vadim@wxwindows.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MSW_WINCE_CHKCONF_H_
#define _WX_MSW_WINCE_CHKCONF_H_
// ----------------------------------------------------------------------------
// Disable features which don't work or don't make sense under CE
// ----------------------------------------------------------------------------
// please keep the list in alphabetic order except for closely related settings
// (e.g. wxUSE_ENH_METAFILE is put immediately after wxUSE_METAFILE)
#undef wxUSE_DEBUGREPORT
#define wxUSE_DEBUGREPORT 0
#if _WIN32_WCE < 400
// not enough API and lack of ddraw.h
#undef wxUSE_DISPLAY
#define wxUSE_DISPLAY 0
#endif
// eVC doesn't have standard streams
#ifdef __EVC4__
#undef wxUSE_STD_IOSTREAM
#define wxUSE_STD_IOSTREAM 0
#endif
// wxFSVolume currently doesn't compile under CE and it's not clear if it makes
// sense at all there (the drives and their names are fixed on CE systems)
#undef wxUSE_FSVOLUME
#define wxUSE_FSVOLUME 0
// no .INI files API under CE
#undef wxUSE_INICONF
#define wxUSE_INICONF 0
// DDE doesn't exist under WinCE and wxIPC is DDE-based under MSW
#undef wxUSE_IPC
#define wxUSE_IPC 0
// doesn't make sense for CE devices and doesn't compile anyhow
#undef wxUSE_JOYSTICK
#define wxUSE_JOYSTICK 0
// libtiff doesn't build with eVC but is ok with VC8
#ifdef __EVC4__
#undef wxUSE_LIBTIFF
#define wxUSE_LIBTIFF 0
#endif
// no AUI under CE: it's unnecessary and currently doesn't compile
#undef wxUSE_AUI
#define wxUSE_AUI 0
// no MDI under CE
#undef wxUSE_MDI
#define wxUSE_MDI 0
#undef wxUSE_MDI_ARCHITECTURE
#define wxUSE_MDI_ARCHITECTURE 0
// metafiles are not supported neither
#undef wxUSE_METAFILE
#define wxUSE_METAFILE 0
#undef wxUSE_ENH_METAFILE
#define wxUSE_ENH_METAFILE 0
// not sure if this is supported by CE but it doesn't compile currently anyhow
#undef wxUSE_MS_HTML_HELP
#define wxUSE_MS_HTML_HELP 0
// eVC doesn't support SEH
#undef wxUSE_ON_FATAL_EXCEPTION
#define wxUSE_ON_FATAL_EXCEPTION 0
// no owner drawn controls (not sure if this is possible at all but in any case
// the code doesn't currently compile)
#undef wxUSE_OWNER_DRAWN
#define wxUSE_OWNER_DRAWN 0
#undef wxUSE_PRINTING_ARCHITECTURE
#define wxUSE_PRINTING_ARCHITECTURE 0
// regex doesn't build with eVC but is ok with VC8
#ifdef __EVC4__
#undef wxUSE_REGEX
#define wxUSE_REGEX 0
#endif
#undef wxUSE_RICHEDIT
#define wxUSE_RICHEDIT 0
#undef wxUSE_RICHEDIT2
#define wxUSE_RICHEDIT2 0
// Standard SDK lacks a few things, forcefully disable them
#ifdef WCE_PLATFORM_STANDARDSDK
// no shell functions support
#undef wxUSE_STDPATHS
#define wxUSE_STDPATHS 0
#endif // WCE_PLATFORM_STANDARDSDK
// there is no support for balloon taskbar icons
#undef wxUSE_TASKBARICON_BALLOONS
#define wxUSE_TASKBARICON_BALLOONS 0
// there is no support for taskbar button
#undef wxUSE_TASKBARBUTTON
#define wxUSE_TASKBARBUTTON 0
// not sure if this is supported by eVC but VC8 SDK lacks the tooltips control
// related declarations
#if wxCHECK_VISUALC_VERSION(8)
#undef wxUSE_TOOLTIPS
#define wxUSE_TOOLTIPS 0
#endif
#undef wxUSE_UXTHEME
#define wxUSE_UXTHEME 0
#undef wxUSE_WXHTML_HELP
#define wxUSE_WXHTML_HELP 0
// Disable features which don't make sense for MS Smartphones
// (due to pointer device usage, limited controls or dialogs, file system)
#if defined(__SMARTPHONE__)
#undef wxUSE_LISTBOOK
#define wxUSE_LISTBOOK 0
#undef wxUSE_NOTEBOOK
#define wxUSE_NOTEBOOK 0
#undef wxUSE_STATUSBAR
#define wxUSE_STATUSBAR 0
#undef wxUSE_COLOURPICKERCTRL
#define wxUSE_COLOURPICKERCTRL 0
#undef wxUSE_COLOURDLG
#define wxUSE_COLOURDLG 0
#endif // __SMARTPHONE__
#endif // _WX_MSW_WINCE_CHKCONF_H_

140
include/wx/msw/wince/choicece.h
View File

@@ -1,140 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/choicece.h
// Purpose: wxChoice implementation for smart phones driven by WinCE
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 29.07.2004
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CHOICECE_H_BASE_
#define _WX_CHOICECE_H_BASE_
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#include "wx/defs.h"
#if wxUSE_CHOICE
#include "wx/dynarray.h"
class WXDLLIMPEXP_FWD_CORE wxChoice;
WX_DEFINE_EXPORTED_ARRAY_PTR(wxChoice *, wxArrayChoiceSpins);
// ----------------------------------------------------------------------------
// Choice item
// ----------------------------------------------------------------------------
class WXDLLIMPEXP_CORE wxChoice : public wxChoiceBase
{
public:
// ctors
wxChoice() { }
virtual ~wxChoice();
wxChoice(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Create(parent, id, pos, size, n, choices, style, validator, name);
}
wxChoice(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr)
{
Create(parent, id, pos, size, choices, style, validator, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
int n = 0, const wxString choices[] = NULL,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
const wxArrayString& choices,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxChoiceNameStr);
// implement base class pure virtuals
virtual void DoDeleteOneItem(unsigned int n);
virtual void DoClear();
virtual unsigned int GetCount() const;
virtual int GetSelection() const;
virtual void SetSelection(int n);
virtual int FindString(const wxString& s, bool bCase = false) const;
virtual wxString GetString(unsigned int n) const;
virtual void SetString(unsigned int n, const wxString& s);
// get the subclassed window proc of the buddy list of choices
WXFARPROC GetBuddyWndProc() const { return m_wndProcBuddy; }
// return the choice object whose buddy is the given window or NULL
static wxChoice *GetChoiceForListBox(WXHWND hwndBuddy);
virtual bool MSWCommand(WXUINT param, WXWORD id);
protected:
virtual int DoInsertItems(const wxArrayStringsAdapter& items,
unsigned int pos,
void **clientData, wxClientDataType type);
virtual void DoSetItemClientData(unsigned int n, void* clientData);
virtual void* DoGetItemClientData(unsigned int n) const;
virtual WXHWND MSWGetItemsHWND() const { return m_hwndBuddy; }
// MSW implementation
virtual void DoGetPosition(int *x, int *y) const;
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual wxSize DoGetBestSize() const;
virtual void DoGetSize(int *width, int *height) const;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const;
// create and initialize the control
bool CreateAndInit(wxWindow *parent, wxWindowID id,
const wxPoint& pos,
const wxSize& size,
int n, const wxString choices[],
long style,
const wxValidator& validator,
const wxString& name);
// the data for the "buddy" list
WXHWND m_hwndBuddy;
WXFARPROC m_wndProcBuddy;
// all existing wxChoice - this allows to find the one corresponding to
// the given buddy window in GetSpinChoiceCtrl()
static wxArrayChoiceSpins ms_allChoiceSpins;
private:
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxChoice);
};
#endif // wxUSE_CHOICE
#endif // _WX_CHOICECE_H_BASE_

57
include/wx/msw/wince/helpwce.h
View File

@@ -1,57 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/helpwce.h
// Purpose: Help system: Windows CE help implementation
// Author: Julian Smart
// Modified by:
// Created: 2003-07-12
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPWCE_H_
#define _WX_HELPWCE_H_
#if wxUSE_HELP
#include "wx/helpbase.h"
class WXDLLIMPEXP_CORE wxWinceHelpController : public wxHelpControllerBase
{
public:
wxWinceHelpController(wxWindow* parentWindow = NULL): wxHelpControllerBase(parentWindow) {}
virtual ~wxWinceHelpController() {}
// Must call this to set the filename
virtual bool Initialize(const wxString& file);
// If file is "", reloads file given in Initialize
virtual bool LoadFile(const wxString& file = wxEmptyString);
virtual bool DisplayContents();
virtual bool DisplaySection(int sectionNo);
virtual bool DisplaySection(const wxString& section);
virtual bool DisplayBlock(long blockNo);
virtual bool DisplayContextPopup(int contextId);
virtual bool DisplayTextPopup(const wxString& text, const wxPoint& pos);
virtual bool KeywordSearch(const wxString& k,
wxHelpSearchMode mode = wxHELP_SEARCH_ALL);
virtual bool Quit();
wxString GetHelpFile() const { return m_helpFile; }
protected:
// Append extension if necessary.
wxString GetValidFilename(const wxString& file) const;
// View topic, or just the HTML file
bool ViewURL(const wxString& topic = wxEmptyString);
private:
wxString m_helpFile;
wxDECLARE_CLASS(wxWinceHelpController);
};
#endif // wxUSE_MS_HTML_HELP
#endif
// _WX_HELPWCE_H_

53
include/wx/msw/wince/libraries.h
View File

@@ -1,53 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/libraries.h
// Purpose: VC++ pragmas for linking against SDK libs
// Author: Vaclav Slavik
// Modified by:
// Created: 2004-04-11
// Copyright: (c) 2004 Vaclav Slavik
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LIBRARIES_H_
#define _WX_LIBRARIES_H_
// NB: According to Microsoft, it is up to the OEM to decide whether
// some of libraries will be included in the system or not. For example,
// MS' STANDARDSDK does not include cyshell.lib and aygshell.lib, while
// Pocket PC 2003 SDK does. We depend on some symbols that are in these
// libraries in some SDKs and in different libs in others. Fortunately we
// can detect what SDK is used in C++ code, so we take advantage of
// VC++'s #pragma to link against the libraries conditionally, instead of
// including libraries in project files.
#if defined(__VISUALC__) && defined(__WXWINCE__)
#if (_WIN32_WCE >= 400) || defined(__POCKETPC__)
// No commdlg.lib in Mobile 5.0 Smartphone
#if !(defined(__SMARTPHONE__) && _WIN32_WCE >= 1200)
#pragma comment(lib,"commdlg.lib")
#endif
#endif
// this library is only available for PocketPC targets using recent SDK and is
// needed for RTTI support
#if (_WIN32_WCE >= 400) && !defined(__WINCE_NET__) && !defined(wxNO_RTTI)
#pragma comment(lib,"ccrtrtti.lib")
#endif
#if defined(__WINCE_STANDARDSDK__)
// DoDragDrop:
#pragma comment(lib,"olece400.lib")
#elif defined(__POCKETPC__) || defined(__SMARTPHONE__) || defined(__WINCE_NET__)
#pragma comment(lib,"ceshell.lib")
#pragma comment(lib,"aygshell.lib")
#elif defined(__HANDHELDPC__)
// Handheld PC builds. Maybe WindowsCE.NET 4.X needs another symbol.
#pragma comment(lib,"ceshell.lib")
#else
#error "Unknown SDK, please fill-in missing pieces"
#endif
#endif // __VISUALC__ && __WXWINCE__
#endif // _WX_LIBRARIES_H_

139
include/wx/msw/wince/missing.h
View File

@@ -1,139 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/missing.h
// Purpose: Missing things in WinCE
// Author: Marco Cavallini
// Modified by:
// Created: 16/11/2002
// Copyright: (c) KOAN SAS ( www.koansoftware.com )
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CE_MISSING_H_
#define _WX_CE_MISSING_H_
#include "wx/msw/private.h"
#include "shellapi.h"
inline BOOL IsIconic( HWND WXUNUSED(hWnd) )
{
// Probably not right...
#if 0
long style = GetWindowLong(hWnd, GWL_STYLE);
return ((style & WS_MINIMIZE) == 0);
#endif
return FALSE;
}
#ifdef __POCKETPC__
#define SM_CXCURSOR 13
#define SM_CYCURSOR 14
#endif
// Missing from eVC 4 for some reason
#ifndef I_IMAGENONE
#define I_IMAGENONE (-2)
#endif
#ifndef TBSTYLE_NO_DROPDOWN_ARROW
#define TBSTYLE_NO_DROPDOWN_ARROW 0x0080
#endif
#ifndef SHCMBM_GETMENU
#define SHCMBM_GETMENU (WM_USER + 402)
#endif
#ifndef SHCMBM_SETSUBMENU
#define SHCMBM_SETSUBMENU (WM_USER + 400) // wparam == id of button, lParam == hmenu, return is old hmenu
#endif
#ifndef SHCMBM_GETSUBMENU
#define SHCMBM_GETSUBMENU (WM_USER + 401) // lParam == ID
#endif
#ifndef LVS_EX_FULLROWSELECT
#define LVS_EX_FULLROWSELECT 0x00000020
#endif
#ifndef TVS_FULLROWSELECT
#define TVS_FULLROWSELECT 0x1000
#endif
#ifndef TVM_SETBKCOLOR
#define TVM_SETBKCOLOR (TV_FIRST + 29)
#define TVM_SETTEXTCOLOR (TV_FIRST + 30)
#endif
// Used in msgdlg.cpp, evtloop.cpp
#ifndef MB_TASKMODAL
#define MB_TASKMODAL 0x2000
#endif
#ifndef HGDI_ERROR
#define HGDI_ERROR ((HANDLE)(0xFFFFFFFFL))
#endif
// some windows styles don't exist in CE SDK, replace them with closest
// equivalents
#ifndef WS_THICKFRAME
#define WS_THICKFRAME WS_BORDER
#endif
#ifndef WS_MINIMIZE
#define WS_MINIMIZE 0
#endif
#ifndef WS_MAXIMIZE
#define WS_MAXIMIZE 0
#endif
// global memory functions don't exist under CE (good riddance, of course, but
// the existing code still uses them in some places, so make it compile)
//
// update: they're defined in eVC 4 inside "#ifdef UNDER_CE" block
#ifndef UNDER_CE
#define GlobalAlloc LocalAlloc
#define GlobalFree LocalFree
#define GlobalSize LocalSize
#define GPTR LPTR
#define GHND LPTR
#define GMEM_MOVEABLE 0
#define GMEM_SHARE 0
#endif // !UNDER_CE
// WinCE RTL doesn't implement bsearch() used in encconv.cpp
extern "C" void *
bsearch(const void *key, const void *base, size_t num, size_t size,
int (wxCMPFUNC_CONV *cmp)(const void *, const void *));
#define O_RDONLY 0x0000 /* open for reading only */
#define O_WRONLY 0x0001 /* open for writing only */
#define O_RDWR 0x0002 /* open for reading and writing */
#define O_APPEND 0x0008 /* writes done at eof */
#define O_CREAT 0x0100 /* create and open file */
#define O_TRUNC 0x0200 /* open and truncate */
#define O_EXCL 0x0400 /* open only if file doesn't already exist */
#define O_TEXT 0x4000 /* file mode is text (translated) */
#define O_BINARY 0x8000 /* file mode is binary (untranslated) */
#ifndef SS_SUNKEN
#define SS_SUNKEN 0x00001000L
#endif
// unsupported flags for WINDOWPOS structure
#ifndef SWP_NOCOPYBITS
#define SWP_NOCOPYBITS 0
#endif
#ifndef SWP_NOOWNERZORDER
#define SWP_NOOWNERZORDER 0
#endif
#ifndef SWP_NOSENDCHANGING
#define SWP_NOSENDCHANGING 0
#endif
#endif // _WX_CE_MISSING_H_

20
include/wx/msw/wince/net.h
View File

@@ -1,20 +0,0 @@
// Copyright 1998, Ben Goetter. All rights reserved.
/*
patch holes in winsock
WCE 2.0 lacks many of the 'database' winsock routines.
Stub just enough them for ss.dll.
getprotobynumber
getservbyport
getservbyname
*/
struct servent * WINSOCKAPI getservbyport(int port, const char * proto) ;
struct servent * WINSOCKAPI getservbyname(const char * name,
const char * proto) ;
struct protoent * WINSOCKAPI getprotobynumber(int proto) ;

26
include/wx/msw/wince/resources.h
View File

@@ -1,26 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/resources.h
// Purpose: identifiers shared between resource compiler and eVC
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 01.05.2004
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// Windows CE dummy menu for SHCreateMenuBar()
#define wxIDM_SHMENU 40000
#define IDM_LEFT 40001
#define IDM_RIGHT 40002
#define IDM_ITEM 40003
#define IDS_EMPTY 40010
#define IDR_POPUP_1 40020
#define IDR_POPUP_2 40021
#define IDR_MENUBAR_ONE_BUTTON 40030
#define IDR_MENUBAR_LEFT_MENU 40031
#define IDR_MENUBAR_RIGHT_MENU 40032
#define IDR_MENUBAR_BOTH_MENUS 40033

1590
include/wx/msw/wince/setup.h
View File

File diff suppressed because it is too large Load Diff

64
include/wx/msw/wince/smartphone.rc
View File

@@ -1,64 +0,0 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/smartphone.rc
// Purpose: resources for MS Smartphone build
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 01.05.2004
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#include <aygshell.h>
STRINGTABLE
BEGIN
IDS_EMPTY ""
END
IDR_POPUP_1 MENU
BEGIN
POPUP ""
BEGIN
MENUITEM "M", IDM_ITEM
END
END
IDR_POPUP_2 MENU
BEGIN
POPUP ""
BEGIN
MENUITEM "M", IDM_ITEM
END
POPUP ""
BEGIN
MENUITEM "M", IDM_ITEM
END
END
IDR_MENUBAR_ONE_BUTTON RCDATA
BEGIN
0,2,
I_IMAGENONE, IDM_LEFT, TBSTATE_ENABLED, TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, NOMENU,
I_IMAGENONE, IDM_RIGHT, TBSTATE_ENABLED, TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, NOMENU,
END
IDR_MENUBAR_LEFT_MENU RCDATA
BEGIN
IDR_POPUP_1,1,
I_IMAGENONE, IDM_LEFT, TBSTATE_ENABLED, TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, 0,
END
IDR_MENUBAR_RIGHT_MENU RCDATA
BEGIN
IDR_POPUP_1,2,
I_IMAGENONE, IDM_LEFT, TBSTATE_ENABLED, TBSTYLE_BUTTON | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, NOMENU,
I_IMAGENONE, IDM_RIGHT, TBSTATE_ENABLED, TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, 0,
END
IDR_MENUBAR_BOTH_MENUS RCDATA
BEGIN
IDR_POPUP_2,2,
I_IMAGENONE, IDM_LEFT, TBSTATE_ENABLED, TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, 0,
I_IMAGENONE, IDM_RIGHT, TBSTATE_ENABLED, TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_EMPTY, 0, 1,
END

169
include/wx/msw/wince/tbarwce.h
View File

@@ -1,169 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/tbarwce.h
// Purpose: Windows CE wxToolBar class
// Author: Julian Smart
// Modified by:
// Created: 2003-07-12
// Copyright: (c) Julian Smart
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_BARWCE_H_
#define _WX_BARWCE_H_
#if wxUSE_TOOLBAR
#include "wx/dynarray.h"
// Smartphones don't have toolbars, so use a dummy class
#ifdef __SMARTPHONE__
class WXDLLIMPEXP_CORE wxToolBar : public wxToolBarBase
{
public:
// ctors and dtor
wxToolBar() { }
wxToolBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr)
{
Create(parent, id, pos, size, style, name);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr);
// override/implement base class virtuals
virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const;
virtual bool Realize() { return true; }
protected:
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable);
virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle);
virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle);
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled,
wxItemKind kind,
wxObject *clientData,
const wxString& shortHelp,
const wxString& longHelp);
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label);
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxToolBar);
wxDECLARE_NO_COPY_CLASS(wxToolBar);
};
#else
// For __POCKETPC__
#include "wx/msw/toolbar.h"
class WXDLLIMPEXP_CORE wxToolMenuBar : public wxToolBar
{
public:
// ctors and dtor
wxToolMenuBar() { Init(); }
wxToolMenuBar(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr,
wxMenuBar* menuBar = NULL)
{
Init();
Create(parent, id, pos, size, style, name, menuBar);
}
bool Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxTB_DEFAULT_STYLE,
const wxString& name = wxToolBarNameStr,
wxMenuBar* menuBar = NULL);
virtual ~wxToolMenuBar();
// override/implement base class virtuals
virtual bool Realize();
// implementation only from now on
// -------------------------------
// Override in order to bypass wxToolBar's overridden function
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
virtual bool MSWCommand(WXUINT param, WXWORD id);
// Return HMENU for the menu associated with the commandbar
WXHMENU GetHMenu();
// Set the wxMenuBar associated with this commandbar
void SetMenuBar(wxMenuBar* menuBar) { m_menuBar = menuBar; }
// Returns the wxMenuBar associated with this commandbar
wxMenuBar* GetMenuBar() const { return m_menuBar; }
protected:
// common part of all ctors
void Init();
// create the native toolbar control
bool MSWCreateToolbar(const wxPoint& pos, const wxSize& size, wxMenuBar* menuBar);
// recreate the control completely
void Recreate();
// implement base class pure virtuals
virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
virtual wxToolBarToolBase *CreateTool(int id,
const wxString& label,
const wxBitmap& bmpNormal,
const wxBitmap& bmpDisabled,
wxItemKind kind,
wxObject *clientData,
const wxString& shortHelp,
const wxString& longHelp);
virtual wxToolBarToolBase *CreateTool(wxControl *control,
const wxString& label);
// The menubar associated with this toolbar
wxMenuBar* m_menuBar;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS(wxToolMenuBar);
wxDECLARE_NO_COPY_CLASS(wxToolMenuBar);
};
#endif
// __SMARTPHONE__
#endif // wxUSE_TOOLBAR
#endif
// _WX_BARWCE_H_

235
include/wx/msw/wince/textctrlce.h
View File

@@ -1,235 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: wx/msw/wince/textctrlce.h
// Purpose: wxTextCtrl implementation for smart phones driven by WinCE
// Author: Wlodzimierz ABX Skiba
// Modified by:
// Created: 30.08.2004
// Copyright: (c) Wlodzimierz Skiba
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_TEXTCTRLCE_H_
#define _WX_TEXTCTRLCE_H_
#include "wx/dynarray.h"
class WXDLLIMPEXP_FWD_CORE wxTextCtrl;
WX_DEFINE_EXPORTED_ARRAY_PTR(wxTextCtrl *, wxArrayTextSpins);
class WXDLLIMPEXP_CORE wxTextCtrl : public wxTextCtrlBase
{
public:
// creation
// --------
wxTextCtrl() { Init(); }
wxTextCtrl(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr)
{
Init();
Create(parent, id, value, pos, size, style, validator, name);
}
virtual ~wxTextCtrl();
bool Create(wxWindow *parent, wxWindowID id,
const wxString& value = wxEmptyString,
const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = 0,
const wxValidator& validator = wxDefaultValidator,
const wxString& name = wxTextCtrlNameStr);
// implement base class pure virtuals
// ----------------------------------
virtual wxString GetValue() const;
virtual void SetValue(const wxString& value) { DoSetValue(value, SetValue_SendEvent); }
virtual void ChangeValue(const wxString &value) { DoSetValue(value); }
virtual wxString GetRange(long from, long to) const;
virtual int GetLineLength(long lineNo) const;
virtual wxString GetLineText(long lineNo) const;
virtual int GetNumberOfLines() const;
virtual bool IsModified() const;
virtual bool IsEditable() const;
virtual void GetSelection(long* from, long* to) const;
// operations
// ----------
// editing
virtual void Clear();
virtual void Replace(long from, long to, const wxString& value);
virtual void Remove(long from, long to);
// load the controls contents from the file
virtual bool LoadFile(const wxString& file);
// clears the dirty flag
virtual void MarkDirty();
virtual void DiscardEdits();
virtual void SetMaxLength(unsigned long len);
// writing text inserts it at the current position, appending always
// inserts it at the end
virtual void WriteText(const wxString& text);
virtual void AppendText(const wxString& text);
// translate between the position (which is just an index in the text ctrl
// considering all its contents as a single strings) and (x, y) coordinates
// which represent column and line.
virtual long XYToPosition(long x, long y) const;
virtual bool PositionToXY(long pos, long *x, long *y) const;
virtual void ShowPosition(long pos);
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt, long *pos) const;
virtual wxTextCtrlHitTestResult HitTest(const wxPoint& pt,
wxTextCoord *col,
wxTextCoord *row) const
{
return wxTextCtrlBase::HitTest(pt, col, row);
}
// Clipboard operations
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual bool CanCopy() const;
virtual bool CanCut() const;
virtual bool CanPaste() const;
// Undo/redo
virtual void Undo();
virtual void Redo();
virtual bool CanUndo() const;
virtual bool CanRedo() const;
// Insertion point
virtual void SetInsertionPoint(long pos);
virtual void SetInsertionPointEnd();
virtual long GetInsertionPoint() const;
virtual wxTextPos GetLastPosition() const;
virtual void SetSelection(long from, long to);
virtual void SetEditable(bool editable);
// Caret handling (Windows only)
bool ShowNativeCaret(bool show = true);
bool HideNativeCaret() { return ShowNativeCaret(false); }
// Implementation from now on
// --------------------------
virtual void Command(wxCommandEvent& event);
virtual bool MSWCommand(WXUINT param, WXWORD id);
virtual void AdoptAttributesFromHWND();
virtual bool AcceptsFocus() const;
// callbacks
void OnDropFiles(wxDropFilesEvent& event);
void OnChar(wxKeyEvent& event); // Process 'enter' if required
void OnCut(wxCommandEvent& event);
void OnCopy(wxCommandEvent& event);
void OnPaste(wxCommandEvent& event);
void OnUndo(wxCommandEvent& event);
void OnRedo(wxCommandEvent& event);
void OnDelete(wxCommandEvent& event);
void OnSelectAll(wxCommandEvent& event);
void OnUpdateCut(wxUpdateUIEvent& event);
void OnUpdateCopy(wxUpdateUIEvent& event);
void OnUpdatePaste(wxUpdateUIEvent& event);
void OnUpdateUndo(wxUpdateUIEvent& event);
void OnUpdateRedo(wxUpdateUIEvent& event);
void OnUpdateDelete(wxUpdateUIEvent& event);
void OnUpdateSelectAll(wxUpdateUIEvent& event);
// Show a context menu for Rich Edit controls (the standard
// EDIT control has one already)
void OnRightClick(wxMouseEvent& event);
// be sure the caret remains invisible if the user
// called HideNativeCaret() before
void OnSetFocus(wxFocusEvent& event);
// get the subclassed window proc of the buddy
WXFARPROC GetBuddyWndProc() const { return m_wndProcBuddy; }
// intercept WM_GETDLGCODE
virtual WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
protected:
// common part of all ctors
void Init();
// call this to increase the size limit (will do nothing if the current
// limit is big enough)
//
// returns true if we increased the limit to allow entering more text,
// false if we hit the limit set by SetMaxLength() and so didn't change it
bool AdjustSpaceLimit();
void DoSetValue(const wxString &value, int flags = 0);
// replace the contents of the selection or of the entire control with the
// given text
void DoWriteText(const wxString& text, int flags = SetValue_SelectionOnly);
// set the selection possibly without scrolling the caret into view
void DoSetSelection(long from, long to, bool scrollCaret = true);
// return true if there is a non empty selection in the control
bool HasSelection() const;
// get the length of the line containing the character at the given
// position
long GetLengthOfLineContainingPos(long pos) const;
// send TEXT_UPDATED event, return true if it was handled, false otherwise
bool SendUpdateEvent();
// override some base class virtuals
virtual void DoMoveWindow(int x, int y, int width, int height);
virtual wxSize DoGetBestSize() const;
virtual WXDWORD MSWGetStyle(long style, WXDWORD *exstyle) const;
// if true, SendUpdateEvent() will eat the next event (see comments in the
// code as to why this is needed)
bool m_suppressNextUpdate;
// all existing wxTextCtrl - this allows to find the one corresponding to
// the given buddy window in GetSpinTextCtrl()
static wxArrayTextSpins ms_allTextSpins;
protected:
// the data for the "buddy" list
WXHWND m_hwndBuddy;
WXFARPROC m_wndProcBuddy;
private:
wxDECLARE_EVENT_TABLE();
wxDECLARE_DYNAMIC_CLASS_NO_COPY(wxTextCtrl);
bool m_isNativeCaretShown;
};
#endif // _WX_TEXTCTRLCE_H_

53
include/wx/msw/wince/time.h
View File

@@ -1,53 +0,0 @@
/*
* time.h
* Missing time functions and structures for use under WinCE
*/
#ifndef _WX_MSW_WINCE_TIME_H_
#define _WX_MSW_WINCE_TIME_H_
#ifndef _TM_DEFINED
#define _TM_DEFINED
struct tm {
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years since 1900 */
int tm_wday; /* days since Sunday - [0,6] */
int tm_yday; /* days since January 1 - [0,365] */
int tm_isdst; /* daylight savings time flag */
};
extern "C"
{
time_t __cdecl time(time_t *);
time_t __cdecl mktime(struct tm *);
// VC8 CRT provides the other functions
#if !defined(__VISUALC__) || (__VISUALC__ < 1400)
struct tm * __cdecl localtime(const time_t *);
struct tm * __cdecl gmtime(const time_t *);
#define _tcsftime wcsftime
size_t __cdecl wcsftime(wchar_t *, size_t, const wchar_t *, const struct tm *);
extern long timezone;
#endif // !VC8
}
#endif // !_TM_DEFINED
#endif // _WX_MSW_WINCE_TIME_H_

15
include/wx/msw/wince/wince.rc
View File

@@ -1,15 +0,0 @@
#include <commctrl.h>
#include "wx/msw/wince/resources.h"
#ifdef WIN32_PLATFORM_WFSP
#include "wx/msw/wince/smartphone.rc"
#else // !smartphone
// Dummy empty menubar/toolbar for WinCE
wxIDM_SHMENU RCDATA DISCARDABLE
BEGIN
wxIDM_SHMENU,
0
END
#endif // smartphone/!smartphone

20
include/wx/msw/window.h
View File

@@ -18,11 +18,7 @@
// resizing complicated window hierarchies, but this can in theory result in
// different behaviour than the old code so we keep the possibility to use it
// by setting this to 0 (in the future this should be removed completely)
#ifdef __WXWINCE__
#define wxUSE_DEFERRED_SIZING 0
#else
#define wxUSE_DEFERRED_SIZING 1
#endif
#define wxUSE_DEFERRED_SIZING 1
// ---------------------------------------------------------------------------
// wxWindow declaration for MSW
@@ -139,11 +135,6 @@ public:
virtual bool UnregisterHotKey(int hotkeyId);
#endif // wxUSE_HOTKEY
#ifdef __POCKETPC__
bool IsContextMenuEnabled() const { return m_contextMenuEnabled; }
void EnableContextMenu(bool enable = true) { m_contextMenuEnabled = enable; }
#endif
// window handle stuff
// -------------------
@@ -188,9 +179,6 @@ public:
// --------------
void OnPaint(wxPaintEvent& event);
#ifdef __WXWINCE__
void OnInitDialog(wxInitDialogEvent& event);
#endif
public:
// Windows subclassing
@@ -486,7 +474,7 @@ public:
return InheritsBackgroundColour();
}
#if !defined(__WXWINCE__) && !defined(__WXUNIVERSAL__)
#if !defined(__WXUNIVERSAL__)
#define wxHAS_MSW_BACKGROUND_ERASE_HOOK
#endif
@@ -719,10 +707,6 @@ protected:
#endif // wxUSE_DEFERRED_SIZING
private:
#ifdef __POCKETPC__
bool m_contextMenuEnabled;
#endif
wxDECLARE_DYNAMIC_CLASS(wxWindowMSW);
wxDECLARE_NO_COPY_CLASS(wxWindowMSW);
wxDECLARE_EVENT_TABLE();

21
include/wx/msw/winundef.h
View File

@@ -365,13 +365,9 @@
#ifdef IsMaximized
#undef IsMaximized
inline BOOL IsMaximized(HWND WXUNUSED_IN_WINCE(hwnd))
inline BOOL IsMaximized(HWND hwnd)
{
#ifdef __WXWINCE__
return FALSE;
#else
return IsZoomed(hwnd);
#endif
}
#endif
@@ -379,13 +375,9 @@
#ifdef GetFirstChild
#undef GetFirstChild
inline HWND GetFirstChild(HWND WXUNUSED_IN_WINCE(hwnd))
inline HWND GetFirstChild(HWND hwnd)
{
#ifdef __WXWINCE__
return 0;
#else
return GetTopWindow(hwnd);
#endif
}
#endif
@@ -462,15 +454,6 @@
#endif
#if defined(__WXWINCE__) && defined(DrawIcon) //#ifdef DrawIcon
#undef DrawIcon
inline BOOL DrawIcon(HDC hdc, int x, int y, HICON hicon)
{
return DrawIconEx(hdc,x,y,hicon,0,0,0,NULL, DI_NORMAL) ;
}
#endif
// GetWindowProc
//ifdef GetWindowProc
// #undef GetWindowProc

6
include/wx/msw/wrapcctl.h
View File

@@ -19,13 +19,9 @@
#include "wx/msw/missing.h"
// Set Unicode format for a common control
inline void wxSetCCUnicodeFormat(HWND WXUNUSED_IN_WINCE(hwnd))
inline void wxSetCCUnicodeFormat(HWND hwnd)
{
#ifndef __WXWINCE__
::SendMessage(hwnd, CCM_SETUNICODEFORMAT, wxUSE_UNICODE, 0);
#else // !__WXWINCE__
// here it should be already in Unicode anyhow
#endif // __WXWINCE__/!__WXWINCE__
}
#if wxUSE_GUI

2
include/wx/msw/wrapcdlg.h
View File

@@ -17,7 +17,7 @@
#include "wx/msw/private.h"
#include "wx/msw/missing.h"
#if wxUSE_COMMON_DIALOGS && !defined(__SMARTPHONE__)
#if wxUSE_COMMON_DIALOGS
#include <commdlg.h>
#endif

7
include/wx/msw/wrapshl.h
View File

@@ -13,13 +13,6 @@
#include "wx/msw/wrapwin.h"
#ifdef __WXWINCE__
#include <winreg.h>
#include <objbase.h>
#include <shlguid.h>
#include <shellapi.h>
#endif
#include <shlobj.h>
#include "wx/msw/winundef.h"

9
include/wx/msw/wrapwin.h
View File

@@ -43,11 +43,6 @@
#define _WIN32_IE 0x0700
#endif
/* Deal with clash with __WINDOWS__ include guard */
#if defined(__WXWINCE__) && defined(__WINDOWS__)
#undef __WINDOWS__
#endif
// For IPv6 support, we must include winsock2.h before winsock.h, and
// windows.h include winsock.h so do it before including it
#if wxUSE_IPV6
@@ -56,10 +51,6 @@
#include <windows.h>
#if defined(__WXWINCE__) && !defined(__WINDOWS__)
#define __WINDOWS__
#endif
// #undef the macros defined in winsows.h which conflict with code elsewhere
#include "wx/msw/winundef.h"

4
include/wx/msw/wx.rc
View File

@@ -11,10 +11,6 @@
#include <windows.h>
#if defined(_WIN32_WCE)
#include "wx/msw/wince/wince.rc"
#endif
#include "wx/msw/rcdefs.h"
//////////////////////////////////////////////////////////////////////////////