/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#ifndef ESWTWIDGETSCORE_H

#define ESWTWIDGETSCORE_H

#include <eikmenup.h>

#include <eikmenub.h>

#include <eikmobs.h>

#include <eikspane.h>

#include "eswtgraphics.h"

class CEikScrollBar;

#ifdef RD_SCALABLE_UI_V2

class CAknStylusPopUpMenu;

#endif //RD_SCALABLE_UI_V2

class MSwtButton;

class MSwtCaptionedControl;

class MSwtCommand;

class MSwtComposite;

class MSwtControl;

class MSwtMenu;

class MSwtMenuItem;

class MSwtShell;

class MSwtMobileShell;

class MSwtDecorations;

class MAknsControlContext;

class MSwtBrowser;

class MSwtListBase;

class MSwtColor;

class CSwtFontData;

class CGraphicsContext;

class MSwtInput;

class MSwtScreen;

class MSwtMultiPagePager;

class MSwtMultiPageTabGroup;

class MSwtMultiPageDialog;

class MSwtDateEditor;

class MSwtConstrainedText;

class MSwtLink;

class MSwtListBox;

class MSwtListView;

class MSwtSortedList;

class MSwtTextExtension;

class MSwtClipboard;

class MSwtTableColumn;

class MSwtTableItem;

class MSwtTable;

class MSwtTree;

class MSwtFontDialog;

class MSwtDirectoryDialog;

class MSwtHyperLink;

static const TInt KSwtCommandBaseId = 0x1000;

/**

 * Interface class for the org.eclipse.swt.widgets.ScrollBar class

 */

class MSwtScrollBar

{

protected:

    virtual ~MSwtScrollBar() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Disposes of (i.e. destroys) the scroll-bar

     * @return The Java peer associated with this object

     */

    virtual TSwtPeer Dispose() =0;

    /**

     * Returns the scroll-bar'size

     */

    virtual TSize GetSize() const =0;

    /**

     * Enables or disables the scrollbar

     */

    virtual void SetEnabled(TBool aEnabled) =0;

    /**

     * Enables or disables the scrollbar visibility

     */

    virtual void SetVisible(TBool aVisible) =0;

    /**

     * Returns the thumb's position

     */

    virtual TInt GetThumbPosition() const =0;

    /**

     * Sets the thumb's position

     * @param aPosition The thumb's new position, if the provided value is out

     *                  of range, it must be adjusted to fit.

     */

    virtual void SetThumbPositionL(TInt aPosition) =0;

    /**

     * Returns the thumb's span

     */

    virtual TInt GetThumbSpan() const =0;

    /**

     * Sets the thumb's span

     * @param aThumbSpan The thumb's new span, will be >= 1. If the provided value

     *                   is larger than (maximum-minimum) it must be ignored.

     */

    virtual void SetThumbSpanL(TInt aThumbSpan) =0;

    /**

     * Returns the minimum value

     */

    virtual TInt GetMinimum() const =0;

    /**

     * Sets the minimum value of the scroll span

     * @param aMinimum The new minimum, will be >= 0. If the provided value is

     *                 greater than or equal to the maximum, it must be ignored.

     */

    virtual void SetMinimumL(TInt aMinimum) =0;

    /**

     * Returns the maximum value

     */

    virtual TInt GetMaximum() const =0;

    /**

     * Sets the maximum value of the scroll span

     * @param aMaximum The new maximum, wil be >= 0. If the provided value is

     *                 less than or equal to the minimum, it must be ignored.

     */

    virtual void SetMaximumL(TInt aMaximum) =0;

    /**

     * Returns the increment

     */

    virtual TInt GetIncrement() const =0;

    /**

     * Sets the increment

     * @param aIncrement The new increment, will be >= 1.

     */

    virtual void SetIncrement(TInt aIncrement) =0;

    /**

     * Returns the page increment.

     */

    virtual TInt GetPageIncrement() const =0;

    /**

     * Sets the page increment

     * @param aPageIncrement The new page increment, will be >= 1.

     */

    virtual void SetPageIncrement(TInt aPageIncrement) =0;

    /**

     * Sets all parameters in once

     */

    virtual void SetValuesL(TInt aPosition, TInt aMinimum, TInt aMaximum,

                            TInt aThumbSpan, TInt aIncrement, TInt aPageIncrement) =0;

};

/**

 * Type for an array of controls

 */

typedef RPointerArray<MSwtControl> RSwtControlArray;

/**

 * Interface class for the org.eclipse.swt.widgets.Control class

 */

class MSwtControl : public MSwtWindowDrawable

{

protected:

    virtual ~MSwtControl() {} // Made protected to prevent destruction through the interface

public:

    /**

     * Mask values for the utility flags

     * Flags are such that the default value is 0

     */

    enum TFlagMask

    {

        EFlagDoNotDraw    = 0x01, // The control must not be drawn

