file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
examples/variouslayouts.cpp | C++ | #include "variouslayouts.h"
#include "ui_variouslayouts.h"
#include "uisupport_variouslayouts.h"
VariousLayouts::VariousLayouts(QWidget *parent)
: QWidget(parent),
ui_(std::make_unique<Ui::VariousLayouts>()),
uiSupport_(std::make_unique<UiSupport::VariousLayouts>(this, ui_.get()))
{
ui_->setupUi(th... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
examples/variouslayouts.h | C/C++ Header | #pragma once
#include <QWidget>
#include <memory>
namespace Ui {
class VariousLayouts;
}
namespace UiSupport {
class VariousLayouts;
}
class VariousLayouts : public QWidget
{
Q_OBJECT
public:
explicit VariousLayouts(QWidget *parent = nullptr);
~VariousLayouts() override;
private:
std::unique_ptr<U... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/color.rs | Rust | //! Qt color type and parser.
use once_cell::sync::Lazy;
use std::collections::HashMap;
use std::str::FromStr;
use thiserror::Error;
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum Color {
Rgb8(ColorRgb8),
Rgba8(ColorRgba8),
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pu... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/diagnostic.rs | Rust | //! Utility for error reporting.
use crate::qmlast::ParseError;
use camino::{Utf8Path, Utf8PathBuf};
use std::ops::Range;
use std::slice;
/// Type (or level) of diagnostic message.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DiagnosticKind {
Error,
Warning,
}
/// Diagnostic m... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/lib.rs | Rust | #![forbid(unsafe_code)]
pub mod color;
pub mod diagnostic;
pub mod metatype;
pub mod metatype_tweak;
pub mod objtree;
pub mod opcode;
pub mod qmlast;
pub mod qmldir;
pub mod qmldoc;
pub mod qtname;
pub mod tir;
pub mod typedexpr;
pub mod typemap;
pub mod typeutil;
pub mod uigen;
| yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/metatype.rs | Rust | //! Qt metatypes.json data types.
use serde::{Deserialize, Serialize};
// TODO: Symbols are stored as owned strings, but we'll eventually want to intern them,
// where we can probably remove these temporary owned strings at all.
/// C++ access specifier.
#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq,... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/metatype_tweak.rs | Rust | //! Modifications on Qt metatypes data.
use crate::metatype::{Class, ClassInfo, Enum, Method, Property, SuperClassSpecifier};
/// Applies all modifications on the given `classes` data.
pub fn apply_all(classes: &mut Vec<Class>) {
fix_classes(classes);
classes.extend(internal_core_classes());
classes.exten... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/objtree.rs | Rust | //! Tree of QML objects.
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::qmlast::{Node, UiObjectDefinition};
use crate::qtname::{self, UniqueNameGenerator};
use crate::typemap::{Class, NamedType, TypeSpace};
use std::collections::HashMap;
use std::mem;
/// Tree of object definitions and the corresponding... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/opcode.rs | Rust | //! Function and operator constants.
use crate::qmlast::{BinaryOperator, UnaryOperator};
use std::fmt;
/// Builtin functions.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum BuiltinFunctionKind {
/// `console.log()`, `.debug()`, `.info()`, `.warn()`, `.error()`
ConsoleLog(ConsoleLogLevel),
///... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/astutil.rs | Rust | //! Utility for AST parsing and building.
use super::{ParseError, ParseErrorKind};
use tree_sitter::{Node, TreeCursor};
pub(super) fn get_child_by_field_name<'tree>(
node: Node<'tree>,
name: &'static str,
) -> Result<Node<'tree>, ParseError<'tree>> {
node.child_by_field_name(name)
.ok_or_else(|| P... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/expr.rs | Rust | use super::astutil::{self, Number};
use super::node::{ExpressionNode, StatementNode};
use super::term::{self, Identifier, NestedIdentifier};
use super::{ParseError, ParseErrorKind};
use std::fmt;
use tree_sitter::{Node, TreeCursor};
/// Tagged union that wraps an expression.
#[derive(Clone, Debug)]
pub enum Expression... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/mod.rs | Rust | //! QML parser interface and document model.
use std::error::Error;
use std::fmt;
use std::ops::Range;
mod astutil;
mod expr;
mod node;
mod object;
mod stmt;
mod term;
pub use self::expr::*; // re-export
pub use self::node::*; // re-export
pub use self::object::*; // re-export
pub use self::stmt::*; // re-export
pub... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/node.rs | Rust | //! Newtype for Node.
use super::expr::Expression;
use super::stmt::Statement;
use super::ParseError;
use std::ops::Range;
use tree_sitter::{Node, TreeCursor};
/// CST node that represents an [`Expression`](Expression).
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct ExpressionNode<'tree>(pub(super) Nod... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/object.rs | Rust | use super::astutil;
use super::node::StatementNode;
use super::stmt::Statement;
use super::term::{Identifier, NestedIdentifier};
use super::{ParseError, ParseErrorKind};
use std::collections::HashMap;
use tree_sitter::{Node, TreeCursor};
/// Represents a top-level QML program.
#[derive(Clone, Debug)]
pub struct UiProg... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/stmt.rs | Rust | use super::astutil;
use super::node::{ExpressionNode, StatementNode};
use super::term::{self, Identifier, NestedIdentifier};
use super::{ParseError, ParseErrorKind};
use tree_sitter::{Node, TreeCursor};
/// Variant for statements.
#[derive(Clone, Debug)]
pub enum Statement<'tree> {
/// Expression node.
Express... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmlast/term.rs | Rust | use super::astutil;
use super::{ParseError, ParseErrorKind};
use std::borrow::Cow;
use tree_sitter::{Node, TreeCursor};
/// Represents a primitive identifier.
#[derive(Clone, Copy, Debug)]
pub struct Identifier<'tree>(Node<'tree>);
impl<'tree> Identifier<'tree> {
pub fn from_node(node: Node<'tree>) -> Result<Self... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmldir.rs | Rust | //! QML module/directory handling.
use crate::diagnostic::{Diagnostic, Diagnostics, ProjectDiagnostics};
use crate::qmlast::{UiImportSource, UiObjectDefinition, UiProgram};
use crate::qmldoc::{UiDocument, UiDocumentsCache};
use crate::typemap::{ModuleData, ModuleId, ModuleIdBuf, QmlComponentData, TypeMap};
use camino:... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qmldoc.rs | Rust | //! QML source document management.
use camino::{Utf8Path, Utf8PathBuf};
use std::collections::{HashMap, VecDeque};
use std::error::Error;
use std::fmt;
use std::fs;
use std::io;
use std::ops::Range;
use tree_sitter::{Language, Node, Parser, Tree};
/// Object holding QML source text and parsed tree.
#[derive(Clone, D... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/qtname.rs | Rust | //! Utility for Qt naming convention.
use std::collections::HashMap;
/// File naming rules.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct FileNameRules {
pub cxx_header_suffix: String,
pub lowercase: bool,
}
impl FileNameRules {
pub fn type_name_to_cxx_header_name<S>(&self, type_name: S) -> String
... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/builder.rs | Rust | use super::ceval;
use super::core::{
BasicBlock, BasicBlockRef, CodeBody, Constant, ConstantValue, EnumVariant, Local, LocalRef,
NamedObject, Operand, Rvalue, Statement, Terminator, Void,
};
use crate::diagnostic::Diagnostics;
use crate::opcode::{BinaryArithOp, BinaryLogicalOp, BinaryOp, BuiltinFunctionKind, Un... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/ceval.rs | Rust | //! Utility to evaluate constant expression.
//!
//! This is not for optimization. We don't want to allocate local variable without
//! concrete integer/string type. And we do want to concatenate string literals to
//! support translation.
use super::core::ConstantValue;
use crate::opcode::{
BinaryArithOp, BinaryB... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/core.rs | Rust | //! Type-checked intermediate representation of expressions.
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::opcode::{BinaryOp, BuiltinFunctionKind, UnaryOp};
use crate::typedexpr::{DescribeType, TypeDesc};
use crate::typemap::{Class, Enum, Method, NamedType, Property, TypeKind};
use crate::typeutil::{sel... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/dump.rs | Rust | use super::core::{
BasicBlock, CodeBody, ConstantValue, Local, NamedObjectRef, Operand, Rvalue, Statement,
Terminator,
};
use crate::typedexpr::DescribeType;
use crate::typemap::Method;
use itertools::Itertools as _;
use std::io;
/// Prints `CodeBody` in human-readable format.
pub fn dump_code_body<W: io::Writ... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/interpret.rs | Rust | //! Minimal TIR interpreter designed for .ui generation pass.
use super::{BasicBlockRef, CodeBody, ConstantValue, Operand, Rvalue, Statement, Terminator};
use crate::opcode::{BinaryBitwiseOp, BinaryOp, BuiltinFunctionKind};
use crate::typemap::TypeSpace;
#[derive(Clone, Debug, PartialEq)]
pub enum EvaluatedValue {
... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/mod.rs | Rust | //! Type-checked intermediate representation of expressions.
// FIXME: Result<_, ExpressionError>: the `Err`-variant returned from this
// function is very large
#![allow(clippy::result_large_err)]
mod builder;
mod ceval;
mod core;
mod dump;
pub mod interpret;
mod propdep;
pub use self::builder::{build, build_callba... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/tir/propdep.rs | Rust | use super::core::{CodeBody, NamedObjectRef, Operand, Rvalue, Statement};
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::typedexpr::DescribeType as _;
/// Analyzes TIR code to collect object/property dependencies and insert observe statements.
pub fn analyze_code_property_dependency(code: &mut CodeBody<'_... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typedexpr.rs | Rust | //! Expression tree visitor with type information.
// FIXME: Result<_, ExpressionError>: the `Err`-variant returned from this
// function is very large
#![allow(clippy::result_large_err)]
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::opcode::{
BinaryLogicalOp, BinaryOp, BuiltinFunctionKind, Builtin... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/class.rs | Rust | use super::core::{TypeMapError, TypeSpace};
use super::enum_::Enum;
use super::function::{Method, MethodDataTable, MethodKind, MethodMatches};
use super::namespace::NamespaceData;
use super::util::{self, TypeDataRef};
use super::{NamedType, ParentSpace, TypeKind};
use crate::metatype;
use crate::qtname;
use std::collec... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/core.rs | Rust | use super::enum_::Enum;
use super::module::ModuleIdBuf;
use super::{NamedType, ParentSpace};
use itertools::Itertools as _;
use std::borrow::Cow;
use std::iter::FusedIterator;
use thiserror::Error;
/// Interface to look up type by name.
pub trait TypeSpace<'a> {
/// Name of this type.
fn name(&self) -> &str;
... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/enum_.rs | Rust | use super::core::{TypeMapError, TypeSpace};
use super::util::TypeDataRef;
use super::{NamedType, ParentSpace};
use crate::metatype;
use std::collections::HashSet;
/// Enum representation.
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
pub struct Enum<'a> {
data: TypeDataRef<'a, EnumData>,
parent_space: ParentSpa... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/function.rs | Rust | use super::class::Class;
use super::core::{TypeMapError, TypeSpace as _};
use super::util::{self, TypeDataRef};
use super::TypeKind;
use crate::metatype;
use std::slice;
use std::vec;
/// Stored method table wrapper to help name-based lookup.
#[derive(Clone, Debug, Default)]
pub(super) struct MethodDataTable {
met... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/mod.rs | Rust | //! Manages types loaded from Qt metatypes.json.
use camino::Utf8PathBuf;
use std::borrow::Cow;
use std::collections::HashMap;
use std::fmt;
use std::mem;
mod class;
mod core;
mod enum_;
mod function;
mod module;
mod namespace;
mod primitive;
mod qml_component;
mod util;
pub use self::class::*; // re-export
pub use ... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/module.rs | Rust | use super::core::{TypeMapError, TypeSpace};
use super::enum_::Enum;
use super::namespace::{Namespace, NamespaceData};
use super::util::{TypeDataRef, TypeMapRef};
use super::QmlComponentData;
use super::{NamedType, ParentSpace, TypeMap};
use crate::metatype;
use camino::{Utf8Path, Utf8PathBuf};
/// Top-level module ide... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/namespace.rs | Rust | use super::class::{Class, ClassData};
use super::core::{TypeMapError, TypeSpace};
use super::enum_::{Enum, EnumData};
use super::qml_component::{QmlComponent, QmlComponentData};
use super::util::{TypeDataRef, TypeMapRef};
use super::{NamedType, ParentSpace, PrimitiveType};
use crate::metatype;
use std::collections::Has... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/primitive.rs | Rust | use super::class::{Class, ClassData};
use super::namespace::{Namespace, NamespaceData};
use super::util::TypeDataRef;
use super::ParentSpace;
use crate::metatype;
use once_cell::sync::Lazy;
/// Value types provided by C++ language and Qt runtime.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum PrimitiveTyp... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/qml_component.rs | Rust | use super::class::{Class, ClassData};
use super::module::{ImportedModuleSpace, ModuleId, ModuleIdBuf};
use super::util::{TypeDataRef, TypeMapRef};
use super::ParentSpace;
/// QML component representation.
///
/// A QML component is basically a class inside an anonymous namespace, and this type itself
/// isn't a [`Typ... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typemap/util.rs | Rust | use super::core::TypeMapError;
use super::{NamedType, TypeKind, TypeMap};
use std::fmt;
use std::hash::{Hash, Hasher};
use std::ptr;
/// Thin wrapper around reference to TypeMap data.
///
/// Two type objects should be considered equal if both borrow the identical data.
///
/// This does not implement Deref nor AsRef ... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/typeutil.rs | Rust | use crate::diagnostic::Diagnostic;
use crate::typedexpr::TypeDesc;
use crate::typemap::{Enum, NamedType, TypeKind, TypeMapError, TypeSpace as _};
use std::ops::Range;
use thiserror::Error;
#[derive(Clone, Debug, Error)]
pub enum TypeError<'a> {
#[error("type resolution failed: {0}")]
TypeResolution(#[from] Typ... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/binding.rs | Rust | use super::expr;
use super::objcode::{CallbackCode, ObjectCodeMap, PropertyCode, PropertyCodeKind};
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::objtree::{ObjectNode, ObjectTree};
use crate::opcode::{BuiltinFunctionKind, ConsoleLogLevel};
use crate::qtname::{self, FileNameRules, UniqueNameGenerator};
us... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/context.rs | Rust | use super::objcode::ObjectCodeMap;
use crate::objtree::{ObjectNode, ObjectTree};
use crate::qmldoc::UiDocument;
use crate::qtname::FileNameRules;
use crate::typedexpr::{RefKind, RefSpace, TypeAnnotationSpace};
use crate::typemap::{
Class, Enum, ImportedModuleSpace, ModuleId, NamedType, TypeKind, TypeMap, TypeMapErr... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/expr.rs | Rust | use super::context::ObjectContext;
use super::gadget::{Gadget, GadgetKind, ModelItem, PaletteColorGroup};
use super::objcode::{PropertyCode, PropertyCodeKind};
use super::xmlutil;
use super::XmlWriter;
use crate::color::Color;
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::qmlast::Node;
use crate::tir;
us... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/form.rs | Rust | use super::context::BuildDocContext;
use super::object::Widget;
use super::xmlutil;
use super::XmlWriter;
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::objtree::ObjectNode;
use crate::qtname::FileNameRules;
use crate::typemap::{Class, TypeSpace};
use itertools::Itertools as _;
use quick_xml::events::{Byt... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/gadget.rs | Rust | use super::context::{KnownClasses, ObjectContext};
use super::expr::{self, SerializableValue, SimpleValue};
use super::objcode::PropertyCode;
use super::property;
use super::xmlutil;
use super::XmlWriter;
use crate::color::Color;
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::qtname;
use crate::tir::inter... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/layout.rs | Rust | use super::context::{BuildDocContext, ObjectContext};
use super::expr::SerializableValue;
use super::objcode::PropertyCode;
use super::object::{self, Widget};
use super::property::{self, PropertySetter};
use super::XmlWriter;
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::objtree::ObjectNode;
use crate::t... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/mod.rs | Rust | //! Qt user interface XML (.ui) generator.
use self::objcode::ObjectCodeMap;
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::objtree::ObjectTree;
use crate::qmlast::{UiImportSource, UiProgram};
use crate::qmldir;
use crate::qmldoc::UiDocument;
use crate::typemap::{ImportedModuleSpace, ModuleId, ModuleIdBu... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/objcode.rs | Rust | //! Code storage for UI object.
use super::context::ObjectContext;
use crate::diagnostic::{Diagnostic, Diagnostics};
use crate::objtree::ObjectNode;
use crate::qmlast::{Node, UiBindingMap, UiBindingValue};
use crate::qtname;
use crate::tir::interpret::EvaluatedValue;
use crate::tir::{self, CodeBody};
use crate::typema... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/object.rs | Rust | use super::context::{BuildDocContext, ObjectContext};
use super::expr::{self, SerializableValue};
use super::gadget::ModelItem;
use super::layout::Layout;
use super::objcode::{PropertyCode, PropertyCodeKind};
use super::property::{self, PropertySetter};
use super::XmlWriter;
use crate::diagnostic::{Diagnostic, Diagnost... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/property.rs | Rust | use super::context::ObjectContext;
use super::expr::{SerializableValue, SimpleValue};
use super::objcode::PropertyCode;
use super::XmlWriter;
use crate::diagnostic::{Diagnostic, Diagnostics};
use itertools::Itertools as _;
use quick_xml::events::{BytesStart, Event};
use std::collections::HashMap;
use std::fmt::Debug;
u... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/src/uigen/xmlutil.rs | Rust | //! Utility for UI XML generation.
use super::XmlWriter;
use quick_xml::events::{BytesStart, BytesText, Event};
use std::io;
pub(super) fn write_tagged_str<W, S, T>(
writer: &mut XmlWriter<W>,
tag: T,
content: S,
) -> io::Result<()>
where
W: io::Write,
S: AsRef<str>,
T: AsRef<str>,
{
let t... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/tests/test_tir_build.rs | Rust | use self::tir_testenv::*;
pub mod tir_testenv;
#[test]
fn float_literal_zeros() {
insta::assert_snapshot!(dump("+0.0"), @r###"
.0:
return 0.0: double
"###);
insta::assert_snapshot!(dump("-0.0"), @r###"
.0:
return -0.0: double
"###);
insta::assert_snapshot!(dump("+0.0 === -0... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/tests/test_tir_interpreter.rs | Rust | use self::tir_testenv::*;
use qmluic::tir;
use qmluic::tir::interpret::{EvaluatedValue, StringKind};
pub mod tir_testenv;
fn try_eval(expr_source: &str) -> Option<EvaluatedValue> {
let env = Env::new();
let code = env.build(expr_source);
tir::evaluate_code(&code)
}
fn eval(expr_source: &str) -> Evaluated... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/tests/test_tir_property_analysis.rs | Rust | use self::tir_testenv::*;
use qmluic::diagnostic::Diagnostics;
use qmluic::tir::{self, CodeBody};
pub mod tir_testenv;
fn analyze_code(code: &mut CodeBody) {
let mut diagnostics = Diagnostics::new();
tir::analyze_code_property_dependency(code, &mut diagnostics);
assert!(!diagnostics.has_error());
}
#[tes... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
lib/tests/tir_testenv/mod.rs | Rust | //! Environment and utility for TIR tests.
use qmluic::diagnostic::Diagnostics;
use qmluic::metatype;
use qmluic::qmlast::{StatementNode, UiObjectDefinition, UiProgram};
use qmluic::qmldoc::UiDocument;
use qmluic::tir::{self, CodeBody};
use qmluic::typedexpr::{RefKind, RefSpace, TypeAnnotationSpace};
use qmluic::typem... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
src/lib.rs | Rust | #![forbid(unsafe_code)]
mod qtpaths;
pub mod reporting;
mod uiviewer;
pub use qtpaths::{QtPaths, QtVersion};
pub use uiviewer::UiViewer;
| yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
src/main.rs | Rust | #![forbid(unsafe_code)]
use anyhow::{anyhow, Context as _};
use camino::{Utf8Component, Utf8Path, Utf8PathBuf};
use clap::{Args, Parser, Subcommand};
use notify::{RecursiveMode, Watcher as _};
use once_cell::sync::OnceCell;
use qmluic::diagnostic::{Diagnostics, ProjectDiagnostics};
use qmluic::metatype;
use qmluic::me... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
src/qtpaths.rs | Rust | use camino::Utf8PathBuf;
use std::ffi::OsStr;
use std::fmt;
use std::io;
use std::process::Command;
use std::str;
use thiserror::Error;
/// Information about Qt installation.
#[derive(Clone, Debug, Default)]
pub struct QtPaths {
pub sysroot: Option<Utf8PathBuf>,
pub install_prefix: Option<Utf8PathBuf>,
pub... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
src/reporting.rs | Rust | use camino::{Utf8Path, Utf8PathBuf};
use codespan_reporting::diagnostic::{Label, LabelStyle, Severity};
use codespan_reporting::files::SimpleFile;
use codespan_reporting::term;
use qmluic::diagnostic::{DiagnosticKind, Diagnostics};
use qmluic::qmldoc::{SyntaxError, SyntaxErrorKind, UiDocument};
use std::borrow::Cow;
us... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
src/uiviewer.rs | Rust | use anyhow::Context as _;
use std::env;
use std::ffi::OsStr;
use std::io::{self, Read as _, Write as _};
use std::process::{Child, ChildStdin, ChildStdout, Command, ExitStatus, Stdio};
/// Interface to UI viewer process.
#[derive(Debug)]
pub struct UiViewer {
child: Child,
stdin: ChildStdin,
stdout: ChildS... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/common/mod.rs | Rust | use assert_cmd::Command;
use camino::Utf8Path;
use codespan_reporting::files::SimpleFile;
use codespan_reporting::term;
use qmluic::diagnostic::{Diagnostics, ProjectDiagnostics};
use qmluic::metatype;
use qmluic::metatype_tweak;
use qmluic::qmldir;
use qmluic::qmldoc::{UiDocument, UiDocumentsCache};
use qmluic::qtname:... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_generate_ui_command.rs | Rust | use self::common::TestEnv;
use std::str;
pub mod common;
#[test]
fn test_simple_file() {
let env = TestEnv::prepare();
env.write_dedent(
"Simple.qml",
r###"
import qmluic.QtWidgets
QDialog {}
"###,
);
let a = env
.generate_ui_cmd(["--no-dynamic-binding"... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_uigen_attached_property.rs | Rust | pub mod common;
#[test]
fn test_unknown_attached_type() {
insta::assert_snapshot!(common::translate_str(r###"
import qmluic.QtWidgets
QWidget {
Whatever.property: 1
}
"###).unwrap_err(), @r###"
error: unknown attaching type: Whatever
┌─ <unknown>:3:5
│
3 │ Whatever.p... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_uigen_examples.rs | Rust | pub mod common;
#[test]
fn test_binding_loop() {
let (ui_xml, ui_support_h) = common::translate_file("examples/BindingLoop.qml").unwrap();
insta::assert_snapshot!(ui_xml);
insta::assert_snapshot!(ui_support_h);
}
#[test]
fn test_hg_email_dialog() {
let (ui_xml, ui_support_h) = common::translate_file("... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_uigen_gadget.rs | Rust | use qmluic::uigen::DynamicBindingHandling;
pub mod common;
#[test]
fn test_brush() {
insta::assert_snapshot!(common::translate_str(r###"
import qmluic.QtWidgets
QGraphicsView {
backgroundBrush.color: "#123abc"
backgroundBrush.style: Qt.Dense4Pattern
}
"###).unwrap(), @r###"
<ui... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_uigen_item_model.rs | Rust | pub mod common;
#[test]
fn test_string_list_as_combo_box_item() {
insta::assert_snapshot!(common::translate_str(r###"
import qmluic.QtWidgets
QComboBox { model: ["foo", qsTr("bar")] }
"###).unwrap(), @r###"
<ui version="4.0">
<class>MyType</class>
<widget class="QComboBox" name="comboBox"... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_uigen_signal_callback.rs | Rust | use qmluic::uigen::DynamicBindingHandling;
pub mod common;
#[test]
fn test_unknown_signal() {
insta::assert_snapshot!(common::translate_str(r###"
import qmluic.QtWidgets
QWidget {
onWhatever: ;
}
"###).unwrap_err(), @r###"
error: unknown signal of class 'QWidget': whatever
┌─ <un... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
tests/test_uigen_widget.rs | Rust | use qmluic::uigen::DynamicBindingHandling;
pub mod common;
#[test]
fn test_root_must_be_widget() {
insta::assert_snapshot!(common::translate_str(r###"
import qmluic.QtWidgets
QVBoxLayout {}
"###).unwrap_err(), @r###"
error: class 'QVBoxLayout' is not a QWidget
┌─ <unknown>:2:1
│
2 ... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
uiviewer/main.cpp | C++ | #include <QApplication>
#include <QBuffer>
#include <QCommandLineParser>
#include <QFile>
#include <QLoggingCategory>
#include <QUiLoader>
#include <QWidget>
#include <QtDebug>
#include <memory>
#include "pipeserver.h"
#include "uiviewerdialog.h"
namespace {
std::unique_ptr<QWidget> loadUiFile(QUiLoader &loader, const... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
uiviewer/pipeserver.cpp | C++ | #include <QFile>
#include <QtDebug>
#include <cstdint>
#include "pipeserver.h"
PipeServer::PipeServer(QObject *parent) : QThread(parent) { }
void PipeServer::run()
{
// AFAIK, QFile basically implements blocking interface.
QFile fin, fout;
if (!fin.open(0, QIODevice::ReadOnly | QIODevice::Unbuffered)) {
... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
uiviewer/pipeserver.h | C/C++ Header | #pragma once
#include <QByteArray>
#include <QThread>
/// Thread to receive data via stdio.
///
/// This is blocking thread since stdin can't be polled via QFile. The thread will
/// terminate when stdin is closed by peer.
class PipeServer : public QThread
{
Q_OBJECT
public:
explicit PipeServer(QObject *pare... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
uiviewer/uiviewerdialog.cpp | C++ | #include <QCloseEvent>
#include <QEvent>
#include <QKeyEvent>
#include <QKeySequence>
#include <QMessageBox>
#include <QMetaObject>
#include "uiviewerdialog.h"
#include "ui_uiviewerdialog.h"
UiViewerDialog::UiViewerDialog(QWidget *parent)
: QDialog(parent), ui_(std::make_unique<Ui::UiViewerDialog>())
{
ui_->se... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
uiviewer/uiviewerdialog.h | C/C++ Header | #ifndef UIVIEWERDIALOG_H
#define UIVIEWERDIALOG_H
#include <QDialog>
#include <QWidget>
#include <memory>
namespace Ui {
class UiViewerDialog;
}
class UiViewerDialog : public QDialog
{
Q_OBJECT
public:
explicit UiViewerDialog(QWidget *parent = nullptr);
~UiViewerDialog() override;
void setClosable(... | yuja/qmluic | 9 | QML -> QtWidgets UI/C++ transpiler | Rust | yuja | Yuya Nishihara | |
bindings/node/binding.cc | C++ | #include "tree_sitter/parser.h"
#include <node.h>
#include "nan.h"
using namespace v8;
extern "C" TSLanguage * tree_sitter_sixtyfps();
namespace {
NAN_METHOD(New) {}
void Init(Local<Object> exports, Local<Object> module) {
Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
tpl->SetClassName(Nan::Ne... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
bindings/node/index.js | JavaScript | try {
module.exports = require("../../build/Release/tree_sitter_sixtyfps_binding");
} catch (error1) {
if (error1.code !== 'MODULE_NOT_FOUND') {
throw error1;
}
try {
module.exports = require("../../build/Debug/tree_sitter_sixtyfps_binding");
} catch (error2) {
if (error2.code !== 'MODULE_NOT_FOUN... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
bindings/rust/build.rs | Rust | fn main() {
let src_dir = std::path::Path::new("src");
let mut c_config = cc::Build::new();
c_config.include(&src_dir);
c_config
.flag_if_supported("-Wno-unused-parameter")
.flag_if_supported("-Wno-unused-but-set-variable")
.flag_if_supported("-Wno-trigraphs");
let parser_p... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
bindings/rust/lib.rs | Rust | //! This crate provides SixtyFPS language support for the [tree-sitter][] parsing library.
//!
//! Typically, you will use the [language][language func] function to add this language to a
//! tree-sitter [Parser][], and then use the parser to parse some code:
//!
//! ```
//! let code = "";
//! let mut parser = tree_sit... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
contrib/lsp-sixtyfps.el | Emacs Lisp | ;;; lsp-sityfps.el --- LSP client for SixtyFPS UI -*- lexical-binding: t; -*-
;; Author: Yuya Nishihara <yuya@tcha.org>
;; Package-Requires: ((emacs "26.1") (lsp-mode "8.0"))
;;; Code:
(require 'lsp-mode)
(add-to-list 'lsp-language-id-configuration
'(sixtyfps-mode . "sixtyfps"))
(lsp-register-client
... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
contrib/sixtyfps-mode.el | Emacs Lisp | ;;; sityfps-mode.el --- Major mode for editing SixtyFPS UI -*- lexical-binding: t; -*-
;; Author: Yuya Nishihara <yuya@tcha.org>
;; Package-Requires: ((emacs "26.1") (tree-sitter "0.16.1") (tree-sitter-indent "0.3"))
;;; Code:
(require 'tree-sitter)
(require 'tree-sitter-hl)
(require 'tree-sitter-indent)
(defconst ... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
grammar.js | JavaScript | // Implemented based on
// https://github.com/slint-ui/slint/
// docs/langref.md
// internal/compiler/{lexer.rs,parser.rs,parser/*.rs}
// {expression_tree.rs,object_tree.rs}
// 136f2686b4e33241da8e7ab97bf27712a8d5bf56
module.exports = grammar({
name: 'sixtyfps',
externals: $ => [
$.blo... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
queries/highlights.scm | Scheme | ; Functions
(callback_declaration
name: (identifier) @function)
(callback_declaration
binding: (two_way_binding
name: (identifier) @function))
(callback_connection
name: (identifier) @function)
(callback_connection_parameters
(identifier) @variable.parameter)
; Properties
(property_declaration
... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
queries/locals.scm | Scheme | ; Scopes
; TODO: this is just a stub
[
(binding_expression)
(callback_declaration)
(callback_connection)
] @local.scope
; Definitions
(callback_connection_parameters
(identifier) @local.definition)
; References
(identifier) @local.reference
| yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
src/scanner.c | C | #include <tree_sitter/parser.h>
enum TokenType {
BLOCK_COMMENT,
};
static void advance(TSLexer *lexer)
{
lexer->advance(lexer, false);
}
static void skip(TSLexer *lexer)
{
lexer->advance(lexer, true);
}
static bool scan_block_comment(TSLexer *lexer, int depth)
{
bool pending_star = false;
while ... | yuja/tree-sitter-sixtyfps | 0 | SixtyFPS grammar for the tree-sitter parsing library | JavaScript | yuja | Yuya Nishihara | |
jdext.js | JavaScript | #!/usr/bin/env node
const fs = require('fs');
exports.extract = (jdsave, webm)=>{
const j = fs.readFileSync(jdsave);
if (j[512495]!=0 || j[512496]!=0x1A)
throw new Error('cannot find video start byte');
const v = Buffer.from(j.buffer, 512496);
fs.writeFileSync(webm, v);
};
if (module.parent)
return;
if ... | yurijmikhalevich/jdext | 6 | JustDance saved video extractor | JavaScript | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 |
autogen.py | Python | import os
import shutil
from pathlib import Path
from keras_autodoc import DocumentationGenerator
rootdir = Path(__file__).parent
docsdir = os.path.join(rootdir, "docs-src", "docs")
srcdocsdir = os.path.join(docsdir, "visionpod")
pages = {"core.PodModule.md": ["visionpod.core.module.PodModule"]}
level = ".." if os.... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/babel.config.js | JavaScript | module.exports = {
presets: [require.resolve('@docusaurus/core/lib/babel/preset')],
};
| yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/docusaurus.config.js | JavaScript | // @ts-check
// Note: type annotations allow type checking and IDEs autocompletion
const lightCodeTheme = require('prism-react-renderer/themes/github');
const darkCodeTheme = require('prism-react-renderer/themes/dracula');
/** @type {import('@docusaurus/types').Config} */
const config = {
title: 'Lightning Pod Visi... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/sidebars.js | JavaScript | /**
* Creating a sidebar enables you to:
- create an ordered group of docs
- render a sidebar for each doc of that group
- provide next/previous navigation
The sidebars can be generated from the filesystem, or explicitly defined here.
Create as many sidebars as you want.
*/
// @ts-check
/** @type {import('@d... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/src/components/HomepageFeatures/index.tsx | TypeScript (TSX) | import React from 'react';
import clsx from 'clsx';
import styles from './styles.module.css';
type FeatureItem = {
title: string;
Svg: React.ComponentType<React.ComponentProps<'svg'>>;
description: JSX.Element;
};
const FeatureList: FeatureItem[] = [
{
title: 'Easy to Use',
Svg: require('@site/static/... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/src/components/HomepageFeatures/styles.module.css | CSS | .features {
display: flex;
align-items: center;
padding: 2rem 0;
width: 100%;
}
.featureSvg {
height: 200px;
width: 200px;
}
| yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/src/css/custom.css | CSS | /**
* Any CSS included here will be global. The classic template
* bundles Infima by default. Infima is a CSS framework designed to
* work well for content-centric websites.
*/
/* You can override the default Infima variables here. */
:root {
--ifm-color-primary: #2e8555;
--ifm-color-primary-dark: #29784c;
-... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/src/pages/index.module.css | CSS | /**
* CSS files with the .module.css suffix will be treated as CSS modules
* and scoped locally.
*/
.heroBanner {
padding: 4rem 0;
text-align: center;
position: relative;
overflow: hidden;
}
@media screen and (max-width: 996px) {
.heroBanner {
padding: 2rem;
}
}
.buttons {
display: flex;
align... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
docs-src/src/pages/index.tsx | TypeScript (TSX) | import React from 'react';
import clsx from 'clsx';
import Link from '@docusaurus/Link';
import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
import Layout from '@theme/Layout';
import HomepageFeatures from '@site/src/components/HomepageFeatures';
import styles from './index.module.css';
function Home... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
lightning-app/app.py | Python | # Copyright Justin R. Goheen.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/next.config.js | JavaScript | /** @type {import('next').NextConfig} */
const nextConfig = {
reactStrictMode: true,
eslint: {
ignoreDuringBuilds: true,
}
};
module.exports = nextConfig;
| yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/graphs/imageGrid.tsx | TypeScript (TSX) | import { Container, Grid, Box, Typography } from "@mui/material";
export const ImageGrid = (props: any) => (
<Container>
<Grid container spacing={4}>
<Grid item>
<Box
sx={{
width: 300,
height: 300,
backgroundColor: "primary.light",
}}
... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/mainPage/navBar.tsx | TypeScript (TSX) | import * as React from "react";
import AppBar from "@mui/material/AppBar";
import Box from "@mui/material/Box";
import Toolbar from "@mui/material/Toolbar";
import Typography from "@mui/material/Typography";
export default function NavBar() {
return (
<Box sx={{ flexGrow: 1 }}>
<AppBar position="static" co... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/metrics/metricFour.tsx | TypeScript (TSX) | import { Card, CardContent, Grid, Typography } from "@mui/material";
export const MetricFour = (props: any) => (
<Card {...props}>
<CardContent>
<Grid container spacing={3}>
<Grid item>
<Typography variant="h5">Metric Name</Typography>
<Typography>0.xx</Typography>
</Gri... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/metrics/metricOne.tsx | TypeScript (TSX) | import { Card, CardContent, Grid, Typography } from "@mui/material";
export const MetricOne = (props: any) => (
<Card {...props}>
<CardContent>
<Grid container spacing={3}>
<Grid item>
<Typography variant="h5">Metric Name</Typography>
<Typography>0.xx</Typography>
</Grid... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/metrics/metricThree.tsx | TypeScript (TSX) | import { Card, CardContent, Grid, Typography } from "@mui/material";
export const MetricThree = (props: any) => (
<Card {...props}>
<CardContent>
<Grid container spacing={3}>
<Grid item>
<Typography variant="h5">Metric Name</Typography>
<Typography>0.xx</Typography>
</Gr... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/metrics/metricTwo.tsx | TypeScript (TSX) | import { Card, CardContent, Grid, Typography } from "@mui/material";
export const MetricTwo = (props: any) => (
<Card {...props}>
<CardContent>
<Grid container spacing={3}>
<Grid item>
<Typography variant="h5">Metric Name</Typography>
<Typography>0.xx</Typography>
</Grid... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 | |
next-app/src/components/metrics/metricsGrid.tsx | TypeScript (TSX) | import { Container, Grid } from "@mui/material";
import { MetricOne } from "./metricOne";
import { MetricTwo } from "./metricTwo";
import { MetricThree } from "./metricThree";
import { MetricFour } from "./metricFour";
export const MetricsGrid = () => (
<Grid container spacing={3} direction={"row"}>
<Grid item ... | yurijmikhalevich/lightning-pod-vision | 0 | An End to End ML Product Example | yurijmikhalevich | Yurij Mikhalevich | Makes magic at QAWolf 🐺 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.