Misplaced Pages

#810189

52-494: Built on the KParts framework and written in C++ , KHTML had relatively good support for Web standards during its prime. Engines forked from KHTML are used by most of the browsers that are widely used today, including WebKit ( Safari ) and Blink ( Google Chrome , Chromium , Microsoft Edge , Opera , Vivaldi and Brave ). KHTML was preceded by an earlier engine called khtmlw or

104-423: A computer program . Historically, a library consisted of subroutines (generally called functions today). The concept now includes other forms of executable code including classes and non-executable data including images and text . It can also refer to a collection of source code . For example, a program could use a library to indirectly make system calls instead of making those system calls directly in

156-468: A Communication Pool (COMPOOL), roughly a library of header files. Another major contributor to the modern library concept came in the form of the subprogram innovation of FORTRAN . FORTRAN subprograms can be compiled independently of each other, but the compiler lacked a linker . So prior to the introduction of modules in Fortran-90, type checking between FORTRAN subprograms was impossible. By

208-559: A feature called smart linking whereby the linker is aware of or integrated with the compiler, such that the linker knows how external references are used, and code in a library that is never actually used , even though internally referenced, can be discarded from the compiled application. For example, a program that only uses integers for arithmetic, or does no arithmetic operations at all, can exclude floating-point library routines. This smart-linking feature can lead to smaller application file sizes and reduced memory usage. Some references in

260-404: A library, a programmer only needs to know high-level information such as what items it contains at and how to use the items – not all of the internal details of the library. Libraries can use other libraries resulting in a hierarchy of libraries in a program. A library of executable code has a well-defined interface by which the functionality is invoked. For example, in C , a library function

312-436: A program are loaded from individual shared objects into memory at load time or runtime , rather than being copied by a linker when it creates a single monolithic executable file for the program. Shared libraries can be statically linked during compile-time, meaning that references to the library modules are resolved and the modules are allocated memory when the executable file is created. But often linking of shared libraries

364-589: A program or library module are stored in a relative or symbolic form which cannot be resolved until all code and libraries are assigned final static addresses. Relocation is the process of adjusting these references, and is done either by the linker or the loader . In general, relocation cannot be done to individual libraries themselves because the addresses in memory may vary depending on the program using them and other libraries they are combined with. Position-independent code avoids references to absolute addresses and therefore does not require relocation. When linking

416-597: A single large package, called kdelibs, in KDE SC 4 . Kdelibs was split into several individual frameworks, some of which are no longer part of KDE but were integrated into Qt 5.2. KDE Frameworks are grouped in four different tiers according to dependency on other libraries. The following image formats have read and write support: Attica is a Qt library that implements the Open Collaboration Services API version 1.6. It grants easy access to

468-553: A single shared library, with multiple backends for it, e.g., Cairo/Qt, etc.). KSVG2 is also a part of WebKit . KHTML was scheduled to be removed in KDE Frameworks 6. Active development ended in 2016, just the necessary maintenance to work with updates to Frameworks 5. It was officially discontinued in 2023. The following standards are supported by the KHTML engine: KHTML and KJS were adopted by Apple in 2002 for use in

520-407: A suffix of .a ( archive , static library) or of .so (shared object, dynamically linked library). Some systems might have multiple names for a dynamically linked library. These names typically share the same prefix and have different suffixes indicating the version number. Most of the names are names for symbolic links to the latest version. For example, on some systems libfoo.so.2 would be

572-558: Is based on Qt 4, while KDE 3 was based on Qt 3. The repository of each framework should contain a file named metainfo.yaml . This file documents the maintainer of the framework, the type, the supported operating system and other information. The currently supported platforms are Linux, Microsoft Windows, macOS and Android. The Frameworks have a clear dependency structure, divided into "categories" and "tiers". The "categories" refer to runtime dependencies: The KDE Frameworks bundle consists of over 70 packages. These existed as

SECTION 10

#1732781051811

624-440: Is created (static linking), or whenever the program is used at runtime (dynamic linking). The references being resolved may be addresses for jumps and other routine calls. They may be in the main program, or in one module depending upon another. They are resolved into fixed or relocatable addresses (from a common base) by allocating runtime memory for the memory segments of each module referenced. Some programming languages use

676-400: Is invoked via C's normal function call capability. The linker generates code to call a function via the library mechanism if the function is available from a library instead of from the program itself. The functions of a library can be connected to the invoking program at different program lifecycle phases . If the code of the library is accessed during the build of the invoking program, then

728-430: Is performed during the creation of an executable or another object file, it is known as static linking or early binding . In this case, the linking is usually done by a linker , but may also be done by the compiler . A static library , also known as an archive , is one intended to be statically linked. Originally, only static libraries existed. Static linking must be performed when any modules are recompiled. All of