        EFlagInvisible    = 0x02, // The control is invisible

        EFlagDisabled     = 0x04, // The control is disabled (grayed, dimmed)

        EFreeFlagStart    = 0x08  // The first flag available for custom use

    };

    enum TFocusBackgroundPolicy

    {

        // Composite use case, no visual indication of focus

        ENoFocusBackground = 0,

        // Normal use case, draw focus background if the Control has focus

        // and there is at least another focusable Control in same Shell.

        EDefaultFocusBackground,

        // Button use case, the Control's focus background is owned by Avkon

        EEmbeddedFocusBackground,

        // Captioned Controls use case, default focus background policy

        // applies to itself and children

        ECaptionedCtrlFocusBackground

    };

public:

    /**

     * Disposes of (i.e. destroys) the control

     * @return The Java peer associated with this object

     */

    virtual TSwtPeer Dispose() =0;

    /**

     * Returns the Java peer associated with this object

     */

    virtual TSwtPeer JavaPeer() const =0;

    /**

     * Returns a pointer to the underlying Cone control used for the

     * actual implementation.

     */

    virtual CCoeControl& CoeControl() =0;

    /**

     * Returns a const pointer to the underlying Cone control used for the

     * actual implementation.

     */

    virtual const CCoeControl& CoeControl() const =0;

    /**

     * Returns the control's utility flags

     * <b>Note</b>: this method is a convenience aimed to be used for the

     * implementation of MSwtComposite. If the implementation on a

     * given platform does use utility flags, this method can return any value.

     */

    virtual TUint Flags() const =0;

    /**

     * Indicate if the control has the flag EFlagDoNotDraw.

     * @return True if the Control has the EFlagDoNotDraw flag, else EFalse.

     */

    virtual TBool HasDoNotDrawFlag() const =0;

    /**

     * Instructs the control to paint itself

     *

     * @param aRect The rectangle to draw, in screen coordinates.

     * @param aPaintNatively Whether the native CCoeControl::Draw should be called before flushing

     *                       the buffered operations

     * @param aGc The GC that was passed into the paint listener

     * @param aIntParam An array of buffered opcodes and integer parameters from gc operations

     *                  done in the paint listener

     * @param aIntCount The Number of items in aIntParams array

     * @param aStrParam Buffered string parameters from gc operations done in the paint listener

     */

    virtual void Paint(const TRect& aRect,

                       TBool aPaintNatively = ETrue,

                       MSwtGc* aGc = NULL,

                       TInt* aIntParams = NULL,

                       TInt aIntCount = 0,

                       HBufC* aStrParams = NULL) const =0;

    /**

     * Emergency native paint. Ignores Java GCs.

     * Window redraw must be started before calling this and stopped after.

     *

     * @param aRect The rectangle to draw, in window coordinates.

     */

    virtual void PaintUrgently(const TRect& aRect, TBool aInitDraw = ETrue) const =0;

    /**

     * Ignoring the Java paint requests and draws directly for the time being.

     */

    virtual TBool IsPaintingUrgently() const = 0;

    /**

     * Processes a key event

     */

    virtual void ProcessKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType) =0;

    /**

     * Handles the pointer events.

     * @param aPointerEvent pointer event to process

     */

    virtual void HandlePointerEventL(const TPointerEvent& aPointerEvent)=0;

    /**

     * Determines if a control is suitable for receiving focus.

     * Invisible or disabled controls can never be focused, not even with

     * KSwtFocusByForce. Shells cannot be focused just activated.

     */

    virtual TBool IsFocusable(TInt aReason = KSwtFocusByApi) const =0;

    /**

     * Attempts to make this control the one that receives focus.

     * If this control or a descendant takes focus, true is returned. Composites

     * attempt to assign focus to their children before taking focus themselves.

     * Some controls, such as labels, do not normally take focus. A control will

     * not take focus if it is disabled or hidden or when input is blocked due to

     * modality.

     * In case of KSwtFocusByForce, forces the control to receive keyboard events.

     * Controls that do not normally accept keyboard input will take focus

     * using this KSwtFocusByForce.

     * @return Whether this control has focus upon method exit.

     */

    virtual TBool SetSwtFocus(TInt aReason = KSwtFocusByApi) =0;

    /**

     * Returns the policy of the focus background.

     * See TFocusBackgroundPolicy.

     */

    virtual TInt FocusBackgroundPolicy() const =0;

    /**

     * Returns true if the control is selectable by the user and is not dimmed

     */

    virtual TBool GetEnabled() const =0;

    /**

     * If this function returns true it does not mean that the control should

     * be visible for the user. The parent migh be invisible in which case this

     * control should not be visible to the user or draw itself. So this function

     * returns only the internal visibility state of this controll without paying

     * attention to the combined visibility of its ancestors.

     * Use GetVisibleRecursively() to determine if the control is really visible.

     */

    virtual TBool GetVisible() const =0;

    /**

     * Except Shells, controls are shown if themeselves and their parent are visible.

     */

    virtual TBool GetVisibleRecursively() const =0;

    /**

     * Indicate if the default system colour was use for the background.

     * @return Returns Etrue if the default system colour was use for the background,

     * otherwise EFalse if a color background setted.

     */

    virtual TBool IsDefaultBackgroundUse() const = 0;

    /**

     * Returns the control context of the Control.

     * @return Returns the control context of the Control define by the control

     * or NULL or there is no specific control context..

     */

    virtual MAknsControlContext* GetControlContext() const =0;

    /**

     * Returns the control background color

     * @return The control background color

     */

    virtual TRgb GetBackground() const = 0;

    /**

     * Returns the control foreground color

     * @return The control foreground color

     */

    virtual TRgb GetForeground() const = 0;

    /**

     * Sets the color of the control's background.

     * @param aColor The colour to set the background to, if NULL

     *               the default colour will be used.

     */

    virtual void SetBackgroundL(const MSwtColor* aColor) =0;

    /**

     * Sets the color of the control's text.

     * @param aColor The colour to set the foreground to, if NULL

     *               the default colour will be used.

     */

    virtual void SetForegroundL(const MSwtColor* aColor) =0;

    /**

     * Returns the control font used for writing text

     * @return The control's font, cannot be NULL

     */

    virtual const MSwtFont* GetFont() const =0;

    /**

     * Gets the control's border width

     * @return The control's border width

     */

    virtual TInt GetBorderWidth() const =0;

    /**

     * Returns the client rectangle (i.e. the part without scroll-bars, borders

     *        and other decorations) of this Control

     * The client area returned is in window coordinates.

     */

    virtual TRect ClientRect() const =0;

    /**

     * Gets the control's bounding rectangle

     * @return The control's coordinates relative to its parent, or in screen

     *         coordinates if it has no parent. Shells always return screen

     *         coordinates.

     */

    virtual TRect GetBounds() const =0;

    /**

     * Gets the control's position.

     * @return The control's position relative to its parent, or in screen

     *         coordinates if it has no parent. Shells always return screen

     *         coordinates.

     */

    virtual TPoint GetLocation() const =0;

    /**

     * Returns the control's popup menu

     */

    virtual const MSwtMenu* GetPopupMenu() const =0;

    /**

     * Returns the control's native menu

     */

    virtual const MSwtMenu* GetControlMenu() const =0;

    /**

     * Returns the control parent

     */

    virtual MSwtComposite* GetParent() const =0;

    /**

     * Check if aParent is in the parent hierarchy.

     */

    virtual TBool IsDescentOf(const MSwtControl& aParent) const =0;

    /**

     * Get the closest parent Shell of the Control

     */

    virtual MSwtShell& GetShell() const =0;

    /**

     * Get the top Shell of the Control

     */

    virtual MSwtShell& GetTopShell() const =0;

    /**

     * Get the top CaptionedControl of the Control, if any

     */

    virtual MSwtCaptionedControl* GetTopCaptionedControl() const =0;

    /**

     * Gets the control's width and height;

     */

    virtual TSize GetWidgetSize() const =0;

    /**

     * Returns true if we have UI focus, false otherwise

     */

    virtual TBool IsFocusControl() =0;

    /**

     * Moves this control above aControl in the drawing order

     */

    virtual void MoveAbove(const MSwtControl* aControl) =0;

    /**

     * Moves this control below aControl in the drawing order

     */

    virtual void MoveBelow(const MSwtControl* aControl) =0;

    /**

     * Redraws the entire control

     */

    virtual void Redraw() =0;

    /**

     * Updates DoNotDraw flag after a call to setRedraw

     */

    virtual void UpdateDoNotDrawFlag() =0;

    /**

     * Redraws the specified area of the control

     * @param aRect The rectangle to redraw, in client area coordinates.

     */

    virtual void RedrawRegion(const TRect& aRect) =0;

    /**

     * Enables or disables future redraw requests

     */

    virtual void SetRedraw(TBool aRedraw) =0;

    /**

     * Sets the font of the control.

     * @param aFont The font to use, if NULL a default font is to be used.

     */

    virtual void SetFontL(const MSwtFont* aFont) =0;

    /**

     * Sets the visibility status of the control

     */

    virtual void SetVisible(TBool aVisible) =0;

    /**

     * Sets the Control's location

     * @param aPoint The new location; in the parent's coordinates, in screen

     *        coordinates for Shells.

     */

    virtual void SetLocation(const TPoint& aPoint) =0;

    /**

     * Sets the Control's size

     *

     * @param aSize The new size.

     */

    virtual void SetWidgetSize(const TSize& aSize) =0;

    /**

     * Compute the preferred size.

     */

    virtual TSize ComputeSizeL(TInt aWHint, TInt aHHint) = 0;