LgiClasses.h

Go to the documentation of this file.

// Includes
#ifndef __GUI_H
#define __GUI_H

#if defined BEOS
#include <string.h>
#endif

#include "GSemaphore.h"
#include "GLibrary.h"
#include "LgiOsClasses.h"
#include "GArray.h"
#include "LgiCommon.h"
#include "GXmlTree.h"

#ifndef WIN32
#include "GDragAndDrop.h"
#endif

// Externs
extern long MouseWatcher(void *Ptr);
extern bool _lgi_check_file(char *Path);
LgiFunc bool LgiPostEvent(OsView Wnd, int Event, int a = 0, int b = 0);

class LgiClass GTarget
{
public:
    virtual int OnEvent(GMessage *Msg) { return 0; }
};

enum GViewFillFlags
{
    GViewFillReferenceBitmap = 0x0001,
    GViewFillCopyBitmap = 0x0002
};

class LgiClass GViewFill
{
    class GViewFillPriv *d;

public:
    GViewFill(COLOUR c, int Bits = -1);
    GViewFill(GSurface *dc, GViewFillFlags Flags = GViewFillCopyBitmap);
    GViewFill(GViewFill &f);
    virtual ~GViewFill();

    void Fill(GSurface *pDC, GRect *r = 0, GdcPt2 *Origin = 0);
};

#ifdef WIN32
typedef DWORD                       OsProcessId;
#define LgiProcessInst()            (LgiApp->GetInstance())
#else
typedef int                         OsProcessId;
#endif

#define LgiProcessId()              (LgiApp->GetProcessId())

#define LgiApp                      (GApp::ObjInstance())

#define SysFont                     (LgiApp->SystemNormal)

#define SysBold                     (LgiApp->SystemBold)

LgiFunc void LgiExitApp();

#define LgiCloseApp()               LgiApp->Exit(false)

struct GAppArguments
{
    bool NoSkin;
};

class LgiClass GApp : virtual public GAppI, public OsApplication
{
    friend class GView;

protected:
    // private member vars
    class GAppPrivate *d;
    
    #if defined WIN32

    CRITICAL_SECTION StackTraceSync;
    friend LONG __stdcall _ExceptionFilter_Redir(LPEXCEPTION_POINTERS e);
    LONG __stdcall _ExceptionFilter(LPEXCEPTION_POINTERS e);
    friend class GWin32Class;
    List<GWin32Class> *GetClasses();

    #elif defined ATHEOS

    char *_AppFile;

    #elif defined BEOS

    void RefsReceived(BMessage *Msg);
    
    #endif

    friend class GMouseHook;
    static GMouseHook *MouseHook;

public:
    // Static publics
    
    static GApp *ObjInstance();
    static class GSkinEngine *SkinEngine;

    // public member vars
    
    GFont *SystemNormal;
    
    GFont *SystemBold;
    
    GWindow *AppWnd;

    bool IsOk();
    
    OsProcessId GetProcessId();
    
    OsThreadId GetGuiThread();

    GApp
    (
        char *MimeType,
        OsAppArguments &AppArgs,
        GAppArguments *ObjArgs = 0
    );

    virtual ~GApp();

    void SetAppArgs(OsAppArguments &AppArgs);
    
    OsAppArguments *GetAppArgs();

    char *GetArgumentAt(int n);
    
    bool Run
    (
        bool Loop = true
    );
    
    void OnCommandLine();
    
    void OnReceiveFiles(GArray<char*> &Files);
    
    void Exit
    (
        int Code = 0
    );
    
    bool GetOption
    (
        char *Option,
        GArray<char> &Buf
    );

    bool GetOption
    (
        char *Option,
        char *Dst = 0,
        int DstSize = 0
    );
    
    GXmlTag *GetConfig(char *Tag);

    void SetConfig(GXmlTag *Tag);
    
    GViewI *GetFocus();
    
    bool GetFileMimeType
    (
        char *File,
        char *Mime,
        int BufLen
    );
        
    int32 GetMetric
    (
        int Metric
    );

    GMouseHook *GetMouseHook();

