Kaydet (Commit) 09aaa188 authored tarafından Caolán McNamara's avatar Caolán McNamara

TaskBar is never constructed

üst c936fcf8
...@@ -128,7 +128,6 @@ $(eval $(call gb_Library_add_exception_objects,svt,\ ...@@ -128,7 +128,6 @@ $(eval $(call gb_Library_add_exception_objects,svt,\
svtools/source/control/stdctrl \ svtools/source/control/stdctrl \
svtools/source/control/stdmenu \ svtools/source/control/stdmenu \
svtools/source/control/tabbar \ svtools/source/control/tabbar \
svtools/source/control/taskbar \
svtools/source/control/taskbox \ svtools/source/control/taskbox \
svtools/source/control/taskmisc \ svtools/source/control/taskmisc \
svtools/source/control/taskstat \ svtools/source/control/taskstat \
......
...@@ -35,7 +35,6 @@ ...@@ -35,7 +35,6 @@
#include <vcl/toolbox.hxx> #include <vcl/toolbox.hxx>
#include <vcl/status.hxx> #include <vcl/status.hxx>
class TaskBar;
class TaskStatusFieldItem; class TaskStatusFieldItem;
struct ImplTaskSBFldItem; struct ImplTaskSBFldItem;
...@@ -81,39 +80,6 @@ benachrichtigt werden will, wenn die Uhrzeit oder die TaskStatusBar ...@@ -81,39 +80,6 @@ benachrichtigt werden will, wenn die Uhrzeit oder die TaskStatusBar
angeklickt wird. Wenn der Notify fuer die Uhrzeit kommt, ist die angeklickt wird. Wenn der Notify fuer die Uhrzeit kommt, ist die
Id TASKSTATUSBAR_CLOCKID, wenn er fuer die TaskStatusBar kommt, ist Id TASKSTATUSBAR_CLOCKID, wenn er fuer die TaskStatusBar kommt, ist
die Id 0. die Id 0.
TaskBar
=======
Erlaubte StyleBits
------------------
WB_BORDER - Border an der oberen Kante
WB_SIZEABLE - Zwischen TaskToolBox und TaskStatusBar kann der Anwender
die Groesse aendern.
Wenn WB_SIZEABLE gesetzt ist, kann die Breite des StatusBars gesetzt und
abgefragt werden. Dazu kann man SetStatusSize()/GetStatusSize() aufrufen.
0 steht dabei fuer optimale Groesse, was auch der Default ist. Bei einem
Doppelklick auf den Trenner kann der Anwender auch wieder die optimale
Groesse einstellen.
Wichtige Methoden
------------------
virtual TaskToolBox* TaskBar::CreateButtonBar();
virtual TaskToolBox* TaskBar::CreateTaskToolBox();
virtual TaskStatusBar* TaskBar::CreateTaskStatusBar();
Diese Methoden muesste man ueberladen, wenn man eine eigene Klasse anlegen
will.
void TaskBar::ShowStatusText( const String& rText );
void TaskBar::HideStatusText();
Blendet den ButtonBar und die TaskBar ein bzw. aus um den Hilfetexte in der
gesammten Zeile anzuzeigen.
*/ */
// ----------------- // -----------------
...@@ -122,10 +88,7 @@ gesammten Zeile anzuzeigen. ...@@ -122,10 +88,7 @@ gesammten Zeile anzuzeigen.
class TaskButtonBar : public ToolBox class TaskButtonBar : public ToolBox
{ {
friend class TaskBar;
private: private:
TaskBar* mpNotifyTaskBar;
void* mpDummy1; void* mpDummy1;
void* mpDummy2; void* mpDummy2;
void* mpDummy3; void* mpDummy3;
...@@ -151,11 +114,8 @@ public: ...@@ -151,11 +114,8 @@ public:
class SVT_DLLPUBLIC TaskToolBox : public ToolBox class SVT_DLLPUBLIC TaskToolBox : public ToolBox
{ {
friend class TaskBar;
private: private:
ImplTaskItemList* mpItemList; ImplTaskItemList* mpItemList;
TaskBar* mpNotifyTaskBar;
Point maContextMenuPos; Point maContextMenuPos;
size_t mnOldItemCount; size_t mnOldItemCount;
long mnMaxTextWidth; long mnMaxTextWidth;
...@@ -267,11 +227,8 @@ public: ...@@ -267,11 +227,8 @@ public:
class SVT_DLLPUBLIC TaskStatusBar : public StatusBar class SVT_DLLPUBLIC TaskStatusBar : public StatusBar
{ {
friend class TaskBar;
private: private:
ImplTaskSBItemList* mpFieldItemList; ImplTaskSBItemList* mpFieldItemList;
TaskBar* mpNotifyTaskBar;
ITaskStatusNotify* mpNotify; ITaskStatusNotify* mpNotify;
Time maTime; Time maTime;
XubString maTimeText; XubString maTimeText;
...@@ -309,82 +266,6 @@ public: ...@@ -309,82 +266,6 @@ public:
ITaskStatusNotify* GetNotifyObject() const { return mpNotify; } ITaskStatusNotify* GetNotifyObject() const { return mpNotify; }
}; };
// -----------
// - TaskBar -
// -----------
class SVT_DLLPUBLIC TaskBar : public Window
{
private:
TaskButtonBar* mpButtonBar;
TaskToolBox* mpTaskToolBox;
TaskStatusBar* mpStatusBar;
void* mpDummy1;
void* mpDummy2;
void* mpDummy3;
void* mpDummy4;
String maOldText;
long mnStatusWidth;
long mnMouseOff;
long mnOldStatusWidth;
long mnDummy1;
long mnDummy2;
long mnDummy3;
long mnDummy4;
WinBits mnWinBits;
sal_uInt16 mnLines;
sal_Bool mbStatusText;
sal_Bool mbShowItems;
sal_Bool mbAutoHide;
sal_Bool mbAlignDummy1;
sal_Bool mbDummy1;
sal_Bool mbDummy2;
sal_Bool mbDummy3;
sal_Bool mbDummy4;
Link maTaskResizeHdl;
#ifdef _TASKBAR_CXX
SVT_DLLPRIVATE void ImplInitSettings();
SVT_DLLPRIVATE void ImplNewHeight( long nNewHeight );
#endif
public:
TaskBar( Window* pParent, WinBits nWinStyle = WB_BORDER | WB_SIZEABLE );
~TaskBar();
virtual void TaskResize();
virtual TaskButtonBar* CreateButtonBar();
virtual TaskToolBox* CreateTaskToolBox();
virtual TaskStatusBar* CreateTaskStatusBar();
virtual void MouseMove( const MouseEvent& rMEvt );
virtual void MouseButtonDown( const MouseEvent& rMEvt );
virtual void Tracking( const TrackingEvent& rMEvt );
virtual void Paint( const Rectangle& rRect );
virtual void Resize();
virtual void StateChanged( StateChangedType nType );
virtual void DataChanged( const DataChangedEvent& rDCEvt );
void Format();
sal_uInt16 GetLines() const { return mnLines; }
sal_Bool IsAutoHideEnabled() const { return mbAutoHide; }
void SetStatusSize( long nNewSize )
{ mnStatusWidth=nNewSize; Resize(); }
long GetStatusSize() const { return mnStatusWidth; }
Size CalcWindowSizePixel() const;
TaskButtonBar* GetButtonBar() const;
TaskToolBox* GetTaskToolBox() const;
TaskStatusBar* GetStatusBar() const;
void SetTaskResizeHdl( const Link& rLink ) { maTaskResizeHdl = rLink; }
const Link& GetTaskResizeHdl() const { return maTaskResizeHdl; }
};
#endif // _TASKBAR_HXX #endif // _TASKBAR_HXX
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org 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. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#define _TASKBAR_CXX
#include <vcl/floatwin.hxx>
#include <svtools/taskbar.hxx>
#define TASKBAR_BORDER 2
#define TASKBAR_OFFSIZE 3
#define TASKBAR_OFFX 2
#define TASKBAR_OFFY 1
#define TASKBAR_BUTTONOFF 5
#define TASKBAR_AUTOHIDE_HEIGHT 2
// =======================================================================
TaskBar::TaskBar( Window* pParent, WinBits nWinStyle ) :
Window( pParent, WB_3DLOOK )
{
mpButtonBar = NULL;
mpTaskToolBox = NULL;
mpStatusBar = NULL;
mnStatusWidth = 0;
mnOldStatusWidth = 0;
mnLines = 1;
mnWinBits = nWinStyle;
mbStatusText = sal_False;
mbShowItems = sal_False;
mbAutoHide = sal_False;
ImplInitSettings();
}
// -----------------------------------------------------------------------
TaskBar::~TaskBar()
{
if ( mpButtonBar )
delete mpButtonBar;
if ( mpTaskToolBox )
delete mpTaskToolBox;
if ( mpStatusBar )
delete mpStatusBar;
}
// -----------------------------------------------------------------------
void TaskBar::ImplInitSettings()
{
const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
Color aColor;
if ( IsControlBackground() )
aColor = GetControlBackground();
else if ( Window::GetStyle() & WB_3DLOOK )
aColor = rStyleSettings.GetFaceColor();
else
aColor = rStyleSettings.GetWindowColor();
SetBackground( aColor );
}
// -----------------------------------------------------------------------
void TaskBar::ImplNewHeight( long nNewHeight )
{
long nOldHeight = GetSizePixel().Height();
if ( nNewHeight != nOldHeight )
{
long nY = GetPosPixel().Y()-(nNewHeight-nOldHeight);
SetPosSizePixel( 0, nY, 0, nNewHeight,
WINDOW_POSSIZE_Y | WINDOW_POSSIZE_HEIGHT );
TaskResize();
}
}
// -----------------------------------------------------------------------
void TaskBar::TaskResize()
{
maTaskResizeHdl.Call( this );
}
// -----------------------------------------------------------------------
TaskButtonBar* TaskBar::CreateButtonBar()
{
return new TaskButtonBar( this );
}
// -----------------------------------------------------------------------
TaskToolBox* TaskBar::CreateTaskToolBox()
{
return new TaskToolBox( this );
}
// -----------------------------------------------------------------------
TaskStatusBar* TaskBar::CreateTaskStatusBar()
{
return new TaskStatusBar( this );
}
// -----------------------------------------------------------------------
void TaskBar::MouseMove( const MouseEvent& rMEvt )
{
if ( mnWinBits & WB_SIZEABLE )
{
TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
TaskStatusBar* pTempStatusBar = GetStatusBar();
if ( pTempTaskToolBox && pTempStatusBar )
{
long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
long nMouseX = rMEvt.GetPosPixel().X();
PointerStyle ePtrStyle;
if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
ePtrStyle = POINTER_HSIZEBAR;
else
ePtrStyle = POINTER_ARROW;
Pointer aPtr( ePtrStyle );
SetPointer( aPtr );
}
}
}
// -----------------------------------------------------------------------
void TaskBar::MouseButtonDown( const MouseEvent& rMEvt )
{
if ( rMEvt.IsLeft() && (mnWinBits & WB_SIZEABLE) )
{
TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
TaskStatusBar* pTempStatusBar = GetStatusBar();
if ( pTempTaskToolBox && pTempStatusBar )
{
long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
long nMouseX = rMEvt.GetPosPixel().X();
if ( (nMouseX >= nStatusX-1) && (nMouseX <= nStatusX+3) )
{
if ( rMEvt.GetClicks() == 2 )
{
if ( mnStatusWidth )
{
mnStatusWidth = 0;
Resize();
}
}
else
{
StartTracking();
mnOldStatusWidth = mnStatusWidth;
mnMouseOff = nMouseX-nStatusX;
}
}
}
}
}
// -----------------------------------------------------------------------
void TaskBar::Tracking( const TrackingEvent& rTEvt )
{
if ( rTEvt.IsTrackingEnded() )
{
if ( rTEvt.IsTrackingCanceled() )
{
mnStatusWidth = mnOldStatusWidth;
Resize();
Update();
}
}
else
{
Size aSize = GetOutputSizePixel();
long nMouseX = rTEvt.GetMouseEvent().GetPosPixel().X()-mnMouseOff;
if ( nMouseX < 0 )
nMouseX = 0;
long nMaxX = aSize.Width()-TASKBAR_OFFX-TASKBAR_OFFSIZE-1;
if ( nMouseX > nMaxX )
nMouseX = nMaxX;
mnStatusWidth = aSize.Width()-nMouseX-TASKBAR_OFFX-TASKBAR_OFFSIZE;
Resize();
Update();
}
}
// -----------------------------------------------------------------------
void TaskBar::Paint( const Rectangle& rRect )
{
if ( mnWinBits & (WB_BORDER | WB_SIZEABLE) )
{
const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
Size aSize = GetOutputSizePixel();
long nY = 0;
if ( mnWinBits & WB_BORDER )
{
SetLineColor( rStyleSettings.GetShadowColor() );
DrawLine( Point( 0, 0 ), Point( aSize.Width()-1, 0 ) );
SetLineColor( rStyleSettings.GetLightColor() );
DrawLine( Point( 0, 1 ), Point( aSize.Width()-1, 1 ) );
nY += 2;
}
if ( (mnWinBits & WB_SIZEABLE) )
{
//TaskButtonBar* pTempButtonBar = GetButtonBar();
TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
TaskStatusBar* pTempStatusBar = GetStatusBar();
if ( pTempTaskToolBox && pTempStatusBar )
{
long nStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
if ( nStatusX > 0 )
{
SetLineColor( rStyleSettings.GetShadowColor() );
DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
nStatusX++;
SetLineColor( rStyleSettings.GetLightColor() );
DrawLine( Point( nStatusX, nY ), Point( nStatusX, aSize.Height()-1 ) );
}
}
}
}
Window::Paint( rRect );
}
// -----------------------------------------------------------------------
void TaskBar::Resize()
{
if ( !IsReallyShown() )
return;
TaskButtonBar* pTempButtonBar = GetButtonBar();
TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
TaskStatusBar* pTempStatusBar = GetStatusBar();
Point aToolPos( TASKBAR_OFFX, 0 );
Size aSize = GetOutputSizePixel();
Size aStatusSize;
Size aToolSize( aSize.Width()-(TASKBAR_OFFX*2), 0 );
long nOldStatusX = -1;
long nNewStatusX = -1;
long nTaskHeight = aSize.Height() - (TASKBAR_OFFY*2);
if ( mnWinBits & WB_BORDER )
{
nTaskHeight -= TASKBAR_BORDER;
aToolPos.Y() += TASKBAR_BORDER;
}
if ( pTempButtonBar )
{
sal_uInt16 i = 0;
sal_Bool bVisibleItems = sal_False;
while ( i < pTempButtonBar->GetItemCount() )
{
if ( pTempButtonBar->IsItemVisible( pTempButtonBar->GetItemId( i ) ) )
{
bVisibleItems = sal_True;
break;
}
i++;
}
if ( mbStatusText || !bVisibleItems )
pTempButtonBar->Hide();
else
{
Size aButtonBarSize = pTempButtonBar->CalcWindowSizePixel();
if ( pTempButtonBar->GetItemCount() )
nTaskHeight = aButtonBarSize.Height();
else
aButtonBarSize.Height() = nTaskHeight;
Point aTempPos = aToolPos;
aTempPos.Y() += (aSize.Height()-aButtonBarSize.Height()-aTempPos.Y())/2;
pTempButtonBar->SetPosSizePixel( aTempPos, aButtonBarSize );
pTempButtonBar->Show();
aToolPos.X() += aButtonBarSize.Width()+TASKBAR_BUTTONOFF;
}
}
if ( pTempStatusBar )
{
aStatusSize = pTempStatusBar->CalcWindowSizePixel();
if ( mnStatusWidth )
aStatusSize.Width() = mnStatusWidth;
if ( !pTempTaskToolBox || mbStatusText )
aStatusSize.Width() = aSize.Width();
long nMaxHeight = aSize.Height()-(TASKBAR_OFFY*2);
if ( mnWinBits & WB_BORDER )
nMaxHeight -= TASKBAR_BORDER;
if ( nMaxHeight+2 > aStatusSize.Height() )
aStatusSize.Height() = nMaxHeight;
Point aPos( aSize.Width()-aStatusSize.Width(), 0 );
if ( pTempTaskToolBox && (mnWinBits & WB_SIZEABLE) && !mbStatusText )
{
long nMinToolWidth = aToolPos.X()+50;
if ( aPos.X() < nMinToolWidth )
{
aStatusSize.Width() -= nMinToolWidth-aPos.X();
aPos.X() = nMinToolWidth;
}
}
if ( aPos.X() < 0 )
{
aStatusSize.Width() = aSize.Width();
aPos.X() = 0;
}
if ( mnWinBits & WB_BORDER )
aPos.Y() += TASKBAR_BORDER;
aPos.Y() += (aSize.Height()-aStatusSize.Height()-aPos.Y())/2;
if ( mnWinBits & WB_SIZEABLE )
{
if ( pTempTaskToolBox )
{
nOldStatusX = pTempStatusBar->GetPosPixel().X()-TASKBAR_OFFSIZE-2;
nNewStatusX = aPos.X()-TASKBAR_OFFSIZE-2;
}
}
pTempStatusBar->SetPosSizePixel( aPos, aStatusSize );
pTempStatusBar->Show();
aToolSize.Width() = aPos.X()-aToolPos.X()-TASKBAR_OFFX;
if ( mnWinBits & WB_SIZEABLE )
aToolSize.Width() -= (TASKBAR_OFFSIZE*2)-2;
}
if ( pTempTaskToolBox )
{
if ( aToolSize.Width() <= 24 )
pTempTaskToolBox->Hide();
else
{
aToolSize.Height() = pTempTaskToolBox->CalcWindowSizePixel().Height();
if ( pTempTaskToolBox->GetItemCount() )
nTaskHeight = aToolSize.Height();
else
aToolSize.Height() = nTaskHeight;
aToolPos.Y() += (aSize.Height()-aToolSize.Height()-aToolPos.Y())/2;
pTempTaskToolBox->SetPosSizePixel( aToolPos, aToolSize );
pTempTaskToolBox->Show();
}
}
if ( nOldStatusX != nNewStatusX )
{
if ( nOldStatusX > 0 )
{
Rectangle aRect( nOldStatusX, 0, nOldStatusX+2, aSize.Height()-1 );
Invalidate( aRect );
}
if ( nNewStatusX > 0 )
{
Rectangle aRect( nNewStatusX, 0, nNewStatusX+2, aSize.Height()-1 );
Invalidate( aRect );
}
}
}
// -----------------------------------------------------------------------
void TaskBar::StateChanged( StateChangedType nType )
{
Window::StateChanged( nType );
if ( nType == STATE_CHANGE_INITSHOW )
Format();
else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
{
ImplInitSettings();
Invalidate();
}
else if ( nType == STATE_CHANGE_FORMAT )
{
ImplInitSettings();
ImplNewHeight( CalcWindowSizePixel().Height() );
Format();
Invalidate();
}
}
// -----------------------------------------------------------------------
void TaskBar::DataChanged( const DataChangedEvent& rDCEvt )
{
Window::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
(rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
(rDCEvt.GetFlags() & SETTINGS_STYLE)) )
{
// Asyncronen StateChanged ausloesen, damit sich die
// TaskBar an die neuen Groessen der Child-Fenster
// orientieren kann
PostStateChanged( STATE_CHANGE_FORMAT );
}
}
// -----------------------------------------------------------------------
void TaskBar::Format()
{
ImplNewHeight( CalcWindowSizePixel().Height() );
Resize();
}
// -----------------------------------------------------------------------
Size TaskBar::CalcWindowSizePixel() const
{
TaskButtonBar* pTempButtonBar = GetButtonBar();
TaskToolBox* pTempTaskToolBox = GetTaskToolBox();
TaskStatusBar* pTempStatusBar = GetStatusBar();
Size aSize;
long nTempHeight;
if ( pTempButtonBar && pTempButtonBar->GetItemCount() )
aSize.Height() = pTempButtonBar->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
if ( pTempTaskToolBox && pTempTaskToolBox->GetItemCount() )
{
nTempHeight = pTempTaskToolBox->CalcWindowSizePixel().Height()+(TASKBAR_OFFY*2);
if ( nTempHeight > aSize.Height() )
aSize.Height() = nTempHeight;
}
if ( pTempStatusBar )
{
nTempHeight = pTempStatusBar->GetSizePixel().Height();
if ( nTempHeight > aSize.Height() )
aSize.Height() = nTempHeight;
}
if ( mnWinBits & WB_BORDER )
aSize.Height() += TASKBAR_BORDER;
return aSize;
}
// -----------------------------------------------------------------------
TaskButtonBar* TaskBar::GetButtonBar() const
{
if ( !mpButtonBar )
((TaskBar*)this)->mpButtonBar = ((TaskBar*)this)->CreateButtonBar();
return mpButtonBar;
}
// -----------------------------------------------------------------------
TaskToolBox* TaskBar::GetTaskToolBox() const
{
if ( !mpTaskToolBox )
((TaskBar*)this)->mpTaskToolBox = ((TaskBar*)this)->CreateTaskToolBox();
return mpTaskToolBox;
}
// -----------------------------------------------------------------------
TaskStatusBar* TaskBar::GetStatusBar() const
{
if ( !mpStatusBar )
{
((TaskBar*)this)->mpStatusBar = ((TaskBar*)this)->CreateTaskStatusBar();
if ( mpStatusBar )
mpStatusBar->mpNotifyTaskBar = (TaskBar*)this;
}
return mpStatusBar;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
...@@ -130,7 +130,6 @@ TaskStatusBar::TaskStatusBar( Window* pParent, WinBits nWinStyle ) : ...@@ -130,7 +130,6 @@ TaskStatusBar::TaskStatusBar( Window* pParent, WinBits nWinStyle ) :
maTime( 0, 0, 0 ) maTime( 0, 0, 0 )
{ {
mpFieldItemList = NULL; mpFieldItemList = NULL;
mpNotifyTaskBar = NULL;
mpNotify = NULL; mpNotify = NULL;
mnClockWidth = 0; mnClockWidth = 0;
mnItemWidth = 0; mnItemWidth = 0;
......
...@@ -358,7 +358,6 @@ SwpHtStart::Insert(SwTxtAttr const**, unsigned short) ...@@ -358,7 +358,6 @@ SwpHtStart::Insert(SwTxtAttr const**, unsigned short)
SwpHtStart::Insert(SwpHtStart const*, unsigned short, unsigned short) SwpHtStart::Insert(SwpHtStart const*, unsigned short, unsigned short)
SwpHtStart::Remove(SwTxtAttr const*&, unsigned short) SwpHtStart::Remove(SwTxtAttr const*&, unsigned short)
SystemChildWindow::SystemChildWindow(Window*, ResId const&) SystemChildWindow::SystemChildWindow(Window*, ResId const&)
TaskBar::TaskBar(Window*, long)
TaskStatusFieldItem::TaskStatusFieldItem() TaskStatusFieldItem::TaskStatusFieldItem()
TempFile::IsValid() const TempFile::IsValid() const
TextEngine::GetLeftMargin() const TextEngine::GetLeftMargin() const
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment