frame_window.h

Go to the documentation of this file.

//    __                                            _             _                  _      //
//   / _| _ __  __ _  _ __ ___    ___    __      __(_) _ __    __| |  ___ __      __| |__   //
//  | |_ | '__|/ _` || '_ ` _ \  / _ \   \ \ /\ / /| || '_ \  / _` | / _ \\ \ /\ / /| '_ \  //
//  |  _|| |  | (_| || | | | | ||  __/    \ V  V / | || | | || (_| || (_) |\ V  V /_| | | | //
//  |_|  |_|   \__,_||_| |_| |_| \___|_____\_/\_/  |_||_| |_| \__,_| \___/  \_/\_/(_)_| |_| //
//                                   |_____|                                                //
//                                                                                          //
//    a top-level window that can have menus, toolbars, a status bar, and a client area     //
//               (multiple-document versions have tabs and child frames)                    //
//                                                                                          //

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

    X11workbench - X11 programmer's 'work bench' application and toolkit
    Copyright (c) 2010-2019 by Bob Frazier (aka 'Big Bad Bombastic Bob')


  DISCLAIMER:  The X11workbench application and toolkit software are supplied
               'as-is', with no warranties, either implied or explicit.
               Any claims to alleged functionality or features should be
               considered 'preliminary', and might not function as advertised.

  MIT-like license:

  There is no restriction as to what you can do with this software, so long
  as you include the above copyright notice and DISCLAIMER for any distributed
  work that is equal to or derived from this one, along with this paragraph
  that explains the terms of the license if the source is also being made
  available.  A "derived work" describes a work that uses a significant portion
  of the source files or algorithms that are included with this one.
  Specifically excluded from this are files that were generated by the software,
  or anything that is included with the software that is part of another package
  (such as files that were created or added during the 'configure' process).
  Specifically included is the use of part or all of any of the X11 workbench
  toolkit source or header files in your distributed application.  If you do not
  ship the source, the above copyright statement is still required to be placed
  in a reasonably prominent place, such as documentation, splash screens, and/or
  'about the application' dialog boxes.

  Use and distribution are in accordance with GPL, LGPL, and/or the above
  MIT-like license.  See COPYING and README files for more information.


  Additional information at http://sourceforge.net/projects/X11workbench

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


#ifndef FRAME_WINDOW_H_INCLUDED
#define FRAME_WINDOW_H_INCLUDED

#include <inttypes.h> // needed for intptr_t, uintptr_t among other things

//#include "window_helper.h"
#include "window_dressing.h"
#include "menu_bar.h"