    // OS Specific
    #if defined WIN32

    static bool IsWin9x;
    HINSTANCE GetInstance();
    int GetShow();

    #else
    
    bool GetAppsForMimeType(char *Mime, GArray<GAppInfo*> &Apps);

    #endif
};

class LgiClass GView : virtual public GViewI, public GObject
{
    friend      class GWindow;
    friend      class GLayout;
    friend      class GControl;
    friend      class GMenu;
    friend      class GSubMenu;
    friend      class GWnd;
    friend      class GScrollBar;
    friend      class GFileTarget;
    friend      class GDialog;
    friend      class GDragDropTarget;
    friend      class GPopup;

    friend      bool SysOnKey(GView *w, GMessage *m);
    friend      GViewI *GetNextTabStop(GViewI *Wnd, bool Back);

    #if defined WIN32

    friend      LRESULT CALLBACK GWin32Class::Redir(OsView hWnd, UINT m, WPARAM a, LPARAM b);
    friend      LRESULT CALLBACK GWin32Class::SubClassRedir(OsView hWnd, UINT m, WPARAM a, LPARAM b);
    friend      LRESULT CALLBACK DlgRedir(OsView hWnd, UINT m, WPARAM a, LPARAM b);
    static      void CALLBACK TimerProc(OsView hwnd, UINT uMsg, UINT idEvent, uint32 dwTime);

    #elif defined MAC
    
    friend OSStatus CarbonWindowProc(EventHandlerCallRef, EventRef, void *);
    friend OSStatus CarbonControlProc(EventHandlerCallRef, EventRef, void *);
    friend OSStatus GViewProc(EventHandlerCallRef, EventRef, void *);

    #elif defined BEOS

    friend      class GButtonRedir;
    friend      class _OsEditFrame;
    friend      class BViewRedir;
    friend      long _lgi_pulse_thread(void *ptr);

    #elif defined XWIN

    friend      class QView<QWidget>;
    friend      class QView<class QScrollBar>;
    friend      class QView<class QPopup>;
    friend      class QWindow;
    
    #elif defined YWIN
    
    friend      class YView;
    friend      class YWindow;

    #endif

    GRect           Pos;
    class GDragDropTarget *&DropTargetPtr();

protected:
    class GViewPrivate  *d;

    OsView              _View; // OS specific handle to view object
    GView               *_Window;
    GSemaphore          *_Lock;
    int                 _BorderSize;
    int                 WndFlags;

    static GViewI       *_Capturing;
    static GViewI       *_Over;
    
    #if defined WIN32

    uint32 GetStyle();
    void SetStyle(uint32 i);
    uint32 GetExStyle();
    void SetExStyle(uint32 i);
    uint32 GetDlgCode();
    void SetDlgCode(uint32 i);
    char *GetClass();
    void SetClass(char *s);
    GWin32Class *CreateClass(char *Class = 0, HICON Icon = 0, int AddStyles = 0);

    virtual int     SysOnNotify(int Code) { return 0; }

    #elif defined BEOS

    struct OsMouseInfo;
    friend long _lgi_mouse_thread(OsMouseInfo *Info);

    OsMouseInfo     *_MouseInfo;
    OsThread        _CaptureThread;
    OsThread        _PulseThread;
    int             _PulseRate;
    BWindow         *_QuitMe;

    void Sys_KeyDown(const char *bytes, int32 numBytes);
    void Sys_KeyUp(const char *bytes, int32 numBytes);
    void Sys_MouseDown(BPoint point);
    void Sys_MouseMoved(BPoint point, uint32 transit, const BMessage *message);
    void Sys_FrameMoved(BPoint p);
    virtual bool QuitRequested() {}

    #endif

    // Complex Region searches
    
    GRect *FindLargest(GRegion &r);

    GRect *FindSmallestFit(GRegion &r, int Sx, int Sy);

    GRect *FindLargestEdge
    (
        GRegion &r,
        int Edge
    );

    void _Delete();
    GViewI *FindReal(GdcPt2 *Offset = 0);
    bool HandleCapture(GView *Wnd, bool c);
    
    virtual void    _Paint(GSurface *pDC = 0);

    #ifndef WIN32

    GView *&PopupChild();
    virtual void    _Mouse(GMouse &m, bool Move);
    virtual void    OnNcPaint(GSurface *pDC, GRect &r);

    #endif

    bool AddView(GViewI *v, int Where = -1);
    bool DelView(GViewI *v);
    bool HasView(GViewI *v);
    GViewIterator *IterateViews();
    void OnAttach() {}
    virtual bool OnViewMouse(GView *v, GMouse &m) { return true; }
    virtual bool OnViewKey(GView *v, GKey &k) { return false; }

public:
    List<GViewI>    Children;
    
    GEventsI *Script;
    bool OnScriptEvent(GViewI *Ctrl) { return false; }

    GView
    (
        OsView wnd = 0
    );

    virtual ~GView();

    OsView Handle() { return _View; }
    
    virtual OsWindow WindowHandle();

    // Attaching windows / heirarchy
    
    virtual bool Attach
    (
        GViewI *p
    );
    
    virtual bool AttachChildren();
    
    virtual bool Detach();
    
    virtual bool IsAttached();
    
    virtual void Quit(bool DontDelete = false);
    
    // Properties
    
    GWindow *GetWindow();
    
    GViewI *GetParent();

    virtual void SetParent(GViewI *p);

    void SendNotify(int Data = 0);
    
    GViewI *GetNotify();

    virtual void SetNotify(GViewI *n);

    bool Lock
    (
        int TimeOut = -1
    );
    
    void Unlock();

    int OnEvent(GMessage *Msg);

    bool Enabled();
    
    void Enabled(bool e);
    
    bool Visible();
    
    void Visible
    (
        bool v
    );

    bool Focus();
    
    void Focus(bool f);
    
    bool DropTarget();
    
    bool DropTarget(bool t);

    bool Sunken();
    
    void Sunken(bool i);

    bool Flat();
    
    void Flat(bool i);
    
    bool Raised();
    
    void Raised(bool i);

    GViewFill *GetBackgroundFill();

    bool SetBackgroundFill(GViewFill *Fill);

    bool InThread();
    
    bool PostEvent
    (
        int Cmd,
        int a = 0,
        int b = 0
    );

    bool Name(char *n);
    
    char *Name();
    
    virtual bool NameW(char16 *n);

    virtual char16 *NameW();

    virtual GFont *GetFont();
    
    virtual void SetFont(GFont *Fnt, bool OwnIt = false);
    
    bool SetCursor
    (
        int Cursor
    );

    virtual GRect &GetPos() { return Pos; }
    virtual GRect &GetClient();
    virtual bool SetPos(GRect &p, bool Repaint = false);
    int X() { return Pos.X(); }
    int Y() { return Pos.Y(); }
    GdcPt2 GetMinimumSize();
    void SetMinimumSize(GdcPt2 Size);   

    void MoveOnScreen();
    void MoveToCenter();
    void MoveToMouse();

    bool Capture(bool c);
    bool IsCapturing();
    bool GetMouse
    (
        GMouse &m,
        bool ScreenCoords = false
    );

    int GetId();
    void SetId(int i);
    bool GetTabStop();
    void SetTabStop(bool b);
    virtual int Value() { return 0; }
    virtual void Value(int i) {}
    virtual GViewI *FindControl(OsView hnd);
    virtual GViewI *FindControl
    (
        // The ID to look for
        int Id
    );

    int GetCtrlValue(int Id);
    void SetCtrlValue(int Id, int i);
    char *GetCtrlName(int Id);
    void SetCtrlName(int Id, char *s);
    bool GetCtrlEnabled(int Id);
    void SetCtrlEnabled(int Id, bool Enabled);
    bool GetCtrlVisible(int Id);
    void SetCtrlVisible(int Id, bool Visible);

    bool Invalidate
    (
        GRect *r = NULL,
        bool Repaint = false,
        bool NonClient = false
    );

    bool Invalidate
    (
        GRegion *r,
        bool Repaint = false,
        bool NonClient = false
    );