780-500: Is postponed until they are loaded. Although originally pioneered in the 1960s, dynamic linking did not reach the most commonly-used operating systems until the late 1980s. It was generally available in some form in most operating systems by the early 1990s. During this same period, object-oriented programming (OOP) was becoming a significant part of the programming landscape. OOP with runtime binding requires additional information that traditional libraries do not supply. In addition to

832-662: The DOM specification, finally announcing on August 16, 1999 that he had checked in what amounted to a complete rewrite of the KHTML library—changing KHTML to use the standard DOM as its internal document representation. That in turn allowed the beginnings of JavaScript support to be added in October 1999, followed shortly afterwards with the integration of KJS by Harri Porten . In the closing months of 1999 and first few months of 2000, Knoll did further work with Antti Koivisto and Dirk Mueller to add CSS support and to refine and stabilize

884-615: The Safari web browser. Apple publishes the source code for their fork of the KHTML engine, called WebKit . In 2013, Google began development on a fork of WebKit, called Blink . KParts KDE Frameworks is a collection of libraries and software frameworks readily available to any Qt -based software stacks or applications on multiple operating systems . Featuring frequently needed functionality solutions like hardware integration, file format support, additional graphical control elements , plotting functions, and spell checking ,

936-536: The KDE HTML Widget , developed by Torben Weis and Martin Jones, which implemented support for HTML 3.2, HTTP 1.0, and HTML frames , but not the DOM , CSS , or JavaScript . KHTML itself came into existence on November 4, 1998, as a fork of the khtmlw library, with some slight refactoring and the addition of Unicode support and changes to support the move to Qt 2. Waldo Bastian was among those who did

