/usr/include/cwidget/widgets/text_layout.h is in libcwidget-dev 0.5.16-3.5ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 | // text_layout.h -*-c++-*-
//
// Copyright (C) 2004-2005, 2007 Daniel Burrows
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// This program 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
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; see the file COPYING. If not, write to
// the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
// Boston, MA 02111-1307, USA.
#ifndef TEXT_LAYOUT_H
#define TEXT_LAYOUT_H
#include "widget.h"
#include <cwidget/fragment_contents.h>
namespace cwidget
{
class fragment;
namespace widgets
{
/** Code to display formatted text.
*
* The text to display is composed of a tree of "fragments". A
* fragment stores some amount of text; at any time, it can be
* formatted to a particular width. The main layout mechanisms
* provided are flowboxes and clipboxes: flowboxes word-wrap their
* contents to a particular width, while clipboxes clip their
* contents to a particular width. These boxes can be nested, if the
* user feels like it for some reason or other, although some
* nestings are non-sensical (for instance, placing a flowbox inside
* a smaller flowbox is likely to lead to really ugly text).
*
* This provides some primitive layout mechanisms; higher-level
* layouts can be expressed in terms of these.
*/
class text_layout : public widget
{
protected:
text_layout();
text_layout(fragment *f);
public:
/** Create an empty text_layout. */
static util::ref_ptr<text_layout> create()
{
util::ref_ptr<text_layout> rval(new text_layout);
rval->decref();
return rval;
}
/** Create a text_layout with the given root fragment.
*
* All fragments are implicitly placed within a clipbox of width
* equal to the width of this widget.
*/
static util::ref_ptr<text_layout> create(fragment *f)
{
util::ref_ptr<text_layout> rval(new text_layout(f));
rval->decref();
return rval;
}
/** Handle the given keypress. Returns \b true if the keystroke
* was "consumed" by this widget.
*/
bool handle_key(const config::key &k);
void dispatch_mouse(short id, int x, int y, int z, mmask_t bstate);
/** Change the fragment being displayed in this layout widget. */
void set_fragment(fragment *f);
/** Append the given fragment to the current fragment.
*
* \note this is slightly less efficient than placing the two
* fragments into the text_layout up-front via a single
* sequence_fragment. Normally this isn't a problem, but if you
* want to append hundreds of fragments this way, it might be.
*
* \todo this is only needed for memory-management reasons
* (otherwise I could safely extract the current fragment and
* create my own sequence). Would refcounting help?
*
* \todo if this becomes very useful, it would be better to just
* explicitly store a sequence of fragments in the layout.
*/
void append_fragment(fragment *f);
/** Return the requested width of this widget. The requested width
* will be the largest possible width of any line.
*/
int width_request();
/** Return the requested height of this widget given its width, by
* running the fragment-layout algorithm.
*/
int height_request(int w);
/** Return \b true iff the cursor is visible in this widget. */
bool get_cursorvisible();
/** Return the location of the cursor in this widget. */
point get_cursorloc();
/** Return \b true iff this widget should be given focus. */
bool focus_me();
/** Paint this widget. */
void paint(const style &st);
/** Move the view one line down. */
void line_down();
/** Move the view one line up. */
void line_up();
/** Move the view to the top of the widget. */
void move_to_top();
/** Move the view to the bottom of the widget. */
void move_to_bottom();
/** Move a page forward. */
void page_down();
/** Move a page back. */
void page_up();
/** Search either forwards or backwards for the string s. The
* search will start on either the next or the previous line
* from the top of the screen.
*/
void search_for(const std::wstring &s,
bool search_forwards);
/** Page based on a scrollbar signal.
*
* \param dir the direction to page: if \b true, call page_up();
* else call page_down().
*/
void scroll(bool dir);
/** Delete the root fragment. */
~text_layout();
/** A signal that is called whenever the "location" of the view
* within the text changes.
*/
sigc::signal2<void, int, int> location_changed;
static config::keybindings *bindings;
static void init_bindings();
private:
/** Move the starting location of the widget. */
void set_start(unsigned int new_start);
/** Update the cached contents of the widget, if necessary. */
void freshen_contents(const style &st);
/** Called when this needs layout. */
void layout_me();
/** Emits the above signal based on the present location of the display. */
void do_signal();
/** The line which is currently at the top of the widget. */
size_t start;
/** The root fragment of this layout. This is always a clipbox. */
fragment *f;
/** Cache the current contents of the widget. */
fragment_contents contents;
/** If \b true, the current cached contents need to be updated. */
bool stale;
/** The width of the widget the last time we updated the cached contents. */
int lastw;
/** The enclosing display style the last time we updated the cached contents. */
style lastst;
};
typedef util::ref_ptr<text_layout> text_layout_ref;
}
}
#endif
|