    bool IsOver(GMouse &m);
    GViewI *WindowFromPoint(int x, int y);
    void SetPulse
    (
        int Ms = -1
    );
    void PointToScreen(GdcPt2 &p);
    void PointToView(GdcPt2 &p);
    bool WindowVirtualOffset(GdcPt2 *Offset);   
    GdcPt2 &GetWindowBorderSize();
    virtual bool Pour
    (
        GRegion &r
    ) { return false; }

    void OnMouseClick
    (
        GMouse &m
    );
    void OnMouseEnter
    (
        GMouse &m
    );
    void OnMouseExit
    (
        GMouse &m
    );
    void OnMouseMove
    (
        GMouse &m
    );
    void OnMouseWheel
    (
        double Lines
    );
    bool OnKey(GKey &k);
    void OnCreate();
    void OnDestroy();
    void OnFocus
    (
        bool f
    );
    void OnPulse();
    void OnPosChange();
    bool OnRequestClose
    (
        bool OsShuttingDown
    );
    int OnHitTest
    (
        int x,
        int y
    );
    void OnChildrenChanged(GViewI *Wnd, bool Attaching);
    void OnPaint(GSurface *pDC);
    int OnNotify(GViewI *Ctrl, int Flags);
    int OnCommand(int Cmd, int Event, OsView Wnd);
};

// Control or View window

#define GV_EDGE_TOP             0x0001
#define GV_EDGE_RIGHT           0x0002
#define GV_EDGE_BOTTOM          0x0004
#define GV_EDGE_LEFT            0x0008

#define IDC_VSCROLL             14000

#define IDC_HSCROLL             14001

class LgiClass GLayout : public GView
{
    friend class GScroll;

    // Private variables
    bool            _SettingScrollBars;
    bool            _PourLargest;

protected:
    GScrollBar      *VScroll;

    GScrollBar      *HScroll;

    virtual bool SetScrollBars
    (
        bool x,
        bool y
    );
    
    #ifndef WIN32
    void AttachScrollBars();
    #endif

public:
    GLayout();
    ~GLayout();

    virtual void GetScrollPos(int &x, int &y);
    virtual void SetScrollPos(int x, int y);

    bool GetPourLargest();
    void SetPourLargest(bool i);

    int OnEvent(GMessage *Msg);

    bool Pour(GRegion &r);

    // Impl
    #ifndef WIN32
    bool Attach(GViewI *p);
    GRect &GetClient();
    void OnPosChange();
    int OnNotify(GViewI *c, int f);
    void OnNcPaint(GSurface *pDC, GRect &r);
    #endif
};

#define GIC_OWNER_DRAW              0x0001

#define GIC_ASK_TEXT                0x0002

#define GIC_ASK_IMAGE               0x0004

#define GIC_OWN_LIST                0x0008

class LgiClass GItemContainer
{
protected:
    int Flags;
    GImageList *ImageList;

public:
    GItemContainer();
    ~GItemContainer();

    // Props
    bool OwnerDraw() { return TestFlag(Flags, GIC_OWNER_DRAW); }
    void OwnerDraw(bool b) { if (b) SetFlag(Flags, GIC_OWNER_DRAW); else ClearFlag(Flags, GIC_OWNER_DRAW); }
    bool AskText() { return TestFlag(Flags, GIC_ASK_TEXT); }
    void AskText(bool b) { if (b) SetFlag(Flags, GIC_ASK_TEXT); else ClearFlag(Flags, GIC_ASK_TEXT); }
    bool AskImage() { return TestFlag(Flags, GIC_ASK_IMAGE); }
    void AskImage(bool b) { if (b) SetFlag(Flags, GIC_ASK_IMAGE); else ClearFlag(Flags, GIC_ASK_IMAGE); }

    // Image List
    GImageList *GetImageList() { return ImageList; }
    bool SetImageList(GImageList *List, bool Own = true);
    bool LoadImageList(char *File, int x, int y);
    bool OwnList() { return TestFlag(Flags, GIC_OWN_LIST); }
    void OwnList(bool b) { if (b) SetFlag(Flags, GIC_OWN_LIST); else ClearFlag(Flags, GIC_OWN_LIST); }
};