988-401: The KHTML architecture, with most of that work being completed by March 2000. Among other things, those changes enabled KHTML to become the second browser after Internet Explorer to correctly support Hebrew and Arabic and languages written right-to-left —before Mozilla had such support. KDE 2.0 was the first KDE release (on October 23, 2000) to include KHTML (as the rendering engine of

1040-562: The applications. Starting with Qt 5, this platform was transformed into a set of modules that is now referred to as KDE Frameworks. These modules include: Solid , Nepomuk , Phonon , etc. and are licensed either under the LGPL, BSD license, MIT License or X11 license. Besides the KDE Software Compilation , there are other adopters such as the desktop environments LXQt , MoonLightDE or Hawaii. Version 3.0 of Krita ,

1092-539: The collection serves as the technological foundation for KDE Plasma and KDE Gear . It is distributed under the GNU Lesser General Public License (LGPL). KDE Frameworks is based on Qt, which enables a more widespread use of QML , a simpler JavaScript -based declarative programming language, for the design of user interfaces. The graphics rendering engine used by QML allows for more fluid user interfaces across different devices. Since

SECTION 20

#1732781051811

1144-478: The data limits specified for the plot. You change the limits by calling `setLimits(double x1, double x2, double y1, double y2)`. Data to be plotted are stored using the KPlotObject class. KPlotObject consists of a QList of QPointF's, each specifying the X,Y coordinates of a data point. KPlotObject also specifies the "type" of data to be plotted (POINTS or CURVE or POLYGON or LABEL). The core of Kross provides

1196-556: The dependencies to external libraries in build configuration files (such as a Maven Pom in Java). Another library technique uses completely separate executables (often in some lightweight form) and calls them using a remote procedure call (RPC) over a network to another computer. This maximizes operating system re-use: the code needed to support the library is the same code being used to provide application support and security for every other program. Additionally, such systems do not require

1248-532: The engine would have a library of its own." In 1947 Goldstine and von Neumann speculated that it would be useful to create a "library" of subroutines for their work on the IAS machine , an early computer that was not yet operational at that time. They envisioned a physical library of magnetic wire recordings , with each wire storing reusable computer code. Inspired by von Neumann, Wilkes and his team constructed EDSAC . A filing cabinet of punched tape held

1300-536: The filename for the second major interface revision of the dynamically linked library libfoo . The .la files sometimes found in the library directories are libtool archives, not usable by the system as such. The system inherits static library conventions from BSD , with the library stored in a .a file, and can use .so -style dynamically linked libraries (with the .dylib suffix instead). Most libraries in macOS, however, consist of "frameworks", placed inside special directories called " bundles " which wrap

1352-645: The following technologies: Many bindings weren't updated to Qt5 and KF5 or only later in the release cycle. The 5.0 release was preceded by a technology preview, two alpha releases, and three beta releases. The source code of KDE Frameworks has been around since KDElibs 1. The first release as KDE Frameworks was with version 5, to account for the fact that the code base was that of KDE Platform version 4 (the only major version of KDE Platform ). The transition from KDE Platform to KDE Frameworks began in August 2013, guided by top KDE technical contributors. After

1404-485: The framework to deal transparently with interpreter-back-ends and offers abstract functionality to deal with scripts. Kirigami is a QML application framework developed by Marco Martin that enables developers to write applications that run natively on Android, iOS, Windows, Plasma Mobile and any classic Linux desktop environment without code adjustments. It is used by various applications, for example Linus Torvalds and Dirk Hohndels' scuba diving application Subsurface,

1456-500: The initial release of KDE Frameworks 5.0, the developers focused on adding new features to the components in KDE Frameworks 5, an example being better integration of Firefox into KDE. The major improvement of Frameworks 5 is its modularization. In earlier KDE versions, the libraries were bundled as a single large package. In Frameworks, the libraries were split into individual smaller packages. This facilitates utilization of

1508-439: The instantiated objects residing only in memory (although potentially able to be made persistent in separate files). In others, like Smalltalk , the class libraries are merely the starting point for a system image that includes the entire state of the environment, classes and all instantiated objects. Today most class libraries are stored in a package repository (such as Maven Central for Java). Client code explicitly declare

1560-534: The libraries by other Qt-based software, since dependencies can be kept at a minimum. While KDE 4 was based on version 4 of the Qt widget toolkit, Frameworks 5 is based on version 5. As part of the KDE project's 'MegaRelease 6', on February 28, 2024, KDE Frameworks 6 was released, upgrading it to a Qt 6 base. During KDE SC 4, the then so called KDE Platform consisted of all libraries and services needed for KDE Plasma and

1612-474: The library is called a static library . An alternative is to build the program executable to be separate from the library file. The library functions are connected after the executable is started, either at load-time or runtime . In this case, the library is called a dynamic library . Most compiled languages have a standard library , although programmers can also create their own custom libraries. Most modern software systems provide libraries that implement

KHTML - Misplaced Pages Continue

1664-958: The library to exist on the same machine, but can forward the requests over the network. However, such an approach means that every library call requires a considerable amount of overhead. RPC calls are much more expensive than calling a shared library that has already been loaded on the same machine. This approach is commonly used in a distributed architecture that makes heavy use of such remote calls, notably client-server systems and application servers such as Enterprise JavaBeans . Code generation libraries are high-level APIs that can generate or transform byte code for Java . They are used by aspect-oriented programming , some data access frameworks, and for testing to generate dynamic proxy objects. They also are used to intercept field access. The system stores libfoo.a and libfoo.so files in directories such as /lib , /usr/lib or /usr/local/lib . The filenames always start with lib , and end with

1716-463: The library's required files and metadata. For example, a framework called MyFramework would be implemented in a bundle called MyFramework.framework , with MyFramework.framework/MyFramework being either the dynamically linked library file or being a symlink to the dynamically linked library file in MyFramework.framework/Versions/Current/MyFramework . Dynamic-link libraries usually have

1768-501: The majority of the system services. Such libraries have organized the services which a modern application requires. As such, most code used by modern applications is provided in these system libraries. The idea of a computer library dates back to the first computers created by Charles Babbage . An 1888 paper on his Analytical Engine suggested that computer operations could be punched on separate cards from numerical input. If these operation punch cards were saved for reuse then "by degrees

1820-609: The messenger client Banji, the Kaidan messenger, Vvave music player and the KDE software center Discover. Linux distribution use some package management system to package the software they distribute. Debian for example distributes KGlobalAccel under the package name libkf5globalaccel , while Fedora Linux distributes it under the name kf5-kglobalaccel . While being mainly written in C++, there are many bindings for other programming languages available: These and other bindings use

1872-528: The mid 1960s, copy and macro libraries for assemblers were common. Starting with the popularity of the IBM System/360 , libraries containing other types of text elements, e.g., system parameters, also became common. In IBM's OS/360 and its successors this is called a partitioned data set . The first object-oriented programming language, Simula , developed in 1965, supported adding classes to libraries via its compiler. Libraries are important in

1924-488: The modules required by a program are sometimes statically linked and copied into the executable file. This process, and the resulting stand-alone file, is known as a static build of the program. A static build may not need any further relocation if virtual memory is used and no address space layout randomization is desired. A shared library or shared object is a file that is intended to be shared by executable files and further shared object files . Modules used by

1976-472: The names and entry points of the code located within, they also require a list of the objects they depend on. This is a side-effect of one of OOP's core concepts, inheritance, which means that parts of the complete definition of any method may be in different places. This is more than simply listing that one library requires the services of another: in a true OOP system, the libraries themselves may not be known at compile time , and vary from system to system. At

2028-444: The new Konqueror file and web browser , which replaced the monolithic KDE File Manager). KSVG was first developed in 2001 by Nikolas Zimmermann and Rob Buis; however, by 2003, it was decided to fork the then-current KSVG implementation into two new projects: KDOM /KSVG2 (to improve the state of DOM rendering in KHTML underneath a more formidable SVG 1.0 render state) and Kcanvas (to abstract any rendering done within khtml/ksvg2 in

2080-546: The predecessor. Releases in the minor series (X.1, X.2, ...) will guarantee binary portability ( API & ABI ). This means, for instance, that software that was developed for KDE 3.0 will work on all (future) KDE 3 releases; however, an application developed for KDE 2 is not guaranteed to be able to make use of the KDE ;3 libraries. KDE major version numbers mainly follow the Qt release cycle, meaning that KDE SC 4

2132-430: The program linking or binding process, which resolves references known as links or symbols to library modules. The linking process is usually automatically done by a linker or binder program that searches a set of libraries and other modules in a given order. Usually it is not considered an error if a link target can be found multiple times in a given set of libraries. Linking may be done when an executable file

KHTML - Misplaced Pages Continue

2184-404: The program. A library can be used by multiple, independent consumers (programs and other libraries). This differs from resources defined in a program which can usually only be used by that program. When a consumer uses a library resource, it gains the value of the library without having to implement it itself. Libraries encourage code reuse in a modular fashion. When writing code that uses

2236-471: The raster graphics editor of the Calligra Suite , which was released on May 31, 2016, depends on KDE Frameworks 5 and Qt 5.2. With Kirigami, there is also increased usage by applications such as Amarok , Avogadro , Trojitá or Subsurface . Library (computing) In computer science , a library is a collection of resources that is leveraged during software development to implement

2288-424: The rough OOP equivalent of older types of code libraries. They contain classes , which describe characteristics and define actions ( methods ) that involve objects. Class libraries are used to create instances , or objects with their characteristics set to specific values. In some OOP languages, like Java , the distinction is clear, with the classes often contained in library files (like Java's JAR file format ) and

2340-424: The same time many developers worked on the idea of multi-tier programs, in which a "display" running on a desktop computer would use the services of a mainframe or minicomputer for data storage or processing. For instance, a program on a GUI-based computer would send messages to a minicomputer to return small samples of a huge dataset for display. Remote procedure calls (RPC) already handled these tasks, but there

2392-411: The services such as querying information about persons and contents. Further documentation: to specify information in "data units"; i.e., the natural units of the data being plotted. KPlotWidget automatically converts everything to screen pixel units. KPlotWidget draws X and Y axes with tick marks and tick labels. It automatically determines how many tick marks to use and where they should be, based on

2444-539: The split of the KDE Software Compilation into KDE Frameworks 5, KDE Plasma 5 and KDE Applications , each sub-project can pick its own development pace. KDE Frameworks are released on a monthly basis and use Git . It should be possible to install KDE Frameworks alongside the KDE Platform 4 so apps can use either one. Platform releases are those which begin a series (version number X.0). Only these major releases are allowed to break binary compatibility with

2496-528: The status of the "next big thing" in the programming world. There were a number of efforts to create systems that would run across platforms, and companies competed to try to get developers locked into their own system. Examples include IBM 's System Object Model (SOM/DSOM), Sun Microsystems ' Distributed Objects Everywhere (DOE), NeXT 's Portable Distributed Objects (PDO), Digital 's ObjectBroker , Microsoft's Component Object Model (COM/DCOM), and any number of CORBA -based systems. Class libraries are

2548-521: The subroutine library for this computer. Programs for EDSAC consisted of a main program and a sequence of subroutines copied from the subroutine library. In 1951 the team published the first textbook on programming, The Preparation of Programs for an Electronic Digital Computer , which detailed the creation and the purpose of the library. COBOL included "primitive capabilities for a library system" in 1959, but Jean Sammet described them as "inadequate library facilities" in retrospect. JOVIAL has

2600-475: The suffix *.DLL , although other file name extensions may identify specific-purpose dynamically linked libraries, e.g. *.OCX for OLE libraries. The interface revisions are either encoded in the file names, or abstracted away using COM-object interfaces. Depending on how they are compiled, *.LIB files can be either static libraries or representations of dynamically linkable libraries needed only during compilation, known as " import libraries ". Unlike in

2652-451: The work of creating that early version of KHTML. The real work on KHTML actually started between May and October 1999, with the realization that the choice facing the project was "either do a significant effort to move KHTML forward or to use Mozilla " and with adding support for JavaScript as the highest priority. So in May 1999, Lars Knoll began doing research with an eye toward implementing

SECTION 50

#1732781051811

2704-467: Was no standard RPC system. Soon the majority of the minicomputer and mainframe vendors instigated projects to combine the two, producing an OOP library format that could be used anywhere. Such systems were known as object libraries , or distributed objects , if they supported remote access (not all did). Microsoft's COM is an example of such a system for local use. DCOM, a modified version of COM, supports remote access. For some time object libraries held

#810189