#ifdef __cplusplus
extern "C" {
#endif // __cplusplus



#define FRAME_WINDOW_TAG (*((const unsigned int *)"FWFW"))


typedef struct tagWB_FW_MENU_HANDLER
{
  uintptr_t lMenuID;                       

  int (* callback)(XClientMessageEvent *);     

  int (* UIcallback)(WBMenu *, WBMenuItem *);
} WBFWMenuHandler;



typedef struct tagWB_FRAME_WINDOW
{
  unsigned int ulTag;                  
  Window wID;                          
  int iFlags;                          

  int iClientX;                        
  int iClientY;                        
  int iClientWidth;                    
  int iClientHeight;                   

} WBFrameWindow;



enum WBFrameWindow_FLAGS
{

  WBFrameWindow_APP_WINDOW = 1,   
  WBFrameWindow_VISIBLE    = 2,   
  WBFrameWindow_NO_TABS    = 4,   
  WBFrameWindow_STATUS_BAR = 8,   

  WBFrameWindow_MAX = 0x80000000L 
};

enum WBStatusTabInfo_FLAGS
{
  WBStatusTabInfo_MASK          = 0x0fffffff, 
  WBStatusTabInfo_BREAK         = 0x10000000, 
  WBStatusTabInfo_JUSTIFY_MASK  = 0x6fffffff, 
  WBStatusTabInfo_JUSTIFY_LEFT  = 0x00000000, 
  WBStatusTabInfo_JUSTIFY_CENTER= 0x20000000, 
  WBStatusTabInfo_JUSTIFY_RIGHT = 0x40000000, 
  WBStatusTabInfo_JUSTIFY_res6  = 0x60000000, 
  WBStatusTabInfo_RTL_COLUMN    = 0x80000000, 
};


// NOTE:  WBChildFrame and WBChildFrameUI are defined HERE to avoid circular header file dependencies
// (also defining supporting structs for same reason)

struct tagWBChildFrameUI; // forward declaration

typedef struct tagWBChildFrame
{
  unsigned int ulTag;               
  Window wID;                       
  WBFrameWindow *pOwner;            
  WB_FONT pFont;                    

  WB_GEOM geom;                     
  WB_GEOM geomEntire;               
  WB_POINT origin;                  
  WB_EXTENT extent;                 

  int iRowHeight;                   
  int iColWidth;                    

  WB_SCROLLINFO scroll;             

  int iSplit;                       

  WB_SCROLLINFO scrollSplit;        

  int fFlags;                       

  char *szDisplayName;              
  Atom aImageAtom;                  

  char *szStatusText;               

  char *pszMenuResource;            
  WBFWMenuHandler *pMenuHandler;    
  int iContextMenuID;               

  WBWinEvent pUserCallback;         
  void (*destructor)(struct tagWBChildFrame *);  
  struct tagWBChildFrameUI *pUI;   

  struct tagWBChildFrame *pNext;   
} WBChildFrame;


typedef struct tagWBChildFrameUI
{
  unsigned int ulTag;                                       
  void (*do_char)(WBChildFrame *, XClientMessageEvent *);   
  void (*scancode)(WBChildFrame *, XClientMessageEvent *);  
  void (*bkspace)(WBChildFrame *, int iACS);                
  void (*del)(WBChildFrame *, int iACS);                    
  void (*tab)(WBChildFrame *, int iACS);                    
  void (*enter)(WBChildFrame *, int iACS);                  
  void (*properties)(WBChildFrame *);                       
  void (*uparrow)(WBChildFrame *, int iACS);                
  void (*downarrow)(WBChildFrame *, int iACS);              
  void (*leftarrow)(WBChildFrame *, int iACS);              
  void (*rightarrow)(WBChildFrame *, int iACS);             
  void (*home)(WBChildFrame *, int iACS);                   
  void (*end)(WBChildFrame *, int iACS);                    
  void (*pgup)(WBChildFrame *, int iACS);                   
  void (*pgdown)(WBChildFrame *, int iACS);                 
  void (*pgleft)(WBChildFrame *, int iACS);                 
  void (*pgright)(WBChildFrame *, int iACS);                
  void (*help)(WBChildFrame *, int iACS);                   
  void (*hover_notify)(WBChildFrame *, int x, int y);       
  void (*hover_cancel)(WBChildFrame *);                     
  int (*is_ins_mode)(WBChildFrame *);                       
  void (*toggle_ins_mode)(WBChildFrame *);                  
  void (*copy_to_cb)(WBChildFrame *);                       
  void (*paste_from_cb)(WBChildFrame *);                    
  void (*cut_to_cb)(WBChildFrame *);                        
  void (*delete_sel)(WBChildFrame *);                       
  void (*select_all)(WBChildFrame *);                       
  void (*select_none)(WBChildFrame *);                      
  void (*save)(WBChildFrame *, const char *szFileName);     

  WB_PCSTR (* get_file_name)(WBChildFrame *);               

  void (*mouse_click)(WBChildFrame *, int iX, int iY,
                      int iButtonMask, int iACS);           
  void (*mouse_dblclick)(WBChildFrame *, int iX, int iY,
                         int iButtonMask, int iACS);        
  void (*mouse_drag)(WBChildFrame *, int iX, int iY,
                     int iButtonMask, int iACS);            
  void (*mouse_drop)(WBChildFrame *, int iX, int iY,
                     int iButtonMask, int iACS);            
  void (*mouse_move)(WBChildFrame *, int iX, int iY);       

  void (*scroll_vert)(WBChildFrame *, int iMode, int iValue); 
  void (*scroll_horiz)(WBChildFrame *, int iMode, int iValue);

  void (*mouse_cancel)(WBChildFrame *);                     
  void (*get_row_col)(WBChildFrame *, int *piR, int *piC);  
  int (*has_selection)(WBChildFrame *);                     
  void (*undo)(WBChildFrame *);                             
  void (*redo)(WBChildFrame *);                             
  int (*can_undo)(WBChildFrame *);                          
  int (*can_redo)(WBChildFrame *);                          
  int (*is_empty)(WBChildFrame *);                          

} WBChildFrameUI;




enum WBChildFrame_FLAGS
{
  WBChildFrame_NO_TAB = 1,        
  WBChildFrame_PIXELS = 2,        
  WBChildFrame_VSPLIT = 4,        
  WBChildFrame_HSPLIT = 8,        
  WBChildFrame_SPLIT_MASK = 12,   
  WBChildFrame_SPLIT_NOSIZE = 16, 
};


// FRAME WINDOW ATOMS

#if !defined(_FRAME_WINDOW_C_) && !defined(_CLIPBOARD_HELPER_C)
     /* this declares the atoms 'const' outside of frame_window.c, and does NOT declare them in clipboard_helper.c */
     /* These atoms are GLOBAL variables, assigned by the DEFAULT Display, and may not work for other threads.     */

extern const Atom aTAB_MESSAGE;  // command sent by Client Message related to tabs

#endif // !defined(_FRAME_WINDOW_C_) && !defined(_CLIPBOARD_HELPER_C)





WBFrameWindow *FWCreateFrameWindow(const char *szTitle, int idIcon, const char *szMenuResource,
                                   int iX, int iY, int iWidth, int iHeight,
                                   WBWinEvent pUserCallback, int iFlags);

void FWRecalcLayout(Window wID);  // recalculate layout information (propagates to contained windows)


void FWSetUserCallback(WBFrameWindow *pFW, WBWinEvent pCallBack);


static __inline__ WBFrameWindow *FWGetFrameWindowStruct(Window wID)  // for frame windows, returns the frame window struct
{
  WBFrameWindow *pRval = (WBFrameWindow *)WBGetWindowData(wID, 0);  // offset 0 for window-specific structs

  if(pRval && pRval->ulTag == FRAME_WINDOW_TAG)
  {
    return(pRval);
  }

  return(NULL);
}

void FWDestroyFrameWindow(Window wID);  // destroys frame window using the Window ID (frees the struct also)

void FWDestroyFrameWindow2(WBFrameWindow *pFrameWindow); // destroys it using the struct pointer

void FWSetMenuHandlers(WBFrameWindow *pFrameWindow, const WBFWMenuHandler *pHandlerArray);

#define FW_MENU_HANDLER_BEGIN(X) static const WBFWMenuHandler X[] = {

#define FW_MENU_HANDLER_ENTRY(X,Y,Z) { (unsigned long)X, Y, Z },

#define FW_MENU_HANDLER_END {0, 0, 0} };


// frame window 'contents' functions

int FWGetNumContWindows(const WBFrameWindow *pFrameWindow);

WBChildFrame * FWGetContainedWindowByIndex(const WBFrameWindow *pFrameWindow, int iIndex);

#define FWGetFocusWindow(pFW) (FWGetNumContWindows(pFW) > 0 ? FWGetContainedWindowByIndex(pFW, -1) : NULL)

int FWAddContainedWindow(WBFrameWindow *pFrameWindow, WBChildFrame *pNew);

void FWRemoveContainedWindow(WBFrameWindow *pFrameWindow, WBChildFrame *pCont);

void FWReplaceContainedWindow(WBFrameWindow *pFrameWindow, WBChildFrame *pCont, WBChildFrame *pContNew);

void FWSetFocusWindow(WBFrameWindow *pFrameWindow, WBChildFrame *pCont);

void FWSetFocusWindowIndex(WBFrameWindow *pFrameWindow, int iIndex);

int FWGetChildFrameIndex(WBFrameWindow *pFrameWindow, WBChildFrame *pCont);

void FWMoveChildFrameTabIndex(WBFrameWindow *pFrameWindow, WBChildFrame *pCont, int iIndex);

#define MOVE_CHILD_FRAME_TAB_INDEX_BEGINNING 0

#define MOVE_CHILD_FRAME_TAB_INDEX_RIGHT -2

#define MOVE_CHILD_FRAME_TAB_INDEX_LEFT -1

void FWSetStatusText(WBFrameWindow *pFrameWindow, const char *szText);

void FWSetStatusTabInfo(WBFrameWindow *pFrameWindow, int nTabs, const int *pTabs);

// DEFAULT COLORS AND FONTS

XColor FWGetDefaultFG(void);

XColor FWGetDefaultBG(void);

XColor FWGetDefaultBD(void);

WB_FONTC FWGetFont(WBFrameWindow *pFW);

WB_FONTC FWGetBoldFont(WBFrameWindow *pFW);


#if 0

int FWDoSelectionEvents(WBFrameWindow *pFrameWindow, Window wID, Window wIDMenu, XEvent *pEvent);
#endif // 0


#ifdef __cplusplus
};
#endif // __cplusplus


#endif // FRAME_WINDOW_H_INCLUDED