// Menus
#include "GMenu.h"


enum GWindowZoom
{
    GZoomMin,
    GZoomNormal,
    GZoomMax
};

#define GMouseEvents                0x01

#define GKeyEvents                  0x02

class LgiClass GWindow :
    public GView
#ifndef WIN32
    , public GDragDropTarget
#endif
{
    friend class BViewRedir;
    friend class GView;
    friend class GButton;
    friend class QWindow;
    friend class YWindow;

    bool _QuitOnClose;

protected:
    #ifdef WIN32

    GRect OldPos;
    HWND LastFocus;

    #else

    OsWindow Wnd;
    void _OnViewDelete();
    void _SetDynamic(bool i);

    #endif

    #if defined BEOS

    friend class GMenu;
    friend class GView;

    #elif defined LINUX
    
    void _Paint(GSurface *pDC = 0);
    
    #endif

    GViewI *_Default;

    GMenu *Menu;

    class GWindowPrivate *d;

public:
    GWindow();
    ~GWindow();

    virtual void Pour();

    GMenu *GetMenu() { return Menu; }
    
    void SetMenu(GMenu *m) { Menu = m; }
    
    bool GetQuitOnClose() { return _QuitOnClose; }

    void SetQuitOnClose(bool i) { _QuitOnClose = i; }

    bool GetSnapToEdge();
    void SetSnapToEdge(bool b);
    
    GWindowZoom GetZoom();
    
    void SetZoom(GWindowZoom i);
    
    void Raise();

    void OnPosChange();
    int OnEvent(GMessage *Msg);
    void OnPaint(GSurface *pDC);
    bool HandleViewMouse(GView *v, GMouse &m);
    bool HandleViewKey(GView *v, GKey &k);
    bool OnRequestClose(bool OsShuttingDown);
    bool Visible();
    void Visible(bool i);
    
    bool RegisterHook
    (
        GView *Target,
        int EventType,
        int Priority = 0
    );

    bool UnregisterHook(GView *Target);
    
    virtual void OnZoom(GWindowZoom Action) {}
    
    virtual void OnTrayClick(GMouse &m) {}
    
    virtual void OnReceiveFiles(GArray<char*> &Files) {}

    #ifndef WIN32

    bool Attach(GViewI *p);

    // Props
    OsWindow WindowHandle() { return Wnd; }
    bool Name(char *n);
    char *Name();
    GRect &GetPos();
    bool SetPos(GRect &p, bool Repaint = false);
    GRect &GetClient();
    
    // D'n'd
    int WillAccept(List<char> &Formats, GdcPt2 Pt, int KeyState);
    int OnDrop(char *Format, GVariant *Data, GdcPt2 Pt, int KeyState);

    // Events
    void OnChildrenChanged(GViewI *Wnd, bool Attaching);
    void OnCreate();

    #endif

    GViewI *GetDefault();
    
    void SetDefault(GViewI *v);
};


class LgiClass GToolTip : public GView
{
    class GToolTipPrivate *d;

public:
    GToolTip();
    ~GToolTip();

    int NewTip
    (
        char *Name,
        GRect &Pos
    );
    
    void DeleteTip(int Id);

    bool Attach(GViewI *p);
};

// Dialog stuff
#include "LgiWidgets.h"

// Progress meters stuff
#include "Progress.h"
#include "GProgress.h"

#include "GFileSelect.h"
#include "GFindReplaceDlg.h"
#include "GToolBar.h"
#include "GThread.h"


class LgiClass GSplitter : public GLayout
{
    class GSplitterPrivate *d;

    void        CalcRegions(bool Follow = false);
    bool        OverSplit(int x, int y);

public:
    GSplitter();
    ~GSplitter();

    int Value(); // Use to set/get the split position
    
    void Value(int i);

    bool IsVertical();
    
    void IsVertical(bool v);

    bool DoesSplitFollow();
    
    void DoesSplitFollow(bool i);

    GView *GetViewA();

    void DetachViewA();

    void SetViewA(GView *a, bool Border = true);

    GView *GetViewB();

    void DetachViewB();

    void SetViewB(GView *b, bool Border = true);

    bool Border();
    void Border(bool i);
    GViewI *FindControl(OsView hCtrl);

    bool Attach(GViewI *p);
    bool Pour(GRegion &r);
    void OnPaint(GSurface *pDC);
    void OnPosChange();
    void OnMouseClick(GMouse &m);
    void OnMouseMove(GMouse &m);
    void OnMouseExit(GMouse &m);
    int OnHitTest(int x, int y);
    void OnChildrenChanged(GViewI *Wnd, bool Attaching);
};

#define STATUSBAR_SEPARATOR         4
#define GSP_SUNKEN                  0x0001

class LgiClass GStatusBar : public GLayout
{
    friend class GStatusPane;

protected:
    void RePour();

public:
    GStatusBar();
    ~GStatusBar();

    bool Pour(GRegion &r);
    void OnPaint(GSurface *pDC);

    GStatusPane *AppendPane(char *Text, int Width);
    bool AppendPane(GStatusPane *Pane);
};

class LgiClass GStatusPane :
    public GView
{
    friend class GStatusBar;

protected:
    int     Flags;
    int     Width;
    GSurface *pDC;

public:
    GStatusPane();
    ~GStatusPane();

    char *Name() { return GObject::Name(); }
    bool Name(char *n);
    void OnPaint(GSurface *pDC);

    int GetWidth();
    void SetWidth(int x);
    bool Sunken();
    void Sunken(bool i);
    GSurface *Bitmap();
    void Bitmap(GSurface *pdc);
};

class LgiClass GCommand : public GObject //, public GFlags
{
    int         Flags;
    bool        PrevValue;

public:
    int         Id;
    GToolButton *ToolButton;
    GMenuItem   *MenuItem;
    GKey        *Accelerator;
    char        *TipHelp;
    
    GCommand();
    ~GCommand();

    bool Enabled();
    void Enabled(bool e);
    bool Value();
    void Value(bool v);
};

#include "GClipBoard.h"


class LgiClass GTrayIcon :
    public GObject
    // public GFlags
{
    friend class GTrayWnd;
    class GTrayIconPrivate *d;

public:
    GTrayIcon
    (
        GWindow *p
    );
    
    ~GTrayIcon();

    bool LoadIcon(char *Str);
    
    bool Visible();

    void Visible(bool v);

    int Value();

    void Value(int v);

    virtual int OnEvent(GMessage *Msg);
};

#include "GInput.h"
#include "GPrinter.h"


class LgiClass GAlert : public GDialog
{
public:
    GAlert
    (
        GViewI *parent,
        char *Title,
        char *Text,
        char *Btn1,
        char *Btn2 = 0,
        char *Btn3 = 0
    );

    int OnNotify(GViewI *Ctrl, int Flags);
};

class LgiClass DoEvery
{
    int64 LastTime;
    int64 Period;

public:
    DoEvery
    (
        int p = 1000
    );
    
    void Init
    (
        int p = -1
    );

    bool DoNow();
};

class LgiClass GViewFactory
{
    static List<GViewFactory> *Factories;

    virtual GView *NewView
    (
        char *Class,
        GRect *Pos,
        char *Text
    ) = 0;

public:
    GViewFactory();
    virtual ~GViewFactory();

    static GView *Create(char *Class, GRect *Pos = 0, char *Text = 0);
};


// Colour
LgiFunc void LgiInitColours();
LgiFunc COLOUR LgiColour(int Colour);

// Graphics
LgiFunc void LgiDrawBox(GSurface *pDC, GRect &r, bool Sunken, bool Fill);
LgiFunc void LgiWideBorder(GSurface *pDC, GRect &r, int Type);
LgiFunc void LgiThinBorder(GSurface *pDC, GRect &r, int Type);
LgiFunc void LgiFlatBorder(GSurface *pDC, GRect &r, int Width = -1);

// Helpers

LgiFunc int LgiMsg
(
    GViewI *Parent,
    char *Msg,
    char *Title = 0,
    int Type = MB_OK,
    ...
);

#endif

---